@poe-platform/safe-bash 0.1.816 → 0.1.818

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

@@ -1,3 +1,4 @@
+import { BiffPropertyNames } from "./biff-property-names.js";
 import { propertyChunks, stagePropertyBytes } from "./biff-property-bytes.js";
 import { SsconvertError } from "../spreadsheet-engine/contracts.js";
 import { biffPropertyFields, biffPropertyFormats, isBiffKeywordSpace } from "./biff-properties.js";
@@ -6,7 +7,7 @@ const fieldByName = new Map([...biffPropertyFields].flatMap(([guid, fields]) =>
 const maximumFileTime = 0xffffffffffffffffn;
 /** Only discard a generic loss report when every XML field has been handled.
  * Keep the original record on the caller's workbook, including unknown content. */
-function handledPropertyRecord(record, keys, charge) {
+function handledPropertyRecord(record, properties, charge) {
     if (record.disposition !== "retained" || record.source !== "Gnumeric_XmlIO:sax" || record.kind !== "document-meta")
         return false;
     const office = "urn:oasis:names:tc:opendocument:xmlns:office:1.0", meta = "urn:oasis:names:tc:opendocument:xmlns:meta:1.0";
@@ -85,7 +86,7 @@ function handledPropertyRecord(record, keys, charge) {
                 return false;
         }
         const keyword = field.namespace === meta && field.name === "keyword";
-        if (key === undefined || !keys.has(key) || seen.has(key) && !(keyword && seen.get(key)))
+        if (key === undefined || !Object.prototype.propertyIsEnumerable.call(properties ?? {}, key) || seen.has(key) && !(keyword && seen.get(key)))
             return false;
         seen.set(key, keyword);
     }
@@ -141,7 +142,6 @@ function durationTicks(text) {
 }
 export async function writeBiffProperties(book, context, staged = false) {
     const planned = new Map(), sections = new Map();
-    const handledKeys = new Set();
     const unsupportedKeys = [];
     let work = 0, textBytes = 0, nodes = 0, payloadBytes = 0;
     const charge = (amount) => {
@@ -275,7 +275,6 @@ export async function writeBiffProperties(book, context, staged = false) {
             if (++nodes > (context.limits.workbookNodes ?? context.limits.outputBytes))
                 throw new SsconvertError("resource-limit", "ssconvert BIFF property node limit exceeded");
             const field = fieldByName.get(key);
-            handledKeys.add(key);
             let source = book.properties[key];
             if (key === "dc:keywords" && Array.isArray(source)) {
                 charge(source.length);
@@ -318,7 +317,7 @@ export async function writeBiffProperties(book, context, staged = false) {
     const handledMetadata = new Set();
     for (const record of book.unsupportedRecords ?? []) {
         charge(1);
-        if (handledPropertyRecord(record, handledKeys, charge))
+        if (handledPropertyRecord(record, book.properties, charge))
             handledMetadata.add(record);
     }
     if (names.length) {
@@ -399,6 +398,7 @@ export async function writeBiffProperties(book, context, staged = false) {
     const snapshots = (book.unsupportedRecords ?? []).some(record => record.source === "biff" && record.kind === "ole-properties" && record.disposition === "retained");
     const streams = new Map(), inputs = [];
     const sources = new Map();
+    let preserved;
     const close = async () => {
         const errors = [];
         for (const source of [...sources.values(), ...inputs])
@@ -408,6 +408,12 @@ export async function writeBiffProperties(book, context, staged = false) {
             catch (error) {
                 errors.push(error);
             }
+        try {
+            await preserved?.close();
+        }
+        catch (error) {
+            errors.push(error);
+        }
         if (errors.length === 1)
             throw errors[0];
         if (errors.length)
@@ -431,10 +437,13 @@ export async function writeBiffProperties(book, context, staged = false) {
                     streams.set(name, bytes);
                 }
             }
-        const preserved = await mergeBiffProperties(book, streams, handledMetadata, context, charge, allocate, staged ? { sources, reserve } : undefined);
+        if (snapshots && unsupportedKeys.length)
+            preserved = new BiffPropertyNames(context, charge);
+        await mergeBiffProperties(book, streams, handledMetadata, context, charge, allocate, staged ? { sources, reserve } : undefined, preserved);
         for (const key of unsupportedKeys)
-            if (!preserved.has(key))
+            if (!await preserved?.has(key))
                 await context.diagnostic?.({ code: "biff-loss-warning", severity: "warning", message: `Unsupported Excel BIFF document property: ${key}` });
+        await preserved?.close();
         if (!staged)
             return { streams, handledMetadata, async close() { } };
         for (const [name, value] of snapshots ? streams : planned)

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 = retained ? [] : undefined;
-        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 && 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` });
+            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,27 @@
+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 first;
+    private last;
+    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>;
+    values(): AsyncIterable<string>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,210 @@
+import { sha256 } from '@noble/hashes/sha2.js';
+import { IntegerTable } from "@poe-platform/safe-fs/storage";
+import { SsconvertError } 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 class BiffPropertyNames {
+    context;
+    charge;
+    storage;
+    index;
+    fallback;
+    initialized = false;
+    first = 0;
+    last = 0;
+    pending = Promise.resolve();
+    closed = false;
+    closing;
+    constructor(context, charge) {
+        this.context = context;
+        this.charge = charge;
+        this.storage = context.createWorkingStorage?.();
+        if (this.storage)
+            this.index = new IntegerTable({ allocate: length => this.allocate(length),
+                read: (at, length) => this.read(at, length),
+                write: async (at, bytes) => {
+                    const owned = new Uint8Array(bytes);
+                    try {
+                        await this.io(() => this.storage.write(at, owned));
+                    }
+                    finally {
+                        owned.fill(0);
+                    }
+                }
+            }, 64);
+        else
+            this.fallback = new Set();
+        context.own(() => this.close());
+    }
+    check() {
+        this.context.signal.throwIfAborted();
+        if (this.closed)
+            throw new SsconvertError('invalid-request', 'BIFF property name index is closed');
+    }
+    io(action) {
+        const result = this.pending.then(async () => { this.check(); const value = await action(); this.check(); return value; });
+        this.pending = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    allocate(length) {
+        this.check();
+        const position = this.storage.allocate(length);
+        this.check();
+        return position;
+    }
+    read(at, length) {
+        return this.io(async () => {
+            const bytes = await this.storage.read(at, length);
+            if (bytes.length !== length)
+                throw new SsconvertError('io', 'Truncated BIFF property name index');
+            return new Uint8Array(bytes);
+        });
+    }
+    fingerprint(name) {
+        const hash = sha256.create(), buffer = new Uint8Array(Math.min(16384, name.length * 2)), view = new DataView(buffer.buffer);
+        try {
+            for (let at = 0; at < name.length;) {
+                this.check();
+                const count = Math.min(buffer.length / 2, name.length - at);
+                for (let i = 0; i < count; i++)
+                    view.setUint16(i * 2, name.charCodeAt(at + i), true);
+                hash.update(buffer.subarray(0, count * 2));
+                at += count;
+            }
+            const digest = hash.digest();
+            return new DataView(digest.buffer, digest.byteOffset, digest.byteLength).getBigUint64(0, true);
+        }
+        finally {
+            buffer.fill(0);
+            hash.destroy();
+        }
+    }
+    async contains(name, head) {
+        let position = Number(head ?? 0n);
+        while (position) {
+            this.charge(1);
+            const record = new DataView((await this.read(position, 24)).buffer);
+            position = record.getFloat64(0, true);
+            if (record.getFloat64(8, true) !== name.length)
+                continue;
+            const start = record.getFloat64(16, true);
+            let same = true;
+            for (let at = 0; at < name.length;) {
+                const count = Math.min(8192, name.length - at);
+                this.charge(count);
+                const bytes = await this.read(start + at * 2, count * 2);
+                const view = new DataView(bytes.buffer);
+                for (let i = 0; i < count; i++)
+                    if (view.getUint16(i * 2, true) !== name.charCodeAt(at + i)) {
+                        same = false;
+                        break;
+                    }
+                if (!same)
+                    break;
+                at += count;
+            }
+            if (same)
+                return true;
+        }
+        return false;
+    }
+    async has(name) {
+        this.check();
+        this.charge(name.length + 1);
+        if (this.fallback)
+            return this.fallback.has(name);
+        const head = await this.index.get(this.fingerprint(name));
+        this.check();
+        return this.contains(name, head);
+    }
+    async add(name) {
+        this.check();
+        this.charge(name.length + 1);
+        if (this.fallback) {
+            this.fallback.add(name);
+            return;
+        }
+        if (!this.initialized) {
+            this.allocate(8);
+            this.check();
+            this.initialized = true;
+        }
+        const key = this.fingerprint(name), head = await this.index.get(key);
+        this.check();
+        if (await this.contains(name, head))
+            return;
+        const start = this.allocate(name.length * 2), buffer = new Uint8Array(Math.min(16384, name.length * 2));
+        const view = new DataView(buffer.buffer);
+        try {
+            for (let at = 0; at < name.length;) {
+                const count = Math.min(buffer.length / 2, name.length - at);
+                for (let i = 0; i < count; i++)
+                    view.setUint16(i * 2, name.charCodeAt(at + i), true);
+                await this.io(() => this.storage.write(start + at * 2, buffer.subarray(0, count * 2)));
+                at += count;
+            }
+        }
+        finally {
+            buffer.fill(0);
+        }
+        const record = new Uint8Array(32), descriptor = new DataView(record.buffer);
+        descriptor.setFloat64(0, Number(head ?? 0n), true);
+        descriptor.setFloat64(8, name.length, true);
+        descriptor.setFloat64(16, start, true);
+        const position = this.allocate(record.length);
+        try {
+            await this.io(() => this.storage.write(position, record));
+        }
+        finally {
+            record.fill(0);
+        }
+        await this.index.set(key, BigInt(position));
+        this.check();
+        if (this.last) {
+            const link = new Uint8Array(8);
+            new DataView(link.buffer).setFloat64(0, position, true);
+            try {
+                await this.io(() => this.storage.write(this.last + 24, link));
+            }
+            finally {
+                link.fill(0);
+            }
+        }
+        else
+            this.first = position;
+        this.last = position;
+    }
+    async *values() {
+        this.check();
+        if (this.fallback) {
+            for (const name of this.fallback) {
+                this.check();
+                yield name;
+            }
+            return;
+        }
+        let position = this.first;
+        while (position) {
+            const record = new DataView((await this.read(position, 32)).buffer);
+            const length = record.getFloat64(8, true), start = record.getFloat64(16, true);
+            position = record.getFloat64(24, true);
+            this.charge(length + 1);
+            let name = '';
+            for (let at = 0; at < length;) {
+                const count = Math.min(8192, length - at), bytes = await this.read(start + at * 2, count * 2);
+                const view = new DataView(bytes.buffer), units = new Uint16Array(count);
+                for (let i = 0; i < count; i++)
+                    units[i] = view.getUint16(i * 2, true);
+                name += String.fromCharCode(...units);
+                at += count;
+            }
+            yield name;
+        }
+        this.check();
+    }
+    close() {
+        this.closed = true;
+        this.fallback?.clear();
+        return this.closing ??= this.pending.then(async () => { await this.storage?.close(); });
+    }
+}