@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash-sqlite-engine/sqlite-edit-snapshot.d.ts

@@ -0,0 +1,15 @@
+import type { SqliteFileSystem } from './safe-fs.js';
+import { type SqliteRecordSource } from './sqlite-pages.js';
+export interface SqliteEditSnapshot {
+    findRecord(rootPage: number, rowid: bigint, match?: 'exact' | 'at-or-after'): Promise<(SqliteRecordSource & {
+        readonly rowid: bigint;
+    }) | undefined>;
+}
+/** Keep a bounded-I/O immutable copy while a private destination is edited.
+ * Every field stream is scoped to the callback; admitted reads drain on exit. */
+export declare function withSqliteEditSnapshot<T>(options: {
+    fs: SqliteFileSystem;
+    directory: string;
+    path: string;
+    signal: AbortSignal;
+}, operation: (snapshot: SqliteEditSnapshot) => Promise<T>): Promise<T>;

package/dist/safe-bash-sqlite-engine/sqlite-finalization.d.ts

@@ -1,6 +1,8 @@
 import { type PrivateSqliteSession } from './sqlite-session.js';
+import { type SqliteRecordRewrite } from './sqlite-record-write.js';
 import type { SqliteFileSystem } from './safe-fs.js';
 import type { sqliteRecord } from './sqlite-record.js';
+import { type SqliteEditSnapshot } from './sqlite-edit-snapshot.js';
 export interface SqliteFinalizer {
     /** Equal-sized private placeholder rewrite; caller owns index/trigger semantics. */
     rewriteRecord(options: {
@@ -8,8 +10,13 @@ export interface SqliteFinalizer {
         rowid: bigint;
         record: ReturnType<typeof sqliteRecord>;
     }): Promise<void>;
+    /** Rewrite a streamed batch using one immutable destination snapshot. */
+    rewriteRecords(records: AsyncIterable<SqliteRecordRewrite>): Promise<void>;
     /** Reopen a native connection only after all earlier rewrites have completed. */
     withSession<T>(operation: (session: PrivateSqliteSession) => Promise<T>): Promise<T>;
+    /** Read an immutable source while a nested editor changes the private target.
+     * Source records/streams expire when this callback closes. */
+    withSnapshot(operation: (source: SqliteEditSnapshot, editor: SqliteFinalizer) => Promise<void>): Promise<void>;
 }
 /** Serialize closed-file edits and native validation. Even a caught or unawaited
  * failed phase poisons publication; no phase can outlive the private owner. */

package/dist/safe-bash-sqlite-engine/sqlite-pages.d.ts

@@ -0,0 +1,18 @@
+import { type ByteSource, type FileReadHandle } from "../safe-bash-contracts/index.js";
+export interface SqliteRecordSource {
+    readonly size: number;
+    /** Retained snapshot range; omitted bounds read the complete record. */
+    bytes(offset?: number, length?: number): ByteSource;
+}
+export interface SqliteStoredRecord extends SqliteRecordSource {
+    readonly rowid: bigint;
+    /** Physical snapshot ranges; retained identity and revision remain checked. */
+    spans(offset?: number, length?: number): AsyncIterable<{
+        readonly offset: number;
+        readonly length: number;
+    }>;
+}
+/** Read a table-btree row from a retained, closed/checkpointed SQLite snapshot.
+ * The caller owns the handle; no ambient filesystem, full-file read or page cache.
+ * Returned streams remain tied to the original snapshot revision and signal. */
+export declare function findSqliteRecord(file: FileReadHandle, rootPage: number, rowid: bigint, signal: AbortSignal, match?: "exact" | "at-or-after"): Promise<SqliteStoredRecord | undefined>;

package/dist/safe-bash-sqlite-engine/sqlite-record-read.d.ts

@@ -0,0 +1,8 @@
+import type { SqliteRecordSource } from './sqlite-pages.js';
+import type { SqliteRecordValue } from './sqlite-record.js';
+/** Decode only bounded record headers and scalar fields. Variable-length fields
+ * remain streams tied to the owning snapshot, including empty TEXT/BLOB values. */
+export declare function readSqliteRecord(record: SqliteRecordSource, options: {
+    signal: AbortSignal;
+    maxColumns: number;
+}): Promise<SqliteRecordValue[]>;

package/dist/safe-bash-sqlite-engine/sqlite-record-write.d.ts

@@ -0,0 +1,20 @@
+import type { SqliteFileSystem } from './safe-fs.js';
+import { sqliteRecord } from './sqlite-record.js';
+export interface SqliteRecordRewrite {
+    rootPage: number;
+    rowid: bigint;
+    record: ReturnType<typeof sqliteRecord>;
+}
+/** Replace equal-sized placeholder records in a CLOSED, exclusively owned
+ * private database. The immutable working copy keeps page-chain validation
+ * meaningful while destination writes advance its revision. Native indexes,
+ * constraints and triggers must be handled by the owning storage operation;
+ * this primitive is not a general SQL UPDATE. Failure invalidates the private
+ * transaction and must never be followed by canonical publication. */
+export declare function rewriteSqliteRecords(options: {
+    fs: SqliteFileSystem;
+    directory: string;
+    path: string;
+    records: AsyncIterable<SqliteRecordRewrite>;
+    signal: AbortSignal;
+}): Promise<void>;

package/dist/safe-bash-sqlite-engine/storage.d.ts

@@ -4,4 +4,6 @@ export { withSqliteStatement, type SqliteStatement, type SqliteBinding, type Sql
 export { readSqliteBlob } from './sqlite-blob-read.js';
 export { writeSqliteBlob } from './sqlite-blob.js';
 export { sqliteRecord, type SqliteRecordValue } from './sqlite-record.js';
+export { readSqliteRecord } from './sqlite-record-read.js';
+export type { SqliteEditSnapshot } from './sqlite-edit-snapshot.js';
 export type { SqliteFinalizer } from './sqlite-finalization.js';

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 FsError12, toByteSource } from "../safe-bash-contracts/index.js";
+import { FsError as FsError13, 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";
@@ -524,7 +524,7 @@ async function createSqliteWalSnapshot(database, wal, index, options) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-finalization.ts
-import { FsError as FsError10 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError11 } 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";
@@ -740,12 +740,15 @@ async function* sqliteSourceChunks(source, signal) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-record-write.ts
-async function rewriteSqliteRecord(options) {
-  const { fs, directory, path, rootPage, rowid, record, signal } = options;
+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 });
   const temporary = directory + "/record-source-" + crypto.randomUUID();
   const errors = [];
+  const remember = (error) => {
+    if (!errors.includes(error)) errors.push(error);
+  };
   let file;
   let copy;
   let created = false;
@@ -773,48 +776,153 @@ async function rewriteSqliteRecord(options) {
       return bytes.slice(0, length);
     }, async close() {
     } };
-    const stored = await findSqliteRecord(snapshot, rootPage, rowid, signal);
-    if (!stored) throw new FsError9("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;
-    try {
-      for await (const bytes of sqliteSourceChunks(record.bytes(signal), signal)) {
-        let position = 0;
-        while (position < bytes.length) {
-          if (span.done) throw new RangeError("SQLite record exceeds placeholder");
-          const count = Math.min(bytes.length - position, span.value.length - offset, 16384);
-          await writeSqliteFile(file, bytes.subarray(position, position + count), span.value.offset + offset, signal);
-          received += count;
-          position += count;
-          offset += count;
-          if (offset === span.value.length) {
-            span = await spans.next();
-            offset = 0;
+    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.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;
+      try {
+        for await (const bytes of sqliteSourceChunks(record.bytes(signal), signal)) {
+          let position = 0;
+          while (position < bytes.length) {
+            if (span.done) throw new RangeError("SQLite record exceeds placeholder");
+            const count = Math.min(bytes.length - position, span.value.length - offset, 16384);
+            await writeSqliteFile(file, bytes.subarray(position, position + count), span.value.offset + offset, signal);
+            received += count;
+            position += count;
+            offset += count;
+            if (offset === span.value.length) {
+              span = await spans.next();
+              offset = 0;
+            }
           }
         }
+        if (received !== record.size || !span.done) throw new RangeError("SQLite record length mismatch");
+      } finally {
+        await spans.return?.();
       }
-      if (received !== record.size || !span.done) throw new RangeError("SQLite record length mismatch");
-    } finally {
-      await spans.return?.();
     }
   } catch (error) {
-    errors.push(error);
+    remember(error);
   }
   for (const descriptor of [copy, file]) if (descriptor) try {
     await descriptor.close();
   } catch (error) {
-    errors.push(error);
+    remember(error);
   }
   if (created) try {
     await fs.unlink(temporary);
   } catch (error) {
-    errors.push(error);
+    remember(error);
   }
   if (errors.length === 1) throw errors[0];
   if (errors.length) throw new AggregateError(errors, "SQLite record rewrite and cleanup failed");
 }
 
+// packages/safe-bash-sqlite-engine/src/sqlite-edit-snapshot.ts
+import { FsError as FsError10 } 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 });
+  const temporary = directory + "/edit-source-" + crypto.randomUUID();
+  let source, copy, created = false, active = true, pending, value;
+  const errors = [];
+  const remember = (error) => {
+    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 (pending) {
+      const error = new FsError10("EBUSY", { message: "SQLite snapshot reads must be serialized" });
+      remember(error);
+      return Promise.reject(error);
+    }
+    if (errors.length) return Promise.reject(errors[0]);
+    const task = Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return action();
+    });
+    pending = task;
+    void task.then(() => {
+      pending = void 0;
+    }, (error) => {
+      pending = void 0;
+      remember(error);
+    });
+    return task;
+  };
+  try {
+    signal.throwIfAborted();
+    source = await fs.open(path, { access: "read", creation: "never", signal });
+    const expected = await source.stat({ signal });
+    verifySqliteSnapshot(expected, expected);
+    copy = await fs.open(temporary, { access: "readwrite", creation: "exclusive", signal });
+    created = true;
+    for (let position = 0; position < expected.size; ) {
+      signal.throwIfAborted();
+      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 });
+      await writeSqliteFile(copy, bytes.subarray(0, count), position, signal);
+      position += count;
+    }
+    verifySqliteSnapshot(await source.stat({ signal }), expected);
+    await source.close();
+    source = void 0;
+    const file = copy;
+    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 });
+      return bytes.slice(0, length);
+    }, async close() {
+    } };
+    value = await operation({ findRecord(rootPage, rowid, match = "exact") {
+      return run(async () => {
+        const record = await findSqliteRecord(snapshot, rootPage, rowid, signal, match);
+        if (!record) return void 0;
+        return { size: record.size, rowid: record.rowid, bytes(offset = 0, length = record.size - offset) {
+          const iterator = record.bytes(offset, length)[Symbol.asyncIterator]();
+          return { [Symbol.asyncIterator]() {
+            return {
+              next() {
+                return run(() => iterator.next());
+              },
+              return() {
+                return run(async () => iterator.return ? iterator.return() : { done: true, value: void 0 });
+              }
+            };
+          } };
+        } };
+      });
+    } });
+  } catch (error) {
+    remember(error);
+  }
+  active = false;
+  if (pending) try {
+    await pending;
+  } catch (error) {
+    remember(error);
+  }
+  for (const file of [source, copy]) if (file) try {
+    await file.close();
+  } catch (error) {
+    remember(error);
+  }
+  if (created) try {
+    await fs.unlink(temporary, { signal: new AbortController().signal });
+  } catch (error) {
+    remember(error);
+  }
+  if (errors.length === 1) throw errors[0];
+  if (errors.length) throw new AggregateError(errors, "SQLite edit snapshot and cleanup failed");
+  return value;
+}
+
 // packages/safe-bash-sqlite-engine/src/sqlite-finalization.ts
 async function finalizeSqlite(options, operation) {
   let accepting = true, busy;
@@ -823,9 +931,9 @@ async function finalizeSqlite(options, operation) {
     if (!errors.includes(error)) errors.push(error);
   };
   const run = (action) => {
-    if (!accepting) return Promise.reject(new FsError10("EBADF", { message: "SQLite finalization is closed" }));
+    if (!accepting) return Promise.reject(new FsError11("EBADF", { message: "SQLite finalization is closed" }));
     if (busy) {
-      const error = new FsError10("EBUSY", { message: "SQLite finalization phases overlap" });
+      const error = new FsError11("EBUSY", { message: "SQLite finalization phases overlap" });
       remember(error);
       return Promise.reject(error);
     }
@@ -847,10 +955,18 @@ async function finalizeSqlite(options, operation) {
     await operation({
       rewriteRecord(record) {
         const owned = { rootPage: record.rootPage, rowid: record.rowid, record: { ...record.record } };
-        return run(() => rewriteSqliteRecord({ ...options, ...owned }));
+        return run(() => rewriteSqliteRecords({ ...options, records: { async *[Symbol.asyncIterator]() {
+          yield owned;
+        } } }));
+      },
+      rewriteRecords(records) {
+        return run(() => rewriteSqliteRecords({ ...options, records }));
       },
       withSession(callback) {
         return run(() => withPrivateSqliteSession(options, callback));
+      },
+      withSnapshot(callback) {
+        return run(() => withSqliteEditSnapshot(options, (source) => finalizeSqlite(options, (editor) => callback(source, editor))));
       }
     });
   } catch (error) {
@@ -872,7 +988,7 @@ async function finalizeSqlite(options, operation) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-publication.ts
-import { FsError as FsError11 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError12 } 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;
@@ -888,7 +1004,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 FsError11("ENOTSUP", { path, message: "SQLite snapshots require atomic conditional publication" });
+    throw new FsError12("ENOTSUP", { path, message: "SQLite snapshots require atomic conditional publication" });
   }
   const original = await snapshot.stat({ signal });
   verifySqliteSnapshot(original, original);
@@ -912,7 +1028,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 FsError11("EIO", { message: "Invalid SQLite snapshot read" });
+        throw new FsError12("EIO", { message: "Invalid SQLite snapshot read" });
       }
       const owned = bytes2.slice();
       await check();
@@ -944,12 +1060,12 @@ async function publishSqliteSnapshot(options) {
   }
   if (staging && companions) {
     if (staging.file.stat.size !== 0 || staging.file.stat.type !== "file") {
-      throw new FsError11("EINVAL", { path: staging.file.path, message: "SQLite publication requires empty regular-file staging" });
+      throw new FsError12("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 FsError11("EIO", { path: staging.file.path, message: "SQLite staged snapshot size mismatch" });
+      throw new FsError12("EIO", { path: staging.file.path, message: "SQLite staged snapshot size mismatch" });
     }
     await check();
     return fs.publishStagedFileSet({ ...staging, file: { ...staging.file, stat } }, path, {
@@ -978,18 +1094,18 @@ 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 FsError12("ENOTSUP", { path, message: "SQLite transactions require retained source-set publication" });
+    if (!fs.createStagedFile || !fs.publishStagedFileSet) throw new FsError13("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 FsError12("EFBIG", { path: target });
+      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 FsError12("EIO", { path: target });
+          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;
         }
@@ -1005,7 +1121,7 @@ async function transactSqlite(options, operation) {
       const overlay = snapshot;
       cleanups.push(() => overlay.close());
     }
-    if (!snapshot && (sources.wal?.stat.size || sources.journal?.stat.size)) throw new FsError12("EIO", { path, message: "SQLite sidecar has no database" });
+    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);
@@ -1025,7 +1141,7 @@ async function transactSqlite(options, operation) {
       }
     }
     if (sources.journal?.stat.size) {
-      if (walMode) throw new FsError12("EIO", { path, message: "SQLite WAL database has a rollback journal" });
+      if (walMode) throw new FsError13("EIO", { path, message: "SQLite WAL database has a rollback journal" });
       await copy(sources.journal.file, `${privatePath}-journal`);
     }
     value = await withPrivateSqliteSession({ ...options, fs: storage.fs, directory: storage.directory, path: privatePath }, async (session) => {
@@ -1059,7 +1175,7 @@ async function transactSqlite(options, operation) {
       cleanups.push(() => staging.cleanup.close());
       cleanups.push(() => staging.cleanup.remove());
     } else {
-      throw new FsError12("EIO", { path, message: "SQLite publication staging omitted retained cleanup" });
+      throw new FsError13("EIO", { path, message: "SQLite publication staging omitted retained cleanup" });
     }
     committed = await publishSqliteSnapshot({
       fs,
@@ -1089,7 +1205,7 @@ async function transactSqlite(options, operation) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-statement.ts
-import { FsError as FsError13 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError14 } 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;
@@ -1116,7 +1232,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 FsError13("EIO", { message: `Native SQLite statement failed (${code})` });
+    if (code !== 0) throw new FsError14("EIO", { message: `Native SQLite statement failed (${code})` });
   };
   let out = 0, statement = 0, accepting = true, current, value;
   const errors = [];
@@ -1133,8 +1249,8 @@ async function withSqliteStatement(module, options, operation) {
   };
   const rows = (bindings, columns) => {
     async function* iterate() {
-      if (!accepting) throw new FsError13("EBADF", { message: "SQLite statement is closed" });
-      if (current) throw new FsError13("EBUSY", { message: "SQLite cursor is already active" });
+      if (!accepting) throw new FsError14("EBADF", { message: "SQLite statement is closed" });
+      if (current) throw new FsError14("EBUSY", { message: "SQLite cursor is already active" });
       current = iterator;
       let failed = false, failure;
       try {
@@ -1224,7 +1340,7 @@ async function withSqliteStatement(module, options, operation) {
     statement = new DataView(module.HEAPU8.buffer).getInt32(out, true);
     result(code);
     signal.throwIfAborted();
-    if (!statement) throw new FsError13("EIO", { message: "SQLite returned an empty statement" });
+    if (!statement) throw new FsError14("EIO", { message: "SQLite returned an empty statement" });
     value = await operation({ rows });
   } catch (error) {
     errors.push(error);
@@ -1259,7 +1375,7 @@ async function withSqliteStatement(module, options, operation) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-blob-read.ts
-import { FsError as FsError14 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError15 } 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;
@@ -1274,7 +1390,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 FsError14("EIO", { message: `Native SQLite blob read failed (${code})` });
+    if (code !== 0) throw new FsError15("EIO", { message: `Native SQLite blob read failed (${code})` });
   };
   let out = 0, blob = 0, buffer = 0;
   let failed = false, failure;
@@ -1288,7 +1404,7 @@ async function* readSqliteBlob(module, options) {
     if (blob) try {
       const code = await close(blob);
       if (!failed) check();
-      if (code !== 0) errors.push(new FsError14("EIO", { message: `Native SQLite blob close failed (${code})` }));
+      if (code !== 0) errors.push(new FsError15("EIO", { message: `Native SQLite blob close failed (${code})` }));
     } catch (error) {
       errors.push(error);
     }
@@ -1310,8 +1426,8 @@ async function* readSqliteBlob(module, options) {
     result(code);
     signal.throwIfAborted();
     const size = length(blob);
-    if (!blob || !Number.isSafeInteger(size) || size < 0) throw new FsError14("EIO", { message: "Invalid SQLite blob size" });
-    if (size > maxBytes) throw new FsError14("EFBIG", { message: "LLM schema input byte limit exceeded" });
+    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 (size) {
       buffer = module._malloc(Math.min(16384, size));
       if (!buffer) throw new RangeError("SQLite memory allocation failed");
@@ -1334,7 +1450,7 @@ async function* readSqliteBlob(module, options) {
 }
 
 // packages/safe-bash-sqlite-engine/src/sqlite-blob.ts
-import { FsError as FsError15 } from "../safe-bash-contracts/index.js";
+import { FsError as FsError16 } 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;
@@ -1348,7 +1464,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 FsError15("EIO", { message: `Native SQLite blob operation failed (${code})` });
+    if (code !== 0) throw new FsError16("EIO", { message: `Native SQLite blob operation failed (${code})` });
   };
   let out = 0, buffer = 0, blob = 0;
   const errors = [];
@@ -1394,7 +1510,7 @@ async function writeSqliteBlob(module, options) {
   if (blob) try {
     const code = await close(blob);
     if (!errors.length) 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);
   }
@@ -1470,8 +1586,73 @@ function sqliteRecord(values) {
     signal.throwIfAborted();
   } };
 }
+
+// packages/safe-bash-sqlite-engine/src/sqlite-record-read.ts
+import { FsError as FsError17 } 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" });
+  };
+  if (!Number.isSafeInteger(record.size) || record.size < 1) corrupt2();
+  const read = async (offset2, length) => {
+    signal.throwIfAborted();
+    if (offset2 < 0 || length < 0 || offset2 + length > record.size) corrupt2();
+    const bytes = new Uint8Array(length);
+    let position2 = 0;
+    for await (const chunk of sqliteSourceChunks(record.bytes(offset2, length), signal)) {
+      signal.throwIfAborted();
+      if (!(chunk instanceof Uint8Array) || chunk.length > length - position2) corrupt2();
+      bytes.set(chunk, position2);
+      position2 += chunk.length;
+    }
+    if (position2 !== length) corrupt2();
+    return bytes;
+  };
+  const start = readSqliteVarint(await read(0, Math.min(9, record.size)), 0);
+  const headerSize = Number(start.value);
+  if (!Number.isSafeInteger(headerSize) || headerSize < start.end || headerSize > record.size || headerSize > 9 * (maxColumns + 1)) corrupt2();
+  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" });
+    const serial = readSqliteVarint(header, position);
+    position = serial.end;
+    const type = serial.value;
+    if (type === 10n || type === 11n) corrupt2();
+    if (type === 0n) {
+      values.push(null);
+      continue;
+    }
+    if (type === 8n || type === 9n) {
+      values.push(type - 8n);
+      continue;
+    }
+    const size = type >= 12n ? Number((type - 12n) / 2n) : [0, 1, 2, 3, 4, 6, 8, 8][Number(type)];
+    if (!Number.isSafeInteger(size) || size < 0 || size > record.size - offset) corrupt2();
+    if (type >= 12n) {
+      const fieldOffset = offset;
+      values.push({ type: type % 2n ? "text" : "blob", size, bytes: { [Symbol.asyncIterator]() {
+        return record.bytes(fieldOffset, size)[Symbol.asyncIterator]();
+      } } });
+    } else {
+      const bytes = await read(offset, size);
+      if (type === 7n) values.push(new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0));
+      else {
+        let integer = 0n;
+        for (const byte of bytes) integer = integer << 8n | BigInt(byte);
+        values.push(BigInt.asIntN(size * 8, integer));
+      }
+    }
+    offset += size;
+  }
+  if (position !== headerSize || offset !== record.size) corrupt2();
+  return values;
+}
 export {
   readSqliteBlob,
+  readSqliteRecord,
   sqliteRecord,
   transactSqlite,
   withPrivateSqliteSession,

package/dist/safe-bash-svg-engine/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/safe-bash-svg-engine/index.d.ts

@@ -0,0 +1,8 @@
+export interface SvgRenderOptions {
+    readonly signal?: AbortSignal;
+    readonly maxNodes?: number;
+    readonly maxPixels?: number;
+    readonly dpi?: number;
+}
+/** Converts vector primitives without host fonts, network, or rasterizing PDF output. */
+export declare function renderSvgDocument(source: string, format: "pdf" | "png", options?: SvgRenderOptions): Promise<Uint8Array>;