@poe-platform/safe-bash 0.1.800 → 0.1.802

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

@@ -340,10 +340,10 @@ function decodeRecord(payload) {
   }
   return values;
 }
-function extractLeafCellPayload(dbBytes, pageSize, cellBytes, payloadSize) {
+function extractLeafCellPayload(dbBytes, pageSize, cellBytes, payloadSize, index = false) {
   const reservedSpace = dbBytes[20] ?? 0;
   const usableSize = Math.max(480, pageSize - reservedSpace);
-  const maxLocal = usableSize - 35;
+  const maxLocal = index ? Math.floor((usableSize - 12) * 64 / 255) - 23 : usableSize - 35;
   const minLocal = Math.floor((usableSize - 12) * 32 / 255) - 23;
   if (payloadSize <= maxLocal) {
     return cellBytes.subarray(0, payloadSize);
@@ -380,7 +380,32 @@ function parseTableBTreeRows(dbBytes, pageSize, pageNumber, visited = /* @__PURE
   const pageType = dbBytes[pageStart + headerOffset] ?? 0;
   const cellCount = readU16BE(dbBytes, pageStart + headerOffset + 3);
   const rows = [];
-  if (pageType === 13) {
+  if (pageType === 10 || pageType === 2) {
+    const interior = pageType === 2;
+    const ptrArrayOffset = pageStart + headerOffset + (interior ? 12 : 8);
+    for (let i = 0; i < cellCount; i++) {
+      let offset = pageStart + readU16BE(dbBytes, ptrArrayOffset + i * 2);
+      if (interior) {
+        rows.push(...parseTableBTreeRows(dbBytes, pageSize, readU32BE(dbBytes, offset), visited));
+        offset += 4;
+      }
+      const size = readVarint(dbBytes, offset);
+      const payload = extractLeafCellPayload(
+        dbBytes,
+        pageSize,
+        dbBytes.subarray(offset + size.length, pageStart + pageSize),
+        size.value,
+        true
+      );
+      rows.push({ rowid: rows.length + 1, values: decodeRecord(payload) });
+    }
+    if (interior) rows.push(...parseTableBTreeRows(
+      dbBytes,
+      pageSize,
+      readU32BE(dbBytes, pageStart + headerOffset + 8),
+      visited
+    ));
+  } else if (pageType === 13) {
     const ptrArrayOffset = pageStart + headerOffset + 8;
     for (let i = 0; i < cellCount; i += 1) {
       const cellOffsetInPage = readU16BE(dbBytes, ptrArrayOffset + i * 2);
@@ -395,7 +420,7 @@ function parseTableBTreeRows(dbBytes, pageSize, pageNumber, visited = /* @__PURE
         pSize.value
       );
       rows.push({
-        rowid: rId.value,
+        rowid: rId.length === 9 ? Number(BigInt.asIntN(64, Array.from(dbBytes.subarray(absOffset + pSize.length, absOffset + pSize.length + 9)).reduce((value, byte, i2) => value << BigInt(i2 === 8 ? 8 : 7) | BigInt(i2 === 8 ? byte : byte & 127), 0n))) : rId.value,
         values: decodeRecord(payload)
       });
     }
@@ -503,7 +528,7 @@ function buildTablePages(rows, startPageNumber, isPageOne) {
     writeU32BE(cell, pSizeVar.byteLength + rIdVar.byteLength + localSize, firstOverflowPageNum);
     return cell;
   };
-  const encodedCells = rows.map((r) => ({
+  const encodedCells = [...rows].sort((a, b) => a.rowid - b.rowid).map((r) => ({
     rowid: r.rowid,
     cell: encodeCellWithOverflow(r.rowid, r.values)
   }));
@@ -595,7 +620,7 @@ function compareSqlValuesForBTree(a, b) {
   }
   return ba.byteLength - bb.byteLength;
 }
-function buildIndexPages(entries, startPageNumber) {
+function buildIndexPages(entries, startPageNumber, presorted = false) {
   const pageSize = DEFAULT_PAGE_SIZE;
   const pages = [];
   const rootPageNum = startPageNumber;
@@ -605,7 +630,7 @@ function buildIndexPages(entries, startPageNumber) {
     pages.push(buf);
     return { pageNum: startPageNumber + pages.length - 1, buf };
   };
-  const sorted = [...entries].sort((r1, r2) => {
+  const sorted = presorted ? entries : [...entries].sort((r1, r2) => {
     const len = Math.min(r1.length, r2.length);
     for (let i = 0; i < len; i += 1) {
       const c = compareSqlValuesForBTree(r1[i] ?? null, r2[i] ?? null);
@@ -650,40 +675,51 @@ function buildIndexPages(entries, startPageNumber) {
     return cell;
   };
   const encodedCells = sorted.map((vals) => encodeIndexCell(vals));
-  const maxRootSpace = pageSize - 8;
-  const totalRootBytes = encodedCells.reduce((sum, c) => sum + c.byteLength + 2, 0);
-  if (totalRootBytes <= maxRootSpace) {
-    const rootBuf2 = pages[0];
-    rootBuf2[0] = 10;
-    writeU16BE(rootBuf2, 1, 0);
-    writeU16BE(rootBuf2, 3, encodedCells.length);
-    let contentOffset2 = pageSize;
-    for (let i = 0; i < encodedCells.length; i += 1) {
-      const c = encodedCells[i];
-      contentOffset2 -= c.byteLength;
-      rootBuf2.set(c, contentOffset2);
-      writeU16BE(rootBuf2, 8 + i * 2, contentOffset2);
-    }
-    writeU16BE(rootBuf2, 5, contentOffset2 === pageSize ? 0 : contentOffset2);
-    return { rootPage: rootPageNum, pages };
-  }
-  const rootBuf = pages[0];
-  rootBuf[0] = 10;
-  writeU16BE(rootBuf, 1, 0);
-  let contentOffset = pageSize;
-  let count = 0;
-  for (let i = 0; i < encodedCells.length; i += 1) {
-    const c = encodedCells[i];
-    if (contentOffset - (c.byteLength + 2) < 8 + (count + 1) * 2) {
+  const writeNode = (buf, cells2, children2) => {
+    const interior = children2.length > 0;
+    const header = interior ? 12 : 8;
+    buf[0] = interior ? 2 : 10;
+    writeU16BE(buf, 3, cells2.length);
+    if (interior) writeU32BE(buf, 8, children2[children2.length - 1]);
+    let offset = pageSize;
+    for (let i = 0; i < cells2.length; i++) {
+      const cell = cells2[i];
+      offset -= cell.length + (interior ? 4 : 0);
+      if (interior) writeU32BE(buf, offset, children2[i]);
+      buf.set(cell, offset + (interior ? 4 : 0));
+      writeU16BE(buf, header + i * 2, offset);
+    }
+    writeU16BE(buf, 5, offset);
+  };
+  let cells = encodedCells;
+  let children = [];
+  while (true) {
+    const overhead = children.length ? 6 : 2;
+    const header = children.length ? 12 : 8;
+    if (cells.reduce((size, cell) => size + cell.length + overhead, header) <= pageSize) {
+      writeNode(pages[0], cells, children);
       break;
     }
-    contentOffset -= c.byteLength;
-    rootBuf.set(c, contentOffset);
-    writeU16BE(rootBuf, 8 + count * 2, contentOffset);
-    count += 1;
+    const separators = [];
+    const nextChildren = [];
+    let start = 0;
+    while (start <= cells.length) {
+      let end = start;
+      let size = header;
+      while (end < cells.length && size + cells[end].length + overhead <= pageSize) {
+        size += cells[end].length + overhead;
+        end++;
+      }
+      const { pageNum, buf } = allocatePage();
+      writeNode(buf, cells.slice(start, end), children.length ? children.slice(start, end + 1) : []);
+      nextChildren.push(pageNum);
+      if (end === cells.length) break;
+      separators.push(cells[end]);
+      start = end + 1;
+    }
+    cells = separators;
+    children = nextChildren;
   }
-  writeU16BE(rootBuf, 3, count);
-  writeU16BE(rootBuf, 5, contentOffset === pageSize ? 0 : contentOffset);
   return { rootPage: rootPageNum, pages };
 }
 function writeSqliteDatabaseBytes(image) {
@@ -694,7 +730,7 @@ function writeSqliteDatabaseBytes(image) {
   for (const item of image.master) {
     if (item.type === "table") {
       const rows = image.tableRows.get(item.name) ?? [];
-      const built = buildTablePages(rows, nextPageNumber, false);
+      const built = item.withoutRowId ? buildIndexPages(rows.map((row) => row.values), nextPageNumber, true) : buildTablePages(rows, nextPageNumber, false);
       extraPageChunks.push(...built.pages);
       nextPageNumber += built.pages.length;
       masterEntries.push({
@@ -735,7 +771,7 @@ function writeSqliteDatabaseBytes(image) {
     for (const item of image.master) {
       if (item.type === "table") {
         const rows = image.tableRows.get(item.name) ?? [];
-        const built = buildTablePages(rows, pNum, false);
+        const built = item.withoutRowId ? buildIndexPages(rows.map((row) => row.values), pNum, true) : buildTablePages(rows, pNum, false);
         reExtraChunks.push(...built.pages);
         pNum += built.pages.length;
         reMasterEntries.push({ ...item, rootpage: built.rootPage });
@@ -803,8 +839,18 @@ function serializeSqlJson(value, preserveRealType = true) {
 }
 var JsonText = class extends String {
 };
+function tableStorageColumns(table) {
+  if (!table.withoutRowId) return table.columns;
+  const keys = table.primaryKeyCols.map((name) => name.toLowerCase());
+  return [
+    ...keys.map((name) => table.columns.find((column) => column.name.toLowerCase() === name)),
+    ...table.columns.filter((column) => !keys.includes(column.name.toLowerCase()))
+  ];
+}
 var textEncoder2 = new TextEncoder();
 var textDecoder2 = new TextDecoder("utf-8", { fatal: false });
+var SqliteConstraintError = class extends Error {
+};
 function cloneSqlValue(v) {
   if (v instanceof Uint8Array) {
     return new Uint8Array(v);
@@ -831,6 +877,7 @@ function cloneTableDef(t) {
     withoutRowId: t.withoutRowId,
     strict: t.strict,
     primaryKeyCols: [...t.primaryKeyCols],
+    primaryKeyOrder: t.primaryKeyOrder?.map((key) => ({ ...key })),
     uniqueColSets: t.uniqueColSets.map((u) => [...u])
   };
 }
@@ -2240,11 +2287,12 @@ var SqliteDatabase = class {
       }
       tbl.rows = [];
       let maxRowid = 0;
+      const storageColumns = tableStorageColumns(tbl);
       for (const r of rawRows) {
         yield;
         const data = {};
         let valIdx = 0;
-        for (const col of tbl.columns) {
+        for (const col of storageColumns) {
           yield;
           if (col.primaryKey && col.type.toUpperCase() === "INTEGER" && !tbl.withoutRowId && tbl.primaryKeyCols.length === 1) {
             const cellVal = r.values[valIdx];
@@ -2313,7 +2361,8 @@ var SqliteDatabase = class {
         name: tbl.name,
         tbl_name: tbl.name,
         rootpage: rootPageCounter++,
-        sql: tbl.sql
+        sql: tbl.sql,
+        withoutRowId: tbl.withoutRowId
       });
       if (tbl.columns.some((c) => {
         return c.autoIncrement;
@@ -2330,11 +2379,26 @@ var SqliteDatabase = class {
           });
         }
       }
-      const rows = yield* stepMap(tbl.rows, function* (r) {
+      const storageColumns = tableStorageColumns(tbl);
+      const orderedRows = tbl.withoutRowId ? yield* stepSort([...tbl.rows], function* (left, right) {
+        for (let i = 0; i < tbl.primaryKeyCols.length; i++) {
+          yield;
+          const column = storageColumns[i];
+          const order = tbl.primaryKeyOrder?.[i];
+          const comparison = compareSqlValues(
+            left.data[column.name] ?? null,
+            right.data[column.name] ?? null,
+            order?.collation ?? column.collate ?? "BINARY"
+          );
+          if (comparison) return order?.desc ? -comparison : comparison;
+        }
+        return 0;
+      }, this) : tbl.rows;
+      const rows = yield* stepMap(orderedRows, function* (r) {
         yield;
         return {
           rowid: r.rowid,
-          values: tbl.columns.map((c) => {
+          values: storageColumns.map((c) => {
             const isRowidAlias = c.primaryKey && c.type.toUpperCase() === "INTEGER" && !tbl.withoutRowId && tbl.primaryKeyCols.length === 1;
             return isRowidAlias ? null : r.data[c.name] ?? null;
           })
@@ -2805,6 +2869,7 @@ var SqliteDatabase = class {
       const strict = trailingTokens.includes("STRICT");
       const columns = [];
       const primaryKeyCols = [];
+      const primaryKeyOrder = [];
       const uniqueColSets = [];
       for (const part of bodyParts) {
         yield;
@@ -2822,11 +2887,19 @@ var SqliteDatabase = class {
             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);
+              if (part[pIdx].value === ",") {
+                pIdx++;
+                continue;
               }
-              pIdx += 1;
+              primaryKeyCols.push(part[pIdx++].value);
+              let collation;
+              if (part[pIdx]?.value.toUpperCase() === "COLLATE") {
+                collation = part[pIdx + 1]?.value;
+                pIdx += 2;
+              }
+              const direction = part[pIdx]?.value.toUpperCase();
+              primaryKeyOrder.push({ desc: direction === "DESC", collation });
+              if (direction === "ASC" || direction === "DESC") pIdx++;
             }
           }
           continue;
@@ -2857,6 +2930,8 @@ var SqliteDatabase = class {
         columns.push(colDef);
         if (colDef.primaryKey && !primaryKeyCols.includes(colDef.name)) {
           primaryKeyCols.push(colDef.name);
+          const primaryIndex = part.findIndex((token) => token.type === "word" && token.value.toUpperCase() === "PRIMARY");
+          primaryKeyOrder.push({ desc: part[primaryIndex + 2]?.value.toUpperCase() === "DESC", collation: colDef.collate });
         }
         if (colDef.unique) {
           uniqueColSets.push([colDef.name]);
@@ -2880,6 +2955,7 @@ var SqliteDatabase = class {
         withoutRowId,
         strict,
         primaryKeyCols,
+        primaryKeyOrder,
         uniqueColSets
       });
       return;
@@ -2895,32 +2971,55 @@ var SqliteDatabase = class {
         return i >= idx && t.value.toUpperCase() === "ON";
       });
       const tableName = tokens[onIdx + 1]?.value ?? "";
+      const tbl = this.findTable(tableName);
+      if (!tbl) throw new Error(`no such table: ${tableName}`);
       const cols = [];
+      const collations = [];
       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);
-          }
-          p += 1;
-        }
+      if (tokens[p++]?.value !== "(") throw new Error("expected index columns");
+      while (p < tokens.length && tokens[p]?.value !== ")") {
+        yield;
+        const name = tokens[p++].value;
+        const column = tbl.columns.find((col) => col.name.toLowerCase() === name.toLowerCase());
+        if (!column) throw new Error(`no such column: ${name}`);
+        cols.push(column.name);
+        let collation = column.collate ?? "BINARY";
+        if (tokens[p]?.value.toUpperCase() === "COLLATE") {
+          p++;
+          collation = tokens[p++]?.value.toUpperCase() ?? "";
+          if (!["BINARY", "NOCASE", "RTRIM"].includes(collation)) throw new Error(`no such collation sequence: ${collation}`);
+        }
+        collations.push(collation);
+        if (["ASC", "DESC"].includes(tokens[p]?.value.toUpperCase() ?? "")) p++;
+        if (tokens[p]?.value === ",") p++;
+        else if (tokens[p]?.value !== ")") throw new Error("expected index column separator");
       }
-      this.indexes.set(objName, {
-        name: objName,
-        tableName,
-        unique,
-        columns: cols,
-        sql
-      });
       if (unique) {
-        const tbl = this.findTable(tableName);
-        if (tbl && cols.length > 0) {
-          tbl.uniqueColSets.push(cols);
+        const keys = [];
+        for (const row of tbl.rows) {
+          const key = [];
+          for (const col of cols) {
+            yield;
+            const value = row.data[col] ?? null;
+            if (value === null) break;
+            key.push(value);
+          }
+          if (key.length === cols.length) keys.push(key);
+        }
+        function* compareKeys(left, right) {
+          for (let c = 0; c < cols.length; c++) {
+            yield;
+            const order = compareSqlValues(left[c], right[c], collations[c]);
+            if (order !== 0) return order;
+          }
+          return 0;
+        }
+        yield* stepSort(keys, compareKeys, this);
+        for (let i = 1; i < keys.length; i++) {
+          if ((yield* compareKeys(keys[i - 1], keys[i])) === 0) throw new SqliteConstraintError(`UNIQUE constraint failed: ${tbl.name}`);
         }
       }
+      this.indexes.set(objName, { name: objName, tableName: tbl.name, unique, columns: cols, collations, sql });
       return;
     }
     if (kind === "VIEW") {
@@ -3389,21 +3488,25 @@ var SqliteDatabase = class {
     }
     return `X'${hex}'`;
   }
-  *checkConstraintsAndConflicts(tbl, candidate, excludeRowid) {
+  *checkConstraintsAndConflicts(tbl, candidate, excludeRowid, replaceNotNull = false) {
     for (const col of tbl.columns) {
       yield;
-      const val = candidate.data[col.name] ?? null;
+      let val = candidate.data[col.name] ?? null;
+      if (replaceNotNull && col.notNull && val === null && col.defaultExpr) {
+        val = applyColumnAffinity(yield* this.evalScalarSql(col.defaultExpr, {}, []), col.type);
+        candidate.data[col.name] = val;
+      }
       if (col.notNull && val === null) {
         if (col.primaryKey && col.type.toUpperCase() === "INTEGER" && !tbl.withoutRowId) {
           candidate.data[col.name] = candidate.rowid;
         } else {
-          throw new Error(`NOT NULL constraint failed: ${tbl.name}.${col.name}`);
+          throw new SqliteConstraintError(`NOT NULL constraint failed: ${tbl.name}.${col.name}`);
         }
       }
       if (col.checkExpr && val !== null) {
         const ok = yield* this.evalExprSteps(parseExprSql(col.checkExpr), candidate.data, []);
         if (ok !== null && !isTruthy(ok)) {
-          throw new Error(`CHECK constraint failed: ${col.checkExpr}`);
+          throw new SqliteConstraintError(`CHECK constraint failed: ${col.checkExpr}`);
         }
       }
     }
@@ -3415,9 +3518,6 @@ var SqliteDatabase = class {
       yield;
       keySets.push(u);
     }
-    if (keySets.length === 0 && candidate.rowid >= tbl.nextRowId) {
-      return null;
-    }
     const resolvedKeySets = yield* stepMap(keySets, function* (kSet) {
       yield;
       return kSet.map((colName) => {
@@ -3427,6 +3527,12 @@ var SqliteDatabase = class {
         return { cKey: realCol ? realCol.name : colName, collate: realCol?.collate ?? "BINARY" };
       });
     }, this);
+    for (const index of this.indexes.values()) {
+      yield;
+      if (index.unique && index.tableName.toLowerCase() === tbl.name.toLowerCase()) {
+        resolvedKeySets.push(index.columns.map((cKey, i) => ({ cKey, collate: index.collations?.[i] ?? tbl.columns.find((col) => col.name === cKey)?.collate ?? "BINARY" })));
+      }
+    }
     for (const existing of tbl.rows) {
       yield;
       if (excludeRowid !== void 0 && existing.rowid === excludeRowid) {
@@ -3454,6 +3560,23 @@ var SqliteDatabase = class {
     }
     return null;
   }
+  synchronizeRowid(tbl, candidate, assigned) {
+    if (tbl.withoutRowId) return;
+    const primary = tbl.columns.find((col) => col.primaryKey && col.type.toUpperCase() === "INTEGER" && tbl.primaryKeyCols.length === 1);
+    for (const name of assigned) {
+      const column = tbl.columns.find((col) => col.name.toLowerCase() === name.toLowerCase());
+      if (column ? column !== primary : !["rowid", "_rowid_", "oid"].includes(name.toLowerCase())) continue;
+      const key = column?.name ?? name;
+      const value = candidate.data[key];
+      if (value !== null && value !== void 0) {
+        const number = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+        if (typeof number !== "number" || !Number.isSafeInteger(number)) throw new Error("datatype mismatch");
+        candidate.rowid = number;
+      }
+      if (!column) delete candidate.data[key];
+    }
+    if (primary) candidate.data[primary.name] = candidate.rowid;
+  }
   *executeInsert(_sql, tokens, positionalParams, cteScope) {
     let idx = 0;
     let conflictAction = "ABORT";
@@ -3678,6 +3801,8 @@ var SqliteDatabase = class {
         }
       }
       const candidate = { rowid, data };
+      this.synchronizeRowid(tbl, candidate, targetCols);
+      rowid = candidate.rowid;
       yield* this.fireTriggers(tbl.name, "BEFORE", "INSERT", void 0, candidate.data);
       const conflictRow = yield* this.checkConstraintsAndConflicts(tbl, candidate);
       if (conflictRow) {
@@ -3839,7 +3964,9 @@ var SqliteDatabase = class {
   }
   *executeUpdate(tokens, positionalParams, _cteScope) {
     let idx = 1;
+    let conflictAction = "ABORT";
     if (tokens[idx]?.value.toUpperCase() === "OR") {
+      conflictAction = tokens[idx + 1]?.value.toUpperCase() ?? "ABORT";
       idx += 2;
     }
     if (tokens[idx + 1]?.value === ".") {
@@ -3929,8 +4056,10 @@ var SqliteDatabase = class {
       }
       return [];
     }, this);
+    const replacedRows = /* @__PURE__ */ new Set();
     for (const { row, ctx } of matches) {
       yield;
+      if (replacedRows.has(row)) continue;
       const oldData = { ...row.data };
       const newData = { ...row.data };
       for (const assign of assignments) {
@@ -3955,11 +4084,25 @@ var SqliteDatabase = class {
       }
       yield* this.fireTriggers(tbl.name, "BEFORE", "UPDATE", oldData, newData);
       const candidate = { rowid: row.rowid, data: newData };
-      const conflict = yield* this.checkConstraintsAndConflicts(tbl, candidate, row.rowid);
-      if (conflict) {
-        throw new Error(`UNIQUE constraint failed: ${tbl.name}`);
+      this.synchronizeRowid(tbl, candidate, assignments.map((assignment) => assignment.col));
+      let conflict;
+      try {
+        conflict = yield* this.checkConstraintsAndConflicts(tbl, candidate, row.rowid, conflictAction === "REPLACE");
+      } catch (error) {
+        if (conflictAction === "IGNORE" && error instanceof SqliteConstraintError) continue;
+        throw error;
+      }
+      if (conflict && conflictAction === "IGNORE") continue;
+      while (conflict) {
+        if (conflictAction !== "REPLACE") throw new Error(`UNIQUE constraint failed: ${tbl.name}`);
+        replacedRows.add(conflict);
+        tbl.rows.splice(tbl.rows.indexOf(conflict), 1);
+        conflict = yield* this.checkConstraintsAndConflicts(tbl, candidate, row.rowid);
       }
       row.data = newData;
+      row.rowid = candidate.rowid;
+      tbl.nextRowId = Math.max(tbl.nextRowId, row.rowid + 1);
+      tbl.maxAutoInc = Math.max(tbl.maxAutoInc, row.rowid);
       updated += 1;
       affectedRows.push(row);
       yield* this.fireTriggers(tbl.name, "AFTER", "UPDATE", oldData, newData);
@@ -4512,8 +4655,9 @@ var SqliteDatabase = class {
             yield;
             for (const col of src.columns) {
               yield;
+              if (src.hidden?.has(col.toLowerCase())) continue;
               selectTargets.push({
-                expr: { kind: "column", table: src.tableAlias || void 0, name: col },
+                expr: { kind: "column", table: src.shared?.has(col.toLowerCase()) ? void 0 : src.tableAlias || void 0, name: col },
                 alias: col
               });
             }
@@ -4679,7 +4823,7 @@ var SqliteDatabase = class {
         windowResults
       );
     }
-    const projected = yield* stepMap(groupedRows, function* (g, rowIdx) {
+    let projected = yield* stepMap(groupedRows, function* (g, rowIdx) {
       const repCtx = { ...g.representative };
       const values = yield* stepMap(selectTargets, function* (st) {
         const val = yield* this.evalExprSteps(
@@ -4696,6 +4840,33 @@ var SqliteDatabase = class {
       }, this);
       return { values, ctx: repCtx, group: g.group };
     }, this);
+    const firstWindow = windowResults.keys().next().value;
+    if (!orderByTokens?.length && firstWindow?.kind === "func" && firstWindow.over) {
+      const sortSpecs = [
+        ...firstWindow.over.partitionBy.map((expr) => ({ expr, desc: false })),
+        ...firstWindow.over.orderBy
+      ];
+      if (sortSpecs.length > 0) {
+        const keyed = yield* stepMap(projected, function* (row) {
+          const keys = yield* stepMap(sortSpecs, function* (spec) {
+            return yield* this.evalExprSteps(spec.expr, row.ctx, positionalParams, cteScope, { group: row.group });
+          }, this);
+          return { row, keys };
+        }, this);
+        yield* stepSort(keyed, function* (a, b) {
+          for (let i = 0; i < sortSpecs.length; i++) {
+            yield;
+            const cmp = compareSqlValues(a.keys[i], b.keys[i]);
+            if (cmp !== 0) return sortSpecs[i].desc ? -cmp : cmp;
+          }
+          return 0;
+        }, this);
+        projected = yield* stepMap(keyed, function* (entry) {
+          yield;
+          return entry.row;
+        }, this);
+      }
+    }
     let finalProjected = projected;
     if (distinct) {
       const seen = /* @__PURE__ */ new Set();
@@ -5007,6 +5178,13 @@ var SqliteDatabase = class {
         yield;
         return prevCols.has(c.toLowerCase());
       }, this) : item.usingCols;
+      if (usingList) {
+        const shared = new Set(usingList.map((column) => column.toLowerCase()));
+        schema[schema.length - 1].hidden = shared;
+        for (const source of schema) {
+          source.shared = /* @__PURE__ */ new Set([...source.shared ?? [], ...shared]);
+        }
+      }
       const rightMatched = /* @__PURE__ */ new Set();
       for (const leftRow of currentRows) {
         yield;
@@ -7254,6 +7432,26 @@ function splitDotCommandArgs(line) {
   }
   return args;
 }
+function isMutatingStatement(sql) {
+  const tokens = tokenizeSql(sql);
+  let depth = 0;
+  for (const token of tokens) {
+    if (token.type === "punct" && token.value === "(") {
+      depth++;
+      continue;
+    }
+    if (token.type === "punct" && token.value === ")") {
+      depth--;
+      continue;
+    }
+    if (depth !== 0 || token.type !== "word") continue;
+    const word = token.value.toUpperCase();
+    if (["CREATE", "DROP", "ALTER", "INSERT", "REPLACE", "UPDATE", "DELETE", "VACUUM", "REINDEX", "ANALYZE"].includes(word)) return true;
+    if (word === "PRAGMA") return tokens.some((item) => item.value === "=" || item.value === "(");
+    if (["SELECT", "VALUES", "EXPLAIN"].includes(word)) return false;
+  }
+  return false;
+}
 var settings = {
   commandName: "sqlite3",
   limits: {
@@ -7430,7 +7628,7 @@ Options:
           } else if (arg === "-init" || arg === "--init") {
             initFile = args[i + 1] ?? null;
             i += 1;
-          } else if (arg.startsWith("-")) {
+          } else if (arg.startsWith("-") && positional.length === 0) {
             await writeText(context.stderr, `sqlite3: Error: unknown option: ${arg}
 `);
             return { exitCode: 1 };
@@ -7830,6 +8028,7 @@ Options:
             return;
           }
           if (cmd === ".import") {
+            if (state.readonly) throw new Error("attempt to write a readonly database");
             let pIdx = 1;
             let csvOverride = false;
             let skipRows = 0;
@@ -7926,6 +8125,7 @@ Options:
             return;
           }
           if (cmd === ".restore") {
+            if (state.readonly) throw new Error("attempt to write a readonly database");
             const srcArg = parts.length >= 3 ? parts[2] : parts[1];
             const srcPath = resolveVfsPath(context.cwd, srcArg);
             db.tables?.clear();
@@ -7973,8 +8173,7 @@ Options:
             await emitOutput(`${stmt}
 `);
           }
-          const upper = stmt.trim().toUpperCase();
-          const isMutating = upper.startsWith("CREATE") || upper.startsWith("DROP") || upper.startsWith("ALTER") || upper.startsWith("INSERT") || upper.startsWith("REPLACE") || upper.startsWith("UPDATE") || upper.startsWith("DELETE") || upper.startsWith("VACUUM") || upper.startsWith("PRAGMA") && stmt.includes("=");
+          const isMutating = isMutatingStatement(stmt);
           if (state.readonly && isMutating) {
             throw new Error("attempt to write a readonly database");
           }
@@ -8251,7 +8450,7 @@ Options:
       } else if (arg === "-init" || arg === "--init") {
         initFile = opArgs[i + 1] ?? null;
         i += 1;
-      } else if (arg.startsWith("-")) {
+      } else if (arg.startsWith("-") && positional.length === 0) {
         return void 0;
       } else {
         positional.push(arg);
@@ -8494,7 +8693,7 @@ Options:
     const runSqlStatementSync = (stmt) => {
       const trimmed = stmt.trim();
       if (!trimmed) return true;
-      const isMutating = !/^\s*(SELECT|PRAGMA|EXPLAIN|VALUES|WITH\s+[\s\S]*?\bSELECT)\b/i.test(trimmed);
+      const isMutating = isMutatingStatement(trimmed);
       if (isMutating) {
         if (state.readonly || state.dbPath !== ":memory:" && !writeFileSync) return false;
       }