@poe-platform/safe-bash 0.1.813 → 0.1.815

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

@@ -1,6 +1,7 @@
+import { visitBiffPropertyDictionary } from './biff-property-dictionary.js';
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { invalidBiff } from "./biff-binary.js";
-import { propertyRange, readPropertySectionRanges, readPropertyValueRanges } from "./biff-property-range.js";
+import { propertyRange, readPropertySectionRanges, withPropertyValueRanges } from "./biff-property-range.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.
@@ -43,125 +44,109 @@ export async function readBiffProperties(streams, context, accountText, accountW
             continue;
         const file = propertyRange(bytes, context);
         accountWork(file.size);
-        const sections = await readPropertySectionRanges(file, admit, accountWork);
+        const sections = readPropertySectionRanges(file, admit, accountWork, context);
         let unknown = false;
         const modeled = [];
-        for (const { guid, offset, end } of sections) {
+        for await (const { guid, offset, end } of sections) {
             if (!biffPropertyFields.has(guid) && guid !== custom) {
                 unknown = true;
                 continue;
             }
-            const values = await readPropertyValueRanges(file.slice(offset, end - offset), admit, accountWork);
-            const cp = 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 names = new Map(), dictionary = values.get(0);
-            try {
-                if (dictionary && guid === custom) {
-                    const length = await dictionary.u32(0);
-                    dictionary.check(4, length * 9);
-                    admit(length);
-                    let at = 4;
-                    for (let i = 0; i < length; i++) {
-                        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);
-                        at = entry.end;
-                    }
+            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);
                 }
-            }
-            catch (error) {
-                if (!(error instanceof SsconvertError) || error.code !== "unsupported-feature")
-                    throw error;
-                unknown = true;
-                continue;
-            }
-            for (const [id, data] of values) {
-                context.signal.throwIfAborted();
-                if (id < 2)
-                    continue;
-                const key = guid === custom ? names.get(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");
-                    }
-                    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`;
+                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;
                         }
-                        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;
+                        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 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);
+                        properties[key] = value;
+                        modeled.push([offset, id, key]);
+                        observe?.({ stream: streamName, section: offset, id, key, value });
                     }
-                }
-                catch (error) {
-                    if (!(error instanceof SsconvertError) || error.code !== "unsupported-feature")
-                        throw error;
-                }
-                if (value === undefined) {
+                });
+                if (!supported)
                     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 (unknown && retained) {
             if (file.size * 2 > (context.limits.workbookTextBytes ?? context.limits.inputBytes * 2))

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

@@ -0,0 +1,5 @@
+import { type CapabilityContext } from "../spreadsheet-engine/contracts.js";
+import { type BiffPropertyRange } from './biff-property-range.js';
+/** Validate/account names once, retain only coordinates, and decode on lookup.
+ * Unsupported dictionary codepages skip the visitor so the caller retains the section. */
+export declare function visitBiffPropertyDictionary(data: BiffPropertyRange | undefined, codepage: number, context: CapabilityContext, admit: (count: number) => void, accountText: (text: string) => string, accountWork: (amount: number) => void, visit: (get: (id: number) => Promise<string | undefined>) => Promise<void>): Promise<boolean>;

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

@@ -0,0 +1,75 @@
+import { IntegerTable } from "@poe-platform/safe-fs/storage";
+import { SsconvertError } from "../spreadsheet-engine/contracts.js";
+import { invalidBiff } from './biff-binary.js';
+import { propertyIndexStorage } from './biff-property-range.js';
+import { readBiffPropertyText } from './biff-property-text.js';
+/** Validate/account names once, retain only coordinates, and decode on lookup.
+ * Unsupported dictionary codepages skip the visitor so the caller retains the section. */
+export async function visitBiffPropertyDictionary(data, codepage, context, admit, accountText, accountWork, visit) {
+    const count = data ? await data.u32(0) : 0;
+    if (data) {
+        data.check(4, count * 9);
+        admit(count);
+    }
+    const storage = data && context.createWorkingStorage?.();
+    let active = true, supported = true;
+    const check = () => {
+        context.signal.throwIfAborted();
+        data?.check(0, 0);
+        if (!active)
+            throw new SsconvertError('invalid-request', 'BIFF property dictionary index is closed');
+    };
+    try {
+        const backing = storage && propertyIndexStorage(storage, data);
+        backing?.allocate(8);
+        const index = backing ? new IntegerTable(backing, 64) : new Map();
+        let at = 4;
+        for (let i = 0; i < count; i++) {
+            const id = await data.u32(at);
+            let entry;
+            try {
+                entry = await readBiffPropertyText(data, at + 4, codepage, context, accountText, accountWork);
+            }
+            catch (error) {
+                if (!(error instanceof SsconvertError) || error.code !== 'unsupported-feature')
+                    throw error;
+                supported = false;
+                break;
+            }
+            if (id < 2 || await index.get(BigInt(id)) !== undefined || !entry.value)
+                invalidBiff('invalid property dictionary entry');
+            check();
+            await index.set(BigInt(id), BigInt(at + 4));
+            check();
+            at = entry.end;
+        }
+        if (supported)
+            await visit(async (id) => {
+                check();
+                const position = await index.get(BigInt(id));
+                check();
+                if (position === undefined)
+                    return undefined;
+                const entry = await readBiffPropertyText(data, Number(position), codepage, context, text => text, accountWork);
+                check();
+                return entry.value;
+            });
+        check();
+    }
+    catch (error) {
+        try {
+            await storage?.close();
+        }
+        catch (cleanup) {
+            throw new AggregateError([error, cleanup], 'BIFF property dictionary and cleanup failed');
+        }
+        throw error;
+    }
+    finally {
+        active = false;
+    }
+    await storage?.close();
+    context.signal.throwIfAborted();
+    data?.check(0, 0);
+    return supported;
+}

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-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>;
+}