@poe-platform/safe-bash 0.1.788 → 0.1.789

package/dist/safe-bash-command-sqlite3/index.js

@@ -4,12 +4,103 @@ import {
 
 // packages/safe-bash-command-sqlite3/dist/index.js
 init_buffer();
+import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
 import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
 import { collectBytes, commandRuntimeIdentity, writeText } from "../safe-bash-contracts/index.js";
 
 // packages/safe-bash-command-sqlite3/dist/engine.js
 init_buffer();
 
+// packages/safe-bash-command-sqlite3/dist/execution.js
+init_buffer();
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
+function runSynchronously(steps) {
+  let step = steps.next();
+  while (!step.done)
+    step = steps.next();
+  return step.value;
+}
+async function runCooperatively(steps, signal) {
+  let work = 0;
+  try {
+    signal.throwIfAborted();
+    let step = steps.next();
+    while (!step.done) {
+      signal.throwIfAborted();
+      if (++work === 2048) {
+        work = 0;
+        await yieldTurn(signal);
+      }
+      step = steps.next();
+    }
+    signal.throwIfAborted();
+    return step.value;
+  } finally {
+    steps.return(void 0);
+  }
+}
+function* stepMap(values, callback, context) {
+  const result = [];
+  for (let i = 0; i < values.length; i++) {
+    yield;
+    result.push(yield* callback.call(context, values[i], i, values));
+  }
+  return result;
+}
+function* stepFilter(values, callback, context) {
+  const result = [];
+  for (let i = 0; i < values.length; i++) {
+    yield;
+    if (yield* callback.call(context, values[i], i, values))
+      result.push(values[i]);
+  }
+  return result;
+}
+function* stepFlatMap(values, callback, context) {
+  const result = [];
+  for (let i = 0; i < values.length; i++) {
+    yield;
+    for (const value of yield* callback.call(context, values[i], i, values)) {
+      yield;
+      result.push(value);
+    }
+  }
+  return result;
+}
+function* stepReduce(values, callback, initial, context) {
+  let result = initial;
+  for (const value of values) {
+    yield;
+    result = yield* callback.call(context, result, value);
+  }
+  return result;
+}
+function* stepSort(values, compare, context) {
+  let source = values.slice();
+  let target = new Array(values.length);
+  for (let width = 1; width < values.length; width *= 2) {
+    for (let start = 0; start < values.length; start += 2 * width) {
+      const middle = Math.min(start + width, values.length);
+      const end = Math.min(start + 2 * width, values.length);
+      let left = start;
+      let right = middle;
+      for (let i = start; i < end; i++) {
+        yield;
+        if (left < middle && (right >= end || (yield* compare.call(context, source[left], source[right])) <= 0))
+          target[i] = source[left++];
+        else
+          target[i] = source[right++];
+      }
+    }
+    [source, target] = [target, source];
+  }
+  for (let i = 0; i < values.length; i++) {
+    yield;
+    values[i] = source[i];
+  }
+  return values;
+}
+
 // packages/safe-bash-command-sqlite3/dist/btree.js
 init_buffer();
 var SQLITE_MAGIC = "SQLite format 3\0";
@@ -2029,6 +2120,17 @@ function sqlPrintf(format, args) {
   });
 }
 var SqliteDatabase = class {
+  maxRows;
+  constructor(maxRows = Infinity) {
+    this.maxRows = maxRows;
+  }
+  checkRowCount(count) {
+    if (count > this.maxRows)
+      throw new RangeError("maxRows limit exceeded");
+  }
+  async executeStatementAsync(sql, signal) {
+    return runCooperatively(this.executeStatementSteps(sql), signal);
+  }
   tables = /* @__PURE__ */ new Map();
   indexes = /* @__PURE__ */ new Map();
   views = /* @__PURE__ */ new Map();
@@ -2049,9 +2151,10 @@ var SqliteDatabase = class {
   preparing = false;
   txSnapshot = null;
   savepoints = /* @__PURE__ */ new Map();
-  captureSnapshot() {
+  *captureSnapshot() {
     const tables = /* @__PURE__ */ new Map();
     for (const [k, v] of this.tables) {
+      yield;
       tables.set(k, cloneTableDef(v));
     }
     return {
@@ -2064,9 +2167,10 @@ var SqliteDatabase = class {
       schemaCookie: this.schemaCookie
     };
   }
-  restoreSnapshot(snap) {
+  *restoreSnapshot(snap) {
     this.tables = /* @__PURE__ */ new Map();
     for (const [k, v] of snap.tables) {
+      yield;
       this.tables.set(k, cloneTableDef(v));
     }
     this.indexes = new Map(snap.indexes);
@@ -2077,6 +2181,9 @@ var SqliteDatabase = class {
     this.schemaCookie = snap.schemaCookie;
   }
   loadFromBytes(bytes) {
+    return runSynchronously(this.loadFromBytesSteps(bytes));
+  }
+  *loadFromBytesSteps(bytes) {
     if (bytes.byteLength === 0) {
       return;
     }
@@ -2084,7 +2191,7 @@ var SqliteDatabase = class {
     if (!image) {
       const text = textDecoder2.decode(bytes);
       if (/^\s*(CREATE|INSERT|BEGIN|PRAGMA|--)/i.test(text)) {
-        this.exec(text);
+        yield* this.execSteps(text);
         return;
       }
       throw new Error("file is not a database");
@@ -2092,21 +2199,27 @@ var SqliteDatabase = class {
     this.userVersion = image.userVersion;
     this.applicationId = image.applicationId;
     this.schemaCookie = image.schemaCookie;
-    this.loadedMaster = image.master.map((m) => ({ ...m }));
-    const preservedMaster = image.master.map((m) => ({ ...m }));
+    this.loadedMaster = image.master.map((m) => {
+      return { ...m };
+    });
+    const preservedMaster = image.master.map((m) => {
+      return { ...m };
+    });
     for (const m of image.master) {
+      yield;
       if (m.name.startsWith("sqlite_autoindex_") || m.name.toLowerCase() === "sqlite_sequence") {
         continue;
       }
       if (m.sql) {
         try {
-          this.exec(m.sql);
+          yield* this.execSteps(m.sql);
         } catch {
         }
       }
     }
     this.loadedMaster = preservedMaster;
     for (const [tblName, rawRows] of image.tableRows.entries()) {
+      yield;
       const tbl = this.findTable(tblName);
       if (!tbl) {
         continue;
@@ -2114,9 +2227,11 @@ var SqliteDatabase = class {
       tbl.rows = [];
       let maxRowid = 0;
       for (const r of rawRows) {
+        yield;
         const data = {};
         let valIdx = 0;
         for (const col of tbl.columns) {
+          yield;
           if (col.primaryKey && col.type.toUpperCase() === "INTEGER" && !tbl.withoutRowId && tbl.primaryKeyCols.length === 1) {
             const cellVal = r.values[valIdx];
             data[col.name] = cellVal === null || cellVal === void 0 ? r.rowid : cellVal;
@@ -2140,6 +2255,7 @@ var SqliteDatabase = class {
     const seqRows = image.tableRows.get("sqlite_sequence");
     if (seqRows) {
       for (const r of seqRows) {
+        yield;
         const tName = String(r.values[0] ?? "");
         const seqVal = Number(r.values[1] ?? 0);
         const tbl = this.findTable(tName);
@@ -2154,6 +2270,7 @@ var SqliteDatabase = class {
         const meta = JSON.parse(image.metaJson);
         if (meta.autoInc) {
           for (const [k, v] of Object.entries(meta.autoInc)) {
+            yield;
             const tbl = this.findTable(k);
             if (tbl) {
               tbl.maxAutoInc = Math.max(tbl.maxAutoInc, v);
@@ -2166,6 +2283,9 @@ var SqliteDatabase = class {
     }
   }
   serializeToBytes() {
+    return runSynchronously(this.serializeToBytesSteps());
+  }
+  *serializeToBytesSteps() {
     const master = [];
     const tableRows = /* @__PURE__ */ new Map();
     const indexRows = /* @__PURE__ */ new Map();
@@ -2173,6 +2293,7 @@ var SqliteDatabase = class {
     let hasAutoIncTable = false;
     let rootPageCounter = 2;
     for (const tbl of this.tables.values()) {
+      yield;
       master.push({
         type: "table",
         name: tbl.name,
@@ -2180,8 +2301,12 @@ var SqliteDatabase = class {
         rootpage: rootPageCounter++,
         sql: tbl.sql
       });
-      if (tbl.columns.some((c) => c.autoIncrement) || tbl.maxAutoInc > 0) {
-        if (tbl.columns.some((c) => c.autoIncrement)) {
+      if (tbl.columns.some((c) => {
+        return c.autoIncrement;
+      }) || tbl.maxAutoInc > 0) {
+        if (tbl.columns.some((c) => {
+          return c.autoIncrement;
+        })) {
           hasAutoIncTable = true;
         }
         if (tbl.maxAutoInc > 0) {
@@ -2191,13 +2316,16 @@ var SqliteDatabase = class {
           });
         }
       }
-      const rows = tbl.rows.map((r) => ({
-        rowid: r.rowid,
-        values: tbl.columns.map((c) => {
-          const isRowidAlias = c.primaryKey && c.type.toUpperCase() === "INTEGER" && !tbl.withoutRowId && tbl.primaryKeyCols.length === 1;
-          return isRowidAlias ? null : r.data[c.name] ?? null;
-        })
-      }));
+      const rows = yield* stepMap(tbl.rows, function* (r) {
+        yield;
+        return {
+          rowid: r.rowid,
+          values: tbl.columns.map((c) => {
+            const isRowidAlias = c.primaryKey && c.type.toUpperCase() === "INTEGER" && !tbl.withoutRowId && tbl.primaryKeyCols.length === 1;
+            return isRowidAlias ? null : r.data[c.name] ?? null;
+          })
+        };
+      }, this);
       tableRows.set(tbl.name, rows);
     }
     if ((hasAutoIncTable || seqRows.length > 0) && !this.findTable("sqlite_sequence")) {
@@ -2211,6 +2339,7 @@ var SqliteDatabase = class {
       tableRows.set("sqlite_sequence", seqRows);
     }
     for (const idx of this.indexes.values()) {
+      yield;
       master.push({
         type: "index",
         name: idx.name,
@@ -2220,18 +2349,24 @@ var SqliteDatabase = class {
       });
       const tbl = this.findTable(idx.tableName);
       if (tbl) {
-        const entries = tbl.rows.map((r) => [
-          ...idx.columns.map((colName) => {
-            const cleaned = colName.replace(/\s+(ASC|DESC)$/i, "").trim();
-            const matchCol = tbl.columns.find((c) => c.name.toLowerCase() === cleaned.toLowerCase());
-            return matchCol ? r.data[matchCol.name] ?? null : null;
-          }),
-          r.rowid
-        ]);
+        const entries = yield* stepMap(tbl.rows, function* (r) {
+          yield;
+          return [
+            ...idx.columns.map((colName) => {
+              const cleaned = colName.replace(/\s+(ASC|DESC)$/i, "").trim();
+              const matchCol = tbl.columns.find((c) => {
+                return c.name.toLowerCase() === cleaned.toLowerCase();
+              });
+              return matchCol ? r.data[matchCol.name] ?? null : null;
+            }),
+            r.rowid
+          ];
+        }, this);
         indexRows.set(idx.name, entries);
       }
     }
     for (const v of this.views.values()) {
+      yield;
       master.push({
         type: "view",
         name: v.name,
@@ -2241,6 +2376,7 @@ var SqliteDatabase = class {
       });
     }
     for (const tr of this.triggers.values()) {
+      yield;
       master.push({
         type: "trigger",
         name: tr.name,
@@ -2277,10 +2413,14 @@ var SqliteDatabase = class {
     return void 0;
   }
   exec(sql, positionalParams = []) {
+    return runSynchronously(this.execSteps(sql, positionalParams));
+  }
+  *execSteps(sql, positionalParams = []) {
     const stmts = splitSqlStatements(sql);
     const results = [];
     for (const stmt of stmts) {
-      const res = this.executeStatement(stmt, positionalParams);
+      yield;
+      const res = yield* this.executeStatementSteps(stmt, positionalParams);
       if (res) {
         results.push(res);
       }
@@ -2288,6 +2428,9 @@ var SqliteDatabase = class {
     return results;
   }
   executeStatement(rawSql, positionalParams = [], cteScope = /* @__PURE__ */ new Map()) {
+    return runSynchronously(this.executeStatementSteps(rawSql, positionalParams, cteScope));
+  }
+  *executeStatementSteps(rawSql, positionalParams = [], cteScope = /* @__PURE__ */ new Map()) {
     const sql = rawSql.trim().replace(/;+\s*$/, "");
     if (!sql) {
       return null;
@@ -2305,7 +2448,7 @@ var SqliteDatabase = class {
     }
     if (first === "BEGIN") {
       if (!this.inTransaction) {
-        this.txSnapshot = this.captureSnapshot();
+        this.txSnapshot = yield* this.captureSnapshot();
         this.inTransaction = true;
       }
       return null;
@@ -2317,7 +2460,9 @@ var SqliteDatabase = class {
       return null;
     }
     if (first === "ROLLBACK") {
-      const toIdx = tokens.findIndex((t) => t.value.toUpperCase() === "TO");
+      const toIdx = tokens.findIndex((t) => {
+        return t.value.toUpperCase() === "TO";
+      });
       if (toIdx !== -1) {
         let spIdx = toIdx + 1;
         if (tokens[spIdx]?.value.toUpperCase() === "SAVEPOINT") {
@@ -2328,11 +2473,11 @@ var SqliteDatabase = class {
         if (!snap) {
           throw new Error(`no such savepoint: ${spName}`);
         }
-        this.restoreSnapshot(snap);
+        yield* this.restoreSnapshot(snap);
         return null;
       }
       if (this.txSnapshot) {
-        this.restoreSnapshot(this.txSnapshot);
+        yield* this.restoreSnapshot(this.txSnapshot);
       }
       this.inTransaction = false;
       this.txSnapshot = null;
@@ -2341,7 +2486,7 @@ var SqliteDatabase = class {
     }
     if (first === "SAVEPOINT") {
       const spName = (tokens[1]?.value ?? "").toLowerCase();
-      this.savepoints.set(spName, this.captureSnapshot());
+      this.savepoints.set(spName, yield* this.captureSnapshot());
       return null;
     }
     if (first === "RELEASE") {
@@ -2354,10 +2499,10 @@ var SqliteDatabase = class {
       return null;
     }
     if (first === "PRAGMA") {
-      return this.executePragma(tokens);
+      return yield* this.executePragma(tokens);
     }
     if (first === "CREATE") {
-      this.executeCreate(sql, tokens, positionalParams);
+      yield* this.executeCreate(sql, tokens, positionalParams);
       this.schemaCookie += 1;
       return null;
     }
@@ -2367,28 +2512,28 @@ var SqliteDatabase = class {
       return null;
     }
     if (first === "ALTER") {
-      this.executeAlter(tokens);
+      yield* this.executeAlter(tokens);
       this.schemaCookie += 1;
       return null;
     }
     if (first === "INSERT" || first === "REPLACE") {
-      return this.executeInsert(sql, tokens, positionalParams, cteScope);
+      return yield* this.executeInsert(sql, tokens, positionalParams, cteScope);
     }
     if (first === "UPDATE") {
-      return this.executeUpdate(tokens, positionalParams, cteScope);
+      return yield* this.executeUpdate(tokens, positionalParams, cteScope);
     }
     if (first === "DELETE") {
-      return this.executeDelete(tokens, positionalParams, cteScope);
+      return yield* this.executeDelete(tokens, positionalParams, cteScope);
     }
     if (first === "WITH") {
-      return this.executeWith(tokens, positionalParams, cteScope);
+      return yield* this.executeWith(tokens, positionalParams, cteScope);
     }
     if (first === "SELECT" || first === "VALUES") {
-      return this.executeSelectCompound(tokens, positionalParams, cteScope);
+      return yield* this.executeSelectCompound(tokens, positionalParams, cteScope);
     }
     throw new Error(`near "${tokens[0].raw}": syntax error`);
   }
-  executePragma(tokens) {
+  *executePragma(tokens) {
     let idx = 1;
     if (tokens[idx + 1]?.value === ".") {
       idx += 2;
@@ -2468,7 +2613,9 @@ var SqliteDatabase = class {
         return { columns: ["cid", "name", "type", "notnull", "dflt_value", "pk"], rows: [] };
       }
       const rows = tbl.columns.map((c, i) => {
-        const pkIdx = tbl.primaryKeyCols.findIndex((p) => p.toLowerCase() === c.name.toLowerCase());
+        const pkIdx = tbl.primaryKeyCols.findIndex((p) => {
+          return p.toLowerCase() === c.name.toLowerCase();
+        });
         const base = [
           i,
           c.name,
@@ -2490,6 +2637,7 @@ var SqliteDatabase = class {
       const rows = [];
       let seq = 0;
       for (const idxDef of this.indexes.values()) {
+        yield;
         if (idxDef.tableName.toLowerCase() === tName) {
           rows.push([seq++, idxDef.name, idxDef.unique ? 1 : 0, "c", 0]);
         }
@@ -2499,6 +2647,7 @@ var SqliteDatabase = class {
     if (name === "index_info") {
       const iName = (arg ?? "").toLowerCase();
       for (const idxDef of this.indexes.values()) {
+        yield;
         if (idxDef.name.toLowerCase() === iName) {
           const tbl = this.findTable(idxDef.tableName);
           const rows = idxDef.columns.map((colName, seqno) => {
@@ -2511,17 +2660,26 @@ var SqliteDatabase = class {
       return { columns: ["seqno", "cid", "name"], rows: [] };
     }
     if (name === "foreign_key_list") {
-      return { columns: ["id", "seq", "table", "from", "to", "on_update", "on_delete", "match"], rows: [] };
+      return {
+        columns: ["id", "seq", "table", "from", "to", "on_update", "on_delete", "match"],
+        rows: []
+      };
     }
     if (name === "compile_options") {
       return {
         columns: ["compile_options"],
-        rows: [["ENABLE_FTS5"], ["ENABLE_JSON1"], ["ENABLE_MATH_FUNCTIONS"], ["ENABLE_RTREE"], ["THREADSAFE=1"]]
+        rows: [
+          ["ENABLE_FTS5"],
+          ["ENABLE_JSON1"],
+          ["ENABLE_MATH_FUNCTIONS"],
+          ["ENABLE_RTREE"],
+          ["THREADSAFE=1"]
+        ]
       };
     }
     return null;
   }
-  executeCreate(sql, tokens, positionalParams) {
+  *executeCreate(sql, tokens, positionalParams) {
     let idx = 1;
     let unique = false;
     if (tokens[idx]?.value.toUpperCase() === "TEMP" || tokens[idx]?.value.toUpperCase() === "TEMPORARY") {
@@ -2550,28 +2708,35 @@ var SqliteDatabase = class {
         }
         throw new Error(`table ${objName} already exists`);
       }
-      const asIdx = tokens.findIndex((t, i) => i >= idx && t.value.toUpperCase() === "AS");
+      const asIdx = tokens.findIndex((t, i) => {
+        return i >= idx && t.value.toUpperCase() === "AS";
+      });
       if (asIdx !== -1 && tokens[idx]?.value !== "(") {
         const selectTokens = tokens.slice(asIdx + 1);
-        const res = this.executeSelectCompound(selectTokens, positionalParams, /* @__PURE__ */ new Map());
-        const columns2 = res.columns.map((c) => ({
-          name: c,
-          type: "TEXT",
-          notNull: false,
-          primaryKey: false,
-          autoIncrement: false,
-          unique: false
-        }));
-        const rows = res.rows.map((r, rIdx) => {
+        const res = yield* this.executeSelectCompound(selectTokens, positionalParams, /* @__PURE__ */ new Map());
+        const columns2 = res.columns.map((c) => {
+          return {
+            name: c,
+            type: "TEXT",
+            notNull: false,
+            primaryKey: false,
+            autoIncrement: false,
+            unique: false
+          };
+        });
+        const rows = yield* stepMap(res.rows, function* (r, rIdx) {
+          yield;
           const data = {};
           res.columns.forEach((c, cIdx) => {
             data[c] = r[cIdx] ?? null;
           });
           return { rowid: rIdx + 1, data };
-        });
+        }, this);
         this.tables.set(objName, {
           name: objName,
-          sql: `CREATE TABLE ${objName}(${columns2.map((c) => `"${c.name}"`).join(",")})`,
+          sql: `CREATE TABLE ${objName}(${columns2.map((c) => {
+            return `"${c.name}"`;
+          }).join(",")})`,
           columns: columns2,
           rows,
           nextRowId: rows.length + 1,
@@ -2585,6 +2750,7 @@ var SqliteDatabase = class {
       }
       let openParen = idx;
       while (openParen < tokens.length && tokens[openParen]?.value !== "(") {
+        yield;
         openParen += 1;
       }
       let depth = 1;
@@ -2592,6 +2758,7 @@ var SqliteDatabase = class {
       const bodyParts = [];
       let curPart = [];
       while (closeParen < tokens.length && depth > 0) {
+        yield;
         const t = tokens[closeParen];
         if (t.value === "(") {
           depth += 1;
@@ -2613,13 +2780,16 @@ var SqliteDatabase = class {
         }
         closeParen += 1;
       }
-      const trailingTokens = tokens.slice(closeParen + 1).map((t) => t.value.toUpperCase());
+      const trailingTokens = tokens.slice(closeParen + 1).map((t) => {
+        return t.value.toUpperCase();
+      });
       const withoutRowId = trailingTokens.includes("WITHOUT") && trailingTokens.includes("ROWID");
       const strict = trailingTokens.includes("STRICT");
       const columns = [];
       const primaryKeyCols = [];
       const uniqueColSets = [];
       for (const part of bodyParts) {
+        yield;
         if (part.length === 0) {
           continue;
         }
@@ -2633,6 +2803,7 @@ var SqliteDatabase = class {
           if (part[pIdx]?.value === "(") {
             pIdx += 1;
             while (pIdx < part.length && part[pIdx]?.value !== ")") {
+              yield;
               const colName = part[pIdx].value;
               if (colName !== "," && colName.toUpperCase() !== "ASC" && colName.toUpperCase() !== "DESC") {
                 primaryKeyCols.push(colName);
@@ -2648,6 +2819,7 @@ var SqliteDatabase = class {
           if (part[pIdx]?.value === "(") {
             pIdx += 1;
             while (pIdx < part.length && part[pIdx]?.value !== ")") {
+              yield;
               const colName = part[pIdx].value;
               if (colName !== "," && colName.toUpperCase() !== "ASC" && colName.toUpperCase() !== "DESC") {
                 uCols.push(colName);
@@ -2673,7 +2845,9 @@ var SqliteDatabase = class {
         }
       }
       if (primaryKeyCols.length === 1) {
-        const pkCol = columns.find((c) => c.name.toLowerCase() === primaryKeyCols[0].toLowerCase());
+        const pkCol = columns.find((c) => {
+          return c.name.toLowerCase() === primaryKeyCols[0].toLowerCase();
+        });
         if (pkCol) {
           pkCol.primaryKey = true;
         }
@@ -2699,13 +2873,16 @@ var SqliteDatabase = class {
         }
         throw new Error(`index ${objName} already exists`);
       }
-      const onIdx = tokens.findIndex((t, i) => i >= idx && t.value.toUpperCase() === "ON");
+      const onIdx = tokens.findIndex((t, i) => {
+        return i >= idx && t.value.toUpperCase() === "ON";
+      });
       const tableName = tokens[onIdx + 1]?.value ?? "";
       const cols = [];
       let p = onIdx + 2;
       if (tokens[p]?.value === "(") {
         p += 1;
         while (p < tokens.length && tokens[p]?.value !== ")") {
+          yield;
           const v = tokens[p].value;
           if (v !== "," && v.toUpperCase() !== "ASC" && v.toUpperCase() !== "DESC" && v.toUpperCase() !== "COLLATE") {
             cols.push(v);
@@ -2740,6 +2917,7 @@ var SqliteDatabase = class {
         viewCols = [];
         idx += 1;
         while (idx < tokens.length && tokens[idx]?.value !== ")") {
+          yield;
           if (tokens[idx].value !== ",") {
             viewCols.push(tokens[idx].value);
           }
@@ -2747,7 +2925,9 @@ var SqliteDatabase = class {
         }
         idx += 1;
       }
-      const asIdx = tokens.findIndex((t, i) => i >= idx && t.value.toUpperCase() === "AS");
+      const asIdx = tokens.findIndex((t, i) => {
+        return i >= idx && t.value.toUpperCase() === "AS";
+      });
       const selectSql = reconstructTokensSql(tokens.slice(asIdx + 1));
       this.views.set(objName, {
         name: objName,
@@ -2785,6 +2965,7 @@ var SqliteDatabase = class {
       if (tokens[idx]?.value.toUpperCase() === "OF") {
         idx += 1;
         while (idx < tokens.length && tokens[idx]?.value.toUpperCase() !== "ON") {
+          yield;
           idx += 1;
         }
       }
@@ -2801,6 +2982,7 @@ var SqliteDatabase = class {
         idx += 1;
         const whenToks = [];
         while (idx < tokens.length && tokens[idx]?.value.toUpperCase() !== "BEGIN") {
+          yield;
           whenToks.push(tokens[idx]);
           idx += 1;
         }
@@ -3045,7 +3227,7 @@ var SqliteDatabase = class {
       this.triggers.delete(found);
     }
   }
-  executeAlter(tokens) {
+  *executeAlter(tokens) {
     this.loadedMaster = null;
     let idx = 2;
     if (tokens[idx + 1]?.value === ".") {
@@ -3073,13 +3255,16 @@ var SqliteDatabase = class {
       }
       const oldCol = tokens[idx]?.value ?? "";
       const newCol = tokens[idx + 2]?.value ?? "";
-      const colObj = tbl.columns.find((c) => c.name.toLowerCase() === oldCol.toLowerCase());
+      const colObj = tbl.columns.find((c) => {
+        return c.name.toLowerCase() === oldCol.toLowerCase();
+      });
       if (!colObj) {
         throw new Error(`in prepare, no such column: "${oldCol}"`);
       }
       const realOld = colObj.name;
       colObj.name = newCol;
       for (const r of tbl.rows) {
+        yield;
         r.data[newCol] = r.data[realOld] ?? null;
         delete r.data[realOld];
       }
@@ -3091,8 +3276,9 @@ var SqliteDatabase = class {
       }
       const colDef = this.parseColumnDefTokens(tokens.slice(idx));
       tbl.columns.push(colDef);
-      const defVal = colDef.defaultExpr ? this.evalScalarSql(colDef.defaultExpr, {}, []) : null;
+      const defVal = colDef.defaultExpr ? yield* this.evalScalarSql(colDef.defaultExpr, {}, []) : null;
       for (const r of tbl.rows) {
+        yield;
         r.data[colDef.name] = defVal;
       }
       tbl.sql = tbl.sql.replace(/\)\s*$/, `, ${colDef.name} ${colDef.type})`);
@@ -3103,35 +3289,41 @@ var SqliteDatabase = class {
         idx += 1;
       }
       const dropCol = tokens[idx]?.value ?? "";
-      const colIdx = tbl.columns.findIndex((c) => c.name.toLowerCase() === dropCol.toLowerCase());
+      const colIdx = tbl.columns.findIndex((c) => {
+        return c.name.toLowerCase() === dropCol.toLowerCase();
+      });
       if (colIdx === -1) {
         throw new Error(`in prepare, no such column: "${dropCol}"`);
       }
       const realName = tbl.columns[colIdx].name;
       tbl.columns.splice(colIdx, 1);
       for (const r of tbl.rows) {
+        yield;
         delete r.data[realName];
       }
     }
   }
-  fireTriggers(tableName, timing, event, oldRow, newRow) {
+  *fireTriggers(tableName, timing, event, oldRow, newRow) {
     for (const tr of this.triggers.values()) {
+      yield;
       if (tr.tableName.toLowerCase() === tableName.toLowerCase() && tr.timing === timing && tr.event === event) {
         const ctx = {};
         if (oldRow) {
           for (const [k, v] of Object.entries(oldRow)) {
+            yield;
             ctx[`OLD.${k}`] = v;
             ctx[`old.${k}`] = v;
           }
         }
         if (newRow) {
           for (const [k, v] of Object.entries(newRow)) {
+            yield;
             ctx[`NEW.${k}`] = v;
             ctx[`new.${k}`] = v;
           }
         }
         if (tr.whenExpr) {
-          const cond = this.evalExpr(parseExprSql(tr.whenExpr), ctx, []);
+          const cond = yield* this.evalExprSteps(parseExprSql(tr.whenExpr), ctx, []);
           if (!isTruthy(cond)) {
             continue;
           }
@@ -3146,7 +3338,7 @@ var SqliteDatabase = class {
           const val = matchKey ? source[matchKey] : null;
           return this.toSqlLiteral(val ?? null);
         });
-        this.exec(body);
+        yield* this.execSteps(body);
       }
     }
   }
@@ -3173,8 +3365,9 @@ var SqliteDatabase = class {
     }
     return `X'${hex}'`;
   }
-  checkConstraintsAndConflicts(tbl, candidate, excludeRowid) {
+  *checkConstraintsAndConflicts(tbl, candidate, excludeRowid) {
     for (const col of tbl.columns) {
+      yield;
       const val = candidate.data[col.name] ?? null;
       if (col.notNull && val === null) {
         if (col.primaryKey && col.type.toUpperCase() === "INTEGER" && !tbl.withoutRowId) {
@@ -3184,7 +3377,7 @@ var SqliteDatabase = class {
         }
       }
       if (col.checkExpr && val !== null) {
-        const ok = this.evalExpr(parseExprSql(col.checkExpr), candidate.data, []);
+        const ok = yield* this.evalExprSteps(parseExprSql(col.checkExpr), candidate.data, []);
         if (ok !== null && !isTruthy(ok)) {
           throw new Error(`CHECK constraint failed: ${col.checkExpr}`);
         }
@@ -3195,16 +3388,23 @@ var SqliteDatabase = class {
       keySets.push(tbl.primaryKeyCols);
     }
     for (const u of tbl.uniqueColSets) {
+      yield;
       keySets.push(u);
     }
     if (keySets.length === 0 && candidate.rowid >= tbl.nextRowId) {
       return null;
     }
-    const resolvedKeySets = keySets.map((kSet) => kSet.map((colName) => {
-      const realCol = tbl.columns.find((c) => c.name.toLowerCase() === colName.toLowerCase());
-      return { cKey: realCol ? realCol.name : colName, collate: realCol?.collate ?? "BINARY" };
-    }));
+    const resolvedKeySets = yield* stepMap(keySets, function* (kSet) {
+      yield;
+      return kSet.map((colName) => {
+        const realCol = tbl.columns.find((c) => {
+          return c.name.toLowerCase() === colName.toLowerCase();
+        });
+        return { cKey: realCol ? realCol.name : colName, collate: realCol?.collate ?? "BINARY" };
+      });
+    }, this);
     for (const existing of tbl.rows) {
+      yield;
       if (excludeRowid !== void 0 && existing.rowid === excludeRowid) {
         continue;
       }
@@ -3212,8 +3412,10 @@ var SqliteDatabase = class {
         return existing;
       }
       for (const kSet of resolvedKeySets) {
+        yield;
         let allEqual = true;
         for (const { cKey, collate } of kSet) {
+          yield;
           const v1 = candidate.data[cKey] ?? null;
           const v2 = existing.data[cKey] ?? null;
           if (v1 === null || v2 === null || !sqlEquals(v1, v2, collate)) {
@@ -3228,7 +3430,7 @@ var SqliteDatabase = class {
     }
     return null;
   }
-  executeInsert(_sql, tokens, positionalParams, cteScope) {
+  *executeInsert(_sql, tokens, positionalParams, cteScope) {
     let idx = 0;
     let conflictAction = "ABORT";
     if (tokens[idx]?.value.toUpperCase() === "REPLACE") {
@@ -3265,14 +3467,19 @@ var SqliteDatabase = class {
         throw new Error("near AS: syntax error");
       idx += 2;
     }
-    let targetCols = tbl.columns.map((c) => c.name);
+    let targetCols = tbl.columns.map((c) => {
+      return c.name;
+    });
     if (tokens[idx]?.value === "(") {
       targetCols = [];
       idx += 1;
       while (idx < tokens.length && tokens[idx]?.value !== ")") {
+        yield;
         if (tokens[idx].value !== ",") {
           const cName = tokens[idx].value;
-          const colMatch = tbl.columns.find((c) => c.name.toLowerCase() === cName.toLowerCase());
+          const colMatch = tbl.columns.find((c) => {
+            return c.name.toLowerCase() === cName.toLowerCase();
+          });
           targetCols.push(colMatch ? colMatch.name : cName);
         }
         idx += 1;
@@ -3283,6 +3490,7 @@ var SqliteDatabase = class {
     let onConflictIdx = -1;
     let pDepth = 0;
     for (let i = idx; i < tokens.length; i += 1) {
+      yield;
       if (tokens[i].value === "(") {
         pDepth += 1;
       } else if (tokens[i].value === ")") {
@@ -3304,12 +3512,14 @@ var SqliteDatabase = class {
     } else if (tokens[idx]?.value.toUpperCase() === "VALUES") {
       idx += 1;
       while (idx < endValuesIdx) {
+        yield;
         if (tokens[idx]?.value === "(") {
           idx += 1;
           const rowToks = [];
           let cur = [];
           let d = 1;
           while (idx < endValuesIdx && d > 0) {
+            yield;
             const t = tokens[idx++];
             if (t.value === "(") {
               d += 1;
@@ -3328,15 +3538,18 @@ var SqliteDatabase = class {
               cur.push(t);
             }
           }
-          const evaledRow = rowToks.map((rt) => this.evalExpr(new ExprParser(rt).parseExpression(), {}, positionalParams));
+          const evaledRow = yield* stepMap(rowToks, function* (rt) {
+            return yield* this.evalExprSteps(new ExprParser(rt).parseExpression(), {}, positionalParams);
+          }, this);
           valueRows.push(evaledRow);
         } else {
           idx += 1;
         }
       }
     } else {
-      const selectRes = this.executeSelectCompound(tokens.slice(idx, endValuesIdx), positionalParams, cteScope);
+      const selectRes = yield* this.executeSelectCompound(tokens.slice(idx, endValuesIdx), positionalParams, cteScope);
       for (const r of selectRes.rows) {
+        yield;
         valueRows.push(r);
       }
     }
@@ -3347,12 +3560,14 @@ var SqliteDatabase = class {
       let uIdx = onConflictIdx + 2;
       if (tokens[uIdx]?.value === "(") {
         while (uIdx < tokens.length && tokens[uIdx]?.value !== ")") {
+          yield;
           uIdx += 1;
         }
         uIdx += 1;
       }
       if (tokens[uIdx]?.value.toUpperCase() === "WHERE") {
         while (uIdx < tokens.length && tokens[uIdx]?.value.toUpperCase() !== "DO") {
+          yield;
           uIdx += 1;
         }
       }
@@ -3371,32 +3586,40 @@ var SqliteDatabase = class {
     }
     const targetBindings = this.tableBindings(tbl, void 0, alias);
     const upsertBindings = { ...targetBindings };
-    for (const column of tbl.columns)
+    for (const column of tbl.columns) {
+      yield;
       upsertBindings[`excluded.${column.name}`] = null;
+    }
     for (const assignment of upsertSetPairs) {
-      this.validateColumns({ kind: "column", name: assignment.col }, targetBindings, positionalParams, cteScope);
-      this.validateColumns(assignment.expr, upsertBindings, positionalParams, cteScope);
+      yield;
+      yield* this.validateColumns({ kind: "column", name: assignment.col }, targetBindings, positionalParams, cteScope);
+      yield* this.validateColumns(assignment.expr, upsertBindings, positionalParams, cteScope);
     }
-    this.validateColumns(upsertWhere, upsertBindings, positionalParams, cteScope);
+    yield* this.validateColumns(upsertWhere, upsertBindings, positionalParams, cteScope);
     let insertedCount = 0;
     const affectedRows = [];
     for (const vRow of valueRows) {
+      yield;
       const data = {};
       for (const col of tbl.columns) {
+        yield;
         if (col.defaultExpr !== void 0) {
-          data[col.name] = this.evalScalarSql(col.defaultExpr, {}, positionalParams);
+          data[col.name] = yield* this.evalScalarSql(col.defaultExpr, {}, positionalParams);
         } else {
           data[col.name] = null;
         }
       }
       for (let c = 0; c < targetCols.length; c += 1) {
+        yield;
         data[targetCols[c]] = vRow[c] ?? null;
       }
       for (const col of tbl.columns) {
+        yield;
         data[col.name] = applyColumnAffinity(data[col.name] ?? null, col.type);
       }
       let rowid = tbl.nextRowId;
       for (const col of tbl.columns) {
+        yield;
         if (col.autoIncrement) {
           rowid = Math.max(rowid, tbl.maxAutoInc + 1);
         }
@@ -3410,13 +3633,14 @@ var SqliteDatabase = class {
         }
       }
       for (const col of tbl.columns) {
+        yield;
         if (col.generatedExpr) {
-          data[col.name] = applyColumnAffinity(this.evalScalarSql(col.generatedExpr, data, positionalParams), col.type);
+          data[col.name] = applyColumnAffinity(yield* this.evalScalarSql(col.generatedExpr, data, positionalParams), col.type);
         }
       }
       const candidate = { rowid, data };
-      this.fireTriggers(tbl.name, "BEFORE", "INSERT", void 0, candidate.data);
-      const conflictRow = this.checkConstraintsAndConflicts(tbl, candidate);
+      yield* this.fireTriggers(tbl.name, "BEFORE", "INSERT", void 0, candidate.data);
+      const conflictRow = yield* this.checkConstraintsAndConflicts(tbl, candidate);
       if (conflictRow) {
         if (upsertDoNothing || conflictAction === "IGNORE") {
           continue;
@@ -3424,22 +3648,27 @@ var SqliteDatabase = class {
         if (upsertSetPairs.length > 0) {
           const ctx = this.tableBindings(tbl, conflictRow, alias);
           for (const [k, v] of Object.entries(conflictRow.data)) {
+            yield;
             ctx[`${tbl.name}.${k}`] = v;
           }
           for (const [k, v] of Object.entries(candidate.data)) {
+            yield;
             ctx[`excluded.${k}`] = v;
             ctx[`EXCLUDED.${k}`] = v;
           }
           if (upsertWhere) {
-            const cond = this.evalExpr(upsertWhere, ctx, positionalParams);
+            const cond = yield* this.evalExprSteps(upsertWhere, ctx, positionalParams);
             if (!isTruthy(cond)) {
               continue;
             }
           }
           for (const assign of upsertSetPairs) {
-            const realCol = tbl.columns.find((c) => c.name.toLowerCase() === assign.col.toLowerCase());
+            yield;
+            const realCol = tbl.columns.find((c) => {
+              return c.name.toLowerCase() === assign.col.toLowerCase();
+            });
             const colKey = realCol ? realCol.name : assign.col;
-            conflictRow.data[colKey] = applyColumnAffinity(this.evalExpr(assign.expr, ctx, positionalParams), realCol?.type ?? "");
+            conflictRow.data[colKey] = applyColumnAffinity(yield* this.evalExprSteps(assign.expr, ctx, positionalParams), realCol?.type ?? "");
           }
           insertedCount += 1;
           affectedRows.push(conflictRow);
@@ -3464,12 +3693,12 @@ var SqliteDatabase = class {
       this.lastInsertRowid = rowid;
       insertedCount += 1;
       affectedRows.push(candidate);
-      this.fireTriggers(tbl.name, "AFTER", "INSERT", void 0, candidate.data);
+      yield* this.fireTriggers(tbl.name, "AFTER", "INSERT", void 0, candidate.data);
     }
     this.lastChanges = insertedCount;
     this.totalChanges += insertedCount;
     if (returningIdx !== -1) {
-      return this.evaluateReturning(tbl, affectedRows, tokens.slice(returningIdx + 1), positionalParams, cteScope);
+      return yield* this.evaluateReturning(tbl, affectedRows, tokens.slice(returningIdx + 1), positionalParams, cteScope);
     }
     return null;
   }
@@ -3561,7 +3790,7 @@ var SqliteDatabase = class {
     }
     return bindings;
   }
-  executeUpdate(tokens, positionalParams, _cteScope) {
+  *executeUpdate(tokens, positionalParams, _cteScope) {
     let idx = 1;
     if (tokens[idx]?.value.toUpperCase() === "OR") {
       idx += 2;
@@ -3586,6 +3815,7 @@ var SqliteDatabase = class {
     let returningIdx = -1;
     let pDepth = 0;
     for (let i = idx; i < tokens.length; i += 1) {
+      yield;
       if (tokens[i].value === "(") {
         pDepth += 1;
       } else if (tokens[i].value === ")") {
@@ -3600,6 +3830,7 @@ var SqliteDatabase = class {
     let whereIdx = sliceEnd;
     let depth = 0;
     for (let i = idx; i < sliceEnd; i += 1) {
+      yield;
       const token = tokens[i].value.toUpperCase();
       if (token === "(")
         depth += 1;
@@ -3612,65 +3843,74 @@ var SqliteDatabase = class {
     }
     const setTokens = fromIdx === -1 ? tokens.slice(idx, sliceEnd) : [...tokens.slice(idx, fromIdx), ...tokens.slice(whereIdx, sliceEnd)];
     const { assignments, whereExpr } = this.parseSetAssignments(setTokens);
-    const source = fromIdx === -1 ? { rows: [{}], schema: [] } : this.evaluateFromClause(tokens.slice(fromIdx + 1, whereIdx), positionalParams, _cteScope);
+    const source = fromIdx === -1 ? { rows: [{}], schema: [] } : yield* this.evaluateFromClause(tokens.slice(fromIdx + 1, whereIdx), positionalParams, _cteScope);
     const targetBindings = this.tableBindings(tbl, void 0, alias);
     const bindings = { ...targetBindings };
     for (const table of source.schema) {
+      yield;
       for (const column of table.columns) {
+        yield;
         bindings[column] = null;
         bindings[`${table.tableAlias}.${column}`] = null;
       }
     }
     for (const assignment of assignments) {
-      this.validateColumns({ kind: "column", name: assignment.col }, targetBindings, positionalParams, _cteScope);
-      this.validateColumns(assignment.expr, bindings, positionalParams, _cteScope);
+      yield;
+      yield* this.validateColumns({ kind: "column", name: assignment.col }, targetBindings, positionalParams, _cteScope);
+      yield* this.validateColumns(assignment.expr, bindings, positionalParams, _cteScope);
     }
-    this.validateColumns(whereExpr, bindings, positionalParams, _cteScope);
+    yield* this.validateColumns(whereExpr, bindings, positionalParams, _cteScope);
     if (returningIdx !== -1)
-      this.evaluateReturning(tbl, [], tokens.slice(returningIdx + 1), positionalParams, _cteScope);
+      yield* this.evaluateReturning(tbl, [], tokens.slice(returningIdx + 1), positionalParams, _cteScope);
     let updated = 0;
     const affectedRows = [];
-    const matches = tbl.rows.flatMap((row) => {
+    const matches = yield* stepFlatMap(tbl.rows, function* (row) {
       const target = this.tableBindings(tbl, row, alias);
       for (const other of source.rows) {
+        yield;
         const ctx = { ...other, ...target };
-        if (!whereExpr || isTruthy(this.evalExpr(whereExpr, ctx, positionalParams, _cteScope)))
+        if (!whereExpr || isTruthy(yield* this.evalExprSteps(whereExpr, ctx, positionalParams, _cteScope)))
           return [{ row, ctx }];
       }
       return [];
-    });
+    }, this);
     for (const { row, ctx } of matches) {
+      yield;
       const oldData = { ...row.data };
       const newData = { ...row.data };
       for (const assign of assignments) {
-        const realCol = tbl.columns.find((c) => c.name.toLowerCase() === assign.col.toLowerCase());
+        yield;
+        const realCol = tbl.columns.find((c) => {
+          return c.name.toLowerCase() === assign.col.toLowerCase();
+        });
         const colKey = realCol ? realCol.name : assign.col;
-        newData[colKey] = applyColumnAffinity(this.evalExpr(assign.expr, ctx, positionalParams, _cteScope), realCol?.type ?? "");
+        newData[colKey] = applyColumnAffinity(yield* this.evalExprSteps(assign.expr, ctx, positionalParams, _cteScope), realCol?.type ?? "");
       }
       for (const col of tbl.columns) {
+        yield;
         if (col.generatedExpr) {
-          newData[col.name] = applyColumnAffinity(this.evalScalarSql(col.generatedExpr, newData, positionalParams), col.type);
+          newData[col.name] = applyColumnAffinity(yield* this.evalScalarSql(col.generatedExpr, newData, positionalParams), col.type);
         }
       }
-      this.fireTriggers(tbl.name, "BEFORE", "UPDATE", oldData, newData);
+      yield* this.fireTriggers(tbl.name, "BEFORE", "UPDATE", oldData, newData);
       const candidate = { rowid: row.rowid, data: newData };
-      const conflict = this.checkConstraintsAndConflicts(tbl, candidate, row.rowid);
+      const conflict = yield* this.checkConstraintsAndConflicts(tbl, candidate, row.rowid);
       if (conflict) {
         throw new Error(`UNIQUE constraint failed: ${tbl.name}`);
       }
       row.data = newData;
       updated += 1;
       affectedRows.push(row);
-      this.fireTriggers(tbl.name, "AFTER", "UPDATE", oldData, newData);
+      yield* this.fireTriggers(tbl.name, "AFTER", "UPDATE", oldData, newData);
     }
     this.lastChanges = updated;
     this.totalChanges += updated;
     if (returningIdx !== -1) {
-      return this.evaluateReturning(tbl, affectedRows, tokens.slice(returningIdx + 1), positionalParams, _cteScope);
+      return yield* this.evaluateReturning(tbl, affectedRows, tokens.slice(returningIdx + 1), positionalParams, _cteScope);
     }
     return null;
   }
-  executeDelete(tokens, positionalParams, _cteScope) {
+  *executeDelete(tokens, positionalParams, _cteScope) {
     let idx = 1;
     if (tokens[idx]?.value.toUpperCase() === "FROM") {
       idx += 1;
@@ -3699,6 +3939,7 @@ var SqliteDatabase = class {
     let returningIdx = -1;
     let pDepth = 0;
     for (let i = idx; i < tokens.length; i += 1) {
+      yield;
       if (tokens[i].value === "(") {
         pDepth += 1;
       } else if (tokens[i].value === ")") {
@@ -3713,39 +3954,42 @@ var SqliteDatabase = class {
     if (idx < sliceEnd && tokens[idx]?.value.toUpperCase() === "WHERE") {
       whereExpr = new ExprParser(tokens.slice(idx + 1, sliceEnd)).parseExpression();
     }
-    this.validateColumns(whereExpr, this.tableBindings(tbl, void 0, alias), positionalParams, _cteScope);
+    yield* this.validateColumns(whereExpr, this.tableBindings(tbl, void 0, alias), positionalParams, _cteScope);
     if (returningIdx !== -1)
-      this.evaluateReturning(tbl, [], tokens.slice(returningIdx + 1), positionalParams, _cteScope);
+      yield* this.evaluateReturning(tbl, [], tokens.slice(returningIdx + 1), positionalParams, _cteScope);
     const kept = [];
     const deletedRows = [];
     for (const row of tbl.rows) {
+      yield;
       const ctx = this.tableBindings(tbl, row, alias);
       if (whereExpr) {
-        const cond = this.evalExpr(whereExpr, ctx, positionalParams, _cteScope);
+        const cond = yield* this.evalExprSteps(whereExpr, ctx, positionalParams, _cteScope);
         if (!isTruthy(cond)) {
           kept.push(row);
           continue;
         }
       }
-      this.fireTriggers(tbl.name, "BEFORE", "DELETE", row.data, void 0);
+      yield* this.fireTriggers(tbl.name, "BEFORE", "DELETE", row.data, void 0);
       deletedRows.push(row);
-      this.fireTriggers(tbl.name, "AFTER", "DELETE", row.data, void 0);
+      yield* this.fireTriggers(tbl.name, "AFTER", "DELETE", row.data, void 0);
     }
     tbl.rows = kept;
     this.lastChanges = deletedRows.length;
     this.totalChanges += deletedRows.length;
     if (returningIdx !== -1) {
-      return this.evaluateReturning(tbl, deletedRows, tokens.slice(returningIdx + 1), positionalParams, _cteScope);
+      return yield* this.evaluateReturning(tbl, deletedRows, tokens.slice(returningIdx + 1), positionalParams, _cteScope);
     }
     return null;
   }
-  evaluateReturning(tbl, rows, returningTokens, positionalParams, cteScope = /* @__PURE__ */ new Map()) {
+  *evaluateReturning(tbl, rows, returningTokens, positionalParams, cteScope = /* @__PURE__ */ new Map()) {
     const items = this.splitTopLevelComma(returningTokens);
     const outCols = [];
     const exprs = [];
     for (const itemToks of items) {
+      yield;
       if (itemToks.length === 1 && itemToks[0].value === "*") {
         for (const c of tbl.columns) {
+          yield;
           outCols.push(c.name);
           exprs.push({ kind: "column", name: c.name });
         }
@@ -3756,15 +4000,19 @@ var SqliteDatabase = class {
       }
     }
     const bindings = this.tableBindings(tbl);
-    for (const expr of exprs)
-      this.validateColumns(expr, bindings, positionalParams, cteScope);
-    const outRows = rows.map((r) => {
+    for (const expr of exprs) {
+      yield;
+      yield* this.validateColumns(expr, bindings, positionalParams, cteScope);
+    }
+    const outRows = yield* stepMap(rows, function* (r) {
       const ctx = this.tableBindings(tbl, r);
-      return exprs.map((e) => this.evalExpr(e, ctx, positionalParams, cteScope));
-    });
+      return yield* stepMap(exprs, function* (e) {
+        return yield* this.evalExprSteps(e, ctx, positionalParams, cteScope);
+      }, this);
+    }, this);
     return { columns: outCols, rows: outRows };
   }
-  executeWith(tokens, positionalParams, outerCtes) {
+  *executeWith(tokens, positionalParams, outerCtes) {
     const cteMap = new Map(outerCtes);
     let idx = 1;
     let isRecursive = false;
@@ -3773,6 +4021,7 @@ var SqliteDatabase = class {
       idx += 1;
     }
     while (idx < tokens.length) {
+      yield;
       const cteName = tokens[idx].value;
       idx += 1;
       let explicitCols;
@@ -3780,6 +4029,7 @@ var SqliteDatabase = class {
         explicitCols = [];
         idx += 1;
         while (idx < tokens.length && tokens[idx]?.value !== ")") {
+          yield;
           if (tokens[idx].value !== ",") {
             explicitCols.push(tokens[idx].value);
           }
@@ -3802,6 +4052,7 @@ var SqliteDatabase = class {
       let depth = 1;
       const bodyTokens = [];
       while (idx < tokens.length && depth > 0) {
+        yield;
         const t = tokens[idx++];
         if (t.value === "(") {
           depth += 1;
@@ -3814,10 +4065,10 @@ var SqliteDatabase = class {
         bodyTokens.push(t);
       }
       if (isRecursive && this.containsTokenWord(bodyTokens, cteName)) {
-        const evaluated = this.evalRecursiveCte(cteName, explicitCols, bodyTokens, positionalParams, cteMap);
+        const evaluated = yield* this.evalRecursiveCte(cteName, explicitCols, bodyTokens, positionalParams, cteMap);
         cteMap.set(cteName.toLowerCase(), evaluated);
       } else {
-        const res = this.executeSelectCompound(bodyTokens, positionalParams, cteMap);
+        const res = yield* this.executeSelectCompound(bodyTokens, positionalParams, cteMap);
         const cols = explicitCols && explicitCols.length > 0 ? explicitCols : res.columns;
         cteMap.set(cteName.toLowerCase(), { columns: cols, rows: res.rows });
       }
@@ -3829,17 +4080,18 @@ var SqliteDatabase = class {
     }
     const mainTokens = tokens.slice(idx);
     const mainSql = reconstructTokensSql(mainTokens);
-    return this.executeStatement(mainSql, positionalParams, cteMap);
+    return yield* this.executeStatementSteps(mainSql, positionalParams, cteMap);
   }
   containsTokenWord(tokens, word) {
     const lower = word.toLowerCase();
     return tokens.some((t) => t.value.toLowerCase() === lower);
   }
-  evalRecursiveCte(cteName, explicitCols, bodyTokens, positionalParams, cteMap) {
+  *evalRecursiveCte(cteName, explicitCols, bodyTokens, positionalParams, cteMap) {
     let d = 0;
     let unionIdx = -1;
     let unionAll = false;
     for (let i = 0; i < bodyTokens.length; i += 1) {
+      yield;
       const t = bodyTokens[i];
       if (t.value === "(") {
         d += 1;
@@ -3852,41 +4104,43 @@ var SqliteDatabase = class {
       }
     }
     if (unionIdx === -1) {
-      const res = this.executeSelectCompound(bodyTokens, positionalParams, cteMap);
+      const res = yield* this.executeSelectCompound(bodyTokens, positionalParams, cteMap);
       return { columns: explicitCols ?? res.columns, rows: res.rows };
     }
     const anchorTokens = bodyTokens.slice(0, unionIdx);
     const recTokens = bodyTokens.slice(unionIdx + (unionAll ? 2 : 1));
-    const anchorRes = this.executeSelectCompound(anchorTokens, positionalParams, cteMap);
+    const anchorRes = yield* this.executeSelectCompound(anchorTokens, positionalParams, cteMap);
     const cols = explicitCols && explicitCols.length > 0 ? explicitCols : anchorRes.columns;
     const scope = new Map(cteMap);
     scope.set(cteName.toLowerCase(), { columns: cols, rows: [] });
     const preparing = this.preparing;
     this.preparing = true;
     try {
-      this.executeSelectCompound(recTokens, positionalParams, scope);
+      yield* this.executeSelectCompound(recTokens, positionalParams, scope);
     } finally {
       this.preparing = preparing;
     }
     if (this.preparing)
       return { columns: cols, rows: [] };
+    this.checkRowCount(anchorRes.rows.length);
     const allRows = [...anchorRes.rows];
     let workingRows = [...anchorRes.rows];
     const seenKeys = /* @__PURE__ */ new Set();
     if (!unionAll) {
       for (const r of allRows) {
+        yield;
         seenKeys.add(serializeSqlJson(r, false));
       }
     }
-    let iterations = 0;
-    const stepMap = new Map(cteMap);
+    const stepMap2 = new Map(cteMap);
     const cteKey = cteName.toLowerCase();
-    while (workingRows.length > 0 && iterations < 5e3) {
-      iterations += 1;
-      stepMap.set(cteKey, { columns: cols, rows: workingRows });
-      const nextRes = this.executeSelectCompound(recTokens, positionalParams, stepMap);
+    while (workingRows.length > 0) {
+      yield;
+      stepMap2.set(cteKey, { columns: cols, rows: workingRows });
+      const nextRes = yield* this.executeSelectCompound(recTokens, positionalParams, stepMap2);
       const nextWorking = [];
       for (const r of nextRes.rows) {
+        yield;
         if (!unionAll) {
           const k = serializeSqlJson(r, false);
           if (seenKeys.has(k)) {
@@ -3894,6 +4148,7 @@ var SqliteDatabase = class {
           }
           seenKeys.add(k);
         }
+        this.checkRowCount(allRows.length + 1);
         allRows.push(r);
         nextWorking.push(r);
       }
@@ -3902,15 +4157,19 @@ var SqliteDatabase = class {
     return { columns: cols, rows: allRows };
   }
   singleSelectCache = /* @__PURE__ */ new WeakMap();
-  executeSelectCompound(tokens, positionalParams, cteScope) {
+  *executeSelectCompound(tokens, positionalParams, cteScope) {
     if (tokens[0]?.value.toUpperCase() === "WITH") {
-      return this.executeWith(tokens, positionalParams, cteScope) ?? { columns: [], rows: [] };
+      return (yield* this.executeWith(tokens, positionalParams, cteScope)) ?? {
+        columns: [],
+        rows: []
+      };
     }
     const segments = [];
     let d = 0;
     let start = 0;
     let pendingOp = "NONE";
     for (let i = 0; i < tokens.length; i += 1) {
+      yield;
       const t = tokens[i];
       if (t.value === "(") {
         d += 1;
@@ -3931,12 +4190,13 @@ var SqliteDatabase = class {
       }
     }
     if (segments.length === 0) {
-      return this.executeSingleSelect(tokens, positionalParams, cteScope);
+      return yield* this.executeSingleSelect(tokens, positionalParams, cteScope);
     }
     const lastSegTokens = tokens.slice(start);
     let orderLimitStart = -1;
     d = 0;
     for (let i = 0; i < lastSegTokens.length; i += 1) {
+      yield;
       const t = lastSegTokens[i];
       if (t.value === "(") {
         d += 1;
@@ -3955,34 +4215,49 @@ var SqliteDatabase = class {
     segments.push({ op: pendingOp, tokens: cleanLastTokens });
     let acc = { columns: [], rows: [] };
     for (const seg of segments) {
-      const res = this.executeSingleSelect(seg.tokens, positionalParams, cteScope);
+      yield;
+      const res = yield* this.executeSingleSelect(seg.tokens, positionalParams, cteScope);
       if (seg.op === "NONE") {
         acc = res;
       } else if (seg.op === "UNION ALL") {
+        this.checkRowCount(acc.rows.length + res.rows.length);
         acc.rows.push(...res.rows);
       } else if (seg.op === "UNION") {
         const combined = [...acc.rows, ...res.rows];
-        acc.rows = this.deduplicateResultRows(combined);
+        acc.rows = yield* this.deduplicateResultRows(combined);
       } else if (seg.op === "INTERSECT") {
-        const rightSet = new Set(res.rows.map((r) => serializeSqlJson(r, false)));
-        acc.rows = this.deduplicateResultRows(acc.rows.filter((r) => rightSet.has(serializeSqlJson(r, false))));
+        const rightSet = new Set(yield* stepMap(res.rows, function* (r) {
+          yield;
+          return serializeSqlJson(r, false);
+        }, this));
+        acc.rows = yield* this.deduplicateResultRows(yield* stepFilter(acc.rows, function* (r) {
+          yield;
+          return rightSet.has(serializeSqlJson(r, false));
+        }, this));
       } else if (seg.op === "EXCEPT") {
-        const rightSet = new Set(res.rows.map((r) => serializeSqlJson(r, false)));
-        acc.rows = this.deduplicateResultRows(acc.rows.filter((r) => !rightSet.has(serializeSqlJson(r, false))));
+        const rightSet = new Set(yield* stepMap(res.rows, function* (r) {
+          yield;
+          return serializeSqlJson(r, false);
+        }, this));
+        acc.rows = yield* this.deduplicateResultRows(yield* stepFilter(acc.rows, function* (r) {
+          yield;
+          return !rightSet.has(serializeSqlJson(r, false));
+        }, this));
       }
     }
     if (tailClauses.length > 0) {
       const tmpScope = new Map(cteScope);
       tmpScope.set("__compound_res__", acc);
       const wrapToks = tokenizeSql(`SELECT * FROM __compound_res__ ${reconstructTokensSql(tailClauses)}`);
-      return this.executeSingleSelect(wrapToks, positionalParams, tmpScope);
+      return yield* this.executeSingleSelect(wrapToks, positionalParams, tmpScope);
     }
     return acc;
   }
-  deduplicateResultRows(rows) {
+  *deduplicateResultRows(rows) {
     const out = [];
     const seen = /* @__PURE__ */ new Set();
     for (const r of rows) {
+      yield;
       const k = serializeSqlJson(r, false);
       if (!seen.has(k)) {
         seen.add(k);
@@ -3991,18 +4266,20 @@ var SqliteDatabase = class {
     }
     return out;
   }
-  executeSingleSelect(tokens, positionalParams, cteScope) {
+  *executeSingleSelect(tokens, positionalParams, cteScope) {
     if (tokens[0]?.value.toUpperCase() === "VALUES") {
       let idx = 1;
       const rows = [];
       let maxCols = 0;
       while (idx < tokens.length) {
+        yield;
         if (tokens[idx]?.value === "(") {
           idx += 1;
           const exprs = [];
           let cur = [];
           let d = 1;
           while (idx < tokens.length && d > 0) {
+            yield;
             const t = tokens[idx++];
             if (t.value === "(") {
               d += 1;
@@ -4021,7 +4298,9 @@ var SqliteDatabase = class {
               cur.push(t);
             }
           }
-          const r = exprs.map((et) => this.evalExpr(new ExprParser(et).parseExpression(), {}, positionalParams));
+          const r = yield* stepMap(exprs, function* (et) {
+            return yield* this.evalExprSteps(new ExprParser(et).parseExpression(), {}, positionalParams);
+          }, this);
           maxCols = Math.max(maxCols, r.length);
           rows.push(r);
         } else {
@@ -4044,6 +4323,7 @@ var SqliteDatabase = class {
       const clausePositions = [];
       let d = 0;
       for (let i = idx; i < tokens.length; i += 1) {
+        yield;
         const t = tokens[i];
         if (t.value === "(") {
           d += 1;
@@ -4081,8 +4361,12 @@ var SqliteDatabase = class {
       const limitTokens2 = getClauseTokens("LIMIT");
       const whereExpr2 = whereTokens && whereTokens.length > 0 ? new ExprParser(whereTokens).parseExpression() : void 0;
       const targetItems2 = this.splitTopLevelComma(selectListTokens);
-      const hasWildcard = targetItems2.some((itemToks) => itemToks.length === 1 && itemToks[0].value === "*" || itemToks.length === 3 && itemToks[1].value === "." && itemToks[2].value === "*");
-      const staticTargets2 = hasWildcard ? void 0 : targetItems2.map((itemToks) => this.parseSelectTarget(itemToks));
+      const hasWildcard = targetItems2.some((itemToks) => {
+        return itemToks.length === 1 && itemToks[0].value === "*" || itemToks.length === 3 && itemToks[1].value === "." && itemToks[2].value === "*";
+      });
+      const staticTargets2 = hasWildcard ? void 0 : targetItems2.map((itemToks) => {
+        return this.parseSelectTarget(itemToks);
+      });
       plan = {
         distinct: distinct2,
         fromTokens: fromTokens2,
@@ -4100,7 +4384,7 @@ var SqliteDatabase = class {
     let workingRows = [{}];
     let sourceSchema = [];
     if (fromTokens && fromTokens.length > 0) {
-      const built = this.evaluateFromClause(fromTokens, positionalParams, cteScope);
+      const built = yield* this.evaluateFromClause(fromTokens, positionalParams, cteScope);
       workingRows = built.rows;
       sourceSchema = built.schema;
     }
@@ -4110,9 +4394,12 @@ var SqliteDatabase = class {
     } else {
       selectTargets = [];
       for (const itemToks of targetItems) {
+        yield;
         if (itemToks.length === 1 && itemToks[0].value === "*") {
           for (const src of sourceSchema) {
+            yield;
             for (const col of src.columns) {
+              yield;
               selectTargets.push({
                 expr: { kind: "column", table: src.tableAlias || void 0, name: col },
                 alias: col
@@ -4121,9 +4408,12 @@ var SqliteDatabase = class {
           }
         } else if (itemToks.length === 3 && itemToks[1].value === "." && itemToks[2].value === "*") {
           const tblAlias = itemToks[0].value;
-          const src = sourceSchema.find((s) => s.tableAlias.toLowerCase() === tblAlias.toLowerCase());
+          const src = sourceSchema.find((s) => {
+            return s.tableAlias.toLowerCase() === tblAlias.toLowerCase();
+          });
           if (src) {
             for (const col of src.columns) {
+              yield;
               selectTargets.push({
                 expr: { kind: "column", table: src.tableAlias, name: col },
                 alias: col
@@ -4137,21 +4427,29 @@ var SqliteDatabase = class {
     }
     const bindings = {};
     for (const source of sourceSchema) {
+      yield;
       for (const column of [...source.columns, "rowid", "_rowid_", "oid"]) {
+        yield;
         bindings[column] = null;
         bindings[`${source.tableAlias}.${column}`] = null;
       }
     }
-    for (const target of selectTargets)
-      this.validateColumns(target.expr, bindings, positionalParams, cteScope);
+    for (const target of selectTargets) {
+      yield;
+      yield* this.validateColumns(target.expr, bindings, positionalParams, cteScope);
+    }
     const aliasBindings = { ...bindings };
-    for (const target of selectTargets)
+    for (const target of selectTargets) {
+      yield;
       aliasBindings[target.alias] = null;
-    this.validateColumns(whereExpr, aliasBindings, positionalParams, cteScope);
+    }
+    yield* this.validateColumns(whereExpr, aliasBindings, positionalParams, cteScope);
     for (const clause of [groupByTokens, havingTokens, orderByTokens]) {
+      yield;
       if (clause) {
         for (const expression of this.splitTopLevelComma(clause)) {
-          this.validateColumns(new ExprParser(expression).parseExpression(), aliasBindings, positionalParams, cteScope);
+          yield;
+          yield* this.validateColumns(new ExprParser(expression).parseExpression(), aliasBindings, positionalParams, cteScope);
         }
       }
     }
@@ -4159,42 +4457,57 @@ var SqliteDatabase = class {
       let depth = 0;
       let start = 0;
       for (let i = 0; i <= limitTokens.length; i += 1) {
+        yield;
         const token = limitTokens[i]?.value;
         if (token === "(")
           depth += 1;
         if (token === ")")
           depth -= 1;
         if (i === limitTokens.length || depth === 0 && (token === "," || token?.toUpperCase() === "OFFSET")) {
-          this.validateColumns(new ExprParser(limitTokens.slice(start, i)).parseExpression(), {}, positionalParams, cteScope);
+          yield* this.validateColumns(new ExprParser(limitTokens.slice(start, i)).parseExpression(), {}, positionalParams, cteScope);
           start = i + 1;
         }
       }
     }
     if (this.preparing)
-      return { columns: selectTargets.map((target) => target.alias), rows: [] };
+      return {
+        columns: selectTargets.map((target) => {
+          return target.alias;
+        }),
+        rows: []
+      };
     if (whereExpr) {
-      workingRows = workingRows.filter((row) => isTruthy(this.evalExpr(whereExpr, row, positionalParams, cteScope)));
+      workingRows = yield* stepFilter(workingRows, function* (row) {
+        return isTruthy(yield* this.evalExprSteps(whereExpr, row, positionalParams, cteScope));
+      }, this);
     }
     const hasGroupBy = Boolean(groupByTokens && groupByTokens.length > 0);
-    const hasAggregateInSelect = selectTargets.some((t) => this.containsAggregate(t.expr));
+    const hasAggregateInSelect = selectTargets.some((t) => {
+      return this.containsAggregate(t.expr);
+    });
     const hasAggregateInHaving = havingTokens ? this.containsAggregate(new ExprParser(havingTokens).parseExpression()) : false;
     const isAggregatedQuery = hasGroupBy || hasAggregateInSelect || hasAggregateInHaving;
     let groupedRows = [];
     if (isAggregatedQuery) {
       if (hasGroupBy) {
-        const groupExprs = this.splitTopLevelComma(groupByTokens).map((gt) => new ExprParser(gt).parseExpression());
+        const groupExprs = this.splitTopLevelComma(groupByTokens).map((gt) => {
+          return new ExprParser(gt).parseExpression();
+        });
         const groups = /* @__PURE__ */ new Map();
         for (const row of workingRows) {
-          const keyVals = groupExprs.map((ge) => {
+          yield;
+          const keyVals = yield* stepMap(groupExprs, function* (ge) {
             if (ge.kind === "literal" && typeof ge.value === "number" && Number.isInteger(ge.value)) {
               const idx1 = ge.value - 1;
               if (selectTargets[idx1]) {
-                return this.evalExpr(selectTargets[idx1].expr, row, positionalParams, cteScope);
+                return yield* this.evalExprSteps(selectTargets[idx1].expr, row, positionalParams, cteScope);
               }
             }
-            return this.evalExpr(ge, row, positionalParams, cteScope);
-          });
-          const keyStr = serializeSqlJson(keyVals.map((v) => [typeof v, v]), false);
+            return yield* this.evalExprSteps(ge, row, positionalParams, cteScope);
+          }, this);
+          const keyStr = serializeSqlJson(keyVals.map((v) => {
+            return [typeof v, v];
+          }), false);
           const existing = groups.get(keyStr);
           if (existing) {
             existing.group.push(row);
@@ -4208,45 +4521,51 @@ var SqliteDatabase = class {
       }
       if (havingTokens && havingTokens.length > 0) {
         const havingExpr = new ExprParser(havingTokens).parseExpression();
-        groupedRows = groupedRows.filter((g) => {
+        groupedRows = yield* stepFilter(groupedRows, function* (g) {
           const repCtx = { ...g.representative };
           for (const st of selectTargets) {
+            yield;
             if (!(st.alias in repCtx)) {
-              repCtx[st.alias] = this.evalExprWithAgg(st.expr, g.representative, g.group, positionalParams, cteScope);
+              repCtx[st.alias] = yield* this.evalExprWithAgg(st.expr, g.representative, g.group, positionalParams, cteScope);
             }
           }
-          return isTruthy(this.evalExprWithAgg(havingExpr, repCtx, g.group, positionalParams, cteScope));
-        });
+          return isTruthy(yield* this.evalExprWithAgg(havingExpr, repCtx, g.group, positionalParams, cteScope));
+        }, this);
       }
     } else {
-      groupedRows = workingRows.map((r) => ({ representative: r, group: [r] }));
+      groupedRows = yield* stepMap(workingRows, function* (r) {
+        yield;
+        return { representative: r, group: [r] };
+      }, this);
     }
     const windowResults = /* @__PURE__ */ new Map();
     for (const st of selectTargets) {
-      this.collectWindowExprs(st.expr, groupedRows, positionalParams, cteScope, windowResults);
+      yield;
+      yield* this.collectWindowExprs(st.expr, groupedRows, positionalParams, cteScope, windowResults);
     }
-    const projected = groupedRows.map((g, rowIdx) => {
+    const projected = yield* stepMap(groupedRows, function* (g, rowIdx) {
       const repCtx = { ...g.representative };
-      const values = selectTargets.map((st) => {
-        const val = this.evalExprWithAggAndWindow(st.expr, repCtx, g.group, rowIdx, windowResults, positionalParams, cteScope);
+      const values = yield* stepMap(selectTargets, function* (st) {
+        const val = yield* this.evalExprWithAggAndWindow(st.expr, repCtx, g.group, rowIdx, windowResults, positionalParams, cteScope);
         if (!(st.alias in repCtx)) {
           repCtx[st.alias] = val;
         }
         return val;
-      });
+      }, this);
       return { values, ctx: repCtx, group: g.group };
-    });
+    }, this);
     let finalProjected = projected;
     if (distinct) {
       const seen = /* @__PURE__ */ new Set();
-      finalProjected = projected.filter((p) => {
+      finalProjected = yield* stepFilter(projected, function* (p) {
+        yield;
         const k = serializeSqlJson(p.values, false);
         if (seen.has(k)) {
           return false;
         }
         seen.add(k);
         return true;
-      });
+      }, this);
     }
     if (orderByTokens && orderByTokens.length > 0) {
       const orderSpecs = this.splitTopLevelComma(orderByTokens).map((ot) => {
@@ -4272,8 +4591,9 @@ var SqliteDatabase = class {
         }
         return { expr, desc, nulls, collation };
       });
-      finalProjected.sort((a, b) => {
+      yield* stepSort(finalProjected, function* (a, b) {
         for (const spec of orderSpecs) {
+          yield;
           let vA;
           let vB;
           if (spec.expr.kind === "literal" && typeof spec.expr.value === "number" && Number.isInteger(spec.expr.value)) {
@@ -4281,8 +4601,8 @@ var SqliteDatabase = class {
             vA = a.values[colIdx] ?? null;
             vB = b.values[colIdx] ?? null;
           } else {
-            vA = this.evalExprWithAgg(spec.expr, a.ctx, a.group, positionalParams, cteScope);
-            vB = this.evalExprWithAgg(spec.expr, b.ctx, b.group, positionalParams, cteScope);
+            vA = yield* this.evalExprWithAgg(spec.expr, a.ctx, a.group, positionalParams, cteScope);
+            vB = yield* this.evalExprWithAgg(spec.expr, b.ctx, b.group, positionalParams, cteScope);
           }
           if (vA === null && vB === null) {
             continue;
@@ -4311,21 +4631,25 @@ var SqliteDatabase = class {
           }
         }
         return 0;
-      });
+      }, this);
     }
     if (limitTokens && limitTokens.length > 0) {
-      const offsetIdx = limitTokens.findIndex((t) => t.value.toUpperCase() === "OFFSET");
-      const commaIdx = limitTokens.findIndex((t) => t.value === ",");
+      const offsetIdx = limitTokens.findIndex((t) => {
+        return t.value.toUpperCase() === "OFFSET";
+      });
+      const commaIdx = limitTokens.findIndex((t) => {
+        return t.value === ",";
+      });
       let limitVal = -1;
       let offsetVal = 0;
       if (offsetIdx !== -1) {
-        limitVal = Math.trunc(toSqlNumber(this.evalExpr(new ExprParser(limitTokens.slice(0, offsetIdx)).parseExpression(), {}, positionalParams)));
-        offsetVal = Math.trunc(toSqlNumber(this.evalExpr(new ExprParser(limitTokens.slice(offsetIdx + 1)).parseExpression(), {}, positionalParams)));
+        limitVal = Math.trunc(toSqlNumber(yield* this.evalExprSteps(new ExprParser(limitTokens.slice(0, offsetIdx)).parseExpression(), {}, positionalParams)));
+        offsetVal = Math.trunc(toSqlNumber(yield* this.evalExprSteps(new ExprParser(limitTokens.slice(offsetIdx + 1)).parseExpression(), {}, positionalParams)));
       } else if (commaIdx !== -1) {
-        offsetVal = Math.trunc(toSqlNumber(this.evalExpr(new ExprParser(limitTokens.slice(0, commaIdx)).parseExpression(), {}, positionalParams)));
-        limitVal = Math.trunc(toSqlNumber(this.evalExpr(new ExprParser(limitTokens.slice(commaIdx + 1)).parseExpression(), {}, positionalParams)));
+        offsetVal = Math.trunc(toSqlNumber(yield* this.evalExprSteps(new ExprParser(limitTokens.slice(0, commaIdx)).parseExpression(), {}, positionalParams)));
+        limitVal = Math.trunc(toSqlNumber(yield* this.evalExprSteps(new ExprParser(limitTokens.slice(commaIdx + 1)).parseExpression(), {}, positionalParams)));
       } else {
-        limitVal = Math.trunc(toSqlNumber(this.evalExpr(new ExprParser(limitTokens).parseExpression(), {}, positionalParams)));
+        limitVal = Math.trunc(toSqlNumber(yield* this.evalExprSteps(new ExprParser(limitTokens).parseExpression(), {}, positionalParams)));
       }
       if (offsetVal > 0) {
         finalProjected = finalProjected.slice(offsetVal);
@@ -4335,11 +4659,15 @@ var SqliteDatabase = class {
       }
     }
     return {
-      columns: selectTargets.map((t) => t.alias),
-      rows: finalProjected.map((p) => p.values)
+      columns: selectTargets.map((t) => {
+        return t.alias;
+      }),
+      rows: finalProjected.map((p) => {
+        return p.values;
+      })
     };
   }
-  evaluateFromClause(fromTokens, positionalParams, cteScope) {
+  *evaluateFromClause(fromTokens, positionalParams, cteScope) {
     const items = [];
     let i = 0;
     const consumeJoinSource = () => {
@@ -4404,6 +4732,7 @@ var SqliteDatabase = class {
     const firstSrc = consumeJoinSource();
     items.push({ joinType: "INNER", natural: false, sourceTokens: firstSrc });
     while (i < fromTokens.length) {
+      yield;
       let joinType = "INNER";
       let natural = false;
       if (fromTokens[i]?.value === ",") {
@@ -4411,6 +4740,7 @@ var SqliteDatabase = class {
         i += 1;
       } else {
         while (i < fromTokens.length) {
+          yield;
           const u = fromTokens[i].value.toUpperCase();
           if (u === "NATURAL") {
             natural = true;
@@ -4450,18 +4780,26 @@ var SqliteDatabase = class {
     let currentRows = [];
     const schema = [];
     for (let itemIdx = 0; itemIdx < items.length; itemIdx += 1) {
+      yield;
       const item = items[itemIdx];
       const preparationScope = {};
       if (this.preparing || currentRows.length === 0) {
         for (const source of schema) {
+          yield;
           for (const column of [...source.columns, "rowid", "_rowid_", "oid"]) {
+            yield;
             preparationScope[column] = null;
             preparationScope[`${source.tableAlias}.${column}`] = null;
           }
         }
       }
-      const resolved = this.resolveSingleTableSource(item.sourceTokens, this.preparing || currentRows.length === 0 ? [preparationScope] : currentRows, positionalParams, cteScope, itemIdx > 0 && currentRows.length === 0);
-      const prevCols = new Set(schema.flatMap((s) => s.columns.map((c) => c.toLowerCase())));
+      const resolved = yield* this.resolveSingleTableSource(item.sourceTokens, this.preparing || currentRows.length === 0 ? [preparationScope] : currentRows, positionalParams, cteScope, itemIdx > 0 && currentRows.length === 0);
+      const prevCols = new Set(yield* stepFlatMap(schema, function* (s) {
+        yield;
+        return s.columns.map((c) => {
+          return c.toLowerCase();
+        });
+      }, this));
       schema.push({ tableAlias: resolved.alias, columns: resolved.columns });
       if (itemIdx === 0) {
         currentRows = resolved.rows;
@@ -4471,30 +4809,39 @@ var SqliteDatabase = class {
       const onExpr = item.onTokens ? new ExprParser(item.onTokens).parseExpression() : void 0;
       const joinBindings = {};
       for (const source of schema) {
+        yield;
         for (const column of [...source.columns, "rowid", "_rowid_", "oid"]) {
+          yield;
           joinBindings[column] = null;
           joinBindings[`${source.tableAlias}.${column}`] = null;
         }
       }
-      this.validateColumns(onExpr, joinBindings, positionalParams, cteScope);
-      const usingList = item.natural ? resolved.columns.filter((c) => prevCols.has(c.toLowerCase())) : item.usingCols;
+      yield* this.validateColumns(onExpr, joinBindings, positionalParams, cteScope);
+      const usingList = item.natural ? yield* stepFilter(resolved.columns, function* (c) {
+        yield;
+        return prevCols.has(c.toLowerCase());
+      }, this) : item.usingCols;
       const rightMatched = /* @__PURE__ */ new Set();
       for (const leftRow of currentRows) {
-        const candidateRightRows = resolved.isCorrelated ? this.resolveSingleTableSource(item.sourceTokens, [leftRow], positionalParams, cteScope).rows : resolved.rows;
+        yield;
+        const candidateRightRows = resolved.isCorrelated ? (yield* this.resolveSingleTableSource(item.sourceTokens, [leftRow], positionalParams, cteScope)).rows : resolved.rows;
         let matchedLeft = false;
         for (let rIdx = 0; rIdx < candidateRightRows.length; rIdx += 1) {
+          yield;
           const rightRow = candidateRightRows[rIdx];
           const merged = { ...leftRow };
           for (const [k, v] of Object.entries(rightRow)) {
+            yield;
             if (k.includes(".") || !(k in merged) || merged[k] === null) {
               merged[k] = v;
             }
           }
           let matches = true;
           if (onExpr) {
-            matches = isTruthy(this.evalExpr(onExpr, merged, positionalParams, cteScope));
+            matches = isTruthy(yield* this.evalExprSteps(onExpr, merged, positionalParams, cteScope));
           } else if (usingList && usingList.length > 0) {
             for (const uCol of usingList) {
+              yield;
               const lVal = this.lookupColInRow(leftRow, void 0, uCol);
               const rVal = this.lookupColInRow(rightRow, resolved.alias, uCol);
               if (lVal === null || rVal === null || !sqlEquals(lVal, rVal)) {
@@ -4506,32 +4853,39 @@ var SqliteDatabase = class {
           if (matches) {
             matchedLeft = true;
             rightMatched.add(rIdx);
+            this.checkRowCount(nextRows.length + 1);
             nextRows.push(merged);
           }
         }
         if (!matchedLeft && (item.joinType === "LEFT" || item.joinType === "FULL")) {
           const nullPadded = { ...leftRow };
           for (const col of resolved.columns) {
+            yield;
             nullPadded[`${resolved.alias}.${col}`] = null;
             if (!(col in nullPadded)) {
               nullPadded[col] = null;
             }
           }
+          this.checkRowCount(nextRows.length + 1);
           nextRows.push(nullPadded);
         }
       }
       if (item.joinType === "RIGHT" || item.joinType === "FULL") {
         for (let rIdx = 0; rIdx < resolved.rows.length; rIdx += 1) {
+          yield;
           if (!rightMatched.has(rIdx)) {
             const rightRow = resolved.rows[rIdx];
             const nullPadded = {};
             for (const s of schema.slice(0, -1)) {
+              yield;
               for (const col of s.columns) {
+                yield;
                 nullPadded[`${s.tableAlias}.${col}`] = null;
                 nullPadded[col] = null;
               }
             }
             Object.assign(nullPadded, rightRow);
+            this.checkRowCount(nextRows.length + 1);
             nextRows.push(nullPadded);
           }
         }
@@ -4540,7 +4894,7 @@ var SqliteDatabase = class {
     }
     return { rows: currentRows, schema };
   }
-  resolveSingleTableSource(srcTokens, outerRows, positionalParams, cteScope, prepareTvf = false) {
+  *resolveSingleTableSource(srcTokens, outerRows, positionalParams, cteScope, prepareTvf = false) {
     if (srcTokens.length === 0) {
       return { alias: "", columns: [], rows: [{}] };
     }
@@ -4549,6 +4903,7 @@ var SqliteDatabase = class {
       let p = 1;
       const inner = [];
       while (p < srcTokens.length && d > 0) {
+        yield;
         const t = srcTokens[p++];
         if (t.value === "(") {
           d += 1;
@@ -4564,18 +4919,19 @@ var SqliteDatabase = class {
         p += 1;
       }
       const alias2 = srcTokens[p]?.value ?? "subquery";
-      const res = this.executeStatement(reconstructTokensSql(inner), positionalParams, cteScope) ?? {
+      const res = (yield* this.executeStatementSteps(reconstructTokensSql(inner), positionalParams, cteScope)) ?? {
         columns: [],
         rows: []
       };
-      const rows2 = res.rows.map((r) => {
+      const rows2 = yield* stepMap(res.rows, function* (r) {
+        yield;
         const obj = {};
         res.columns.forEach((c, idx2) => {
           obj[c] = r[idx2] ?? null;
           obj[`${alias2}.${c}`] = r[idx2] ?? null;
         });
         return obj;
-      });
+      }, this);
       return { alias: alias2, columns: res.columns, rows: rows2 };
     }
     let idx = 0;
@@ -4590,6 +4946,7 @@ var SqliteDatabase = class {
       let cur = [];
       let d = 1;
       while (idx < srcTokens.length && d > 0) {
+        yield;
         const t = srcTokens[idx++];
         if (t.value === "(") {
           d += 1;
@@ -4615,25 +4972,30 @@ var SqliteDatabase = class {
       }
       const alias2 = srcTokens[idx]?.value ?? name;
       const outerCtx = outerRows[0] ?? {};
-      const isCorrelated = argToks.some((at) => at.some((t) => t.type === "word" || t.type === "ident"));
+      const isCorrelated = argToks.some((at) => {
+        return at.some((t) => {
+          return t.type === "word" || t.type === "ident";
+        });
+      });
       const prepare = this.preparing || prepareTvf && isCorrelated;
-      const args = argToks.map((at) => {
+      const args = yield* stepMap(argToks, function* (at) {
         const expression = new ExprParser(at).parseExpression();
         if (prepare) {
-          this.validateColumns(expression, outerCtx, positionalParams, cteScope);
+          yield* this.validateColumns(expression, outerCtx, positionalParams, cteScope);
           return null;
         }
-        return this.evalExpr(expression, outerCtx, positionalParams, cteScope);
-      });
+        return yield* this.evalExprSteps(expression, outerCtx, positionalParams, cteScope);
+      }, this);
       const preparing = this.preparing;
       this.preparing = prepare;
       let tvf;
       try {
-        tvf = this.evaluateTableValuedFunction(name, args);
+        tvf = yield* this.evaluateTableValuedFunction(name, args);
       } finally {
         this.preparing = preparing;
       }
-      const rows2 = tvf.rows.map((r) => {
+      const rows2 = yield* stepMap(tvf.rows, function* (r) {
+        yield;
         const obj = {};
         tvf.columns.forEach((c, cIdx) => {
           obj[c] = r[cIdx] ?? null;
@@ -4641,7 +5003,7 @@ var SqliteDatabase = class {
           obj[`${name}.${c}`] = r[cIdx] ?? null;
         });
         return obj;
-      });
+      }, this);
       return { alias: alias2, columns: tvf.columns, rows: rows2, isCorrelated };
     }
     if (srcTokens[idx]?.value.toUpperCase() === "AS") {
@@ -4650,7 +5012,8 @@ var SqliteDatabase = class {
     const alias = srcTokens[idx]?.value ?? name;
     const cte = cteScope.get(name.toLowerCase());
     if (cte) {
-      const rows2 = cte.rows.map((r) => {
+      const rows2 = yield* stepMap(cte.rows, function* (r) {
+        yield;
         const obj = {};
         cte.columns.forEach((c, cIdx) => {
           obj[c] = r[cIdx] ?? null;
@@ -4658,7 +5021,7 @@ var SqliteDatabase = class {
           obj[`${name}.${c}`] = r[cIdx] ?? null;
         });
         return obj;
-      });
+      }, this);
       return { alias, columns: cte.columns, rows: rows2 };
     }
     const lowerName = name.toLowerCase();
@@ -4666,7 +5029,10 @@ var SqliteDatabase = class {
       const cols2 = ["name", "seq"];
       const seqResultRows = [];
       for (const tbl2 of this.tables.values()) {
-        if ((tbl2.columns.some((c) => c.autoIncrement) || tbl2.maxAutoInc > 0) && tbl2.maxAutoInc > 0) {
+        yield;
+        if ((tbl2.columns.some((c) => {
+          return c.autoIncrement;
+        }) || tbl2.maxAutoInc > 0) && tbl2.maxAutoInc > 0) {
           const entry = {
             name: tbl2.name,
             seq: tbl2.maxAutoInc,
@@ -4683,6 +5049,7 @@ var SqliteDatabase = class {
       const masterRows = [];
       if (this.loadedMaster) {
         for (const m of this.loadedMaster) {
+          yield;
           const entry = {
             type: m.type,
             name: m.name,
@@ -4691,6 +5058,7 @@ var SqliteDatabase = class {
             sql: m.sql || null
           };
           for (const c of cols2) {
+            yield;
             entry[`${alias}.${c}`] = entry[c];
           }
           masterRows.push(entry);
@@ -4699,6 +5067,7 @@ var SqliteDatabase = class {
       }
       let rp = 2;
       for (const tbl2 of this.tables.values()) {
+        yield;
         const entry = {
           type: "table",
           name: tbl2.name,
@@ -4707,11 +5076,13 @@ var SqliteDatabase = class {
           sql: tbl2.sql
         };
         for (const c of cols2) {
+          yield;
           entry[`${alias}.${c}`] = entry[c];
         }
         masterRows.push(entry);
       }
       for (const idxDef of this.indexes.values()) {
+        yield;
         const entry = {
           type: "index",
           name: idxDef.name,
@@ -4720,11 +5091,13 @@ var SqliteDatabase = class {
           sql: idxDef.sql
         };
         for (const c of cols2) {
+          yield;
           entry[`${alias}.${c}`] = entry[c];
         }
         masterRows.push(entry);
       }
       for (const vDef of this.views.values()) {
+        yield;
         const entry = {
           type: "view",
           name: vDef.name,
@@ -4733,11 +5106,13 @@ var SqliteDatabase = class {
           sql: vDef.sql
         };
         for (const c of cols2) {
+          yield;
           entry[`${alias}.${c}`] = entry[c];
         }
         masterRows.push(entry);
       }
       for (const trDef of this.triggers.values()) {
+        yield;
         const entry = {
           type: "trigger",
           name: trDef.name,
@@ -4746,6 +5121,7 @@ var SqliteDatabase = class {
           sql: trDef.sql
         };
         for (const c of cols2) {
+          yield;
           entry[`${alias}.${c}`] = entry[c];
         }
         masterRows.push(entry);
@@ -4754,9 +5130,10 @@ var SqliteDatabase = class {
     }
     const view = this.findView(name);
     if (view) {
-      const res = this.executeStatement(view.selectSql, positionalParams, cteScope) ?? { columns: [], rows: [] };
+      const res = (yield* this.executeStatementSteps(view.selectSql, positionalParams, cteScope)) ?? { columns: [], rows: [] };
       const cols2 = view.columns && view.columns.length > 0 ? view.columns : res.columns;
-      const rows2 = res.rows.map((r) => {
+      const rows2 = yield* stepMap(res.rows, function* (r) {
+        yield;
         const obj = {};
         cols2.forEach((c, cIdx) => {
           obj[c] = r[cIdx] ?? null;
@@ -4764,15 +5141,17 @@ var SqliteDatabase = class {
           obj[`${name}.${c}`] = r[cIdx] ?? null;
         });
         return obj;
-      });
+      }, this);
       return { alias, columns: cols2, rows: rows2 };
     }
     const tbl = this.findTable(name);
     if (!tbl) {
       throw new Error(`no such table: ${name}`);
     }
-    const cols = tbl.columns.map((c) => c.name);
-    const rows = (this.preparing ? [] : tbl.rows).map((r) => {
+    const cols = tbl.columns.map((c) => {
+      return c.name;
+    });
+    const rows = yield* stepMap(this.preparing ? [] : tbl.rows, function* (r) {
       const obj = {
         rowid: r.rowid,
         _rowid_: r.rowid,
@@ -4781,16 +5160,17 @@ var SqliteDatabase = class {
         [`${name}.rowid`]: r.rowid
       };
       for (const c of cols) {
+        yield;
         const val = r.data[c] ?? null;
         obj[c] = val;
         obj[`${alias}.${c}`] = val;
         obj[`${name}.${c}`] = val;
       }
       return obj;
-    });
+    }, this);
     return { alias, columns: cols, rows };
   }
-  evaluateTableValuedFunction(fnName, args) {
+  *evaluateTableValuedFunction(fnName, args) {
     const lower = fnName.toLowerCase();
     if (lower === "generate_series") {
       if (this.preparing)
@@ -4800,11 +5180,15 @@ var SqliteDatabase = class {
       const step = args[2] !== void 0 ? Math.trunc(toSqlNumber(args[2])) : 1;
       const rows = [];
       if (step > 0) {
-        for (let v = start; v <= stop && rows.length < 1e5; v += step) {
+        for (let v = start; v <= stop; v += step) {
+          yield;
+          this.checkRowCount(rows.length + 1);
           rows.push([v]);
         }
       } else if (step < 0) {
-        for (let v = start; v >= stop && rows.length < 1e5; v += step) {
+        for (let v = start; v >= stop; v += step) {
+          yield;
+          this.checkRowCount(rows.length + 1);
           rows.push([v]);
         }
       }
@@ -4852,6 +5236,7 @@ var SqliteDatabase = class {
         const isContainer = tStr === "array" || tStr === "object";
         const sqlVal = isContainer ? serializeSqlJson(val) : val === null ? null : typeof val === "boolean" ? val ? 1 : 0 : val;
         const atom = isContainer ? null : sqlVal;
+        this.checkRowCount(rows.length + 1);
         rows.push([key, sqlVal, tStr, atom, myId, parentId, fullkey, pathStr]);
         return myId;
       };
@@ -4862,6 +5247,7 @@ var SqliteDatabase = class {
           });
         } else if (target && typeof target === "object") {
           for (const [k, item] of Object.entries(target)) {
+            yield;
             toRow(k, item, null, `${rootPath}.${k}`, rootPath);
           }
         } else if (target !== void 0) {
@@ -4973,43 +5359,48 @@ var SqliteDatabase = class {
     }
     return false;
   }
-  collectWindowExprs(expr, groupedRows, positionalParams, cteScope, out) {
+  *collectWindowExprs(expr, groupedRows, positionalParams, cteScope, out) {
     if (expr.kind === "func" && expr.over) {
-      const values = this.evaluateWindowFunc(expr, groupedRows, positionalParams, cteScope);
+      const values = yield* this.evaluateWindowFunc(expr, groupedRows, positionalParams, cteScope);
       out.set(expr, values);
       return;
     }
     if (expr.kind === "unary") {
-      this.collectWindowExprs(expr.expr, groupedRows, positionalParams, cteScope, out);
+      yield* this.collectWindowExprs(expr.expr, groupedRows, positionalParams, cteScope, out);
     } else if (expr.kind === "binary") {
-      this.collectWindowExprs(expr.left, groupedRows, positionalParams, cteScope, out);
-      this.collectWindowExprs(expr.right, groupedRows, positionalParams, cteScope, out);
+      yield* this.collectWindowExprs(expr.left, groupedRows, positionalParams, cteScope, out);
+      yield* this.collectWindowExprs(expr.right, groupedRows, positionalParams, cteScope, out);
     } else if (expr.kind === "func") {
       for (const a of expr.args) {
-        this.collectWindowExprs(a, groupedRows, positionalParams, cteScope, out);
+        yield;
+        yield* this.collectWindowExprs(a, groupedRows, positionalParams, cteScope, out);
       }
     } else if (expr.kind === "case") {
       if (expr.base) {
-        this.collectWindowExprs(expr.base, groupedRows, positionalParams, cteScope, out);
+        yield* this.collectWindowExprs(expr.base, groupedRows, positionalParams, cteScope, out);
       }
       for (const b of expr.branches) {
-        this.collectWindowExprs(b.when, groupedRows, positionalParams, cteScope, out);
-        this.collectWindowExprs(b.then, groupedRows, positionalParams, cteScope, out);
+        yield;
+        yield* this.collectWindowExprs(b.when, groupedRows, positionalParams, cteScope, out);
+        yield* this.collectWindowExprs(b.then, groupedRows, positionalParams, cteScope, out);
       }
       if (expr.elseExpr) {
-        this.collectWindowExprs(expr.elseExpr, groupedRows, positionalParams, cteScope, out);
+        yield* this.collectWindowExprs(expr.elseExpr, groupedRows, positionalParams, cteScope, out);
       }
     } else if (expr.kind === "cast") {
-      this.collectWindowExprs(expr.expr, groupedRows, positionalParams, cteScope, out);
+      yield* this.collectWindowExprs(expr.expr, groupedRows, positionalParams, cteScope, out);
     }
   }
-  evaluateWindowFunc(fnExpr, groupedRows, positionalParams, cteScope) {
+  *evaluateWindowFunc(fnExpr, groupedRows, positionalParams, cteScope) {
     const result = new Array(groupedRows.length).fill(null);
     const over = fnExpr.over;
     const partitions = /* @__PURE__ */ new Map();
     for (let i = 0; i < groupedRows.length; i += 1) {
+      yield;
       const g = groupedRows[i];
-      const pKey = serializeSqlJson(over.partitionBy.map((pe) => this.evalExprWithAgg(pe, g.representative, g.group, positionalParams, cteScope)), false);
+      const pKey = serializeSqlJson(yield* stepMap(over.partitionBy, function* (pe) {
+        return yield* this.evalExprWithAgg(pe, g.representative, g.group, positionalParams, cteScope);
+      }, this), false);
       const arr = partitions.get(pKey);
       if (arr) {
         arr.push(i);
@@ -5019,28 +5410,33 @@ var SqliteDatabase = class {
     }
     const fnUpper = fnExpr.name.toUpperCase();
     for (const indices of partitions.values()) {
+      yield;
       if (over.orderBy.length > 0) {
-        indices.sort((iA, iB) => {
+        yield* stepSort(indices, function* (iA, iB) {
           const gA = groupedRows[iA];
           const gB = groupedRows[iB];
           for (const ob of over.orderBy) {
-            const vA = this.evalExprWithAgg(ob.expr, gA.representative, gA.group, positionalParams, cteScope);
-            const vB = this.evalExprWithAgg(ob.expr, gB.representative, gB.group, positionalParams, cteScope);
+            yield;
+            const vA = yield* this.evalExprWithAgg(ob.expr, gA.representative, gA.group, positionalParams, cteScope);
+            const vB = yield* this.evalExprWithAgg(ob.expr, gB.representative, gB.group, positionalParams, cteScope);
             const cmp = compareSqlValues(vA, vB);
             if (cmp !== 0) {
               return ob.desc ? -cmp : cmp;
             }
           }
           return iA - iB;
-        });
+        }, this);
       }
-      const orderPeerKeys = indices.map((idx) => {
+      const orderPeerKeys = yield* stepMap(indices, function* (idx) {
         const g = groupedRows[idx];
-        return serializeSqlJson(over.orderBy.map((ob) => this.evalExprWithAgg(ob.expr, g.representative, g.group, positionalParams, cteScope)), false);
-      });
+        return serializeSqlJson(yield* stepMap(over.orderBy, function* (ob) {
+          return yield* this.evalExprWithAgg(ob.expr, g.representative, g.group, positionalParams, cteScope);
+        }, this), false);
+      }, this);
       let currentRank = 1;
       let currentDenseRank = 1;
       for (let pPos = 0; pPos < indices.length; pPos += 1) {
+        yield;
         const rowIdx = indices[pPos];
         const g = groupedRows[rowIdx];
         if (pPos > 0 && orderPeerKeys[pPos] !== orderPeerKeys[pPos - 1]) {
@@ -5054,77 +5450,85 @@ var SqliteDatabase = class {
         } else if (fnUpper === "DENSE_RANK") {
           result[rowIdx] = currentDenseRank;
         } else if (fnUpper === "NTILE") {
-          const buckets = Math.max(1, Math.trunc(toSqlNumber(this.evalExprWithAgg(fnExpr.args[0], g.representative, g.group, positionalParams, cteScope))));
+          const buckets = Math.max(1, Math.trunc(toSqlNumber(yield* this.evalExprWithAgg(fnExpr.args[0], g.representative, g.group, positionalParams, cteScope))));
           result[rowIdx] = Math.floor(pPos * buckets / indices.length) + 1;
         } else if (fnUpper === "PERCENT_RANK") {
           result[rowIdx] = indices.length <= 1 ? 0 : (currentRank - 1) / (indices.length - 1);
         } else if (fnUpper === "CUME_DIST") {
           let peerEnd = pPos;
           while (peerEnd + 1 < indices.length && orderPeerKeys[peerEnd + 1] === orderPeerKeys[pPos]) {
+            yield;
             peerEnd += 1;
           }
           result[rowIdx] = (peerEnd + 1) / indices.length;
         } else if (fnUpper === "LAG" || fnUpper === "LEAD") {
-          const offset = fnExpr.args[1] ? Math.trunc(toSqlNumber(this.evalExprWithAgg(fnExpr.args[1], g.representative, g.group, positionalParams, cteScope))) : 1;
-          const defVal = fnExpr.args[2] ? this.evalExprWithAgg(fnExpr.args[2], g.representative, g.group, positionalParams, cteScope) : null;
+          const offset = fnExpr.args[1] ? Math.trunc(toSqlNumber(yield* this.evalExprWithAgg(fnExpr.args[1], g.representative, g.group, positionalParams, cteScope))) : 1;
+          const defVal = fnExpr.args[2] ? yield* this.evalExprWithAgg(fnExpr.args[2], g.representative, g.group, positionalParams, cteScope) : null;
           const targetPos = fnUpper === "LAG" ? pPos - offset : pPos + offset;
           if (targetPos < 0 || targetPos >= indices.length) {
             result[rowIdx] = defVal;
           } else {
             const targetG = groupedRows[indices[targetPos]];
-            result[rowIdx] = this.evalExprWithAgg(fnExpr.args[0], targetG.representative, targetG.group, positionalParams, cteScope);
+            result[rowIdx] = yield* this.evalExprWithAgg(fnExpr.args[0], targetG.representative, targetG.group, positionalParams, cteScope);
           }
         } else if (fnUpper === "FIRST_VALUE") {
           const firstG = groupedRows[indices[0]];
-          result[rowIdx] = this.evalExprWithAgg(fnExpr.args[0], firstG.representative, firstG.group, positionalParams, cteScope);
+          result[rowIdx] = yield* this.evalExprWithAgg(fnExpr.args[0], firstG.representative, firstG.group, positionalParams, cteScope);
         } else if (fnUpper === "LAST_VALUE") {
           let peerEnd = over.orderBy.length > 0 ? pPos : indices.length - 1;
           while (over.orderBy.length > 0 && peerEnd + 1 < indices.length && orderPeerKeys[peerEnd + 1] === orderPeerKeys[pPos]) {
+            yield;
             peerEnd += 1;
           }
           const lastG = groupedRows[indices[peerEnd]];
-          result[rowIdx] = this.evalExprWithAgg(fnExpr.args[0], lastG.representative, lastG.group, positionalParams, cteScope);
+          result[rowIdx] = yield* this.evalExprWithAgg(fnExpr.args[0], lastG.representative, lastG.group, positionalParams, cteScope);
         } else if (fnUpper === "NTH_VALUE") {
-          const n = Math.trunc(toSqlNumber(this.evalExprWithAgg(fnExpr.args[1], g.representative, g.group, positionalParams, cteScope)));
+          const n = Math.trunc(toSqlNumber(yield* this.evalExprWithAgg(fnExpr.args[1], g.representative, g.group, positionalParams, cteScope)));
           if (n >= 1 && n <= indices.length) {
             const nthG = groupedRows[indices[n - 1]];
-            result[rowIdx] = this.evalExprWithAgg(fnExpr.args[0], nthG.representative, nthG.group, positionalParams, cteScope);
+            result[rowIdx] = yield* this.evalExprWithAgg(fnExpr.args[0], nthG.representative, nthG.group, positionalParams, cteScope);
           } else {
             result[rowIdx] = null;
           }
         } else {
           let frameEnd = over.orderBy.length > 0 ? pPos : indices.length - 1;
           while (over.orderBy.length > 0 && frameEnd + 1 < indices.length && orderPeerKeys[frameEnd + 1] === orderPeerKeys[pPos]) {
+            yield;
             frameEnd += 1;
           }
-          const frameRows = indices.slice(0, frameEnd + 1).flatMap((idx) => groupedRows[idx].group);
+          const frameRows = yield* stepFlatMap(indices.slice(0, frameEnd + 1), function* (idx) {
+            yield;
+            return groupedRows[idx].group;
+          }, this);
           const strippedFn = { ...fnExpr, over: void 0 };
-          result[rowIdx] = this.evalAggregateFunction(strippedFn, frameRows, positionalParams, cteScope);
+          result[rowIdx] = yield* this.evalAggregateFunction(strippedFn, frameRows, positionalParams, cteScope);
         }
       }
     }
     return result;
   }
-  evalExprWithAggAndWindow(expr, rep, group, rowIdx, windowResults, positionalParams, cteScope) {
+  *evalExprWithAggAndWindow(expr, rep, group, rowIdx, windowResults, positionalParams, cteScope) {
     if (windowResults.has(expr)) {
       return windowResults.get(expr)[rowIdx] ?? null;
     }
     if (expr.kind === "unary") {
-      const v = this.evalExprWithAggAndWindow(expr.expr, rep, group, rowIdx, windowResults, positionalParams, cteScope);
+      const v = yield* this.evalExprWithAggAndWindow(expr.expr, rep, group, rowIdx, windowResults, positionalParams, cteScope);
       return this.applyUnary(expr.op, v);
     }
     if (expr.kind === "binary") {
-      const l = this.evalExprWithAggAndWindow(expr.left, rep, group, rowIdx, windowResults, positionalParams, cteScope);
-      const r = this.evalExprWithAggAndWindow(expr.right, rep, group, rowIdx, windowResults, positionalParams, cteScope);
+      const l = yield* this.evalExprWithAggAndWindow(expr.left, rep, group, rowIdx, windowResults, positionalParams, cteScope);
+      const r = yield* this.evalExprWithAggAndWindow(expr.right, rep, group, rowIdx, windowResults, positionalParams, cteScope);
       return this.applyBinary(expr.op, l, r);
     }
     if (expr.kind === "func" && !this.containsAggregate(expr) && !expr.over) {
-      const args = expr.args.map((a) => this.evalExprWithAggAndWindow(a, rep, group, rowIdx, windowResults, positionalParams, cteScope));
-      return this.evalScalarFunction(expr.name, args);
+      const args = yield* stepMap(expr.args, function* (a) {
+        return yield* this.evalExprWithAggAndWindow(a, rep, group, rowIdx, windowResults, positionalParams, cteScope);
+      }, this);
+      return yield* this.evalScalarFunction(expr.name, args);
     }
-    return this.evalExprWithAgg(expr, rep, group, positionalParams, cteScope);
+    return yield* this.evalExprWithAgg(expr, rep, group, positionalParams, cteScope);
   }
-  evalExprWithAgg(expr, rep, group, positionalParams, cteScope) {
+  *evalExprWithAgg(expr, rep, group, positionalParams, cteScope) {
     if (expr.kind === "func") {
       const u = expr.name.toUpperCase();
       if ([
@@ -5139,11 +5543,12 @@ var SqliteDatabase = class {
         "JSON_GROUP_ARRAY",
         "JSON_GROUP_OBJECT"
       ].includes(u) && !((u === "MIN" || u === "MAX") && expr.args.length > 1)) {
-        return this.evalAggregateFunction(expr, group, positionalParams, cteScope);
+        return yield* this.evalAggregateFunction(expr, group, positionalParams, cteScope);
       }
       if (u === "COALESCE" || u === "IFNULL") {
         for (const a of expr.args) {
-          const v = this.evalExprWithAgg(a, rep, group, positionalParams, cteScope);
+          yield;
+          const v = yield* this.evalExprWithAgg(a, rep, group, positionalParams, cteScope);
           if (v !== null && v !== void 0) {
             return v;
           }
@@ -5151,28 +5556,30 @@ var SqliteDatabase = class {
         return null;
       }
       if (u === "IIF") {
-        const cond = this.evalExprWithAgg(expr.args[0], rep, group, positionalParams, cteScope);
-        return isTruthy(cond) ? this.evalExprWithAgg(expr.args[1], rep, group, positionalParams, cteScope) : expr.args[2] ? this.evalExprWithAgg(expr.args[2], rep, group, positionalParams, cteScope) : null;
+        const cond = yield* this.evalExprWithAgg(expr.args[0], rep, group, positionalParams, cteScope);
+        return isTruthy(cond) ? yield* this.evalExprWithAgg(expr.args[1], rep, group, positionalParams, cteScope) : expr.args[2] ? yield* this.evalExprWithAgg(expr.args[2], rep, group, positionalParams, cteScope) : null;
       }
-      const args = expr.args.map((a) => this.evalExprWithAgg(a, rep, group, positionalParams, cteScope));
-      return this.evalScalarFunction(expr.name, args);
+      const args = yield* stepMap(expr.args, function* (a) {
+        return yield* this.evalExprWithAgg(a, rep, group, positionalParams, cteScope);
+      }, this);
+      return yield* this.evalScalarFunction(expr.name, args);
     }
     if (expr.kind === "unary") {
-      return this.applyUnary(expr.op, this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope));
+      return this.applyUnary(expr.op, yield* this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope));
     }
     if (expr.kind === "binary") {
-      const l = this.evalExprWithAgg(expr.left, rep, group, positionalParams, cteScope);
-      const r = this.evalExprWithAgg(expr.right, rep, group, positionalParams, cteScope);
+      const l = yield* this.evalExprWithAgg(expr.left, rep, group, positionalParams, cteScope);
+      const r = yield* this.evalExprWithAgg(expr.right, rep, group, positionalParams, cteScope);
       return this.applyBinary(expr.op, l, r);
     }
     if (expr.kind === "is_null") {
-      const v = this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope);
+      const v = yield* this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope);
       return (expr.not ? v !== null : v === null) ? 1 : 0;
     }
     if (expr.kind === "between") {
-      const v = this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope);
-      const lo = this.evalExprWithAgg(expr.low, rep, group, positionalParams, cteScope);
-      const hi = this.evalExprWithAgg(expr.high, rep, group, positionalParams, cteScope);
+      const v = yield* this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope);
+      const lo = yield* this.evalExprWithAgg(expr.low, rep, group, positionalParams, cteScope);
+      const hi = yield* this.evalExprWithAgg(expr.high, rep, group, positionalParams, cteScope);
       if (v === null || lo === null || hi === null) {
         return null;
       }
@@ -5180,76 +5587,93 @@ var SqliteDatabase = class {
       return (expr.not ? !inside : inside) ? 1 : 0;
     }
     if (expr.kind === "case") {
-      const baseVal = expr.base ? this.evalExprWithAgg(expr.base, rep, group, positionalParams, cteScope) : void 0;
+      const baseVal = expr.base ? yield* this.evalExprWithAgg(expr.base, rep, group, positionalParams, cteScope) : void 0;
       for (const b of expr.branches) {
-        const wVal = this.evalExprWithAgg(b.when, rep, group, positionalParams, cteScope);
+        yield;
+        const wVal = yield* this.evalExprWithAgg(b.when, rep, group, positionalParams, cteScope);
         const matched = expr.base ? sqlEquals(baseVal ?? null, wVal) === true : isTruthy(wVal);
         if (matched) {
-          return this.evalExprWithAgg(b.then, rep, group, positionalParams, cteScope);
+          return yield* this.evalExprWithAgg(b.then, rep, group, positionalParams, cteScope);
         }
       }
-      return expr.elseExpr ? this.evalExprWithAgg(expr.elseExpr, rep, group, positionalParams, cteScope) : null;
+      return expr.elseExpr ? yield* this.evalExprWithAgg(expr.elseExpr, rep, group, positionalParams, cteScope) : null;
     }
     if (expr.kind === "cast") {
-      const v = this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope);
+      const v = yield* this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope);
       return this.applyCast(v, expr.targetType);
     }
-    return this.evalExpr(expr, rep, positionalParams, cteScope);
+    return yield* this.evalExprSteps(expr, rep, positionalParams, cteScope);
   }
-  evalAggregateFunction(expr, group, positionalParams, cteScope) {
+  *evalAggregateFunction(expr, group, positionalParams, cteScope) {
     const u = expr.name.toUpperCase();
     let filteredGroup = group;
     if (expr.filterWhere) {
-      filteredGroup = group.filter((r) => isTruthy(this.evalExpr(expr.filterWhere, r, positionalParams, cteScope)));
+      filteredGroup = yield* stepFilter(group, function* (r) {
+        return isTruthy(yield* this.evalExprSteps(expr.filterWhere, r, positionalParams, cteScope));
+      }, this);
     }
     if (u === "COUNT") {
       if (expr.star || expr.args.length === 0) {
         return filteredGroup.length;
       }
-      const vals2 = filteredGroup.map((r) => this.evalExpr(expr.args[0], r, positionalParams, cteScope)).filter((v) => v !== null && v !== void 0);
+      const vals2 = yield* stepFilter(yield* stepMap(filteredGroup, function* (r) {
+        return yield* this.evalExprSteps(expr.args[0], r, positionalParams, cteScope);
+      }, this), function* (v) {
+        yield;
+        return v !== null && v !== void 0;
+      }, this);
       if (expr.distinct) {
-        return new Set(vals2.map((v) => serializeSqlJson(v, false))).size;
+        return new Set(vals2.map((v) => {
+          return serializeSqlJson(v, false);
+        })).size;
       }
       return vals2.length;
     }
     if (u === "JSON_GROUP_OBJECT") {
       const obj = {};
       for (const r of filteredGroup) {
-        const k = this.evalExpr(expr.args[0], r, positionalParams, cteScope);
-        const v = this.evalExpr(expr.args[1], r, positionalParams, cteScope);
+        yield;
+        const k = yield* this.evalExprSteps(expr.args[0], r, positionalParams, cteScope);
+        const v = yield* this.evalExprSteps(expr.args[1], r, positionalParams, cteScope);
         if (k !== null && k !== void 0) {
           obj[toSqlString(k)] = this.sqlValToJsJson(v);
         }
       }
       return serializeSqlJson(obj);
     }
-    let vals = filteredGroup.map((r) => expr.args[0] ? this.evalExpr(expr.args[0], r, positionalParams, cteScope) : null);
+    let vals = yield* stepMap(filteredGroup, function* (r) {
+      return expr.args[0] ? yield* this.evalExprSteps(expr.args[0], r, positionalParams, cteScope) : null;
+    }, this);
     if (u === "JSON_GROUP_ARRAY") {
       if (expr.distinct) {
         const seen = /* @__PURE__ */ new Set();
-        vals = vals.filter((v) => {
+        vals = yield* stepFilter(vals, function* (v) {
+          yield;
           const k = serializeSqlJson(v, false);
           if (seen.has(k)) {
             return false;
           }
           seen.add(k);
           return true;
-        });
+        }, this);
       }
-      return serializeSqlJson(vals.map((v) => this.sqlValToJsJson(v)));
+      return serializeSqlJson(vals.map((v) => {
+        return this.sqlValToJsJson(v);
+      }));
     }
     const nonNull = vals.filter((v) => v !== null && v !== void 0);
     let activeVals = nonNull;
     if (expr.distinct) {
       const seen = /* @__PURE__ */ new Set();
-      activeVals = nonNull.filter((v) => {
+      activeVals = yield* stepFilter(nonNull, function* (v) {
+        yield;
         const k = serializeSqlJson(v, false);
         if (seen.has(k)) {
           return false;
         }
         seen.add(k);
         return true;
-      });
+      }, this);
     }
     if (u === "SUM") {
       if (activeVals.length === 0) {
@@ -5258,6 +5682,7 @@ var SqliteDatabase = class {
       let exact = 0n;
       let realSum;
       for (const value of activeVals) {
+        yield;
         const numeric = arithmeticNumber(value);
         if (realSum !== void 0) {
           realSum += Number(numeric);
@@ -5272,33 +5697,47 @@ var SqliteDatabase = class {
       return realSum === void 0 ? integerResult(exact) : new Number(realSum);
     }
     if (u === "TOTAL") {
-      return new Number(activeVals.reduce((sum, v) => sum + toSqlNumber(v), 0));
+      return new Number(yield* stepReduce(activeVals, function* (sum, v) {
+        yield;
+        return sum + toSqlNumber(v);
+      }, 0, this));
     }
     if (u === "AVG") {
       if (activeVals.length === 0) {
         return null;
       }
-      const sum = activeVals.reduce((s, v) => s + toSqlNumber(v), 0);
+      const sum = yield* stepReduce(activeVals, function* (s, v) {
+        yield;
+        return s + toSqlNumber(v);
+      }, 0, this);
       return new Number(sum / activeVals.length);
     }
     if (u === "MIN") {
       if (activeVals.length === 0) {
         return null;
       }
-      return activeVals.reduce((min, v) => compareSqlValues(v, min) < 0 ? v : min, activeVals[0]);
+      return yield* stepReduce(activeVals, function* (min, v) {
+        yield;
+        return compareSqlValues(v, min) < 0 ? v : min;
+      }, activeVals[0], this);
     }
     if (u === "MAX") {
       if (activeVals.length === 0) {
         return null;
       }
-      return activeVals.reduce((max, v) => compareSqlValues(v, max) > 0 ? v : max, activeVals[0]);
+      return yield* stepReduce(activeVals, function* (max, v) {
+        yield;
+        return compareSqlValues(v, max) > 0 ? v : max;
+      }, activeVals[0], this);
     }
     if (u === "GROUP_CONCAT" || u === "STRING_AGG") {
       if (activeVals.length === 0) {
         return null;
       }
-      const sep = expr.args[1] ? toSqlString(this.evalExpr(expr.args[1], filteredGroup[0] ?? {}, positionalParams, cteScope)) : ",";
-      return activeVals.map((v) => toSqlString(v)).join(sep);
+      const sep = expr.args[1] ? toSqlString(yield* this.evalExprSteps(expr.args[1], filteredGroup[0] ?? {}, positionalParams, cteScope)) : ",";
+      return activeVals.map((v) => {
+        return toSqlString(v);
+      }).join(sep);
     }
     return null;
   }
@@ -5319,7 +5758,7 @@ var SqliteDatabase = class {
     }
     return v;
   }
-  validateColumns(node, scope, positionalParams, cteScope) {
+  *validateColumns(node, scope, positionalParams, cteScope) {
     if (!node || typeof node !== "object")
       return;
     if ("kind" in node && node.kind === "column") {
@@ -5333,7 +5772,7 @@ var SqliteDatabase = class {
       this.preparing = true;
       this.outerRows.push(scope);
       try {
-        const result = this.executeStatement(subquery.kind === "subquery" ? subquery.sql : subquery.subquerySql, positionalParams, cteScope);
+        const result = yield* this.executeStatementSteps(subquery.kind === "subquery" ? subquery.sql : subquery.subquerySql, positionalParams, cteScope);
         if (!(subquery.kind === "subquery" && subquery.exists) && result && result.columns.length !== 1) {
           throw new Error(`sub-select returns ${result.columns.length} columns - expected 1`);
         }
@@ -5342,8 +5781,10 @@ var SqliteDatabase = class {
         this.preparing = preparing;
       }
     }
-    for (const child of Object.values(node))
-      this.validateColumns(child, scope, positionalParams, cteScope);
+    for (const child of Object.values(node)) {
+      yield;
+      yield* this.validateColumns(child, scope, positionalParams, cteScope);
+    }
   }
   lookupColInRow(row, table, name, doubleQuoted = false) {
     if (table) {
@@ -5377,10 +5818,13 @@ var SqliteDatabase = class {
       return name;
     throw new Error(`in prepare, no such column: ${table ? `${table}.` : ""}${name}`);
   }
-  evalScalarSql(sql, row, positionalParams) {
-    return this.evalExpr(parseExprSql(sql), row, positionalParams);
+  *evalScalarSql(sql, row, positionalParams) {
+    return yield* this.evalExprSteps(parseExprSql(sql), row, positionalParams);
   }
   evalExpr(expr, row, positionalParams, cteScope = /* @__PURE__ */ new Map()) {
+    return runSynchronously(this.evalExprSteps(expr, row, positionalParams, cteScope));
+  }
+  *evalExprSteps(expr, row, positionalParams, cteScope = /* @__PURE__ */ new Map()) {
     switch (expr.kind) {
       case "literal":
         return expr.value;
@@ -5399,16 +5843,16 @@ var SqliteDatabase = class {
         return this.parameters.get(expr.name) ?? this.parameters.get(expr.name.slice(1)) ?? positionalParams[expr.index - 1] ?? null;
       }
       case "collate":
-        return this.evalExpr(expr.expr, row, positionalParams, cteScope);
+        return yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
       case "unary":
-        return this.applyUnary(expr.op, this.evalExpr(expr.expr, row, positionalParams, cteScope));
+        return this.applyUnary(expr.op, yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope));
       case "binary": {
         if (expr.op === "AND") {
-          const l2 = this.evalExpr(expr.left, row, positionalParams, cteScope);
+          const l2 = yield* this.evalExprSteps(expr.left, row, positionalParams, cteScope);
           if (l2 !== null && !isTruthy(l2)) {
             return 0;
           }
-          const r2 = this.evalExpr(expr.right, row, positionalParams, cteScope);
+          const r2 = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope);
           if (r2 !== null && !isTruthy(r2)) {
             return 0;
           }
@@ -5418,11 +5862,11 @@ var SqliteDatabase = class {
           return 1;
         }
         if (expr.op === "OR") {
-          const l2 = this.evalExpr(expr.left, row, positionalParams, cteScope);
+          const l2 = yield* this.evalExprSteps(expr.left, row, positionalParams, cteScope);
           if (l2 !== null && isTruthy(l2)) {
             return 1;
           }
-          const r2 = this.evalExpr(expr.right, row, positionalParams, cteScope);
+          const r2 = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope);
           if (r2 !== null && isTruthy(r2)) {
             return 1;
           }
@@ -5432,22 +5876,22 @@ var SqliteDatabase = class {
           return 0;
         }
         const collation = expr.left.kind === "collate" ? expr.left.collation : expr.right.kind === "collate" ? expr.right.collation : "BINARY";
-        const l = this.evalExpr(expr.left, row, positionalParams, cteScope);
+        const l = yield* this.evalExprSteps(expr.left, row, positionalParams, cteScope);
         if ((expr.op === "LIKE" || expr.op === "GLOB") && expr.right.kind === "func" && expr.right.name === "__like_escape__") {
-          const pat = this.evalExpr(expr.right.args[0], row, positionalParams, cteScope);
-          const esc = this.evalExpr(expr.right.args[1], row, positionalParams, cteScope);
+          const pat = yield* this.evalExprSteps(expr.right.args[0], row, positionalParams, cteScope);
+          const esc = yield* this.evalExprSteps(expr.right.args[1], row, positionalParams, cteScope);
           if (l === null || pat === null || esc === null) {
             return null;
           }
           return matchLike(toSqlString(l), toSqlString(pat), expr.op === "LIKE", toSqlString(esc)) ? 1 : 0;
         }
-        const r = this.evalExpr(expr.right, row, positionalParams, cteScope);
+        const r = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope);
         return this.applyBinary(expr.op, l, r, collation);
       }
       case "between": {
-        const v = this.evalExpr(expr.expr, row, positionalParams, cteScope);
-        const lo = this.evalExpr(expr.low, row, positionalParams, cteScope);
-        const hi = this.evalExpr(expr.high, row, positionalParams, cteScope);
+        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
+        const lo = yield* this.evalExprSteps(expr.low, row, positionalParams, cteScope);
+        const hi = yield* this.evalExprSteps(expr.high, row, positionalParams, cteScope);
         if (v === null || lo === null || hi === null) {
           return null;
         }
@@ -5455,13 +5899,14 @@ var SqliteDatabase = class {
         return (expr.not ? !inside : inside) ? 1 : 0;
       }
       case "in_list": {
-        const v = this.evalExpr(expr.expr, row, positionalParams, cteScope);
+        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
         if (v === null) {
           return expr.list.length === 0 ? expr.not ? 1 : 0 : null;
         }
         let sawNull = false;
         for (const item of expr.list) {
-          const iv = this.evalExpr(item, row, positionalParams, cteScope);
+          yield;
+          const iv = yield* this.evalExprSteps(item, row, positionalParams, cteScope);
           if (iv === null) {
             sawNull = true;
           } else if (sqlEquals(v, iv) === true) {
@@ -5474,11 +5919,11 @@ var SqliteDatabase = class {
         return expr.not ? 1 : 0;
       }
       case "in_subquery": {
-        const v = this.evalExpr(expr.expr, row, positionalParams, cteScope);
+        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
         this.outerRows.push(row);
         let res;
         try {
-          res = this.executeStatement(expr.subquerySql, positionalParams, cteScope) ?? { columns: [], rows: [] };
+          res = (yield* this.executeStatementSteps(expr.subquerySql, positionalParams, cteScope)) ?? { columns: [], rows: [] };
         } finally {
           this.outerRows.pop();
         }
@@ -5489,6 +5934,7 @@ var SqliteDatabase = class {
         }
         let sawNull = false;
         for (const r of res.rows) {
+          yield;
           const iv = r[0] ?? null;
           if (iv === null) {
             sawNull = true;
@@ -5502,29 +5948,33 @@ var SqliteDatabase = class {
         return expr.not ? 1 : 0;
       }
       case "is_null": {
-        const v = this.evalExpr(expr.expr, row, positionalParams, cteScope);
+        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
         return (expr.not ? v !== null : v === null) ? 1 : 0;
       }
       case "case": {
-        const baseVal = expr.base ? this.evalExpr(expr.base, row, positionalParams, cteScope) : void 0;
+        const baseVal = expr.base ? yield* this.evalExprSteps(expr.base, row, positionalParams, cteScope) : void 0;
         for (const b of expr.branches) {
-          const wVal = this.evalExpr(b.when, row, positionalParams, cteScope);
+          yield;
+          const wVal = yield* this.evalExprSteps(b.when, row, positionalParams, cteScope);
           const matched = expr.base ? sqlEquals(baseVal ?? null, wVal) === true : isTruthy(wVal);
           if (matched) {
-            return this.evalExpr(b.then, row, positionalParams, cteScope);
+            return yield* this.evalExprSteps(b.then, row, positionalParams, cteScope);
           }
         }
-        return expr.elseExpr ? this.evalExpr(expr.elseExpr, row, positionalParams, cteScope) : null;
+        return expr.elseExpr ? yield* this.evalExprSteps(expr.elseExpr, row, positionalParams, cteScope) : null;
       }
       case "cast": {
-        const v = this.evalExpr(expr.expr, row, positionalParams, cteScope);
+        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
         return this.applyCast(v, expr.targetType);
       }
       case "subquery": {
         this.outerRows.push(row);
         let res;
         try {
-          res = this.executeStatement(expr.sql, positionalParams, cteScope) ?? { columns: [], rows: [] };
+          res = (yield* this.executeStatementSteps(expr.sql, positionalParams, cteScope)) ?? {
+            columns: [],
+            rows: []
+          };
         } finally {
           this.outerRows.pop();
         }
@@ -5540,7 +5990,8 @@ var SqliteDatabase = class {
         const u = expr.name.toUpperCase();
         if (u === "COALESCE" || u === "IFNULL") {
           for (const a of expr.args) {
-            const v = this.evalExpr(a, row, positionalParams, cteScope);
+            yield;
+            const v = yield* this.evalExprSteps(a, row, positionalParams, cteScope);
             if (v !== null && v !== void 0) {
               return v;
             }
@@ -5548,11 +5999,13 @@ var SqliteDatabase = class {
           return null;
         }
         if (u === "IIF") {
-          const cond = this.evalExpr(expr.args[0], row, positionalParams, cteScope);
-          return isTruthy(cond) ? this.evalExpr(expr.args[1], row, positionalParams, cteScope) : expr.args[2] ? this.evalExpr(expr.args[2], row, positionalParams, cteScope) : null;
+          const cond = yield* this.evalExprSteps(expr.args[0], row, positionalParams, cteScope);
+          return isTruthy(cond) ? yield* this.evalExprSteps(expr.args[1], row, positionalParams, cteScope) : expr.args[2] ? yield* this.evalExprSteps(expr.args[2], row, positionalParams, cteScope) : null;
         }
-        const args = expr.args.map((a) => this.evalExpr(a, row, positionalParams, cteScope));
-        return this.evalScalarFunction(expr.name, args);
+        const args = yield* stepMap(expr.args, function* (a) {
+          return yield* this.evalExprSteps(a, row, positionalParams, cteScope);
+        }, this);
+        return yield* this.evalScalarFunction(expr.name, args);
       }
     }
   }
@@ -5691,7 +6144,7 @@ var SqliteDatabase = class {
     const n = toSqlNumber(v);
     return Number.isInteger(n) ? n : n;
   }
-  evalScalarFunction(name, args) {
+  *evalScalarFunction(name, args) {
     const u = name.toUpperCase();
     const a0 = args[0] ?? null;
     const a1 = args[1] ?? null;
@@ -5701,6 +6154,7 @@ var SqliteDatabase = class {
       case "COALESCE":
       case "IFNULL": {
         for (const a of args) {
+          yield;
           if (a !== null && a !== void 0) {
             return a;
           }
@@ -5759,11 +6213,13 @@ var SqliteDatabase = class {
         let end = s.length;
         if (u === "TRIM" || u === "LTRIM") {
           while (start < end && set.has(s[start])) {
+            yield;
             start += 1;
           }
         }
         if (u === "TRIM" || u === "RTRIM") {
           while (end > start && set.has(s[end - 1])) {
+            yield;
             end -= 1;
           }
         }
@@ -5817,13 +6273,20 @@ var SqliteDatabase = class {
         }
         return sqlPrintf(toSqlString(a0), args.slice(1));
       case "CONCAT":
-        return args.map((x) => x === null || x === void 0 ? "" : toSqlString(x)).join("");
+        return args.map((x) => {
+          return x === null || x === void 0 ? "" : toSqlString(x);
+        }).join("");
       case "CONCAT_WS": {
         if (a0 === null) {
           return null;
         }
         const sep = toSqlString(a0);
-        return args.slice(1).filter((x) => x !== null && x !== void 0).map((x) => toSqlString(x)).join(sep);
+        return (yield* stepFilter(args.slice(1), function* (x) {
+          yield;
+          return x !== null && x !== void 0;
+        }, this)).map((x) => {
+          return toSqlString(x);
+        }).join(sep);
       }
       case "REVERSE":
         return a0 === null ? null : Array.from(toSqlString(a0)).reverse().join("");
@@ -5834,7 +6297,9 @@ var SqliteDatabase = class {
       case "RPAD":
         return a0 === null || a1 === null ? null : toSqlString(a0).padEnd(Math.trunc(toSqlNumber(a1)), args[2] ? toSqlString(args[2]) : " ");
       case "CHAR":
-        return args.map((x) => String.fromCodePoint(Math.max(0, Math.trunc(toSqlNumber(x))))).join("");
+        return args.map((x) => {
+          return String.fromCodePoint(Math.max(0, Math.trunc(toSqlNumber(x))));
+        }).join("");
       case "UNICODE":
         if (a0 === null) {
           return null;
@@ -5847,6 +6312,7 @@ var SqliteDatabase = class {
         const bytes = a0 instanceof Uint8Array ? a0 : textEncoder2.encode(toSqlString(a0));
         let out = "";
         for (const b of bytes) {
+          yield;
           out += b.toString(16).toUpperCase().padStart(2, "0");
         }
         return out;
@@ -5861,6 +6327,7 @@ var SqliteDatabase = class {
         }
         const out = new Uint8Array(h.length / 2);
         for (let i = 0; i < out.length; i += 1) {
+          yield;
           out[i] = Number.parseInt(h.slice(i * 2, i * 2 + 2), 16);
         }
         return out;
@@ -5936,27 +6403,38 @@ var SqliteDatabase = class {
       case "MOD":
         return a0 === null || a1 === null || toSqlNumber(a1) === 0 ? null : toSqlNumber(a0) % toSqlNumber(a1);
       case "MIN":
-        if (args.some((x) => x === null || x === void 0)) {
+        if (args.some((x) => {
+          return x === null || x === void 0;
+        })) {
           return null;
         }
-        return args.reduce((m, x) => compareSqlValues(x, m) < 0 ? x : m, args[0] ?? null);
+        return yield* stepReduce(args, function* (m, x) {
+          yield;
+          return compareSqlValues(x, m) < 0 ? x : m;
+        }, args[0] ?? null, this);
       case "MAX":
-        if (args.some((x) => x === null || x === void 0)) {
+        if (args.some((x) => {
+          return x === null || x === void 0;
+        })) {
           return null;
         }
-        return args.reduce((m, x) => compareSqlValues(x, m) > 0 ? x : m, args[0] ?? null);
+        return yield* stepReduce(args, function* (m, x) {
+          yield;
+          return compareSqlValues(x, m) > 0 ? x : m;
+        }, args[0] ?? null, this);
       case "RANDOM":
         return Math.floor((Math.random() - 0.5) * 2 * Number.MAX_SAFE_INTEGER);
       case "RANDOMBLOB": {
-        const n = Math.max(0, Math.min(65536, Math.trunc(toSqlNumber(a0 ?? 0))));
+        const n = Math.max(0, Math.trunc(toSqlNumber(a0 ?? 0)));
         const b = new Uint8Array(n);
         for (let i = 0; i < n; i += 1) {
+          yield;
           b[i] = Math.floor(Math.random() * 256);
         }
         return b;
       }
       case "ZEROBLOB": {
-        const n = Math.max(0, Math.min(65536, Math.trunc(toSqlNumber(a0 ?? 0))));
+        const n = Math.max(0, Math.trunc(toSqlNumber(a0 ?? 0)));
         return new Uint8Array(n);
       }
       case "CHANGES":
@@ -6024,10 +6502,13 @@ var SqliteDatabase = class {
       case "JSON_QUOTE":
         return a0 === null ? "null" : serializeSqlJson(this.sqlValToJsJson(a0));
       case "JSON_ARRAY":
-        return serializeSqlJson(args.map((x) => this.sqlValToJsJson(x)));
+        return serializeSqlJson(args.map((x) => {
+          return this.sqlValToJsJson(x);
+        }));
       case "JSON_OBJECT": {
         const obj = {};
         for (let i = 0; i + 1 < args.length; i += 2) {
+          yield;
           if (args[i] !== null && args[i] !== void 0) {
             obj[toSqlString(args[i])] = this.sqlValToJsJson(args[i + 1] ?? null);
           }
@@ -6105,6 +6586,7 @@ var SqliteDatabase = class {
           let cur = JSON.parse(toSqlString(a0));
           const mode = u === "JSON_SET" ? "set" : u === "JSON_INSERT" ? "insert" : "replace";
           for (let i = 1; i + 1 < args.length; i += 2) {
+            yield;
             const p = toSqlString(args[i] ?? "$");
             const v = this.sqlValToJsJson(args[i + 1] ?? null);
             cur = setByJsonPath(cur, p, v, mode);
@@ -6121,6 +6603,7 @@ var SqliteDatabase = class {
         try {
           let cur = JSON.parse(toSqlString(a0));
           for (let i = 1; i < args.length; i += 1) {
+            yield;
             cur = removeByJsonPath(cur, toSqlString(args[i] ?? "$"));
           }
           return serializeSqlJson(cur);
@@ -6379,8 +6862,7 @@ function formatQueryResult(res, state) {
       for (const r of rows) {
         lines.push(r.map((v) => formatCsvCell(formatCellValue(v, state.nullValue), sep)).join(sep));
       }
-      return `${lines.join("\n")}
-`;
+      return lines.map((line) => line + state.rowSeparator).join("");
     }
     case "json": {
       const objects = rows.map((row) => "{" + columns.map((column, index) => {
@@ -6804,17 +7286,25 @@ Options:
             const raw = typeof options.engine === "function" ? await options.engine({ dbPath, readonly, context }) : options.engine;
             return normalizeInjectedEngine(raw);
           }
-          return new SqliteDatabase();
+          return new SqliteDatabase(limits.maxRows);
         };
         const db = await createDbInstance(state.dbPath, state.readonly);
         const execSingleStmt = async (stmt) => {
+          await yieldTurn2(context.signal);
           let sets = [];
-          if (typeof db.executeStatement === "function") {
-            const result = await db.executeStatement(stmt);
-            if (result)
-              sets = [result];
-          } else if (typeof db.exec === "function") {
-            sets = await db.exec(stmt);
+          try {
+            if (typeof db.executeStatement === "function") {
+              const result = await (db.executeStatementAsync ? db.executeStatementAsync(stmt, context.signal) : db.executeStatement(stmt));
+              if (result)
+                sets = [result];
+            } else if (typeof db.exec === "function") {
+              sets = await db.exec(stmt);
+            }
+          } catch (error) {
+            context.signal.throwIfAborted();
+            if (error instanceof RangeError && error.message === "maxRows limit exceeded")
+              enforceLimit("maxRows", Infinity);
+            throw error;
           }
           for (const result of sets)
             enforceLimit("maxRows", result.rows.length);
@@ -6878,6 +7368,7 @@ Options:
               }
             }
           } catch (err) {
+            context.signal.throwIfAborted();
             const msg = err instanceof Error ? err.message : String(err);
             throw new Error(`Error: in prepare, ${msg}`);
           }
@@ -6918,6 +7409,7 @@ Options:
         try {
           await loadDbFromDisk(state.dbPath);
         } catch (err) {
+          context.signal.throwIfAborted();
           await writeText(context.stderr, `${err instanceof Error ? err.message : String(err)}
 `);
           return { exitCode: 1 };
@@ -6971,8 +7463,10 @@ Options:
               state.mode = newMode;
               if (newMode === "list") {
                 state.colSeparator = "|";
+                state.rowSeparator = "\n";
               } else if (newMode === "csv") {
                 state.colSeparator = ",";
+                state.rowSeparator = "\r\n";
               } else if (newMode === "tabs") {
                 state.colSeparator = "	";
               } else if (newMode === "insert" && parts[2]) {
@@ -7376,6 +7870,7 @@ Options:
               try {
                 await runSqlStatement(st);
               } catch (err) {
+                context.signal.throwIfAborted();
                 const msg = err instanceof Error ? err.message : String(err);
                 await writeText(context.stderr, `Error: ${msg}
 `);
@@ -7397,6 +7892,7 @@ Options:
               try {
                 await executeDotCommand(trimmed);
               } catch (err) {
+                context.signal.throwIfAborted();
                 const msg = err instanceof Error ? err.message : String(err);
                 await writeText(context.stderr, `Error: ${msg}
 `);
@@ -7425,6 +7921,7 @@ Options:
             const initContent = textDecoder3.decode(await readInputFile(resolveVfsPath(context.cwd, initFile)));
             await processScript(initContent, false);
           } catch (err) {
+            context.signal.throwIfAborted();
             await writeText(context.stderr, `Error: cannot read init file "${initFile}": ${err instanceof Error ? err.message : String(err)}
 `);
             return { exitCode: 1 };
@@ -7451,6 +7948,7 @@ Options:
             try {
               stdinBytes = await collectBytes(context.stdin, { signal: context.signal, maxBytes: limits.maxInputBytes - inputBytes });
             } catch (error) {
+              context.signal.throwIfAborted();
               if (error instanceof Error && "code" in error && error.code === "EFBIG") {
                 enforceLimit("maxInputBytes", Infinity);
               }
@@ -7468,6 +7966,7 @@ Options:
         }
         return { exitCode: limitExceeded ? 1 : state.exitCode };
       } catch (error) {
+        context.signal.throwIfAborted();
         await writeText(context.stderr, `Error: ${error instanceof Error ? error.message : String(error)}
 `);
         return { exitCode: 1 };