@poe-platform/safe-bash 0.1.814 → 0.1.815

package/dist/spreadsheet-format-xls/biff-properties-merge.js

@@ -1,3 +1,4 @@
+import { BiffMutablePropertyValues } from './biff-property-values.js';
 import { createBiffPropertyNameEncoder } from "./biff-property-name.js";
 import { readBiffPropertyText } from "./biff-property-text.js";
 import { stageWideBiffProperty } from './biff-property-transcode.js';
@@ -5,7 +6,7 @@ import { stagePropertyBytes, propertyChunks } from './biff-property-bytes.js';
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { Binary, invalidBiff } from "./biff-binary.js";
 import { biffPropertyFields, biffPropertyFormats, readBiffProperties } from "./biff-properties.js";
-import { propertyRange, readPropertySectionRanges, readPropertyValueRanges } from "./biff-property-range.js";
+import { propertyRange, readPropertySectionRanges, withPropertyValueRanges } from "./biff-property-range.js";
 /** Rebuild offsets around original opaque spans. Never transcode their codepage. */
 export async function mergeBiffProperties(book, streams, handled, context, charge, allocate, staged) {
     const canonical = (name) => ["\u0005SummaryInformation", "\u0005DocumentSummaryInformation"].find(target => target.toUpperCase() === name.toUpperCase());
@@ -89,8 +90,16 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
             const file = propertyRange(input, context), sections = [];
             for await (const section of readPropertySectionRanges(file, admit, charge, context)) {
                 const bytes = file.slice(section.offset, section.end - section.offset);
-                sections.push({ ...section, bytes, ...(biffPropertyFields.has(section.guid) || section.guid === biffPropertyFormats.custom ?
-                        { values: await readPropertyValueRanges(bytes, admit, charge, context) } : {}) });
+                let values;
+                if (biffPropertyFields.has(section.guid) || section.guid === biffPropertyFormats.custom) {
+                    values = new BiffMutablePropertyValues(context, charge);
+                    temporarySources.push(values);
+                    await withPropertyValueRanges(bytes, admit, charge, context, async (source) => {
+                        for await (const [id, value] of source.entries())
+                            await values.set(id, value);
+                    });
+                }
+                sections.push({ ...section, bytes, ...(values ? { values } : {}) });
             }
             return sections;
         };
@@ -122,10 +131,10 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
             }
         };
         const dictionary = async function* (section, names = true) {
-            const data = section.values?.get(0);
+            const data = await section.values?.get(0);
             if (!data)
                 return;
-            const cp = await section.values?.get(1)?.u16(4) ?? 1252, count = await data.u32(0);
+            const cp = await (await section.values?.get(1))?.u16(4) ?? 1252, count = await data.u32(0);
             data.check(4, count * 9);
             if (names) {
                 charge(data.size);
@@ -171,7 +180,7 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                 staged.reserve(plan.length);
                 const source = await stagePropertyBytes(output, context);
                 temporarySources.push(source);
-                section.values.set(0, propertyRange(source, context));
+                await section.values.set(0, propertyRange(source, context));
             }
             else {
                 const bytes = allocate(plan.length);
@@ -180,11 +189,11 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                     bytes.set(part, at);
                     at += part.length;
                 }
-                section.values.set(0, propertyRange(bytes, context));
+                await section.values.set(0, propertyRange(bytes, context));
             }
         };
         const remove = async (section, id) => {
-            section.values.delete(id);
+            await section.values.delete(id);
             if (section.guid === biffPropertyFormats.custom) {
                 let length = 4, count = 0;
                 for await (const entry of dictionary(section))
@@ -198,13 +207,13 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
         const take = async (property) => {
             charge(fresh.get(property.stream).length);
             const section = fresh.get(property.stream).find(section => section.offset === property.section);
-            const value = section.values.get(property.id);
+            const value = (await section.values.get(property.id));
             await remove(section, property.id);
             pending.delete(property.key);
             return value;
         };
         const wide = async (source, section) => {
-            if (await source.u32(0) !== 30 || (await section.values.get(1)?.u16(4) ?? 1252) === 65001)
+            if (await source.u32(0) !== 30 || (await (await section.values.get(1))?.u16(4) ?? 1252) === 65001)
                 return source;
             if (staged) {
                 const output = await stageWideBiffProperty(source, context, charge, staged.reserve);
@@ -265,7 +274,7 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                         await take(replacement);
                 }
                 else if (replacement)
-                    section.values.set(id, await wide(await take(replacement), section));
+                    await section.values.set(id, await wide(await take(replacement), section));
             }
         }
         const encodeName = createBiffPropertyNameEncoder(context, charge, accountText);
@@ -301,13 +310,13 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                     await warn(property.key, "opaque name collision");
                     continue;
                 }
-                const cp = await values.get(1)?.u16(4) ?? 1252, text = encodeName(property.key, cp);
+                const cp = await (await values.get(1))?.u16(4) ?? 1252, text = encodeName(property.key, cp);
                 if (!text) {
                     await warn(property.key, "name cannot be encoded in the original codepage");
                     continue;
                 }
                 id = maximumId;
-                for (const key of values.keys())
+                for await (const [key] of values.entries())
                     id = Math.max(id, key);
                 id++;
                 if (id > 0xffffffff) {
@@ -342,11 +351,11 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                 }
                 await writeDictionary(target, { length: dictionaryLength + bytes.size, count: count + 1, append: bytes });
             }
-            else if (values.has(id)) {
+            else if (await values.get(id)) {
                 await warn(property.key, "opaque property ID collision");
                 continue;
             }
-            values.set(id, await wide(value, target));
+            await values.set(id, await wide(value, target));
         }
         const reserve = staged?.reserve ?? ((length) => {
             charge(length);
@@ -354,12 +363,12 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                 throw new SsconvertError("resource-limit", "ssconvert BIFF property output bytes limit exceeded");
             return length;
         });
-        const encodeSection = (section) => {
+        const encodeSection = async (section) => {
             if (!section.values)
                 return { length: section.bytes.size, chunks: () => chunks(section.bytes) };
             const values = section.values;
             let length = 8 + values.size * 8;
-            for (const value of values.values())
+            for await (const [, value] of values.entries())
                 length += Math.ceil(value.size / 4) * 4;
             // Buffered output charges the section size here, as the old allocation did.
             reserve(length);
@@ -369,7 +378,7 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                     view.setUint32(4, values.size, true);
                     yield header;
                     let at = 8 + values.size * 8;
-                    for (const [id, value] of values) {
+                    for await (const [id, value] of values.entries()) {
                         charge(value.size);
                         const entry = new Uint8Array(8), view = new DataView(entry.buffer);
                         view.setUint32(0, id, true);
@@ -377,7 +386,7 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                         yield entry;
                         at += Math.ceil(value.size / 4) * 4;
                     }
-                    for (const value of values.values()) {
+                    for await (const [, value] of values.entries()) {
                         yield* chunks(value);
                         const padding = (4 - value.size % 4) % 4;
                         if (padding)
@@ -388,7 +397,14 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
         for (const name of new Set([...streams.keys(), ...snapshots.keys()])) {
             for (const section of fresh.get(name) ?? [])
                 charge(1 + section.values.size);
-            const remaining = fresh.get(name)?.filter(section => [...section.values.keys()].some(id => id >= 2)) ?? [];
+            const remaining = [];
+            for (const section of fresh.get(name) ?? []) {
+                for await (const [id] of section.values.entries())
+                    if (id >= 2) {
+                        remaining.push(section);
+                        break;
+                    }
+            }
             if (!old.has(name) && remaining.some(section => section.guid === biffPropertyFormats.custom) &&
                 !remaining.some(section => section.guid === biffPropertyFormats.document)) {
                 const builtin = fresh.get(name)?.find(section => section.guid === biffPropertyFormats.document);
@@ -400,7 +416,10 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                 streams.delete(name);
                 continue;
             }
-            const bodies = sections.map(encodeSection), length = 28 + sections.length * 20 + bodies.reduce((sum, body) => sum + body.length, 0);
+            const bodies = [];
+            for (const section of sections)
+                bodies.push(await encodeSection(section));
+            const length = 28 + sections.length * 20 + bodies.reduce((sum, body) => sum + body.length, 0);
             const originalHeader = await (snapshots.get(name)?.bytes ?? propertyRange(streams.get(name), context)).read(0, 28);
             const output = { length, async *chunks() {
                     const header = new Uint8Array(originalHeader);

package/dist/spreadsheet-format-xls/biff-property-values.d.ts

@@ -0,0 +1,31 @@
+import { type CapabilityContext } from "../spreadsheet-engine/contracts.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 declare class BiffMutablePropertyValues {
+    private readonly context;
+    private readonly charge;
+    private readonly storage;
+    private readonly index;
+    private readonly fallback;
+    private pending;
+    private closing;
+    private closed;
+    private initialized;
+    private first;
+    private last;
+    private count;
+    private readonly root;
+    constructor(context: CapabilityContext, charge: (amount: number) => void);
+    get size(): number;
+    private check;
+    private allocate;
+    private io;
+    private read;
+    private write;
+    get(id: number): Promise<BiffPropertyRange | undefined>;
+    set(id: number, value: BiffPropertyRange): Promise<void>;
+    delete(id: number): Promise<boolean>;
+    entries(): AsyncGenerator<readonly [number, BiffPropertyRange]>;
+    close(): Promise<void>;
+}

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.814",
+  "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.814",
+    "@poe-platform/safe-fs": "0.1.815",
     "pdf-lib": "1.17.1",
     "@types/node": "^25.2.2",
     "@formatjs/intl-numberformat": "9.4.0",
@@ -2845,6 +2845,7 @@
     "./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",