@poe-platform/safe-bash 0.1.811 → 0.1.813

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

@@ -396,30 +396,12 @@ export async function writeBiffProperties(book, context, staged = false) {
                     yield* propertyChunks(encoded.get(guid));
             } });
     }
-    // Opaque snapshot merging still needs random byte-array access. Keep it explicit
-    // until that reader and its codepage/identity logic migrate to retained ranges.
     const snapshots = (book.unsupportedRecords ?? []).some(record => record.source === "biff" && record.kind === "ole-properties" && record.disposition === "retained");
-    const streams = new Map();
-    if (!staged || snapshots)
-        for (const [name, value] of planned) {
-            const bytes = new Uint8Array(value.length);
-            let at = 0;
-            for (const part of propertyChunks(value)) {
-                bytes.set(part, at);
-                at += part.length;
-            }
-            streams.set(name, bytes);
-        }
-    const preserved = await mergeBiffProperties(book, streams, handledMetadata, context, charge, allocate);
-    for (const key of unsupportedKeys)
-        if (!preserved.has(key))
-            await context.diagnostic?.({ code: "biff-loss-warning", severity: "warning", message: `Unsupported Excel BIFF document property: ${key}` });
-    if (!staged)
-        return { streams, handledMetadata, async close() { } };
+    const streams = new Map(), inputs = [];
     const sources = new Map();
     const close = async () => {
         const errors = [];
-        for (const source of sources.values())
+        for (const source of [...sources.values(), ...inputs])
             try {
                 await source.close();
             }
@@ -432,8 +414,42 @@ export async function writeBiffProperties(book, context, staged = false) {
             throw new AggregateError(errors, "BIFF property sources cleanup failed");
     };
     try {
+        if (!staged || snapshots)
+            for (const [name, value] of planned) {
+                if (staged) {
+                    const source = await stagePropertyBytes(value, context);
+                    inputs.push(source);
+                    streams.set(name, source);
+                }
+                else {
+                    const bytes = new Uint8Array(value.length);
+                    let at = 0;
+                    for (const part of propertyChunks(value)) {
+                        bytes.set(part, at);
+                        at += part.length;
+                    }
+                    streams.set(name, bytes);
+                }
+            }
+        const preserved = await mergeBiffProperties(book, streams, handledMetadata, context, charge, allocate, staged ? { sources, reserve } : undefined);
+        for (const key of unsupportedKeys)
+            if (!preserved.has(key))
+                await context.diagnostic?.({ code: "biff-loss-warning", severity: "warning", message: `Unsupported Excel BIFF document property: ${key}` });
+        if (!staged)
+            return { streams, handledMetadata, async close() { } };
         for (const [name, value] of snapshots ? streams : planned)
-            sources.set(name, await stagePropertyBytes(value, context));
+            if (!sources.has(name)) {
+                const bytes = 'size' in value ? { length: value.size, async *chunks() {
+                        for (let at = 0; at < value.size;) {
+                            const part = await value.read(at, Math.min(16384, value.size - at));
+                            at += part.length;
+                            yield part;
+                        }
+                    } } : value;
+                sources.set(name, await stagePropertyBytes(bytes, context));
+            }
+        for (const input of inputs)
+            await input.close();
         return { streams: sources, handledMetadata, close };
     }
     catch (error) {
@@ -446,8 +462,9 @@ export async function writeBiffProperties(book, context, staged = false) {
         throw error;
     }
     finally {
-        if (snapshots)
+        if (staged && snapshots)
             for (const bytes of streams.values())
-                bytes.fill(0);
+                if (bytes instanceof Uint8Array)
+                    bytes.fill(0);
     }
 }

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

@@ -1,8 +1,7 @@
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { invalidBiff } from "./biff-binary.js";
 import { propertyRange, readPropertySectionRanges, readPropertyValueRanges } from "./biff-property-range.js";
-import { biffDbcsTables } from "../spreadsheet-engine/encoding/biff-dbcs-tables.js";
-import { biffDecode } from "./biff-strings.js";
+import { readBiffPropertyText } from "./biff-property-text.js";
 // OLE property-set layout and IDs: LibreOffice oleprops.cxx/.hxx at
 // bce0998afefdbc355585ca324285661a2170ba77; source receipts are in the gap ledger.
 export const biffPropertyFormats = { summary: "e0859ff2f94f6810ab9108002b27b3d9",
@@ -29,70 +28,6 @@ export async function readBiffProperties(streams, context, accountText, accountW
         if (nodes > (context.limits.workbookNodes ?? context.limits.inputBytes))
             throw new SsconvertError("resource-limit", "ssconvert BIFF property node limit exceeded");
     };
-    const text = async (data, offset, codepage) => {
-        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 };
-    };
     for (const target of ["\u0005SummaryInformation", "\u0005DocumentSummaryInformation"]) {
         let streamName = target, bytes = streams.get(target);
         if (!bytes)
@@ -132,7 +67,7 @@ export async function readBiffProperties(streams, context, accountText, accountW
                     admit(length);
                     let at = 4;
                     for (let i = 0; i < length; i++) {
-                        const id = await dictionary.u32(at), entry = await text(dictionary, at + 4, codepage);
+                        const id = await dictionary.u32(at), entry = await readBiffPropertyText(dictionary, at + 4, codepage, context, accountText, accountWork);
                         if (id < 2 || names.has(id) || !entry.value)
                             invalidBiff("invalid property dictionary entry");
                         names.set(id, entry.value);
@@ -159,7 +94,7 @@ export async function readBiffProperties(streams, context, accountText, accountW
                 const type = await data.u32(0);
                 try {
                     if (type === 30 || type === 31)
-                        value = (await text(data, 4, type === 31 ? 1200 : codepage)).value;
+                        value = (await readBiffPropertyText(data, 4, type === 31 ? 1200 : codepage, context, accountText, accountWork)).value;
                     else if (type === 3)
                         value = (await data.u32(4)) | 0;
                     else if (type === 5) {

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

@@ -0,0 +1,23 @@
+import type { WorkingStorage } from "../spreadsheet-engine/contracts.js";
+export interface BiffPropertyDescriptor {
+    offset: number;
+    size: number;
+    block: number;
+    name: string;
+}
+/** Two bounded radix caches index UTF-16 name edges and stable range order.
+ * Linked fixed-size records replay original descriptor order without an array. */
+export declare class BiffPropertyDescriptorIndex {
+    private readonly storage;
+    private readonly check;
+    private readonly names;
+    private readonly ranges;
+    private node;
+    private count;
+    private first;
+    private last;
+    constructor(storage: WorkingStorage, check: () => void);
+    add(entry: BiffPropertyDescriptor): Promise<void>;
+    validate(): Promise<void>;
+    entries(): AsyncIterable<BiffPropertyDescriptor>;
+}

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

@@ -0,0 +1,93 @@
+import { IntegerTable } from "@poe-platform/safe-fs/storage";
+import { Binary, invalidBiff } from './biff-binary.js';
+/** Two bounded radix caches index UTF-16 name edges and stable range order.
+ * Linked fixed-size records replay original descriptor order without an array. */
+export class BiffPropertyDescriptorIndex {
+    storage;
+    check;
+    names;
+    ranges;
+    node = 2n;
+    count = 0;
+    first = 0;
+    last = 0;
+    constructor(storage, check) {
+        this.storage = storage;
+        this.check = check;
+        storage.allocate(8);
+        this.check();
+        this.names = new IntegerTable(storage, 64);
+        this.ranges = new IntegerTable(storage, 64);
+    }
+    async add(entry) {
+        this.check();
+        let node = 1n;
+        const name = entry.name.toUpperCase();
+        for (let i = 0; i < name.length; i++) {
+            const key = node << 16n | BigInt(name.charCodeAt(i));
+            let next = await this.names.get(key);
+            this.check();
+            if (next === undefined) {
+                next = this.node++;
+                await this.names.set(key, next);
+                this.check();
+            }
+            node = next;
+        }
+        const terminal = node << 16n;
+        if (await this.names.get(terminal) !== undefined)
+            invalidBiff('duplicate or invalid encrypted property stream name');
+        this.check();
+        await this.names.set(terminal, 1n);
+        this.check();
+        await this.ranges.set(BigInt(entry.offset) << 32n | BigInt(this.count++), BigInt(entry.offset + entry.size));
+        this.check();
+        const bytes = new Uint8Array(88), view = new DataView(bytes.buffer);
+        view.setUint32(8, entry.offset, true);
+        view.setUint32(12, entry.size, true);
+        view.setUint16(16, entry.block, true);
+        view.setUint16(18, entry.name.length, true);
+        for (let i = 0; i < entry.name.length; i++)
+            view.setUint16(20 + i * 2, entry.name.charCodeAt(i), true);
+        const position = this.storage.allocate(bytes.length);
+        this.check();
+        try {
+            await this.storage.write(position, bytes);
+            this.check();
+            if (this.last) {
+                view.setFloat64(0, position, true);
+                await this.storage.write(this.last, bytes.subarray(0, 8));
+                this.check();
+            }
+            else
+                this.first = position;
+            this.last = position;
+        }
+        finally {
+            bytes.fill(0);
+        }
+    }
+    async validate() {
+        let end = 0n;
+        for await (const [key, next] of this.ranges.entries()) {
+            this.check();
+            if (key >> 32n < end)
+                invalidBiff('overlapping encrypted property payloads');
+            end = next;
+        }
+    }
+    async *entries() {
+        let position = this.first;
+        while (position) {
+            this.check();
+            const bytes = new Binary(await this.storage.read(position, 88));
+            this.check();
+            bytes.check(0, 88);
+            position = bytes.f64(0);
+            let name = '';
+            for (let i = 0; i < bytes.u16(18); i++)
+                name += String.fromCharCode(bytes.u16(20 + i * 2));
+            yield { offset: bytes.u32(8), size: bytes.u32(12), block: bytes.u16(16), name };
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import { type CapabilityContext } from "../spreadsheet-engine/contracts.js";
+import type { BiffPropertyBytes } from './biff-property-bytes.js';
+/** Validate representability before exposing bounded encoded windows. */
+export declare function createBiffPropertyNameEncoder(context: CapabilityContext, charge: (amount: number) => void, accountText: (text: string) => string): (name: string, codepage: number) => BiffPropertyBytes | undefined;

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-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/dist/spreadsheet-format-xls/biff-write-metadata.js

@@ -3,7 +3,7 @@ import { parseA1 } from "../spreadsheet-ast/index.js";
 import { metadataNode } from "../spreadsheet-engine/codecs/xlsx-write-support.js";
 import { words } from "./biff-write-binary.js";
 import { biffString } from "./biff-write.js";
-import { biffProtectionPermissions } from "./biff-metadata.js";
+import { biffProtectionPermissions, biffHeaderParts } from "./biff-metadata.js";
 import { biffFontWidth } from "./biff-font-widths.js";
 import { writeBiffLabelRanges } from "./biff-label-ranges.js";
 function concat(...parts) {
@@ -442,6 +442,15 @@ export class BiffMetadataWriter {
                     text += source[at] === "&" ? "&&" : source[at];
                 }
             }
+            const original = sheet.view?.[name === "Header" ? "printHeader" : "printFooter"];
+            if (node && typeof original === "string") {
+                this.charge(original.length);
+                const sections = biffHeaderParts(original);
+                // Keep the imported token spelling (including formatting controls)
+                // when the normalized sections are unchanged. Explicit edits win.
+                if (Object.entries(sections).every(([side, value]) => value === (node.attributes[side] ?? "")))
+                    text = original;
+            }
             await output.record(opcode, biffString(text, revision, this.context, revision === 8 ? 2 : 1));
         }
         for (const [name, opcode] of [["hPageBreaks", 0x1b], ["vPageBreaks", 0x1a]]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-bash",
-  "version": "0.1.811",
+  "version": "0.1.813",
   "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.811",
+    "@poe-platform/safe-fs": "0.1.813",
     "pdf-lib": "1.17.1",
     "@types/node": "^25.2.2",
     "@formatjs/intl-numberformat": "9.4.0",
@@ -2834,12 +2834,15 @@
     "./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-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",