@pptx-studio/validate 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @pptx-studio/validate
 
+## 0.3.0
+
+### Minor Changes
+
+- ae2e566: A table's style is the one PowerPoint draws. `BUILTIN_TABLE_STYLES` is PowerPoint's own Table
+  Styles gallery: 74 styles, each with its GUID, its name and the `a:tblStyle` PowerPoint writes for
+  it. `tableStyleOf(table)` returns the built-in a table's GUID names, in any case, or `null` for
+  PowerPoint's default 1-pt black grid; nothing in `ppt/tableStyles.xml` changes which. `builtinTableStyle`
+  and `parseTableStyle` read a `CT_TableStyle` into its thirteen parts. An inline `TableStyleRef` now
+  carries its `id`, a style GUID without braces or with padding throws `MODEL_TABLE_ATTR`, and
+  `MODEL_ERROR_CODES` lists every code, including the new `MODEL_TABLE_STYLE`.
+
+  validate adds `V032`, a warning on a table that names no built-in style, and `V033`, refusing the
+  table-style forms PowerPoint repairs.
+
 ## 0.2.1
 
 ### Patch Changes

package/NOTICE

@@ -27,14 +27,24 @@ Entries are added here at the moment the material lands, not at release time.
       presetShapeDefinitions.xml, 538970 bytes
       sha256 4a762444d8d85876881c02a5b1dedf6f73006fcd8acb7b4e393435615b37c780
 
+  * Microsoft PowerPoint output
+      Written by Microsoft PowerPoint, driven by this project's own scripts.
+
+    @pptx-studio/model contains PowerPoint's 74 built-in table styles: each is
+    the a:tblStyle element PowerPoint writes into ppt/tableStyles.xml, byte for
+    byte, enumerated through PowerPoint's Table Styles gallery and saved by
+    PowerPoint (LEGAL.md, ADR 0063). corpus/ground-truth/table-styles.json holds
+    the same 74.
+
+    The decks in corpus/authored are PowerPoint Blank Presentations, so each
+    carries the Microsoft-generated ppt/theme/theme1.xml and default layouts
+    PowerPoint writes into a new deck (ADR 0009).
+
 --------------------------------------------------------------------------------
 Attributions the plan commits us to, listed so the obligation is visible before
 the code arrives
 --------------------------------------------------------------------------------
 
-  * Pattern fill tiles (sub-phase 2.7) are generated from Mono libgdiplus.
-      libgdiplus - Copyright Novell, Inc. and contributors - MIT
-
   * Metric-compatible substitute fonts ship in a separate package,
     @pptx-studio/fonts-metric-compat, under SIL OFL 1.1 with its own
     OFL.txt and reserved-font-name handling. They are deliberately kept out

package/README.md

@@ -1,6 +1,6 @@
 # @pptx-studio/validate
 
-**The repair firewall.** Thirty-one rules a `.pptx` must not break, checked
+**The repair firewall.** Thirty-three rules a `.pptx` must not break, checked
 before any bytes are handed over, each finding carrying the part and the XPath.
 
 Apache-2.0 · browser and Web Worker only, no Node · part of
@@ -28,7 +28,7 @@ quietly lost something.
 So this is not a schema validator with a nice report. It is the only feedback
 loop that exists, and it runs on every export in development and in production.
 
-## Thirty-one rules, in two halves
+## Thirty-three rules, in two halves
 
 Roughly half come from ECMA-376: content-type coverage, `xsd:sequence` child
 order, `minOccurs`, the four identifier ranges. Those are derivable, and one of
@@ -38,19 +38,23 @@ schemas and checked against 194 148 elements PowerPoint wrote.
 The other half cannot be derived from anything. Each is the record of a package
 built with **one** change in it, opened in PowerPoint 16.0.20326, and declined:
 
-|        |                                                                                                      |
-| ------ | ---------------------------------------------------------------------------------------------------- |
-| `V022` | a `p:ph type="hdr"` on a slide. The other seven content types all open.                              |
-| `V023` | a geometry guide referenced but never defined. `ST_GeomGuideName` is an unconstrained token.         |
-| `V024` | a `c:strLit` inside a series `c:tx`, two elements away from where the literal forms are legal.       |
-| `V025` | a `p:control`, in all eight forms tried. An empty `p:controls` is accepted.                          |
-| `V026` | a `cs:chartStyle` with thirty of its thirty-one entries. No chart style at all is fine.              |
-| `V019` | a master id colliding with a layout id. They are one number space and no schema says so.             |
-| `V020` | a `p:cNvPr/@id` between 2147483648 and 4294967294. 4294967295 opens; it is minus one.                |
-| `V009` | a slide without exactly one layout relationship; a `cx:chartSpace` with no `.rels`.                  |
-| `V004` | a percent-escape of an _unreserved_ character in a part name. `0x808D1005`.                          |
-| `V012` | an `a:ahXY` directly under `a:custGeom`, without its `a:ahLst` wrapper.                              |
-| `V031` | an `a:gridCol` without `@w`, an `a:tr` without `@h`, `gridSpan="2.0"`, `hMerge="on"`: a repair each. |
+|        |                                                                                                         |
+| ------ | ------------------------------------------------------------------------------------------------------- |
+| `V022` | a `p:ph type="hdr"` on a slide. The other seven content types all open.                                 |
+| `V023` | a geometry guide referenced but never defined. `ST_GeomGuideName` is an unconstrained token.            |
+| `V024` | a `c:strLit` inside a series `c:tx`, two elements away from where the literal forms are legal.          |
+| `V025` | a `p:control`, in all eight forms tried. An empty `p:controls` is accepted.                             |
+| `V026` | a `cs:chartStyle` with thirty of its thirty-one entries. No chart style at all is fine.                 |
+| `V019` | a master id colliding with a layout id. They are one number space and no schema says so.                |
+| `V020` | a `p:cNvPr/@id` between 2147483648 and 4294967294. 4294967295 opens; it is minus one.                   |
+| `V009` | a slide without exactly one layout relationship; a `cx:chartSpace` with no `.rels`.                     |
+| `V004` | a percent-escape of an _unreserved_ character in a part name. `0x808D1005`.                             |
+| `V012` | an `a:ahXY` directly under `a:custGeom`, without its `a:ahLst` wrapper.                                 |
+| `V031` | an `a:gridCol` without `@w`, an `a:tr` without `@h`, `gridSpan="2.0"`, `hMerge="on"`: a repair each.    |
+| `V033` | a table style id without braces or padded, a table-style part without `@def`, `b="yes"`: a repair each. |
+
+And one warning measured the same way: `V032`, a table naming none of PowerPoint's 74 built-in
+table styles, which PowerPoint draws as a 1-pt black grid whatever the package defines.
 
 Every rule carries a `why` recording what was tried and what opened, so whoever
 eventually contradicts one knows what they are contradicting.
@@ -86,7 +90,7 @@ the same reason.
 
 Two suites that check opposite things, and neither substitutes for the other.
 
-**It fires.** `validate.test.ts` breaks a minimal deck thirty-one ways, one per
+**It fires.** `validate.test.ts` breaks a minimal deck once per
 rule, and asserts each rule reports the right part and the right XPath.
 
 **It is quiet.** `tools/corpus/suites/validate.test.ts` runs all fifty-two committed

package/dist/index.d.ts

@@ -49,46 +49,9 @@ export declare function isValidateError(value: unknown): value is ValidateError;
 //#endregion
 //#region src/rules/rules.d.ts
 /**
- * The thirty-one rules, and the evidence for each.
- *
- * ## Why a table and not thirty-one functions
- *
- * The functions are in the files beside this one. What lives here is the part a
- * person reads: what each rule claims, how sure we are, and *how we know*. A
- * validator whose rules exist only as code is a validator nobody can audit, and
- * this one has to be audited, because roughly half of it enforces things no
- * schema says.
- *
- * That is the fact that shapes the whole package. ECMA-376 is a description of
- * a file format; PowerPoint is an implementation that refuses files the
- * description permits. Sub-phase 0.7 and the corpus bisections in
- * `tools/corpus/ROSTER.md` found nineteen such refusals by building a package
- * with one change in it and watching PowerPoint decline to open it - no
- * diagnostic, no log, no part named, just "PowerPoint could not open the file"
- * or `0x80070570`. Every rule below whose `evidence` says `measured` came from
- * that loop and from nowhere else.
- *
- * So each rule carries three things beyond its check:
- *
- * - `evidence` - `schema` (ECMA-376 says so), `measured` (we watched PowerPoint
- *   refuse it), or `both`.
- * - `why` - the sentence that justifies the rule to somebody who is about to
- *   delete it because it fired on their file.
- * - `severity` - `fatal` refuses an export; `warning` is reported and does not.
- *
- * ## On being wrong in the safe direction
- *
- * A false positive here blocks an export a user wanted. A false negative hands
- * them a file PowerPoint will not open, with no way to find out why. Those are
- * not symmetric, but the first is not free either - a validator that fires on
- * good files gets turned off, and then it catches nothing.
- *
- * The resolution is `origin`, which lives on the finding rather than here: a
- * fatal a caller *introduced* refuses the export, and the identical fatal that
- * was already in the file when it was opened is reported and does not. That is
- * the same split `PartStore.write` already makes for dangling relationships,
- * and for the same reason - refusing to re-export a file we did not break makes
- * the file unopenable in this editor and does not fix anything.
+ * The rules, and the evidence for each: `schema`, `measured` (PowerPoint refused or repaired it),
+ * or `both`. A fatal a caller introduced refuses an export; the same fatal inherited from the
+ * opened file is reported and does not. The README lists every rule.
  */
 type RuleCategory = 'package' | 'relationships' | 'order' | 'required' | 'ids' | 'refused' | 'preservation';
 type Severity = 'fatal' | 'warning';
@@ -104,13 +67,8 @@ interface Rule {
   /** Why the rule exists, for whoever is about to argue with it. */
   readonly why: string;
   /**
-   * True when the rule needs the package as it was opened as well as the
-   * package about to be written.
-   *
-   * Six rules do. They are skipped rather than passed when no baseline is
-   * given, and the report says so - a preservation rule that silently reports
-   * nothing because it had nothing to compare against is worse than one that
-   * did not run, because it looks like a pass.
+   * True when the rule needs the package as it was opened; without a baseline it is reported as
+   * skipped, never as passed.
    */
   readonly needsBaseline?: true;
 }
@@ -334,6 +292,20 @@ export declare const RULES: readonly [{
   readonly evidence: "both";
   readonly title: "`a:gridCol/@w`, `a:tr/@h`, and typed `gridSpan`, `rowSpan`, `hMerge`, `vMerge`";
   readonly why: string;
+}, {
+  readonly id: "V032";
+  readonly category: "ids";
+  readonly severity: "warning";
+  readonly evidence: "measured";
+  readonly title: "a table names one of PowerPoint's 74 built-in table styles, or none";
+  readonly why: string;
+}, {
+  readonly id: "V033";
+  readonly category: "required";
+  readonly severity: "fatal";
+  readonly evidence: "both";
+  readonly title: "a table style id is a braced GUID, and the table-style part is one PowerPoint keeps";
+  readonly why: string;
 }];
 type RuleId = (typeof RULES)[number]['id'];
 export declare function ruleById(id: string): Rule | undefined;
@@ -440,33 +412,9 @@ export declare function rootName(document: XDocument): string;
 //#endregion
 //#region src/report/report.d.ts
 /**
- * What validation produces.
- *
- * ## Origin, and why it is computed rather than guessed
- *
- * The hardest question this package has to answer is not "is this file valid".
- * It is **"did we break it"**, and those are different questions with different
- * consequences. A fatal finding in a deck the user imported ten seconds ago is
- * information; the same finding in a deck they just edited is a bug in us, and
- * handing over the bytes would give them a repair prompt with no explanation.
- *
- * Refusing both would be the strict-looking choice and it is the wrong one. It
- * would mean that a deck with one pre-existing defect - a dangling image
- * relationship, say, which PowerPoint tolerates and which is common in files
- * that have been through three other tools - could be opened in this editor and
- * never saved again. The editor would be refusing to give the user back their
- * own file over a problem it did not cause and cannot fix. `PartStore.write`
- * already made exactly this call for dangling relationships, and this is the
- * same call generalised to all thirty-one rules.
- *
- * So `origin` is not a per-rule judgement call. It is computed by running the
- * rules a second time against the package **as it was opened** and differencing
- * the two reports: a finding that is in both is `inherited`, one that is only in
- * the new report is `introduced`. That is exact, it needs no rule to reason
- * about history, and it cannot drift from what the rules actually do.
- *
- * The second pass only happens when the first found something fatal, so a clean
- * export - the overwhelmingly common case - pays nothing for it.
+ * A finding is `inherited` when the package as it was opened already had it, `introduced` when it
+ * did not, computed by running the rules on both and differencing. Only an introduced fatal refuses
+ * an export, so a deck with a defect it arrived with can still be saved.
  */
 type Origin =
 /** The finding is in the package we are about to write and was not in the original. */
@@ -555,28 +503,9 @@ export declare function formatReport(report: Report, options?: FormatOptions): s
 //#endregion
 //#region src/context.d.ts
 /**
- * The state a rule reads, and the one method it writes.
- *
- * Every rule is `(ctx: Context) => void`. That is a deliberately small
- * interface, and it is the same shape `checkLayering({manifests, catalog})` and
- * `checkCorpus({manifests, files, ...})` already have in this repository, for
- * the same reason: a rule that takes a context and returns nothing is a rule
- * that can be run against a package assembled in a test, with no temporary
- * directory, no archive on disk and no other twenty-eight rules running beside
- * it obscuring which one fired.
- *
- * ## Everything is lazy, and everything is cached
- *
- * Twelve of the rules want the parsed tree of every XML part. Parsing each part
- * once per rule would be twelve passes over a deck that can be two hundred
- * megabytes. Parsing all of them up front would be one pass too many for the
- * package-level rules, which need no trees at all.
- *
- * So `document()` parses on first ask and remembers. A part that is not XML
- * returns `null` and is not asked again. A part that will not *parse* also
- * returns `null` - and records a `ReadProblem`, because a rule that silently
- * saw nothing is indistinguishable from a rule that found nothing, and those
- * are opposite answers.
+ * The state a rule reads, and the one method it writes. Every rule is `(ctx: Context) => void`,
+ * so one runs alone against a package built in a test. Trees parse on first ask and are cached;
+ * a part that will not parse returns `null` and records a `ReadProblem`.
  */
 interface Context {
   /** The package about to be handed over, or the one being inspected. */
@@ -688,11 +617,11 @@ interface ValidateOptions {
    * those are skipped and the report says so.
    */
   readonly bytes?: Uint8Array;
-  /** The package as it was opened. The six preservation rules need it. */
+  /** The package as it was opened. The preservation rules need it. */
   readonly baseline?: PartStore;
   /** The baseline's archive, so an inherited `V003` can be recognised as inherited. */
   readonly baselineBytes?: Uint8Array;
-  /** A subset to run. Defaults to all twenty-nine. */
+  /** A subset to run. Defaults to every rule. */
   readonly rules?: readonly RuleId[];
   /** Passed to `readZip` when `bytes` are given. */
   readonly zip?: ReadZipOptions;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/errors.ts","../src/rules/rules.ts","../src/report/location.ts","../src/report/report.ts","../src/context.ts","../src/validate.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/errors.ts","../src/rules/rules.ts","../src/report/location.ts","../src/report/report.ts","../src/context.ts","../src/validate.ts"],"mappings":"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"}

package/dist/index.js

@@ -295,6 +295,22 @@ const RULES = [
 		evidence: "both",
 		title: "`a:gridCol/@w`, `a:tr/@h`, and typed `gridSpan`, `rowSpan`, `hMerge`, `vMerge`",
 		why: "`CT_TableCol/@w` and `CT_TableRow/@h` are required `ST_Coordinate`s, the spans are `xsd:int` and the flags `xsd:boolean`. C7 measured each: a `gridCol` without `@w`, a `tr` without `@h`, `gridSpan=\"2.0\"` and `hMerge=\"on\"` are a repair prompt apiece; PowerPoint saves the column at its minimum width, the row at zero, the span gone and the flag as \"1\". `w=\"108pt\"`, the universal-measure spelling, opens clean and is not this rule."
+	},
+	{
+		id: "V032",
+		category: "ids",
+		severity: "warning",
+		evidence: "measured",
+		title: "a table names one of PowerPoint's 74 built-in table styles, or none",
+		why: "C8 drew 84 probe packages in three themes. A table whose `a:tableStyleId`, or inline `a:tableStyle`, names one of the 74 built-ins draws that built-in, in any case, whatever `ppt/tableStyles.xml` says about it; any other id - defined in the part or not - draws a 1-pt black grid with no fill, and an id nothing defines is dropped on the next save. The deck opens without a word, which is why this is a warning: the file names one style and PowerPoint draws another."
+	},
+	{
+		id: "V033",
+		category: "required",
+		severity: "fatal",
+		evidence: "both",
+		title: "a table style id is a braced GUID, and the table-style part is one PowerPoint keeps",
+		why: "`ST_Guid` is a GUID in braces, `CT_TableStyleList/@def` and `CT_TableStyle/@styleId` are required, `b` and `i` are `ST_OnOffStyleType` and a border or fill must hold one. C8 measured each as a repair prompt: an id without braces or with padding, a `tblPr` naming its style twice, a part whose root is not `a:tblStyleLst`, a list without `@def`, a style without `@styleId`, `b=\"yes\"`, an edge with neither `a:ln` nor `a:lnRef`, and an empty `a:fill`. PowerPoint writes the all-zero GUID for the id and empties the part."
 	}
 ];
 const BY_ID = new Map(RULES.map((rule) => [rule.id, rule]));
@@ -645,14 +661,7 @@ function readRelsParts(ctx) {
 	return parts;
 }
 /**
-* Memoised above, because five of the thirty-one rules want this list and each
-* would otherwise re-walk every `.rels` part in the package. The parsed trees
-* are already cached on the context; what is saved here is the element scan and
-* the allocation, which on a three-hundred-slide deck is five passes over a
-* thousand relationship parts for one answer that cannot have changed.
-*
-* Keyed by context rather than by store, so nothing survives one validation run
-* into the next.
+* Memoised per context: several rules want every relationship part, and this walks them once.
 */
 function scanRelsParts(ctx) {
 	const out = [];
@@ -1169,16 +1178,8 @@ function forEachElement$1(ctx, visit) {
 //#endregion
 //#region src/rules/required.ts
 /**
-* `V013` … `V017`, `V030` and `V031`: children and attributes that are not optional.
-*
-* Every one of these is a `minOccurs` the schema states plainly, and every one
-* is broken the same way: by an editor deleting the last of something. The last
-* paragraph goes and a `p:txBody` is left with no `a:p`; a shape is dragged out
-* of a group and the group's `p:grpSpPr` is dropped with it. That is why these
-* are separate rules from the ordering ones even though a missing child and a
-* misplaced child are both "the sequence is wrong": the messages have to say
-* *add this*, not *move this*, and they have to fire on the parent rather than
-* on a child that is not there to point at.
+* `V013` … `V017`, `V030`, `V031` and `V033`: children and attributes that are not optional.
+* Each is a `minOccurs` or a type the schema states, reported on the element that lacks it.
 */
 /** The twelve attributes of `CT_ColorMapping`. All required, no defaults. */
 const CLR_MAP_ATTRIBUTES = [
@@ -1288,6 +1289,82 @@ function v031TableAttributes(ctx) {
 		}
 	});
 }
+/** `ST_Guid`, in any case: C8 measured lower case opening clean. */
+const TABLE_STYLE_GUID$1 = /^\{[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\}$/i;
+const ON_OFF_STYLES = /* @__PURE__ */ new Set([
+	"on",
+	"off",
+	"def"
+]);
+const TABLE_STYLE_EDGES = /* @__PURE__ */ new Set([
+	"left",
+	"right",
+	"top",
+	"bottom",
+	"insideH",
+	"insideV",
+	"tl2br",
+	"tr2bl"
+]);
+const FILL_PROPERTIES = /* @__PURE__ */ new Set([
+	"noFill",
+	"solidFill",
+	"gradFill",
+	"blipFill",
+	"pattFill",
+	"grpFill"
+]);
+const drawingChildren = (element, local) => childElements(element).filter((child) => child.local === local && namespaceOf(child) === NS.a);
+/** A table-style id is a braced GUID, and a table style has the parts C8 measured as required. */
+function v033TableStyles(ctx) {
+	for (const part of ctx.parts()) {
+		if (ctx.contentType(part) !== CONTENT_TYPE.tableStyles) continue;
+		const root = ctx.document(part)?.root;
+		if (root === void 0 || root.local === "tblStyleLst" && namespaceOf(root) === NS.a) continue;
+		ctx.add("V033", elementLocation(part, root), `The table-style part's root is <${root.qname}>, not <a:tblStyleLst>. C8 measured this as a repair prompt.`);
+	}
+	forEachElement(ctx, (part, element) => {
+		if (namespaceOf(element) !== NS.a) return;
+		const report = (at, what) => {
+			ctx.add("V033", elementLocation(part, at), what + " C8 measured this as a repair prompt.");
+		};
+		if (element.local === "tblPr" && drawingChildren(element, "tableStyleId").length > 0 && drawingChildren(element, "tableStyle").length > 0) report(element, "<a:tblPr> names its style twice, by <a:tableStyleId> and <a:tableStyle>.");
+		const guid = (raw, what) => {
+			if (!TABLE_STYLE_GUID$1.test(raw)) report(element, `${what} is "${raw}", which is not a GUID in braces.`);
+		};
+		switch (element.local) {
+			case "tableStyleId":
+				guid(textContent(element), "<a:tableStyleId>");
+				return;
+			case "tableStyle":
+			case "tblStyle": {
+				const id = attributeValue(element, "styleId");
+				if (id === void 0) report(element, `<a:${element.local}> has no @styleId.`);
+				else guid(id, `<a:${element.local}>/@styleId`);
+				return;
+			}
+			case "tblStyleLst":
+				if (attributeValue(element, "def") === void 0) report(element, "<a:tblStyleLst> has no @def.");
+				return;
+			case "tcTxStyle":
+				for (const name of ["b", "i"]) {
+					const raw = attributeValue(element, name);
+					if (raw !== void 0 && !ON_OFF_STYLES.has(raw)) report(element, `<a:tcTxStyle>/@${name} is "${raw}", not on, off or def.`);
+				}
+				return;
+			case "tcBdr":
+				for (const edge of childElements(element)) {
+					if (!TABLE_STYLE_EDGES.has(edge.local) || namespaceOf(edge) !== NS.a) continue;
+					if (drawingChildren(edge, "ln").length + drawingChildren(edge, "lnRef").length === 0) report(edge, `<a:${edge.local}> has neither <a:ln> nor <a:lnRef>.`);
+				}
+				return;
+			case "tcStyle":
+			case "tblBg":
+				for (const fill of drawingChildren(element, "fill")) if (!childElements(fill).some((child) => FILL_PROPERTIES.has(child.local))) report(fill, "<a:fill> holds no fill.");
+				return;
+		}
+	});
+}
 /** Zero is one and a negative runs to the edge: C7's span-zero and span-negative. */
 function spanOf(raw) {
 	if (raw === void 0) return 1;
@@ -1404,22 +1481,93 @@ function forEachElement(ctx, visit) {
 	}
 }
 //#endregion
+//#region src/rules/table-style-ids.ts
+/**
+* The GUIDs of PowerPoint's 74 built-in table styles, in its gallery's order.
+* GENERATED by tools/ground-truth/model/tables/styles/write-tables.ts from
+* corpus/ground-truth/table-styles.json. Do not edit: rules.test.ts re-derives it.
+*/
+const BUILTIN_TABLE_STYLE_IDS = [
+	"{2D5ABB26-0587-4C30-8999-92F81FD0307C}",
+	"{3C2FFA5D-87B4-456A-9821-1D502468CF0F}",
+	"{284E427A-3D55-4303-BF80-6455036E1DE7}",
+	"{69C7853C-536D-4A76-A0AE-DD22124D55A5}",
+	"{775DCB02-9BB8-47FD-8907-85C794F793BA}",
+	"{35758FB7-9AC5-4552-8A53-C91805E547FA}",
+	"{08FB837D-C827-4EFA-A057-4D05807E0F7C}",
+	"{5940675A-B579-460E-94D1-54222C63F5DA}",
+	"{D113A9D2-9D6B-4929-AA2D-F23B5EE8CBE7}",
+	"{18603FDC-E32A-4AB5-989C-0864C3EAD2B8}",
+	"{306799F8-075E-4A3A-A7F6-7FBC6576F1A4}",
+	"{E269D01E-BC32-4049-B463-5C60D7B0CCD2}",
+	"{327F97BB-C833-4FB7-BDE5-3F7075034690}",
+	"{638B1855-1B75-4FBE-930C-398BA8C253C6}",
+	"{9D7B26C5-4107-4FEC-AEDC-1716B250A1EF}",
+	"{3B4B98B0-60AC-42C2-AFA5-B58CD77FA1E5}",
+	"{0E3FDE45-AF77-4B5C-9715-49D594BDF05E}",
+	"{C083E6E3-FA7D-4D7B-A595-EF9225AFEA82}",
+	"{D27102A9-8310-4765-A935-A1911B00CA55}",
+	"{5FD0F851-EC5A-4D38-B0AD-8093EC10F338}",
+	"{68D230F3-CF80-4859-8CE7-A43EE81993B5}",
+	"{7E9639D4-E3E2-4D34-9284-5A2195B3D0D7}",
+	"{69012ECD-51FC-41F1-AA8D-1B2483CD663E}",
+	"{72833802-FEF1-4C79-8D5D-14CF1EAF98D9}",
+	"{F2DE63D5-997A-4646-A377-4702673A728D}",
+	"{17292A2E-F333-43FB-9621-5CBBE7FDCDCB}",
+	"{5A111915-BE36-4E01-A7E5-04B1672EAD32}",
+	"{912C8C85-51F0-491E-9774-3900AFEF0FD7}",
+	"{616DA210-FB5B-4158-B5E0-FEB733F419BA}",
+	"{BC89EF96-8CEA-46FF-86C4-4CE0E7609802}",
+	"{5DA37D80-6434-44D0-A028-1B22A696006F}",
+	"{8799B23B-EC83-4686-B30A-512413B5E67A}",
+	"{ED083AE6-46FA-4A59-8FB0-9F97EB10719F}",
+	"{BDBED569-4797-4DF1-A0F4-6AAB3CD982D8}",
+	"{E8B1032C-EA38-4F05-BA0D-38AFFFC7BED3}",
+	"{793D81CF-94F2-401A-BA57-92F5A7B2D0C5}",
+	"{B301B821-A1FF-4177-AEE7-76D212191A09}",
+	"{9DCAF9ED-07DC-4A11-8D7F-57B35C25682E}",
+	"{1FECB4D8-DB02-4DC6-A0A2-4F2EBAE1DC90}",
+	"{1E171933-4619-4E11-9A3F-F7608DF75F80}",
+	"{FABFCF23-3B69-468F-B69F-88F6DE6A72F2}",
+	"{10A1B5D5-9B99-4C35-A422-299274C87663}",
+	"{073A0DAA-6AF3-43AB-8588-CEC1D06C72B9}",
+	"{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}",
+	"{21E4AEA4-8DFA-4A89-87EB-49C32662AFE0}",
+	"{F5AB1C69-6EDB-4FF4-983F-18BD219EF322}",
+	"{00A15C55-8517-42AA-B614-E9B94910E393}",
+	"{7DF18680-E054-41AD-8BC1-D1AEF772440D}",
+	"{93296810-A885-4BE3-A3E7-6D5BEEA58F35}",
+	"{8EC20E35-A176-4012-BC5E-935CFFF8708E}",
+	"{6E25E649-3F16-4E02-A733-19D2CDBF48F0}",
+	"{85BE263C-DBD7-4A20-BB59-AAB30ACAA65A}",
+	"{EB344D84-9AFB-497E-A393-DC336BA19D2E}",
+	"{EB9631B5-78F2-41C9-869B-9F39066F8104}",
+	"{74C1A8A3-306A-4EB7-A6B1-4F7E0EB9C5D6}",
+	"{2A488322-F2BA-4B5B-9748-0D474271808F}",
+	"{D7AC3CCA-C797-4891-BE02-D94E43425B78}",
+	"{69CF1AB2-1976-4502-BF36-3FF5EA218861}",
+	"{8A107856-5554-42FB-B03E-39F5DBC370BA}",
+	"{0505E3EF-67EA-436B-97B2-0124C06EBD24}",
+	"{C4B1156A-380E-4F78-BDF5-A606A8083BF9}",
+	"{22838BEF-8BB2-4498-84A7-C5851F593DF1}",
+	"{16D9F66E-5EB9-4882-86FB-DCBF35E3C3E4}",
+	"{E8034E78-7F5D-4C2E-B375-FC64B27BC917}",
+	"{125E5076-3810-47DD-B79F-674D7AD40C01}",
+	"{37CE84F3-28C3-443E-9E96-99CF82512B78}",
+	"{D03447BB-5D67-496B-8E87-E561075AD55C}",
+	"{E929F9F4-4A8F-4326-A1B4-22849713DDAB}",
+	"{8FD4443E-F989-4FC4-A0C8-D5A2AF1F390B}",
+	"{AF606853-7671-496A-8E4F-DF71F8EC918B}",
+	"{5202B0CA-FC54-4496-8BCA-5EF66A818D29}",
+	"{0660B408-B3CF-4A94-85FC-2B1E0A45F4A2}",
+	"{91EBBBCC-DAD2-459C-BE2E-F6DE35CF9A28}",
+	"{46F890A9-2807-4EBB-B81D-B2AA78EC7F39}"
+];
+//#endregion
 //#region src/rules/id.ts
 /**
-* `V018` … `V021`: four identifier spaces, and never one allocator.
-*
-* A presentation has four kinds of id and they do not share a rule between
-* them. Slide ids start at 256 and stop at 2147483647. Master and layout ids
-* start at 2147483648, and - the part no schema says - come out of **one**
-* counter shared between them. Shape ids are unique inside a part and free to
-* repeat across parts. Placeholder indices are not identifiers at all; they are
-* a join key against another part.
-*
-* Every one of those is a way to break a file that looks like a way to be
-* tidy. Renumbering shape ids to be unique across the deck is the obvious
-* example: it is more consistent, it is what a database would do, and it
-* detaches every `p:custDataLst`, VML `@spid` and animation target that names
-* the old number.
+* `V018` … `V021` and `V032`: identifier spaces and the ids that name into them. Slide, sheet and
+* shape ids never share an allocator, and a table style id names one of PowerPoint's built-ins.
 */
 const SLIDE_ID_MIN = 256;
 const SLIDE_ID_MAX = 2147483647;
@@ -1641,6 +1789,19 @@ function v021PlaceholderIndices(ctx) {
 		}
 	}
 }
+const BUILTIN_TABLE_STYLES = new Set(BUILTIN_TABLE_STYLE_IDS);
+/** A well-formed id; V033 reports the rest. */
+const TABLE_STYLE_GUID = /^\{[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\}$/i;
+/** A table's `a:tableStyleId`, or its inline `a:tableStyle/@styleId`, names a built-in (C8). */
+function v032TableStyleIds(ctx) {
+	forEachElement(ctx, (part, element) => {
+		if (namespaceOf(element) !== NS.a) return;
+		const named = element.local === "tableStyleId" ? textContent(element) : element.local === "tableStyle" ? attributeValue(element, "styleId") : void 0;
+		if (named === void 0 || !TABLE_STYLE_GUID.test(named)) return;
+		if (BUILTIN_TABLE_STYLES.has(named.toUpperCase())) return;
+		ctx.add("V032", elementLocation(part, element), `<a:${element.local}> names ${named}, none of PowerPoint's 74 built-in table styles. PowerPoint draws a 1-pt black grid instead, whatever ppt/tableStyles.xml defines (C8).`);
+	});
+}
 //#endregion
 //#region src/rules/refusal.ts
 /**
@@ -2109,12 +2270,7 @@ function v029TextAndFieldIdentity(ctx) {
 //#endregion
 //#region src/validate.ts
 /**
-* The thirty-one, wired to their implementations.
-*
-* A plain table, so that "is every rule reachable" is a thing a test can ask
-* rather than a thing a reader has to believe. `rules.test.ts` asserts that the
-* keys here are exactly `RULE_IDS` - a rule with a definition and no function
-* would otherwise sit in the table looking enforced.
+* Every rule wired to its implementation; `rules.test.ts` holds the keys to `RULE_IDS`.
 */
 const IMPLEMENTATIONS = {
 	V001: v001ContentTypeCoverage,
@@ -2147,7 +2303,9 @@ const IMPLEMENTATIONS = {
 	V028: v028OpaqueContainersUnchanged,
 	V029: v029TextAndFieldIdentity,
 	V030: v030TableGrid,
-	V031: v031TableAttributes
+	V031: v031TableAttributes,
+	V032: v032TableStyleIds,
+	V033: v033TableStyles
 };
 /** Rules that cannot run without the archive bytes. See `Context.archive`. */
 const ARCHIVE_RULES = ["V003"];
@@ -2220,20 +2378,9 @@ function run(ctx, rules) {
 	for (const id of rules) IMPLEMENTATIONS[id](ctx);
 }
 /**
-* Decide, for each finding, whether we introduced it.
-*
-* The second pass is the whole of it: run the same rules against the package as
-* it was opened and difference the two sets. A finding in both was already
-* there. See `report.ts` for why that question is the one that decides whether
-* an export is refused, and why answering it by differencing beats answering it
-* per rule.
-*
-* Three properties make it cheap enough to be unconditional in the only case
-* that matters. It runs **only when something fatal was found**, so a clean
-* export - which is nearly all of them - pays nothing. It runs **only the rules
-* that fired**, not all twenty-nine. And it skips the preservation rules, which
-* would be comparing the baseline against itself and would find nothing by
-* construction.
+* Which findings were already in the package as it was opened: the fired rules run again on
+* the baseline and the two sets are differenced. Only when something fatal was found, only the
+* rules that fired, and never the preservation rules. `report.ts` has why.
 */
 function attributeOrigins(ctx, options, running) {
 	const baseline = options.baseline;