@poe-platform/safe-bash 0.1.816 → 0.1.818

package/dist/safe-bash-xml-engine/index.js

@@ -3,10 +3,10 @@ import {
 } from "../safe-bash/command-chunks/chunk-LNKZVU5V.js";
 import {
   serializeDocument
-} from "../safe-bash/command-chunks/chunk-DBZCTL7C.js";
+} from "../safe-bash/command-chunks/chunk-4Z7PBIMP.js";
 import {
   parseStoredXml
-} from "../safe-bash/command-chunks/chunk-RINR7XPR.js";
+} from "../safe-bash/command-chunks/chunk-MMSKDYK6.js";
 import {
   escape,
   evaluate,

package/dist/safe-bash-xml-engine/recovery.d.ts

@@ -1,7 +1,11 @@
-import { parseXmlSourceSteps, type XmlElement } from "@poe-platform/safe-fs/core";
+import { parseXmlSourceSteps, type XmlElement, type XmlAttribute } from "@poe-platform/safe-fs/core";
 import { type PagedStorageContext } from "@poe-platform/safe-fs/storage";
 import { XmlBudget } from "./limits.js";
-type XmlEvent = Parameters<NonNullable<NonNullable<Parameters<typeof parseXmlSourceSteps>[1]>["events"]>>[0];
+type XmlEvent = Parameters<NonNullable<NonNullable<Parameters<typeof parseXmlSourceSteps>[1]>["events"]>>[0] | {
+    type: "attribute";
+    attribute: XmlAttribute;
+    element: XmlElement;
+};
 /** Parse lazy input, or prevalidated recovery input, through a shared 64 KiB source/frame cache.
  * The parser retains only its current source window, tokens and the current frame. */
 export declare function parseStoredXml(source: AsyncIterable<string> | Iterable<string>, context: PagedStorageContext & {

package/dist/safe-bash-xml-engine/stored-document.d.ts

@@ -1,5 +1,6 @@
 import { type XmlAttribute, type XmlContent } from "@poe-platform/safe-fs/core";
 import { PagedStorage, type PagedStorageContext } from "@poe-platform/safe-fs/storage";
+import { StoredStringMap as StoredNamespaces } from "./stored-map.js";
 import { XmlBudget } from "./limits.js";
 export type StoredXmlAttribute = {
     kind: "attribute";
@@ -24,6 +25,8 @@ export declare class StoredXmlDocument {
     private append;
     /** Buffering convenience API; engine traversal uses metadata and attribute links. */
     node(reference: number): Promise<XmlContent | StoredXmlAttribute>;
+    namespaceScope(reference: number): Promise<StoredNamespaces>;
+    /** Load scalar metadata only; attributes and namespace scopes have separate iterators. */
     metadata(reference: number): Promise<XmlContent | StoredXmlAttribute>;
     /** Content bodies may span parser fragments or coalesced text tokens.
      * Replay them without making a concatenated node value. */

package/dist/safe-bash-xml-engine/stored-document.js

@@ -1,6 +1,6 @@
 import {
   StoredXmlDocument
-} from "../safe-bash/command-chunks/chunk-RINR7XPR.js";
+} from "../safe-bash/command-chunks/chunk-MMSKDYK6.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   StoredXmlDocument

package/dist/safe-bash-xml-engine/stored-evaluate.js

@@ -82,7 +82,7 @@ var StoredXPath = class {
     } else yield* this.document.children(reference, attributes);
   }
   async select(query, context = this.document.document) {
-    const root = await this.document.metadata(this.document.root);
+    const namespaces = await this.document.namespaceScope(this.document.root);
     const union = new StoredSelection(this);
     for (const path of query.paths) {
       let contexts = new StoredSelection(this);
@@ -90,7 +90,7 @@ var StoredXPath = class {
       for (const step of path) {
         const colon = step.name.indexOf(":");
         const prefix = colon < 0 ? "" : step.name.slice(0, colon);
-        const namespace = colon < 0 ? "" : root.namespaces.get(prefix);
+        const namespace = colon < 0 ? "" : await namespaces.get(prefix);
         if (namespace === void 0) throw new XmlQueryError(`undefined XPath namespace prefix: ${prefix}`, 10);
         const localName = colon < 0 ? step.name : step.name.slice(colon + 1);
         const parents = new StoredSelection(this);

package/dist/safe-bash-xml-engine/stored-map.d.ts

@@ -0,0 +1,21 @@
+import type { PagedStorage } from "@poe-platform/safe-fs/storage";
+import type { XmlBudget } from "./limits.js";
+/** Immutable AVL maps share unchanged subtrees in caller storage. AVL ancestry
+ * is bounded by safe-integer storage addresses (fewer than 80 levels), rather
+ * than XML depth or the number of entries. Individual keys and values still have
+ * the parser's token cost. */
+export declare class StoredStringMap {
+    private readonly storage;
+    private readonly budget;
+    readonly reference: number;
+    constructor(storage: PagedStorage, budget: XmlBudget, reference?: number);
+    private read;
+    private write;
+    get(key: string): Promise<string | undefined>;
+    private height;
+    private updated;
+    private rotate;
+    private balance;
+    set(key: string, value: string): Promise<StoredStringMap>;
+    [Symbol.asyncIterator](): AsyncGenerator<readonly [string, string]>;
+}

package/dist/safe-bash-zip-engine/index.js

@@ -9,14 +9,14 @@ import {
   streamZipArchive,
   updateZipExtras,
   writeZipArchive
-} from "../safe-bash/command-chunks/chunk-WXW665TV.js";
+} from "../safe-bash/command-chunks/chunk-ZSHXZ3XG.js";
 import "../safe-bash/command-chunks/chunk-FVQFB7OD.js";
 import "../safe-bash/command-chunks/chunk-3I3PD6VU.js";
+import "../safe-bash/command-chunks/chunk-CFK5CVU7.js";
 import "../safe-bash/command-chunks/chunk-ZNVKI6FP.js";
+import "../safe-bash/command-chunks/chunk-RYNTNJMA.js";
 import "../safe-bash/command-chunks/chunk-ORHPC5DZ.js";
-import "../safe-bash/command-chunks/chunk-CFK5CVU7.js";
 import "../safe-bash/command-chunks/chunk-7OZAH3MX.js";
-import "../safe-bash/command-chunks/chunk-RYNTNJMA.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   crc32,

package/dist/safe-bash-zip-engine/zip/repair.js

@@ -8,7 +8,7 @@ import {
   decodeZipEntry,
   readZipArchive,
   readZipIndexedArchive
-} from "../../safe-bash/command-chunks/chunk-WXW665TV.js";
+} from "../../safe-bash/command-chunks/chunk-ZSHXZ3XG.js";
 import {
   ZipRanges,
   joinZipSources,
@@ -19,11 +19,11 @@ import {
   zip64Fields,
   zipEnd
 } from "../../safe-bash/command-chunks/chunk-3I3PD6VU.js";
+import "../../safe-bash/command-chunks/chunk-CFK5CVU7.js";
 import "../../safe-bash/command-chunks/chunk-ZNVKI6FP.js";
+import "../../safe-bash/command-chunks/chunk-RYNTNJMA.js";
 import "../../safe-bash/command-chunks/chunk-ORHPC5DZ.js";
-import "../../safe-bash/command-chunks/chunk-CFK5CVU7.js";
 import "../../safe-bash/command-chunks/chunk-7OZAH3MX.js";
-import "../../safe-bash/command-chunks/chunk-RYNTNJMA.js";
 import "../../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-zip-engine/src/zip/repair.ts

package/dist/safe-bash-zip-engine/zip/safety.js

@@ -8,7 +8,7 @@ import {
   spoolZipSource,
   stageZip,
   unchangedZipSource
-} from "../../safe-bash/command-chunks/chunk-IHLZ6HNQ.js";
+} from "../../safe-bash/command-chunks/chunk-TSKJNCKD.js";
 import "../../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   ZipScope,

package/dist/safe-bash-zip-engine/zip/sfx.js

@@ -2,16 +2,16 @@ import {
   decodeZipEntry,
   readZipArchive,
   readZipIndexedArchive
-} from "../../safe-bash/command-chunks/chunk-WXW665TV.js";
+} from "../../safe-bash/command-chunks/chunk-ZSHXZ3XG.js";
 import {
   ZipRanges
 } from "../../safe-bash/command-chunks/chunk-FVQFB7OD.js";
 import "../../safe-bash/command-chunks/chunk-3I3PD6VU.js";
+import "../../safe-bash/command-chunks/chunk-CFK5CVU7.js";
 import "../../safe-bash/command-chunks/chunk-ZNVKI6FP.js";
+import "../../safe-bash/command-chunks/chunk-RYNTNJMA.js";
 import "../../safe-bash/command-chunks/chunk-ORHPC5DZ.js";
-import "../../safe-bash/command-chunks/chunk-CFK5CVU7.js";
 import "../../safe-bash/command-chunks/chunk-7OZAH3MX.js";
-import "../../safe-bash/command-chunks/chunk-RYNTNJMA.js";
 import "../../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-zip-engine/src/zip/sfx.ts

package/dist/safe-bash-zip-engine/zip/volumes.js

@@ -5,7 +5,7 @@ import {
   openZipSource,
   sameZipIdentity,
   stageZip
-} from "../../safe-bash/command-chunks/chunk-IHLZ6HNQ.js";
+} from "../../safe-bash/command-chunks/chunk-TSKJNCKD.js";
 import {
   ZipFailure
 } from "../../safe-bash/command-chunks/chunk-4REP6ZW6.js";

package/dist/safe-bash-zip-engine/zip-format.js

@@ -9,14 +9,14 @@ import {
   streamZipArchive,
   updateZipExtras,
   writeZipArchive
-} from "../safe-bash/command-chunks/chunk-WXW665TV.js";
+} from "../safe-bash/command-chunks/chunk-ZSHXZ3XG.js";
 import "../safe-bash/command-chunks/chunk-FVQFB7OD.js";
 import "../safe-bash/command-chunks/chunk-3I3PD6VU.js";
+import "../safe-bash/command-chunks/chunk-CFK5CVU7.js";
 import "../safe-bash/command-chunks/chunk-ZNVKI6FP.js";
+import "../safe-bash/command-chunks/chunk-RYNTNJMA.js";
 import "../safe-bash/command-chunks/chunk-ORHPC5DZ.js";
-import "../safe-bash/command-chunks/chunk-CFK5CVU7.js";
 import "../safe-bash/command-chunks/chunk-7OZAH3MX.js";
-import "../safe-bash/command-chunks/chunk-RYNTNJMA.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   crc32,

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")

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); });
-        await readBiffProperties(streams, readContext, accountText, charge, undefined, property => { admit(1); pending.set(property.key, property); });
+        await readBiffProperties(new Map([...snapshots].map(([name, value]) => [name, value.bytes])), readContext, accountText, charge, undefined, 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);
-        });
-        for (const key of exposed)
+                await exposed.add(property.key);
+        }, false);
+        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;
 }