@pptx-studio/validate 0.1.2 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @pptx-studio/validate
 
+## 0.2.1
+
+### Patch Changes
+
+- b58dd19: Built with tsdown 0.23. The declarations take a new shape, and the API is unchanged.
+
+  - Every value is exported where it is declared (`export declare function …`), not in a trailing
+    `export { … }`.
+  - The types are exported in one `export type { … }`.
+  - The JavaScript is byte-for-byte what 0.22 emitted.
+  - In geometry, opc, validate and xml, the source maps name fewer symbols.
+
+- Updated dependencies [b58dd19]
+  - @pptx-studio/opc@0.1.3
+  - @pptx-studio/xml@0.1.2
+
+## 0.2.0
+
+### Minor Changes
+
+- e8ba475: A table is parsed, and its grid is the one PowerPoint draws.
+
+  `Shape.table` carries the `a:tbl` of a `p:graphicFrame`: the `a:tblPr` flags and style source, every
+  `a:gridCol`, every `a:tr` with its cells, and each cell's spans, body and `a:tcPr` as written.
+  `tableGrid` resolves the merges by the rule C7 measured (`tables.json`, 76 of 76 tables PowerPoint
+  opened as written and 21 it authored itself): each `a:tc` takes the next column, the spans on the
+  anchor are the whole story, a covered position is covered whatever its own attributes say, a span
+  stops at the edge or at the first claimed position, and `hMerge`/`vMerge` change nothing. `a:tr/@h`
+  is a minimum, a column is never narrower than its cells' side margins plus 2 pt, and the frame's
+  `a:ext` says nothing about the drawn size. A table attribute of the wrong type throws
+  `MODEL_TABLE_ATTR`.
+
+  `@pptx-studio/validate` gains `V030`, a warning on a table whose rows, spans and flags disagree —
+  PowerPoint opens it silently and rewrites it on the next save — and `V031`, fatal on the missing or
+  mistyped table attributes PowerPoint repairs. The downstream packages carry the new rules and the
+  new field; nothing they draw changes.
+
 ## 0.1.2
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # @pptx-studio/validate
 
-**The repair firewall.** Twenty-nine rules a `.pptx` must not break, checked
+**The repair firewall.** Thirty-one 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.
 
-## Twenty-nine rules, in two halves
+## Thirty-one 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,18 +38,19 @@ 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.                        |
+|        |                                                                                                      |
+| ------ | ---------------------------------------------------------------------------------------------------- |
+| `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. |
 
 Every rule carries a `why` recording what was tried and what opened, so whoever
 eventually contradicts one knows what they are contradicting.
@@ -85,7 +86,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 twenty-nine ways, one per
+**It fires.** `validate.test.ts` breaks a minimal deck thirty-one ways, one 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

@@ -24,7 +24,7 @@ import { PartName, PartStore, ReadZipOptions, ZipArchive } from "@pptx-studio/op
  *
  * Deliberately few. Almost everything this package has to say is a finding.
  */
-declare const VALIDATE_ERROR_CODES: readonly ["ERR_VALIDATION_FAILED", "ERR_UNVALIDATABLE", "ERR_UNKNOWN_RULE"];
+export declare const VALIDATE_ERROR_CODES: readonly ["ERR_VALIDATION_FAILED", "ERR_UNVALIDATABLE", "ERR_UNKNOWN_RULE"];
 type ValidateErrorCode = (typeof VALIDATE_ERROR_CODES)[number];
 interface ValidateErrorDetail {
   /** The part the failure is about, if it is about one. */
@@ -40,18 +40,18 @@ interface ValidateErrorDetail {
    */
   readonly report?: unknown;
 }
-declare class ValidateError extends Error {
+export declare class ValidateError extends Error {
   readonly code: ValidateErrorCode;
   readonly detail: ValidateErrorDetail;
   constructor(code: ValidateErrorCode, message: string, detail?: ValidateErrorDetail);
 }
-declare function isValidateError(value: unknown): value is ValidateError;
+export declare function isValidateError(value: unknown): value is ValidateError;
 //#endregion
 //#region src/rules/rules.d.ts
 /**
- * The twenty-nine rules, and the evidence for each.
+ * The thirty-one rules, and the evidence for each.
  *
- * ## Why a table and not twenty-nine functions
+ * ## 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
@@ -114,7 +114,7 @@ interface Rule {
    */
   readonly needsBaseline?: true;
 }
-declare const RULES: readonly [{
+export declare const RULES: readonly [{
   readonly id: "V001";
   readonly category: "package";
   readonly severity: "fatal";
@@ -223,7 +223,7 @@ declare const RULES: readonly [{
   readonly id: "V016";
   readonly category: "required";
   readonly severity: "fatal";
-  readonly evidence: "schema";
+  readonly evidence: "both";
   readonly title: "every text body has `a:bodyPr` and at least one `a:p`";
   readonly why: string;
 }, {
@@ -320,12 +320,26 @@ declare const RULES: readonly [{
   readonly needsBaseline: true;
   readonly title: "text and field identity survive: `xml:space`, `a:fld/@id`, cached field text";
   readonly why: string;
+}, {
+  readonly id: "V030";
+  readonly category: "required";
+  readonly severity: "warning";
+  readonly evidence: "measured";
+  readonly title: "a table is the one PowerPoint reads: a cell per column in every row, a flag where a span covers";
+  readonly why: string;
+}, {
+  readonly id: "V031";
+  readonly category: "required";
+  readonly severity: "fatal";
+  readonly evidence: "both";
+  readonly title: "`a:gridCol/@w`, `a:tr/@h`, and typed `gridSpan`, `rowSpan`, `hMerge`, `vMerge`";
+  readonly why: string;
 }];
 type RuleId = (typeof RULES)[number]['id'];
-declare function ruleById(id: string): Rule | undefined;
-declare const RULE_IDS: readonly RuleId[];
+export declare function ruleById(id: string): Rule | undefined;
+export declare const RULE_IDS: readonly RuleId[];
 /** Rules that need the package as it was opened. See `Rule.needsBaseline`. */
-declare const BASELINE_RULES: readonly RuleId[];
+export declare const BASELINE_RULES: readonly RuleId[];
 //#endregion
 //#region src/report/location.d.ts
 /**
@@ -383,9 +397,9 @@ interface Location {
   readonly offset: number | null;
 }
 /** A location that names a part and nothing inside it. */
-declare function partLocation(part: string): Location;
+export declare function partLocation(part: string): Location;
 /** The location of the package itself: the archive, the content types, the graph. */
-declare const PACKAGE_LOCATION: Location;
+export declare const PACKAGE_LOCATION: Location;
 /**
  * The XPath of an element, from the document root.
  *
@@ -394,11 +408,11 @@ declare const PACKAGE_LOCATION: Location;
  * finding built from a node the caller synthesised is degraded rather than
  * lost.
  */
-declare function xpathOf(element: XElement): string;
+export declare function xpathOf(element: XElement): string;
 /** The XPath of an attribute: its owner's path, then `/@qname`. */
-declare function xpathOfAttribute(owner: XElement, attr: XAttribute | string): string;
+export declare function xpathOfAttribute(owner: XElement, attr: XAttribute | string): string;
 /** A location for an element inside a named part. */
-declare function elementLocation(part: string, element: XElement): Location;
+export declare function elementLocation(part: string, element: XElement): Location;
 /**
  * A location for one attribute of an element.
  *
@@ -406,7 +420,7 @@ declare function elementLocation(part: string, element: XElement): Location;
  * element's start when it does not - which is the case that matters, because a
  * *missing* required attribute is a finding and it has to point somewhere.
  */
-declare function attributeLocation(part: string, element: XElement, qname: string): Location;
+export declare function attributeLocation(part: string, element: XElement, qname: string): Location;
 /**
  * `line:column` for an offset, 1-based, or `null`.
  *
@@ -415,14 +429,14 @@ declare function attributeLocation(part: string, element: XElement, qname: strin
  * hundred times. Callers that render a report for a human ask for it once, at
  * the point of rendering, for the findings they are about to show.
  */
-declare function lineColumn(source: string, offset: number): {
+export declare function lineColumn(source: string, offset: number): {
   line: number;
   column: number;
 };
 /** Document order, for sorting findings within a part. */
-declare function inDocumentOrder(a: XNode, b: XNode): number;
+export declare function inDocumentOrder(a: XNode, b: XNode): number;
 /** The root element's qname, for the handful of rules that dispatch on it. */
-declare function rootName(document: XDocument): string;
+export declare function rootName(document: XDocument): string;
 //#endregion
 //#region src/report/report.d.ts
 /**
@@ -443,7 +457,7 @@ declare function rootName(document: XDocument): string;
  * 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 twenty-nine rules.
+ * 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
@@ -514,14 +528,14 @@ interface Report {
  * the same place with different values are different findings, and treating
  * them as one would let an introduced defect hide behind an inherited one.
  */
-declare function findingKey(finding: Finding): string;
-declare function buildReport(input: {
+export declare function findingKey(finding: Finding): string;
+export declare function buildReport(input: {
   readonly findings: readonly Finding[];
   readonly checked: readonly RuleId[];
   readonly skipped: readonly SkippedRule[];
   readonly problems: readonly ReadProblem[];
 }): Report;
-declare function isReport(value: unknown): value is Report;
+export declare function isReport(value: unknown): value is Report;
 interface FormatOptions {
   /** Include `inherited` findings. Default true. */
   readonly inherited?: boolean;
@@ -537,7 +551,7 @@ interface FormatOptions {
  * "what is wrong with this file", and a file is a set of parts. Grouping by
  * rule is the right shape for the corpus gate and the wrong one here.
  */
-declare function formatReport(report: Report, options?: FormatOptions): string;
+export declare function formatReport(report: Report, options?: FormatOptions): string;
 //#endregion
 //#region src/context.d.ts
 /**
@@ -651,7 +665,7 @@ declare class RuntimeContext implements Context {
   add(rule: RuleId, where: Location, message: string): void;
   problem(part: string, message: string): void;
 }
-declare function createContext(input: ContextInput): RuntimeContext;
+export declare function createContext(input: ContextInput): RuntimeContext;
 //#endregion
 //#region src/validate.d.ts
 interface ValidateOptions {
@@ -690,7 +704,7 @@ interface ValidateOptions {
  * findings in it, which is the shape a caller can render. It throws only when
  * it was handed something it cannot open at all.
  */
-declare function validatePackage(options: ValidateOptions): Report;
+export declare function validatePackage(options: ValidateOptions): Report;
 /**
  * Validate, and refuse to go on if we broke something.
  *
@@ -701,7 +715,7 @@ declare function validatePackage(options: ValidateOptions): Report;
  * feedback loop that exists, and a caller who forgot to check a return value
  * would have removed it.
  */
-declare function assertValid(options: ValidateOptions): Report;
+export declare function assertValid(options: ValidateOptions): Report;
 //#endregion
-export { BASELINE_RULES, type Context, type ContextInput, type Evidence, type Finding, type FormatOptions, type Location, type Origin, PACKAGE_LOCATION, RULES, RULE_IDS, type ReadProblem, type Report, type Rule, type RuleCategory, type RuleId, type Severity, type SkippedRule, VALIDATE_ERROR_CODES, ValidateError, type ValidateErrorCode, type ValidateErrorDetail, type ValidateOptions, assertValid, attributeLocation, buildReport, createContext, elementLocation, findingKey, formatReport, inDocumentOrder, isReport, isValidateError, lineColumn, partLocation, rootName, ruleById, validatePackage, xpathOf, xpathOfAttribute };
+export type { Context, ContextInput, Evidence, Finding, FormatOptions, Location, Origin, ReadProblem, Report, Rule, RuleCategory, RuleId, Severity, SkippedRule, ValidateErrorCode, ValidateErrorDetail, ValidateOptions };
 //# sourceMappingURL=index.d.ts.map

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":";;;;;;;;;;;;;;;;;;;;;;;;;;cAwBa;KAuBD,4BAA4B;UAEvB;;WAEN;;WAEA;;;;;;;;WAQA;;cAGE,sBAAsB;WACxB,MAAM;WACN,QAAQ;EAEL,YAAA,MAAM,mBAAmB,iBAAiB,SAAQ;;iBAQhD,gBAAgB,iBAAiB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCjC9C;KAGA;;KAGA;UAEK;WACN,IAAI;WACJ,UAAU;WACV,UAAU;WACV,UAAU;;WAEV;;WAEA;;;;;;;;;;WAUA;;cAsBE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsbD,iBAAiB;iBAIb,SAAS,aAAa;cAIzB,mBAAmB;;cAGnB,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UC1erB;;;;;;;WAON;;WAEA;;WAEA;;;iBAIK,aAAa,eAAe;;cAK/B,kBAAkB;;;;;;;;;iBAwBf,QAAQ,SAAS;;iBAWjB,iBAAiB,OAAO,UAAU,MAAM;;iBAMxC,gBAAgB,cAAc,SAAS,WAAW;;;;;;;;iBAWlD,kBAAkB,cAAc,SAAS,UAAU,gBAAgB;;;;;;;;;iBAiBnE,WAAW,gBAAgB;EAAmB;EAAc;;;iBAc5D,gBAAgB,GAAG,OAAO,GAAG;;iBAK7B,SAAS,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KC7HvB;;;;;;;UAQK;WACN,MAAM;WACN,UAAU;WACV,UAAU;WACV,OAAO;;;;;;;WAOP;WACA,QAAQ;;;UAIF;WACN,MAAM;WACN;;;UAIM;WACN;WACA;;UAGM;;WAEN,mBAAmB;;WAEnB,kBAAkB;;;;;;;;;WASlB,kBAAkB;;WAElB,mBAAmB;;WAEnB;;WAEA;;;;;;;;;;iBAqBK,WAAW,SAAS;iBAMpB,YAAY;WACjB,mBAAmB;WACnB,kBAAkB;WAClB,kBAAkB;WAClB,mBAAmB;IAC1B;iBAeY,SAAS,iBAAiB,SAAS;UASlC;;WAEN;;WAEA;;WAEA;;;;;;;;;iBAUK,aAAa,QAAQ,QAAQ,UAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;UCzHrC;;WAEN,OAAO;;WAEP,OAAO;;;;;;;;;;;;;;;;WAgBP,SAAS;;WAET,UAAU;;EAGnB,kBAAkB;;EAElB,KAAK,eAAe;;EAEpB,YAAY;;EAEZ,SAAS,eAAe;;;;;;;;;;;;;;EAcxB,wBAAwB;;EAGxB,aAAa,eAAe;EAC5B,iBAAiB,eAAe;;;;;;;;;;EAWhC,OAAO;EAEP,IAAI,MAAM,QAAQ,OAAO,UAAU;EACnC,QAAQ,cAAc;;UAGP;WACN,OAAO;WACP,QAAQ;WACR,UAAU;WACV,WAAW;;cAYhB,0BAA0B;;WACrB,OAAO;WACP,OAAO;WACP,SAAS;WACT,UAAU;WAEV,UAAU;WACV,UAAU;EAMP,YAAA,OAAO;EAOnB,kBAAkB;EAKlB,KAAK,eAAe;EAUpB,YAAY;EAIZ,SAAS,eAAe;EASxB,iBAAiB,eAAe;EAiChC,wBAAwB;EAiBxB,aAAa,eAAe;EAS5B,OAAO;EAIP,IAAI,MAAM,QAAQ,OAAO,UAAU;EAenC,QAAQ,cAAc;;iBAcR,cAAc,OAAO,eAAe;;;UC3KnC;;;;;;;;;;WAUN,QAAQ;;;;;;;;;WASR,QAAQ;;WAER,WAAW;;WAEX,gBAAgB;;WAEhB,iBAAiB;;WAEjB,MAAM;;;;;;;;;iBAwBD,gBAAgB,SAAS,kBAAkB;;;;;;;;;;;iBA2I3C,YAAY,SAAS,kBAAkB"}
+{"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

@@ -169,9 +169,9 @@ const RULES = [
 		id: "V016",
 		category: "required",
 		severity: "fatal",
-		evidence: "schema",
+		evidence: "both",
 		title: "every text body has `a:bodyPr` and at least one `a:p`",
-		why: "`CT_TextBody` is `bodyPr` then optional `lstStyle` then `a:p` at `[1..unbounded]`. A shape whose text was deleted down to nothing is the way this gets broken in an editor: the last paragraph goes, and what is left is a `p:txBody` with no `a:p` in it. An empty paragraph is not the same as no paragraph, and `a:endParaRPr` is where its height comes from."
+		why: "`CT_TextBody` is `bodyPr` then optional `lstStyle` then `a:p` at `[1..unbounded]`. A shape whose text was deleted down to nothing is the way this gets broken in an editor: the last paragraph goes, and what is left is a `p:txBody` with no `a:p` in it. An empty paragraph is not the same as no paragraph, and `a:endParaRPr` is where its height comes from. C7 measured it on a table cell: a repair prompt, and PowerPoint writes the paragraph in."
 	},
 	{
 		id: "V017",
@@ -279,6 +279,22 @@ const RULES = [
 		needsBaseline: true,
 		title: "text and field identity survive: `xml:space`, `a:fld/@id`, cached field text",
 		why: "Three small things that are each silently destructive. An `a:t` with leading or trailing whitespace needs `xml:space=\"preserve\"` if it was written with it, because dropping the attribute changes what the text *is*. `a:fld/@id` is a required `ST_Guid` and regenerating one can make PowerPoint repair the file. And a field’s cached `a:t` is the only thing that renders when we cannot evaluate the field ourselves, so discarding it turns a date placeholder into an empty box on every consumer that is not PowerPoint."
+	},
+	{
+		id: "V030",
+		category: "required",
+		severity: "warning",
+		evidence: "measured",
+		title: "a table is the one PowerPoint reads: a cell per column in every row, a flag where a span covers",
+		why: "Nothing in the schema ties an `a:tr` to the number of `a:gridCol`, or a `gridSpan` on one cell to the `hMerge` on the next. C7 built 82 tables, 52 of them to disagree with themselves, and asked PowerPoint which cell every grid position belongs to: the spans on the anchor are the whole answer (76 of 76, against 52 for the flags), a short row is padded, a fifth cell is dropped, a colliding or oversized span is clamped and a covered cell’s own span ignored - and PowerPoint writes all of that back on save. The deck opens without a word, which is why this is a warning: the file says one table and PowerPoint draws another, and the next save is the one that rewrites the part."
+	},
+	{
+		id: "V031",
+		category: "required",
+		severity: "fatal",
+		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."
 	}
 ];
 const BY_ID = new Map(RULES.map((rule) => [rule.id, rule]));
@@ -629,7 +645,7 @@ function readRelsParts(ctx) {
 	return parts;
 }
 /**
-* Memoised above, because five of the twenty-nine rules want this list and each
+* 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
@@ -1153,7 +1169,7 @@ function forEachElement$1(ctx, visit) {
 //#endregion
 //#region src/rules/required.ts
 /**
-* `V013` … `V017`: children and attributes that are not optional.
+* `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
@@ -1226,6 +1242,140 @@ function v017GraphicFrame(ctx) {
 		if (childElements(element).find((child) => child.local === "graphic" && namespaceOf(child) === NS.a) === void 0) ctx.add("V017", elementLocation(part, element), "no <a:graphic>. The frame is the wrapper; the graphic is the thing in it, and a frame without one names no table, chart, diagram or OLE object at all.");
 	});
 }
+/** The lexical forms of `xsd:boolean`. */
+const BOOLEANS = /* @__PURE__ */ new Set([
+	"1",
+	"0",
+	"true",
+	"false"
+]);
+const INT = /^[+-]?\d+$/;
+/** `a:gridCol` carries `@w`, `a:tr` carries `@h`, and a cell's four merge attributes are typed. */
+function v031TableAttributes(ctx) {
+	forEachElement(ctx, (part, element) => {
+		if (namespaceOf(element) !== NS.a) return;
+		const missing = (name) => {
+			ctx.add("V031", elementLocation(part, element), "<" + element.qname + "> has no @" + name + ". CT_TableCol and CT_TableRow require it, and C7 measured the repair prompt: PowerPoint opens the deck only after rewriting the part.");
+		};
+		if (element.local === "gridCol" && attribute(element, "w") === void 0) missing("w");
+		if (element.local === "tr" && attribute(element, "h") === void 0) missing("h");
+		if (element.local !== "tc") return;
+		for (const [name, ok, type] of [
+			[
+				"gridSpan",
+				INT,
+				"xsd:int"
+			],
+			[
+				"rowSpan",
+				INT,
+				"xsd:int"
+			],
+			[
+				"hMerge",
+				BOOLEANS,
+				"xsd:boolean"
+			],
+			[
+				"vMerge",
+				BOOLEANS,
+				"xsd:boolean"
+			]
+		]) {
+			const raw = attribute(element, name)?.value;
+			if (raw === void 0 || (ok instanceof RegExp ? ok.test(raw) : ok.has(raw))) continue;
+			ctx.add("V031", elementLocation(part, element), "<a:tc>/@" + name + " is \"" + raw + "\", which is not an " + type + ". C7 measured gridSpan=\"2.0\" and hMerge=\"on\": a repair prompt each; the span is dropped with the merge it named and the flag comes back as \"1\" under its span.");
+		}
+	});
+}
+/** 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;
+	const n = Number(raw);
+	return n < 0 ? Number.POSITIVE_INFINITY : Math.max(1, n);
+}
+function flagged(cell, name) {
+	const raw = attribute(cell, name)?.value;
+	return raw === "1" || raw === "true";
+}
+/**
+* The occupancy `@pptx-studio/model` ships, over attributes: each cell takes the next column, a
+* claimed position is covered whatever it says, a span stops at the edge or at a claimed position.
+*/
+function owners(cells, cols) {
+	const grid = cells.map(() => Array.from({ length: cols }).fill(null));
+	cells.forEach((line, r) => {
+		line.forEach((cell, c) => {
+			if (c >= cols || grid[r][c] !== null) return;
+			const wide = spanOf(attribute(cell, "gridSpan")?.value);
+			const tall = spanOf(attribute(cell, "rowSpan")?.value);
+			const owner = {
+				row: r,
+				col: c,
+				rows: 1,
+				cols: 1
+			};
+			while (c + owner.cols < cols && owner.cols < wide && grid[r][c + owner.cols] === null) owner.cols += 1;
+			owner.rows = Math.min(tall, cells.length - r);
+			for (let rr = r; rr < r + owner.rows; rr++) for (let cc = c; cc < c + owner.cols; cc++) grid[rr][cc] = owner;
+		});
+	});
+	return grid;
+}
+/** The table PowerPoint reads: one cell per column in every row, a flag exactly where a span covers. */
+function v030TableGrid(ctx) {
+	forEachElement(ctx, (part, element) => {
+		if (element.local !== "tbl" || namespaceOf(element) !== NS.a) return;
+		const add = (where, message) => {
+			ctx.add("V030", elementLocation(part, where), message);
+		};
+		const grid = childElements(element).find((child) => child.local === "tblGrid");
+		const cols = grid === void 0 ? 0 : childElements(grid).filter((c) => c.local === "gridCol").length;
+		const rows = childElements(element).filter((child) => child.local === "tr");
+		if (cols === 0 || rows.length === 0) {
+			add(element, "the table has " + String(cols) + " column(s) and " + String(rows.length) + " row(s). PowerPoint invents one of whichever is missing, empty, and writes it back - measured in C7.");
+			return;
+		}
+		const cells = rows.map((row) => childElements(row).filter((child) => child.local === "tc"));
+		cells.forEach((line, r) => {
+			if (line.length === cols) return;
+			add(rows[r], "row " + String(r + 1) + " holds " + String(line.length) + " cell(s) for " + String(cols) + " column(s). PowerPoint pads a short row with an empty cell, drops the cells past the last column, and writes the result back - measured in C7.");
+		});
+		const grid2 = owners(cells, cols);
+		cells.forEach((line, r) => {
+			line.forEach((cell, c) => {
+				const owner = grid2[r]?.[c];
+				if (owner === null || owner === void 0) return;
+				const at = "cell (" + String(r + 1) + ", " + String(c + 1) + ")";
+				if (owner.row === r && owner.col === c) {
+					for (const [name, span] of [["gridSpan", owner.cols], ["rowSpan", owner.rows]]) {
+						const written = attribute(cell, name)?.value;
+						if (written === void 0 || Number(written) === span) continue;
+						add(cell, at + " says " + name + "=\"" + written + "\" and covers " + String(span) + ". A span stops at the grid edge or at a position an earlier span claimed, zero is one and a negative runs to the edge; PowerPoint writes the span it drew - measured in C7.");
+					}
+					for (const name of ["hMerge", "vMerge"]) {
+						if (!flagged(cell, name)) continue;
+						add(cell, at + " says " + name + "=\"1\" and no span covers it. The flag changes nothing: PowerPoint reads the spans alone, 76 of 76 in C7, and drops the flag on save.");
+					}
+					return;
+				}
+				for (const [name, covered] of [["hMerge", owner.col < c], ["vMerge", owner.row < r]]) {
+					if (covered === flagged(cell, name)) continue;
+					if (!covered) {
+						add(cell, at + " says " + name + "=\"1\" and the span of cell (" + String(owner.row + 1) + ", " + String(owner.col + 1) + ") covers it the other way. PowerPoint drops the flag on save - measured in C7.");
+						continue;
+					}
+					add(cell, at + " is covered by the span of cell (" + String(owner.row + 1) + ", " + String(owner.col + 1) + ") and does not say " + name + "=\"1\". PowerPoint reads it as covered anyway and adds the flag on save; a reader that trusts the flag draws a cell PowerPoint does not - measured in C7.");
+				}
+				for (const [name, allowed] of [["gridSpan", c === owner.col ? owner.cols : null], ["rowSpan", r === owner.row ? owner.rows : null]]) {
+					const written = attribute(cell, name)?.value;
+					if (written === void 0 || Number(written) === allowed) continue;
+					add(cell, at + " is covered and says " + name + "=\"" + written + "\". A covered cell’s own span is ignored and PowerPoint deletes it on save unless it repeats the anchor’s other span, as PowerPoint’s own form does - measured in C7.");
+				}
+			});
+		});
+	});
+}
 /**
 * Presentation-family parts only.
 *
@@ -1959,7 +2109,7 @@ function v029TextAndFieldIdentity(ctx) {
 //#endregion
 //#region src/validate.ts
 /**
-* The twenty-nine, wired to their implementations.
+* 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
@@ -1995,7 +2145,9 @@ const IMPLEMENTATIONS = {
 	V026: v026ChartStyleComplete,
 	V027: v027UneditedPartsUnchanged,
 	V028: v028OpaqueContainersUnchanged,
-	V029: v029TextAndFieldIdentity
+	V029: v029TextAndFieldIdentity,
+	V030: v030TableGrid,
+	V031: v031TableAttributes
 };
 /** Rules that cannot run without the archive bytes. See `Context.archive`. */
 const ARCHIVE_RULES = ["V003"];