@poe-platform/safe-bash 0.1.812 → 0.1.814

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

@@ -0,0 +1,114 @@
+import { SsconvertError } from "../spreadsheet-engine/contracts.js";
+import { singleByteTables } from "../spreadsheet-engine/encoding/tables.js";
+import { biffDbcsTables } from "../spreadsheet-engine/encoding/biff-dbcs-tables.js";
+import { biffDecode } from './biff-strings.js';
+/** Validate representability before exposing bounded encoded windows. */
+export function createBiffPropertyNameEncoder(context, charge, accountText) {
+    // Reverse the same tables as the importer; no transliteration or escape fallback.
+    const encodings = new Map();
+    return (name, cp) => {
+        accountText(name);
+        if (cp === 65001) {
+            let length = 1;
+            for (const point of name) {
+                const code = point.codePointAt(0);
+                length += code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+            }
+            return { length, *chunks() {
+                    const encoder = new TextEncoder(), buffer = new Uint8Array(16384);
+                    try {
+                        for (let at = 0; at < name.length;) {
+                            context.signal.throwIfAborted();
+                            let end = Math.min(name.length, at + 4096);
+                            if (end < name.length && name.charCodeAt(end - 1) >= 0xd800 && name.charCodeAt(end - 1) <= 0xdbff)
+                                end--;
+                            const result = encoder.encodeInto(name.slice(at, end), buffer);
+                            at = end;
+                            yield buffer.subarray(0, result.written);
+                        }
+                        yield new Uint8Array(1);
+                    }
+                    finally {
+                        buffer.fill(0);
+                    }
+                } };
+        }
+        if (cp === 1200) {
+            const length = (name.length + 1) * 2;
+            charge(length);
+            if (length > 0xffffffff || length > context.limits.outputBytes)
+                throw new SsconvertError("resource-limit", "ssconvert BIFF property output bytes limit exceeded");
+            return { length, *chunks() {
+                    const buffer = new Uint8Array(16384), view = new DataView(buffer.buffer);
+                    try {
+                        for (let at = 0; at < name.length; at += 8192) {
+                            context.signal.throwIfAborted();
+                            const size = Math.min(8192, name.length - at);
+                            for (let i = 0; i < size; i++)
+                                view.setUint16(i * 2, name.charCodeAt(at + i), true);
+                            yield buffer.subarray(0, size * 2);
+                        }
+                        yield new Uint8Array(2);
+                    }
+                    finally {
+                        buffer.fill(0);
+                    }
+                } };
+        }
+        let reverse = encodings.get(cp);
+        if (!reverse) {
+            reverse = new Map();
+            encodings.set(cp, reverse);
+            const dbcs = biffDbcsTables[cp], table = dbcs?.single ?? singleByteTables[cp === 1201 ? "iso-8859-1" : cp === 10000 ? "macintosh" : cp >= 1250 && cp <= 1258 ? `windows-${cp}` : `cp${cp}`];
+            if (!table)
+                return undefined;
+            for (let i = 0; i < table.length; i++) {
+                charge(1);
+                if (table[i] !== "\uffff" && !reverse.has(table[i]))
+                    reverse.set(table[i], [i]);
+            }
+            if (dbcs)
+                for (const [lead, row] of Object.entries(dbcs.double))
+                    for (let trail = 0; trail < row.length; trail++) {
+                        charge(1);
+                        if (row[trail] !== "\uffff" && !reverse.has(row[trail]))
+                            reverse.set(row[trail], [Number(lead), trail]);
+                    }
+        }
+        const characters = function* () { yield* name; yield "\0"; };
+        let length = 0;
+        for (const character of characters()) {
+            charge(1);
+            const value = reverse.get(character);
+            if (!value)
+                return undefined;
+            if (biffDecode(Uint8Array.from(value), cp) !== character)
+                return undefined;
+            length += value.length;
+            if (length > context.limits.outputBytes)
+                throw new SsconvertError("resource-limit", "ssconvert BIFF property output bytes limit exceeded");
+        }
+        const table = reverse;
+        return { length, *chunks() {
+                const buffer = new Uint8Array(16384);
+                let at = 0;
+                try {
+                    for (const character of characters()) {
+                        const value = table.get(character);
+                        if (at + value.length > buffer.length) {
+                            context.signal.throwIfAborted();
+                            yield buffer.subarray(0, at);
+                            at = 0;
+                        }
+                        buffer.set(value, at);
+                        at += value.length;
+                    }
+                    if (at)
+                        yield buffer.subarray(0, at);
+                }
+                finally {
+                    buffer.fill(0);
+                }
+            } };
+    };
+}

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

@@ -1,4 +1,4 @@
-import { type CapabilityContext, type RangeSource } from "../spreadsheet-engine/contracts.js";
+import { type CapabilityContext, type RangeSource, type WorkingStorage } from "../spreadsheet-engine/contracts.js";
 import type { BiffPropertySection } from './biff-properties-layout.js';
 interface Root {
     read: RangeSource['read'];
@@ -20,6 +20,20 @@ export declare class BiffPropertyRange implements RangeSource {
     f64(at: number): Promise<number>;
 }
 export declare function propertyRange(input: Uint8Array | RangeSource, context: CapabilityContext): BiffPropertyRange;
-export declare function readPropertySectionRanges(file: BiffPropertyRange, admit: (count: number) => void, accountWork: (amount: number) => void): Promise<BiffPropertySection[]>;
-export declare function readPropertyValueRanges(section: BiffPropertyRange, admit: (count: number) => void, accountWork: (amount: number) => void): Promise<Map<number, BiffPropertyRange>>;
+/** Index IO checks disposal around awaits and owns transient write buffers. */
+export declare function propertyIndexStorage(storage: WorkingStorage, range: BiffPropertyRange): {
+    allocate(length: number): number;
+    read(at: number, length: number): Promise<Uint8Array<ArrayBufferLike>>;
+    write(at: number, bytes: Uint8Array): Promise<void>;
+};
+/** Validate all section intervals before replaying any descriptor. */
+export declare function readPropertySectionRanges(file: BiffPropertyRange, admit: (count: number) => void, accountWork: (amount: number) => void, context: CapabilityContext): AsyncGenerator<BiffPropertySection>;
+export interface BiffPropertyValues {
+    get(id: number): Promise<BiffPropertyRange | undefined>;
+    entries(): AsyncIterable<readonly [number, BiffPropertyRange]>;
+}
+/** The visitor owns the index lifetime; returned range views own only source coordinates. */
+export declare function withPropertyValueRanges<T>(section: BiffPropertyRange, admit: (count: number) => void, accountWork: (amount: number) => void, context: CapabilityContext, visit: (values: BiffPropertyValues) => Promise<T>): Promise<T>;
+/** Mutable convenience materialization for retained property merge edits. */
+export declare function readPropertyValueRanges(section: BiffPropertyRange, admit: (count: number) => void, accountWork: (amount: number) => void, context: CapabilityContext): Promise<Map<number, BiffPropertyRange>>;
 export {};

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

@@ -1,3 +1,4 @@
+import { IntegerTable } from "@poe-platform/safe-fs/storage";
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { Binary, invalidBiff } from './biff-binary.js';
 /** Property subviews retain coordinates; even scalar reads own their borrowed input. */
@@ -75,7 +76,31 @@ export function propertyRange(input, context) {
     root.check();
     return new BiffPropertyRange(root, 0, size);
 }
-export async function readPropertySectionRanges(file, admit, accountWork) {
+/** Index IO checks disposal around awaits and owns transient write buffers. */
+export function propertyIndexStorage(storage, range) {
+    return {
+        allocate(length) { range.check(0, 0); return storage.allocate(length); },
+        async read(at, length) {
+            range.check(0, 0);
+            const bytes = await storage.read(at, length);
+            range.check(0, 0);
+            return bytes;
+        },
+        async write(at, bytes) {
+            range.check(0, 0);
+            const owned = new Uint8Array(bytes);
+            try {
+                await storage.write(at, owned);
+                range.check(0, 0);
+            }
+            finally {
+                owned.fill(0);
+            }
+        }
+    };
+}
+/** Validate all section intervals before replaying any descriptor. */
+export async function* readPropertySectionRanges(file, admit, accountWork, context) {
     file.check(0, 28);
     const header = new Binary(await file.read(0, 28));
     if (header.u16(0) !== 0xfffe || header.u16(2) > 1)
@@ -83,47 +108,163 @@ export async function readPropertySectionRanges(file, admit, accountWork) {
     const count = header.u32(24), tableEnd = 28 + count * 20;
     file.check(28, count * 20);
     admit(count);
-    const sections = [];
-    for (let i = 0; i < count; i++) {
-        const entry = new Binary(await file.read(28 + i * 20, 20)), offset = entry.u32(16);
-        if (offset < tableEnd || offset % 4)
-            invalidBiff('invalid property section offset');
-        const size = await file.u32(offset);
-        if (size < 8)
-            invalidBiff('invalid property section size');
-        file.check(offset, size);
-        const guid = Array.from(entry.slice(0, 16), byte => byte.toString(16).padStart(2, '0')).join('');
-        sections.push({ guid, offset, end: offset + size });
-    }
     accountWork(count * Math.ceil(Math.log2(count + 1)));
-    sections.sort((a, b) => a.offset - b.offset);
-    for (let i = 1; i < sections.length; i++)
-        if (sections[i].offset < sections[i - 1].end)
-            invalidBiff('overlapping property sections');
-    return sections;
+    const storage = context.createWorkingStorage?.();
+    let failed = false;
+    try {
+        const backing = storage && propertyIndexStorage(storage, file);
+        backing?.allocate(8);
+        const offsets = backing ? new IntegerTable(backing, 64) : new Map();
+        const records = backing ? undefined : new Map();
+        for (let i = 0; i < count; i++) {
+            const bytes = await file.read(28 + i * 20, 20), offset = new Binary(bytes).u32(16);
+            if (offset < tableEnd || offset % 4)
+                invalidBiff('invalid property section offset');
+            const size = await file.u32(offset);
+            if (size < 8)
+                invalidBiff('invalid property section size');
+            file.check(offset, size);
+            const record = new Uint8Array(24);
+            record.set(bytes);
+            new DataView(record.buffer).setUint32(20, size, true);
+            const position = backing ? backing.allocate(record.length) : i;
+            if (backing) {
+                try {
+                    await backing.write(position, record);
+                }
+                finally {
+                    record.fill(0);
+                }
+            }
+            else
+                records.set(position, record);
+            await offsets.set(BigInt(offset) << 32n | BigInt(i), BigInt(position));
+            file.check(0, 0);
+        }
+        const entries = async function* () {
+            const ordered = offsets instanceof Map ? [...offsets].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0) : offsets.entries();
+            for await (const [, position] of ordered) {
+                file.check(0, 0);
+                const bytes = new Binary(backing ? await backing.read(Number(position), 24) : records.get(Number(position)));
+                bytes.check(0, 24);
+                const offset = bytes.u32(16), end = offset + bytes.u32(20);
+                const guid = Array.from(bytes.slice(0, 16), byte => byte.toString(16).padStart(2, '0')).join('');
+                yield { guid, offset, end };
+            }
+        };
+        let end = 0;
+        for await (const section of entries()) {
+            if (section.offset < end)
+                invalidBiff('overlapping property sections');
+            end = section.end;
+        }
+        yield* entries();
+    }
+    catch (error) {
+        failed = true;
+        try {
+            await storage?.close();
+        }
+        catch (cleanup) {
+            throw new AggregateError([error, cleanup], 'BIFF property section index and cleanup failed');
+        }
+        throw error;
+    }
+    finally {
+        if (!failed)
+            await storage?.close();
+    }
 }
-export async function readPropertyValueRanges(section, admit, accountWork) {
+/** The visitor owns the index lifetime; returned range views own only source coordinates. */
+export async function withPropertyValueRanges(section, admit, accountWork, context, visit) {
     const count = await section.u32(4);
     section.check(8, count * 8);
     admit(count);
-    const pointers = [], ids = new Set();
-    for (let i = 0; i < count; i++) {
-        const entry = new Binary(await section.read(8 + i * 8, 8)), id = entry.u32(0), at = entry.u32(4);
-        if (at < 8 + count * 8 || at > section.size - 4)
-            invalidBiff('invalid property offset');
-        if (ids.has(id))
-            invalidBiff('duplicate property ID');
-        ids.add(id);
-        pointers.push({ id, at });
-    }
     accountWork(count * Math.ceil(Math.log2(count + 1)));
-    pointers.sort((a, b) => a.at - b.at);
-    const values = new Map();
-    for (let i = 0; i < count; i++) {
-        const { id, at } = pointers[i], next = pointers[i + 1]?.at ?? section.size;
-        if (next === at)
-            invalidBiff('overlapping property values');
-        values.set(id, section.slice(at, next - at));
+    const storage = context.createWorkingStorage?.();
+    let active = true, result;
+    const check = () => {
+        section.check(0, 0);
+        if (!active)
+            throw new SsconvertError('invalid-request', 'BIFF property value index is closed');
+    };
+    try {
+        const backing = storage && propertyIndexStorage(storage, section);
+        backing?.allocate(8);
+        const ids = backing ? new IntegerTable(backing, 64) : new Map();
+        const offsets = backing ? new IntegerTable(backing, 64) : new Map();
+        for (let i = 0; i < count; i++) {
+            const entry = new Binary(await section.read(8 + i * 8, 8)), id = BigInt(entry.u32(0)), at = entry.u32(4);
+            if (at < 8 + count * 8 || at > section.size - 4)
+                invalidBiff('invalid property offset');
+            if (await ids.get(id) !== undefined)
+                invalidBiff('duplicate property ID');
+            check();
+            await ids.set(id, BigInt(at));
+            check();
+            if (await offsets.get(BigInt(at)) !== undefined)
+                invalidBiff('overlapping property values');
+            check();
+            await offsets.set(BigInt(at), id);
+            check();
+        }
+        const ordered = (start = 0n) => offsets instanceof Map ? [...offsets].filter(([at]) => at >= start).sort(([a], [b]) => Number(a - b)) : offsets.entries(start);
+        result = await visit({
+            async get(id) {
+                check();
+                const at = await ids.get(BigInt(id));
+                check();
+                if (at === undefined)
+                    return undefined;
+                let end = section.size;
+                for await (const [next] of ordered(at + 1n)) {
+                    check();
+                    end = Number(next);
+                    break;
+                }
+                check();
+                return section.slice(Number(at), end - Number(at));
+            },
+            async *entries() {
+                check();
+                let previous;
+                for await (const [offset, id] of ordered()) {
+                    check();
+                    const at = Number(offset);
+                    if (previous)
+                        yield [previous.id, section.slice(previous.at, at - previous.at)];
+                    previous = { id: Number(id), at };
+                }
+                check();
+                if (previous)
+                    yield [previous.id, section.slice(previous.at, section.size - previous.at)];
+                check();
+            }
+        });
+        check();
     }
-    return values;
+    catch (error) {
+        try {
+            await storage?.close();
+        }
+        catch (cleanup) {
+            throw new AggregateError([error, cleanup], 'BIFF property index and cleanup failed');
+        }
+        throw error;
+    }
+    finally {
+        active = false;
+    }
+    await storage?.close();
+    section.check(0, 0);
+    return result;
+}
+/** Mutable convenience materialization for retained property merge edits. */
+export async function readPropertyValueRanges(section, admit, accountWork, context) {
+    return withPropertyValueRanges(section, admit, accountWork, context, async (source) => {
+        const values = new Map();
+        for await (const [id, value] of source.entries())
+            values.set(id, value);
+        return values;
+    });
 }

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

@@ -0,0 +1,6 @@
+import { type CapabilityContext } from "../spreadsheet-engine/contracts.js";
+import type { BiffPropertyRange } from './biff-property-range.js';
+export declare function readBiffPropertyText(data: BiffPropertyRange, offset: number, codepage: number, context: CapabilityContext, accountText: (text: string) => string, accountWork: (amount: number) => void): Promise<{
+    value: string;
+    end: number;
+}>;

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

@@ -0,0 +1,68 @@
+import { SsconvertError } from "../spreadsheet-engine/contracts.js";
+import { invalidBiff } from './biff-binary.js';
+import { biffDbcsTables } from "../spreadsheet-engine/encoding/biff-dbcs-tables.js";
+import { biffDecode } from './biff-strings.js';
+export async function readBiffPropertyText(data, offset, codepage, context, accountText, accountWork) {
+    const count = await data.u32(offset), width = codepage === 1200 ? 2 : 1, size = count * width;
+    if (!count)
+        invalidBiff("empty property string buffer");
+    data.check(offset + 4, size);
+    // Admit the maximum UTF-8 expansion before allocating a decoded string.
+    if ((count - 1) * 3 > (context.limits.workbookTextBytes ?? context.limits.inputBytes))
+        throw new SsconvertError("resource-limit", "ssconvert BIFF property text limit exceeded");
+    accountWork(size);
+    const end = offset + 4 + size;
+    if ((await data.read(end - width, width)).some(Boolean))
+        invalidBiff("unterminated property string");
+    let value = "";
+    const unicode = codepage === 1200 || codepage === 65001;
+    const decoder = unicode ? new TextDecoder(codepage === 1200 ? "utf-16le" : "utf-8", { fatal: true, ignoreBOM: true }) : undefined;
+    const multibyte = biffDbcsTables[codepage];
+    let lead;
+    if (!unicode && !multibyte)
+        biffDecode(new Uint8Array(), codepage);
+    for (let at = offset + 4; at < end - width;) {
+        const bytes = await data.read(at, Math.min(16384, end - width - at));
+        at += bytes.length;
+        if (decoder) {
+            try {
+                value += decoder.decode(bytes, { stream: true });
+            }
+            catch {
+                invalidBiff("invalid property string encoding");
+            }
+        }
+        else if (multibyte) {
+            const characters = [];
+            for (const byte of bytes) {
+                if (lead !== undefined) {
+                    const character = multibyte.double[lead]?.[byte];
+                    if (character === undefined || character === "\uffff")
+                        invalidBiff("invalid or truncated DBCS character");
+                    characters.push(character);
+                    lead = undefined;
+                }
+                else {
+                    const character = multibyte.single[byte];
+                    if (character === "\uffff")
+                        lead = byte;
+                    else
+                        characters.push(character);
+                }
+            }
+            value += characters.join("");
+        }
+        else
+            value += biffDecode(bytes, codepage);
+    }
+    if (lead !== undefined)
+        invalidBiff("invalid or truncated DBCS character");
+    if (decoder)
+        try {
+            value += decoder.decode();
+        }
+        catch {
+            invalidBiff("invalid property string encoding");
+        }
+    return { value: accountText(value), end: width === 2 ? Math.ceil(end / 4) * 4 : end };
+}

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

@@ -0,0 +1,5 @@
+import type { CapabilityContext } from "../spreadsheet-engine/contracts.js";
+import type { BiffPropertyRange } from './biff-property-range.js';
+import type { BiffPropertySource } from './biff-encrypted-properties-write.js';
+/** Count UTF-16 units before staging; both passes retain only a bounded decoder window. */
+export declare function stageWideBiffProperty(source: BiffPropertyRange, context: CapabilityContext, charge: (amount: number) => void, reserve: (length: number) => number): Promise<BiffPropertySource>;

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

@@ -0,0 +1,45 @@
+import { stagePropertyBytes } from './biff-property-bytes.js';
+/** Count UTF-16 units before staging; both passes retain only a bounded decoder window. */
+export async function stageWideBiffProperty(source, context, charge, reserve) {
+    reserve(source.size);
+    const text = source.slice(8, await source.u32(4) - 1);
+    const parts = async function* () {
+        const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+        for (let at = 0; at < text.size;) {
+            const bytes = await text.read(at, Math.min(8192, text.size - at));
+            at += bytes.length;
+            try {
+                yield decoder.decode(bytes, { stream: true });
+            }
+            finally {
+                bytes.fill(0);
+            }
+        }
+        yield decoder.decode();
+    };
+    let units = 0;
+    for await (const part of parts())
+        units += part.length;
+    charge(units);
+    const length = reserve(8 + (units + 1) * 2);
+    return stagePropertyBytes({ length, async *chunks() {
+            const header = new Uint8Array(8), view = new DataView(header.buffer);
+            view.setUint32(0, 31, true);
+            view.setUint32(4, units + 1, true);
+            yield header;
+            const buffer = new Uint8Array(16384), output = new DataView(buffer.buffer);
+            try {
+                for await (const part of parts())
+                    for (let at = 0; at < part.length; at += 8192) {
+                        const size = Math.min(8192, part.length - at);
+                        for (let i = 0; i < size; i++)
+                            output.setUint16(i * 2, part.charCodeAt(at + i), true);
+                        yield buffer.subarray(0, size * 2);
+                    }
+                yield new Uint8Array(2);
+            }
+            finally {
+                buffer.fill(0);
+            }
+        } }, context);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-bash",
-  "version": "0.1.812",
+  "version": "0.1.814",
   "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.812",
+    "@poe-platform/safe-fs": "0.1.814",
     "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",
@@ -2834,12 +2835,16 @@
     "./dist/spreadsheet-format-xls/biff-label-ranges.js",
     "./dist/spreadsheet-format-xls/biff-metadata.js",
     "./dist/spreadsheet-format-xls/biff-name-bindings.js",
-    "./dist/spreadsheet-format-xls/biff-properties-layout.js",
     "./dist/spreadsheet-format-xls/biff-properties-merge.js",
     "./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-range.js",
     "./dist/spreadsheet-format-xls/biff-record-storage.js",
     "./dist/spreadsheet-format-xls/biff-shared-strings.js",