@poe-platform/safe-bash 0.1.815 → 0.1.817

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

@@ -1,7 +1,7 @@
 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';
+import { wideBiffPropertyBytes } from './biff-property-transcode.js';
 import { stagePropertyBytes, propertyChunks } from './biff-property-bytes.js';
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { Binary, invalidBiff } from "./biff-binary.js";
@@ -121,8 +121,8 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
         const identity = (property) => `${property.stream}:${property.section}:${property.id}`;
         const readContext = { ...context, limits: { ...context.limits, inputBytes: context.limits.outputBytes } };
         // Reuse scalar decoding, but do not create another retained hexadecimal copy.
-        await readBiffProperties(new Map([...snapshots].map(([name, value]) => [name, value.bytes])), readContext, accountText, charge, undefined, property => { admit(1); original.set(identity(property), property); });
-        await readBiffProperties(streams, readContext, accountText, charge, undefined, property => { admit(1); pending.set(property.key, property); });
+        await readBiffProperties(new Map([...snapshots].map(([name, value]) => [name, value.bytes])), readContext, accountText, charge, undefined, property => { admit(1); original.set(identity(property), property); }, false);
+        await readBiffProperties(streams, readContext, accountText, charge, undefined, property => { admit(1); pending.set(property.key, property); }, false);
         const chunks = async function* (source) {
             for (let at = 0; at < source.size;) {
                 const bytes = await source.read(at, source.size - at);
@@ -161,6 +161,12 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                 yield { id, name, bytes: data.slice(start, at - start) };
             }
         };
+        const reserve = staged?.reserve ?? ((length) => {
+            charge(length);
+            if (length > 0xffffffff || length > context.limits.outputBytes)
+                throw new SsconvertError("resource-limit", "ssconvert BIFF property output bytes limit exceeded");
+            return length;
+        });
         const writeDictionary = async (section, plan) => {
             const output = { length: plan.length, async *chunks() {
                     const header = new Uint8Array(4);
@@ -172,15 +178,13 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                             yield* chunks(entry.bytes);
                         }
                     if (plan.append) {
-                        charge(plan.append.size);
-                        yield* chunks(plan.append);
+                        charge(plan.append.length);
+                        yield* propertyChunks(plan.append);
                     }
                 } };
             if (staged) {
                 staged.reserve(plan.length);
-                const source = await stagePropertyBytes(output, context);
-                temporarySources.push(source);
-                await section.values.set(0, propertyRange(source, context));
+                await section.values.set(0, { size: plan.length, chunks: output.chunks });
             }
             else {
                 const bytes = allocate(plan.length);
@@ -216,9 +220,7 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
             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);
-                temporarySources.push(output);
-                return propertyRange(output, context);
+                return wideBiffPropertyBytes(source, context, charge, staged.reserve);
             }
             const data = await materialize(source);
             const value = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(data.slice(8, data.u32(4) - 1));
@@ -238,9 +240,11 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
         };
         for (const [name, snapshot] of snapshots) {
             const seen = new Set();
-            let modeled = snapshot.modeled;
-            if (!modeled) {
-                modeled = [];
+            function* modeled() {
+                if (snapshot.modeled) {
+                    yield* snapshot.modeled;
+                    return;
+                }
                 // SummaryInformation is read first. A legacy document-only snapshot lacks
                 // that earlier stream's ownership decisions: infer only unchanged values.
                 for (const property of original.values()) {
@@ -250,11 +254,11 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                     if (name === "\u0005SummaryInformation" || snapshots.has("\u0005SummaryInformation") ||
                         Object.hasOwn(book.properties ?? {}, property.key) && same(property.value, book.properties?.[property.key])) {
                         admit(1);
-                        modeled.push([property.section, property.id, property.key]);
+                        yield [property.section, property.id, property.key];
                     }
                 }
             }
-            for (const entry of modeled) {
+            for (const entry of modeled()) {
                 admit(1);
                 if (!Array.isArray(entry) || entry.length !== 3 || typeof entry[0] !== "number" || typeof entry[1] !== "number" || typeof entry[2] !== "string")
                     invalidBiff("invalid retained property identity");
@@ -333,23 +337,10 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                         if (length > size)
                             yield new Uint8Array(length - size);
                     } };
-                let bytes;
-                if (staged) {
-                    staged.reserve(length);
-                    const source = await stagePropertyBytes(entry, context);
-                    temporarySources.push(source);
-                    bytes = propertyRange(source, context);
-                }
-                else {
-                    const data = allocate(length);
-                    let at = 0;
-                    for (const part of entry.chunks()) {
-                        data.set(part, at);
-                        at += part.length;
-                    }
-                    bytes = propertyRange(data, context);
-                }
-                await writeDictionary(target, { length: dictionaryLength + bytes.size, count: count + 1, append: bytes });
+                // Preserve admission for the entry while writing its chunks directly into
+                // the rebuilt dictionary, without a separate store per inserted name.
+                reserve(length);
+                await writeDictionary(target, { length: dictionaryLength + length, count: count + 1, append: entry });
             }
             else if (await values.get(id)) {
                 await warn(property.key, "opaque property ID collision");
@@ -357,21 +348,11 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
             }
             await values.set(id, await wide(value, target));
         }
-        const reserve = staged?.reserve ?? ((length) => {
-            charge(length);
-            if (length > 0xffffffff || length > context.limits.outputBytes)
-                throw new SsconvertError("resource-limit", "ssconvert BIFF property output bytes limit exceeded");
-            return length;
-        });
-        const encodeSection = async (section) => {
+        const encodeSection = (section) => {
             if (!section.values)
                 return { length: section.bytes.size, chunks: () => chunks(section.bytes) };
             const values = section.values;
-            let length = 8 + values.size * 8;
-            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);
+            const length = values.serializedSize;
             return { length, async *chunks() {
                     const header = new Uint8Array(8), view = new DataView(header.buffer);
                     view.setUint32(0, length, true);
@@ -397,46 +378,61 @@ 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 = [];
-            for (const section of fresh.get(name) ?? []) {
-                for await (const [id] of section.values.entries())
-                    if (id >= 2) {
-                        remaining.push(section);
-                        break;
+            const remaining = async function* () {
+                for (const section of fresh.get(name) ?? []) {
+                    charge(1);
+                    for await (const [id] of section.values.entries()) {
+                        charge(1);
+                        if (id >= 2) {
+                            yield 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);
+                }
+            };
+            let custom = false, document = false;
+            if (!old.has(name))
+                for await (const section of remaining()) {
+                    custom ||= section.guid === biffPropertyFormats.custom;
+                    document ||= section.guid === biffPropertyFormats.document;
+                }
+            const builtin = custom && !document ? fresh.get(name)?.find(section => section.guid === biffPropertyFormats.document) : undefined;
+            const sections = async function* () {
+                yield* old.get(name) ?? [];
                 if (builtin)
-                    remaining.unshift(builtin);
+                    yield builtin;
+                yield* remaining();
+            };
+            let count = 0, length = 28;
+            for await (const section of sections()) {
+                charge(1);
+                count++;
+                const size = section.values?.serializedSize ?? section.bytes.size;
+                if (section.values)
+                    reserve(size);
+                length += 20 + size;
             }
-            const sections = [...old.get(name) ?? [], ...remaining];
-            if (!sections.length) {
+            if (!count) {
                 streams.delete(name);
                 continue;
             }
-            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);
-                    new DataView(header.buffer).setUint32(24, sections.length, true);
+                    new DataView(header.buffer).setUint32(24, count, true);
                     yield header;
-                    let at = 28 + sections.length * 20;
-                    for (let i = 0; i < sections.length; i++) {
+                    let at = 28 + count * 20;
+                    for await (const section of sections()) {
                         charge(1);
                         const entry = new Uint8Array(20), view = new DataView(entry.buffer);
                         for (let j = 0; j < 16; j++)
-                            entry[j] = parseInt(sections[i].guid.slice(j * 2, j * 2 + 2), 16);
+                            entry[j] = parseInt(section.guid.slice(j * 2, j * 2 + 2), 16);
                         view.setUint32(16, at, true);
                         yield entry;
-                        at += bodies[i].length;
+                        at += section.values?.serializedSize ?? section.bytes.size;
                     }
-                    for (const body of bodies)
-                        yield* body.chunks();
+                    for await (const section of sections())
+                        yield* encodeSection(section).chunks();
                 } };
             if (staged) {
                 reserve(length);
@@ -460,7 +456,7 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
             admit(1);
             if (!Object.hasOwn(book.properties ?? {}, property.key))
                 exposed.add(property.key);
-        });
+        }, false);
         for (const key of exposed)
             await warn(key, "opaque property exposes a field absent from the model");
     }

package/dist/spreadsheet-format-xls/biff-properties.d.ts

@@ -7,11 +7,13 @@ export declare const biffPropertyFormats: {
 };
 export declare const biffPropertyFields: Map<string, ReadonlyMap<number, string>>;
 export declare function isBiffKeywordSpace(code: number): boolean;
-/** Property offsets are section-relative; dictionaries have no variant header. */
+/** Property offsets are section-relative; dictionaries have no variant header.
+ * With collect=false, await observations without retaining a result record; exact
+ * duplicate-name checks use bounded caller storage when available. */
 export declare function readBiffProperties(streams: ReadonlyMap<string, Uint8Array | RangeSource>, context: CapabilityContext, accountText: (text: string) => string, accountWork: (amount: number) => void, retained: UnsupportedRecord[] | undefined, observe?: (property: {
     stream: string;
     section: number;
     id: number;
     key: string;
     value: ImportedValue;
-}) => void): Promise<Readonly<Record<string, ImportedValue>>>;
+}) => void | Promise<void>, collect?: boolean): Promise<Readonly<Record<string, ImportedValue>>>;

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

@@ -1,3 +1,4 @@
+import { BiffPropertyNames } from './biff-property-names.js';
 import { visitBiffPropertyDictionary } from './biff-property-dictionary.js';
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { invalidBiff } from "./biff-binary.js";
@@ -19,9 +20,12 @@ export const biffPropertyFields = new Map([
 export function isBiffKeywordSpace(code) {
     return code > 0 && code <= 32 || code >= 0x2000 && code <= 0x200b || code === 0x2028 || code === 0x2029;
 }
-/** Property offsets are section-relative; dictionaries have no variant header. */
-export async function readBiffProperties(streams, context, accountText, accountWork, retained, observe) {
+/** Property offsets are section-relative; dictionaries have no variant header.
+ * With collect=false, await observations without retaining a result record; exact
+ * duplicate-name checks use bounded caller storage when available. */
+export async function readBiffProperties(streams, context, accountText, accountWork, retained, observe, collect = true) {
     const properties = Object.create(null);
+    let names;
     let nodes = 0;
     const admit = (count) => {
         accountWork(count);
@@ -29,138 +33,153 @@ 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");
     };
-    for (const target of ["\u0005SummaryInformation", "\u0005DocumentSummaryInformation"]) {
-        let streamName = target, bytes = streams.get(target);
-        if (!bytes)
-            for (const [name, data] of streams) {
-                accountWork(1);
-                if (name.toUpperCase() === target.toUpperCase()) {
-                    streamName = name;
-                    bytes = data;
-                    break;
+    try {
+        for (const target of ["\u0005SummaryInformation", "\u0005DocumentSummaryInformation"]) {
+            let streamName = target, bytes = streams.get(target);
+            if (!bytes)
+                for (const [name, data] of streams) {
+                    accountWork(1);
+                    if (name.toUpperCase() === target.toUpperCase()) {
+                        streamName = name;
+                        bytes = data;
+                        break;
+                    }
                 }
-            }
-        if (!bytes)
-            continue;
-        const file = propertyRange(bytes, context);
-        accountWork(file.size);
-        const sections = readPropertySectionRanges(file, admit, accountWork, context);
-        let unknown = false;
-        const modeled = [];
-        for await (const { guid, offset, end } of sections) {
-            if (!biffPropertyFields.has(guid) && guid !== custom) {
-                unknown = true;
+            if (!bytes)
                 continue;
-            }
-            await withPropertyValueRanges(file.slice(offset, end - offset), admit, accountWork, context, async (values) => {
-                const cp = await values.get(1);
-                let codepage = 1252;
-                if (cp) {
-                    if ((await cp.u32(0)) !== 2)
-                        invalidBiff("invalid property codepage type");
-                    codepage = await cp.u16(4);
+            const file = propertyRange(bytes, context);
+            accountWork(file.size);
+            const sections = readPropertySectionRanges(file, admit, accountWork, context);
+            let unknown = false;
+            const modeled = retained ? [] : undefined;
+            for await (const { guid, offset, end } of sections) {
+                if (!biffPropertyFields.has(guid) && guid !== custom) {
+                    unknown = true;
+                    continue;
                 }
-                const dictionary = guid === custom ? await values.get(0) : undefined;
-                const supported = await visitBiffPropertyDictionary(dictionary, codepage, context, admit, accountText, accountWork, async (getName) => {
-                    for await (const [id, data] of values.entries()) {
-                        context.signal.throwIfAborted();
-                        if (id < 2)
-                            continue;
-                        const key = guid === custom ? await getName(id) : biffPropertyFields.get(guid)?.get(id);
-                        if (key === undefined || Object.hasOwn(properties, key)) {
-                            unknown = true;
-                            continue;
-                        }
-                        let value;
-                        const type = await data.u32(0);
-                        try {
-                            if (type === 30 || type === 31)
-                                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) {
-                                value = await data.f64(4);
-                                if (!Number.isFinite(value))
-                                    invalidBiff("nonfinite property value");
+                await withPropertyValueRanges(file.slice(offset, end - offset), admit, accountWork, context, async (values) => {
+                    const cp = await values.get(1);
+                    let codepage = 1252;
+                    if (cp) {
+                        if ((await cp.u32(0)) !== 2)
+                            invalidBiff("invalid property codepage type");
+                        codepage = await cp.u16(4);
+                    }
+                    const dictionary = guid === custom ? await values.get(0) : undefined;
+                    const supported = await visitBiffPropertyDictionary(dictionary, codepage, context, admit, accountText, accountWork, async (getName) => {
+                        for await (const [id, data] of values.entries()) {
+                            context.signal.throwIfAborted();
+                            if (id < 2)
+                                continue;
+                            const key = guid === custom ? await getName(id) : biffPropertyFields.get(guid)?.get(id);
+                            if (key === undefined || (collect ? Object.hasOwn(properties, key) : await (names ??= new BiffPropertyNames(context, accountWork)).has(key))) {
+                                unknown = true;
+                                continue;
                             }
-                            else if (type === 11)
-                                value = (await data.u16(4)) !== 0;
-                            else if (type === 64) {
-                                const ticks = BigInt(await data.u32(4)) + (BigInt(await data.u32(8)) << 32n);
-                                if (guid === summary && id === 10) {
-                                    const fraction = (ticks % 10000000n).toString().padStart(7, "0");
-                                    let end = fraction.length;
-                                    while (end && fraction[end - 1] === "0")
-                                        end--;
-                                    value = `PT${ticks / 600000000n}M${ticks / 10000000n % 60n}${end ? "." + fraction.slice(0, end) : ""}S`;
+                            let value;
+                            const type = await data.u32(0);
+                            try {
+                                if (type === 30 || type === 31)
+                                    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) {
+                                    value = await data.f64(4);
+                                    if (!Number.isFinite(value))
+                                        invalidBiff("nonfinite property value");
+                                }
+                                else if (type === 11)
+                                    value = (await data.u16(4)) !== 0;
+                                else if (type === 64) {
+                                    const ticks = BigInt(await data.u32(4)) + (BigInt(await data.u32(8)) << 32n);
+                                    if (guid === summary && id === 10) {
+                                        const fraction = (ticks % 10000000n).toString().padStart(7, "0");
+                                        let end = fraction.length;
+                                        while (end && fraction[end - 1] === "0")
+                                            end--;
+                                        value = `PT${ticks / 600000000n}M${ticks / 10000000n % 60n}${end ? "." + fraction.slice(0, end) : ""}S`;
+                                    }
+                                    else {
+                                        value = new Date(Number(ticks / 10000n) - 11644473600000).toISOString();
+                                        // The workbook model stores timestamps as strings; retain the
+                                        // original property bytes when Date's millisecond precision loses ticks.
+                                        if (ticks % 10000n)
+                                            unknown = true;
+                                    }
+                                    accountText(value);
                                 }
-                                else {
-                                    value = new Date(Number(ticks / 10000n) - 11644473600000).toISOString();
-                                    // The workbook model stores timestamps as strings; retain the
-                                    // original property bytes when Date's millisecond precision loses ticks.
-                                    if (ticks % 10000n)
-                                        unknown = true;
+                                else if (type === 7) {
+                                    const days = await data.f64(4);
+                                    if (!Number.isFinite(days) || days <= -657435 || days >= 2958466)
+                                        invalidBiff("invalid OLE property date");
+                                    // OLE Automation uses 1899-12-30 and the absolute fractional day.
+                                    // LibreOffice's oleprops DATE path truncates it and uses 1899-12-31;
+                                    // the documented Automation representation governs the stored value.
+                                    value = new Date(-2209161600000 + Math.round((Math.trunc(days) + Math.abs(days % 1)) * 86400000)).toISOString();
+                                    accountText(value);
                                 }
-                                accountText(value);
                             }
-                            else if (type === 7) {
-                                const days = await data.f64(4);
-                                if (!Number.isFinite(days) || days <= -657435 || days >= 2958466)
-                                    invalidBiff("invalid OLE property date");
-                                // OLE Automation uses 1899-12-30 and the absolute fractional day.
-                                // LibreOffice's oleprops DATE path truncates it and uses 1899-12-31;
-                                // the documented Automation representation governs the stored value.
-                                value = new Date(-2209161600000 + Math.round((Math.trunc(days) + Math.abs(days % 1)) * 86400000)).toISOString();
-                                accountText(value);
+                            catch (error) {
+                                if (!(error instanceof SsconvertError) || error.code !== "unsupported-feature")
+                                    throw error;
                             }
+                            if (value === undefined) {
+                                unknown = true;
+                                continue;
+                            }
+                            if (guid === summary && id === 5 && typeof value === "string") {
+                                let count = 1;
+                                for (const character of value)
+                                    if (character === ",")
+                                        count++;
+                                admit(count);
+                                accountWork(value.length);
+                                value = value.split(",").map(keyword => {
+                                    let start = 0, end = keyword.length;
+                                    while (start < end && isBiffKeywordSpace(keyword.charCodeAt(start)))
+                                        start++;
+                                    while (end > start && isBiffKeywordSpace(keyword.charCodeAt(end - 1)))
+                                        end--;
+                                    return keyword.slice(start, end);
+                                }).filter(Boolean);
+                            }
+                            accountText(key);
+                            if (collect)
+                                properties[key] = value;
+                            else
+                                await names.add(key);
+                            modeled?.push([offset, id, key]);
+                            await observe?.({ stream: streamName, section: offset, id, key, value });
                         }
-                        catch (error) {
-                            if (!(error instanceof SsconvertError) || error.code !== "unsupported-feature")
-                                throw error;
-                        }
-                        if (value === undefined) {
-                            unknown = true;
-                            continue;
-                        }
-                        if (guid === summary && id === 5 && typeof value === "string") {
-                            let count = 1;
-                            for (const character of value)
-                                if (character === ",")
-                                    count++;
-                            admit(count);
-                            accountWork(value.length);
-                            value = value.split(",").map(keyword => {
-                                let start = 0, end = keyword.length;
-                                while (start < end && isBiffKeywordSpace(keyword.charCodeAt(start)))
-                                    start++;
-                                while (end > start && isBiffKeywordSpace(keyword.charCodeAt(end - 1)))
-                                    end--;
-                                return keyword.slice(start, end);
-                            }).filter(Boolean);
-                        }
-                        accountText(key);
-                        properties[key] = value;
-                        modeled.push([offset, id, key]);
-                        observe?.({ stream: streamName, section: offset, id, key, value });
-                    }
+                    });
+                    if (!supported)
+                        unknown = true;
                 });
-                if (!supported)
-                    unknown = true;
-            });
-        }
-        if (unknown && retained) {
-            if (file.size * 2 > (context.limits.workbookTextBytes ?? context.limits.inputBytes * 2))
-                throw new SsconvertError("resource-limit", "ssconvert BIFF property retention limit exceeded");
-            let encoded = "";
-            for (let at = 0; at < file.size;) {
-                const chunk = await file.read(at, Math.min(16384, file.size - at));
-                encoded += Array.from(chunk, byte => byte.toString(16).padStart(2, "0")).join("");
-                at += chunk.length;
             }
-            const hex = accountText(encoded);
-            retained.push({ source: "biff", kind: "ole-properties", disposition: "retained", data: { stream: streamName, bytes: hex, modeled } });
-            await context.diagnostic?.({ code: "biff-loss-warning", severity: "warning", message: `BIFF property stream ${streamName.slice(1)} retained with uninterpreted values` });
+            if (unknown && retained && modeled) {
+                if (file.size * 2 > (context.limits.workbookTextBytes ?? context.limits.inputBytes * 2))
+                    throw new SsconvertError("resource-limit", "ssconvert BIFF property retention limit exceeded");
+                let encoded = "";
+                for (let at = 0; at < file.size;) {
+                    const chunk = await file.read(at, Math.min(16384, file.size - at));
+                    encoded += Array.from(chunk, byte => byte.toString(16).padStart(2, "0")).join("");
+                    at += chunk.length;
+                }
+                const hex = accountText(encoded);
+                retained.push({ source: "biff", kind: "ole-properties", disposition: "retained", data: { stream: streamName, bytes: hex, modeled } });
+                await context.diagnostic?.({ code: "biff-loss-warning", severity: "warning", message: `BIFF property stream ${streamName.slice(1)} retained with uninterpreted values` });
+            }
+        }
+    }
+    catch (error) {
+        try {
+            await names?.close();
+        }
+        catch (cleanup) {
+            throw new AggregateError([error, cleanup], 'BIFF property observation cleanup failed');
         }
+        throw error;
     }
+    await names?.close();
     return properties;
 }

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

@@ -0,0 +1,24 @@
+import { type CapabilityContext } from "../spreadsheet-engine/contracts.js";
+/** Exact UTF-16 identity, including empty names and embedded NULs. Calls are sequential.
+ * A bounded hash index points to name records; collisions use exact bounded comparisons. */
+export declare class BiffPropertyNames {
+    private readonly context;
+    private readonly charge;
+    private readonly storage;
+    private readonly index;
+    private readonly fallback;
+    private initialized;
+    private pending;
+    private closed;
+    private closing;
+    constructor(context: CapabilityContext, charge: (amount: number) => void);
+    private check;
+    private io;
+    private allocate;
+    private read;
+    private fingerprint;
+    private contains;
+    has(name: string): Promise<boolean>;
+    add(name: string): Promise<void>;
+    close(): Promise<void>;
+}