@poe-platform/safe-bash 0.1.817 → 0.1.819

package/dist/spreadsheet-engine/formatting/cell-text.js

@@ -2,7 +2,7 @@ import { SsconvertError } from "../contracts.js";
 import { cellValueFormat } from "../workbook/value-format.js";
 import { formatText } from "./number-format.js";
 import { parseFormatSections, selectFormatSection } from "./sections.js";
-import { formatGeneralNumber } from "../rendering/print/general-number.js";
+import { formatGeneralNumber } from "./general-number.js";
 import { scanFormat } from "./numeric.js";
 import { formattingLocale, localizedValueText } from "./locale.js";
 function checkedText(text, context) {

package/dist/spreadsheet-engine/{rendering/print → formatting}/general-number.js

@@ -1,6 +1,6 @@
-import { SsconvertError } from "../../contracts.js";
-import { fixedNumber } from "../../formatting/number-format.js";
-import { formattingLocale } from "../../formatting/locale.js";
+import { SsconvertError } from "../contracts.js";
+import { fixedNumber } from "./number-format.js";
+import { formattingLocale } from "./locale.js";
 /** Native General precision selection, measured in the caller's font units. */
 export function formatGeneralNumber(value, initial, width, measure, locale, tick, unicodeMinus = true) {
     const decimal = formattingLocale(locale).decimal;

package/dist/spreadsheet-engine/formulas/functions/python-printf.js

@@ -37,9 +37,10 @@ function* pythonText(profile, value, repr, ascii, host) {
     }
     if (typeof value === "object") {
         if ("range" in value) {
-            // Precision may stop before the address, whose native bytes are unstable.
-            yield* "<RangeRef object at 0x";
-            throw new SsconvertError("unsupported-feature", "Unsupported ssconvert feature: Python RangeRef object representation");
+            // CPython uses a process address. The portable loader uses an opaque,
+            // call-local identity for each newly allocated reference wrapper instead.
+            yield* "<RangeRef object at 0x" + value.range.toString(16) + ">";
+            return;
         }
         yield "[";
         for (let column = 0; column < value.columns.length; column++) {
@@ -82,7 +83,7 @@ function* pythonText(profile, value, repr, ascii, host) {
     }
     yield quote;
 }
-function pythonValue(value, host, argument = true) {
+function pythonValue(value, host, references, argument = true) {
     host.tick();
     // The node loader evaluates arguments without PERMIT_EMPTY; array children
     // are converted directly and retain Python None for empty Gnumeric values.
@@ -93,10 +94,10 @@ function pythonValue(value, host, argument = true) {
         return null;
     }
     if (value.kind === "range")
-        return { range: true };
+        return { range: ++references.count };
     if (value.kind === "matrix" || value.kind === "set") {
         const rows = host.matrix(value).rows;
-        return { columns: Array.from({ length: rows[0]?.length ?? 0 }, (_, column) => rows.map(row => pythonValue(row[column], host, false))) };
+        return { columns: Array.from({ length: rows[0]?.length ?? 0 }, (_, column) => rows.map(row => pythonValue(row[column], host, references, false))) };
     }
     // Both Python C-string acquisition and returned Gnumeric strings stop at NUL.
     return typeof value.value === "string" ? rendered(value).split("\0", 1)[0] : value.value;
@@ -170,7 +171,8 @@ function decimalFloat(value, kind, precision, alternate, host) {
 export function pythonPrintf(profile, args, host) {
     if (!args.length)
         return { kind: "error", value: "Python exception (<class 'TypeError'>: func_printf() missing 1 required positional argument: 'format')" };
-    const values = args.map(value => pythonValue(value, host)), format = values[0];
+    const references = { count: 0 };
+    const values = args.map(value => pythonValue(value, host, references)), format = values[0];
     // Activated 1.12.61 loaders on CPython 3.12 and 3.14 wrap the sample's
     // GnumericError rather than recognizing it in py_exc_to_string.
     if (typeof format !== "string")
@@ -221,7 +223,7 @@ export function pythonPrintf(profile, args, host) {
                 if (flag === "#")
                     alternate = true;
             }
-            const operand = () => {
+            const operand = (isPrecision = false) => {
                 if (chars[index] === "*") {
                     index++;
                     const value = take();
@@ -233,7 +235,9 @@ export function pythonPrintf(profile, args, host) {
                 while (chars[index] !== undefined && chars[index] >= "0" && chars[index] <= "9") {
                     host.tick();
                     count = count * 10 + Number(chars[index++]);
-                    if (count > limit)
+                    if (isPrecision && count > 2147483647)
+                        throw new PythonFormatError("ValueError", "precision too big");
+                    if (!isPrecision && count > limit)
                         throw new SsconvertError("resource-limit", "ssconvert calculation text limit exceeded");
                 }
                 return count;
@@ -242,7 +246,7 @@ export function pythonPrintf(profile, args, host) {
             let precision;
             if (chars[index] === ".") {
                 index++;
-                precision = operand();
+                precision = operand(true);
             }
             if (chars[index] !== undefined && "hlL".includes(chars[index]))
                 index++;
@@ -280,6 +284,8 @@ export function pythonPrintf(profile, args, host) {
             else if ("diuoxXeEfFgG".includes(conversion)) {
                 if (typeof value !== "number" && typeof value !== "boolean" || "oxX".includes(conversion) && typeof value !== "boolean")
                     throw new PythonFormatError("TypeError", "numeric conversion requires a number");
+                if (precision !== undefined && precision > limit)
+                    throw new SsconvertError("resource-limit", "ssconvert calculation text limit exceeded");
                 const number = Number(value), negative = number < 0 || Object.is(number, -0);
                 numeric = true;
                 sign = negative ? "-" : plus ? "+" : space ? " " : "";

package/dist/spreadsheet-engine/solver/program.js

@@ -136,9 +136,10 @@ export class SolverProgram {
         const columns = [];
         for (let i = 0; i < n; i++) {
             const lo = this.lower[i], hi = this.upper[i], start = origin[i];
-            const end = lo === hi ? start : this.model.domains[i] !== 'continuous' && hi - lo === 1 ? hi : start + 1 <= hi ? start + 1 : start - 1 >= hi ? start - 1 : start !== hi ? (start + hi) / 2 : (start + lo) / 2;
+            const end = lo === hi ? start : this.model.domains[i] !== 'continuous' && hi - lo === 1 ? hi : start + 1 <= hi ? start + 1 : start - 1 >= lo ? start - 1 : start !== hi ? (start + hi) / 2 : (start + lo) / 2;
             const dx = end - start;
-            if (!(dx > 0)) {
+            // A finite backward probe carries the same affine slope as a forward probe.
+            if (dx === 0) {
                 columns.push(addresses.map(() => 0));
                 continue;
             }

package/dist/spreadsheet-engine/solver/run.js

@@ -4,7 +4,7 @@ import { loadSolverParameters, validateSolverParametersSteps, selectSolverAlgori
 import { SolverBudget, solveLinearSteps } from "./linear.js";
 import { SolverProgram } from "./program.js";
 import { solveNonlinearSteps } from "./nonlinear.js";
-import { linearSensitivity } from "./sensitivity.js";
+import { linearSensitivitySteps } from "./sensitivity.js";
 import { createProgramReport, createSensitivityReport } from "./report.js";
 export const solverAlgorithms = Object.freeze([
     Object.freeze({ id: 'glpk', modelType: 'linear', available: true }),
@@ -50,6 +50,12 @@ export async function runSolverValidation(book, context, registry = solverAlgori
             }
             const result = await runCooperatively(solveLinearSteps(linear.rows, linear.objective, model.domains, budget), context.signal);
             solution = result.quality === 'infeasible' || result.quality === 'unbounded' ? undefined : result.solution;
+            // Linearization substitutes fixed inputs into the affine constants, leaving
+            // zero columns. Restore those coordinates before recalculation and reports.
+            if (solution) {
+                budget.tick(model.variables.length);
+                solution = solution.map((value, i) => program.lower[i] === program.upper[i] ? program.lower[i] : value);
+            }
             if (algorithm.id === 'glpk' && model.options.sensitivityReport && (result.quality === 'infeasible' || result.quality === 'unbounded' || model.domains.some(d => d !== 'continuous'))) {
                 await warning('Solver: Solver ran, but failed');
                 return book;
@@ -65,7 +71,7 @@ export async function runSolverValidation(book, context, registry = solverAlgori
             else if (result.quality === 'optimal') {
                 quality = algorithm.id === 'glpk' && model.domains.every(d => d === 'continuous') ? 'Feasible' : 'Optimal';
                 if (model.options.sensitivityReport && solution && model.domains.every(d => d === 'continuous'))
-                    sensitivity = linearSensitivity(linear.rows, linear.objective, solution, budget);
+                    sensitivity = await runCooperatively(linearSensitivitySteps(linear.rows, linear.objective, solution, budget), context.signal);
             }
         }
     }

package/dist/spreadsheet-engine/solver/sensitivity.d.ts

@@ -1,4 +1,4 @@
-import type { LinearRow, SolverBudget } from "./linear.js";
+import { type LinearRow, type SolverBudget } from "./linear.js";
 export interface SensitivityEntry {
     readonly low: number;
     readonly high: number;
@@ -9,4 +9,6 @@ export interface Sensitivity {
     readonly constraints: readonly SensitivityEntry[];
 }
 /** Active-basis sensitivity for continuous linear programs, with shared bounded arithmetic. */
-export declare function linearSensitivity(rows: readonly LinearRow[], objective: readonly number[], solution: readonly number[], budget: SolverBudget): Sensitivity;
+export declare function linearSensitivitySteps(rows: readonly LinearRow[], objective: readonly number[], solution: readonly number[], budget: SolverBudget): Generator<void, Sensitivity>;
+/** Synchronous sensitivity inspection; conversions use the cooperative steps. */
+export declare function linearSensitivity(...args: Parameters<typeof linearSensitivitySteps>): Sensitivity;

package/dist/spreadsheet-engine/solver/sensitivity.js

@@ -1,53 +1,83 @@
+import { simplexSteps } from "./linear.js";
 /** Active-basis sensitivity for continuous linear programs, with shared bounded arithmetic. */
-export function linearSensitivity(rows, objective, solution, budget) {
+export function* linearSensitivitySteps(rows, objective, solution, budget) {
     const n = objective.length;
     budget.tick(n * n + rows.length * n);
-    const basis = [], echelon = [];
-    for (let i = 0; i < rows.length && basis.length < n; i++) {
-        const row = rows[i];
-        const activity = row.coefficients.reduce((sum, v, j) => sum + v * solution[j], 0);
-        if (Math.abs(activity - row.upper) > 1e-7 * Math.max(1, Math.abs(row.upper)))
-            continue;
-        const vector = [...row.coefficients];
-        for (const b of echelon) {
-            const pivot = b.findIndex(v => Math.abs(v) > 1e-10), multiplier = vector[pivot];
-            for (let j = 0; j < n; j++) {
-                budget.tick();
-                vector[j] = vector[j] - multiplier * b[j];
-            }
-        }
-        const pivot = vector.findIndex(v => Math.abs(v) > 1e-10);
-        if (pivot === -1)
-            continue;
-        const scale = vector[pivot];
-        echelon.push(vector.map(v => v / scale));
-        basis.push(i);
-    }
     const missing = () => ({ low: NaN, high: NaN, shadow: NaN });
-    if (basis.length !== n)
-        return { variables: objective.map(missing), constraints: rows.map(missing) };
-    const inverse = basis.map((i, j) => [...rows[i].coefficients, ...objective.map((_, k) => Number(j === k))]);
-    for (let j = 0; j < n; j++) {
-        let pivot = j;
-        for (let i = j + 1; i < n; i++)
-            if (Math.abs(inverse[i][j]) > Math.abs(inverse[pivot][j]))
-                pivot = i;
-        [inverse[j], inverse[pivot]] = [inverse[pivot], inverse[j]];
-        const divisor = inverse[j][j];
-        for (let k = 0; k < n * 2; k++) {
-            budget.tick();
-            inverse[j][k] = inverse[j][k] / divisor;
-        }
-        for (let i = 0; i < n; i++)
-            if (i !== j) {
-                const multiplier = inverse[i][j];
-                for (let k = 0; k < n * 2; k++) {
+    const unavailable = () => ({ variables: objective.map(missing), constraints: rows.map(missing) });
+    const active = rows.flatMap((row, i) => {
+        const activity = row.coefficients.reduce((sum, v, j) => sum + v * solution[j], 0);
+        return Math.abs(activity - row.upper) <= 1e-7 * Math.max(1, Math.abs(row.upper)) ? [i] : [];
+    });
+    const makeBasis = (order) => {
+        const basis = [], echelon = [];
+        for (const i of order) {
+            if (basis.length === n)
+                break;
+            const vector = [...rows[i].coefficients];
+            for (const b of echelon) {
+                const pivot = b.findIndex(v => Math.abs(v) > 1e-10), multiplier = vector[pivot];
+                for (let j = 0; j < n; j++) {
                     budget.tick();
-                    inverse[i][k] = inverse[i][k] - multiplier * inverse[j][k];
+                    vector[j] = vector[j] - multiplier * b[j];
                 }
             }
+            const pivot = vector.findIndex(v => Math.abs(v) > 1e-10);
+            if (pivot === -1)
+                continue;
+            const scale = vector[pivot];
+            echelon.push(vector.map(v => v / scale));
+            basis.push(i);
+        }
+        if (basis.length !== n)
+            return undefined;
+        budget.tick(n * n * 2);
+        const inverse = basis.map((i, j) => [...rows[i].coefficients, ...objective.map((_, k) => Number(j === k))]);
+        for (let j = 0; j < n; j++) {
+            let pivot = j;
+            for (let i = j + 1; i < n; i++)
+                if (Math.abs(inverse[i][j]) > Math.abs(inverse[pivot][j]))
+                    pivot = i;
+            [inverse[j], inverse[pivot]] = [inverse[pivot], inverse[j]];
+            const divisor = inverse[j][j];
+            for (let k = 0; k < n * 2; k++) {
+                budget.tick();
+                inverse[j][k] = inverse[j][k] / divisor;
+            }
+            for (let i = 0; i < n; i++)
+                if (i !== j) {
+                    const multiplier = inverse[i][j];
+                    for (let k = 0; k < n * 2; k++) {
+                        budget.tick();
+                        inverse[i][k] = inverse[i][k] - multiplier * inverse[j][k];
+                    }
+                }
+        }
+        const dual = basis.map((_, i) => objective.reduce((sum, c, j) => sum + c * inverse[j][n + i], 0));
+        return { basis, inverse, dual };
+    };
+    let selected = makeBasis(active);
+    if (!selected)
+        return unavailable();
+    if (!selected.dual.every(value => Number.isFinite(value) && value >= -1e-10)) {
+        // A degenerate vertex can have independent active rows whose dual is
+        // infeasible. Find nonnegative multipliers A' * lambda = c, then extend
+        // their independent support with zero-multiplier active rows.
+        budget.tick(2 * n * active.length);
+        const equations = objective.flatMap((value, column) => {
+            const coefficients = active.map(i => rows[i].coefficients[column]);
+            return [{ coefficients, upper: value }, { coefficients: coefficients.map(v => -v), upper: -value }];
+        });
+        const feasible = yield* simplexSteps(equations, active.map(() => 0), budget);
+        if (feasible.quality !== 'optimal' || !feasible.solution)
+            return unavailable();
+        const positive = active.filter((_, i) => feasible.solution[i] > 0);
+        const zero = active.filter((_, i) => feasible.solution[i] <= 0);
+        selected = makeBasis([...positive, ...zero]);
+        if (!selected || !selected.dual.every(value => Number.isFinite(value) && value >= -1e-10))
+            return unavailable();
     }
-    const dual = basis.map((_, i) => objective.reduce((sum, c, j) => sum + c * inverse[j][n + i], 0));
+    const { basis, inverse, dual } = selected;
     const variables = objective.map((c, j) => {
         let low = -Infinity, high = Infinity;
         for (let i = 0; i < n; i++) {
@@ -80,3 +110,11 @@ export function linearSensitivity(rows, objective, solution, budget) {
     });
     return { variables, constraints };
 }
+/** Synchronous sensitivity inspection; conversions use the cooperative steps. */
+export function linearSensitivity(...args) {
+    const steps = linearSensitivitySteps(...args);
+    let result = steps.next();
+    while (!result.done)
+        result = steps.next();
+    return result.value;
+}

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

@@ -1,3 +1,4 @@
+import { BiffPropertyNames } from './biff-property-names.js';
 import type { BiffPropertySource } from './biff-encrypted-properties-write.js';
 import { type CapabilityContext, type RangeSource } from "../spreadsheet-engine/contracts.js";
 import type { UnsupportedRecord, Workbook } from "../spreadsheet-ast/index.js";
@@ -5,4 +6,4 @@ import type { UnsupportedRecord, Workbook } from "../spreadsheet-ast/index.js";
 export declare function mergeBiffProperties(book: Workbook, streams: Map<string, Uint8Array | RangeSource>, handled: Set<UnsupportedRecord>, context: CapabilityContext, charge: (amount: number) => void, allocate: (length: number) => Uint8Array, staged?: {
     sources: Map<string, BiffPropertySource>;
     reserve: (length: number) => number;
-}): Promise<ReadonlySet<string>>;
+}, preserved?: Pick<BiffPropertyNames, "add">): Promise<void>;

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

@@ -1,3 +1,5 @@
+import { BiffPropertyNames } from './biff-property-names.js';
+import { BiffOriginalProperties } from './biff-property-observations.js';
 import { BiffMutablePropertyValues } from './biff-property-values.js';
 import { createBiffPropertyNameEncoder } from "./biff-property-name.js";
 import { readBiffPropertyText } from "./biff-property-text.js";
@@ -8,10 +10,9 @@ import { Binary, invalidBiff } from "./biff-binary.js";
 import { biffPropertyFields, biffPropertyFormats, readBiffProperties } from "./biff-properties.js";
 import { propertyRange, readPropertySectionRanges, withPropertyValueRanges } from "./biff-property-range.js";
 /** Rebuild offsets around original opaque spans. Never transcode their codepage. */
-export async function mergeBiffProperties(book, streams, handled, context, charge, allocate, staged) {
+export async function mergeBiffProperties(book, streams, handled, context, charge, allocate, staged, preserved) {
     const canonical = (name) => ["\u0005SummaryInformation", "\u0005DocumentSummaryInformation"].find(target => target.toUpperCase() === name.toUpperCase());
     const snapshots = new Map(), duplicates = new Set();
-    const preserved = new Set();
     let nodes = 0, textBytes = 0;
     const admit = (amount) => {
         charge(amount);
@@ -85,7 +86,7 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
         for (const name of duplicates)
             snapshots.delete(name);
         if (!snapshots.size)
-            return preserved;
+            return;
         const parse = async (input) => {
             const file = propertyRange(input, context), sections = [];
             for await (const section of readPropertySectionRanges(file, admit, charge, context)) {
@@ -117,12 +118,22 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
             }
             return new Binary(bytes);
         };
-        const original = new Map(), pending = new Map();
-        const identity = (property) => `${property.stream}:${property.section}:${property.id}`;
+        const same = (a, b) => {
+            if (!Array.isArray(a) || !Array.isArray(b))
+                return Object.is(a, b);
+            charge(a.length + b.length);
+            return a.length === b.length && a.every((value, i) => Object.is(value, b[i]));
+        };
+        const original = new BiffOriginalProperties(context, charge), pending = new Map();
+        temporarySources.push(original);
         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); }, false);
-        await readBiffProperties(streams, readContext, accountText, charge, undefined, property => { admit(1); pending.set(property.key, property); }, false);
+        await readBiffProperties(new Map([...snapshots].map(([name, value]) => [name, value.bytes])), readContext, accountText, charge, undefined, async (property) => {
+            admit(1);
+            const { stream, section, id, key } = property;
+            await original.add({ stream, section, id, key, unchanged: same(property.value, book.properties?.[key]) });
+        }, false);
+        await readBiffProperties(streams, readContext, accountText, charge, undefined, property => { admit(1); const { stream, section, id, key } = property; pending.set(key, { stream, section, id, key }); }, false);
         const chunks = async function* (source) {
             for (let at = 0; at < source.size;) {
                 const bytes = await source.read(at, source.size - at);
@@ -232,48 +243,43 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
                 view.setUint16(8 + i * 2, value.charCodeAt(i), true);
             return propertyRange(bytes, context);
         };
-        const same = (a, b) => {
-            if (!Array.isArray(a) || !Array.isArray(b))
-                return Object.is(a, b);
-            charge(a.length + b.length);
-            return a.length === b.length && a.every((value, i) => Object.is(value, b[i]));
-        };
         for (const [name, snapshot] of snapshots) {
-            const seen = new Set();
-            function* modeled() {
+            const seen = new BiffPropertyNames(context, charge);
+            temporarySources.push(seen);
+            async 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()) {
+                for await (const property of original.values()) {
                     charge(1);
                     if (property.stream !== name)
                         continue;
                     if (name === "\u0005SummaryInformation" || snapshots.has("\u0005SummaryInformation") ||
-                        Object.hasOwn(book.properties ?? {}, property.key) && same(property.value, book.properties?.[property.key])) {
+                        Object.hasOwn(book.properties ?? {}, property.key) && property.unchanged) {
                         admit(1);
                         yield [property.section, property.id, property.key];
                     }
                 }
             }
-            for (const entry of modeled()) {
+            for await (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");
                 const [offset, id, key] = entry;
-                const property = original.get(identity({ stream: name, section: offset, id }));
-                if (!property || property.key !== key || seen.has(key))
+                const property = await original.get(name, offset, id);
+                if (!property || property.key !== key || await seen.has(key))
                     invalidBiff("invalid retained property identity");
-                seen.add(key);
+                await seen.add(key);
                 charge(old.get(name).length);
                 const section = old.get(name).find(section => section.offset === offset);
-                const value = book.properties?.[key], replacement = pending.get(key);
+                const replacement = pending.get(key);
                 if (!Object.hasOwn(book.properties ?? {}, key))
                     await remove(section, id);
-                else if (same(property.value, value)) {
-                    preserved.add(key);
+                else if (property.unchanged) {
+                    await preserved?.add(key);
                     if (replacement)
                         await take(replacement);
                 }
@@ -451,13 +457,14 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
             if (snapshot)
                 handled.add(snapshot.record);
         }
-        const exposed = new Set();
-        await readBiffProperties(staged?.sources ?? streams, readContext, accountText, charge, undefined, property => {
+        const exposed = new BiffPropertyNames(context, charge);
+        temporarySources.push(exposed);
+        await readBiffProperties(staged?.sources ?? streams, readContext, accountText, charge, undefined, async (property) => {
             admit(1);
             if (!Object.hasOwn(book.properties ?? {}, property.key))
-                exposed.add(property.key);
+                await exposed.add(property.key);
         }, false);
-        for (const key of exposed)
+        for await (const key of exposed.values())
             await warn(key, "opaque property exposes a field absent from the model");
     }
     catch (error) {
@@ -470,5 +477,4 @@ export async function mergeBiffProperties(book, streams, handled, context, charg
         throw error;
     }
     await closeTemporary();
-    return preserved;
 }

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-property-names.d.ts

@@ -8,6 +8,8 @@ export declare class BiffPropertyNames {
     private readonly index;
     private readonly fallback;
     private initialized;
+    private first;
+    private last;
     private pending;
     private closed;
     private closing;
@@ -20,5 +22,6 @@ export declare class BiffPropertyNames {
     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

@@ -10,6 +10,8 @@ export class BiffPropertyNames {
     index;
     fallback;
     initialized = false;
+    first = 0;
+    last = 0;
     pending = Promise.resolve();
     closed = false;
     closing;
@@ -145,7 +147,7 @@ export class BiffPropertyNames {
         finally {
             buffer.fill(0);
         }
-        const record = new Uint8Array(24), descriptor = new DataView(record.buffer);
+        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);
@@ -158,6 +160,47 @@ export class BiffPropertyNames {
         }
         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;