@deepagents/text2sql 7.0.1 → 7.1.0

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 path7 of paths) {
+      const rows = path7.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((path7) => `result.${path7}`).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,9 +1196,12 @@ var FileIndexCache = class {
   }
   #cacheFor(key) {
     const watermark = this.#namespace ? `${this.#namespace}-${key}` : key;
-    return new JsonCache(watermark, this.#dir);
+    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/index-lock.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -1371,6 +1432,20 @@ function errorMessage(error) {
 import { createHash as createHash3 } 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;
@@ -1389,12 +1464,12 @@ var Checkpoint = class _Checkpoint {
     if (existsSync2(path7)) {
       try {
         const content = readFileSync(path7, "utf-8");
-        const file = JSON.parse(content);
+        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, {});
         }
-        const points = file.points ?? {};
+        const points = file.points;
         const totalEntries = Object.values(points).reduce(
           (sum, p) => sum + p.entries.length,
           0
@@ -1415,27 +1490,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 +1511,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 +1533,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;
@@ -1492,31 +1561,32 @@ function hash(value) {
   return createHash3("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,7 +1599,7 @@ 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) {
@@ -1539,11 +1609,40 @@ function hashConfig(config) {
 // packages/text2sql/src/lib/fs/sqlite/sqlite-fs.ts
 import * as path3 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();
@@ -1651,8 +1750,8 @@ var SqliteFs = class {
     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 +1775,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 +1804,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}`);
     }
@@ -1715,8 +1825,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 +1834,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 +1851,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 +1887,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 +1921,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 +1940,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 +1958,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;
@@ -1864,9 +1975,11 @@ var SqliteFs = class {
         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);
+          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 +1991,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 +2013,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 +2023,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);
+      ).all(prefix, resolved, prefix)
+    );
     return rows.map((row) => path3.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,12 +2047,14 @@ 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),
       isFile: row.type === "file",
@@ -1946,8 +2065,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 +2095,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,9 +2107,11 @@ 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);
@@ -2006,9 +2127,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 +2148,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 +2164,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,9 +2173,11 @@ 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);
@@ -2074,9 +2193,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 +2217,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 (?, ?, ?)"
@@ -2117,9 +2232,7 @@ var SqliteFs = class {
     return path3.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 +2290,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 +2311,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 +2322,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}`);
     }
@@ -2227,6 +2340,7 @@ var SqliteFs = class {
 // packages/text2sql/src/lib/fs/mssql/mssql-fs.ts
 import { createRequire } from "node:module";
 import * as path4 from "node:path";
+import z7 from "zod";
 
 // packages/text2sql/src/lib/fs/mssql/ddl.mssql-fs.ts
 function mssqlFsDDL(schema) {
@@ -2259,6 +2373,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 +2458,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 +2472,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(
@@ -2353,9 +2500,12 @@ var MssqlFs = class _MssqlFs {
     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]
+      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 +2515,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();
@@ -2440,10 +2589,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 +2628,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 +2649,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}`);
     }
@@ -2528,8 +2672,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 +2686,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 +2707,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 +2755,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 +2788,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 +2801,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 +2815,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 +2837,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;
@@ -2710,10 +2868,12 @@ var MssqlFs = class _MssqlFs {
           currentPath = path4.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 +2889,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 +2914,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,12 +2928,15 @@ 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));
   }
@@ -2777,11 +2944,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}`);
     }
@@ -2789,12 +2958,15 @@ 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),
@@ -2806,11 +2978,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 +2995,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 +3023,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,10 +3041,13 @@ 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) {
+        for (const entry of allEntries) {
           const relativePath = path4.posix.relative(srcPrefixed, entry.path);
           const newPath = path4.posix.join(destPrefixed, relativePath);
           const insertReq = transaction.request();
@@ -2893,10 +3075,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 +3113,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 +3142,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,15 +3157,18 @@ 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()) {
+        for (const entry of [...allEntries].reverse()) {
           const relativePath = path4.posix.relative(srcPrefixed, entry.path);
           const newPath = path4.posix.join(destPrefixed, relativePath);
           const insertReq = transaction.request();
@@ -3003,10 +3196,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 +3244,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);
@@ -3078,8 +3277,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 +3289,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 +3327,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 +3354,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 +3390,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 +3410,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}`);
     }
@@ -3212,6 +3430,7 @@ 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 z8 from "zod";
 
 // packages/text2sql/src/lib/fs/postgres/ddl.postgres-fs.ts
 function postgresFsDDL(schema) {
@@ -3240,6 +3459,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 +3527,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 +3541,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(
@@ -3317,9 +3569,12 @@ var PostgresFs = class _PostgresFs {
     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]
+      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 +3584,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);
@@ -3395,11 +3649,13 @@ var PostgresFs = class _PostgresFs {
     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 +3682,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 +3703,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}`);
     }
@@ -3476,8 +3726,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 +3740,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 +3761,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 +3799,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 +3825,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 +3838,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 +3852,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 +3874,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;
@@ -3639,11 +3903,13 @@ var PostgresFs = class _PostgresFs {
         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]
+          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 +3921,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 +3945,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,12 +3959,15 @@ 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));
   }
@@ -3702,11 +3975,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}`);
     }
@@ -3714,12 +3989,15 @@ 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),
@@ -3731,11 +4009,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 +4024,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 +4051,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,11 +4067,14 @@ 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) {
+        for (const entry of allEntries) {
           const relativePath = path5.posix.relative(srcPrefixed, entry.path);
           const newPath = path5.posix.join(destPrefixed, relativePath);
           await client.query(
@@ -3807,11 +4095,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 +4125,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,26 +4151,31 @@ 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()) {
+        for (const entry of [...allEntries].reverse()) {
           const relativePath = path5.posix.relative(srcPrefixed, entry.path);
           const newPath = path5.posix.join(destPrefixed, relativePath);
           await client.query(
@@ -3897,11 +4196,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 +4234,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]
@@ -3959,8 +4264,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 +4276,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 +4314,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 +4338,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 +4368,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 +4386,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}`);
     }
@@ -4583,12 +4907,11 @@ 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 +5001,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 +5012,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 +5031,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 +5380,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(
@@ -5213,10 +5517,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 +5534,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,11 +5568,7 @@ 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]);
@@ -5514,8 +5807,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);
@@ -5679,15 +5974,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;
       }
@@ -5745,10 +6038,12 @@ export {
   filterRelationshipsByTables,
   filterTablesByName,
   getTablesWithRelated,
+  groundingFor,
   hashConfig,
   index,
   instructions,
   isValidAdapterName,
+  jsonCodec,
   matchesFilter,
   relationship,
   repairSqlCommand,