Release note · August 3, 2026

A benchmark for reviewing spreadsheet changes, not just editing them

By SybilGambleyyu · Workbook Change Assurance Benchmark 0.42.0

Spreadsheet tools are increasingly good at writing a formula or producing a finished workbook. The harder operational question comes afterward: a workbook changed—what changed, which other formulas can it reach, should it block a review, and what could the tool not determine? Workbook Change Assurance Benchmark (WCAB) is a small, open way to make those claims testable.

Version 0.42.0 contains 59 deterministic scenarios: 58 baseline/candidate workbook pairs and one directory portfolio. Together they declare 61 observable facts, a benchmark review disposition, and—where appropriate—a static dependency-impact lower bound. The files are generated from source in the repository, not copied from a financial model, email archive, or other sensitive corpus.

An external-workbook source can move without changing the formula

Excel’s workbook-link guidance includes Change source for pointing an existing link at another workbook. The Open XML ExternalBook reference describes the relationship-backed external workbook that supplies data to the current file. That creates a review surface a formula-text diff can miss.

Version 0.32.0 adds a compact, relationship-backed source-retarget case. LinkedModel!B2 keeps ='[WCABSource.xlsx]Inputs'!$B$2, and Dashboard!B4=LinkedModel!$B$2 remains its direct local consumer. The workbook external-reference binding, externalLink/externalBook declaration, source-sheet name, relationship IDs/types, content type, calculation properties, and all other package members remain fixed. Only xl/externalLinks/_rels/externalLink1.xml.rels changes: its one external Relationship/@Target moves between reserved example.invalid sources. The validator reads local OOXML only; it does not resolve, open, fetch, authenticate to, trust, refresh, calculate, or claim that a client updates a link or returns a value.

An external source can hide inside a local defined name

Microsoft’s workbook-link guidance calls out defined names as a place links can be used, and the Open XML DefinedNames reference describes the workbook-level collection that stores those expressions. A formula can therefore remain unchanged while the name it consumes points elsewhere.

WCAB 0.33.0 adds a local ScenarioRate name whose stored expression moves from '[WCABApprovedSource.xlsx]Inputs'!$B$2 to '[WCABReviewSource.xlsx]Inputs'!$B$2. Model!B2=ScenarioRate*2, its direct Dashboard!B4=Model!$B$2 consumer, calculation properties, sheet declarations, and workbook relationships remain fixed. Only xl/workbook.xml changes. The deliberately compact package has no externalReferences declaration and no externalLink part. The validator reads stored local OOXML only: it does not resolve, open, fetch, authenticate to, trust, refresh, calculate, or claim that a client resolves the name or returns a value.

A reusable LAMBDA can change without editing its caller

Microsoft’s LAMBDA guidance describes naming a LAMBDA in Name Manager so it becomes a reusable custom function throughout a workbook. The defined-names guidance likewise treats names as reusable formula definitions. That means a caller’s cell formula can stay byte-for-byte stable while its callable body changes.

WCAB 0.34.0 adds a workbook-scoped ScenarioValue definition whose stored expression moves from =LAMBDA(rate,amount,rate*amount) to =LAMBDA(rate,amount,rate*(amount+10)). Inputs!B2=0.08, Inputs!B3=100, Model!B2=ScenarioValue(Inputs!B2,Inputs!B3), and Dashboard!B4=Model!$B$2 remain fixed. Only xl/workbook.xml changes, and the compact package has neither externalReferences nor an externalLink part. The validator reads the stored definition only: it does not evaluate the LAMBDA, calculate a result, infer Excel-version support, or claim a client recalculates, spills, or persists a value.

A Table can store a formula master outside worksheet cells

Microsoft’s calculated-column guidance explains that a formula in one Excel Table column can fill through the column. The Open XML CalculatedColumnFormula reference identifies the Table-column child that stores that formula. It is a formula-definition surface distinct from a worksheet <f> node.

The second 0.34.0 case keeps the local ScenarioLedger Table at Ledger!A1:C4, its headers, raw Ledger!C2:C4 formulas, and Dashboard!B4=SUM(ScenarioLedger[Calculated amount]) fixed. Only the third column’s raw calculatedColumnFormula moves from A2*B2 to A2*(B2+1), leaving xl/tables/table1.xml as the sole changed package member. WCAB records that stored master: it does not fill a column, reconcile the master with row formulas, calculate a structured reference, infer a total, or claim client behavior.

A Data Model relationship can retarget without a cell edit

Microsoft’s PowerPivot Model overview explains that relationships filter data across model tables. The Office Open XML definitions for CT_DataModel and CT_ModelRelationship define the stored table and key declarations. That creates a review surface beyond ordinary cells and formula text.

WCAB 0.35.0 adds a compact pair that keeps two local Excel Tables, SalesModel and CalendarModel, their worksheet cells, the powerPivotData workbook binding, content type, calculation properties, and a fixed opaque xl/model/item.data payload unchanged. Only the raw Office 2013 x15:modelRelationship in xl/workbook.xml moves from SalesModel.CalendarKey → CalendarModel.DateKey to SalesModel.CalendarKey → CalendarModel.FiscalDateKey. WCAB verifies that declaration and the payload digest only: it does not deserialize a Data Model, evaluate DAX, refresh, calculate, render a report, infer model-to-cell impact, or claim Excel-client behavior.

An automatic XLM target can move while its macro sheet stays fixed

Microsoft’s Excel 4.0 macro guidance says that Excel continues to support XLM macros, and its XlRunAutoMacro reference names Auto_Open, Auto_Close, Auto_Activate, and Auto_Deactivate as automatic macro events. A review therefore needs to see a stored automatic binding retarget even when the macro-sheet bytes do not change.

WCAB 0.36.0 adds a real macro-enabled .xlsm pair. Its one workbook-scoped _xlnm.Auto_Open defined name moves from 'Macro Automation'!$A$1 to 'Macro Automation'!$A$2. The target sheet is very hidden; its raw xlMacrosheet part stays byte-identical and contains only two static HALT() formula cells. The workbook-to-macro-sheet relationship, macro-enabled content types, ordinary Inputs!B2 → Model!B2 → Dashboard!B4 formula context, calculation properties, and every package member except xl/workbook.xml remain fixed. WCAB records the stored dispatch declaration only: it never opens Excel, enables or executes XLM code, parses or emulates macro instructions, resolves a dynamic name, inspects macro-security or trust settings, or claims an automatic dispatch result.

A web-query source can move without changing an imported cell

Microsoft's external-connection format documentation shows that a workbook connection can carry provider, server, authentication, command, and refresh material outside worksheet cells. For a web query, the Open XML WebQueryProperties reference identifies the stored URL and request controls. That endpoint is a review surface even when saved imported values and ordinary formulas stay fixed.

WCAB 0.37.0 adds a compact relationship-backed connection whose only raw difference is xl/connections.xml webPr/@url, moving between two reserved example.invalid endpoints. Its connection ID, type, name, refresh controls, workbook relationship, content type, saved ImportedData!B2=100 cell, ImportedData!B2 → Summary!B2 → Dashboard!B4 formula path, calculation properties, and every other package member remain fixed. The validator compares the connection part after removing only that URL. It reads local OOXML only: it does not resolve, open, fetch, authenticate to, trust, refresh, calculate, or claim a client result.

A package signature can declare a different scope without a cell edit

The Open Packaging Conventions specification defines package relationships and signature parts, while the W3C XML Signature specification distinguishes SignedInfo references from Manifest references. A local SignedInfo object reference is not the same evidence as a package part declared through Object/Manifest/Reference.

WCAB 0.38.0 adds a structurally shaped OPC signature pair with fixed root-to-origin and origin-to-signature relationships, content types, a SignedInfo local-object reference, stable Controls!B10=12 and Controls!D10=B10*C10 context, calculation properties, and every archive member except _xmlsignatures/sig1.xml. Its one Object/Manifest/Reference/@URI moves from a direct workbook part to a direct worksheet part. The digest and signature values are deliberately synthetic. The validator proves only this bounded declaration and package boundary: it does not verify a digest, signature, transform, certificate, identity, trust chain, or package-consumer decision.

A protected sheet can permit sorting without a cell edit

Microsoft’s worksheet-protection guidance lists Sort among the actions a protected sheet can permit. The Open XML SheetProtection reference records those action controls. That is a review surface even if every stored cell remains identical.

The second 0.33.0 case keeps the protected Controls worksheet, Controls!D2=B2*C2, its direct Dashboard!B4=Controls!$D$2 consumer, styles, calculation properties, and every other action lock fixed. Raw sheetProtection/@sort moves only from 1 (locked) to 0 (permitted), so xl/worksheets/sheet1.xml is the sole changed package member. WCAB records a stored permission, not an Excel interaction: it does not test a password, authorization, editable range, client sort operation, or resulting value.

A hyperlink can move without changing visible cell text

Version 0.31.0 adds a relationship-backed worksheet cell hyperlink case. Excel's Hyperlink.Address reference defines a hyperlink address as the target document's string address, while the Open XML Hyperlink reference identifies x:hyperlink/@r:id as the relationship binding that expresses the target location. In the pair, Inputs!B2 keeps the visible text Open vendor portal; its worksheet declaration, relationship ID/type/mode, calculation properties, and Inputs!B2 → Summary!B2 → Dashboard!B4 formula context stay fixed. Only the external relationship Target in xl/worksheets/_rels/sheet1.xml.rels moves between reserved example.invalid URLs. The validator reads local OOXML only: it does not resolve, open, fetch, visit, execute, calculate, or claim that a client follows either target.

The gap is about change assurance

There are already useful spreadsheet datasets. Modified EUSES injects formula faults and supplies test decisions. VEnron recovered version information from business spreadsheets. SpreadsheetBench tests spreadsheet manipulation. And recent formula-repair research measures whether a tool can fix runtime formula problems.

Those are complementary questions. I could not find an open benchmark whose primary contract is the review boundary between two workbook versions: explicit change facts, a stated accept/review/block convention, static impact that must not be missed, and a way to say “unsupported” rather than silently pass. That is the narrower problem WCAB addresses.

What the first cases cover

The suite includes formula-to-value replacement, wrong-period reference drift, material input propagation, external formula references, defined-name redirection, copied-formula interruption, mismatched SUMIFS ranges, data validation and conditional-formatting removal, a stored conditional-formatting threshold whose raw cutoff moves while its target, priority, operator, values, and differential fill stay fixed, a stored custom number format that changes from a percentage display to ;;; while its raw value, style assignment, and dependent formula stay fixed, a stored ignored-error declaration that suppresses a formula-range checking category while its ordinary cells and formula context stay fixed, a list validation whose stored source moves between local permitted-status ranges while the target and metadata stay fixed, hidden-sheet visibility, direct formula-cell unlocking, incomplete manual calculation, direct static cycles, a 3-D formula whose tab span changes without its text changing, an Excel Table whose scope changes while its structured-reference summary text stays unchanged, a direct reference that becomes INDIRECT, unchanged INDIRECT and OFFSET formulas whose selectors change, an external-data connection that begins refreshing when the file opens, a separate connection whose stored web-query source moves while its saved cells and formulas stay fixed, a relationship-backed QueryTable whose own refresh-on-open request changes while its connection control and saved cells stay fixed, a local worksheet-backed PivotTable cache whose refresh-on-open request changes while stored output cells stay fixed, a local PivotTable whose aggregate declaration moves from Sum to Average while its source, cache, and stored report cells stay fixed, a local PivotTable Slicer cache whose selected Region item changes while its source, cache, and stored report cells stay fixed, a connection-only Power Query M definition whose local-table filter literal changes while its source and controls stay fixed, a stored Scenario Manager alternate input whose raw value changes while visible worksheet values and formulas stay fixed, a one-variable What-If Data Table whose raw input reference changes while its output range and ordinary formulas stay fixed, a dashboard chart whose source-value reference changes while its cells and other bindings stay fixed, an unchanged external-workbook formula whose open-time update policy changes, an unchanged direct circular formula whose iterative calculation becomes enabled, an unchanged precision-sensitive input and formula whose calculation switches to precision as displayed, a saved formula result that changes without a formula or input edit, a workbook-wide serial-date-system control change with no cell edit, an active AutoFilter criterion change with stable SUBTOTAL and downstream formulas, an unchanged array formula that changes from fixed CSE to dynamic spill semantics, a documented structural rewrite, and a local cross-workbook dependency.

It also includes a workbook-structure lock changing from enabled to disabled while a hidden review-control sheet and an ordinary formula remain fixed. That is a stored operational control, not a claim about encryption, a password, authorization, or a particular spreadsheet client’s actions.

The Office Web Add-in case follows the same discipline: one stored Office.AutoShowTaskpaneWithDocument property moves from false to true, while a synthetic local FileSystem reference, a hidden locked task pane, ordinary cells, calculation properties, and the Inputs!B2 → Model!B2 → Dashboard!B4 formula context remain fixed. It is review evidence about a stored package request, not a claim that an add-in was installed, loaded, executed, fetched, or displayed a pane.

The 0.30 case makes a QueryTable refresh-on-open request reviewable. One local queryTable/@refreshOnLoad attribute moves from false to true while its direct worksheet relationship, fixed internal connection with refreshOnLoad=false, non-routable example.invalid endpoint, saved cells, and ImportedData!B2 → Summary!B2 → Dashboard!B4 formula context remain fixed. Only xl/queryTables/queryTable1.xml changes. The fixture does not open a connection, fetch a URL, refresh a query, materialize rows, calculate a workbook, or claim that a client refreshes successfully.

That mix matters. A row or column insertion can rewrite many formulas while retaining the declared logical inputs. Conversely, inserting a tab inside SUM(Jan:Mar!B5) can change the formula’s scope while its text does not change at all. A benchmark that treats every text difference as a regression—or every unchanged formula string as safe—cannot measure the review problem honestly.

Truth that can be inspected

Every case carries a truth.json document. Schema version 3 adds a machine-matchable coverage_expectations field alongside facts such as formula_to_value, sheet_visibility_changed, and three_d_scope_changed. Its must_reach section gives formula locations a conservative local A1 dependency walk must reach. These are deliberately lower bounds; WCAB is not a formula evaluator and does not claim complete Excel dependency semantics, dynamic-reference resolution, or numerical correctness.

The bundled validator reads the generated files and verifies those contracts. It does not trust a fixture merely because the manifest says it is right. The schema documents each fact kind and boundary.

Reproducibility is part of the artifact

Openpyxl can build the workbooks, but ZIP timestamps would otherwise change on every run. WCAB fixes workbook metadata and canonicalizes package member order and timestamps, then tests byte-for-byte regeneration. Version 0.42.0 validated all 59 cases and 280 tests locally under Python 3.13; fresh wheel and source-distribution installations both validated all 59 cases and reproduced the catalogue byte-for-byte. The validation record contains the exact commands and results.

A distribution that tools can verify

Version 0.37.0 retains a deterministic, one-row-per-case manifest.jsonl catalogue. It retains each case’s facts, review convention, static-impact lower bounds, coverage text, and scoreable coverage expectations, alongside the exact relative path, byte count, and SHA-256 digest for every baseline and candidate workbook. A pair is explicitly either a matching .xlsx pair or a matching .xlsm pair, so a runner can record precisely which fixtures it consumed instead of inferring identity or macro capability from a directory name.

The same release is available as a Hugging Face dataset. Its downloadable catalogue matches the GitHub release byte-for-byte, while the source repository remains the place to regenerate and validate every file.

A score that makes coverage gaps visible

A benchmark needs more than files and truth documents: different review tools emit different report formats. WCAB 0.42.0 retains its small normalized observation protocol and scorer. An adapter declares each case as analyzed, unsupported, or errored; then the scorer reports expected-fact recall, coverage-disclosure recall, analyzed coverage, and agreement with WCAB’s reference review convention.

That last boundary matters. WCAB’s truth is intentionally targeted, not a claim that it lists every possible workbook difference. A tool may report another real observation that the case does not name. The scorer keeps such evidence explicit as unrecognized instead of calling it a false positive. And an unsupported case remains visible in the result—it cannot become an unearned pass.

When a dynamic selector moves, formula text is not enough

Microsoft documents that INDIRECT returns the reference named by text, and its OFFSET documentation describes a reference displaced from another reference. WCAB’s first dynamic case changes a direct =Revenue!$C$8 output into =INDIRECT(Inputs!$E$12). A tool can still report that formula edit; the edit alone does not establish that its static dependency graph covers every target the workbook can select.

Version 0.5.0 adds the harder paired case: the formula stays exactly the same while its selector changes. In one workbook, Inputs!E12 changes from Revenue!B8 to Revenue!C8 beneath =INDIRECT(Inputs!$E$12); in the other it changes an OFFSET column displacement. A local graph can correctly show that the input reaches the summary, yet still cannot honestly claim that it resolved the selected target.

Schema v3 therefore names both dynamic_reference_static_coverage and dynamic_reference_driver_changed expectations. Protocol v2 lets an adapter attach native evidence to the exact expectation, and the scorer measures it separately. This avoids rewarding a tool for silently treating an indirection boundary as a complete impact graph, without forcing every tool to make the same claim about formula evaluation.

When a Table grows, formula text is not enough

Excel structured references use a Table and column name instead of a fixed cell range. Microsoft documents that those references adjust when data is added to or removed from the Table. The schema-v2 case therefore holds =SUM(SalesLedger[Amount]) constant while the stored Table range changes from A1:D4 to A1:D5. The benchmark asks a reviewer to surface that stored-scope change; it does not attempt to calculate the total or claim a numerical result.

The same array formula can have different semantics

Excel distinguishes a legacy Ctrl+Shift+Enter (CSE) array, whose output range is fixed, from a dynamic array, which can resize its spill output. That distinction affects editability, future resizing, and possible #SPILL! failures even if the visible anchor formula has not changed.

WCAB 0.7.0 holds =LEN(Inputs!A1:A3) and its currently stored B1:B3 range constant. The candidate adds the relationship-backed OOXML metadata binding that marks Model!B1 as a dynamic array. The validator reads that binding directly; it does not calculate the formula, predict a future spill extent, find blockers, or assert client-version compatibility.

This makes the review question concrete without manufacturing a result: the workbook’s array behavior changed, and a static consumer at Dashboard!B2 remains a declared lower-bound impact.

When opening the workbook changes its behavior

Excel connection properties can enable “Refresh data when opening the file.” That setting can make opening a workbook attempt to retrieve current external data—even if no worksheet cell, formula, or visible layout changed in the edit under review.

WCAB 0.6.0 isolates that control in a relationship-backed connections.xml part. The baseline and candidate have the same worksheet cells, formulas, and ZIP members; only the connection’s refreshOnLoad attribute changes from false to true. Its endpoint is a non-routable example.invalid URL. The benchmark never connects, refreshes, tests credentials or trust settings, or asserts a new result.

This is deliberately a stored-control fact, not a claim about a future calculation. A reviewer can see that the workbook’s on-open behavior changed while retaining a hard boundary around source availability, authentication, and returned data.

An unchanged external link can start updating at open

Excel's workbook-link guidance describes startup choices for external workbook links, and the Open XML workbook properties identify updateLinks as the stored behavior used when a workbook opens. That is a different control from a query or connection refresh flag.

WCAB 0.8.0 keeps LinkedModel!B2's ='[WCABSource.xlsx]Inputs'!$B$2 formula and its local Dashboard!B4 consumer unchanged. Only workbookPr/@updateLinks moves from never to always. The source workbook is synthetic and absent. The validator requires the exact raw-OOXML transition and matching formula text, but it never opens or resolves that source, tests trust or authentication, retrieves a value, or claims recalculation succeeded.

An unchanged circular model can start iterating

Excel’s circular-reference guidance explains that iterative calculation can intentionally allow circular references in financial or engineering models. The Open XML calculation-properties definition records iterate, iterateCount, and iterateDelta.

WCAB 0.9.0 keeps Model!B2's =(B2+Inputs!$B$2)/2 direct self-reference and its local Dashboard!B4 consumer unchanged. Only calcPr/@iterate moves from false to true; both workbooks record 100 iterations and a 0.001 delta. The validator reads the stored control and formula text, but never calculates the circular model, asserts convergence, predicts an iteration count, or reports a terminal value.

Precision can change without a visible value edit

Excel’s calculation guidance says that calculating with displayed values permanently changes stored values, and its rounding-precision guidance warns of cumulative effects. The Open XML calculation-properties definition records the corresponding fullPrecision control.

The precision case deliberately keeps the stored Inputs!B2 value 10.005, its 0.00 number format, Model!B2's =Inputs!$B$2*2 formula, and its Dashboard!B4 consumer unchanged. Only calcPr/@fullPrecision moves from true to false. The validator reads raw package metadata and stored cells, but never opens or saves the workbook, calculates a formula, asserts that any value rounded, predicts a result, or claims a particular client applies the setting.

A saved result can change while the formula does not

SpreadsheetML stores a formula expression in <f> and the result saved from its last calculation in the neighboring <v> element. Microsoft’s Open XML formula guidance documents that split directly. It creates a different review surface from formula text: the saved result can change even when the formula and visible inputs do not.

WCAB 0.11.0 keeps Inputs!B2=10, Model!B2's =Inputs!$B$2*2 expression, calculation metadata, and a local Dashboard!B4 consumer unchanged. Only the raw numeric <v> next to Model!B2's formula moves from 20 to 25. The validator proves that the package changes only in that worksheet and that the worksheet is otherwise identical after erasing the selected result text. It does not calculate the formula, decide that either result is current, stale, tampered, or correct, or claim what Excel displays after opening.

A workbook date base can change without a cell edit

Excel supports 1900 and 1904 workbook date systems. Its date-system guidance documents a 1,462-day difference for the same stored serial. In SpreadsheetML, the relevant workbook-level controls are date1904 and dateCompatibility; the documented Open XML defaults are false and true.

WCAB 0.12.0 preserves the raw Inputs!B2=45292 numeric serial, its yyyy-mm-dd number format, Model!B2's local formula, and the Dashboard!B4 consumer. Only workbookPr/@date1904 moves from false to true while explicit dateCompatibility=true remains fixed. The validator reads raw OOXML, style metadata, formula text, and package members. It does not calculate a formula, convert a serial, predict a displayed date, or claim behavior for any Excel client.

A filter can change the report without editing a cell

Excel's filter guidance explains that an AutoFilter shows matching data and hides the rest; the filtered subset can then be copied, charted, or printed. Its SUBTOTAL documentation says that filter-excluded rows are always excluded. That makes an active criterion review-material even when cell values and formula text have not moved.

WCAB 0.13.0 changes the sole list criterion in Report!A1:B5, column 0, from North to South. It leaves Report!D2=SUBTOTAL(109,B2:B5) and Dashboard!B4=Report!$D$2 exactly as stored. The validator proves the raw AutoFilter declaration, stable formulas and direct dependency edge, and the report-worksheet-only package difference. It does not apply the filter, calculate the subtotal, infer a visible row set, or claim what an Excel client displays, copies, charts, or prints.

A saved Sheet View can change the review lens without a cell edit

Microsoft documents Sheet Views as saved, customized filter and sort views for collaborative work. The MS-XLSX Named Sheet Views specification describes the stored collection as sort/filter settings associated with a worksheet AutoFilter. That creates a review surface distinct from the active filter: an alternate view can change even while ordinary cells and formula text do not.

WCAB 0.26.0 keeps a no-criterion Report!A1:B5 base AutoFilter, report rows, Report!D2=SUBTOTAL(109,B2:B5), and Dashboard!B4=Report!$D$2 fixed. One worksheet relationship binds that base filter to xl/namedSheetViews/namedSheetView1.xml; only the saved column-0 list value moves from North to South. The validator follows the relationship and filter ID, checks the Named Sheet View part is the sole package difference, and does not activate, render, or apply the view; calculate a subtotal; infer visible rows; or claim a display or print outcome.

An XML Map can redirect an import/export field without a cell edit

Microsoft’s XML guidance describes XML Maps as bindings between schema elements and worksheet cells or XML tables, used for importing and exporting XML data. Its XmlMap API exposes those import and export operations. That makes a map’s stored field target a review surface even when its current visible worksheet cells do not change.

WCAB 0.27.0 keeps a synthetic local MapInfo/XSD declaration, file-binding metadata, Export!E2 single-cell mapping, table values, Export!D2=SUM(InvoiceLines[Net amount]), and Dashboard!B4=Export!$D$2 fixed. Only the InvoiceLines table’s Net amount xmlColumnPr/@xpath moves from NetAmount to TaxAmount. The validator follows local workbook and worksheet relationships, requires xl/tables/table1.xml to be the sole changed package member, and does not access a file, validate a schema, import or export XML, materialize data, calculate a result, or claim client behavior.

An add-in can request a task pane without a cell edit

Microsoft’s workbook auto-open guidance documents the package parts that associate a workbook with an Office Add-in and makes a crucial deployment caveat: the referenced add-in must already be installed, sideloaded, or deployed before an application can honor the association. The MS-OWEMXML specification defines Office.AutoShowTaskpaneWithDocument as an extension property. That makes the stored request reviewable separately from client state and executable add-in content.

WCAB 0.28.0 has one workbook-to-taskpane-to-web-extension relationship chain. It keeps a synthetic local FileSystem reference, the add-in and reference IDs, a hidden locked task pane, Inputs!B2=10, Model!B2=Inputs!$B$2*2, and Dashboard!B4=Model!$B$2 fixed. Only Office.AutoShowTaskpaneWithDocument changes from false to true, and xl/webextensions/webextension1.xml is the sole changed package member. The fixture has no manifest payload or external relationship. The validator does not install, load, execute, or fetch an add-in or manifest, and does not claim that a task pane opens or that an add-in accesses workbook cells.

An embedded OLE object can request auto-load without a cell edit

Microsoft’s OLEObject.AutoLoad reference describes whether an OLE object loads automatically when its workbook opens, while the Open XML property reference identifies the stored SpreadsheetML attribute. That makes the declaration reviewable separately from an object server, installed component, or client outcome.

WCAB 0.29.0 retains one worksheet OLE declaration, a direct internal OLE-object relationship, a matching content type, opaque fixed ASCII bytes, a synthetic unregistered ProgID, and Inputs!B2=10, Model!B2=Inputs!$B$2*2, and Dashboard!B4=Model!$B$2. Only oleObject/@autoLoad moves from false to true, so xl/worksheets/sheet1.xml is the sole changed package member. There is no linked target, ActiveX control, presentation, macro, or external relationship. The validator does not deserialize, open, render, execute, register, or invoke an object server, and does not claim that an object loads successfully.

A QueryTable can request refresh without changing a cell

Microsoft’s QueryTable.RefreshOnFileOpen reference describes a table-level setting for automatic refresh when a workbook opens. The Open XML QueryTable reference exposes the stored refreshOnLoad control alongside the table’s connection ID. That makes it a distinct review surface from a connection’s own refresh control.

WCAB 0.30.0 has one ImportedData worksheet-to-QueryTable relationship and one fixed internal workbook-to-connections relationship. Only xl/queryTables/queryTable1.xml changes: queryTable/@refreshOnLoad moves from false to true. The connection retains refreshOnLoad=false, the endpoint is the reserved non-routable example.invalid URL, and ImportedData!B2=100 plus ImportedData!B2 → Summary!B2 → Dashboard!B4 remain fixed. No connection is opened, URL fetched, query refreshed, row materialized, or workbook calculated, and the benchmark makes no claim that a client refreshes successfully.

A PivotTable cache can start refreshing without a cell edit

Excel's PivotTable refresh guidance includes refreshing data when a workbook opens, and the Open XML PivotCacheDefinition reference exposes refreshOnLoad. A shared cache can therefore be review-material even when no worksheet cells change.

WCAB 0.14.0 binds a local Source!A1:B5 cache through a PivotTable at Report!A1:B2 and a direct Dashboard!B4=Report!$B$2 consumer. Baseline and candidate retain the source, cache records, stored report cells, formula, and every other package member; only pivotCacheDefinition/@refreshOnLoad moves from false to true. The validator checks the relationship bindings and raw package isolation. It does not open Excel, refresh a cache, calculate or render a PivotTable, infer a result, or claim that any client honors the request.

A PivotTable can change its aggregation without a cell edit

Excel's PivotTable layout guidance describes placing a field in the Values area and changing its settings. In SpreadsheetML, the Open XML DataField.Subtotal property records that data-consolidate function. A report can therefore switch from Sum to Average without a source-cell edit or a changed saved display value.

WCAB 0.16.0 keeps the local Source!A1:B5 cache binding, every cache record, Report!A1:B2 location, stored Report!B2 display cell, and Dashboard!B4=Report!$B$2 formula fixed. Only its sole dataFields/dataField/@subtotal moves from sum to average. The validator follows the local cache/PivotTable relationship graph and proves that only xl/pivotTables/pivotTable1.xml changes. It does not refresh, calculate, or render a PivotTable, infer a changed display value, or claim client behavior.

A PivotTable Slicer can switch state without a cell edit

Excel's PivotTable filtering guidance describes Slicers as controls that filter PivotTables and convey the current filtering state. The Office Open XML Slicer Cache Part specification stores cache-item indices with x and selected items with s=1. That makes a Slicer-cache selection review-material even when no worksheet cell changes.

WCAB 0.17.0 keeps the local Source!A1:B5 cache, Report!A1:B2 PivotTable, stored Report!B2 display cell, and Dashboard!B4=Report!$B$2 formula fixed. Only its local Region Slicer cache selection moves from item 0 (North) to item 1 (South). The validator follows the workbook-to-Slicer-cache-to-PivotCache/PivotTable relationship graph and proves that only xl/slicerCaches/slicerCache1.xml changes. This fixture has no visual Slicer or drawing: it does not apply a filter, refresh, calculate, or render a PivotTable, infer a changed result, or claim client behavior.

A Power Query filter can change without a worksheet edit

Power Query’s overview explains that transformations are stored as M, and its query-management guidance allows a query to be connection-only. A stored local-table M definition can therefore be review-material even when ordinary worksheet cells and saved outputs do not move.

WCAB 0.18.0 keeps its generated Source!A1:B5 SourceData Table, every worksheet cell, table definition, metadata, permission control, and calculation property fixed. Only the stored Table.SelectRows Region literal moves from North to South in customXml/item1.xml. The validator follows the package-root custom-XML relationship and a bounded generated Data Mashup envelope. It does not execute M, apply a filter, refresh a query, materialize output, calculate a workbook, infer returned rows, or claim client behavior.

A Scenario Manager assumption can change without a worksheet edit

Excel’s Scenario Manager guidance describes scenarios as saved sets of values for changing cells. That makes their stored alternate inputs a separate review surface: a workbook can carry a different downside assumption even when its displayed worksheet values and formulas do not change.

WCAB 0.19.0 keeps Inputs!B2=0.1, Inputs!B3=125, Inputs!D2=B2*B3, and Dashboard!B4=Inputs!$D$2 fixed. In the selected locked WCAB downside scenario, only the raw stored Inputs!B2 value moves from 0.08 to 0.16; the scenario remains stored rather than shown or applied. The validator proves the exact scenario metadata and that only xl/worksheets/sheet1.xml differs. It does not show or apply a scenario, calculate a formula, create a scenario summary, infer a result, or claim Excel-client behavior.

A What-If Data Table can retarget an input without a formula edit

Excel’s Data Table guidance distinguishes one- and two-variable tables and their row or column input cells. The Open XML CellFormula reference records a Data Table master through its dataTable type, output range, input references, and orientation controls. A changed input reference is therefore review-material even when ordinary formulas and visible cells do not move.

WCAB 0.20.0 keeps a column-oriented one-variable Sensitivity!D3 master’s D3:D5 output range, recalculation request, input grid, ordinary formulas, calculation properties, and saved table results fixed. Only raw f/@r1 changes from B2 to B3. The validator proves that the Sensitivity worksheet is the only changed package member and that both possible input cells retain ordinary static paths to the model and dashboard. It does not substitute values, calculate a table or workbook, infer an output, resolve a circular dependency, or claim Excel-client behavior.

A list validation can retarget allowed inputs without a cell edit

Excel’s data-validation guidance describes list rules through stored formula fields, and the Open XML Formula1 reference allows a formula, constant, or list series. Changing the source can therefore change the set of future permitted values even while the current cell and every ordinary formula remain unchanged.

WCAB 0.21.0 makes that boundary inspectable. Its one Inputs!B2 list rule keeps its target, blank/dropdown/error/prompt controls, both Lists source columns, current Draft input, Model!B2=Inputs!$B$2, and Dashboard!B4=Model!$B$2 fixed. Only raw formula1 moves from =Lists!$A$2:$A$4 to =Lists!$B$2:$B$4. The validator proves the Inputs worksheet is the only changed package member, and treats the direct formula path as a lower bound if a user later enters a value. It does not evaluate either list, decide whether a future input is valid, accept or reject an entry, calculate the workbook, or claim Excel-client behavior.

A conditional-formatting threshold can move without a cell edit

Microsoft’s Open XML guidance describes conditional-formatting rules stored alongside a worksheet, and its formula specification distinguishes the rule expression from a rendered worksheet outcome. A changed stored threshold is therefore review-material even when no ordinary cell edit accompanies it.

WCAB 0.22.0 holds one Operations!B2:B4 cellIs rule’s target, priority 1, greaterThan operator, values 10, 75, and 120, and solid FFFFC7CE differential fill fixed. Only raw rule formula moves from 100 to 50. The validator proves that the Operations worksheet is the sole changed package member and that its XML is otherwise identical after erasing that selected formula text. It does not evaluate a condition, calculate a workbook, decide which values are highlighted, render a worksheet, or claim Excel-client behavior.

A number format can hide a metric without a cell edit

Excel’s custom-number-format guidance documents ;;; as a way to hide worksheet values, while its percentage-format guidance describes changing the display of a stored number. That makes a raw number-format definition a review surface distinct from a value or formula edit.

WCAB 0.23.0 keeps Operations!B2's raw 0.125 value, custom format ID 164, cell-style assignment, and Operations!B3=B2 formula fixed. Only the custom format code moves from 0.0%;[Red](0.0%);- to ;;;. The validator proves that only xl/styles.xml changes and is otherwise identical after erasing the selected format code. It does not render a cell, apply locale or column-width rules, infer a displayed result, calculate a workbook, or claim Excel-client behavior.

An ignored-error rule can remove a review prompt without a formula edit

Microsoft’s formula-error guidance explains that an ignored error no longer appears in later error checks until errors are reset. It also describes the formula-range-omission rule, where adjacent nonblank cells outside a formula’s referenced range can cause an error indicator. A stored per-range suppression is therefore a separate review surface from a formula or value edit.

WCAB 0.24.0 keeps Operations!B2=10, B3=20, B4=30, B5=SUM(B2:B3), and C5=B5 fixed. Only one standard ignoredErrors/ignoredError declaration is added, with sqref="B5" and formulaRange="1". The validator proves that only xl/worksheets/sheet1.xml changes and is otherwise identical after removing that declaration. It does not determine whether Excel would show a warning, evaluate a formula, decide whether the suppression is justified, render an indicator, change application-level error checking, calculate a workbook, or claim Excel-client behavior.

A workbook’s structure can become editable without a cell edit

Microsoft’s workbook-protection guidance distinguishes structure protection from file and worksheet protection, and says that it restricts adding, moving, deleting, hiding, unhiding, and renaming sheets. The related Open XML specification records the workbook-level control.

WCAB 0.25.0 keeps the hidden ReviewControls sheet and Inputs!D2=B2*C2 formula fixed. Only workbookProtection/@lockStructure moves from 1 to 0; the validator proves that xl/workbook.xml is the only changed package member and is otherwise identical after removing that attribute. It does not test a password, encryption, authentication, authorization, whether the hidden sheet becomes exposed, or a particular Excel client’s sheet-operation behavior.

A chart can switch its source without a cell edit

Excel’s series guidance allows a series to use a different source range, while the Open XML NumberReference model holds that binding. A dashboard chart can therefore become review-material even if no worksheet value or formula changes.

WCAB 0.15.0 keeps Dashboard!D2, its title 'Source'!B1, its category range 'Source'!$A$2:$A$4, and every worksheet cell fixed, while the raw value-series source changes from 'Source'!$B$2:$B$4 to 'Source'!$C$2:$C$4. The validator follows the worksheet-to-drawing-to-chart relationship chain and proves that only xl/charts/chart1.xml changes. It records the stored binding only: it does not calculate, refresh, render, infer a visible difference, or claim client behavior.

A baseline adapter, without making it the benchmark

WCAB has an optional local adapter for FormulaFence. It invokes a locally installed executable, maps its JSON evidence into WCAB facts, and leaves unmapped cases visible. FormulaFence 0.221.0 observed all 55 mappable facts, all three scoreable dynamic-reference coverage declarations, and five targeted lint rules. It maps the Power Query case only when the tool emits its exact redacted power_query_changed profile and FF024; FormulaFence deliberately does not expose M source, local-table values, or a query result.

The adapter makes the same distinction throughout: a native diff must match the declared fact boundary, rather than merely share a broad category. It requires exact evidence for the connection and PivotCache refresh controls, PivotTable aggregation and Slicer state, Power Query, Scenario Manager state, What-If Data Tables, list-validation sources, conditional-formatting thresholds, custom number-format controls, ignored-error controls, chart source, external-link policy, calculation controls, saved result, date system, active filter, saved Sheet View, XML Map binding, Office Web Add-in declarations, and array mode. The Scenario Manager mapping requires FormulaFence’s redacted scenario_manager_changed profile and FF035; the Data Table mapping requires its one-variable what_if_data_tables_changed profile and FF034. The list-source mapping requires the exact data_validation_changed rule transition and FF020: FormulaFence exposes the stored source/control metadata but does not evaluate a list or decide whether an input is permitted. The threshold mapping requires its exact conditional_formatting_changed rule transition and FF021, including the raw 100 → 50 formula change with all other declared rule details stable. The number-format mapping requires the exact redacted number_format_controls_changed profile and FF039; FormulaFence deliberately redacts the code and target, so WCAB independently verifies the Operations!B2 transition and styles-only boundary. The ignored-error mapping requires the exact redacted ignored_error_controls_changed profile and FF037; FormulaFence deliberately redacts the target and formula, so WCAB independently verifies the Operations!B5 declaration and worksheet-only boundary. WCAB’s raw validator then establishes the fixture-specific source bindings and stored transitions without executing Excel or Power Query.

The workbook-structure mapping requires FormulaFence’s exact non-secret workbook_protection_changed profile and FF022: its before profile has only the structure lock active, while its after profile has all workbook locks false and neither side reports a credential or opaque metadata. WCAB independently verifies the raw lockStructure transition, hidden-sheet/formula context, and workbook-only package boundary.

The saved-Sheet-View mapping requires exact named_sheet_views_changed evidence and FF038: FormulaFence reports one worksheet, part, view, filter, column, and criterion, with no sort rule, sort condition, or unrecognized declaration. It intentionally redacts the view name, IDs, filter range, and selected value; WCAB independently verifies the North → South stored criterion, base-AutoFilter relationship, stable formulas, and Named-Sheet-View-part-only boundary.

The XML Map mapping requires exact xml_mapping_controls_changed evidence and FF049: FormulaFence reports one map part, schema, map, data binding, file binding, table binding, and single-cell binding, with no unrecognized mapping metadata. It intentionally redacts schema, map, XPath, table, and cell values; WCAB independently verifies the NetAmount → TaxAmount transition, stable declarations and formulas, and table-part-only boundary.

The Office Web Add-in mapping requires exact office_web_addins_changed evidence and FF028: FormulaFence’s redacted profile must retain one declared task-pane part, task pane, web-extension part, and store reference; one hidden locked pane; no bindings, snapshots, external relationships, in-content references, or unrecognized parts; and an auto-show count moving from zero to one. It redacts the IDs, store name, and property value; WCAB independently verifies the false-to-true property, stable local workbook context, and web-extension-part-only boundary.

The embedded-OLE mapping requires exact worksheet_embedded_controls_changed evidence and FF029: FormulaFence’s redacted profile must retain one worksheet, one embedded OLE object, one internal payload, no linked, external, ActiveX, VML, or presentation material, and no unrecognized declaration while its auto-load count moves from zero to one. It does not inspect or deserialize the payload; WCAB independently verifies the stored false-to-true attribute, relationship and content-type boundary, inert bytes, formula context, and worksheet-XML-only package change.

The QueryTable mapping requires exact query_table_refresh_controls_changed evidence and FF023: FormulaFence’s redacted profile retains one ImportedData table, connection ID 1, fixed background/disable/remove/fill/edit/growth controls, name metadata, and no opaque metadata while only refresh_on_load moves from false to true. It does not expose an endpoint, OOXML part, or result rows; WCAB independently proves the local relationship graph, fixed connection-level control, saved cells/formulas, and QueryTable-part-only boundary.

The 0.37.0 web-query-source mapping requires a separate exact high-severity external_data_connections_changed record and FF023. FormulaFence’s before/after profiles must remain the same safe one-web-query connection description while reporting source_configuration_material_changed=true and exactly source_material_change_categories: ["web_query_url"]. It does not expose either URL, a connection string, command, parameter, or fingerprint. WCAB independently verifies the reserved endpoint transition, connection graph and controls, saved cells/formulas, and xl/connections.xml-only package boundary.

The cell-hyperlink mapping requires FormulaFence’s exact cell_hyperlink_controls_changed evidence and FF047: one external worksheet hyperlink binding remains, with no location, display, tooltip, or unrecognized declaration, while its binding, definition material, and relationship material change. FormulaFence intentionally redacts the target and relationship ID, so WCAB independently verifies the target transition, stable visible text/formulas, and relationship-part-only boundary.

The external-workbook source mapping requires FormulaFence’s exact redacted external_link_packages_changed profile and high-severity FF025: it retains one external workbook and source sheet, no DDE/OLE link, no cached external data, and no opaque metadata while only source_material_changed is set. FormulaFence does not expose the source target or relationship IDs. WCAB independently verifies the reserved-target transition, external-reference graph, stable formula context, and externalLink-relationship-part-only boundary; its generic external_relationships_changed / FF063 diagnostic remains deliberately unmapped.

The 0.33.0 adapter mapping is deliberately narrower than its broad categories. The defined-name case requires both FormulaFence’s one-surface external_workbook_link_surfaces_changed / FF081 evidence and matching ScenarioRate defined_name_changed / FF008 evidence; either signal alone is insufficient. The sort-permission case requires an exact sheet_protection_changed profile and FF022 with every action lock retained except sort. WCAB’s raw validator independently establishes the OOXML values and package boundaries in both cases.

The 0.34.0 mappings are equally narrow. The named-LAMBDA case requires FormulaFence’s exact ScenarioValue defined_name_changed record and matching FF008 before/after texts. The Table case requires its exact redacted table_definition_changed profile, calculated_column_formula_material_changed flag, and FF013; FormulaFence intentionally does not expose the master text. WCAB’s raw validator supplies the exact local OOXML values, worksheet-to-Table binding, stable formula context, and one-part package boundaries rather than treating either adapter signal as proof of evaluation.

The 0.35.0 Data Model mapping requires an exact high-severity power_pivot_data_model_changed record and FF033, with one internal data part, one workbook binding, one declaration, two model tables, one model relationship, and a fixed fingerprinted payload profile on both sides. FormulaFence redacts model names and keys, so WCAB independently verifies the stored DateKey → FiscalDateKey transition, fixed opaque payload, and workbook-XML-only boundary. Neither side deserializes a Data Model, evaluates DAX, refreshes it, calculates or renders a report, or infers model-to-cell impact.

The 0.36.0 XLM mapping is equally narrow: FormulaFence must report its high-severity xlm_automatic_macro_bindings_changed record and FF076, with one automatic binding, one Auto_Open binding, and no close/activate/deactivate binding on either side; only its material-change flag may differ. FormulaFence deliberately redacts the macro-sheet name, target cells, XML, and macro instructions. WCAB independently verifies the exact $A$1 → $A$2 stored target transition, fixed two-HALT() macro sheet, very-hidden state, relationship/content types, and workbook-XML-only boundary. Neither side opens Excel, enables or executes XLM code, parses or emulates macro instructions, or claims client behavior.

Its normalized-observation export leaves review decisions unset rather than inventing a policy, so its score is 55 of 56 declared facts, three of three coverage disclosures, full analyzed coverage, and zero policy agreement. The structural rewrite remains intentionally unmapped: a small fixture can document its before/after intent, but it cannot establish a generic proof of Excel semantic equivalence.

That distinction is the point. A tool should be rewarded for finding what it can prove and for exposing what it cannot—not for converting a coverage gap into an unearned pass.

A protected-range descriptor is stored review material, not access proof

The ISO/IEC SpreadsheetML protected-range example places account descriptors in nested securityDescriptor children. The Open XML SDK's ProtectedRange reference also identifies that child. It can therefore be important review evidence even if every ordinary cell is identical—but it does not establish an identity, authentication, authorization, encryption result, editable-range enforcement decision, or spreadsheet-client behavior.

WCAB 0.42.0 adds one standards-form pair whose only changed package member is xl/worksheets/sheet1.xml. Inside it, one nested protectedRange/securityDescriptor text node changes; the protected worksheet, locked Controls!B2:B2 target, range name/reference, legacy verifier, Controls!D2=B2*C2 formula, direct Dashboard!B4 consumer, calculation properties, and every other package member stay fixed. The raw validator checks the compact synthetic XML and compares the worksheet after erasing only that text. Its public fact deliberately excludes the descriptor, range name, and verifier.

The optional FormulaFence adapter accepts the fact only with exact high-severity protected_range_permissions_changed and FF022 evidence. The redacted before/after profiles retain one named range, one legacy verifier, one standard descriptor, and no opaque metadata; only security_descriptor_material_changed: true differs. That gives a reviewer a material-change signal without turning the benchmark or report into an account-descriptor disclosure.

Use or extend it

git clone https://github.com/SybilGambleyyu/workbook-change-benchmark.git
cd workbook-change-benchmark
python -m venv .venv
.venv/bin/python -m pip install -e '.[dev]'
wcab validate --fixtures fixtures
wcab manifest --fixtures fixtures
wcab observation-template --fixtures fixtures --output observations.json
wcab score --fixtures fixtures --observations observations.json
pytest

The benchmark is MIT-licensed. Start with the source, the v0.42.0 release, or the dataset mirror. The useful next additions are cases and adapters that retain the same standard: deterministic generation, inspectable evidence, explicit limits, and a validation test.