# Research basis

WCAB was selected after examining change-assurance needs across spreadsheet
audit, versioning, repair, and research corpora on 2026-08-01.

## What is already available

| Resource | What it makes measurable | Why it is not sufficient for change assurance |
| --- | --- | --- |
| [Modified EUSES](https://spreadsheets.sai.tugraz.at/index.php/corpora-for-benchmarking/euses/) | Injected formula faults and output-cell test decisions | It is fault-localization/testing data, not an explicit before/after review policy or dependency-impact contract. |
| [VEnron](https://researchportal.hkust.edu.hk/en/publications/venron-a-versioned-spreadsheet-corpus-and-related-evolution-analy/) | Recovered spreadsheet version history | The original work says version information is fragmented and uses recovered evolution groups; it does not publish a CI-oriented accept/review/block oracle for changes. |
| [Enron Error Corpus discussion](https://web-ainf.aau.at/pub/jannach/files/Conference_VL_HCC_2016.pdf) | A small collection of real faults and repairs | It is important evidence that real historical changes can be faults, but it targets fault recovery rather than broad change-review controls. |
| [SpreadsheetBench](https://github.com/RUCKBReasoning/SpreadsheetBench) | Real-world spreadsheet manipulation tasks | It evaluates producing or editing workbooks, not deciding whether a candidate change should pass a review gate. |
| [Formula repair benchmark](https://www.microsoft.com/en-us/research/publication/benchmark-dataset-generation-and-evaluation-for-excel-formula-repair-with-llms/) | Formula runtime-error repair | It evaluates repair generation and execution checks, not version comparison or conservative static impact. |

## Evidence of the workflow problem

Microsoft's [Spreadsheet Inquire documentation](https://support.microsoft.com/en-US/Excel/compare-workbooks-using-spreadsheet-inquire)
describes cell-by-cell comparison, workbook analysis, and relationship diagrams,
but the workflow is a desktop inspection rather than a portable policy gate.
Commercial tools such as [xltrail](https://www.xltrail.com/) provide version
history and component diffs.  Their existence is useful confirmation that
formula-level history matters, while it also leaves room for an open,
reproducible way to evaluate policy and impact claims.

The spreadsheet-evolution literature describes a central review problem: a
structural edit can rewrite many formulas even when intent is preserved, while a
single formula or value change can alter model behaviour.  The paper surfaced
through [this TU Delft copy](https://pure.tudelft.nl/ws/portalfiles/portal/47903754/00_Spreadsheet_Evolution.pdf)
explicitly calls out both effects.  A benchmark must therefore include both
clear regressions and benign-looking structural changes.

## Design decision

The first release uses original generated workbooks instead of rehosting public
corporate corpora.  This provides unambiguous redistribution rights, directly
observable ground truth, deterministic regeneration, and cases that include
modern OOXML controls often absent from older `.xls` research datasets.

WCAB's result is intentionally narrower than a claim of Excel semantic
equivalence.  It provides checkable change facts and static dependency lower
bounds.  A tool that cannot handle a case must report a coverage gap; it cannot
turn a missing observation into an "allow" result.

## Structured-reference scope expansion

Microsoft documents that a structured reference combines a Table and column
name, and that the reference adjusts when data is added to or removed from the
Table. Its [structured-reference guidance](https://support.microsoft.com/en-us/excel/using-structured-references-with-excel-tables)
also shows formulas outside a Table that refer to Table data. This creates a
change-review case that ordinary formula text comparison misses: the stored
formula can remain unchanged while the Table's stored range grows. WCAB schema
version 2 therefore adds a generated Table-expansion case that checks those
observable facts without evaluating a formula or asserting a result value.

## External-workbook link startup policy

Microsoft's [workbook-link guidance](https://support.microsoft.com/en-us/excel/manage-workbook-links)
documents startup choices for external workbook links, including always
refreshing them, never refreshing them, and asking the user. The Open XML
[`workbookPr` specification](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.workbookproperties?view=openxml-3.0.1)
identifies `updateLinks` as the stored behavior for updating external links
when a workbook opens. This is distinct from a query, connection, or pivot
refresh switch: an unchanged formula that refers to a separate workbook can
start attempting an update solely because this workbook-wide policy changes.

WCAB 0.8 therefore preserves one original synthetic external-link formula and
its local downstream consumer while changing only `workbookPr/@updateLinks`
from `never` to `always`. The named source workbook is deliberately absent;
the validator reads local OOXML and formula text only. It does not resolve the
link, test source availability or trust, retrieve a value, or claim that Excel
successfully recalculates the workbook.

## External-workbook source relationships

Microsoft's [workbook-link guidance](https://support.microsoft.com/en-us/excel/manage-workbook-links)
documents **Change source** as a workflow for pointing existing workbook links
to another source. The Open XML [`ExternalBook` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.externalbook?view=openxml-3.0.1)
states that `externalBook` represents an external workbook supplying data to
the current workbook, including a relationship to the supporting book path.
This creates a separate review surface from a startup-refresh policy: a stored
source can change while the visible external formula stays exactly the same.

WCAB 0.32 isolates that relationship graph in one original synthetic package.
`LinkedModel!B2` keeps `='[WCABSource.xlsx]Inputs'!$B$2`, and
`Dashboard!B4=LinkedModel!$B$2` remains its direct local consumer. One workbook
external-reference binding leads to one `externalLink/externalBook` declaration
and its one externalLinkPath relationship. The formula, source-sheet name,
relationship IDs/types, content type, and every package member except
`xl/externalLinks/_rels/externalLink1.xml.rels` stay fixed; only its external
`Target` moves from `approved.example.invalid` to `review.example.invalid`.
The validator reads local OOXML only, never resolves, opens, fetches,
authenticates to, trusts, refreshes, or calculates either source, and does not
claim that any client updates a link or returns a value.

## External-data source endpoints can move without changing visible cells

Microsoft's [external-connection format documentation](https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-xls/69df8d03-b6fd-45cd-a0a0-9b026e50a3d9)
shows that a workbook connection can store provider, server, authentication,
command, and refresh material outside ordinary cells. For web queries, the
Open XML [`webPr` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.webqueryproperties?view=openxml-3.0.0)
identifies the stored URL and request controls. A source retarget can therefore
be material to review even when imported saved values and local formulas look
unchanged.

WCAB 0.37 isolates that declaration using one local relationship-backed
web-query connection. Only its raw `webPr/@url` moves from
`approved.example.invalid` to `review.example.invalid`; connection identity and
refresh controls, relationship and content-type bindings, saved
`ImportedData!B2=100`, the `ImportedData!B2 → Summary!B2 → Dashboard!B4`
formula path, calculation properties, and every other package member stay
fixed. The validator reads local OOXML and compares `xl/connections.xml` after
removing only the URL. It never opens, fetches, authenticates to, trusts,
refreshes, or otherwise interacts with either endpoint, evaluates formulas, or
claims a client result. The fixture also motivates FormulaFence's safe
`web_query_url` category: it identifies the class of changed sensitive source
material without emitting either endpoint, a command, a parameter, or a
fingerprint.

## Package-signature scope can change outside worksheet cells

The [Open Packaging Conventions specification](https://ecma-international.org/wp-content/uploads/ECMA-376-Part-2-5th-edition.pdf)
defines package relationships and digital-signature parts, while the W3C
[XML Signature specification](https://www.w3.org/TR/xmldsig-core/) distinguishes
the `Reference` items in `SignedInfo` from the `Reference` items collected by a
`Manifest`. A `SignedInfo` URI can therefore point to a local signature
`Object`, while a separate `Object/Manifest` declaration names the package
parts whose stated scope a reviewer needs to understand. Treating those two
namespaces as interchangeable would turn a signature-local reference into an
unsupported package-coverage claim.

WCAB 0.38 isolates this boundary with one structurally shaped package signature.
Its root-to-origin and origin-to-signature relationships, origin/signature
content types, one `SignedInfo` local-object reference, ordinary
`Controls!B10=12` and `Controls!D10=B10*C10` context, calculation properties,
and all package members except `_xmlsignatures/sig1.xml` remain fixed. Only one
`Object/Manifest/Reference/@URI` moves from the direct workbook part to the
direct worksheet part. The raw validator checks that bounded local declaration
and compares the signature XML after erasing only that URI.

WCAB 0.39 adds the complementary relationship-selector boundary: the Manifest
URI names the root relationships part and its XMLDSIG transform sequence is one
OPC Relationships Transform immediately followed by XML C14N. Only its
`RelationshipReference/@SourceId` changes, selecting the root office-document
relationship before and the root signature-origin relationship after. A
selector identifies a relationship entry rather than proving its target part
was signed, and the redacted aggregate selector counts intentionally remain
equal. The raw validator checks only that bounded local structure and compares
the envelope after erasing the source ID. The digest and signature values in
both fixtures are deliberately synthetic: neither package-signature case is a
cryptographic verification, transform evaluation, certificate/identity check,
trust-chain assessment, or package-consumer decision.

## Legacy shared-workbook revision history persists outside ordinary cells

Microsoft's Open XML [`Headers` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.headers?view=openxml-3.0.1)
describes revision history persisted in distinct headers and log files, with
shared/tracking/history/retention/protection controls. Its
[`WorkbookRevisionHeaderPart` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.packaging.workbookrevisionheaderpart?view=openxml-3.0.1)
exposes linked revision-log parts, while the [`Revisions` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.revisions?view=openxml-3.0.1)
describes a log as a list of revisions made to a shared workbook. The old shared
workbook feature is legacy, but that is exactly why persisted history can remain
outside an ordinary cell/value/formula comparison.

WCAB 0.41 isolates a compact relationship-backed workbook-to-header-to-log
graph. The header controls, synthetic author/timestamp/GUID, revision-record
shape, content types, `Controls!B10=12`, `Controls!D10=B10*C10`, calculation
properties, and every package member except `xl/revisions/revisionLog1.xml`
remain fixed. Only one synthetic historic value changes. The raw validator
checks that bounded local declaration and compares the log after erasing the
private value. It does not publish historic values, cell locations, writer
identity, timestamps, GUIDs, or relationship IDs; verify provenance or a
writer; replay revisions; resolve conflicts; establish review/approval;
authenticate or authorize a person; or claim workflow/client behavior.

## External sources can hide in defined names without an externalLink part

Microsoft's [workbook-link guidance](https://support.microsoft.com/en-us/excel/manage-workbook-links)
explicitly identifies defined names as a location where workbook links may be
used and gives a workflow for finding them. The Open XML
[`DefinedNames` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.definednames?view=openxml-3.0.1)
places those expressions in the workbook-level name collection. This is a
separate review surface from an `externalLink` relationship graph: an ordinary
formula can stay fixed while the name it consumes changes its qualified source.

WCAB 0.33 therefore keeps `Model!B2=ScenarioRate*2` and its direct
`Dashboard!B4=Model!$B$2` consumer unchanged while the local `ScenarioRate`
definition moves from `'[WCABApprovedSource.xlsx]Inputs'!$B$2` to
`'[WCABReviewSource.xlsx]Inputs'!$B$2`. Its original compact fixture has no
`externalReferences` declaration and no `xl/externalLinks/` member; only
`xl/workbook.xml` changes. The validator reads those local bytes and fixed
formula context only. It never resolves, opens, fetches, authenticates to,
trusts, refreshes, or calculates either synthetic source, and it does not claim
that a client resolves the name or returns a value.

## Named LAMBDAs are workbook-scoped formula programs, not ordinary cells

Microsoft's [LAMBDA guidance](https://support.microsoft.com/en-us/excel/functions/lambda-function)
describes naming a LAMBDA in Name Manager so it becomes a reusable custom
function available throughout a workbook. Its [names-in-formulas guidance](https://support.microsoft.com/en-US/Excel/get-started/define-and-use-names-in-formulas)
also calls out defining reusable formulas with LET and LAMBDA. A cell-level
formula diff can therefore leave an invocation unchanged while the callable
formula body behind its friendly name changes.

WCAB 0.34 isolates that review surface in one original compact workbook. The
only stored difference is the workbook-level `ScenarioValue` definition moving
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 unchanged, as do calculation properties,
workbook relationships, and every package member except `xl/workbook.xml`.
The package has no external references or external-link part. The validator
reads the stored definition and local ordinary formula paths only; it does not
evaluate a LAMBDA, expand every named-formula dependency, calculate a result,
infer client/version support, or claim a client recalculates, spills, or saves
a value.

## Table calculated-column masters can change outside worksheet cells

Microsoft's [calculated-column guidance](https://support.microsoft.com/en-US/Excel/use-calculated-columns-in-an-excel-table)
explains that a formula entered in one Excel Table column is filled through the
column, and that later edits expand through the calculated column. In Open XML,
[`calculatedColumnFormula`](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.calculatedcolumnformula?view=openxml-3.0.1)
is the `tableColumn` child that stores the formula used for each cell in that
column. This is a stored formula program distinct from a worksheet `<f>` cell
node and from a Table range change.

WCAB 0.34 therefore keeps a local `ScenarioLedger` Table at `Ledger!A1:C4`,
its worksheet-to-Table relationship, headers, ordinary `Ledger!C2:C4` formulas,
and `Dashboard!B4=SUM(ScenarioLedger[Calculated amount])` fixed. Only the
third Table column's raw `calculatedColumnFormula` text moves from `A2*B2` to
`A2*(B2+1)`, so `xl/tables/table1.xml` is the sole changed package member. The
validator follows that local binding and compares the Table part after erasing
only the master text. It does not fill formulas, reconcile the master with
stored row formulas, calculate a structured reference, infer a total, add a
row, render a Table, open Excel, or claim client behavior.

## Data Model relationships can change report filtering outside cell formulas

Microsoft's [PowerPivot Model object guidance](https://learn.microsoft.com/en-us/office/vba/excel/concepts/about-the-powerpivot-model-object-in-excel)
describes one workbook model containing tables and relationships, where a
relationship connects a primary key to a foreign key and lets a user filter
across multiple tables in a PivotTable or PivotChart. The Open XML
[`dataModel` declaration](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/eaea0fe6-3e3c-401d-a3a0-2d2cbb9fce00)
and [`modelRelationship` type](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/02c4fd22-dfcb-4cbb-abc0-05fc16dd9db0)
place that relationship separately from ordinary worksheet cell formulas. A
worksheet diff can therefore miss a changed model key even if its visible cells
and formulas remain stable.

WCAB 0.35 isolates one compact declaration whose relationship changes from
`SalesModel.CalendarKey → CalendarModel.DateKey` to
`SalesModel.CalendarKey → CalendarModel.FiscalDateKey`. Its two local source
Tables, `powerPivotData` workbook relationship, `.data` content type,
calculation properties, and fixed opaque `xl/model/item.data` payload remain
unchanged; `xl/workbook.xml` is the sole changed package member. The raw
validator reads only that declaration, its local package binding, and a digest
of the opaque payload. It does not deserialize the Analysis Services stream,
evaluate DAX, load or refresh a model, calculate or render a PivotTable or
chart, infer model-to-cell impact, or claim Excel-client behavior.

## XLM automatic-macro declarations remain a review surface

Microsoft's [Excel 4.0 macro guidance](https://support.microsoft.com/en-au/office/working-with-excel-4-0-macros-ba8924d4-e157-4bb2-8d76-2c07ff02e0b8)
states that Excel continues to support Excel 4.0 (XLM) macros and documents
their security controls. Its [`XlRunAutoMacro` reference](https://learn.microsoft.com/en-us/office/vba/api/excel.xlrunautomacro)
names `Auto_Open`, `Auto_Close`, `Auto_Activate`, and `Auto_Deactivate` as the
automatic macro events. This makes a stored automatic-macro binding materially
different from an ordinary worksheet formula: a reviewer may need to see that
the event's stored target changed even when the macro-sheet bytes did not.

WCAB 0.36 therefore uses a real macro-enabled `.xlsm` pair with one
very-hidden XLM macro sheet and one workbook-scoped `_xlnm.Auto_Open` name.
Only that raw defined-name text changes, from `'Macro Automation'!$A$1` to
`'Macro Automation'!$A$2`; the raw macro-sheet payload is byte-identical and
contains only two static `HALT()` formula cells. Its macro-sheet relationship,
content types, ordinary local formula context, calculation properties, and
every other package member stay fixed. The fixture is designed to test review
of a stored dispatch declaration, not macro execution: WCAB never opens Excel,
enables or executes XLM code, parses or emulates instructions, resolves a
dynamic name, inspects security/trust state, or claims an event dispatch result
or client behavior.

## Iterative calculation and intentional circular models

Microsoft's [circular-reference guidance](https://support.microsoft.com/en-US/Excel/remove-or-allow-a-circular-reference-in-excel)
explains that iterative calculation can intentionally allow circular references
in financial or engineering models, and that maximum iterations and maximum
change bound that repeated calculation. Its [calculation guidance](https://support.microsoft.com/en-US/Excel/change-formula-recalculation-iteration-or-precision-in-excel)
likewise distinguishes a direct or indirect self-reference from a workbook
where iteration has been enabled to calculate it. The Open XML
[`calcPr` specification](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.calculationproperties?view=openxml-3.0.1)
defines the stored calculation-properties element and its `iterate`,
`iterateCount`, and `iterateDelta` attributes.

WCAB 0.9 uses one small original direct self-reference whose formula text,
input, and downstream local consumer do not change. The candidate changes only
the stored `iterate` flag from false to true while retaining explicit 100 and
0.001 bounds. The fixture records a calculation-control change—not a numerical
outcome. The validator does not calculate the circular model, assume that it
converges, predict how many iterations occur, or assert a cached or
business-correct result.

## Precision as displayed and irreversible stored values

Microsoft's [calculation and precision guidance](https://support.microsoft.com/en-US/Excel/change-formula-recalculation-iteration-or-precision-in-excel)
distinguishes the values Excel stores from the values a number format displays.
It warns that enabling calculation using displayed values permanently changes
stored values to that displayed precision and cannot restore the prior
underlying values. Its separate [rounding-precision guidance](https://support.microsoft.com/en-us/excel/set-rounding-precision)
also warns of cumulative calculation effects. The Open XML
[`calcPr` specification](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.calculationproperties?view=openxml-3.0.1)
identifies `fullPrecision` as the stored calculation control.

That creates a review boundary that a formula or cell-value diff can miss: a
package can retain a stored `10.005` input, a `0.00` format, and unchanged
formulas while its calculation control moves from full precision to displayed
precision. WCAB 0.10 therefore isolates raw `fullPrecision=true` to
`fullPrecision=false` in an original synthetic pair. The validator confirms
the stored metadata, input value, format, and formulas only. It does not open
or save either workbook, emulate Excel, calculate a result, round a stored
value, or assert any client will apply or persist the control.

## Saved formula results without a visible precedent edit

Microsoft's [SpreadsheetML formula guidance](https://learn.microsoft.com/en-us/office/open-xml/spreadsheet/working-with-formulas)
separates a formula's `<f>` expression from the `<v>` cached value based on
the last calculation. Its [`CellValue` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.cellvalue?view=openxml-3.0.1)
also states that a formula-cell `<v>` stores the last calculated result. This
is a distinct review surface: an ordinary formula or literal-value diff can
stay silent when the saved result evidence has changed.

WCAB 0.11 therefore retains an original `Inputs!B2=10`, the direct
`Model!B2 = Inputs!$B$2*2` formula, stable calculation properties, and a local
`Dashboard!B4` consumer, while changing only `Model!B2`'s raw numeric `<v>`
from `20` to `25`. The pair is deliberately not a claim that either value is
correct, stale, tampered, or will be displayed after opening: volatile,
external, and client-specific calculation behavior are out of scope. Its
purpose is to make the saved-result discrepancy observable and reviewable.

## Workbook serial-date systems without a cell edit

Microsoft documents that Excel workbooks use either a 1900 or 1904 date
system, and that the same stored serial differs by 1,462 days between those
systems in its [date-system guidance](https://support.microsoft.com/en-us/office/date-systems-in-excel-e7fe7167-48a9-4b96-bb53-5612a800b487). The Open XML
[`workbookPr` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.workbookproperties?view=openxml-3.0.1)
stores `date1904` and `dateCompatibility` as workbook controls, with defaults
of `false` and `true` respectively. That makes an omitted control materially
different from an arbitrary boolean parser: a comparator should normalize the
specified defaults before deciding that a date-system change occurred.

WCAB 0.12 isolates that surface in an original synthetic pair. It makes both
controls explicit, preserves a raw `45292` numeric serial and its
`yyyy-mm-dd` custom format, and changes only `date1904=false` to `true` while
`dateCompatibility=true` remains fixed. The validator reads local OOXML and
style metadata only. It neither converts the serial nor asserts what date a
client will display, and it does not calculate, open, or save a workbook.

## Active AutoFilter criteria without a cell edit

Microsoft's [filter guidance](https://support.microsoft.com/en-us/excel/get-started/filter-data-in-a-range-or-table-in-excel)
explains that AutoFilter shows the requested subset and hides the rest; a
filtered subset can then be copied, charted, or printed. Its
[`SUBTOTAL` reference](https://support.microsoft.com/en-us/excel/functions/subtotal-function)
states that rows excluded by a filter are always excluded. Consequently, an
active criterion can be review-material even when no formula text or stored
cell value changes.

WCAB 0.13 records that control boundary in one original synthetic pair. The
sole list criterion in `Report!A1:B5` moves from `North` to `South`, while
`Report!D2=SUBTOTAL(109,B2:B5)` and `Dashboard!B4=Report!$D$2` remain unchanged.
The raw validator checks the stored `<autoFilter>`, `<filterColumn>`,
`<filters>`, and `<filter>` declaration plus the formula/dependency and
package-member boundary. It does not apply a filter, calculate the subtotal,
infer which rows a client shows, or claim a displayed, copied, charted, or
printed result.

## Named Sheet Views can alter a saved review lens without a cell edit

Microsoft's [Sheet View guidance](https://support.microsoft.com/en-us/excel/create-and-manage-sheet-views-in-excel)
describes saved, customized filter and sort views for collaborative work,
including switching among saved views. The [MS-XLSX Named Sheet Views
specification](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/78cf20a1-2551-45c6-86bf-f1e92bd5fc39)
defines the stored collection as sort/filter settings for an AutoFilter on a
specific worksheet. This is a separate review surface from the active
worksheet AutoFilter: a reviewer can select a saved view without a formula or
cell value having changed.

WCAB 0.26 keeps a no-criterion `Report!A1:B5` base AutoFilter, the report
rows, `Report!D2=SUBTOTAL(109,B2:B5)`, and `Dashboard!B4=Report!$D$2` fixed.
A worksheet relationship binds that filter to one saved Named Sheet View;
only its column-0 list criterion moves from `North` to `South`. The validator
follows the local relationship, reconciles its stable filter ID and range to
the base AutoFilter, compares the named-view part after removing only the
terminal list value, and requires that part to be the sole package change.
It does not activate, render, or apply the view; calculate a subtotal; infer
visible rows; or claim a display or print outcome.

## XML Maps can retarget a workbook's import/export contract without a cell edit

Microsoft's [XML overview](https://support.microsoft.com/en-US/Excel/overview-of-xml-in-excel)
explains that XML Maps bind schema elements to worksheet cells or XML tables
and are used to import and export mapped XML data. It distinguishes
single-mapped cells from repeating XML tables, and describes XML Maps as the
relationship between mapped cells and schema elements. The
[Excel XmlMap API](https://learn.microsoft.com/en-us/office/vba/api/excel.xmlmap)
likewise exposes Import and Export operations over a workbook XML map. That
makes the raw mapping target—not only the current worksheet value—a material
review surface for data-exchange templates.

WCAB 0.27 isolates that boundary in one original synthetic package. The
`Export!A1:B3` `InvoiceLines` XML table has one mapped `Net amount` column;
only its raw `xmlColumnPr/@xpath` moves from a `NetAmount` to a `TaxAmount`
path. The local XML Map, embedded XSD declaration, local file-binding
metadata, stable `Export!E2` single-cell mapping, table values,
`Export!D2=SUM(InvoiceLines[Net amount])`, and
`Dashboard!B4=Export!$D$2` remain fixed. The validator follows only local
workbook and worksheet relationships, compares the table part after erasing
the XPath, and requires that table part to be the sole package change. It
does not access a file, validate the schema, import or export XML, materialize
data, calculate formulas, or claim a client result.

## Office Web Add-in auto-show requests change workbook behavior outside cells

Microsoft's [Excel auto-open task-pane guidance](https://learn.microsoft.com/en-us/office/dev/add-ins/excel/pnp-open-in-excel)
documents the `webextension` and `taskpanes` package parts used to associate
a workbook with an Office Add-in. Its deployment caveat is important: an
association is only honored when the referenced add-in is already installed,
sideloaded, or deployed. The [MS-OWEMXML
specification](https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-owemxml/4b94ac5d-a8df-44f4-8433-81d43e35a2d7)
defines the `Office.AutoShowTaskpaneWithDocument` extension property. A
workbook can therefore acquire a stored request to show an add-in task pane
without a worksheet-cell diff, and without the package containing an add-in
manifest or payload.

WCAB 0.28 isolates that declaration in one original synthetic package. It has
one local workbook-to-taskpane-to-web-extension relationship chain, one hidden
locked task pane, and one synthetic FileSystem store reference. Its
`Office.AutoShowTaskpaneWithDocument` value alone moves from false to true;
the reference, IDs, task-pane layout, ordinary cells, calculation properties,
and `Inputs!B2 → Model!B2 → Dashboard!B4` formula context remain unchanged.
The validator follows only local package relationships, compares the
web-extension XML after erasing that value, and requires that part to be the
sole package change. The fixture has no manifest payload or external
relationship. It does not install, load, execute, or fetch an add-in or
manifest, and it does not claim that any client opens a task pane or that the
add-in accesses workbook cells.

## Embedded OLE auto-load requests change workbook-open behavior outside cells

Microsoft's [OLEObject.AutoLoad reference](https://learn.microsoft.com/en-us/office/vba/api/excel.oleobject.autoload)
defines the property as whether an OLE object is automatically loaded when its
workbook opens. It defaults to false for new OLE objects, Microsoft advises
against setting it true for most object types, and explicitly distinguishes
ActiveX controls, which ignore the property because they always load. The Open
XML [`OleObject.AutoLoad` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.oleobject.autoload?view=openxml-3.0.1)
records the same stored `autoLoad` schema boolean, while the
[`OleObject` element reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.oleobject?view=openxml-3.0.1)
defines its relationship identifier as the pointer to object-persistence data.
That creates a material review surface independent of a cell diff, without
requiring a benchmark to launch an object server.

WCAB 0.29 isolates that declaration in one original synthetic package. It has
one worksheet `oleObject` declaration, one standard internal OLE relationship,
and one fixed opaque ASCII payload under a synthetic unregistered ProgID. Its
`autoLoad` value alone moves from false to true; its relationship, content
type, bytes, ordinary cells, calculation properties, and
`Inputs!B2 → Model!B2 → Dashboard!B4` formula context remain fixed. The
validator follows only that local relationship, compares worksheet XML after
erasing `autoLoad`, verifies the fixed opaque bytes without deserializing them,
and requires the worksheet part to be the sole package change. The fixture has
no linked target, ActiveX control, object presentation, macro, or external
relationship. It does not deserialize, open, render, execute, register, or
invoke an object server, and it does not claim that an object loads
successfully.

## QueryTable refresh requests are distinct from connection refresh controls

Microsoft's [QueryTable.RefreshOnFileOpen reference](https://learn.microsoft.com/en-us/office/vba/api/excel.querytable.refreshonfileopen)
defines the property as whether a QueryTable is refreshed whenever its workbook
opens. The Open XML [`QueryTable` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.querytable?view=openxml-3.0.1)
lists the raw `refreshOnLoad` attribute alongside the table's connection ID and
other refresh controls. This is a material review surface separate from a
workbook connection's own `refreshOnLoad` setting: a stored table-level request
can change without a normal cell, formula, connection-control, or package
relationship diff.

WCAB 0.30 isolates that declaration in one original synthetic package. It has
one `ImportedData` worksheet-to-QueryTable relationship, one fixed internal
workbook-to-connections relationship, and one reserved `example.invalid`
web-query URL. Its QueryTable `refreshOnLoad` value alone moves from false to
true; the connection's own `refreshOnLoad=false`, QueryTable controls,
relationships, content types, saved `ImportedData!B2=100` cell, and
`ImportedData!B2 → Summary!B2 → Dashboard!B4` formula context remain fixed.
The validator follows only those local OOXML parts, compares the QueryTable XML
after erasing `refreshOnLoad`, and requires that QueryTable part to be the sole
package difference. The fixture has no credentials, query result, table range,
or external OOXML relationship. It does not open a connection, fetch a URL,
refresh a query, materialize rows, calculate a workbook, or claim that a
client refreshes successfully.

## Worksheet cell hyperlink targets can change outside ordinary cell content

Microsoft's [Hyperlink.Address reference](https://learn.microsoft.com/en-us/office/vba/api/excel.hyperlink.address)
defines the address as the target document's string address, while its
[Hyperlinks collection reference](https://learn.microsoft.com/en-us/office/vba/api/excel.hyperlinks)
shows that a worksheet range can own a hyperlink. In the Open XML
[`Hyperlink` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.hyperlink?view=openxml-3.0.1), the worksheet's
`x:hyperlink/@r:id` is the relationship identifier that expresses that target
location; the same element separately documents local `location`, `display`,
and `tooltip` attributes. A cell's displayed value can therefore remain fixed
while its relationship-backed external destination changes.

WCAB 0.31 isolates that review surface in one original synthetic package.
`Inputs!B2` retains the visible text `Open vendor portal`, one plain worksheet
hyperlink declaration, no local location/display/tooltip fields, and the local
`Inputs!B2 → Summary!B2 → Dashboard!B4` formula context. The sole package
difference is `xl/worksheets/_rels/sheet1.xml.rels`: its one external standard
hyperlink relationship keeps the same ID, type, and `TargetMode=External` but
its `Target` moves from `approved.example.invalid` to
`review.example.invalid`. The validator reads only the local package parts,
compares the relationship XML after erasing `Target`, and requires that
relationship part to be the sole package difference. It does not resolve, open,
fetch, visit, execute, calculate, or otherwise interact with either target,
and does not claim that a client follows one.

## PivotTable cache refresh requests without a cell edit

Microsoft documents an option to [refresh PivotTable data when a workbook
opens](https://support.microsoft.com/en-us/excel/refresh-pivottable-data), and
its [PivotTable overview](https://support.microsoft.com/en-us/excel/overview-of-pivottables-and-pivotcharts)
explains that PivotTables keep a cache that can be shared. The Open XML
[`PivotCacheDefinition` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.pivotcachedefinition?view=openxml-3.0.1)
identifies `refreshOnLoad` as the stored instruction for whether an application
refreshes that cache when the workbook opens. This leaves a material review
surface outside worksheet-cell diffs: the request can change without a formula,
source value, or stored display value changing.

WCAB 0.14 isolates this control in an original synthetic package with one local
worksheet cache. `Source!A1:B5` binds through a raw PivotCache/PivotTable
relationship graph to `Report!A1:B2`; its stored `Report!B2` is directly
referenced by `Dashboard!B4`. The pair changes only
`pivotCacheDefinition/@refreshOnLoad` from false to true. The raw validator
checks the relationship binding, source declaration, stored report/dashboard
cells, and package-member isolation. It does not open Excel, refresh data,
calculate or render the PivotTable, infer a new report result, or claim that a
client honors the setting.

## PivotTable aggregation without a cell edit

Microsoft's [PivotTable layout guidance](https://support.microsoft.com/en-US/Excel/design-the-layout-and-format-of-a-pivottable)
describes moving fields into the Values area and changing their settings, while
the Open XML [`DataField.Subtotal` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.datafield.subtotal?view=openxml-3.0.1)
identifies `subtotal` as the stored data-consolidate function. A report can
therefore switch from Sum to Average without changing a source cell, cached
record, worksheet formula, or saved PivotTable display value.

WCAB 0.16 isolates that declaration in an original local package. It retains
the `Source!A1:B5` cache binding, `Report!A1:B2` PivotTable location, all cache
records, stored `Report!B2`, and `Dashboard!B4=Report!$B$2`; only the sole
`dataFields/dataField/@subtotal` moves from `sum` to `average`. The raw
validator follows the local relationship graph and compares the PivotTable
part after removing that one attribute. It does not open Excel, refresh data,
calculate or render the PivotTable, infer a changed display value, or claim
client behavior.

## PivotTable Slicer selection without a cell edit

Microsoft's [PivotTable filtering guidance](https://support.microsoft.com/en-us/excel/get-started/filter-data-in-a-pivottable)
documents that Slicers filter PivotTables and make their current filtering
state visible. The Office Open XML [Slicer Cache Part
specification](https://learn.microsoft.com/en-us/openspecs/office_standards/MS-XLSX/e7eda20c-c65e-45ed-9540-de59c4a07b7d)
records each cache item with an `x` index and stores selection with `s=1`.
That makes a Slicer-cache selection a review surface outside ordinary cell and
formula diffs.

WCAB 0.17 isolates that state in an original local package. It retains the
`Source!A1:B5` cache binding, `Report!A1:B2` PivotTable location, cache records,
stored `Report!B2`, and `Dashboard!B4=Report!$B$2`; only the selected Slicer
cache item moves from index 0 (`North`) to index 1 (`South`). The raw validator
follows the local workbook-to-Slicer-cache-to-PivotCache/PivotTable graph and
compares the Slicer cache after removing only selection state. It creates no
visual Slicer or drawing, does not apply the filter, refresh data, calculate or
render a PivotTable, infer a report value, or claim client behavior.

## Power Query definitions without a worksheet edit

Microsoft's [Power Query overview](https://support.microsoft.com/en-us/excel/about-power-query-in-excel)
explains that transformations are recorded and can be edited as M source. Its
[query-management guidance](https://support.microsoft.com/en-us/excel/manage-queries-power-query)
also makes clear that a query can load to a worksheet, the Data Model, or stay
connection-only. The [Power Query M language reference](https://learn.microsoft.com/en-us/powerquery-m/)
and [`Excel.CurrentWorkbook`](https://learn.microsoft.com/en-us/powerquery-m/excel-currentworkbook)
show why a local Excel Table can be a query source without an external service.
That creates a high-value review surface: a query definition can materially
change while all ordinary cells and any saved output remain unchanged.

WCAB 0.18 isolates a small, deterministic version of that boundary. It creates
one generated `SourceData` Table at `Source!A1:B5` and stores one
connection-only M formula in a compact Data Mashup custom-XML part. The only
semantic difference is `Table.SelectRows` changing its `Region` literal from
`North` to `South`; the table, worksheet cells, formula-free dashboard text,
metadata, permissions, and calculation properties stay fixed. The validator
follows the package-root custom-XML relationship and parses only the generated,
bounded envelope. It does not claim general Power Query support, execute M,
apply a filter, refresh a query, materialize a result, calculate a workbook,
infer returned rows, or predict client behavior.

## Scenario Manager alternate inputs without a worksheet edit

Microsoft's [Scenario Manager guidance](https://support.microsoft.com/en-us/excel/switch-between-various-sets-of-values-by-using-scenarios)
defines a Scenario as a saved set of values that can be substituted into a
worksheet, distinguishes changing cells from formula result cells, and supports
scenario protection. It also explains that a scenario can hold up to 32
changing-cell values. The Open XML
[`inputCells` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.inputcells?view=openxml-3.0.1)
identifies the stored cell reference, cached value, deletion state, and
display-only number format within a scenario. This puts material alternate
assumptions in a raw worksheet control declaration rather than in the visible
grid that an ordinary cell diff usually compares.

WCAB 0.19 deliberately uses one selected, locked scenario with two inputs so
the changed value can be audited without expanding the case into scenario
application or numerical evaluation.

WCAB 0.19 keeps visible `Inputs!B2=0.1`, `Inputs!B3=125`,
`Inputs!D2=B2*B3`, and `Dashboard!B4=Inputs!$D$2` fixed while a raw Scenario
Manager `inputCells/@val` record for `B2` moves from `0.08` to `0.16`. The
scenario's selection, protection, comment/user, summary reference, second
input, and number-format metadata also remain fixed. The validator reads only
the generated raw OOXML and checks the local formula path as a lower bound if a
client applies the scenario. It does not show or apply a scenario, calculate a
model, create a scenario summary, infer a result, or claim client behavior.

## What-If Data Table input references without a formula edit

Microsoft's [Data Table guidance](https://support.microsoft.com/en-us/excel/calculate-multiple-results-by-using-a-data-table)
defines one- and two-variable What-If Data Tables and distinguishes their row
and column input cells. The Open XML
[`CellFormula` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.cellformula?view=openxml-3.0.1)
identifies a `t="dataTable"` master formula and its `ref`, `r1`, `r2`, `dt2D`,
and `dtr` controls. Excel's
[calculation-performance guidance](https://learn.microsoft.com/en-us/office/vba/excel/concepts/excel-performance/excel-improving-calculation-performance)
also notes that Data Tables trigger repeated recalculation and use a special
calculation path. A review system therefore needs to notice a changed input
reference even when ordinary cells and ordinary formula text do not change.

WCAB 0.20 isolates a column-oriented one-variable declaration in an original
three-sheet workbook. The generated `Sensitivity!D3` master has
`t="dataTable"`, `ref="D3:D5"`, `ca="1"`, and `r1="B2"`; the candidate changes
only `r1` to `B3`. `Sensitivity!D2=Model!$B$2`, input grid `C3:C5`, both
possible local input values, `Model!B2`, `Dashboard!B4`, and all calculation
properties stay fixed. The raw validator accepts only this compact shape and
compares the worksheet after removing the single `r1` value. It does not
substitute an input, calculate the table or workbook, infer an output,
interpret a circular dependency, or claim Excel-client behavior.

## List data-validation sources without a cell edit

Microsoft's [Excel data-validation API guidance](https://learn.microsoft.com/en-us/office/dev/add-ins/excel/excel-add-ins-data-validation)
describes list validation as a rule with formula fields, and the Open XML
[`Formula1` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.formula1?view=openxml-3.0.1)
states that the stored field can be a formula, constant, or list series. The
[MS-XLSX data-validation formula specification](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/b71087ce-6f73-461b-b23e-fcd4ece396aa)
likewise defines `formula1` and `formula2` as validation formulas. A
list-source declaration can therefore change the set of future permitted
entries while the current input and any ordinary formula remain fixed.

This is also a practical comparison blind spot: one Excel reviewer described
data-validation comparison as difficult in a [Microsoft Tech Community
discussion](https://techcommunity.microsoft.com/discussions/excelgeneral/limitations-of-the-spreadsheets-compare-tool/3734215).
That report is not treated as a broad measurement claim; it motivates an open,
inspectable case with a precise raw OOXML boundary instead.

WCAB 0.21 keeps a single `Inputs!B2` list validation, its error/prompt/dropdown
controls, both `Lists` source columns, the current `Draft` input, calculation
properties, `Model!B2=Inputs!$B$2`, and `Dashboard!B4=Model!$B$2` fixed. Only
the raw list `formula1` moves from `=Lists!$A$2:$A$4` to
`=Lists!$B$2:$B$4`. The validator reads the generated raw declaration and
ordinary direct formula path only. It does not evaluate a source formula,
determine a future input's validity, accept or reject an input, calculate a
workbook, or claim behavior from any Excel client.

## Conditional-formatting thresholds without a cell edit

Microsoft's [Open XML conditional-formatting guidance](https://learn.microsoft.com/en-us/office/open-xml/spreadsheet/working-with-conditional-formatting)
describes conditional formats as worksheet-level rules applied when a condition
is true. Its `cellIs` example stores the comparison operator and a `formula`
threshold inside `cfRule`; the [MS-XLSX conditional-formatting formula
specification](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/7476f340-5fe0-4051-9524-6daeaa1e0006)
likewise identifies `cfRule` formula elements as conditional-formatting
formulas. A stored threshold can therefore change the visual exception
criterion without a cell-value or ordinary-formula edit.

That boundary is relevant to review rather than merely to visual polish:
[ICAEW's spreadsheet-review guidance](https://www.icaew.com/technical/technology/excel-community/excel-community-articles/2021/conditional-formatting-and-spreadsheet-review)
describes conditional formatting as part of spreadsheet review, while a
comparison product can explicitly focus on entered values and formulas in its
[workbook comparison description](https://www.xltrail.com/blog/compare-two-excel-workbooks).
Those sources do not establish a population-wide coverage measurement; they
motivate a small, inspectable rule-level case that distinguishes a changed
criterion from an executed or rendered outcome.

WCAB 0.22 keeps one `Operations!B2:B4` `cellIs` rule's target, priority,
`greaterThan` operator, differential red fill, and stored `10`, `75`, and
`120` metrics fixed. Only its raw `formula` threshold moves from `100` to
`50`. The validator compares the worksheet after erasing that one formula and
requires the Operations worksheet to be the only changed package member. It
does not evaluate the rule, decide which cells an Excel client formats,
calculate a workbook, or claim client behavior.

## Number formats can hide or reinterpret a value without a cell edit

Microsoft's [percentage-format guidance](https://support.microsoft.com/en-us/excel/format-numbers-as-percentages-in-excel)
explains that applying a percentage format to a stored decimal changes its
display scale, while its [hide/display guidance](https://support.microsoft.com/en-us/excel/hide-or-display-cell-values)
documents the custom `;;;` format for hiding values on a worksheet. The
[MS-OI29500 numFmt notes](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oi29500/c6046ec6-f96d-4609-98e4-0dd549292955)
likewise describe custom number formats and percentage formatting at the
SpreadsheetML level. The stored format code is therefore a review surface that
can change even while a cell's numeric value and formula text do not.

This is not merely cosmetic in a serious review workflow. ICAEW's [spreadsheet
review report](https://www.icaew.com/-/media/corporate/files/technical/technology/excel/how-to-review-a-spreadsheet-report.ashx)
lists display errors—including a percentage shown with integer formatting—as a
review concern. Those sources do not establish a rendered outcome for a
particular client, locale, or column width; they motivate a narrow,
stored-metadata case rather than a screenshot-based assertion.

WCAB 0.23 keeps one `Operations!B2` style index, raw `0.125` numeric value,
neighboring `=B2` formula, calculation properties, and every package member
except `xl/styles.xml` fixed. Only its referenced custom
`numFmt/@formatCode` moves from `0.0%;[Red](0.0%);-` to `;;;`. The
validator follows the direct cell style to that one custom number-format
record, compares styles XML after erasing only its code, and never renders,
locale-resolves, calculates, or claims what an Excel client displays.

## Error-checking suppressions can hide a review prompt without a formula edit

Microsoft's [formula-error guidance](https://support.microsoft.com/en-us/excel/detect-formula-errors-in-excel)
states that an ignored error does not appear in subsequent error checks until
the user resets ignored errors. The same guidance documents the rule for
formulas that omit cells in a region: an adjacent, nonblank cell outside the
referenced range can produce an error indicator. Microsoft's Office 2010
[MS-XLSX `ignoredErrors` specification](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/0d164d85-23bf-4d43-87c5-9fcde148aabe)
documents the stored extension form for per-range ignored-error declarations.
Together, those sources identify an editable warning surface separate from an
ordinary formula, result, or workbook-wide preference.

The useful benchmark boundary is intentionally smaller than a claim that a
particular Excel client will display a triangle or that a formula is wrong.
WCAB 0.24 keeps `Operations!B2=10`, `B3=20`, `B4=30`,
`B5=SUM(B2:B3)`, and `C5=B5` fixed. Only one standard
`ignoredErrors/ignoredError` record with `sqref="B5"` and
`formulaRange="1"` is added. The validator removes that one declaration when
comparing worksheet XML and requires the Operations worksheet to be the sole
changed package member. It does not evaluate the formula, predict an Excel
warning or indicator, decide whether suppression is justified, change
application-level error checking, calculate, or claim client behavior.

## Workbook-structure protection can change operational controls without a cell edit

Microsoft's [Protect a workbook guidance](https://support.microsoft.com/en-us/office/protect-a-workbook-7e365a4d-3e89-4616-84ca-1931257c1517)
states that protecting workbook structure controls adding, moving, deleting,
hiding, unhiding, and renaming worksheets, and distinguishes that control from
file and worksheet protection. Its password is optional. The Office Open XML
[`workbookProtection` specification](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oe376/ae53f189-04e6-45e6-acb2-7f61fecabee4)
identifies the stored workbook-level protection element. Those sources motivate
a narrow review case for a governance setting that ordinary cell diffs can
miss, without mistaking it for encryption or access control.

WCAB 0.25 keeps a hidden `ReviewControls` sheet and
`Inputs!D2=B2*C2` formula fixed while its raw
`workbookProtection/@lockStructure` moves exactly from `1` to `0`. The
validator strips only that attribute when comparing `xl/workbook.xml`, requires
that member to be the sole package difference, and checks the stable hidden
sheet and formula context. It does not test a password, encryption,
authentication, authorization, whether a hidden sheet becomes exposed, or an
Excel client's sheet-operation behavior.

## Sheet-protection sort permission can change without a cell edit

Microsoft's [Protect a worksheet guidance](https://support.microsoft.com/en-us/excel/protect-a-worksheet)
lists **Sort** among the actions that can be permitted on a protected
worksheet, while distinguishing worksheet protection from file protection. The
Open XML [`SheetProtection` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.sheetprotection?view=openxml-3.0.1)
defines the stored element and action attributes. This motivates a narrow
governance-review case: a permission can change while every cell and formula is
identical.

WCAB 0.33 retains `Controls!D2=B2*C2`, its direct
`Dashboard!B4=Controls!$D$2` consumer, enabled sheet protection, every other
action lock, styles, and calculation properties. It changes only raw
`sheetProtection/@sort` from `1` (locked) to `0` (permitted), leaving
`xl/worksheets/sheet1.xml` as the sole package difference. The validator
records that exact stored transition; it does not test a password, encryption,
authentication, authorization, editable ranges, a client sort operation, a
permission decision, or an output value.

## Protected-range descriptors are stored review material, not access proof

ISO/IEC 29500's
[`securityDescriptor` example](https://www.reginfo.gov/public/do/DownloadDocument?objectID=136723002)
places one or more account descriptors as nested children of `protectedRange`.
The standard's text describes these as accounts that may edit a range without
providing the range password, while noting that the descriptor format is
application-defined. The Open XML SDK's
[`ProtectedRange` reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.protectedrange?view=openxml-3.0.1)
also lists the nested child; separately, the Office 2010 extension's
[`ProtectedRange` surface](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.office2010.excel.protectedrange?view=openxml-3.0.1)
documents an attribute-shaped variant. These sources make the document
representation a legitimate review surface, but not a reason to infer identity,
authentication, authorization, encryption, or enforcement by a given client.

WCAB 0.42 therefore uses only the standard nested child form. It keeps the
protected sheet, locked `Controls!B2:B2` target, legacy verifier, range name,
formulas, calculation properties, and all other package members fixed while
one synthetic child text changes. The raw validator verifies both synthetic
texts privately and proves the worksheet-only package boundary. The public
truth contract omits those texts, the range name, and the verifier so adapters
can be scored on redacted material-change evidence rather than exposed account
data.

## Worksheet-control macro assignments can change without a cell edit

Microsoft's [control-button guidance](https://support.microsoft.com/en-us/excel/assign-a-macro-to-a-form-or-a-control-button)
documents that Form and ActiveX controls can run a workbook macro when clicked.
That makes a stored control-to-macro assignment review-material independently
of the worksheet cells a button happens to sit beside. It does not require a
benchmark to package or execute VBA: the security-relevant review boundary is
already present in the local declaration.

WCAB 0.44.1 isolates a compact relationship-bound Form-control declaration. The
baseline and candidate retain one worksheet control, its direct
control-properties relationship and Office 2010 properties part, content type,
ordinary `Controls!B2=12` input, `Controls!D2=B2*C2` formula, direct
`Dashboard!B4=Controls!$D$2` consumer, calculation properties, and every other
package member. Only the private inline control macro assignment differs in
`xl/worksheets/sheet1.xml`. The validator reads only this bounded local OOXML
shape and compares the worksheets after removing that one attribute. It keeps
the control identity, shape ID, macro names, relationship ID, and raw XML
private; it does not load a control, inspect or execute VBA, resolve a macro,
authenticate a user, evaluate permissions, invoke an Office client, or claim
an event-dispatch result.

## Sensitivity-label metadata is a package review surface, not an enforcement result

Microsoft's [Sensitivity Label Information Part specification](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oi29500/c0599e21-b77f-475e-99e0-bd647f60bcbb)
defines a package-root `classificationlabels` relationship targeting an
`application/xml` part whose root is `labelList`. The [LabelInfo stream
specification](https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-offcrypto/8d6d414d-ac0b-40ee-ac87-af2e6401c128)
documents the standard label-list shape, while the [LabelInfo versus custom
document properties note](https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-offcrypto/13939de6-c833-44ab-b213-e0088bf02341)
describes the older reserved custom-property representation. Those sources
establish a real persisted review surface, but they do not justify inferring a
label lookup, effective policy, encryption state, user permission, identity,
or Office/SharePoint/OneDrive enforcement result from one local package diff.

WCAB therefore uses one generated standards-form envelope: `docProps/custom.xml`
has a bound `Sensitivity` property and seven `MSIP_Label_<GUID>_*` properties;
the package root has one bound LabelInfo relationship and
`docMetadata/LabelInfo.xml` `labelList` part. Only the synthetic MIP `Name`
value changes. The raw validator checks the identifiers, values, relationships,
content types, and LabelInfo element privately; public truth publishes only
counts, safe member boundaries, and fixed formula context. The case is scored
as stored-metadata change detection, never as label resolution, policy
evaluation, permission checking, client behavior, or service enforcement.

## Chart series sources without a worksheet edit

Microsoft's [chart-series guidance](https://support.microsoft.com/en-US/Excel/rename-a-data-series)
states that a user can change a series' values in the Select Data dialog without
changing the worksheet data. The Open XML
[`NumberReference` definition](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.drawing.charts.numberreference?view=openxml-3.0.1)
captures the numeric-series reference in the chart part. That leaves a material
review surface that cell and formula diffs can miss: a dashboard chart can point
at another local range while every worksheet cell remains identical.

WCAB 0.15 isolates that stored binding in an original single-chart package. A
chart anchored at `Dashboard!D2` retains its host relationship, title reference,
category reference, source cells, and all non-chart package members. Only its
`c:ser/c:val/c:numRef/c:f` formula moves from `Source!$B$2:$B$4` to
`Source!$C$2:$C$4`. The validator follows the local worksheet-to-drawing-to-
chart relationship chain and compares raw chart XML after removing the declared
formula text. It does not calculate a source, refresh chart data, render a
chart, infer a visible difference, or claim that an Excel client honors the
stored source reference.

## Array-formula semantics

Microsoft's [dynamic-array versus legacy-CSE guidance](https://support.microsoft.com/en-US/Excel/dynamic-array-formulas-vs-legacy-cse-array-formulas)
distinguishes a dynamic array entered in one anchor cell from a legacy CSE
formula entered across a fixed range. It also documents that dynamic arrays
resize as source data changes while legacy CSE ranges do not. That creates a
change-review concern beyond formula text: retaining the same array-capable
formula and currently stored range can still change editability, resizing, and
spill-blocker behavior.

WCAB 0.7 therefore uses a small original `LEN` array formula rather than a
private workbook or a calculated result. The candidate adds the compact OOXML
cell-metadata binding used by dynamic-array writers, while the validator checks
only the stored mode, formula text, and range. It deliberately does not
calculate the array, predict a future spill extent, or assert client-version
compatibility.

## Evidence scoring without a false-positive fiction

The [NIST static-analysis methodology](https://www.nist.gov/system/files/documents/2021/03/24/CAS%202012%20Static%20Analysis%20Tool%20Study%20Methodology.pdf)
defines precision as reported true findings divided by all reported findings,
and recall as reported true findings divided by all known findings. WCAB's
truth is intentionally not a complete list of every difference in a workbook:
it declares review-relevant facts plus coverage boundaries. Calling every
unlisted tool observation a false positive would therefore misrepresent the
oracle. Version 0.3 adds a normalized adapter protocol that measures recall of
declared facts, analyzed coverage, and reference-policy agreement, while
preserving unrecognized observations for review instead of forcing a precision
claim.