@deepagents/text2sql 7.0.2 → 7.1.1

package/dist/index.js

@@ -20,6 +20,7 @@ function validateAdapterNames(names) {
 
 // packages/text2sql/src/lib/adapters/adapter.ts
 import { format as formatSql } from "sql-formatter";
+import { z } from "zod";
 
 // packages/text2sql/src/lib/agents/exceptions.ts
 var sqlValidationMarker = /* @__PURE__ */ Symbol("SQLValidationError");
@@ -192,6 +193,16 @@ function createGroundingContext(options = {}) {
 }
 
 // packages/text2sql/src/lib/adapters/adapter.ts
+function groundingFor(adapterType, create) {
+  return (adapter) => {
+    if (!(adapter instanceof adapterType)) {
+      throw new Error(
+        `A ${adapterType.name} grounding needs a ${adapterType.name} adapter, not ${adapter.constructor.name}.`
+      );
+    }
+    return create(adapter);
+  };
+}
 var Adapter = class {
   #policyAnalyzer;
   /**
@@ -452,6 +463,40 @@ var Adapter = class {
     }
     return decoded;
   }
+  /**
+   * Run an introspection query and check every row against `row`, the shape
+   * the driver returns for that query. A row of any other shape throws.
+   */
+  async runQuery(sql, row) {
+    const rows = z.array(row).safeParse(await this.queryRows(sql));
+    if (!rows.success) {
+      throw new Error(
+        `${this.constructor.name} introspection query returned rows of an unexpected shape:
+${z.prettifyError(rows.error)}
+SQL: ${sql.trim()}`,
+        { cause: rows.error }
+      );
+    }
+    return rows.data;
+  }
+  /**
+   * The rows in a driver's execute() result: the result itself when it is an
+   * array, otherwise the first array found at one of `paths` (dot-separated,
+   * so `recordsets.0` reads `result.recordsets[0]`).
+   */
+  rowsFrom(result, paths) {
+    if (Array.isArray(result)) return result;
+    for (const path6 of paths) {
+      const rows = path6.split(".").reduce(
+        (value, key) => typeof value === "object" && value !== null ? Reflect.get(value, key) : void 0,
+        result
+      );
+      if (Array.isArray(rows)) return rows;
+    }
+    throw new Error(
+      `${this.constructor.name} execute() must return an array of rows or an object holding one at ${paths.map((path6) => `result.${path6}`).join(", ")}.`
+    );
+  }
   /**
    * Convert unknown database value to number.
    * Handles number, bigint, and string types.
@@ -586,7 +631,7 @@ import {
 } from "ai";
 import dedent from "dedent";
 import pRetry from "p-retry";
-import z from "zod";
+import z2 from "zod";
 import "@deepagents/agent";
 import {
   ContextEngine,
@@ -878,14 +923,14 @@ Question: ${options.input}
       const sqlOutput = structuredOutput({
         model,
         context,
-        schema: z.object({
-          result: z.union([
-            z.object({
-              sql: z.string().describe("The SQL query that answers the question"),
-              reasoning: z.string().describe("The reasoning steps taken to generate the SQL")
+        schema: z2.object({
+          result: z2.union([
+            z2.object({
+              sql: z2.string().describe("The SQL query that answers the question"),
+              reasoning: z2.string().describe("The reasoning steps taken to generate the SQL")
             }),
-            z.object({
-              error: z.string().describe(
+            z2.object({
+              error: z2.string().describe(
                 "Error message explaining why the question cannot be answered with the given schema"
               )
             })
@@ -936,11 +981,11 @@ Question: ${options.input}
         const forcedSqlOutput = structuredOutput({
           model,
           context,
-          schema: z.object({
-            sql: z.string().describe(
+          schema: z2.object({
+            sql: z2.string().describe(
               "Best-effort SQL query that answers the core intent using only available schema entities."
             ),
-            reasoning: z.string().describe("Reasoning steps for best-effort schema mapping.")
+            reasoning: z2.string().describe("Reasoning steps for best-effort schema mapping.")
           })
         });
         try {
@@ -1025,17 +1070,17 @@ async function withRetry(computation, options = { retries: 3 }) {
 // packages/text2sql/src/lib/agents/suggestions.agents.ts
 import { groq as groq2 } from "@ai-sdk/groq";
 import dedent2 from "dedent";
-import z2 from "zod";
+import z3 from "zod";
 import { agent, thirdPersonPrompt } from "@deepagents/agent";
 var suggestionsAgent = agent({
   name: "text2sql-suggestions",
   model: groq2("openai/gpt-oss-20b"),
-  output: z2.object({
-    suggestions: z2.array(
-      z2.object({
-        question: z2.string().describe("A complex, high-impact business question."),
-        sql: z2.string().describe("The SQL statement needed to answer the question."),
-        businessValue: z2.string().describe("Why the question matters to stakeholders.")
+  output: z3.object({
+    suggestions: z3.array(
+      z3.object({
+        question: z3.string().describe("A complex, high-impact business question."),
+        sql: z3.string().describe("The SQL statement needed to answer the question."),
+        businessValue: z3.string().describe("Why the question matters to stakeholders.")
       })
     ).min(1).max(5).describe("A set of up to two advanced question + SQL pairs.")
   }),
@@ -1077,6 +1122,12 @@ var suggestionsAgent = agent({
 // packages/text2sql/src/lib/adapter-index.ts
 import { fragment as fragment2 } from "@deepagents/context";
 
+// packages/text2sql/src/lib/index-cache.ts
+import {
+  isFragment,
+  isFragmentData
+} from "@deepagents/context";
+
 // packages/text2sql/src/lib/file-cache.ts
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
@@ -1103,8 +1154,14 @@ var FileCache = class {
   }
 };
 var JsonCache = class extends FileCache {
-  constructor(watermark, baseDir) {
+  #isValid;
+  /**
+   * @param isValid - Checks that a parsed cache file holds a T; a file that
+   * fails it is read as a miss.
+   */
+  constructor(watermark, isValid, baseDir) {
     super(watermark, ".json", baseDir);
+    this.#isValid = isValid;
   }
   async read() {
     const content = await this.get();
@@ -1112,7 +1169,8 @@ var JsonCache = class extends FileCache {
       return null;
     }
     try {
-      return JSON.parse(content);
+      const value = JSON.parse(content);
+      return this.#isValid(value) ? value : null;
     } catch {
       return null;
     }
@@ -1138,54 +1196,12 @@ var FileIndexCache = class {
   }
   #cacheFor(key) {
     const watermark = this.#namespace ? `${this.#namespace}-${key}` : key;
-    return new JsonCache(watermark, this.#dir);
-  }
-};
-
-// packages/text2sql/src/lib/index-lock.ts
-import { createHash as createHash2 } from "node:crypto";
-import { mkdir as mkdir2 } from "node:fs/promises";
-import { tmpdir as tmpdir2 } from "node:os";
-import * as path2 from "node:path";
-import { lock as acquireLock } from "proper-lockfile";
-var DEFAULT_STALE_MS = 3e4;
-var DEFAULT_RETRIES = {
-  retries: 10,
-  factor: 2,
-  minTimeout: 100,
-  maxTimeout: 2e3
-};
-var FileIndexLock = class {
-  #dir;
-  #namespace;
-  #stale;
-  #retries;
-  constructor(options = {}) {
-    this.#dir = options.dir ?? tmpdir2();
-    this.#namespace = options.namespace;
-    this.#stale = options.stale ?? DEFAULT_STALE_MS;
-    this.#retries = options.retries ?? DEFAULT_RETRIES;
-  }
-  async run(key, fn) {
-    await mkdir2(this.#dir, { recursive: true });
-    const release = await acquireLock(this.#lockPathFor(key), {
-      realpath: false,
-      stale: this.#stale,
-      retries: this.#retries
-    });
-    try {
-      return await fn();
-    } finally {
-      await release().catch(() => {
-      });
-    }
-  }
-  #lockPathFor(key) {
-    const watermark = this.#namespace ? `${this.#namespace}-${key}` : key;
-    const hash2 = createHash2("md5").update(watermark).digest("hex");
-    return path2.join(this.#dir, `text2sql-lock-${hash2}`);
+    return new JsonCache(watermark, isFragmentList, this.#dir);
   }
 };
+function isFragmentList(value) {
+  return Array.isArray(value) && value.every((item) => isFragment(item) && isFragmentData(item));
+}
 
 // packages/text2sql/src/lib/adapter-index.ts
 var TEXT2SQL_INDEX_PROGRESS_CHUNK = "data-text2sql-index-progress";
@@ -1206,7 +1222,6 @@ function databaseNameFragment(name) {
 var AdapterIndexer = class {
   #adapters;
   #cache;
-  #lock;
   constructor(options) {
     const adapterNames = Object.keys(options.adapters);
     if (adapterNames.length === 0) {
@@ -1215,7 +1230,6 @@ var AdapterIndexer = class {
     validateAdapterNames(adapterNames);
     this.#adapters = options.adapters;
     this.#cache = options.cache;
-    this.#lock = options.lock;
   }
   async index(options = {}) {
     const progress = timestampProgressHandler(options.onProgress);
@@ -1273,41 +1287,15 @@ var AdapterIndexer = class {
       message: `Indexing adapter "${name}"...`
     });
     const cache = this.#cache;
-    const key = name;
-    const emitCacheHit = () => progress({
-      type: "adapter:cache-hit",
-      adapter: name,
-      message: `Using cached index for adapter "${name}".`,
-      cached: true
-    });
-    const emitCacheMiss = () => progress({
-      type: "adapter:cache-miss",
-      adapter: name,
-      message: `No cached index for adapter "${name}".`,
-      cached: false
-    });
-    const introspect = async () => {
-      const ctx = createGroundingContext({
-        onProgress: (event) => progress(adapterProgressEvent(name, event))
-      });
-      const fragments = await adapter.introspect(ctx);
-      await cache?.write(key, fragments);
-      return fragments;
-    };
-    let servedFromCache = false;
-    const populate = async () => {
-      const recheck = await cache?.read(key);
-      if (recheck) {
-        servedFromCache = true;
-        return recheck;
-      }
-      if (cache) emitCacheMiss();
-      return introspect();
-    };
     try {
-      const cached = await cache?.read(key);
+      const cached = await cache?.read(name);
       if (cached) {
-        emitCacheHit();
+        progress({
+          type: "adapter:cache-hit",
+          adapter: name,
+          message: `Using cached index for adapter "${name}".`,
+          cached: true
+        });
         progress({
           type: "adapter:end",
           adapter: name,
@@ -1316,13 +1304,24 @@ var AdapterIndexer = class {
         });
         return cached;
       }
-      const fragments = await this.#lock.run(key, populate);
-      if (servedFromCache) emitCacheHit();
+      if (cache) {
+        progress({
+          type: "adapter:cache-miss",
+          adapter: name,
+          message: `No cached index for adapter "${name}".`,
+          cached: false
+        });
+      }
+      const ctx = createGroundingContext({
+        onProgress: (event) => progress(adapterProgressEvent(name, event))
+      });
+      const fragments = await adapter.introspect(ctx);
+      await cache?.write(name, fragments);
       progress({
         type: "adapter:end",
         adapter: name,
         message: `Finished indexing adapter "${name}".`,
-        cached: servedFromCache
+        cached: false
       });
       return fragments;
     } catch (error) {
@@ -1368,16 +1367,30 @@ function errorMessage(error) {
 }
 
 // packages/text2sql/src/lib/checkpoint.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync2, readFileSync, renameSync, writeFileSync } from "node:fs";
 import pLimit from "p-limit";
+import z4 from "zod";
+function jsonCodec(schema) {
+  return { encode: (value) => value, decode: (stored) => schema.parse(stored) };
+}
+var pointData = z4.object({
+  committed: z4.boolean(),
+  entries: z4.array(
+    z4.object({ inputHash: z4.string(), output: z4.unknown().optional() })
+  )
+});
+var checkpointFile = z4.object({
+  configHash: z4.string().optional(),
+  points: z4.record(z4.string(), pointData)
+});
 var Checkpoint = class _Checkpoint {
   points;
   path;
   configHash;
-  constructor(path7, configHash, points) {
+  constructor(path6, configHash, points) {
     this.points = points;
-    this.path = path7;
+    this.path = path6;
     this.configHash = configHash;
   }
   /**
@@ -1385,29 +1398,29 @@ var Checkpoint = class _Checkpoint {
    * Handles corrupted files and config changes gracefully.
    */
   static async load(options) {
-    const { path: path7, configHash } = options;
-    if (existsSync2(path7)) {
+    const { path: path6, configHash } = options;
+    if (existsSync2(path6)) {
       try {
-        const content = readFileSync(path7, "utf-8");
-        const file = JSON.parse(content);
+        const content = readFileSync(path6, "utf-8");
+        const file = checkpointFile.parse(JSON.parse(content));
         if (configHash && file.configHash && file.configHash !== configHash) {
           console.log("\u26A0 Config changed, starting fresh");
-          return new _Checkpoint(path7, configHash, {});
+          return new _Checkpoint(path6, configHash, {});
         }
-        const points = file.points ?? {};
+        const points = file.points;
         const totalEntries = Object.values(points).reduce(
           (sum, p) => sum + p.entries.length,
           0
         );
         console.log(`\u2713 Resuming from checkpoint (${totalEntries} entries)`);
-        return new _Checkpoint(path7, configHash, points);
+        return new _Checkpoint(path6, configHash, points);
       } catch {
         console.log("\u26A0 Checkpoint corrupted, starting fresh");
-        return new _Checkpoint(path7, configHash, {});
+        return new _Checkpoint(path6, configHash, {});
       }
     }
     console.log("Starting new checkpoint");
-    return new _Checkpoint(path7, configHash, {});
+    return new _Checkpoint(path6, configHash, {});
   }
   /**
    * Run a single computation with checkpointing.
@@ -1415,27 +1428,20 @@ var Checkpoint = class _Checkpoint {
    *
    * @param key - Unique identifier for this computation
    * @param computation - Async function that produces the value
-   * @param codec - Optional codec for encoding/decoding non-primitive values
+   * @param codec - Codec that stores the value and restores it on resume
    */
   async run(key, computation, codec) {
-    const point = this.point(key);
-    return point.through(
-      "single",
-      async () => {
-        const result = await computation();
-        return codec ? codec.encode(result) : result;
-      },
-      codec
-    );
+    return this.point(key, codec).through("single", computation);
   }
   /**
    * Create a resumable checkpoint point for iterative operations.
    *
    * @param step - Unique identifier for this checkpoint point
+   * @param codec - Codec that stores each output and restores it on resume
    */
-  point(step) {
+  point(step, codec) {
     this.points[step] ??= { committed: false, entries: [] };
-    return new Point(this.points[step], () => this.save());
+    return new Point(this.points[step], codec, () => this.save());
   }
   /**
    * Process each input with automatic checkpointing and concurrency.
@@ -1443,11 +1449,12 @@ var Checkpoint = class _Checkpoint {
    * @param step - Unique identifier for this checkpoint
    * @param inputs - Items to process
    * @param process - Function to process each input
+   * @param codec - Codec that stores each output and restores it on resume
    * @param options - Optional settings like concurrency
    * @returns All outputs (use `.flat()` if outputs are arrays)
    */
-  async each(step, inputs, process, options) {
-    const point = this.point(step);
+  async each(step, inputs, process, codec, options) {
+    const point = this.point(step, codec);
     const limit = pLimit(options?.concurrency ?? 1);
     const inputArray = Array.from(inputs);
     await Promise.all(
@@ -1464,11 +1471,11 @@ var Checkpoint = class _Checkpoint {
    */
   getOutput() {
     const output = {};
-    for (const [key, pointData] of Object.entries(this.points)) {
-      if (pointData.entries.length === 1) {
-        output[key] = pointData.entries[0].output;
+    for (const [key, pointData2] of Object.entries(this.points)) {
+      if (pointData2.entries.length === 1) {
+        output[key] = pointData2.entries[0].output;
       } else {
-        output[key] = pointData.entries.map((e) => e.output);
+        output[key] = pointData2.entries.map((e) => e.output);
       }
     }
     return output;
@@ -1489,34 +1496,35 @@ var Checkpoint = class _Checkpoint {
   }
 };
 function hash(value) {
-  return createHash3("md5").update(JSON.stringify(value)).digest("hex");
+  return createHash2("md5").update(JSON.stringify(value)).digest("hex");
 }
 var Point = class {
-  #cache;
+  #stored;
   data;
+  codec;
   persist;
-  constructor(data, persist) {
-    this.#cache = new Map(
-      data.entries.map((e) => [e.inputHash, e.output])
-    );
+  constructor(data, codec, persist) {
+    this.#stored = new Map(data.entries.map((e) => [e.inputHash, e.output]));
     this.data = data;
+    this.codec = codec;
     this.persist = persist;
   }
   /**
    * Execute computation if input wasn't processed before.
-   * Returns cached output if input hash exists, otherwise executes, saves, and returns.
+   * Returns the decoded stored output if input hash exists, otherwise
+   * executes, saves the encoded output, and returns the computed value.
    */
-  async through(input, compute, codec) {
+  async through(input, compute) {
     const inputHash = hash(input);
-    if (this.#cache.has(inputHash)) {
-      const cached = this.#cache.get(inputHash);
-      return codec ? codec.decode(cached) : cached;
+    if (this.#stored.has(inputHash)) {
+      return this.codec.decode(this.#stored.get(inputHash));
     }
-    const output = await compute();
+    const value = await compute();
+    const output = this.codec.encode(value);
     this.data.entries.push({ inputHash, output });
-    this.#cache.set(inputHash, output);
+    this.#stored.set(inputHash, output);
     await this.persist();
-    return codec ? codec.decode(output) : output;
+    return value;
   }
   /** Mark this point as complete. */
   async commit() {
@@ -1529,21 +1537,50 @@ var Point = class {
   }
   /** Get all outputs from this point. */
   values() {
-    return this.data.entries.map((e) => e.output);
+    return this.data.entries.map((e) => this.codec.decode(e.output));
   }
 };
 function hashConfig(config) {
-  return createHash3("md5").update(JSON.stringify(config)).digest("hex");
+  return createHash2("md5").update(JSON.stringify(config)).digest("hex");
 }
 
 // packages/text2sql/src/lib/fs/sqlite/sqlite-fs.ts
-import * as path3 from "node:path";
+import * as path2 from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import z6 from "zod";
+
+// packages/text2sql/src/lib/fs/columns.ts
+import z5 from "zod";
+var entryType = z5.enum(["file", "directory", "symlink"]);
+var bigintColumn = z5.union([z5.number(), z5.string().regex(/^-?\d+$/)]).transform(Number);
 
 // packages/text2sql/src/lib/fs/sqlite/ddl.sqlite-fs.sql
 var ddl_sqlite_fs_default = "-- SQLite-based filesystem schema for artifact storage\n-- Tables: fs_entries (file/directory metadata), fs_chunks (file content)\n\n-- Performance PRAGMAs (session-level, run on each connection)\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA cache_size = -64000;\nPRAGMA temp_store = MEMORY;\nPRAGMA mmap_size = 268435456;\n\n-- Integrity\nPRAGMA foreign_keys = ON;\n\n-- Filesystem entries table (files, directories, symlinks)\nCREATE TABLE IF NOT EXISTS fs_entries (\n  path TEXT PRIMARY KEY,            -- Normalized absolute path (e.g., '/results/uuid.json')\n  type TEXT NOT NULL,               -- 'file' | 'directory' | 'symlink'\n  mode INTEGER NOT NULL,            -- Unix permissions (e.g., 0o644 = 420)\n  size INTEGER NOT NULL,            -- File size in bytes (0 for directories)\n  mtime INTEGER NOT NULL,           -- Modified time (milliseconds since epoch)\n  symlinkTarget TEXT                -- Target path for symlinks (NULL for files/dirs)\n);\n\nCREATE INDEX IF NOT EXISTS idx_fs_entries_type ON fs_entries(type);\n\n-- File content chunks table (for handling large files)\n-- Files are split into 1MB chunks to avoid SQLite BLOB performance issues\nCREATE TABLE IF NOT EXISTS fs_chunks (\n  path TEXT NOT NULL,               -- Reference to fs_entries.path\n  chunkIndex INTEGER NOT NULL,      -- 0-based chunk sequence\n  data BLOB NOT NULL,               -- Chunk content (up to 1MB default)\n  PRIMARY KEY (path, chunkIndex),\n  FOREIGN KEY (path) REFERENCES fs_entries(path) ON DELETE CASCADE ON UPDATE CASCADE\n);\n";
 
 // packages/text2sql/src/lib/fs/sqlite/sqlite-fs.ts
+var entryRow = z6.object({
+  path: z6.string(),
+  type: entryType,
+  mode: z6.number(),
+  size: z6.number(),
+  mtime: z6.number(),
+  symlinkTarget: z6.string().nullable()
+});
+var typeRow = entryRow.pick({ type: true });
+var pathRow = entryRow.pick({ path: true });
+var pathTypeRow = entryRow.pick({ path: true, type: true });
+var linkRow = z6.discriminatedUnion("type", [
+  z6.object({ type: z6.literal("symlink"), symlinkTarget: z6.string() }),
+  z6.object({
+    type: z6.enum(["file", "directory"]),
+    symlinkTarget: z6.string().nullable()
+  })
+]);
+var chunkRow = z6.object({
+  chunkIndex: z6.number(),
+  data: z6.instanceof(Uint8Array)
+});
+var dataRow = chunkRow.pick({ data: true });
 var SqliteFs = class {
   #db;
   #statements = /* @__PURE__ */ new Map();
@@ -1585,7 +1622,7 @@ var SqliteFs = class {
     const segments = p.split("/").filter(Boolean);
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
-      currentPath = path3.posix.join(currentPath, segments[i]);
+      currentPath = path2.posix.join(currentPath, segments[i]);
       const exists = this.#stmt("SELECT 1 FROM fs_entries WHERE path = ?").get(
         currentPath
       );
@@ -1606,7 +1643,7 @@ var SqliteFs = class {
     return stmt;
   }
   #normalizeRoot(root) {
-    return path3.posix.resolve("/", root.trim());
+    return path2.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -1615,7 +1652,7 @@ var SqliteFs = class {
     if (p === "/") {
       return this.#root;
     }
-    return path3.posix.join(this.#root, p);
+    return path2.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -1636,23 +1673,26 @@ var SqliteFs = class {
       this.#db.exec("COMMIT");
       return result;
     } catch (error) {
-      this.#db.exec("ROLLBACK");
+      try {
+        this.#db.exec("ROLLBACK");
+      } catch {
+      }
       throw error;
     }
   }
   #normalizePath(p) {
-    return path3.posix.resolve("/", p);
+    return path2.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path3.posix.dirname(p);
+    const dir = path2.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   #ensureParentExists(filePath) {
     const parent = this.#dirname(filePath);
     const rootPath = this.#root || "/";
     if (parent === rootPath || parent === "/") return;
-    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
-      parent
+    const entry = typeRow.optional().parse(
+      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(parent)
     );
     if (!entry) {
       this.#ensureParentExists(parent);
@@ -1676,10 +1716,19 @@ var SqliteFs = class {
       ).run(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
+      )
+    );
+  }
   #readChunks(filePath) {
-    const rows = this.#stmt(
-      "SELECT data FROM fs_chunks WHERE path = ? ORDER BY chunkIndex"
-    ).all(filePath);
+    const rows = z6.array(dataRow).parse(
+      this.#stmt(
+        "SELECT data FROM fs_chunks WHERE path = ? ORDER BY chunkIndex"
+      ).all(filePath)
+    );
     if (rows.length === 0) {
       return new Uint8Array(0);
     }
@@ -1696,9 +1745,11 @@ var SqliteFs = class {
     if (seen.has(p)) {
       throw new Error(`readFile: circular symlink: ${p}`);
     }
-    const entry = this.#stmt(
-      "SELECT type, symlinkTarget FROM fs_entries WHERE path = ?"
-    ).get(p);
+    const entry = linkRow.optional().parse(
+      this.#stmt(
+        "SELECT type, symlinkTarget FROM fs_entries WHERE path = ?"
+      ).get(p)
+    );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${p}`);
     }
@@ -1707,7 +1758,7 @@ var SqliteFs = class {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path3.posix.resolve(this.#dirname(p), entry.symlinkTarget)
+      path2.posix.resolve(this.#dirname(p), entry.symlinkTarget)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -1715,8 +1766,7 @@ var SqliteFs = class {
     if (content instanceof Uint8Array) {
       return content;
     }
-    const enc = encoding ?? "utf8";
-    return new Uint8Array(Buffer.from(content, enc));
+    return new Uint8Array(Buffer.from(content, encoding ?? "utf8"));
   }
   // ============================================================================
   // IFileSystem Implementation
@@ -1725,8 +1775,8 @@ var SqliteFs = class {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
-    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
-      resolved
+    const entry = typeRow.optional().parse(
+      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(resolved)
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
@@ -1742,8 +1792,8 @@ var SqliteFs = class {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
-    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
-      resolved
+    const entry = typeRow.optional().parse(
+      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(resolved)
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
@@ -1778,9 +1828,11 @@ var SqliteFs = class {
     const newData = this.#toUint8Array(content, encoding);
     this.#useTransaction(() => {
       this.#ensureParentExists(prefixed);
-      const entry = this.#stmt(
-        "SELECT type FROM fs_entries WHERE path = ?"
-      ).get(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}`);
       }
@@ -1810,8 +1862,8 @@ var SqliteFs = class {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
-    const entry = this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(
-      resolved
+    const entry = entryRow.optional().parse(
+      this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(resolved)
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
@@ -1829,8 +1881,8 @@ var SqliteFs = class {
   async lstat(filePath) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
-    const entry = this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(
-      prefixed
+    const entry = entryRow.optional().parse(
+      this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(prefixed)
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
@@ -1847,9 +1899,9 @@ var SqliteFs = class {
   async mkdir(dirPath, options) {
     const normalized = this.#normalizePath(dirPath);
     const prefixed = this.#prefixPath(normalized);
-    const existing = this.#stmt(
-      "SELECT type FROM fs_entries WHERE path = ?"
-    ).get(prefixed);
+    const existing = typeRow.optional().parse(
+      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(prefixed)
+    );
     if (existing) {
       if (options?.recursive) {
         return;
@@ -1859,14 +1911,16 @@ var SqliteFs = class {
     this.#useTransaction(() => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path3.posix.relative(rootPath, prefixed);
+        const relativePath = path2.posix.relative(rootPath, prefixed);
         const segments = relativePath.split("/").filter(Boolean);
         let currentPath = rootPath;
         for (const segment of segments) {
-          currentPath = path3.posix.join(currentPath, segment);
-          const exists = this.#stmt(
-            "SELECT type FROM fs_entries WHERE path = ?"
-          ).get(currentPath);
+          currentPath = path2.posix.join(currentPath, segment);
+          const exists = typeRow.optional().parse(
+            this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
+              currentPath
+            )
+          );
           if (!exists) {
             this.#stmt(
               `INSERT INTO fs_entries (path, type, mode, size, mtime)
@@ -1878,9 +1932,11 @@ var SqliteFs = class {
         }
       } else {
         const parent = this.#dirname(prefixed);
-        const parentEntry = this.#stmt(
-          "SELECT type FROM fs_entries WHERE path = ?"
-        ).get(parent);
+        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}`);
         }
@@ -1898,8 +1954,8 @@ var SqliteFs = class {
     const normalized = this.#normalizePath(dirPath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
-    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
-      resolved
+    const entry = typeRow.optional().parse(
+      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(resolved)
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
@@ -1908,20 +1964,22 @@ var SqliteFs = class {
       throw new Error(`ENOTDIR: not a directory: ${dirPath}`);
     }
     const prefix = resolved === "/" ? "/" : resolved + "/";
-    const rows = this.#stmt(
-      `SELECT path FROM fs_entries
+    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);
-    return rows.map((row) => path3.posix.basename(row.path));
+      ).all(prefix, resolved, prefix)
+    );
+    return rows.map((row) => path2.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = this.#resolveSymlink(prefixed);
-    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
-      resolved
+    const entry = typeRow.optional().parse(
+      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(resolved)
     );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
@@ -1930,14 +1988,16 @@ var SqliteFs = class {
       throw new Error(`ENOTDIR: not a directory: ${dirPath}`);
     }
     const prefix = resolved === "/" ? "/" : resolved + "/";
-    const rows = this.#stmt(
-      `SELECT path, type FROM fs_entries
+    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);
+      ).all(prefix, resolved, prefix)
+    );
     return rows.map((row) => ({
-      name: path3.posix.basename(row.path),
+      name: path2.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -1946,8 +2006,8 @@ var SqliteFs = class {
   async rm(filePath, options) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
-    const entry = this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(
-      prefixed
+    const entry = typeRow.optional().parse(
+      this.#stmt("SELECT type FROM fs_entries WHERE path = ?").get(prefixed)
     );
     if (!entry) {
       if (options?.force) {
@@ -1976,8 +2036,8 @@ var SqliteFs = class {
     const destNormalized = this.#normalizePath(dest);
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
-    const srcEntry = this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(
-      srcPrefixed
+    const srcEntry = entryRow.optional().parse(
+      this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(srcPrefixed)
     );
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${src}`);
@@ -1988,12 +2048,14 @@ var SqliteFs = class {
     this.#useTransaction(() => {
       this.#ensureParentExists(destPrefixed);
       if (srcEntry.type === "directory") {
-        const allEntries = this.#stmt(
-          `SELECT * FROM fs_entries WHERE path = ? OR path LIKE ? || '/%'`
-        ).all(srcPrefixed, srcPrefixed);
+        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 = path3.posix.relative(srcPrefixed, entry.path);
-          const newPath = path3.posix.join(destPrefixed, relativePath);
+          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 (?, ?, ?, ?, ?, ?)`
@@ -2006,9 +2068,7 @@ var SqliteFs = class {
             entry.symlinkTarget
           );
           if (entry.type === "file") {
-            const chunks = this.#stmt(
-              "SELECT chunkIndex, data FROM fs_chunks WHERE path = ?"
-            ).all(entry.path);
+            const chunks = this.#chunks(entry.path);
             for (const chunk of chunks) {
               this.#stmt(
                 "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
@@ -2029,9 +2089,7 @@ var SqliteFs = class {
           srcEntry.symlinkTarget
         );
         if (srcEntry.type === "file") {
-          const chunks = this.#stmt(
-            "SELECT chunkIndex, data FROM fs_chunks WHERE path = ?"
-          ).all(srcPrefixed);
+          const chunks = this.#chunks(srcPrefixed);
           this.#stmt("DELETE FROM fs_chunks WHERE path = ?").run(destPrefixed);
           for (const chunk of chunks) {
             this.#stmt(
@@ -2047,8 +2105,8 @@ var SqliteFs = class {
     const destNormalized = this.#normalizePath(dest);
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
-    const srcEntry = this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(
-      srcPrefixed
+    const srcEntry = entryRow.optional().parse(
+      this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(srcPrefixed)
     );
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${src}`);
@@ -2056,12 +2114,14 @@ var SqliteFs = class {
     this.#useTransaction(() => {
       this.#ensureParentExists(destPrefixed);
       if (srcEntry.type === "directory") {
-        const allEntries = this.#stmt(
-          `SELECT * FROM fs_entries WHERE path = ? OR path LIKE ? || '/%' ORDER BY path DESC`
-        ).all(srcPrefixed, srcPrefixed);
+        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 = path3.posix.relative(srcPrefixed, entry.path);
-          const newPath = path3.posix.join(destPrefixed, relativePath);
+          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 (?, ?, ?, ?, ?, ?)`
@@ -2074,9 +2134,7 @@ var SqliteFs = class {
             entry.symlinkTarget
           );
           if (entry.type === "file") {
-            const chunks = this.#stmt(
-              "SELECT chunkIndex, data FROM fs_chunks WHERE path = ?"
-            ).all(entry.path);
+            const chunks = this.#chunks(entry.path);
             for (const chunk of chunks) {
               this.#stmt(
                 "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
@@ -2100,9 +2158,7 @@ var SqliteFs = class {
           srcEntry.symlinkTarget
         );
         if (srcEntry.type === "file") {
-          const chunks = this.#stmt(
-            "SELECT chunkIndex, data FROM fs_chunks WHERE path = ?"
-          ).all(srcPrefixed);
+          const chunks = this.#chunks(srcPrefixed);
           for (const chunk of chunks) {
             this.#stmt(
               "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
@@ -2114,12 +2170,10 @@ var SqliteFs = class {
     });
   }
   resolvePath(base, relativePath) {
-    return path3.posix.resolve(base, relativePath);
+    return path2.posix.resolve(base, relativePath);
   }
   getAllPaths() {
-    const rows = this.#stmt(
-      "SELECT path FROM fs_entries ORDER BY path"
-    ).all();
+    const rows = z6.array(pathRow).parse(this.#stmt("SELECT path FROM fs_entries ORDER BY path").all());
     return rows.map((row) => row.path);
   }
   async realpath(filePath) {
@@ -2177,8 +2231,8 @@ var SqliteFs = class {
     const destNormalized = this.#normalizePath(newPath);
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
-    const srcEntry = this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(
-      srcPrefixed
+    const srcEntry = entryRow.optional().parse(
+      this.#stmt("SELECT * FROM fs_entries WHERE path = ?").get(srcPrefixed)
     );
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${existingPath}`);
@@ -2198,9 +2252,7 @@ var SqliteFs = class {
         `INSERT INTO fs_entries (path, type, mode, size, mtime)
          VALUES (?, 'file', ?, ?, ?)`
       ).run(destPrefixed, srcEntry.mode, srcEntry.size, Date.now());
-      const chunks = this.#stmt(
-        "SELECT chunkIndex, data FROM fs_chunks WHERE path = ?"
-      ).all(srcPrefixed);
+      const chunks = this.#chunks(srcPrefixed);
       for (const chunk of chunks) {
         this.#stmt(
           "INSERT INTO fs_chunks (path, chunkIndex, data) VALUES (?, ?, ?)"
@@ -2211,9 +2263,11 @@ var SqliteFs = class {
   async readlink(linkPath) {
     const normalized = this.#normalizePath(linkPath);
     const prefixed = this.#prefixPath(normalized);
-    const entry = this.#stmt(
-      "SELECT type, symlinkTarget FROM fs_entries WHERE path = ?"
-    ).get(prefixed);
+    const entry = linkRow.optional().parse(
+      this.#stmt(
+        "SELECT type, symlinkTarget FROM fs_entries WHERE path = ?"
+      ).get(prefixed)
+    );
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${linkPath}`);
     }
@@ -2226,7 +2280,8 @@ var SqliteFs = class {
 
 // packages/text2sql/src/lib/fs/mssql/mssql-fs.ts
 import { createRequire } from "node:module";
-import * as path4 from "node:path";
+import * as path3 from "node:path";
+import z7 from "zod";
 
 // packages/text2sql/src/lib/fs/mssql/ddl.mssql-fs.ts
 function mssqlFsDDL(schema) {
@@ -2259,6 +2314,33 @@ GO
 }
 
 // packages/text2sql/src/lib/fs/mssql/mssql-fs.ts
+var entryRow2 = z7.object({
+  path: z7.string(),
+  type: entryType,
+  mode: z7.number(),
+  size: bigintColumn,
+  mtime: bigintColumn,
+  symlinkTarget: z7.string().nullable()
+});
+var typeRow2 = entryRow2.pick({ type: true });
+var pathRow2 = entryRow2.pick({ path: true });
+var pathTypeRow2 = entryRow2.pick({ path: true, type: true });
+var linkRow2 = z7.discriminatedUnion("type", [
+  z7.object({ type: z7.literal("symlink"), symlinkTarget: z7.string() }),
+  z7.object({
+    type: z7.enum(["file", "directory"]),
+    symlinkTarget: z7.string().nullable()
+  })
+]);
+var existsRow = z7.object({ exists: z7.union([z7.literal(0), z7.literal(1)]) });
+var chunkRow2 = z7.object({
+  chunkIndex: z7.number(),
+  data: z7.instanceof(Buffer)
+});
+var dataRow2 = chunkRow2.pick({ data: true });
+function rowsOf(row, result) {
+  return z7.array(row).parse(result.recordset);
+}
 var MssqlFs = class _MssqlFs {
   #pool;
   #chunkSize;
@@ -2317,8 +2399,11 @@ var MssqlFs = class _MssqlFs {
         await this.#pool.request().batch(batch);
       }
     }
-    const rootSlashExists = await this.#rawQuery(
-      `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = '/') THEN 1 ELSE 0 END as [exists]`
+    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(
@@ -2328,9 +2413,12 @@ var MssqlFs = class _MssqlFs {
     }
     if (this.#root) {
       await this.#createParentDirs(this.#root);
-      const rootExists = 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]
+      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(
@@ -2352,10 +2440,13 @@ var MssqlFs = class _MssqlFs {
     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 = 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]
+      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(
@@ -2365,13 +2456,12 @@ var MssqlFs = class _MssqlFs {
       }
     }
   }
-  async #rawQuery(sql, params) {
+  #rawQuery(sql, params) {
     const request = this.#pool.request();
     params?.forEach((value, index2) => {
       request.input(`p${index2}`, value);
     });
-    const result = await request.query(sql);
-    return result.recordset;
+    return request.query(sql);
   }
   async #rawExec(sql, params) {
     const request = this.#pool.request();
@@ -2404,7 +2494,7 @@ var MssqlFs = class _MssqlFs {
     }
   }
   #normalizeRoot(root) {
-    return path4.posix.resolve("/", root.trim());
+    return path3.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -2413,7 +2503,7 @@ var MssqlFs = class _MssqlFs {
     if (p === "/") {
       return this.#root;
     }
-    return path4.posix.join(this.#root, p);
+    return path3.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -2428,10 +2518,10 @@ var MssqlFs = class _MssqlFs {
     return p;
   }
   #normalizePath(p) {
-    return path4.posix.resolve("/", p);
+    return path3.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path4.posix.dirname(p);
+    const dir = path3.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   async #ensureParentExists(filePath, transaction) {
@@ -2440,10 +2530,12 @@ var MssqlFs = class _MssqlFs {
     if (parent === rootPath || parent === "/") return;
     const request = transaction.request();
     request.input("p0", parent);
-    const result = await request.query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`
+    const [entry] = rowsOf(
+      typeRow2,
+      await request.query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`
+      )
     );
-    const entry = result.recordset[0];
     if (!entry) {
       await this.#ensureParentExists(parent, transaction);
       const insertReq = transaction.request();
@@ -2477,20 +2569,11 @@ var MssqlFs = class _MssqlFs {
     }
   }
   async #readChunks(filePath, transaction) {
-    let rows;
-    if (transaction) {
-      const req = transaction.request();
-      req.input("p0", filePath);
-      const result2 = await req.query(
-        `SELECT data FROM ${this.#t("fs_chunks")} WHERE path = @p0 ORDER BY chunkIndex`
-      );
-      rows = result2.recordset;
-    } else {
-      rows = await this.#query(
-        `SELECT data FROM ${this.#t("fs_chunks")} WHERE path = @p0 ORDER BY chunkIndex`,
-        [filePath]
-      );
-    }
+    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])
+    );
     if (rows.length === 0) {
       return new Uint8Array(0);
     }
@@ -2507,11 +2590,13 @@ var MssqlFs = class _MssqlFs {
     if (seen.has(p)) {
       throw new Error(`readFile: circular symlink: ${p}`);
     }
-    const rows = await this.#query(
-      `SELECT type, symlinkTarget FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [p]
+    const [entry] = rowsOf(
+      linkRow2,
+      await this.#query(
+        `SELECT type, symlinkTarget FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [p]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${p}`);
     }
@@ -2520,7 +2605,7 @@ var MssqlFs = class _MssqlFs {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path4.posix.resolve(this.#dirname(p), entry.symlinkTarget)
+      path3.posix.resolve(this.#dirname(p), entry.symlinkTarget)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -2528,8 +2613,7 @@ var MssqlFs = class _MssqlFs {
     if (content instanceof Uint8Array) {
       return content;
     }
-    const enc = encoding ?? "utf8";
-    return new Uint8Array(Buffer.from(content, enc));
+    return new Uint8Array(Buffer.from(content, encoding ?? "utf8"));
   }
   async close() {
     if (this.#ownsPool) {
@@ -2543,11 +2627,13 @@ var MssqlFs = class _MssqlFs {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const rows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [resolved]
+    const [entry] = rowsOf(
+      typeRow2,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [resolved]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -2562,11 +2648,13 @@ var MssqlFs = class _MssqlFs {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const rows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [resolved]
+    const [entry] = rowsOf(
+      typeRow2,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [resolved]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -2608,10 +2696,12 @@ var MssqlFs = class _MssqlFs {
       await this.#ensureParentExists(prefixed, transaction);
       const checkReq = transaction.request();
       checkReq.input("p0", prefixed);
-      const result = await checkReq.query(
-        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`
+      const [entry] = rowsOf(
+        typeRow2,
+        await checkReq.query(
+          `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`
+        )
       );
-      const entry = result.recordset[0];
       if (entry && entry.type !== "file") {
         throw new Error(`appendFile: not a file: ${filePath}`);
       }
@@ -2639,9 +2729,12 @@ var MssqlFs = class _MssqlFs {
   async exists(filePath) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
-    const rows = await this.#query(
-      `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
-      [prefixed]
+    const rows = rowsOf(
+      existsRow,
+      await this.#query(
+        `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
+        [prefixed]
+      )
     );
     return rows[0].exists === 1;
   }
@@ -2649,11 +2742,13 @@ var MssqlFs = class _MssqlFs {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const rows = await this.#query(
-      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [resolved]
+    const [entry] = rowsOf(
+      entryRow2,
+      await this.#query(
+        `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [resolved]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -2661,19 +2756,21 @@ var MssqlFs = class _MssqlFs {
       isFile: entry.type === "file",
       isDirectory: entry.type === "directory",
       isSymbolicLink: false,
-      mode: Number(entry.mode),
-      size: Number(entry.size),
-      mtime: new Date(Number(entry.mtime))
+      mode: entry.mode,
+      size: entry.size,
+      mtime: new Date(entry.mtime)
     };
   }
   async lstat(filePath) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
-    const rows = await this.#query(
-      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [prefixed]
+    const [entry] = rowsOf(
+      entryRow2,
+      await this.#query(
+        `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [prefixed]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -2681,19 +2778,21 @@ var MssqlFs = class _MssqlFs {
       isFile: entry.type === "file",
       isDirectory: entry.type === "directory",
       isSymbolicLink: entry.type === "symlink",
-      mode: Number(entry.mode),
-      size: Number(entry.size),
-      mtime: new Date(Number(entry.mtime))
+      mode: entry.mode,
+      size: entry.size,
+      mtime: new Date(entry.mtime)
     };
   }
   async mkdir(dirPath, options) {
     const normalized = this.#normalizePath(dirPath);
     const prefixed = this.#prefixPath(normalized);
-    const existingRows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [prefixed]
+    const [existing] = rowsOf(
+      typeRow2,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [prefixed]
+      )
     );
-    const existing = existingRows[0];
     if (existing) {
       if (options?.recursive) {
         return;
@@ -2703,17 +2802,19 @@ var MssqlFs = class _MssqlFs {
     await this.#useTransaction(async (transaction) => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path4.posix.relative(rootPath, prefixed);
+        const relativePath = path3.posix.relative(rootPath, prefixed);
         const segments = relativePath.split("/").filter(Boolean);
         let currentPath = rootPath;
         for (const segment of segments) {
-          currentPath = path4.posix.join(currentPath, segment);
+          currentPath = path3.posix.join(currentPath, segment);
           const checkReq = transaction.request();
           checkReq.input("p0", currentPath);
-          const result = await checkReq.query(
-            `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`
+          const [exists] = rowsOf(
+            typeRow2,
+            await checkReq.query(
+              `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`
+            )
           );
-          const exists = result.recordset[0];
           if (!exists) {
             const insertReq = transaction.request();
             insertReq.input("p0", currentPath);
@@ -2729,10 +2830,12 @@ var MssqlFs = class _MssqlFs {
         const parent = this.#dirname(prefixed);
         const parentReq = transaction.request();
         parentReq.input("p0", parent);
-        const parentResult = await parentReq.query(
-          `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`
+        const [parentEntry] = rowsOf(
+          typeRow2,
+          await parentReq.query(
+            `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`
+          )
         );
-        const parentEntry = parentResult.recordset[0];
         if (!parentEntry) {
           throw new Error(`mkdir: parent does not exist: ${parent}`);
         }
@@ -2752,11 +2855,13 @@ var MssqlFs = class _MssqlFs {
     const normalized = this.#normalizePath(dirPath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const entryRows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [resolved]
+    const [entry] = rowsOf(
+      typeRow2,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [resolved]
+      )
     );
-    const entry = entryRows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
     }
@@ -2764,24 +2869,29 @@ var MssqlFs = class _MssqlFs {
       throw new Error(`ENOTDIR: not a directory: ${dirPath}`);
     }
     const prefix = resolved === "/" ? "/" : resolved + "/";
-    const rows = await this.#query(
-      `SELECT path FROM ${this.#t("fs_entries")}
+    const rows = rowsOf(
+      pathRow2,
+      await this.#query(
+        `SELECT path FROM ${this.#t("fs_entries")}
        WHERE path LIKE @p0 + '%'
          AND path != @p1
          AND path NOT LIKE @p0 + '%/%'`,
-      [prefix, resolved]
+        [prefix, resolved]
+      )
     );
-    return rows.map((row) => path4.posix.basename(row.path));
+    return rows.map((row) => path3.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const entryRows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [resolved]
+    const [entry] = rowsOf(
+      typeRow2,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [resolved]
+      )
     );
-    const entry = entryRows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
     }
@@ -2789,15 +2899,18 @@ var MssqlFs = class _MssqlFs {
       throw new Error(`ENOTDIR: not a directory: ${dirPath}`);
     }
     const prefix = resolved === "/" ? "/" : resolved + "/";
-    const rows = await this.#query(
-      `SELECT path, type FROM ${this.#t("fs_entries")}
+    const rows = rowsOf(
+      pathTypeRow2,
+      await this.#query(
+        `SELECT path, type FROM ${this.#t("fs_entries")}
        WHERE path LIKE @p0 + '%'
          AND path != @p1
          AND path NOT LIKE @p0 + '%/%'`,
-      [prefix, resolved]
+        [prefix, resolved]
+      )
     );
     return rows.map((row) => ({
-      name: path4.posix.basename(row.path),
+      name: path3.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -2806,11 +2919,13 @@ var MssqlFs = class _MssqlFs {
   async rm(filePath, options) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
-    const rows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [prefixed]
+    const [entry] = rowsOf(
+      typeRow2,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [prefixed]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       if (options?.force) {
         return;
@@ -2821,10 +2936,13 @@ var MssqlFs = class _MssqlFs {
       if (entry.type === "directory") {
         const childrenReq = transaction.request();
         childrenReq.input("p0", prefixed);
-        const childrenResult = await childrenReq.query(
-          `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path LIKE @p0 + '/%') THEN 1 ELSE 0 END as [exists]`
+        const children = rowsOf(
+          existsRow,
+          await childrenReq.query(
+            `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path LIKE @p0 + '/%') THEN 1 ELSE 0 END as [exists]`
+          )
         );
-        if (childrenResult.recordset[0].exists === 1 && !options?.recursive) {
+        if (children[0].exists === 1 && !options?.recursive) {
           throw new Error(`ENOTEMPTY: directory not empty: ${filePath}`);
         }
         const deleteReq = transaction.request();
@@ -2846,11 +2964,13 @@ var MssqlFs = class _MssqlFs {
     const destNormalized = this.#normalizePath(dest);
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
-    const srcRows = await this.#query(
-      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [srcPrefixed]
+    const [srcEntry] = rowsOf(
+      entryRow2,
+      await this.#query(
+        `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [srcPrefixed]
+      )
     );
-    const srcEntry = srcRows[0];
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${src}`);
     }
@@ -2862,12 +2982,15 @@ var MssqlFs = class _MssqlFs {
       if (srcEntry.type === "directory") {
         const allEntriesReq = transaction.request();
         allEntriesReq.input("p0", srcPrefixed);
-        const allEntriesResult = await allEntriesReq.query(
-          `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0 OR path LIKE @p0 + '/%'`
+        const allEntries = rowsOf(
+          entryRow2,
+          await allEntriesReq.query(
+            `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0 OR path LIKE @p0 + '/%'`
+          )
         );
-        for (const entry of allEntriesResult.recordset) {
-          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
-          const newPath = path4.posix.join(destPrefixed, relativePath);
+        for (const entry of allEntries) {
+          const relativePath = path3.posix.relative(srcPrefixed, entry.path);
+          const newPath = path3.posix.join(destPrefixed, relativePath);
           const insertReq = transaction.request();
           insertReq.input("p0", newPath);
           insertReq.input("p1", entry.type);
@@ -2893,10 +3016,13 @@ var MssqlFs = class _MssqlFs {
             );
             const chunksReq = transaction.request();
             chunksReq.input("p0", entry.path);
-            const chunksResult = await chunksReq.query(
-              `SELECT chunkIndex, data FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+            const chunks = rowsOf(
+              chunkRow2,
+              await chunksReq.query(
+                `SELECT chunkIndex, data FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+              )
             );
-            for (const chunk of chunksResult.recordset) {
+            for (const chunk of chunks) {
               const chunkInsertReq = transaction.request();
               chunkInsertReq.input("p0", newPath);
               chunkInsertReq.input("p1", chunk.chunkIndex);
@@ -2928,15 +3054,18 @@ var MssqlFs = class _MssqlFs {
         if (srcEntry.type === "file") {
           const chunksReq = transaction.request();
           chunksReq.input("p0", srcPrefixed);
-          const chunksResult = await chunksReq.query(
-            `SELECT chunkIndex, data FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+          const chunks = rowsOf(
+            chunkRow2,
+            await chunksReq.query(
+              `SELECT chunkIndex, data FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+            )
           );
           const deleteChunksReq = transaction.request();
           deleteChunksReq.input("p0", destPrefixed);
           await deleteChunksReq.query(
             `DELETE FROM ${this.#t("fs_chunks")} WHERE path = @p0`
           );
-          for (const chunk of chunksResult.recordset) {
+          for (const chunk of chunks) {
             const chunkInsertReq = transaction.request();
             chunkInsertReq.input("p0", destPrefixed);
             chunkInsertReq.input("p1", chunk.chunkIndex);
@@ -2954,11 +3083,13 @@ var MssqlFs = class _MssqlFs {
     const destNormalized = this.#normalizePath(dest);
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
-    const srcRows = await this.#query(
-      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [srcPrefixed]
+    const [srcEntry] = rowsOf(
+      entryRow2,
+      await this.#query(
+        `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [srcPrefixed]
+      )
     );
-    const srcEntry = srcRows[0];
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${src}`);
     }
@@ -2967,17 +3098,20 @@ var MssqlFs = class _MssqlFs {
       if (srcEntry.type === "directory") {
         const allEntriesReq = transaction.request();
         allEntriesReq.input("p0", srcPrefixed);
-        const allEntriesResult = await allEntriesReq.query(
-          `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0 OR path LIKE @p0 + '/%' ORDER BY path DESC`
+        const allEntries = rowsOf(
+          entryRow2,
+          await allEntriesReq.query(
+            `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0 OR path LIKE @p0 + '/%' ORDER BY path DESC`
+          )
         );
         const destDeleteReq = transaction.request();
         destDeleteReq.input("dp0", destPrefixed);
         await destDeleteReq.query(
           `DELETE FROM ${this.#t("fs_entries")} WHERE path = @dp0 OR path LIKE @dp0 + '/%'`
         );
-        for (const entry of [...allEntriesResult.recordset].reverse()) {
-          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
-          const newPath = path4.posix.join(destPrefixed, relativePath);
+        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();
           insertReq.input("p0", newPath);
           insertReq.input("p1", entry.type);
@@ -3003,10 +3137,13 @@ var MssqlFs = class _MssqlFs {
             );
             const chunksReq = transaction.request();
             chunksReq.input("p0", entry.path);
-            const chunksResult = await chunksReq.query(
-              `SELECT chunkIndex, data FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+            const chunks = rowsOf(
+              chunkRow2,
+              await chunksReq.query(
+                `SELECT chunkIndex, data FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+              )
             );
-            for (const chunk of chunksResult.recordset) {
+            for (const chunk of chunks) {
               const chunkInsertReq = transaction.request();
               chunkInsertReq.input("p0", newPath);
               chunkInsertReq.input("p1", chunk.chunkIndex);
@@ -3048,10 +3185,13 @@ var MssqlFs = class _MssqlFs {
           );
           const chunksReq = transaction.request();
           chunksReq.input("p0", srcPrefixed);
-          const chunksResult = await chunksReq.query(
-            `SELECT chunkIndex, data FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+          const chunks = rowsOf(
+            chunkRow2,
+            await chunksReq.query(
+              `SELECT chunkIndex, data FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+            )
           );
-          for (const chunk of chunksResult.recordset) {
+          for (const chunk of chunks) {
             const chunkInsertReq = transaction.request();
             chunkInsertReq.input("p0", destPrefixed);
             chunkInsertReq.input("p1", chunk.chunkIndex);
@@ -3070,7 +3210,7 @@ var MssqlFs = class _MssqlFs {
     });
   }
   resolvePath(base, relativePath) {
-    return path4.posix.resolve(base, relativePath);
+    return path3.posix.resolve(base, relativePath);
   }
   getAllPaths() {
     throw new Error(
@@ -3078,8 +3218,11 @@ var MssqlFs = class _MssqlFs {
     );
   }
   async getAllPathsAsync() {
-    const rows = await this.#query(
-      `SELECT path FROM ${this.#t("fs_entries")} ORDER BY path`
+    const rows = rowsOf(
+      pathRow2,
+      await this.#query(
+        `SELECT path FROM ${this.#t("fs_entries")} ORDER BY path`
+      )
     );
     return rows.map((row) => row.path);
   }
@@ -3087,9 +3230,12 @@ var MssqlFs = class _MssqlFs {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const rows = await this.#query(
-      `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
-      [resolved]
+    const rows = rowsOf(
+      existsRow,
+      await this.#query(
+        `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
+        [resolved]
+      )
     );
     if (rows[0].exists !== 1) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
@@ -3122,9 +3268,12 @@ var MssqlFs = class _MssqlFs {
   async symlink(target, linkPath) {
     const normalized = this.#normalizePath(linkPath);
     const prefixed = this.#prefixPath(normalized);
-    const existingRows = await this.#query(
-      `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
-      [prefixed]
+    const existingRows = rowsOf(
+      existsRow,
+      await this.#query(
+        `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
+        [prefixed]
+      )
     );
     if (existingRows[0].exists === 1) {
       throw new Error(`EEXIST: file already exists: ${linkPath}`);
@@ -3146,20 +3295,25 @@ var MssqlFs = class _MssqlFs {
     const destNormalized = this.#normalizePath(newPath);
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
-    const srcRows = await this.#query(
-      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [srcPrefixed]
+    const [srcEntry] = rowsOf(
+      entryRow2,
+      await this.#query(
+        `SELECT * FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [srcPrefixed]
+      )
     );
-    const srcEntry = srcRows[0];
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${existingPath}`);
     }
     if (srcEntry.type !== "file") {
       throw new Error(`link: not supported for directories: ${existingPath}`);
     }
-    const existingRows = await this.#query(
-      `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
-      [destPrefixed]
+    const existingRows = rowsOf(
+      existsRow,
+      await this.#query(
+        `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
+        [destPrefixed]
+      )
     );
     if (existingRows[0].exists === 1) {
       throw new Error(`EEXIST: file already exists: ${newPath}`);
@@ -3177,10 +3331,13 @@ var MssqlFs = class _MssqlFs {
       );
       const chunksReq = transaction.request();
       chunksReq.input("p0", srcPrefixed);
-      const chunksResult = await chunksReq.query(
-        `SELECT chunkIndex, data FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+      const chunks = rowsOf(
+        chunkRow2,
+        await chunksReq.query(
+          `SELECT chunkIndex, data FROM ${this.#t("fs_chunks")} WHERE path = @p0`
+        )
       );
-      for (const chunk of chunksResult.recordset) {
+      for (const chunk of chunks) {
         const chunkInsertReq = transaction.request();
         chunkInsertReq.input("p0", destPrefixed);
         chunkInsertReq.input("p1", chunk.chunkIndex);
@@ -3194,11 +3351,13 @@ var MssqlFs = class _MssqlFs {
   async readlink(linkPath) {
     const normalized = this.#normalizePath(linkPath);
     const prefixed = this.#prefixPath(normalized);
-    const rows = await this.#query(
-      `SELECT type, symlinkTarget FROM ${this.#t("fs_entries")} WHERE path = @p0`,
-      [prefixed]
+    const [entry] = rowsOf(
+      linkRow2,
+      await this.#query(
+        `SELECT type, symlinkTarget FROM ${this.#t("fs_entries")} WHERE path = @p0`,
+        [prefixed]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${linkPath}`);
     }
@@ -3211,7 +3370,8 @@ var MssqlFs = class _MssqlFs {
 
 // packages/text2sql/src/lib/fs/postgres/postgres-fs.ts
 import { createRequire as createRequire2 } from "node:module";
-import * as path5 from "node:path";
+import * as path4 from "node:path";
+import z8 from "zod";
 
 // packages/text2sql/src/lib/fs/postgres/ddl.postgres-fs.ts
 function postgresFsDDL(schema) {
@@ -3240,6 +3400,33 @@ CREATE TABLE IF NOT EXISTS "${schema}"."fs_chunks" (
 }
 
 // packages/text2sql/src/lib/fs/postgres/postgres-fs.ts
+var entryRow3 = z8.object({
+  path: z8.string(),
+  type: entryType,
+  mode: z8.number(),
+  size: bigintColumn,
+  mtime: bigintColumn,
+  symlink_target: z8.string().nullable()
+});
+var typeRow3 = entryRow3.pick({ type: true });
+var pathRow3 = entryRow3.pick({ path: true });
+var pathTypeRow3 = entryRow3.pick({ path: true, type: true });
+var linkRow3 = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("symlink"), symlink_target: z8.string() }),
+  z8.object({
+    type: z8.enum(["file", "directory"]),
+    symlink_target: z8.string().nullable()
+  })
+]);
+var existsRow2 = z8.object({ exists: z8.boolean() });
+var chunkRow3 = z8.object({
+  chunk_index: z8.number(),
+  data: z8.instanceof(Buffer)
+});
+var dataRow3 = chunkRow3.pick({ data: true });
+function rowsOf2(row, result) {
+  return z8.array(row).parse(result.rows);
+}
 var PostgresFs = class _PostgresFs {
   #pool;
   #chunkSize;
@@ -3281,8 +3468,11 @@ var PostgresFs = class _PostgresFs {
   async initialize() {
     const ddl = postgresFsDDL(this.#schema);
     await this.#pool.query(ddl);
-    const rootSlashExists = await this.#rawQuery(
-      `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = '/') AS exists`
+    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(
@@ -3292,9 +3482,12 @@ var PostgresFs = class _PostgresFs {
     }
     if (this.#root) {
       await this.#createParentDirs(this.#root);
-      const rootExists = await this.#rawQuery(
-        `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
-        [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(
@@ -3316,10 +3509,13 @@ var PostgresFs = class _PostgresFs {
     const segments = p.split("/").filter(Boolean);
     let currentPath = "/";
     for (let i = 0; i < segments.length - 1; i++) {
-      currentPath = path5.posix.join(currentPath, segments[i]);
-      const exists = await this.#rawQuery(
-        `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
-        [currentPath]
+      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(
@@ -3329,9 +3525,8 @@ var PostgresFs = class _PostgresFs {
       }
     }
   }
-  async #rawQuery(sql, params) {
-    const result = await this.#pool.query(sql, params);
-    return result.rows;
+  #rawQuery(sql, params) {
+    return this.#pool.query(sql, params);
   }
   async #rawExec(sql, params) {
     const result = await this.#pool.query(sql, params);
@@ -3361,7 +3556,7 @@ var PostgresFs = class _PostgresFs {
     }
   }
   #normalizeRoot(root) {
-    return path5.posix.resolve("/", root.trim());
+    return path4.posix.resolve("/", root.trim());
   }
   #prefixPath(p) {
     if (!this.#root) {
@@ -3370,7 +3565,7 @@ var PostgresFs = class _PostgresFs {
     if (p === "/") {
       return this.#root;
     }
-    return path5.posix.join(this.#root, p);
+    return path4.posix.join(this.#root, p);
   }
   #unprefixPath(p) {
     if (!this.#root) {
@@ -3385,21 +3580,23 @@ var PostgresFs = class _PostgresFs {
     return p;
   }
   #normalizePath(p) {
-    return path5.posix.resolve("/", p);
+    return path4.posix.resolve("/", p);
   }
   #dirname(p) {
-    const dir = path5.posix.dirname(p);
+    const dir = path4.posix.dirname(p);
     return dir === "" ? "/" : dir;
   }
   async #ensureParentExists(filePath, client) {
     const parent = this.#dirname(filePath);
     const rootPath = this.#root || "/";
     if (parent === rootPath || parent === "/") return;
-    const result = await client.query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [parent]
+    const [entry] = rowsOf2(
+      typeRow3,
+      await client.query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [parent]
+      )
     );
-    const entry = result.rows[0];
     if (!entry) {
       await this.#ensureParentExists(parent, client);
       await client.query(
@@ -3426,19 +3623,11 @@ var PostgresFs = class _PostgresFs {
     }
   }
   async #readChunks(filePath, client) {
-    let rows;
-    if (client) {
-      const result2 = await client.query(
-        `SELECT data FROM ${this.#t("fs_chunks")} WHERE path = $1 ORDER BY chunk_index`,
-        [filePath]
-      );
-      rows = result2.rows;
-    } else {
-      rows = await this.#query(
-        `SELECT data FROM ${this.#t("fs_chunks")} WHERE path = $1 ORDER BY chunk_index`,
-        [filePath]
-      );
-    }
+    const sql = `SELECT data FROM ${this.#t("fs_chunks")} WHERE path = $1 ORDER BY chunk_index`;
+    const rows = rowsOf2(
+      dataRow3,
+      client ? await client.query(sql, [filePath]) : await this.#query(sql, [filePath])
+    );
     if (rows.length === 0) {
       return new Uint8Array(0);
     }
@@ -3455,11 +3644,13 @@ var PostgresFs = class _PostgresFs {
     if (seen.has(p)) {
       throw new Error(`readFile: circular symlink: ${p}`);
     }
-    const rows = await this.#query(
-      `SELECT type, symlink_target FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [p]
+    const [entry] = rowsOf2(
+      linkRow3,
+      await this.#query(
+        `SELECT type, symlink_target FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [p]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${p}`);
     }
@@ -3468,7 +3659,7 @@ var PostgresFs = class _PostgresFs {
     }
     seen.add(p);
     const target = this.#normalizePath(
-      path5.posix.resolve(this.#dirname(p), entry.symlink_target)
+      path4.posix.resolve(this.#dirname(p), entry.symlink_target)
     );
     return this.#resolveSymlink(target, seen);
   }
@@ -3476,8 +3667,7 @@ var PostgresFs = class _PostgresFs {
     if (content instanceof Uint8Array) {
       return content;
     }
-    const enc = encoding ?? "utf8";
-    return new Uint8Array(Buffer.from(content, enc));
+    return new Uint8Array(Buffer.from(content, encoding ?? "utf8"));
   }
   async close() {
     if (this.#ownsPool) {
@@ -3491,11 +3681,13 @@ var PostgresFs = class _PostgresFs {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const rows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [resolved]
+    const [entry] = rowsOf2(
+      typeRow3,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [resolved]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -3510,11 +3702,13 @@ var PostgresFs = class _PostgresFs {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const rows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [resolved]
+    const [entry] = rowsOf2(
+      typeRow3,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [resolved]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -3546,11 +3740,13 @@ var PostgresFs = class _PostgresFs {
     const newData = this.#toUint8Array(content, encoding);
     await this.#useTransaction(async (client) => {
       await this.#ensureParentExists(prefixed, client);
-      const result = await client.query(
-        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
-        [prefixed]
+      const [entry] = rowsOf2(
+        typeRow3,
+        await client.query(
+          `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+          [prefixed]
+        )
       );
-      const entry = result.rows[0];
       if (entry && entry.type !== "file") {
         throw new Error(`appendFile: not a file: ${filePath}`);
       }
@@ -3570,9 +3766,12 @@ var PostgresFs = class _PostgresFs {
   async exists(filePath) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
-    const rows = await this.#query(
-      `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
-      [prefixed]
+    const rows = rowsOf2(
+      existsRow2,
+      await this.#query(
+        `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
+        [prefixed]
+      )
     );
     return rows[0].exists;
   }
@@ -3580,11 +3779,13 @@ var PostgresFs = class _PostgresFs {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const rows = await this.#query(
-      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [resolved]
+    const [entry] = rowsOf2(
+      entryRow3,
+      await this.#query(
+        `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [resolved]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -3592,19 +3793,21 @@ var PostgresFs = class _PostgresFs {
       isFile: entry.type === "file",
       isDirectory: entry.type === "directory",
       isSymbolicLink: false,
-      mode: Number(entry.mode),
-      size: Number(entry.size),
-      mtime: new Date(Number(entry.mtime))
+      mode: entry.mode,
+      size: entry.size,
+      mtime: new Date(entry.mtime)
     };
   }
   async lstat(filePath) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
-    const rows = await this.#query(
-      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [prefixed]
+    const [entry] = rowsOf2(
+      entryRow3,
+      await this.#query(
+        `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [prefixed]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
     }
@@ -3612,19 +3815,21 @@ var PostgresFs = class _PostgresFs {
       isFile: entry.type === "file",
       isDirectory: entry.type === "directory",
       isSymbolicLink: entry.type === "symlink",
-      mode: Number(entry.mode),
-      size: Number(entry.size),
-      mtime: new Date(Number(entry.mtime))
+      mode: entry.mode,
+      size: entry.size,
+      mtime: new Date(entry.mtime)
     };
   }
   async mkdir(dirPath, options) {
     const normalized = this.#normalizePath(dirPath);
     const prefixed = this.#prefixPath(normalized);
-    const existingRows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [prefixed]
+    const [existing] = rowsOf2(
+      typeRow3,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [prefixed]
+      )
     );
-    const existing = existingRows[0];
     if (existing) {
       if (options?.recursive) {
         return;
@@ -3634,16 +3839,18 @@ var PostgresFs = class _PostgresFs {
     await this.#useTransaction(async (client) => {
       if (options?.recursive) {
         const rootPath = this.#root || "/";
-        const relativePath = path5.posix.relative(rootPath, prefixed);
+        const relativePath = path4.posix.relative(rootPath, prefixed);
         const segments = relativePath.split("/").filter(Boolean);
         let currentPath = rootPath;
         for (const segment of segments) {
-          currentPath = path5.posix.join(currentPath, segment);
-          const result = await client.query(
-            `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
-            [currentPath]
+          currentPath = path4.posix.join(currentPath, segment);
+          const [exists] = rowsOf2(
+            typeRow3,
+            await client.query(
+              `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+              [currentPath]
+            )
           );
-          const exists = result.rows[0];
           if (!exists) {
             await client.query(
               `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
@@ -3655,11 +3862,13 @@ var PostgresFs = class _PostgresFs {
         }
       } else {
         const parent = this.#dirname(prefixed);
-        const parentResult = await client.query(
-          `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
-          [parent]
+        const [parentEntry] = rowsOf2(
+          typeRow3,
+          await client.query(
+            `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+            [parent]
+          )
         );
-        const parentEntry = parentResult.rows[0];
         if (!parentEntry) {
           throw new Error(`mkdir: parent does not exist: ${parent}`);
         }
@@ -3677,11 +3886,13 @@ var PostgresFs = class _PostgresFs {
     const normalized = this.#normalizePath(dirPath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const entryRows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [resolved]
+    const [entry] = rowsOf2(
+      typeRow3,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [resolved]
+      )
     );
-    const entry = entryRows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
     }
@@ -3689,24 +3900,29 @@ var PostgresFs = class _PostgresFs {
       throw new Error(`ENOTDIR: not a directory: ${dirPath}`);
     }
     const prefix = resolved === "/" ? "/" : resolved + "/";
-    const rows = await this.#query(
-      `SELECT path FROM ${this.#t("fs_entries")}
+    const rows = rowsOf2(
+      pathRow3,
+      await this.#query(
+        `SELECT path FROM ${this.#t("fs_entries")}
        WHERE path LIKE $1 || '%'
          AND path != $2
          AND path NOT LIKE $1 || '%/%'`,
-      [prefix, resolved]
+        [prefix, resolved]
+      )
     );
-    return rows.map((row) => path5.posix.basename(row.path));
+    return rows.map((row) => path4.posix.basename(row.path));
   }
   async readdirWithFileTypes(dirPath) {
     const normalized = this.#normalizePath(dirPath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const entryRows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [resolved]
+    const [entry] = rowsOf2(
+      typeRow3,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [resolved]
+      )
     );
-    const entry = entryRows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${dirPath}`);
     }
@@ -3714,15 +3930,18 @@ var PostgresFs = class _PostgresFs {
       throw new Error(`ENOTDIR: not a directory: ${dirPath}`);
     }
     const prefix = resolved === "/" ? "/" : resolved + "/";
-    const rows = await this.#query(
-      `SELECT path, type FROM ${this.#t("fs_entries")}
+    const rows = rowsOf2(
+      pathTypeRow3,
+      await this.#query(
+        `SELECT path, type FROM ${this.#t("fs_entries")}
        WHERE path LIKE $1 || '%'
          AND path != $2
          AND path NOT LIKE $1 || '%/%'`,
-      [prefix, resolved]
+        [prefix, resolved]
+      )
     );
     return rows.map((row) => ({
-      name: path5.posix.basename(row.path),
+      name: path4.posix.basename(row.path),
       isFile: row.type === "file",
       isDirectory: row.type === "directory",
       isSymbolicLink: row.type === "symlink"
@@ -3731,11 +3950,13 @@ var PostgresFs = class _PostgresFs {
   async rm(filePath, options) {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
-    const rows = await this.#query(
-      `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [prefixed]
+    const [entry] = rowsOf2(
+      typeRow3,
+      await this.#query(
+        `SELECT type FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [prefixed]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       if (options?.force) {
         return;
@@ -3744,11 +3965,14 @@ var PostgresFs = class _PostgresFs {
     }
     await this.#useTransaction(async (client) => {
       if (entry.type === "directory") {
-        const childrenResult = await client.query(
-          `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path LIKE $1 || '/%') AS exists`,
-          [prefixed]
+        const children = rowsOf2(
+          existsRow2,
+          await client.query(
+            `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path LIKE $1 || '/%') AS exists`,
+            [prefixed]
+          )
         );
-        if (childrenResult.rows[0].exists && !options?.recursive) {
+        if (children[0].exists && !options?.recursive) {
           throw new Error(`ENOTEMPTY: directory not empty: ${filePath}`);
         }
         await client.query(
@@ -3768,11 +3992,13 @@ var PostgresFs = class _PostgresFs {
     const destNormalized = this.#normalizePath(dest);
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
-    const srcRows = await this.#query(
-      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [srcPrefixed]
+    const [srcEntry] = rowsOf2(
+      entryRow3,
+      await this.#query(
+        `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [srcPrefixed]
+      )
     );
-    const srcEntry = srcRows[0];
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${src}`);
     }
@@ -3782,13 +4008,16 @@ var PostgresFs = class _PostgresFs {
     await this.#useTransaction(async (client) => {
       await this.#ensureParentExists(destPrefixed, client);
       if (srcEntry.type === "directory") {
-        const allEntriesResult = await client.query(
-          `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1 OR path LIKE $1 || '/%'`,
-          [srcPrefixed]
+        const allEntries = rowsOf2(
+          entryRow3,
+          await client.query(
+            `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1 OR path LIKE $1 || '/%'`,
+            [srcPrefixed]
+          )
         );
-        for (const entry of allEntriesResult.rows) {
-          const relativePath = path5.posix.relative(srcPrefixed, entry.path);
-          const newPath = path5.posix.join(destPrefixed, relativePath);
+        for (const entry of allEntries) {
+          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
+          const newPath = path4.posix.join(destPrefixed, relativePath);
           await client.query(
             `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime, symlink_target)
              VALUES ($1, $2, $3, $4, $5, $6)
@@ -3807,11 +4036,14 @@ var PostgresFs = class _PostgresFs {
               `DELETE FROM ${this.#t("fs_chunks")} WHERE path = $1`,
               [newPath]
             );
-            const chunksResult = await client.query(
-              `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
-              [entry.path]
+            const chunks = rowsOf2(
+              chunkRow3,
+              await client.query(
+                `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+                [entry.path]
+              )
             );
-            for (const chunk of chunksResult.rows) {
+            for (const chunk of chunks) {
               await client.query(
                 `INSERT INTO ${this.#t("fs_chunks")} (path, chunk_index, data) VALUES ($1, $2, $3)`,
                 [newPath, chunk.chunk_index, chunk.data]
@@ -3834,15 +4066,18 @@ var PostgresFs = class _PostgresFs {
           ]
         );
         if (srcEntry.type === "file") {
-          const chunksResult = await client.query(
-            `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
-            [srcPrefixed]
+          const chunks = rowsOf2(
+            chunkRow3,
+            await client.query(
+              `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+              [srcPrefixed]
+            )
           );
           await client.query(
             `DELETE FROM ${this.#t("fs_chunks")} WHERE path = $1`,
             [destPrefixed]
           );
-          for (const chunk of chunksResult.rows) {
+          for (const chunk of chunks) {
             await client.query(
               `INSERT INTO ${this.#t("fs_chunks")} (path, chunk_index, data) VALUES ($1, $2, $3)`,
               [destPrefixed, chunk.chunk_index, chunk.data]
@@ -3857,28 +4092,33 @@ var PostgresFs = class _PostgresFs {
     const destNormalized = this.#normalizePath(dest);
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
-    const srcRows = await this.#query(
-      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [srcPrefixed]
+    const [srcEntry] = rowsOf2(
+      entryRow3,
+      await this.#query(
+        `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [srcPrefixed]
+      )
     );
-    const srcEntry = srcRows[0];
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${src}`);
     }
     await this.#useTransaction(async (client) => {
       await this.#ensureParentExists(destPrefixed, client);
       if (srcEntry.type === "directory") {
-        const allEntriesResult = await client.query(
-          `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1 OR path LIKE $1 || '/%' ORDER BY path DESC`,
-          [srcPrefixed]
+        const allEntries = rowsOf2(
+          entryRow3,
+          await client.query(
+            `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1 OR path LIKE $1 || '/%' ORDER BY path DESC`,
+            [srcPrefixed]
+          )
         );
         await client.query(
           `DELETE FROM ${this.#t("fs_entries")} WHERE path = $1 OR path LIKE $1 || '/%'`,
           [destPrefixed]
         );
-        for (const entry of [...allEntriesResult.rows].reverse()) {
-          const relativePath = path5.posix.relative(srcPrefixed, entry.path);
-          const newPath = path5.posix.join(destPrefixed, relativePath);
+        for (const entry of [...allEntries].reverse()) {
+          const relativePath = path4.posix.relative(srcPrefixed, entry.path);
+          const newPath = path4.posix.join(destPrefixed, relativePath);
           await client.query(
             `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime, symlink_target)
              VALUES ($1, $2, $3, $4, $5, $6)
@@ -3897,11 +4137,14 @@ var PostgresFs = class _PostgresFs {
               `DELETE FROM ${this.#t("fs_chunks")} WHERE path = $1`,
               [newPath]
             );
-            const chunksResult = await client.query(
-              `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
-              [entry.path]
+            const chunks = rowsOf2(
+              chunkRow3,
+              await client.query(
+                `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+                [entry.path]
+              )
             );
-            for (const chunk of chunksResult.rows) {
+            for (const chunk of chunks) {
               await client.query(
                 `INSERT INTO ${this.#t("fs_chunks")} (path, chunk_index, data) VALUES ($1, $2, $3)`,
                 [newPath, chunk.chunk_index, chunk.data]
@@ -3932,11 +4175,14 @@ var PostgresFs = class _PostgresFs {
             `DELETE FROM ${this.#t("fs_chunks")} WHERE path = $1`,
             [destPrefixed]
           );
-          const chunksResult = await client.query(
-            `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
-            [srcPrefixed]
+          const chunks = rowsOf2(
+            chunkRow3,
+            await client.query(
+              `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+              [srcPrefixed]
+            )
           );
-          for (const chunk of chunksResult.rows) {
+          for (const chunk of chunks) {
             await client.query(
               `INSERT INTO ${this.#t("fs_chunks")} (path, chunk_index, data) VALUES ($1, $2, $3)`,
               [destPrefixed, chunk.chunk_index, chunk.data]
@@ -3951,7 +4197,7 @@ var PostgresFs = class _PostgresFs {
     });
   }
   resolvePath(base, relativePath) {
-    return path5.posix.resolve(base, relativePath);
+    return path4.posix.resolve(base, relativePath);
   }
   getAllPaths() {
     throw new Error(
@@ -3959,8 +4205,11 @@ var PostgresFs = class _PostgresFs {
     );
   }
   async getAllPathsAsync() {
-    const rows = await this.#query(
-      `SELECT path FROM ${this.#t("fs_entries")} ORDER BY path`
+    const rows = rowsOf2(
+      pathRow3,
+      await this.#query(
+        `SELECT path FROM ${this.#t("fs_entries")} ORDER BY path`
+      )
     );
     return rows.map((row) => row.path);
   }
@@ -3968,9 +4217,12 @@ var PostgresFs = class _PostgresFs {
     const normalized = this.#normalizePath(filePath);
     const prefixed = this.#prefixPath(normalized);
     const resolved = await this.#resolveSymlink(prefixed);
-    const rows = await this.#query(
-      `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
-      [resolved]
+    const rows = rowsOf2(
+      existsRow2,
+      await this.#query(
+        `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
+        [resolved]
+      )
     );
     if (!rows[0].exists) {
       throw new Error(`ENOENT: no such file or directory: ${filePath}`);
@@ -4003,9 +4255,12 @@ var PostgresFs = class _PostgresFs {
   async symlink(target, linkPath) {
     const normalized = this.#normalizePath(linkPath);
     const prefixed = this.#prefixPath(normalized);
-    const existingRows = await this.#query(
-      `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
-      [prefixed]
+    const existingRows = rowsOf2(
+      existsRow2,
+      await this.#query(
+        `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
+        [prefixed]
+      )
     );
     if (existingRows[0].exists) {
       throw new Error(`EEXIST: file already exists: ${linkPath}`);
@@ -4024,20 +4279,25 @@ var PostgresFs = class _PostgresFs {
     const destNormalized = this.#normalizePath(newPath);
     const srcPrefixed = this.#prefixPath(srcNormalized);
     const destPrefixed = this.#prefixPath(destNormalized);
-    const srcRows = await this.#query(
-      `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [srcPrefixed]
+    const [srcEntry] = rowsOf2(
+      entryRow3,
+      await this.#query(
+        `SELECT * FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [srcPrefixed]
+      )
     );
-    const srcEntry = srcRows[0];
     if (!srcEntry) {
       throw new Error(`ENOENT: no such file or directory: ${existingPath}`);
     }
     if (srcEntry.type !== "file") {
       throw new Error(`link: not supported for directories: ${existingPath}`);
     }
-    const existingRows = await this.#query(
-      `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
-      [destPrefixed]
+    const existingRows = rowsOf2(
+      existsRow2,
+      await this.#query(
+        `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
+        [destPrefixed]
+      )
     );
     if (existingRows[0].exists) {
       throw new Error(`EEXIST: file already exists: ${newPath}`);
@@ -4049,11 +4309,14 @@ var PostgresFs = class _PostgresFs {
          VALUES ($1, 'file', $2, $3, $4)`,
         [destPrefixed, srcEntry.mode, srcEntry.size, Date.now()]
       );
-      const chunksResult = await client.query(
-        `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
-        [srcPrefixed]
+      const chunks = rowsOf2(
+        chunkRow3,
+        await client.query(
+          `SELECT chunk_index, data FROM ${this.#t("fs_chunks")} WHERE path = $1`,
+          [srcPrefixed]
+        )
       );
-      for (const chunk of chunksResult.rows) {
+      for (const chunk of chunks) {
         await client.query(
           `INSERT INTO ${this.#t("fs_chunks")} (path, chunk_index, data) VALUES ($1, $2, $3)`,
           [destPrefixed, chunk.chunk_index, chunk.data]
@@ -4064,11 +4327,13 @@ var PostgresFs = class _PostgresFs {
   async readlink(linkPath) {
     const normalized = this.#normalizePath(linkPath);
     const prefixed = this.#prefixPath(normalized);
-    const rows = await this.#query(
-      `SELECT type, symlink_target FROM ${this.#t("fs_entries")} WHERE path = $1`,
-      [prefixed]
+    const [entry] = rowsOf2(
+      linkRow3,
+      await this.#query(
+        `SELECT type, symlink_target FROM ${this.#t("fs_entries")} WHERE path = $1`,
+        [prefixed]
+      )
     );
-    const entry = rows[0];
     if (!entry) {
       throw new Error(`ENOENT: no such file or directory: ${linkPath}`);
     }
@@ -4087,29 +4352,29 @@ var ScopedFs = class {
     this.#base = options.base;
     this.#prefix = options.prefix.replace(/\/$/, "");
   }
-  #scope(path7) {
-    return `${this.#prefix}${path7}`;
+  #scope(path6) {
+    return `${this.#prefix}${path6}`;
   }
-  #unscope(path7) {
-    if (path7 === this.#prefix) {
+  #unscope(path6) {
+    if (path6 === this.#prefix) {
       return "/";
     }
-    if (path7.startsWith(this.#prefix + "/")) {
-      return path7.slice(this.#prefix.length) || "/";
+    if (path6.startsWith(this.#prefix + "/")) {
+      return path6.slice(this.#prefix.length) || "/";
     }
-    return path7;
+    return path6;
   }
-  async writeFile(path7, content, options) {
-    await this.#base.writeFile(this.#scope(path7), content, options);
+  async writeFile(path6, content, options) {
+    await this.#base.writeFile(this.#scope(path6), content, options);
   }
-  async appendFile(path7, content, options) {
-    await this.#base.appendFile(this.#scope(path7), content, options);
+  async appendFile(path6, content, options) {
+    await this.#base.appendFile(this.#scope(path6), content, options);
   }
-  async mkdir(path7, options) {
-    return this.#base.mkdir(this.#scope(path7), options);
+  async mkdir(path6, options) {
+    return this.#base.mkdir(this.#scope(path6), options);
   }
-  async rm(path7, options) {
-    await this.#base.rm(this.#scope(path7), options);
+  async rm(path6, options) {
+    await this.#base.rm(this.#scope(path6), options);
   }
   async cp(src, dest, options) {
     await this.#base.cp(this.#scope(src), this.#scope(dest), options);
@@ -4117,8 +4382,8 @@ var ScopedFs = class {
   async mv(src, dest) {
     await this.#base.mv(this.#scope(src), this.#scope(dest));
   }
-  async chmod(path7, mode) {
-    return this.#base.chmod(this.#scope(path7), mode);
+  async chmod(path6, mode) {
+    return this.#base.chmod(this.#scope(path6), mode);
   }
   async symlink(target, linkPath) {
     await this.#base.symlink(target, this.#scope(linkPath));
@@ -4126,35 +4391,35 @@ var ScopedFs = class {
   async link(existingPath, newPath) {
     await this.#base.link(this.#scope(existingPath), this.#scope(newPath));
   }
-  readFile(path7, options) {
-    return this.#base.readFile(this.#scope(path7), options);
+  readFile(path6, options) {
+    return this.#base.readFile(this.#scope(path6), options);
   }
-  readFileBuffer(path7) {
-    return this.#base.readFileBuffer(this.#scope(path7));
+  readFileBuffer(path6) {
+    return this.#base.readFileBuffer(this.#scope(path6));
   }
-  stat(path7) {
-    return this.#base.stat(this.#scope(path7));
+  stat(path6) {
+    return this.#base.stat(this.#scope(path6));
   }
-  lstat(path7) {
-    return this.#base.lstat(this.#scope(path7));
+  lstat(path6) {
+    return this.#base.lstat(this.#scope(path6));
   }
-  readdir(path7) {
-    return this.#base.readdir(this.#scope(path7));
+  readdir(path6) {
+    return this.#base.readdir(this.#scope(path6));
   }
-  readdirWithFileTypes(path7) {
-    return this.#base.readdirWithFileTypes(this.#scope(path7));
+  readdirWithFileTypes(path6) {
+    return this.#base.readdirWithFileTypes(this.#scope(path6));
   }
-  exists(path7) {
-    return this.#base.exists(this.#scope(path7));
+  exists(path6) {
+    return this.#base.exists(this.#scope(path6));
   }
-  readlink(path7) {
-    return this.#base.readlink(this.#scope(path7));
+  readlink(path6) {
+    return this.#base.readlink(this.#scope(path6));
   }
-  realpath(path7) {
-    return this.#base.realpath(this.#scope(path7)).then((p) => this.#unscope(p));
+  realpath(path6) {
+    return this.#base.realpath(this.#scope(path6)).then((p) => this.#unscope(p));
   }
-  utimes(path7, atime, mtime) {
-    return this.#base.utimes(this.#scope(path7), atime, mtime);
+  utimes(path6, atime, mtime) {
+    return this.#base.utimes(this.#scope(path6), atime, mtime);
   }
   resolvePath(base, relativePath) {
     return this.#base.resolvePath(base, relativePath);
@@ -4577,18 +4842,17 @@ import { BashTransformPipeline } from "just-bash";
 
 // packages/text2sql/src/lib/agents/sql-transform-plugins.ts
 import { parse as parse2, serialize } from "just-bash";
-import { createHash as createHash4 } from "node:crypto";
-import * as path6 from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import * as path5 from "node:path";
 import {
   BashException,
   asStaticWordText as asStaticWordText2
 } from "@deepagents/context";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
 function isScriptNode(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const node = value;
-  return node.type === "Script" && Array.isArray(node.statements);
+  return isRecord(value) && value.type === "Script" && Array.isArray(value.statements);
 }
 var BLOCKED_DB_CLIENT_COMMANDS = /* @__PURE__ */ new Set([
   "psql",
@@ -4678,11 +4942,7 @@ function wordContainsBlockedCommand(word, context, mode) {
   if (!word) {
     return false;
   }
-  return wordPartContainsBlockedCommand(
-    word.parts,
-    context,
-    mode
-  );
+  return wordPartContainsBlockedCommand(word.parts, context, mode);
 }
 function wordPartContainsBlockedCommand(parts, context, mode) {
   for (const part of parts) {
@@ -4693,6 +4953,9 @@ function wordPartContainsBlockedCommand(parts, context, mode) {
   return false;
 }
 function partContainsBlockedCommand(node, context, mode) {
+  if (!isRecord(node)) {
+    return false;
+  }
   const type = node.type;
   if (type === "CommandSubstitution" || type === "ProcessSubstitution") {
     if (isScriptNode(node.body)) {
@@ -4709,27 +4972,13 @@ function partContainsBlockedCommand(node, context, mode) {
   }
   for (const value of Object.values(node)) {
     if (Array.isArray(value)) {
-      for (const item of value) {
-        if (typeof item === "object" && item !== null) {
-          if (partContainsBlockedCommand(
-            item,
-            context,
-            mode
-          )) {
-            return true;
-          }
-        }
+      if (wordPartContainsBlockedCommand(value, context, mode)) {
+        return true;
       }
       continue;
     }
-    if (typeof value === "object" && value !== null) {
-      if (partContainsBlockedCommand(
-        value,
-        context,
-        mode
-      )) {
-        return true;
-      }
+    if (partContainsBlockedCommand(value, context, mode)) {
+      return true;
     }
   }
   return false;
@@ -5072,11 +5321,7 @@ function isBlockedSimpleCommand(command, context, mode, options) {
   }
   if (command.redirections.some((redirection) => {
     if (redirection.target.type === "Word") {
-      return wordContainsBlockedCommand(
-        redirection.target,
-        context,
-        mode
-      );
+      return wordContainsBlockedCommand(redirection.target, context, mode);
     }
     if (redirection.target.type === "HereDoc" && redirection.target.content) {
       return wordContainsBlockedCommand(
@@ -5093,7 +5338,7 @@ function isBlockedSimpleCommand(command, context, mode, options) {
   if (!commandName) {
     return false;
   }
-  const normalizedName = path6.posix.basename(commandName).toLowerCase();
+  const normalizedName = path5.posix.basename(commandName).toLowerCase();
   if (BLOCKED_DB_CLIENT_COMMANDS.has(normalizedName)) {
     return true;
   }
@@ -5213,10 +5458,8 @@ function wordPartsContainExpansion(parts) {
     if (part.type === "CommandSubstitution" || part.type === "ParameterExpansion" || part.type === "ArithmeticExpansion") {
       return true;
     }
-    if (part.type === "DoubleQuoted" && Array.isArray(part.parts)) {
-      if (wordPartsContainExpansion(part.parts)) {
-        return true;
-      }
+    if (part.type === "DoubleQuoted" && wordPartsContainExpansion(part.parts)) {
+      return true;
     }
   }
   return false;
@@ -5232,38 +5475,33 @@ function isSqlCommandRequiringRewrite(cmd) {
   if (!isValidAdapterName(dbName)) return false;
   const sqlArgs = cmd.args.slice(2);
   if (sqlArgs.length > 1) return true;
-  return sqlArgs.some(
-    (arg) => wordPartsContainExpansion(
-      arg.parts
-    )
-  );
+  return sqlArgs.some((arg) => wordPartsContainExpansion(arg.parts));
 }
 function extractWordPartText(parts) {
-  let text = "";
-  for (const part of parts) {
-    const type = part.type;
-    if (type === "Literal" || type === "SingleQuoted" || type === "Escaped") {
-      text += part.value;
-    } else if (type === "DoubleQuoted" && Array.isArray(part.parts)) {
-      text += extractWordPartText(part.parts);
-    } else if (type === "CommandSubstitution" && part.legacy === true) {
-      text += "`" + serialize(part.body).trim() + "`";
-    } else if (type === "CommandSubstitution") {
-      text += "$(" + serialize(part.body).trim() + ")";
-    } else if (type === "ParameterExpansion") {
-      text += emitParameterExpansion(part);
-    } else if (type === "ArithmeticExpansion") {
-      const expression = part.expression;
-      text += "$((" + (expression?.originalText ?? "") + "))";
-    }
-  }
-  return text;
+  return parts.map(wordPartText).join("");
+}
+function wordPartText(part) {
+  switch (part.type) {
+    case "Literal":
+    case "SingleQuoted":
+    case "Escaped":
+      return part.value;
+    case "DoubleQuoted":
+      return extractWordPartText(part.parts);
+    case "CommandSubstitution":
+      return part.legacy ? "`" + serialize(part.body).trim() + "`" : "$(" + serialize(part.body).trim() + ")";
+    case "ParameterExpansion":
+      return emitParameterExpansion(part);
+    case "ArithmeticExpansion":
+      return "$((" + (part.expression.originalText ?? "") + "))";
+    default:
+      return "";
+  }
 }
 function emitParameterExpansion(part) {
-  const parameter = part.parameter;
-  const operation = part.operation;
+  const { parameter, operation } = part;
   if (!operation) return "$" + parameter;
-  if (operation.type === "DefaultValue" && operation.word) {
+  if (operation.type === "DefaultValue") {
     const fallback = extractWordPartText(operation.word.parts);
     const separator = operation.checkEmpty ? ":-" : "-";
     return "${" + parameter + separator + fallback + "}";
@@ -5271,18 +5509,14 @@ function emitParameterExpansion(part) {
   return "${" + parameter + "}";
 }
 function extractSqlText(args) {
-  return args.map(
-    (arg) => extractWordPartText(
-      arg.parts
-    )
-  ).join(" ");
+  return args.map((arg) => extractWordPartText(arg.parts)).join(" ");
 }
 function rewriteSqlCommand(cmd, ast) {
   const subcommand = asStaticWordText2(cmd.args[0]);
   const dbName = asStaticWordText2(cmd.args[1]);
   const sqlArgs = cmd.args.slice(2);
   const unquotedSql = extractSqlText(sqlArgs);
-  const hash2 = createHash4("sha256").update(serialize(ast)).digest("hex").slice(0, 12);
+  const hash2 = createHash3("sha256").update(serialize(ast)).digest("hex").slice(0, 12);
   const sqlPath = `/tmp/sql-inline-${subcommand}-${hash2}.sql`;
   const heredocTag = `SQL_${hash2.toUpperCase()}`;
   const groupScript = [
@@ -5394,7 +5628,6 @@ import {
 } from "@deepagents/context";
 
 // packages/text2sql/src/lib/sql.ts
-import "@deepagents/agent";
 var text2SqlValidationMarker = /* @__PURE__ */ Symbol("Text2SqlValidationError");
 var text2SqlUnknownAdapterMarker = /* @__PURE__ */ Symbol("Text2SqlUnknownAdapterError");
 var Text2SqlValidationError = class _Text2SqlValidationError extends Error {
@@ -5455,8 +5688,7 @@ var Text2Sql = class {
     this.#config = config;
     this.#indexer = new AdapterIndexer({
       adapters: config.adapters,
-      cache: config.cache,
-      lock: config.lock
+      cache: config.cache
     });
   }
   #requireAdapter(name) {
@@ -5466,13 +5698,6 @@ var Text2Sql = class {
     }
     return adapter;
   }
-  #requireModel(op) {
-    const model = this.#config.model;
-    if (!model) {
-      throw new Error(`Text2Sql.${op}() requires a model in Text2SqlConfig`);
-    }
-    return model;
-  }
   adapterNames() {
     return Object.keys(this.#config.adapters);
   }
@@ -5514,8 +5739,10 @@ var Text2Sql = class {
     if (!Array.isArray(result)) {
       throw new Error("adapter.execute must return an array of rows");
     }
-    const columns = result.length > 0 ? Object.keys(result[0]) : [];
-    return { rows: result, columns };
+    const rows = result;
+    const [first] = rows;
+    const columns = typeof first === "object" && first !== null ? Object.keys(first) : [];
+    return { rows, columns };
   }
   async #validateWith(adapter, sql) {
     const formatted = adapter.format(sql);
@@ -5529,18 +5756,6 @@ var Text2Sql = class {
       onProgress: options.onProgress
     });
   }
-  async toSql(input, adapterName) {
-    const adapter = this.#requireAdapter(adapterName);
-    const model = this.#requireModel("toSql");
-    const fragments = await this.#indexer.indexAdapter(adapterName);
-    const result = await toSql({
-      input,
-      adapter,
-      fragments,
-      model
-    });
-    return result.sql;
-  }
   async toPairs(adapterName, factory) {
     const adapter = this.#requireAdapter(adapterName);
     const producer = factory(adapter);
@@ -5679,15 +5894,13 @@ function extractSqlInvocation(command) {
   return parseSqlQueryInvocation(repairSqlCommand(command));
 }
 function inputCommand(input) {
-  return input?.command;
+  return typeof input === "object" && input !== null && "command" in input ? input.command : void 0;
 }
 function alreadyValidated(messages, run) {
   for (const message of messages ?? []) {
     for (const part of message.parts) {
       if (!isToolUIPart(part)) continue;
-      const invocation = extractSqlInvocation(
-        inputCommand(part.input)
-      );
+      const invocation = extractSqlInvocation(inputCommand(part.input));
       if (invocation?.subcommand === "validate" && invocation.dbName === run.dbName && invocation.sql === run.sql) {
         return true;
       }
@@ -5718,7 +5931,6 @@ export {
   Checkpoint,
   FileCache,
   FileIndexCache,
-  FileIndexLock,
   JsonCache,
   MssqlFs,
   Point,
@@ -5745,10 +5957,12 @@ export {
   filterRelationshipsByTables,
   filterTablesByName,
   getTablesWithRelated,
+  groundingFor,
   hashConfig,
   index,
   instructions,
   isValidAdapterName,
+  jsonCodec,
   matchesFilter,
   relationship,
   repairSqlCommand,