@deepagents/text2sql 7.1.1 → 7.1.3

package/dist/index.js

@@ -1545,6 +1545,7 @@ function hashConfig(config) {
 }
 
 // packages/text2sql/src/lib/fs/sqlite/sqlite-fs.ts
+import { transaction } from "@zukhruf/sqlite-transaction";
 import * as path2 from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import z6 from "zod";
@@ -1583,7 +1584,7 @@ var chunkRow = z6.object({
 var dataRow = chunkRow.pick({ data: true });
 var SqliteFs = class {
   #db;
-  #statements = /* @__PURE__ */ new Map();
+  #sql;
   #chunkSize;
   #root;
   constructor(options) {
@@ -1592,25 +1593,18 @@ var SqliteFs = class {
     this.#root = normalizedRoot === "/" ? "" : normalizedRoot;
     this.#db = new DatabaseSync(options.dbPath);
     this.#db.exec(ddl_sqlite_fs_default);
-    const rootSlashExists = this.#stmt(
-      "SELECT 1 FROM fs_entries WHERE path = ?"
-    ).get("/");
+    this.#sql = this.#db.createTagStore();
+    const rootSlashExists = this.#sql.get`SELECT 1 FROM fs_entries WHERE path = '/'`;
     if (!rootSlashExists) {
-      this.#stmt(
-        `INSERT INTO fs_entries (path, type, mode, size, mtime)
-         VALUES ('/', 'directory', 493, 0, ?)`
-      ).run(Date.now());
+      this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime)
+         VALUES ('/', 'directory', 493, 0, ${Date.now()})`;
     }
     if (this.#root) {
       this.#createParentDirs(this.#root);
-      const rootExists = this.#stmt(
-        "SELECT 1 FROM fs_entries WHERE path = ?"
-      ).get(this.#root);
+      const rootExists = this.#sql.get`SELECT 1 FROM fs_entries WHERE path = ${this.#root}`;
       if (!rootExists) {
-        this.#stmt(
-          `INSERT INTO fs_entries (path, type, mode, size, mtime)
-           VALUES (?, 'directory', 493, 0, ?)`
-        ).run(this.#root, Date.now());
+        this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime)
+           VALUES (${this.#root}, 'directory', 493, 0, ${Date.now()})`;
       }
     }
   }
@@ -1623,25 +1617,13 @@ var SqliteFs = class {
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
       currentPath = path2.posix.join(currentPath, segments[i]);
-      const exists = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
-        currentPath
-      );
+      const exists = this.#sql.get`SELECT 1 FROM fs_entries WHERE path = ${currentPath}`;
       if (!exists) {
-        this.#stmt(
-          `INSERT INTO fs_entries (path, type, mode, size, mtime)
-           VALUES (?, 'directory', 493, 0, ?)`
-        ).run(currentPath, Date.now());
+        this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime)
+           VALUES (${currentPath}, 'directory', 493, 0, ${Date.now()})`;
       }
     }
   }
-  #stmt(sql) {
-    let stmt = this.#statements.get(sql);
-    if (!stmt) {
-      stmt = this.#db.prepare(sql);
-      this.#statements.set(sql, stmt);
-    }
-    return stmt;
-  }
   #normalizeRoot(root) {
     return path2.posix.resolve("/", root.trim());
   }
@@ -1666,20 +1648,6 @@ var SqliteFs = class {
     }
     return p;
   }
-  #useTransaction(fn) {
-    this.#db.exec("BEGIN TRANSACTION");
-    try {
-      const result = fn();
-      this.#db.exec("COMMIT");
-      return result;
-    } catch (error) {
-      try {
-        this.#db.exec("ROLLBACK");
-      } catch {
-      }
-      throw error;
-    }
-  }
   #normalizePath(p) {
     return path2.posix.resolve("/", p);
   }
@@ -1691,43 +1659,33 @@ var SqliteFs = class {
     const parent = this.#dirname(filePath);
     const rootPath = this.#root || "/";
     if (parent === rootPath || parent === "/") return;
-    const entry = typeRow.optional().parse(
-      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(parent)
-    );
+    const entry = typeRow.optional().parse(this.#sql.get`SELECT type FROM fs_entries WHERE path = ${parent}`);
     if (!entry) {
       this.#ensureParentExists(parent);
-      this.#stmt(
-        `INSERT INTO fs_entries (path, type, mode, size, mtime)
-         VALUES (?, 'directory', 493, 0, ?)`
-      ).run(parent, Date.now());
+      this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime)
+         VALUES (${parent}, 'directory', 493, 0, ${Date.now()})`;
     } else if (entry.type !== "directory") {
       throw new Error(`mkdir: parent is not a directory: ${parent}`);
     }
   }
   #writeChunks(filePath, content) {
-    this.#stmt("DELETE FROM fs_chunks WHERE path = ?").run(filePath);
+    this.#sql.run`DELETE FROM fs_chunks WHERE path = ${filePath}`;
     for (let i = 0; i < content.length; i += this.#chunkSize) {
       const chunk = content.slice(
         i,
         Math.min(i + this.#chunkSize, content.length)
       );
-      this.#stmt(
-        "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
-      ).run(filePath, Math.floor(i / this.#chunkSize), chunk);
+      this.#sql.run`INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (${filePath}, ${Math.floor(i / this.#chunkSize)}, ${chunk})`;
     }
   }
   #chunks(filePath) {
     return z6.array(chunkRow).parse(
-      this.#stmt("SELECT chunkIndex, data FROM fs_chunks WHERE path = ?").all(
-        filePath
-      )
+      this.#sql.all`SELECT chunkIndex, data FROM fs_chunks WHERE path = ${filePath}`
     );
   }
   #readChunks(filePath) {
     const rows = z6.array(dataRow).parse(
-      this.#stmt(
-        "SELECT data FROM fs_chunks WHERE path = ? ORDER BY chunkIndex"
-      ).all(filePath)
+      this.#sql.all`SELECT data FROM fs_chunks WHERE path = ${filePath} ORDER BY chunkIndex`
     );
     if (rows.length === 0) {
       return new Uint8Array(0);
@@ -1746,9 +1704,7 @@ var SqliteFs = class {
       throw new Error(`readFile: circular symlink: ${p}`);
     }
     const entry = linkRow.optional().parse(
-      this.#stmt(
-        "SELECT type, symlinkTarget FROM fs_entries WHERE path = ?"
-      ).get(p)
+      this.#sql.get`SELECT type, symlinkTarget FROM fs_entries WHERE path = ${p}`
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${p}`);
@@ -1776,7 +1732,7 @@ var SqliteFs = class {
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
     const entry = typeRow.optional().parse(
-      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(resolved)
+      this.#sql.get`SELECT type FROM fs_entries WHERE path = ${resolved}`
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
@@ -1793,7 +1749,7 @@ var SqliteFs = class {
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
     const entry = typeRow.optional().parse(
-      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(resolved)
+      this.#sql.get`SELECT type FROM fs_entries WHERE path = ${resolved}`
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
@@ -1808,63 +1764,61 @@ var SqliteFs = class {
     const prefixed = this.#prefixPath(normalized);
     const encoding = typeof options === "string" ? options : options?.encoding;
     const data = this.#toUint8Array(content, encoding);
-    this.#useTransaction(() => {
-      this.#ensureParentExists(prefixed);
-      this.#stmt(
-        `INSERT INTO fs_entries (path, type, mode, size, mtime)
-         VALUES (?, 'file', 420, ?, ?)
+    transaction(
+      this.#db,
+      () => {
+        this.#ensureParentExists(prefixed);
+        this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime)
+         VALUES (${prefixed}, 'file', 420, ${data.length}, ${Date.now()})
          ON CONFLICT(path) DO UPDATE SET
            type = 'file',
            size = excluded.size,
-           mtime = excluded.mtime`
-      ).run(prefixed, data.length, Date.now());
-      this.#writeChunks(prefixed, data);
-    });
+           mtime = excluded.mtime`;
+        this.#writeChunks(prefixed, data);
+      },
+      { mode: "deferred" }
+    );
   }
   async appendFile(filePath, content, options) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const encoding = typeof options === "string" ? options : options?.encoding;
     const newData = this.#toUint8Array(content, encoding);
-    this.#useTransaction(() => {
-      this.#ensureParentExists(prefixed);
-      const entry = typeRow.optional().parse(
-        this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
-          prefixed
-        )
-      );
-      if (entry && entry.type !== "file") {
-        throw new Error(`appendFile: not a file: ${filePath}`);
-      }
-      const existing = entry ? this.#readChunks(prefixed) : new Uint8Array(0);
-      const combined = new Uint8Array(existing.length + newData.length);
-      combined.set(existing, 0);
-      combined.set(newData, existing.length);
-      this.#stmt(
-        `INSERT INTO fs_entries (path, type, mode, size, mtime)
-         VALUES (?, 'file', 420, ?, ?)
+    transaction(
+      this.#db,
+      () => {
+        this.#ensureParentExists(prefixed);
+        const entry = typeRow.optional().parse(
+          this.#sql.get`SELECT type FROM fs_entries WHERE path = ${prefixed}`
+        );
+        if (entry && entry.type !== "file") {
+          throw new Error(`appendFile: not a file: ${filePath}`);
+        }
+        const existing = entry ? this.#readChunks(prefixed) : new Uint8Array(0);
+        const combined = new Uint8Array(existing.length + newData.length);
+        combined.set(existing, 0);
+        combined.set(newData, existing.length);
+        this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime)
+         VALUES (${prefixed}, 'file', 420, ${combined.length}, ${Date.now()})
          ON CONFLICT(path) DO UPDATE SET
            size = excluded.size,
-           mtime = excluded.mtime`
-      ).run(prefixed, combined.length, Date.now());
-      this.#writeChunks(prefixed, combined);
-    });
+           mtime = excluded.mtime`;
+        this.#writeChunks(prefixed, combined);
+      },
+      { mode: "deferred" }
+    );
   }
   async exists(filePath) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
-    const row = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
-      prefixed
-    );
+    const row = this.#sql.get`SELECT 1 FROM fs_entries WHERE path = ${prefixed}`;
     return row !== void 0;
   }
   async stat(filePath) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
-    const entry = entryRow.optional().parse(
-      this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(resolved)
-    );
+    const entry = entryRow.optional().parse(this.#sql.get`SELECT * FROM fs_entries WHERE path = ${resolved}`);
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -1881,9 +1835,7 @@ var SqliteFs = class {
   async lstat(filePath) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
-    const entry = entryRow.optional().parse(
-      this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(prefixed)
-    );
+    const entry = entryRow.optional().parse(this.#sql.get`SELECT * FROM fs_entries WHERE path = ${prefixed}`);
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -1900,7 +1852,7 @@ var SqliteFs = class {
     const normalized = this.#normalizePath(dirPath);
     const prefixed = this.#prefixPath(normalized);
     const existing = typeRow.optional().parse(
-      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(prefixed)
+      this.#sql.get`SELECT type FROM fs_entries WHERE path = ${prefixed}`
     );
     if (existing) {
       if (options?.recursive) {
@@ -1908,54 +1860,50 @@ var SqliteFs = class {
       }
       throw new Error(`EEXIST: file already exists: ${dirPath}`);
     }
-    this.#useTransaction(() => {
-      if (options?.recursive) {
-        const rootPath = this.#root || "/";
-        const relativePath = path2.posix.relative(rootPath, prefixed);
-        const segments = relativePath.split("/").filter(Boolean);
-        let currentPath = rootPath;
-        for (const segment of segments) {
-          currentPath = path2.posix.join(currentPath, segment);
-          const exists = typeRow.optional().parse(
-            this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
-              currentPath
-            )
+    transaction(
+      this.#db,
+      () => {
+        if (options?.recursive) {
+          const rootPath = this.#root || "/";
+          const relativePath = path2.posix.relative(rootPath, prefixed);
+          const segments = relativePath.split("/").filter(Boolean);
+          let currentPath = rootPath;
+          for (const segment of segments) {
+            currentPath = path2.posix.join(currentPath, segment);
+            const exists = typeRow.optional().parse(
+              this.#sql.get`SELECT type FROM fs_entries WHERE path = ${currentPath}`
+            );
+            if (!exists) {
+              this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime)
+               VALUES (${currentPath}, 'directory', 493, 0, ${Date.now()})`;
+            } else if (exists.type !== "directory") {
+              throw new Error(`mkdir: not a directory: ${currentPath}`);
+            }
+          }
+        } else {
+          const parent = this.#dirname(prefixed);
+          const parentEntry = typeRow.optional().parse(
+            this.#sql.get`SELECT type FROM fs_entries WHERE path = ${parent}`
           );
-          if (!exists) {
-            this.#stmt(
-              `INSERT INTO fs_entries (path, type, mode, size, mtime)
-               VALUES (?, 'directory', 493, 0, ?)`
-            ).run(currentPath, Date.now());
-          } else if (exists.type !== "directory") {
-            throw new Error(`mkdir: not a directory: ${currentPath}`);
+          if (!parentEntry) {
+            throw new Error(`mkdir: parent does not exist: ${parent}`);
           }
+          if (parentEntry.type !== "directory") {
+            throw new Error(`mkdir: parent is not a directory: ${parent}`);
+          }
+          this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime)
+           VALUES (${prefixed}, 'directory', 493, 0, ${Date.now()})`;
         }
-      } else {
-        const parent = this.#dirname(prefixed);
-        const parentEntry = typeRow.optional().parse(
-          this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
-            parent
-          )
-        );
-        if (!parentEntry) {
-          throw new Error(`mkdir: parent does not exist: ${parent}`);
-        }
-        if (parentEntry.type !== "directory") {
-          throw new Error(`mkdir: parent is not a directory: ${parent}`);
-        }
-        this.#stmt(
-          `INSERT INTO fs_entries (path, type, mode, size, mtime)
-           VALUES (?, 'directory', 493, 0, ?)`
-        ).run(prefixed, Date.now());
-      }
-    });
+      },
+      { mode: "deferred" }
+    );
   }
   async readdir(dirPath) {
     const normalized = this.#normalizePath(dirPath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
     const entry = typeRow.optional().parse(
-      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(resolved)
+      this.#sql.get`SELECT type FROM fs_entries WHERE path = ${resolved}`
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
@@ -1965,12 +1913,10 @@ var SqliteFs = class {
     }
     const prefix = resolved === "/" ? "/" : resolved + "/";
     const rows = z6.array(pathRow).parse(
-      this.#stmt(
-        `SELECT path FROM fs_entries
-       WHERE path LIKE ? || '%'
-         AND path != ?
-         AND path NOT LIKE ? || '%/%'`
-      ).all(prefix, resolved, prefix)
+      this.#sql.all`SELECT path FROM fs_entries
+       WHERE path LIKE ${prefix} || '%'
+         AND path != ${resolved}
+         AND path NOT LIKE ${prefix} || '%/%'`
     );
     return rows.map((row) => path2.posix.basename(row.path));
   }
@@ -1979,7 +1925,7 @@ var SqliteFs = class {
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
     const entry = typeRow.optional().parse(
-      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(resolved)
+      this.#sql.get`SELECT type FROM fs_entries WHERE path = ${resolved}`
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
@@ -1989,12 +1935,10 @@ var SqliteFs = class {
     }
     const prefix = resolved === "/" ? "/" : resolved + "/";
     const rows = z6.array(pathTypeRow).parse(
-      this.#stmt(
-        `SELECT path, type FROM fs_entries
-       WHERE path LIKE ? || '%'
-         AND path != ?
-         AND path NOT LIKE ? || '%/%'`
-      ).all(prefix, resolved, prefix)
+      this.#sql.all`SELECT path, type FROM fs_entries
+       WHERE path LIKE ${prefix} || '%'
+         AND path != ${resolved}
+         AND path NOT LIKE ${prefix} || '%/%'`
     );
     return rows.map((row) => ({
       name: path2.posix.basename(row.path),
@@ -2007,7 +1951,7 @@ var SqliteFs = class {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const entry = typeRow.optional().parse(
-      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(prefixed)
+      this.#sql.get`SELECT type FROM fs_entries WHERE path = ${prefixed}`
     );
     if (!entry) {
       if (options?.force) {
@@ -2015,21 +1959,21 @@ var SqliteFs = class {
       }
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
-    this.#useTransaction(() => {
-      if (entry.type === "directory") {
-        const children = this.#stmt(
-          `SELECT 1 FROM fs_entries WHERE path LIKE ? || '/%' LIMIT 1`
-        ).get(prefixed);
-        if (children && !options?.recursive) {
-          throw new Error(`ENOTEMPTY: directory not empty: ${filePath}`);
+    transaction(
+      this.#db,
+      () => {
+        if (entry.type === "directory") {
+          const children = this.#sql.get`SELECT 1 FROM fs_entries WHERE path LIKE ${prefixed} || '/%' LIMIT 1`;
+          if (children && !options?.recursive) {
+            throw new Error(`ENOTEMPTY: directory not empty: ${filePath}`);
+          }
+          this.#sql.run`DELETE FROM fs_entries WHERE path = ${prefixed} OR path LIKE ${prefixed} || '/%'`;
+        } else {
+          this.#sql.run`DELETE FROM fs_entries WHERE path = ${prefixed}`;
         }
-        this.#stmt(
-          `DELETE FROM fs_entries WHERE path = ? OR path LIKE ? || '/%'`
-        ).run(prefixed, prefixed);
-      } else {
-        this.#stmt("DELETE FROM fs_entries WHERE path = ?").run(prefixed);
-      }
-    });
+      },
+      { mode: "deferred" }
+    );
   }
   async cp(src, dest, options) {
     const srcNormalized = this.#normalizePath(src);
@@ -2037,7 +1981,7 @@ var SqliteFs = class {
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
     const srcEntry = entryRow.optional().parse(
-      this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(srcPrefixed)
+      this.#sql.get`SELECT * FROM fs_entries WHERE path = ${srcPrefixed}`
     );
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${src}`);
@@ -2045,60 +1989,40 @@ var SqliteFs = class {
     if (srcEntry.type === "directory" && !options?.recursive) {
       throw new Error(`cp: -r not specified; omitting directory: ${src}`);
     }
-    this.#useTransaction(() => {
-      this.#ensureParentExists(destPrefixed);
-      if (srcEntry.type === "directory") {
-        const allEntries = z6.array(entryRow).parse(
-          this.#stmt(
-            `SELECT * FROM fs_entries WHERE path = ? OR path LIKE ? || '/%'`
-          ).all(srcPrefixed, srcPrefixed)
-        );
-        for (const entry of allEntries) {
-          const relativePath = path2.posix.relative(srcPrefixed, entry.path);
-          const newPath = path2.posix.join(destPrefixed, relativePath);
-          this.#stmt(
-            `INSERT OR REPLACE INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
-             VALUES (?, ?, ?, ?, ?, ?)`
-          ).run(
-            newPath,
-            entry.type,
-            entry.mode,
-            entry.size,
-            Date.now(),
-            entry.symlinkTarget
+    transaction(
+      this.#db,
+      () => {
+        this.#ensureParentExists(destPrefixed);
+        if (srcEntry.type === "directory") {
+          const allEntries = z6.array(entryRow).parse(
+            this.#sql.all`SELECT * FROM fs_entries WHERE path = ${srcPrefixed} OR path LIKE ${srcPrefixed} || '/%'`
           );
-          if (entry.type === "file") {
-            const chunks = this.#chunks(entry.path);
-            for (const chunk of chunks) {
-              this.#stmt(
-                "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
-              ).run(newPath, chunk.chunkIndex, chunk.data);
+          for (const entry of allEntries) {
+            const relativePath = path2.posix.relative(srcPrefixed, entry.path);
+            const newPath = path2.posix.join(destPrefixed, relativePath);
+            this.#sql.run`INSERT OR REPLACE INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
+             VALUES (${newPath}, ${entry.type}, ${entry.mode}, ${entry.size}, ${Date.now()}, ${entry.symlinkTarget})`;
+            if (entry.type === "file") {
+              const chunks = this.#chunks(entry.path);
+              for (const chunk of chunks) {
+                this.#sql.run`INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (${newPath}, ${chunk.chunkIndex}, ${chunk.data})`;
+              }
             }
           }
-        }
-      } else {
-        this.#stmt(
-          `INSERT OR REPLACE INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
-           VALUES (?, ?, ?, ?, ?, ?)`
-        ).run(
-          destPrefixed,
-          srcEntry.type,
-          srcEntry.mode,
-          srcEntry.size,
-          Date.now(),
-          srcEntry.symlinkTarget
-        );
-        if (srcEntry.type === "file") {
-          const chunks = this.#chunks(srcPrefixed);
-          this.#stmt("DELETE FROM fs_chunks WHERE path = ?").run(destPrefixed);
-          for (const chunk of chunks) {
-            this.#stmt(
-              "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
-            ).run(destPrefixed, chunk.chunkIndex, chunk.data);
+        } else {
+          this.#sql.run`INSERT OR REPLACE INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
+           VALUES (${destPrefixed}, ${srcEntry.type}, ${srcEntry.mode}, ${srcEntry.size}, ${Date.now()}, ${srcEntry.symlinkTarget})`;
+          if (srcEntry.type === "file") {
+            const chunks = this.#chunks(srcPrefixed);
+            this.#sql.run`DELETE FROM fs_chunks WHERE path = ${destPrefixed}`;
+            for (const chunk of chunks) {
+              this.#sql.run`INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (${destPrefixed}, ${chunk.chunkIndex}, ${chunk.data})`;
+            }
           }
         }
-      }
-    });
+      },
+      { mode: "deferred" }
+    );
   }
   async mv(src, dest) {
     const srcNormalized = this.#normalizePath(src);
@@ -2106,83 +2030,59 @@ var SqliteFs = class {
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
     const srcEntry = entryRow.optional().parse(
-      this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(srcPrefixed)
+      this.#sql.get`SELECT * FROM fs_entries WHERE path = ${srcPrefixed}`
     );
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${src}`);
     }
-    this.#useTransaction(() => {
-      this.#ensureParentExists(destPrefixed);
-      if (srcEntry.type === "directory") {
-        const allEntries = z6.array(entryRow).parse(
-          this.#stmt(
-            `SELECT * FROM fs_entries WHERE path = ? OR path LIKE ? || '/%' ORDER BY path DESC`
-          ).all(srcPrefixed, srcPrefixed)
-        );
-        for (const entry of [...allEntries].reverse()) {
-          const relativePath = path2.posix.relative(srcPrefixed, entry.path);
-          const newPath = path2.posix.join(destPrefixed, relativePath);
-          this.#stmt(
-            `INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
-             VALUES (?, ?, ?, ?, ?, ?)`
-          ).run(
-            newPath,
-            entry.type,
-            entry.mode,
-            entry.size,
-            Date.now(),
-            entry.symlinkTarget
+    transaction(
+      this.#db,
+      () => {
+        this.#ensureParentExists(destPrefixed);
+        if (srcEntry.type === "directory") {
+          const allEntries = z6.array(entryRow).parse(
+            this.#sql.all`SELECT * FROM fs_entries WHERE path = ${srcPrefixed} OR path LIKE ${srcPrefixed} || '/%' ORDER BY path DESC`
           );
-          if (entry.type === "file") {
-            const chunks = this.#chunks(entry.path);
-            for (const chunk of chunks) {
-              this.#stmt(
-                "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
-              ).run(newPath, chunk.chunkIndex, chunk.data);
+          for (const entry of [...allEntries].reverse()) {
+            const relativePath = path2.posix.relative(srcPrefixed, entry.path);
+            const newPath = path2.posix.join(destPrefixed, relativePath);
+            this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
+             VALUES (${newPath}, ${entry.type}, ${entry.mode}, ${entry.size}, ${Date.now()}, ${entry.symlinkTarget})`;
+            if (entry.type === "file") {
+              const chunks = this.#chunks(entry.path);
+              for (const chunk of chunks) {
+                this.#sql.run`INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (${newPath}, ${chunk.chunkIndex}, ${chunk.data})`;
+              }
             }
           }
-        }
-        this.#stmt(
-          `DELETE FROM fs_entries WHERE path = ? OR path LIKE ? || '/%'`
-        ).run(srcPrefixed, srcPrefixed);
-      } else {
-        this.#stmt(
-          `INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
-           VALUES (?, ?, ?, ?, ?, ?)`
-        ).run(
-          destPrefixed,
-          srcEntry.type,
-          srcEntry.mode,
-          srcEntry.size,
-          Date.now(),
-          srcEntry.symlinkTarget
-        );
-        if (srcEntry.type === "file") {
-          const chunks = this.#chunks(srcPrefixed);
-          for (const chunk of chunks) {
-            this.#stmt(
-              "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
-            ).run(destPrefixed, chunk.chunkIndex, chunk.data);
+          this.#sql.run`DELETE FROM fs_entries WHERE path = ${srcPrefixed} OR path LIKE ${srcPrefixed} || '/%'`;
+        } else {
+          this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
+           VALUES (${destPrefixed}, ${srcEntry.type}, ${srcEntry.mode}, ${srcEntry.size}, ${Date.now()}, ${srcEntry.symlinkTarget})`;
+          if (srcEntry.type === "file") {
+            const chunks = this.#chunks(srcPrefixed);
+            for (const chunk of chunks) {
+              this.#sql.run`INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (${destPrefixed}, ${chunk.chunkIndex}, ${chunk.data})`;
+            }
           }
+          this.#sql.run`DELETE FROM fs_entries WHERE path = ${srcPrefixed}`;
         }
-        this.#stmt("DELETE FROM fs_entries WHERE path = ?").run(srcPrefixed);
-      }
-    });
+      },
+      { mode: "deferred" }
+    );
   }
   resolvePath(base, relativePath) {
     return path2.posix.resolve(base, relativePath);
   }
   getAllPaths() {
-    const rows = z6.array(pathRow).parse(this.#stmt("SELECT path FROM fs_entries ORDER BY path").all());
+    const rows = z6.array(pathRow).parse(this.#sql.all`SELECT path FROM fs_entries ORDER BY path`);
     return rows.map((row) => row.path);
   }
   async realpath(filePath) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
-    const exists = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
-      resolved
-    );
+    const exists = this.#sql.get`SELECT 1 FROM fs_entries WHERE path = ${resolved}`;
     if (!exists) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -2192,9 +2092,7 @@ var SqliteFs = class {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
-    const result = this.#stmt(
-      "UPDATE fs_entries SET mtime = ? WHERE path = ?"
-    ).run(mtime.getTime(), resolved);
+    const result = this.#sql.run`UPDATE fs_entries SET mtime = ${mtime.getTime()} WHERE path = ${resolved}`;
     if (result.changes === 0) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -2202,9 +2100,7 @@ var SqliteFs = class {
   async chmod(filePath, mode) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
-    const result = this.#stmt(
-      "UPDATE fs_entries SET mode = ? WHERE path = ?"
-    ).run(mode, prefixed);
+    const result = this.#sql.run`UPDATE fs_entries SET mode = ${mode} WHERE path = ${prefixed}`;
     if (result.changes === 0) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -2212,19 +2108,19 @@ var SqliteFs = class {
   async symlink(target, linkPath) {
     const normalized = this.#normalizePath(linkPath);
     const prefixed = this.#prefixPath(normalized);
-    const existing = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
-      prefixed
-    );
+    const existing = this.#sql.get`SELECT 1 FROM fs_entries WHERE path = ${prefixed}`;
     if (existing) {
       throw new Error(`EEXIST: file already exists: ${linkPath}`);
     }
-    this.#useTransaction(() => {
-      this.#ensureParentExists(prefixed);
-      this.#stmt(
-        `INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
-         VALUES (?, 'symlink', 511, 0, ?, ?)`
-      ).run(prefixed, Date.now(), target);
-    });
+    transaction(
+      this.#db,
+      () => {
+        this.#ensureParentExists(prefixed);
+        this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime, symlinkTarget)
+         VALUES (${prefixed}, 'symlink', 511, 0, ${Date.now()}, ${target})`;
+      },
+      { mode: "deferred" }
+    );
   }
   async link(existingPath, newPath) {
     const srcNormalized = this.#normalizePath(existingPath);
@@ -2232,7 +2128,7 @@ var SqliteFs = class {
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
     const srcEntry = entryRow.optional().parse(
-      this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(srcPrefixed)
+      this.#sql.get`SELECT * FROM fs_entries WHERE path = ${srcPrefixed}`
     );
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${existingPath}`);
@@ -2240,33 +2136,29 @@ var SqliteFs = class {
     if (srcEntry.type !== "file") {
       throw new Error(`link: not supported for directories: ${existingPath}`);
     }
-    const existing = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
-      destPrefixed
-    );
+    const existing = this.#sql.get`SELECT 1 FROM fs_entries WHERE path = ${destPrefixed}`;
     if (existing) {
       throw new Error(`EEXIST: file already exists: ${newPath}`);
     }
-    this.#useTransaction(() => {
-      this.#ensureParentExists(destPrefixed);
-      this.#stmt(
-        `INSERT INTO fs_entries (path, type, mode, size, mtime)
-         VALUES (?, 'file', ?, ?, ?)`
-      ).run(destPrefixed, srcEntry.mode, srcEntry.size, Date.now());
-      const chunks = this.#chunks(srcPrefixed);
-      for (const chunk of chunks) {
-        this.#stmt(
-          "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
-        ).run(destPrefixed, chunk.chunkIndex, chunk.data);
-      }
-    });
+    transaction(
+      this.#db,
+      () => {
+        this.#ensureParentExists(destPrefixed);
+        this.#sql.run`INSERT INTO fs_entries (path, type, mode, size, mtime)
+         VALUES (${destPrefixed}, 'file', ${srcEntry.mode}, ${srcEntry.size}, ${Date.now()})`;
+        const chunks = this.#chunks(srcPrefixed);
+        for (const chunk of chunks) {
+          this.#sql.run`INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (${destPrefixed}, ${chunk.chunkIndex}, ${chunk.data})`;
+        }
+      },
+      { mode: "deferred" }
+    );
   }
   async readlink(linkPath) {
     const normalized = this.#normalizePath(linkPath);
     const prefixed = this.#prefixPath(normalized);
     const entry = linkRow.optional().parse(
-      this.#stmt(
-        "SELECT type, symlinkTarget FROM fs_entries WHERE path = ?"
-      ).get(prefixed)
+      this.#sql.get`SELECT type, symlinkTarget FROM fs_entries WHERE path = ${prefixed}`
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${linkPath}`);
@@ -2313,6 +2205,38 @@ GO
 `;
 }
 
+// packages/text2sql/src/lib/fs/mssql/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/text2sql/src/lib/fs/mssql/mssql-fs.ts
 var entryRow2 = z7.object({
   path: z7.string(),
@@ -2347,7 +2271,6 @@ var MssqlFs = class _MssqlFs {
   #root;
   #schema;
   #ownsPool;
-  #isInitialized = false;
   constructor(options) {
     this.#chunkSize = options.chunkSize ?? 1024 * 1024;
     const schema = options.schema ?? "dbo";
@@ -2379,91 +2302,72 @@ var MssqlFs = class _MssqlFs {
   #t(name) {
     return `[${this.#schema}].[${name}]`;
   }
-  async initialize() {
+  /** Opens the file system: creates its tables and its root directories. */
+  static async create(options) {
+    const fs = new _MssqlFs(options);
+    try {
+      await fs.#initialize();
+    } catch (error) {
+      await fs.close();
+      throw error;
+    }
+    return fs;
+  }
+  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 = mssqlFsDDL(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(
+      _MssqlFs.#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 = mssqlFsDDL(this.#schema);
+        const batches = ddl.split(/\bGO\b/i).filter((b) => b.trim());
+        for (const batch of batches) {
+          await this.#pool.request().batch(batch);
+        }
+        await this.#ensureDirectory("/");
+        if (this.#root) {
+          await this.#createParentDirs(this.#root);
+          await this.#ensureDirectory(this.#root);
+        }
       }
-    }
-    const rootSlashExists = rowsOf(
-      existsRow,
-      await this.#rawQuery(
-        `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = '/') THEN 1 ELSE 0 END as [exists]`
-      )
     );
-    if (rootSlashExists[0].exists === 0) {
-      await this.#rawExec(
-        `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ('/', 'directory', 493, 0, @p0)`,
-        [Date.now()]
-      );
-    }
-    if (this.#root) {
-      await this.#createParentDirs(this.#root);
-      const rootExists = rowsOf(
-        existsRow,
-        await this.#rawQuery(
-          `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
-          [this.#root]
-        )
-      );
-      if (rootExists[0].exists === 0) {
-        await this.#rawExec(
-          `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES (@p0, 'directory', 493, 0, @p1)`,
-          [this.#root, Date.now()]
-        );
-      }
-    }
-    this.#isInitialized = true;
-  }
-  #ensureInitialized() {
-    if (!this.#isInitialized) {
-      throw new Error(
-        "MssqlFs not initialized. Call await fs.initialize() after construction."
-      );
-    }
   }
   async #createParentDirs(p) {
     const segments = p.split("/").filter(Boolean);
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
       currentPath = path3.posix.join(currentPath, segments[i]);
-      const exists = rowsOf(
-        existsRow,
-        await this.#rawQuery(
-          `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
-          [currentPath]
-        )
-      );
-      if (exists[0].exists === 0) {
-        await this.#rawExec(
-          `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES (@p0, 'directory', 493, 0, @p1)`,
-          [currentPath, Date.now()]
-        );
-      }
+      await this.#ensureDirectory(currentPath);
     }
   }
-  #rawQuery(sql, params) {
+  async #ensureDirectory(p) {
+    await this.#exec(
+      `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime)
+       SELECT @p0, 'directory', 493, 0, @p1
+       WHERE NOT EXISTS (SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0)`,
+      [p, Date.now()]
+    );
+  }
+  #query(sql, params) {
     const request = this.#pool.request();
     params?.forEach((value, index2) => {
       request.input(`p${index2}`, value);
     });
     return request.query(sql);
   }
-  async #rawExec(sql, params) {
+  async #exec(sql, params) {
     const request = this.#pool.request();
     params?.forEach((value, index2) => {
       request.input(`p${index2}`, value);
@@ -2471,25 +2375,16 @@ var MssqlFs = class _MssqlFs {
     const result = await request.query(sql);
     return result.rowsAffected[0] ?? 0;
   }
-  async #query(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawQuery(sql, params);
-  }
-  async #exec(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawExec(sql, params);
-  }
   async #useTransaction(fn) {
-    this.#ensureInitialized();
     const mssql = _MssqlFs.#requireMssql();
-    const transaction = new mssql.Transaction(this.#pool);
+    const transaction2 = new mssql.Transaction(this.#pool);
     try {
-      await transaction.begin();
-      const result = await fn(transaction);
-      await transaction.commit();
+      await transaction2.begin();
+      const result = await fn(transaction2);
+      await transaction2.commit();
       return result;
     } catch (error) {
-      await transaction.rollback();
+      await transaction2.rollback();
       throw error;
     }
   }
@@ -2524,11 +2419,11 @@ var MssqlFs = class _MssqlFs {
     const dir = path3.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
-  async #ensureParentExists(filePath, transaction) {
+  async #ensureParentExists(filePath, transaction2) {
     const parent = this.#dirname(filePath);
     const rootPath = this.#root || "/";
     if (parent === rootPath || parent === "/") return;
-    const request = transaction.request();
+    const request = transaction2.request();
     request.input("p0", parent);
     const [entry] = rowsOf(
       typeRow2,
@@ -2537,8 +2432,8 @@ var MssqlFs = class _MssqlFs {
       )
     );
     if (!entry) {
-      await this.#ensureParentExists(parent, transaction);
-      const insertReq = transaction.request();
+      await this.#ensureParentExists(parent, transaction2);
+      const insertReq = transaction2.request();
       insertReq.input("p0", parent);
       insertReq.input("p1", Date.now());
       await insertReq.query(
@@ -2548,8 +2443,8 @@ var MssqlFs = class _MssqlFs {
       throw new Error(`mkdir: parent is not a directory: ${parent}`);
     }
   }
-  async #writeChunks(filePath, content, transaction) {
-    const deleteReq = transaction.request();
+  async #writeChunks(filePath, content, transaction2) {
+    const deleteReq = transaction2.request();
     deleteReq.input("p0", filePath);
     await deleteReq.query(
       `DELETE FROM ${this.#t("fs_chunks")} WHERE path = @p0`
@@ -2559,7 +2454,7 @@ var MssqlFs = class _MssqlFs {
         i,
         Math.min(i + this.#chunkSize, content.length)
       );
-      const insertReq = transaction.request();
+      const insertReq = transaction2.request();
       insertReq.input("p0", filePath);
       insertReq.input("p1", Math.floor(i / this.#chunkSize));
       insertReq.input("p2", Buffer.from(chunk));
@@ -2568,11 +2463,11 @@ var MssqlFs = class _MssqlFs {
       );
     }
   }
-  async #readChunks(filePath, transaction) {
+  async #readChunks(filePath, transaction2) {
     const sql = `SELECT data FROM ${this.#t("fs_chunks")} WHERE path = @p0 ORDER BY chunkIndex`;
     const rows = rowsOf(
       dataRow2,
-      transaction ? await transaction.request().input("p0", filePath).query(sql) : await this.#query(sql, [filePath])
+      transaction2 ? await transaction2.request().input("p0", filePath).query(sql) : await this.#query(sql, [filePath])
     );
     if (rows.length === 0) {
       return new Uint8Array(0);
@@ -2668,9 +2563,9 @@ var MssqlFs = class _MssqlFs {
     const prefixed = this.#prefixPath(normalized);
     const encoding = typeof options === "string" ? options : options?.encoding;
     const data = this.#toUint8Array(content, encoding);
-    await this.#useTransaction(async (transaction) => {
-      await this.#ensureParentExists(prefixed, transaction);
-      const request = transaction.request();
+    await this.#useTransaction(async (transaction2) => {
+      await this.#ensureParentExists(prefixed, transaction2);
+      const request = transaction2.request();
       request.input("p0", prefixed);
       request.input("p1", data.length);
       request.input("p2", Date.now());
@@ -2684,7 +2579,7 @@ var MssqlFs = class _MssqlFs {
           INSERT (path, type, mode, size, mtime)
           VALUES (@p0, 'file', 420, @p1, @p2);
       `);
-      await this.#writeChunks(prefixed, data, transaction);
+      await this.#writeChunks(prefixed, data, transaction2);
     });
   }
   async appendFile(filePath, content, options) {
@@ -2692,9 +2587,9 @@ var MssqlFs = class _MssqlFs {
     const prefixed = this.#prefixPath(normalized);
     const encoding = typeof options === "string" ? options : options?.encoding;
     const newData = this.#toUint8Array(content, encoding);
-    await this.#useTransaction(async (transaction) => {
-      await this.#ensureParentExists(prefixed, transaction);
-      const checkReq = transaction.request();
+    await this.#useTransaction(async (transaction2) => {
+      await this.#ensureParentExists(prefixed, transaction2);
+      const checkReq = transaction2.request();
       checkReq.input("p0", prefixed);
       const [entry] = rowsOf(
         typeRow2,
@@ -2705,11 +2600,11 @@ var MssqlFs = class _MssqlFs {
       if (entry && entry.type !== "file") {
         throw new Error(`appendFile: not a file: ${filePath}`);
       }
-      const existing = entry ? await this.#readChunks(prefixed, transaction) : new Uint8Array(0);
+      const existing = entry ? await this.#readChunks(prefixed, transaction2) : new Uint8Array(0);
       const combined = new Uint8Array(existing.length + newData.length);
       combined.set(existing, 0);
       combined.set(newData, existing.length);
-      const upsertReq = transaction.request();
+      const upsertReq = transaction2.request();
       upsertReq.input("p0", prefixed);
       upsertReq.input("p1", combined.length);
       upsertReq.input("p2", Date.now());
@@ -2723,7 +2618,7 @@ var MssqlFs = class _MssqlFs {
           INSERT (path, type, mode, size, mtime)
           VALUES (@p0, 'file', 420, @p1, @p2);
       `);
-      await this.#writeChunks(prefixed, combined, transaction);
+      await this.#writeChunks(prefixed, combined, transaction2);
     });
   }
   async exists(filePath) {
@@ -2799,7 +2694,7 @@ var MssqlFs = class _MssqlFs {
       }
       throw new Error(`EEXIST: file already exists: ${dirPath}`);
     }
-    await this.#useTransaction(async (transaction) => {
+    await this.#useTransaction(async (transaction2) => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
         const relativePath = path3.posix.relative(rootPath, prefixed);
@@ -2807,7 +2702,7 @@ var MssqlFs = class _MssqlFs {
         let currentPath = rootPath;
         for (const segment of segments) {
           currentPath = path3.posix.join(currentPath, segment);
-          const checkReq = transaction.request();
+          const checkReq = transaction2.request();
           checkReq.input("p0", currentPath);
           const [exists] = rowsOf(
             typeRow2,
@@ -2816,7 +2711,7 @@ var MssqlFs = class _MssqlFs {
             )
           );
           if (!exists) {
-            const insertReq = transaction.request();
+            const insertReq = transaction2.request();
             insertReq.input("p0", currentPath);
             insertReq.input("p1", Date.now());
             await insertReq.query(
@@ -2828,7 +2723,7 @@ var MssqlFs = class _MssqlFs {
         }
       } else {
         const parent = this.#dirname(prefixed);
-        const parentReq = transaction.request();
+        const parentReq = transaction2.request();
         parentReq.input("p0", parent);
         const [parentEntry] = rowsOf(
           typeRow2,
@@ -2842,7 +2737,7 @@ var MssqlFs = class _MssqlFs {
         if (parentEntry.type !== "directory") {
           throw new Error(`mkdir: parent is not a directory: ${parent}`);
         }
-        const insertReq = transaction.request();
+        const insertReq = transaction2.request();
         insertReq.input("p0", prefixed);
         insertReq.input("p1", Date.now());
         await insertReq.query(
@@ -2932,9 +2827,9 @@ var MssqlFs = class _MssqlFs {
       }
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
-    await this.#useTransaction(async (transaction) => {
+    await this.#useTransaction(async (transaction2) => {
       if (entry.type === "directory") {
-        const childrenReq = transaction.request();
+        const childrenReq = transaction2.request();
         childrenReq.input("p0", prefixed);
         const children = rowsOf(
           existsRow,
@@ -2945,13 +2840,13 @@ var MssqlFs = class _MssqlFs {
         if (children[0].exists === 1 && !options?.recursive) {
           throw new Error(`ENOTEMPTY: directory not empty: ${filePath}`);
         }
-        const deleteReq = transaction.request();
+        const deleteReq = transaction2.request();
         deleteReq.input("p0", prefixed);
         await deleteReq.query(
           `DELETE FROM ${this.#t("fs_entries")} WHERE path = @p0 OR path LIKE @p0 + '/%'`
         );
       } else {
-        const deleteReq = transaction.request();
+        const deleteReq = transaction2.request();
         deleteReq.input("p0", prefixed);
         await deleteReq.query(
           `DELETE FROM ${this.#t("fs_entries")} WHERE path = @p0`
@@ -2977,10 +2872,10 @@ var MssqlFs = class _MssqlFs {
     if (srcEntry.type === "directory" && !options?.recursive) {
       throw new Error(`cp: -r not specified; omitting directory: ${src}`);
     }
-    await this.#useTransaction(async (transaction) => {
-      await this.#ensureParentExists(destPrefixed, transaction);
+    await this.#useTransaction(async (transaction2) => {
+      await this.#ensureParentExists(destPrefixed, transaction2);
       if (srcEntry.type === "directory") {
-        const allEntriesReq = transaction.request();
+        const allEntriesReq = transaction2.request();
         allEntriesReq.input("p0", srcPrefixed);
         const allEntries = rowsOf(
           entryRow2,
@@ -2991,7 +2886,7 @@ var MssqlFs = class _MssqlFs {
         for (const entry of allEntries) {
           const relativePath = path3.posix.relative(srcPrefixed, entry.path);
           const newPath = path3.posix.join(destPrefixed, relativePath);
-          const insertReq = transaction.request();
+          const insertReq = transaction2.request();
           insertReq.input("p0", newPath);
           insertReq.input("p1", entry.type);
           insertReq.input("p2", entry.mode);
@@ -3009,12 +2904,12 @@ var MssqlFs = class _MssqlFs {
               VALUES (@p0, @p1, @p2, @p3, @p4, @p5);
           `);
           if (entry.type === "file") {
-            const deleteChunksReq = transaction.request();
+            const deleteChunksReq = transaction2.request();
             deleteChunksReq.input("p0", newPath);
             await deleteChunksReq.query(
               `DELETE FROM ${this.#t("fs_chunks")} WHERE path = @p0`
             );
-            const chunksReq = transaction.request();
+            const chunksReq = transaction2.request();
             chunksReq.input("p0", entry.path);
             const chunks = rowsOf(
               chunkRow2,
@@ -3023,7 +2918,7 @@ var MssqlFs = class _MssqlFs {
               )
             );
             for (const chunk of chunks) {
-              const chunkInsertReq = transaction.request();
+              const chunkInsertReq = transaction2.request();
               chunkInsertReq.input("p0", newPath);
               chunkInsertReq.input("p1", chunk.chunkIndex);
               chunkInsertReq.input("p2", chunk.data);
@@ -3034,7 +2929,7 @@ var MssqlFs = class _MssqlFs {
           }
         }
       } else {
-        const insertReq = transaction.request();
+        const insertReq = transaction2.request();
         insertReq.input("p0", destPrefixed);
         insertReq.input("p1", srcEntry.type);
         insertReq.input("p2", srcEntry.mode);
@@ -3052,7 +2947,7 @@ var MssqlFs = class _MssqlFs {
             VALUES (@p0, @p1, @p2, @p3, @p4, @p5);
         `);
         if (srcEntry.type === "file") {
-          const chunksReq = transaction.request();
+          const chunksReq = transaction2.request();
           chunksReq.input("p0", srcPrefixed);
           const chunks = rowsOf(
             chunkRow2,
@@ -3060,13 +2955,13 @@ var MssqlFs = class _MssqlFs {
               `SELECT chunkIndex, data FROM ${this.#t("fs_chunks")} WHERE path = @p0`
             )
           );
-          const deleteChunksReq = transaction.request();
+          const deleteChunksReq = transaction2.request();
           deleteChunksReq.input("p0", destPrefixed);
           await deleteChunksReq.query(
             `DELETE FROM ${this.#t("fs_chunks")} WHERE path = @p0`
           );
           for (const chunk of chunks) {
-            const chunkInsertReq = transaction.request();
+            const chunkInsertReq = transaction2.request();
             chunkInsertReq.input("p0", destPrefixed);
             chunkInsertReq.input("p1", chunk.chunkIndex);
             chunkInsertReq.input("p2", chunk.data);
@@ -3093,10 +2988,10 @@ var MssqlFs = class _MssqlFs {
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${src}`);
     }
-    await this.#useTransaction(async (transaction) => {
-      await this.#ensureParentExists(destPrefixed, transaction);
+    await this.#useTransaction(async (transaction2) => {
+      await this.#ensureParentExists(destPrefixed, transaction2);
       if (srcEntry.type === "directory") {
-        const allEntriesReq = transaction.request();
+        const allEntriesReq = transaction2.request();
         allEntriesReq.input("p0", srcPrefixed);
         const allEntries = rowsOf(
           entryRow2,
@@ -3104,7 +2999,7 @@ var MssqlFs = class _MssqlFs {
             `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0 OR path LIKE @p0 + '/%' ORDER BY path DESC`
           )
         );
-        const destDeleteReq = transaction.request();
+        const destDeleteReq = transaction2.request();
         destDeleteReq.input("dp0", destPrefixed);
         await destDeleteReq.query(
           `DELETE FROM ${this.#t("fs_entries")} WHERE path = @dp0 OR path LIKE @dp0 + '/%'`
@@ -3112,7 +3007,7 @@ var MssqlFs = class _MssqlFs {
         for (const entry of [...allEntries].reverse()) {
           const relativePath = path3.posix.relative(srcPrefixed, entry.path);
           const newPath = path3.posix.join(destPrefixed, relativePath);
-          const insertReq = transaction.request();
+          const insertReq = transaction2.request();
           insertReq.input("p0", newPath);
           insertReq.input("p1", entry.type);
           insertReq.input("p2", entry.mode);
@@ -3130,12 +3025,12 @@ var MssqlFs = class _MssqlFs {
               VALUES (@p0, @p1, @p2, @p3, @p4, @p5);
           `);
           if (entry.type === "file") {
-            const deleteChunksReq = transaction.request();
+            const deleteChunksReq = transaction2.request();
             deleteChunksReq.input("p0", newPath);
             await deleteChunksReq.query(
               `DELETE FROM ${this.#t("fs_chunks")} WHERE path = @p0`
             );
-            const chunksReq = transaction.request();
+            const chunksReq = transaction2.request();
             chunksReq.input("p0", entry.path);
             const chunks = rowsOf(
               chunkRow2,
@@ -3144,7 +3039,7 @@ var MssqlFs = class _MssqlFs {
               )
             );
             for (const chunk of chunks) {
-              const chunkInsertReq = transaction.request();
+              const chunkInsertReq = transaction2.request();
               chunkInsertReq.input("p0", newPath);
               chunkInsertReq.input("p1", chunk.chunkIndex);
               chunkInsertReq.input("p2", chunk.data);
@@ -3154,13 +3049,13 @@ var MssqlFs = class _MssqlFs {
             }
           }
         }
-        const deleteReq = transaction.request();
+        const deleteReq = transaction2.request();
         deleteReq.input("p0", srcPrefixed);
         await deleteReq.query(
           `DELETE FROM ${this.#t("fs_entries")} WHERE path = @p0 OR path LIKE @p0 + '/%'`
         );
       } else {
-        const insertReq = transaction.request();
+        const insertReq = transaction2.request();
         insertReq.input("p0", destPrefixed);
         insertReq.input("p1", srcEntry.type);
         insertReq.input("p2", srcEntry.mode);
@@ -3178,12 +3073,12 @@ var MssqlFs = class _MssqlFs {
             VALUES (@p0, @p1, @p2, @p3, @p4, @p5);
         `);
         if (srcEntry.type === "file") {
-          const deleteChunksReq = transaction.request();
+          const deleteChunksReq = transaction2.request();
           deleteChunksReq.input("p0", destPrefixed);
           await deleteChunksReq.query(
             `DELETE FROM ${this.#t("fs_chunks")} WHERE path = @p0`
           );
-          const chunksReq = transaction.request();
+          const chunksReq = transaction2.request();
           chunksReq.input("p0", srcPrefixed);
           const chunks = rowsOf(
             chunkRow2,
@@ -3192,7 +3087,7 @@ var MssqlFs = class _MssqlFs {
             )
           );
           for (const chunk of chunks) {
-            const chunkInsertReq = transaction.request();
+            const chunkInsertReq = transaction2.request();
             chunkInsertReq.input("p0", destPrefixed);
             chunkInsertReq.input("p1", chunk.chunkIndex);
             chunkInsertReq.input("p2", chunk.data);
@@ -3201,7 +3096,7 @@ var MssqlFs = class _MssqlFs {
             );
           }
         }
-        const deleteReq = transaction.request();
+        const deleteReq = transaction2.request();
         deleteReq.input("p0", srcPrefixed);
         await deleteReq.query(
           `DELETE FROM ${this.#t("fs_entries")} WHERE path = @p0`
@@ -3278,9 +3173,9 @@ var MssqlFs = class _MssqlFs {
     if (existingRows[0].exists === 1) {
       throw new Error(`EEXIST: file already exists: ${linkPath}`);
     }
-    await this.#useTransaction(async (transaction) => {
-      await this.#ensureParentExists(prefixed, transaction);
-      const insertReq = transaction.request();
+    await this.#useTransaction(async (transaction2) => {
+      await this.#ensureParentExists(prefixed, transaction2);
+      const insertReq = transaction2.request();
       insertReq.input("p0", prefixed);
       insertReq.input("p1", Date.now());
       insertReq.input("p2", target);
@@ -3318,9 +3213,9 @@ var MssqlFs = class _MssqlFs {
     if (existingRows[0].exists === 1) {
       throw new Error(`EEXIST: file already exists: ${newPath}`);
     }
-    await this.#useTransaction(async (transaction) => {
-      await this.#ensureParentExists(destPrefixed, transaction);
-      const insertReq = transaction.request();
+    await this.#useTransaction(async (transaction2) => {
+      await this.#ensureParentExists(destPrefixed, transaction2);
+      const insertReq = transaction2.request();
       insertReq.input("p0", destPrefixed);
       insertReq.input("p1", srcEntry.mode);
       insertReq.input("p2", srcEntry.size);
@@ -3329,7 +3224,7 @@ var MssqlFs = class _MssqlFs {
         `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime)
          VALUES (@p0, 'file', @p1, @p2, @p3)`
       );
-      const chunksReq = transaction.request();
+      const chunksReq = transaction2.request();
       chunksReq.input("p0", srcPrefixed);
       const chunks = rowsOf(
         chunkRow2,
@@ -3338,7 +3233,7 @@ var MssqlFs = class _MssqlFs {
         )
       );
       for (const chunk of chunks) {
-        const chunkInsertReq = transaction.request();
+        const chunkInsertReq = transaction2.request();
         chunkInsertReq.input("p0", destPrefixed);
         chunkInsertReq.input("p1", chunk.chunkIndex);
         chunkInsertReq.input("p2", chunk.data);
@@ -3372,6 +3267,7 @@ var MssqlFs = class _MssqlFs {
 import { createRequire as createRequire2 } from "node:module";
 import * as path4 from "node:path";
 import z8 from "zod";
+import { lockSchemaDDL } from "@deepagents/context";
 
 // packages/text2sql/src/lib/fs/postgres/ddl.postgres-fs.ts
 function postgresFsDDL(schema) {
@@ -3433,7 +3329,6 @@ var PostgresFs = class _PostgresFs {
   #root;
   #schema;
   #ownsPool;
-  #isInitialized = false;
   constructor(options) {
     this.#chunkSize = options.chunkSize ?? 1024 * 1024;
     const schema = options.schema ?? "public";
@@ -3465,83 +3360,53 @@ var PostgresFs = class _PostgresFs {
   #t(name) {
     return `"${this.#schema}"."${name}"`;
   }
-  async initialize() {
-    const ddl = postgresFsDDL(this.#schema);
-    await this.#pool.query(ddl);
-    const rootSlashExists = rowsOf2(
-      existsRow2,
-      await this.#rawQuery(
-        `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = '/') AS exists`
-      )
-    );
-    if (!rootSlashExists[0].exists) {
-      await this.#rawExec(
-        `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ('/', 'directory', 493, 0, $1)`,
-        [Date.now()]
-      );
-    }
-    if (this.#root) {
-      await this.#createParentDirs(this.#root);
-      const rootExists = rowsOf2(
-        existsRow2,
-        await this.#rawQuery(
-          `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
-          [this.#root]
-        )
-      );
-      if (!rootExists[0].exists) {
-        await this.#rawExec(
-          `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
-          [this.#root, Date.now()]
-        );
-      }
+  /** Opens the file system: creates its tables and its root directories. */
+  static async create(options) {
+    const fs = new _PostgresFs(options);
+    try {
+      await fs.#initialize();
+    } catch (error) {
+      await fs.close();
+      throw error;
     }
-    this.#isInitialized = true;
+    return fs;
   }
-  #ensureInitialized() {
-    if (!this.#isInitialized) {
-      throw new Error(
-        "PostgresFs not initialized. Call await fs.initialize() after construction."
+  // The schema lock is held until this transaction commits, so concurrent
+  // openers also create the root directories one at a time.
+  async #initialize() {
+    await this.#useTransaction(async (client) => {
+      await client.query(
+        lockSchemaDDL(postgresFsDDL(this.#schema), this.#schema)
       );
-    }
+      await this.#ensureDirectory(client, "/");
+      if (this.#root) {
+        await this.#createParentDirs(client, this.#root);
+        await this.#ensureDirectory(client, this.#root);
+      }
+    });
   }
-  async #createParentDirs(p) {
+  async #createParentDirs(client, p) {
     const segments = p.split("/").filter(Boolean);
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
       currentPath = path4.posix.join(currentPath, segments[i]);
-      const exists = rowsOf2(
-        existsRow2,
-        await this.#rawQuery(
-          `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
-          [currentPath]
-        )
-      );
-      if (!exists[0].exists) {
-        await this.#rawExec(
-          `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
-          [currentPath, Date.now()]
-        );
-      }
+      await this.#ensureDirectory(client, currentPath);
     }
   }
-  #rawQuery(sql, params) {
+  async #ensureDirectory(client, p) {
+    await client.query(
+      `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2) ON CONFLICT (path) DO NOTHING`,
+      [p, Date.now()]
+    );
+  }
+  #query(sql, params) {
     return this.#pool.query(sql, params);
   }
-  async #rawExec(sql, params) {
+  async #exec(sql, params) {
     const result = await this.#pool.query(sql, params);
     return result.rowCount ?? 0;
   }
-  async #query(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawQuery(sql, params);
-  }
-  async #exec(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawExec(sql, params);
-  }
   async #useTransaction(fn) {
-    this.#ensureInitialized();
     const client = await this.#pool.connect();
     try {
       await client.query("BEGIN");