@poe-platform/safe-bash 0.1.813 → 0.1.815

package/dist/spreadsheet-format-xls/biff-property-values.js

@@ -0,0 +1,158 @@
+import { IntegerTable } from "@poe-platform/safe-fs/storage";
+import { SsconvertError } from "../spreadsheet-engine/contracts.js";
+import { Binary, invalidBiff } from './biff-binary.js';
+import { BiffPropertyRange } from './biff-property-range.js';
+/** Mutable insertion order with immutable payload snapshots. Deleted payloads remain
+ * readable until close, so values can be moved between independently edited sections. */
+export class BiffMutablePropertyValues {
+    context;
+    charge;
+    storage;
+    index;
+    fallback;
+    pending = Promise.resolve();
+    closing;
+    closed = false;
+    initialized = false;
+    first = 0;
+    last = 0;
+    count = 0;
+    root = { read: (at, count) => this.read(at, count), check: () => this.check() };
+    constructor(context, charge) {
+        this.context = context;
+        this.charge = charge;
+        this.storage = context.createWorkingStorage?.();
+        if (this.storage)
+            this.index = new IntegerTable({ allocate: length => this.allocate(length),
+                read: (at, length) => this.read(at, length), write: (at, bytes) => this.write(at, bytes) }, 64);
+        else
+            this.fallback = new Map();
+        context.own(() => this.close());
+    }
+    get size() { this.check(); return this.fallback?.size ?? this.count; }
+    check() {
+        this.context.signal.throwIfAborted();
+        if (this.closed)
+            throw new SsconvertError('invalid-request', 'BIFF mutable property values are closed');
+    }
+    allocate(length) { this.check(); return this.storage.allocate(length); }
+    io(action) {
+        const result = this.pending.then(async () => { this.check(); const value = await action(); this.check(); return value; });
+        this.pending = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    read(at, length) {
+        return this.io(async () => {
+            const bytes = await this.storage.read(at, length);
+            if (bytes.length !== length)
+                invalidBiff('truncated mutable property values');
+            return new Uint8Array(bytes);
+        });
+    }
+    async write(at, bytes) {
+        const owned = new Uint8Array(bytes);
+        try {
+            await this.io(() => this.storage.write(at, owned));
+        }
+        finally {
+            owned.fill(0);
+        }
+    }
+    async get(id) {
+        this.check();
+        if (this.fallback)
+            return this.fallback.get(id);
+        const position = await this.index.get(BigInt(id));
+        this.check();
+        if (!position)
+            return undefined;
+        const record = new Binary(await this.read(Number(position), 32));
+        return new BiffPropertyRange(this.root, record.f64(8), record.f64(16));
+    }
+    async set(id, value) {
+        this.check();
+        if (this.fallback) {
+            this.fallback.set(id, value);
+            return;
+        }
+        this.charge(value.size);
+        if (!this.initialized) {
+            this.allocate(8);
+            this.initialized = true;
+        }
+        const existing = await this.index.get(BigInt(id));
+        this.check();
+        const data = this.allocate(value.size);
+        for (let at = 0; at < value.size;) {
+            const bytes = await value.read(at, Math.min(16384, value.size - at));
+            try {
+                await this.write(data + at, bytes);
+                at += bytes.length;
+            }
+            finally {
+                bytes.fill(0);
+            }
+        }
+        const record = new Uint8Array(32), view = new DataView(record.buffer);
+        view.setFloat64(8, data, true);
+        view.setFloat64(16, value.size, true);
+        view.setUint32(24, id, true);
+        view.setUint32(28, 1, true);
+        if (existing) {
+            await this.write(Number(existing) + 8, record.subarray(8, 24));
+            return;
+        }
+        const position = this.allocate(32);
+        await this.write(position, record);
+        if (this.last) {
+            view.setFloat64(0, position, true);
+            await this.write(this.last, record.subarray(0, 8));
+        }
+        else
+            this.first = position;
+        this.last = position;
+        await this.index.set(BigInt(id), BigInt(position));
+        this.check();
+        this.count++;
+    }
+    async delete(id) {
+        this.check();
+        if (this.fallback)
+            return this.fallback.delete(id);
+        const position = await this.index.get(BigInt(id));
+        this.check();
+        if (!position)
+            return false;
+        await this.write(Number(position) + 28, new Uint8Array(4));
+        await this.index.set(BigInt(id), 0n);
+        this.check();
+        this.count--;
+        return true;
+    }
+    async *entries() {
+        this.check();
+        if (this.fallback) {
+            for (const entry of this.fallback) {
+                this.check();
+                yield entry;
+            }
+            return;
+        }
+        let position = this.first;
+        while (position) {
+            const record = new Binary(await this.read(position, 32));
+            position = record.f64(0);
+            if (record.u32(28))
+                yield [record.u32(24), new BiffPropertyRange(this.root, record.f64(8), record.f64(16))];
+        }
+        this.check();
+    }
+    close() {
+        if (!this.closing) {
+            this.closed = true;
+            this.fallback?.clear();
+            this.closing = this.pending.then(async () => { await this.storage?.close(); });
+        }
+        return this.closing;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-bash",
-  "version": "0.1.813",
+  "version": "0.1.815",
   "description": "Extensible virtual shell with pluggable filesystems and streaming commands",
   "type": "module",
   "license": "MIT",
@@ -1407,7 +1407,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@poe-platform/safe-fs": "0.1.813",
+    "@poe-platform/safe-fs": "0.1.815",
     "pdf-lib": "1.17.1",
     "@types/node": "^25.2.2",
     "@formatjs/intl-numberformat": "9.4.0",
@@ -1719,6 +1719,7 @@
     "./dist/safe-bash-command-html-to-markdown/options.js",
     "./dist/safe-bash-command-html-to-markdown/parser.js",
     "./dist/safe-bash-command-html-to-markdown/render.js",
+    "./dist/safe-bash-command-html-to-markdown/stored-text.js",
     "./dist/safe-bash-command-html-to-markdown/text.js",
     "./dist/safe-bash-command-htmlq/index.js",
     "./dist/safe-bash-command-iconv/codec.js",
@@ -2838,11 +2839,13 @@
     "./dist/spreadsheet-format-xls/biff-properties-write.js",
     "./dist/spreadsheet-format-xls/biff-properties.js",
     "./dist/spreadsheet-format-xls/biff-property-bytes.js",
+    "./dist/spreadsheet-format-xls/biff-property-dictionary.js",
     "./dist/spreadsheet-format-xls/biff-property-index.js",
     "./dist/spreadsheet-format-xls/biff-property-name.js",
     "./dist/spreadsheet-format-xls/biff-property-range.js",
     "./dist/spreadsheet-format-xls/biff-property-text.js",
     "./dist/spreadsheet-format-xls/biff-property-transcode.js",
+    "./dist/spreadsheet-format-xls/biff-property-values.js",
     "./dist/spreadsheet-format-xls/biff-range.js",
     "./dist/spreadsheet-format-xls/biff-record-storage.js",
     "./dist/spreadsheet-format-xls/biff-shared-strings.js",