@poe-platform/safe-bash 0.1.818 → 0.1.819

package/dist/safe-bash-sqlite-engine/storage.js

@@ -6,7 +6,7 @@ import {
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-sqlite-engine/src/sqlite-transaction.ts
-import { FsError as FsError13, toByteSource } from "../safe-bash-contracts/index.js";
+import { FsError as FsError14, toByteSource } from "../safe-bash-contracts/index.js";
 
 // packages/safe-bash-sqlite-engine/src/sqlite-sources.ts
 import { FsError as FsError2 } from "../safe-bash-contracts/index.js";
@@ -396,6 +396,9 @@ async function withPrivateSqliteSession(options, operation) {
   return value;
 }
 
+// packages/safe-bash-sqlite-engine/src/sqlite-copy-snapshot.ts
+import { FsError as FsError7 } from "../safe-bash-contracts/index.js";
+
 // packages/safe-bash-sqlite-engine/src/sqlite-wal.ts
 import { FsError as FsError6 } from "../safe-bash-contracts/index.js";
 import { yieldTurn } from "../safe-bash-contracts/yield.js";
@@ -523,23 +526,91 @@ async function createSqliteWalSnapshot(database, wal, index, options) {
   };
 }
 
+// packages/safe-bash-sqlite-engine/src/sqlite-copy-snapshot.ts
+async function copySqliteSnapshot(options) {
+  const { sources, storage, path: privatePath, signal, maxFileBytes, maxIndexBytes } = options;
+  const path = sources.path, cleanups = [];
+  const errors = [];
+  let result;
+  try {
+    const copy = async (source, target) => {
+      const stat = await source.stat({ signal });
+      if (!Number.isSafeInteger(stat.size) || stat.size < 0 || stat.size > maxFileBytes) throw new FsError7("EFBIG", { path: target });
+      const file = await storage.fs.open(target, { access: "readwrite", creation: "exclusive", signal });
+      try {
+        for (let position = 0; position < stat.size; ) {
+          const bytes = await source.read(position, Math.min(16384, stat.size - position), { signal });
+          if (!bytes.length || bytes.length > Math.min(16384, stat.size - position)) throw new FsError7("EIO", { path: target });
+          await writeSqliteFile(file, bytes, position, signal);
+          position += bytes.length;
+        }
+      } finally {
+        await file.close();
+      }
+    };
+    let snapshot = sources.database?.file;
+    if (snapshot && sources.wal?.stat.size) {
+      const index = await storage.fs.open(`${privatePath}-index`, { access: "readwrite", creation: "exclusive", signal });
+      cleanups.push(() => index.close());
+      snapshot = await createSqliteWalSnapshot(snapshot, sources.wal.file, index, { signal, maxIndexBytes });
+      const overlay = snapshot;
+      cleanups.push(() => overlay.close());
+    }
+    if (!snapshot && (sources.wal?.stat.size || sources.journal?.stat.size)) throw new FsError7("EIO", { path, message: "SQLite sidecar has no database" });
+    let walMode = false;
+    if (snapshot) {
+      await copy(snapshot, privatePath);
+      const file = await storage.fs.open(privatePath, { access: "readwrite", creation: "never", signal });
+      try {
+        const header = new Uint8Array(20);
+        let count = 0;
+        while (count < header.length) {
+          const read = await file.read(header.subarray(count), count, { signal });
+          if (!read) break;
+          count += read;
+        }
+        walMode = count === 20 && header[18] === 2 && header[19] === 2;
+        if (walMode) await writeSqliteFile(file, new Uint8Array([1, 1]), 18, signal);
+      } finally {
+        await file.close();
+      }
+    }
+    if (sources.journal?.stat.size) {
+      if (walMode) throw new FsError7("EIO", { path, message: "SQLite WAL database has a rollback journal" });
+      await copy(sources.journal.file, `${privatePath}-journal`);
+    }
+    sources.validate();
+    result = { walMode };
+  } catch (error) {
+    errors.push(error);
+  }
+  for (const cleanup of cleanups.reverse()) try {
+    await cleanup();
+  } catch (error) {
+    errors.push(error);
+  }
+  if (errors.length === 1) throw errors[0];
+  if (errors.length) throw new AggregateError(errors, "SQLite snapshot copy and cleanup failed");
+  return result;
+}
+
 // packages/safe-bash-sqlite-engine/src/sqlite-finalization.ts
-import { FsError as FsError11 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError12 } from "../safe-bash-contracts/index.js";
 
 // packages/safe-bash-sqlite-engine/src/sqlite-record-write.ts
-import { FsError as FsError9 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError10 } from "../safe-bash-contracts/index.js";
 
 // packages/safe-bash-sqlite-engine/src/sqlite-varint.ts
-import { FsError as FsError7 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError8 } from "../safe-bash-contracts/index.js";
 function readSqliteVarint(bytes, start) {
   let value = 0n;
   for (let i = 0; i < 9; i++) {
     const byte = bytes[start + i];
-    if (byte === void 0) throw new FsError7("EIO", { message: "Invalid SQLite varint" });
+    if (byte === void 0) throw new FsError8("EIO", { message: "Invalid SQLite varint" });
     value = value << BigInt(i === 8 ? 8 : 7) | BigInt(i === 8 ? byte : byte & 127);
     if (i === 8 || byte < 128) return { value, end: start + i + 1 };
   }
-  throw new FsError7("EIO", { message: "Invalid SQLite varint" });
+  throw new FsError8("EIO", { message: "Invalid SQLite varint" });
 }
 function writeSqliteVarint(value) {
   if (value < 0n || value > 0xffffffffffffffffn) throw new RangeError("SQLite varint out of range");
@@ -557,10 +628,10 @@ function writeSqliteVarint(value) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-pages.ts
-import { FsError as FsError8 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError9 } from "../safe-bash-contracts/index.js";
 import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
 function corrupt() {
-  throw new FsError8("EIO", { message: "Invalid SQLite table record or page chain" });
+  throw new FsError9("EIO", { message: "Invalid SQLite table record or page chain" });
 }
 function u16(bytes, offset) {
   if (offset < 0 || offset + 2 > bytes.length) return corrupt();
@@ -743,7 +814,7 @@ async function* sqliteSourceChunks(source, signal) {
 async function rewriteSqliteRecords(options) {
   const { fs, directory, path, records, signal } = options;
   signal.throwIfAborted();
-  if (!path.startsWith(directory + "/") || path.slice(directory.length + 1).includes("/") || !fs.open || !fs.unlink) throw new FsError9("EACCES", { path });
+  if (!path.startsWith(directory + "/") || path.slice(directory.length + 1).includes("/") || !fs.open || !fs.unlink) throw new FsError10("EACCES", { path });
   const temporary = directory + "/record-source-" + crypto.randomUUID();
   const errors = [];
   const remember = (error) => {
@@ -763,7 +834,7 @@ async function rewriteSqliteRecords(options) {
       verifySqliteSnapshot(await file.stat({ signal }), original);
       const bytes = new Uint8Array(Math.min(16384, original.size - position));
       const count = await file.read(bytes, position, { signal });
-      if (!Number.isSafeInteger(count) || count < 1 || count > bytes.length) throw new FsError9("EIO", { path });
+      if (!Number.isSafeInteger(count) || count < 1 || count > bytes.length) throw new FsError10("EIO", { path });
       await writeSqliteFile(copy, bytes.subarray(0, count), position, signal);
       position += count;
     }
@@ -772,14 +843,14 @@ async function rewriteSqliteRecords(options) {
     const snapshot = { stat: (controls) => source.stat(controls), async read(position, count, controls) {
       const bytes = new Uint8Array(Math.min(count, 16384));
       const length = await source.read(bytes, position, controls);
-      if (!Number.isSafeInteger(length) || length < 0 || length > bytes.length) throw new FsError9("EIO", { path: temporary });
+      if (!Number.isSafeInteger(length) || length < 0 || length > bytes.length) throw new FsError10("EIO", { path: temporary });
       return bytes.slice(0, length);
     }, async close() {
     } };
     for await (const { rootPage, rowid, record } of sqliteSourceChunks(records, signal)) {
       signal.throwIfAborted();
       const stored = await findSqliteRecord(snapshot, rootPage, rowid, signal);
-      if (!stored) throw new FsError9("ENOENT", { path, message: "SQLite placeholder record is missing" });
+      if (!stored) throw new FsError10("ENOENT", { path, message: "SQLite placeholder record is missing" });
       if (stored.size !== record.size) throw new RangeError("SQLite placeholder record length mismatch");
       const spans = stored.spans()[Symbol.asyncIterator]();
       let span = await spans.next(), offset = 0, received = 0;
@@ -822,10 +893,10 @@ async function rewriteSqliteRecords(options) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-edit-snapshot.ts
-import { FsError as FsError10 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError11 } from "../safe-bash-contracts/index.js";
 async function withSqliteEditSnapshot(options, operation) {
   const { fs, directory, path, signal } = options;
-  if (!fs.open || !fs.unlink || !path.startsWith(directory + "/") || path.slice(directory.length + 1).includes("/")) throw new FsError10("EACCES", { path });
+  if (!fs.open || !fs.unlink || !path.startsWith(directory + "/") || path.slice(directory.length + 1).includes("/")) throw new FsError11("EACCES", { path });
   const temporary = directory + "/edit-source-" + crypto.randomUUID();
   let source, copy, created = false, active = true, pending, value;
   const errors = [];
@@ -833,9 +904,9 @@ async function withSqliteEditSnapshot(options, operation) {
     if (!errors.includes(error)) errors.push(error);
   };
   const run = (action) => {
-    if (!active) return Promise.reject(new FsError10("EBADF", { message: "SQLite edit snapshot is closed" }));
+    if (!active) return Promise.reject(new FsError11("EBADF", { message: "SQLite edit snapshot is closed" }));
     if (pending) {
-      const error = new FsError10("EBUSY", { message: "SQLite snapshot reads must be serialized" });
+      const error = new FsError11("EBUSY", { message: "SQLite snapshot reads must be serialized" });
       remember(error);
       return Promise.reject(error);
     }
@@ -865,7 +936,7 @@ async function withSqliteEditSnapshot(options, operation) {
       verifySqliteSnapshot(await source.stat({ signal }), expected);
       const bytes = new Uint8Array(Math.min(16384, expected.size - position));
       const count = await source.read(bytes, position, { signal });
-      if (!Number.isSafeInteger(count) || count < 1 || count > bytes.length) throw new FsError10("EIO", { path });
+      if (!Number.isSafeInteger(count) || count < 1 || count > bytes.length) throw new FsError11("EIO", { path });
       await writeSqliteFile(copy, bytes.subarray(0, count), position, signal);
       position += count;
     }
@@ -876,7 +947,7 @@ async function withSqliteEditSnapshot(options, operation) {
     const snapshot = { stat: (controls) => file.stat(controls), async read(position, count, controls) {
       const bytes = new Uint8Array(Math.min(count, 16384));
       const length = await file.read(bytes, position, controls);
-      if (!Number.isSafeInteger(length) || length < 0 || length > bytes.length) throw new FsError10("EIO", { path: temporary });
+      if (!Number.isSafeInteger(length) || length < 0 || length > bytes.length) throw new FsError11("EIO", { path: temporary });
       return bytes.slice(0, length);
     }, async close() {
     } };
@@ -931,9 +1002,9 @@ async function finalizeSqlite(options, operation) {
     if (!errors.includes(error)) errors.push(error);
   };
   const run = (action) => {
-    if (!accepting) return Promise.reject(new FsError11("EBADF", { message: "SQLite finalization is closed" }));
+    if (!accepting) return Promise.reject(new FsError12("EBADF", { message: "SQLite finalization is closed" }));
     if (busy) {
-      const error = new FsError11("EBUSY", { message: "SQLite finalization phases overlap" });
+      const error = new FsError12("EBUSY", { message: "SQLite finalization phases overlap" });
       remember(error);
       return Promise.reject(error);
     }
@@ -988,7 +1059,7 @@ async function finalizeSqlite(options, operation) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-publication.ts
-import { FsError as FsError12 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError13 } from "../safe-bash-contracts/index.js";
 import { yieldTurn as yieldTurn3 } from "../safe-bash-contracts/yield.js";
 async function publishSqliteSnapshot(options) {
   const { fs, snapshot, path, signal } = options;
@@ -1004,7 +1075,7 @@ async function publishSqliteSnapshot(options) {
   signal.throwIfAborted();
   const capabilities = await fs.capabilitiesFor?.(path, { signal, create: expected === null }) ?? fs.capabilities;
   if (sourceSet !== void 0 ? !fs.publishStagedFileSet || capabilities.retainedStagingWrite !== true || !staging?.writer : capabilities.atomicFilePublication !== true || !fs.publishFileConditional) {
-    throw new FsError12("ENOTSUP", { path, message: "SQLite snapshots require atomic conditional publication" });
+    throw new FsError13("ENOTSUP", { path, message: "SQLite snapshots require atomic conditional publication" });
   }
   const original = await snapshot.stat({ signal });
   verifySqliteSnapshot(original, original);
@@ -1028,7 +1099,7 @@ async function publishSqliteSnapshot(options) {
       const requested = Math.min(16384, stop - start);
       const bytes2 = await snapshot.read(start, requested, { signal });
       if (!(bytes2 instanceof Uint8Array) || bytes2.length === 0 || bytes2.length > requested) {
-        throw new FsError12("EIO", { message: "Invalid SQLite snapshot read" });
+        throw new FsError13("EIO", { message: "Invalid SQLite snapshot read" });
       }
       const owned = bytes2.slice();
       await check();
@@ -1060,12 +1131,12 @@ async function publishSqliteSnapshot(options) {
   }
   if (staging && companions) {
     if (staging.file.stat.size !== 0 || staging.file.stat.type !== "file") {
-      throw new FsError12("EINVAL", { path: staging.file.path, message: "SQLite publication requires empty regular-file staging" });
+      throw new FsError13("EINVAL", { path: staging.file.path, message: "SQLite publication requires empty regular-file staging" });
     }
     for await (const chunk of bytes()) await staging.writer.write(chunk, { signal });
     const stat = await staging.writer.finish({ signal });
     if (stat.type !== "file" || stat.size !== original.size) {
-      throw new FsError12("EIO", { path: staging.file.path, message: "SQLite staged snapshot size mismatch" });
+      throw new FsError13("EIO", { path: staging.file.path, message: "SQLite staged snapshot size mismatch" });
     }
     await check();
     return fs.publishStagedFileSet({ ...staging, file: { ...staging.file, stat } }, path, {
@@ -1094,56 +1165,11 @@ async function transactSqlite(options, operation) {
     cleanups.push(() => sources.close());
     const path = sources.path;
     const directory = path.slice(0, path.lastIndexOf("/")) || "/";
-    if (!fs.createStagedFile || !fs.publishStagedFileSet) throw new FsError13("ENOTSUP", { path, message: "SQLite transactions require retained source-set publication" });
+    if (!fs.createStagedFile || !fs.publishStagedFileSet) throw new FsError14("ENOTSUP", { path, message: "SQLite transactions require retained source-set publication" });
     const storage = await createPrivateSqliteStorage({ fs, directory, signal, maxFiles: options.maxOpenFiles });
     cleanups.push(() => storage.close());
     const privatePath = `${storage.directory}/database`;
-    const copy = async (source, target) => {
-      const stat = await source.stat({ signal });
-      if (!Number.isSafeInteger(stat.size) || stat.size < 0 || stat.size > maxFileBytes) throw new FsError13("EFBIG", { path: target });
-      const file2 = await storage.fs.open(target, { access: "readwrite", creation: "exclusive", signal });
-      try {
-        for (let position = 0; position < stat.size; ) {
-          const bytes = await source.read(position, Math.min(16384, stat.size - position), { signal });
-          if (!bytes.length || bytes.length > Math.min(16384, stat.size - position)) throw new FsError13("EIO", { path: target });
-          await writeSqliteFile(file2, bytes, position, signal);
-          position += bytes.length;
-        }
-      } finally {
-        await file2.close();
-      }
-    };
-    let snapshot = sources.database?.file;
-    if (snapshot && sources.wal?.stat.size) {
-      const index = await storage.fs.open(`${storage.directory}/index`, { access: "readwrite", creation: "exclusive", signal });
-      cleanups.push(() => index.close());
-      snapshot = await createSqliteWalSnapshot(snapshot, sources.wal.file, index, { signal, maxIndexBytes: options.maxIndexBytes });
-      const overlay = snapshot;
-      cleanups.push(() => overlay.close());
-    }
-    if (!snapshot && (sources.wal?.stat.size || sources.journal?.stat.size)) throw new FsError13("EIO", { path, message: "SQLite sidecar has no database" });
-    let walMode = false;
-    if (snapshot) {
-      await copy(snapshot, privatePath);
-      const file2 = await storage.fs.open(privatePath, { access: "readwrite", creation: "never", signal });
-      try {
-        const header = new Uint8Array(20);
-        let count = 0;
-        while (count < header.length) {
-          const read = await file2.read(header.subarray(count), count, { signal });
-          if (!read) break;
-          count += read;
-        }
-        walMode = count === 20 && header[18] === 2 && header[19] === 2;
-        if (walMode) await writeSqliteFile(file2, new Uint8Array([1, 1]), 18, signal);
-      } finally {
-        await file2.close();
-      }
-    }
-    if (sources.journal?.stat.size) {
-      if (walMode) throw new FsError13("EIO", { path, message: "SQLite WAL database has a rollback journal" });
-      await copy(sources.journal.file, `${privatePath}-journal`);
-    }
+    const { walMode } = await copySqliteSnapshot({ ...options, sources, storage, path: privatePath });
     value = await withPrivateSqliteSession({ ...options, fs: storage.fs, directory: storage.directory, path: privatePath }, async (session) => {
       await session.execute("BEGIN IMMEDIATE");
       const result = await operation(session);
@@ -1175,7 +1201,7 @@ async function transactSqlite(options, operation) {
       cleanups.push(() => staging.cleanup.close());
       cleanups.push(() => staging.cleanup.remove());
     } else {
-      throw new FsError13("EIO", { path, message: "SQLite publication staging omitted retained cleanup" });
+      throw new FsError14("EIO", { path, message: "SQLite publication staging omitted retained cleanup" });
     }
     committed = await publishSqliteSnapshot({
       fs,
@@ -1205,7 +1231,7 @@ async function transactSqlite(options, operation) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-statement.ts
-import { FsError as FsError14 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError15 } from "../safe-bash-contracts/index.js";
 import { yieldTurn as yieldTurn4 } from "../safe-bash-contracts/yield.js";
 async function withSqliteStatement(module, options, operation) {
   const { database, sql, signal, check } = options;
@@ -1232,7 +1258,7 @@ async function withSqliteStatement(module, options, operation) {
   const bindText = module.cwrap("sqlite3_bind_text", "number", ["number", "number", "number", "number", "number"]);
   const result = (code) => {
     check();
-    if (code !== 0) throw new FsError14("EIO", { message: `Native SQLite statement failed (${code})` });
+    if (code !== 0) throw new FsError15("EIO", { message: `Native SQLite statement failed (${code})` });
   };
   let out = 0, statement = 0, accepting = true, current, value;
   const errors = [];
@@ -1249,8 +1275,8 @@ async function withSqliteStatement(module, options, operation) {
   };
   const rows = (bindings, columns) => {
     async function* iterate() {
-      if (!accepting) throw new FsError14("EBADF", { message: "SQLite statement is closed" });
-      if (current) throw new FsError14("EBUSY", { message: "SQLite cursor is already active" });
+      if (!accepting) throw new FsError15("EBADF", { message: "SQLite statement is closed" });
+      if (current) throw new FsError15("EBUSY", { message: "SQLite cursor is already active" });
       current = iterator;
       let failed = false, failure;
       try {
@@ -1340,7 +1366,7 @@ async function withSqliteStatement(module, options, operation) {
     statement = new DataView(module.HEAPU8.buffer).getInt32(out, true);
     result(code);
     signal.throwIfAborted();
-    if (!statement) throw new FsError14("EIO", { message: "SQLite returned an empty statement" });
+    if (!statement) throw new FsError15("EIO", { message: "SQLite returned an empty statement" });
     value = await operation({ rows });
   } catch (error) {
     errors.push(error);
@@ -1375,7 +1401,7 @@ async function withSqliteStatement(module, options, operation) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-blob-read.ts
-import { FsError as FsError15 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError16 } from "../safe-bash-contracts/index.js";
 import { yieldTurn as yieldTurn5 } from "../safe-bash-contracts/yield.js";
 async function* readSqliteBlob(module, options) {
   const { database, table, column, rowid, signal, check } = options;
@@ -1390,7 +1416,7 @@ async function* readSqliteBlob(module, options) {
   const close = module.cwrap("sqlite3_blob_close", "number", ["number"], { async: true });
   const result = (code) => {
     check();
-    if (code !== 0) throw new FsError15("EIO", { message: `Native SQLite blob read failed (${code})` });
+    if (code !== 0) throw new FsError16("EIO", { message: `Native SQLite blob read failed (${code})` });
   };
   let out = 0, blob = 0, buffer = 0;
   let failed = false, failure;
@@ -1404,7 +1430,7 @@ async function* readSqliteBlob(module, options) {
     if (blob) try {
       const code = await close(blob);
       if (!failed) check();
-      if (code !== 0) errors.push(new FsError15("EIO", { message: `Native SQLite blob close failed (${code})` }));
+      if (code !== 0) errors.push(new FsError16("EIO", { message: `Native SQLite blob close failed (${code})` }));
     } catch (error) {
       errors.push(error);
     }
@@ -1426,8 +1452,8 @@ async function* readSqliteBlob(module, options) {
     result(code);
     signal.throwIfAborted();
     const size = length(blob);
-    if (!blob || !Number.isSafeInteger(size) || size < 0) throw new FsError15("EIO", { message: "Invalid SQLite blob size" });
-    if (size > maxBytes) throw new FsError15("EFBIG", { message: "LLM schema input byte limit exceeded" });
+    if (!blob || !Number.isSafeInteger(size) || size < 0) throw new FsError16("EIO", { message: "Invalid SQLite blob size" });
+    if (size > maxBytes) throw new FsError16("EFBIG", { message: "LLM schema input byte limit exceeded" });
     if (size) {
       buffer = module._malloc(Math.min(16384, size));
       if (!buffer) throw new RangeError("SQLite memory allocation failed");
@@ -1450,7 +1476,7 @@ async function* readSqliteBlob(module, options) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-blob.ts
-import { FsError as FsError16 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError17 } from "../safe-bash-contracts/index.js";
 import { yieldTurn as yieldTurn6 } from "../safe-bash-contracts/yield.js";
 async function writeSqliteBlob(module, options) {
   const { database, table, column, rowid, source, size, signal, check } = options;
@@ -1464,7 +1490,7 @@ async function writeSqliteBlob(module, options) {
   const close = module.cwrap("sqlite3_blob_close", "number", ["number"], { async: true });
   const result = (code) => {
     check();
-    if (code !== 0) throw new FsError16("EIO", { message: `Native SQLite blob operation failed (${code})` });
+    if (code !== 0) throw new FsError17("EIO", { message: `Native SQLite blob operation failed (${code})` });
   };
   let out = 0, buffer = 0, blob = 0;
   const errors = [];
@@ -1510,7 +1536,7 @@ async function writeSqliteBlob(module, options) {
   if (blob) try {
     const code = await close(blob);
     if (!errors.length) check();
-    if (code !== 0) errors.push(new FsError16("EIO", { message: `Native SQLite blob close failed (${code})` }));
+    if (code !== 0) errors.push(new FsError17("EIO", { message: `Native SQLite blob close failed (${code})` }));
   } catch (error) {
     errors.push(error);
   }
@@ -1588,12 +1614,12 @@ function sqliteRecord(values) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-record-read.ts
-import { FsError as FsError17 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError18 } from "../safe-bash-contracts/index.js";
 async function readSqliteRecord(record, options) {
   const { signal, maxColumns } = options;
   if (!Number.isSafeInteger(maxColumns) || maxColumns < 0 || maxColumns > 65536) throw new RangeError("Invalid SQLite column budget");
   const corrupt2 = () => {
-    throw new FsError17("EIO", { message: "Invalid SQLite record encoding" });
+    throw new FsError18("EIO", { message: "Invalid SQLite record encoding" });
   };
   if (!Number.isSafeInteger(record.size) || record.size < 1) corrupt2();
   const read = async (offset2, length) => {
@@ -1616,7 +1642,7 @@ async function readSqliteRecord(record, options) {
   const header = await read(0, headerSize), values = [];
   let position = start.end, offset = headerSize;
   while (position < headerSize) {
-    if (values.length === maxColumns) throw new FsError17("EFBIG", { message: "SQLite record exceeds column budget" });
+    if (values.length === maxColumns) throw new FsError18("EFBIG", { message: "SQLite record exceeds column budget" });
     const serial = readSqliteVarint(header, position);
     position = serial.end;
     const type = serial.value;
@@ -1650,6 +1676,49 @@ async function readSqliteRecord(record, options) {
   if (position !== headerSize || offset !== record.size) corrupt2();
   return values;
 }
+
+// packages/safe-bash-sqlite-engine/src/sqlite-read-session.ts
+import { FsError as FsError19 } from "../safe-bash-contracts/index.js";
+async function withSqliteReadSession(options, operation) {
+  const { fs, signal } = options;
+  for (const limit of [options.maxFileBytes, options.maxIndexBytes, options.maxOpenFiles]) if (!Number.isSafeInteger(limit) || limit < 0) throw new RangeError("Invalid SQLite snapshot budget");
+  const inputs = [{ path: options.path, alias: "main" }, ...(options.attachments ?? []).map((input) => ({ ...input }))];
+  for (const { alias } of inputs) if (alias.includes("\0") || new TextEncoder().encode(alias).length > 65536) throw new RangeError("Invalid SQLite attachment alias");
+  const storage = await createPrivateSqliteStorage({ ...options, maxFiles: options.maxOpenFiles });
+  const errors = [];
+  let value;
+  try {
+    for (const [index, input] of inputs.entries()) {
+      const sources = await acquireSqliteSources(fs, input.path, signal);
+      try {
+        if (!sources.database) throw new FsError19("ENOENT", { path: input.path });
+        await copySqliteSnapshot({ ...options, sources, storage, path: `${storage.directory}/database-${index}` });
+      } finally {
+        await sources.close();
+      }
+    }
+    value = await withPrivateSqliteSession({ ...options, fs: storage.fs, directory: storage.directory, path: storage.directory + "/database-0" }, async (session) => {
+      for (let index = 1; index < inputs.length; index++) {
+        const alias = inputs[index].alias;
+        await withSqliteStatement(session.module, { ...session, signal, sql: 'ATTACH DATABASE ? AS "' + alias.replaceAll('"', '""') + '"' }, async (statement) => {
+          for await (const ignored of statement.rows([`${storage.directory}/database-${index}`], [])) signal.throwIfAborted();
+        });
+      }
+      await session.execute("PRAGMA query_only=ON");
+      return operation(session);
+    });
+  } catch (error) {
+    errors.push(error);
+  }
+  try {
+    await storage.close();
+  } catch (error) {
+    errors.push(error);
+  }
+  if (errors.length === 1) throw errors[0];
+  if (errors.length) throw new AggregateError(errors, "SQLite read session and cleanup failed");
+  return value;
+}
 export {
   createPrivateSqliteStorage,
   readSqliteBlob,
@@ -1657,6 +1726,7 @@ export {
   sqliteRecord,
   transactSqlite,
   withPrivateSqliteSession,
+  withSqliteReadSession,
   withSqliteStatement,
   writeSqliteBlob
 };

package/dist/safe-bash-xml-engine/document.js

@@ -1,8 +1,8 @@
 import {
   serializeDocument
-} from "../safe-bash/command-chunks/chunk-4Z7PBIMP.js";
-import "../safe-bash/command-chunks/chunk-MMSKDYK6.js";
-import "../safe-bash/command-chunks/chunk-IJE65P52.js";
+} from "../safe-bash/command-chunks/chunk-5P5SF75H.js";
+import "../safe-bash/command-chunks/chunk-WOECEZAC.js";
+import "../safe-bash/command-chunks/chunk-JMUB5A26.js";
 import "../safe-bash/command-chunks/chunk-3I5WTVWZ.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {

package/dist/safe-bash-xml-engine/evaluate.js

@@ -6,7 +6,7 @@ import {
   serialize,
   serializeSimpleSync,
   stringValue
-} from "../safe-bash/command-chunks/chunk-IJE65P52.js";
+} from "../safe-bash/command-chunks/chunk-JMUB5A26.js";
 import "../safe-bash/command-chunks/chunk-3I5WTVWZ.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {

package/dist/safe-bash-xml-engine/index.js

@@ -1,12 +1,12 @@
 import {
   parseQuery
-} from "../safe-bash/command-chunks/chunk-LNKZVU5V.js";
+} from "../safe-bash/command-chunks/chunk-E76WK7OQ.js";
 import {
   serializeDocument
-} from "../safe-bash/command-chunks/chunk-4Z7PBIMP.js";
+} from "../safe-bash/command-chunks/chunk-5P5SF75H.js";
 import {
   parseStoredXml
-} from "../safe-bash/command-chunks/chunk-MMSKDYK6.js";
+} from "../safe-bash/command-chunks/chunk-WOECEZAC.js";
 import {
   escape,
   evaluate,
@@ -15,7 +15,7 @@ import {
   serialize,
   serializeSimpleSync,
   stringValue
-} from "../safe-bash/command-chunks/chunk-IJE65P52.js";
+} from "../safe-bash/command-chunks/chunk-JMUB5A26.js";
 import {
   XmlBudget,
   XmlQueryError,

package/dist/safe-bash-xml-engine/json.js

@@ -40,7 +40,11 @@ async function* storedXmlToJson(document, budget) {
   }
   async function hash(parent, name) {
     let value = 14695981039346656037n;
-    for (const part of [String(parent), ":", name]) for (const character of part) {
+    for await (const part of (async function* () {
+      yield String(parent);
+      yield ":";
+      yield* document.nameText(name);
+    })()) for (const character of part) {
       const checkpoint = budget.tick();
       if (checkpoint) await checkpoint;
       value = BigInt.asUintN(64, (value ^ BigInt(character.codePointAt(0))) * 1099511628211n);
@@ -51,14 +55,14 @@ async function* storedXmlToJson(document, budget) {
     if (entry.closing || entry.reference === document.root) continue;
     const current = await document.metadata(entry.reference);
     if (current.kind !== "element") continue;
-    const parent = await document.parent(entry.reference), key = await hash(parent, current.name);
+    const parent = await document.parent(entry.reference), key = await hash(parent, current);
     const bucket = Number(await hashes.get(key) ?? 0n);
     let group = bucket;
     while (group) {
       const value = await fields(group, 8);
       const checkpoint = budget.tick(current.name.length + 1);
       if (checkpoint) await checkpoint;
-      if (value[0] === parent && (await node(value[1])).name === current.name) break;
+      if (value[0] === parent && await document.nameEquals(await node(value[1]), current)) break;
       group = value[6];
     }
     const member = await record([entry.reference, 0]);
@@ -111,7 +115,7 @@ async function* storedXmlToJson(document, budget) {
   async function* output() {
     const root = await node(document.root);
     yield "{";
-    yield* quoted([root.name]);
+    yield* quoted(document.nameText(root));
     yield ":";
     await push({ kind: "literal", value: "}" });
     await push({ kind: "element", reference: document.root });
@@ -128,9 +132,12 @@ async function* storedXmlToJson(document, budget) {
         const value = await document.metadata(task.reference);
         if (value.kind !== "attribute") throw new TypeError("Expected XML attribute");
         const attribute = value.value;
-        yield* quoted(["@" + attribute.name]);
+        yield* quoted((async function* () {
+          yield "@";
+          yield* document.nameText(attribute);
+        })());
         yield ":";
-        yield* quoted([attribute.value]);
+        yield* quoted(document.text(task.reference));
         continue;
       }
       if (task.kind === "text") {
@@ -148,7 +155,7 @@ async function* storedXmlToJson(document, budget) {
       }
       if (task.kind === "group") {
         const group = await fields(task.reference, 8);
-        yield* quoted([(await node(group[1])).name]);
+        yield* quoted(document.nameText(await node(group[1])));
         yield ":";
         if (group[7] === 1) await push({ kind: "element", reference: group[1] });
         else {

package/dist/safe-bash-xml-engine/query.js

@@ -1,7 +1,7 @@
 import {
   parseQuery
-} from "../safe-bash/command-chunks/chunk-LNKZVU5V.js";
-import "../safe-bash/command-chunks/chunk-IJE65P52.js";
+} from "../safe-bash/command-chunks/chunk-E76WK7OQ.js";
+import "../safe-bash/command-chunks/chunk-JMUB5A26.js";
 import "../safe-bash/command-chunks/chunk-3I5WTVWZ.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {

package/dist/safe-bash-xml-engine/recovery.d.ts

@@ -1,14 +1,20 @@
-import { parseXmlSourceSteps, type XmlElement, type XmlAttribute } from "@poe-platform/safe-fs/core";
+import { parseXmlSourceSteps, type XmlElement, type XmlAttribute, type XmlSourceSpan } from "@poe-platform/safe-fs/core";
 import { type PagedStorageContext } from "@poe-platform/safe-fs/storage";
 import { XmlBudget } from "./limits.js";
 type XmlEvent = Parameters<NonNullable<NonNullable<Parameters<typeof parseXmlSourceSteps>[1]>["events"]>>[0] | {
     type: "attribute";
     attribute: XmlAttribute;
     element: XmlElement;
+    continuation?: boolean;
 };
 /** Parse lazy input, or prevalidated recovery input, through a shared 64 KiB source/frame cache.
  * The parser retains only its current source window, tokens and the current frame. */
 export declare function parseStoredXml(source: AsyncIterable<string> | Iterable<string>, context: PagedStorageContext & {
     readonly registerCleanup?: (cleanup: () => Promise<void>) => void;
-}, budget: XmlBudget, recover?: (message: string) => void, consume?: (event: XmlEvent) => Promise<void>): Promise<XmlElement>;
+}, budget: XmlBudget, recover?: (message: string) => void, consume?: (event: XmlEvent, namespaceParts: (reference: number) => AsyncIterable<string>, sourceParts: (span: XmlSourceSpan) => AsyncIterable<string>) => Promise<void>, options?: {
+    deferNamespaces?: boolean;
+    deferContentNames?: boolean;
+    deferElementNames?: boolean;
+    deferAttributeNames?: boolean;
+}): Promise<XmlElement>;
 export { parseStoredXml as parseXmlRecovery };