document-schema 4.0.0 → 4.1.0

package/README.md

@@ -48,7 +48,7 @@ graph TD
     style schema fill:#f9a825,stroke:#333,stroke-width:3px
 ```
 
-`ContentDocument` (the semantic pivot) is a discriminated union of five kinds: `wordprocessing` (docx/odt sections of paragraphs/runs/tables/images), `presentation` (pptx/odp slides of shapes), `spreadsheet` (xlsx/ods sheets of cells, columns, rows, print settings), `drawing` (odg pages of shapes plus vector primitives — rect/ellipse/line/path), and `formula` (an equation carrying its own MathML node tree plus StarMath source when the producing format had one, extended with the two-layer math model: an optional verbatim-LaTeX `presentation` authoritative for rendering, an optional semantic `content: MathExpression` tree authoritative for computation, and provenance — neither layer stored derived from the other, so editing one never silently mutates the other). `ContentEmbeddedObjectSchema` lets any of the five embed another whole `ContentDocument`. Every paragraph/run/image/table/shape/vector/spreadsheet-cell leaf also carries its own canonical `headingLevel`-or-position fields directly: a `ContentParagraph`'s optional `headingLevel` (1 = the outermost heading, independent of the round-trip-only `styleId`), and every such leaf's optional `frames: LayoutFrame[]` — that node's own rendered page position(s) (`pageIndex` plus PDF user-space `xPt`/`yPt`/`widthPt`/`heightPt`), fused directly onto the content tree once a layout pass has run. `DocumentPackage` is the single hierarchical artefact — structure, layout, and content fused in one tree (see [The package tree](#the-package-tree)): the root carries `kind`, `metadata`, the optional document-level `symbolTable` and rendered `pages`, the optional package-level `styles`/`definitions` tables (see [Definitions tables and styles](#definitions-tables-and-styles)), and `children` — one group per top-level container with the content tree grouped inside it; the schema does not keep populated `frames` fields and `pages` in sync or detect staleness, and does not check that a tree's `style` refs name table entries (both are producer responsibilities, exactly as the frames/pages pairing always was). Every one of the five kinds also accepts an optional document-level `symbolTable` — the math curation layer mapping each written symbol glyph (within a scope) to its id, quantity kind, preferred unit, and definition source, alongside the unit registry (SI dimension-exponent vectors, exact rational conversions, per-unit-system normalisation contexts) that the `qty` nodes of lowered formulas resolve against.
+`ContentDocument` (the semantic pivot) is a discriminated union of five kinds: `wordprocessing` (docx/odt sections of paragraphs/runs/tables/images), `presentation` (pptx/odp slides of shapes), `spreadsheet` (xlsx/ods sheets of cells, columns, rows, print settings), `drawing` (odg pages of shapes plus vector primitives — rect/ellipse/line/path), and `formula` (an equation carrying its own MathML node tree plus StarMath source when the producing format had one, extended with the two-layer math model: an optional verbatim-LaTeX `presentation` authoritative for rendering, an optional semantic `content: MathExpression` tree authoritative for computation, and provenance — neither layer stored derived from the other, so editing one never silently mutates the other). `ContentEmbeddedObjectSchema` lets any of the five embed another whole `ContentDocument`. Every paragraph/run/image/table/shape/vector/spreadsheet-cell leaf also carries its own canonical `headingLevel`-or-position fields directly: a `ContentParagraph`'s optional `headingLevel` (1 = the outermost heading, independent of the round-trip-only `styleId`), and every such leaf's optional `frames: LayoutFrame[]` — that node's own rendered page position(s) (`pageIndex` plus PDF user-space `xPt`/`yPt`/`widthPt`/`heightPt`), fused directly onto the content tree once a layout pass has run. `DocumentPackage` is the single hierarchical artefact — structure, layout, and content fused in one tree (see [The package tree](#the-package-tree)): the root carries `kind`, `metadata`, the optional document-level `symbolTable` and rendered `pages`, the optional package-level `styles`/`definitions`/`layers`/`attachments`/`destinations` tables (see [Definitions tables and styles](#definitions-tables-and-styles)), and `children` — one group per top-level container with the content tree grouped inside it, where a group's node may also be one of the six fidelity construct descriptors (see [Fidelity constructs](#fidelity-constructs)); the schema does not keep populated `frames` fields and `pages` in sync or detect staleness, and does not check that a tree's `style` refs name table entries (both are producer responsibilities, exactly as the frames/pages pairing always was). Every one of the five kinds also accepts an optional document-level `symbolTable` — the math curation layer mapping each written symbol glyph (within a scope) to its id, quantity kind, preferred unit, and definition source, alongside the unit registry (SI dimension-exponent vectors, exact rational conversions, per-unit-system normalisation contexts) that the `qty` nodes of lowered formulas resolve against.
 
 The `LayoutDocument` family (pages of positioned `LayoutItem`s — `text`/`image`/`rect`/`line`/`ellipse`/`path`/`link` in PDF user-space coordinates) no longer lives here: 4.0.0 demoted it to a pdf-codec-private model ([pdf-codec#65](https://github.com/ExaDev/pdf-codec/issues/65)), where the only codec that ever read or wrote it owns it outright. `documentFromJson` recognises old layout-document `$schema` URIs and throws a tombstone pointing at pdf-codec rather than failing as if the value were unrelated. Dependents stay on document-schema.js 3.x via semver until their own majors, so the demotion is not a cascade-breaker.
 
@@ -90,7 +90,7 @@ const laidOut = DocumentPackageSchema.parse({ ...pkg, pages: [{ widthPt: 612, he
 
 `DocumentPackage` ([#20](https://github.com/ExaDev/document-schema.js/issues/20)) is the promoted single hierarchical artefact — one tree where 3.x carried `{ formatVersion, content, pages }` with the content flat. The tree's vocabulary is defined in `src/package-node.ts` and was proven first as [document-outline.js](https://github.com/ExaDev/document-outline.js)'s phase-1 `decompose`/`flatten` implementation ([document-outline.js#2](https://github.com/ExaDev/document-outline.js/issues/2)); this package's schemas are that shape's schema-home port, matching it node for node:
 
-- **Groups** are `{ node, children }` where `node` embeds either an anchor paragraph (heading groups and list-item groups carry the full `ContentParagraph` — runs, formatting, frames — never a projected text label) or a container descriptor: `{ kind: 'section', pageSize, margins }`, `{ kind: 'slide', size, notes }`, `{ kind: 'sheet', name, cells, columns, rows, printSettings }`, `{ kind: 'drawPage', size }`, each tagged with a `kind` the flat container type does not carry, or a shape group's untagged frame descriptor.
+- **Groups** are `{ node, children }` where `node` embeds either an anchor paragraph (heading groups and list-item groups carry the full `ContentParagraph` — runs, formatting, frames — never a projected text label) or a container descriptor: `{ kind: 'section', pageSize, margins }`, `{ kind: 'slide', size, notes }`, `{ kind: 'sheet', name, cells, columns, rows, printSettings }`, `{ kind: 'drawPage', size }`, each tagged with a `kind` the flat container type does not carry, or a shape group's untagged frame descriptor, or — since 4.1.0 — a **construct descriptor** (see [Fidelity constructs](#fidelity-constructs)).
 - **Bare leaves** carry their own `kind` and never `children`. Discrimination is structural on `node`+`children`, not on the presence of a `kind`.
 - **Section groups are mandatory** — one per `ContentSection` — because a section carries pre-layout page geometry (`pageSize`/`margins`) that a rendered `pages` array cannot hold.
 - **Grouping never crosses container boundaries**: a shape is its own group with its inner blocks grouped inside it (never a slide's paragraphs flattened across its shapes — that is a TOC projection, not a decomposition); a sheet's grid rides on the sheet node with images and embedded documents as children; embedded documents stay intact as one leaf.
@@ -104,9 +104,69 @@ The flat `ContentDocument` and the tree are **one format, two encodings**, relat
 
 The codecs do not change: they keep producing flat `ContentDocument`s (their natural reading shape); decomposition runs once at the package boundary in documents.js and flatten runs once where a builder consumes a package.
 
+## Fidelity constructs
+
+Every format carries constructs the flat content model drops — docx SDTs and field codes, ODF fields and tracked changes, PDF form widgets and link annotations, markdown footnotes and link titles. [#22](https://github.com/ExaDev/document-schema.js/issues/22) replaces those per-repo caveats with one **harmonised semantic vocabulary**: no format-specific node kinds, ever. Four codec inventories ([ooxml.js#65](https://github.com/ExaDev/ooxml.js/issues/65), [odf.js#59](https://github.com/ExaDev/odf.js/issues/59), [markdown-codec#63](https://github.com/ExaDev/markdown-codec/issues/63), [pdf-codec#66](https://github.com/ExaDev/pdf-codec/issues/66)) audited what each format actually carries, and 4.1.0 lands their answer additively ([#24](https://github.com/ExaDev/document-schema.js/issues/24)) — new descriptor kinds and package tables, no change to any existing node shape, so a 4.0.0 tree parses unchanged.
+
+A construct is a group like any other: `{ node: <descriptor>, children }`, where the children are the extent the construct spans. The tree was designed construct-capable from day one for exactly this, which is why the kinds could land in a minor rather than a second structural break.
+
+```ts
+// A tracked insertion inside a docx content control, and a footnote marker whose body lives in the definitions table.
+const pkg = DocumentPackageSchema.parse({
+  kind: 'wordprocessing',
+  metadata: {},
+  definitions: { n1: { kind: 'footnote', blocks: [{ kind: 'paragraph', runs: [{ text: 'The note body.' }] }] } },
+  children: [
+    {
+      node: { kind: 'section', pageSize: { widthPt: 612, heightPt: 792 }, margins: { topPt: 72, rightPt: 72, bottomPt: 72, leftPt: 72 } },
+      children: [
+        {
+          node: { kind: 'contentControl', controlType: 'richText', tag: 'ClientBlock', lock: 'container' },
+          children: [
+            {
+              node: { kind: 'provenance', change: 'insertion', author: 'A. Reviewer', dateIso: '2026-08-18T09:00:00Z' },
+              children: [{ kind: 'paragraph', runs: [{ text: 'Inserted sentence.' }] }],
+            },
+            { node: { kind: 'anchor', anchorType: 'footnote', name: '1', definition: 'n1' }, children: [] },
+          ],
+        },
+      ],
+    },
+  ],
+});
+```
+
+The six kinds (`src/construct.ts`):
+
+| Kind | Carries | Where it comes from |
+| --- | --- | --- |
+| `contentControl` | `controlType`, `tag`, `alias`, `lock`, `value`, `checked`, `options` | docx block and inline SDTs, docx legacy `w:ffData` form fields, ODF `office:forms` controls and TOC/index wrappers, PDF AcroForm widgets and their field tree |
+| `field` | `instruction`, `cachedResult` | docx `w:fldChar`/`w:instrText` and `w:fldSimple`, ODF field masters and simple fields, ODF cross-reference displays, pptx `a:fld` |
+| `anchor` | `anchorType`, `name`, `definition` | docx bookmarks, comment extents, footnote/endnote references; ODF `text:bookmark`, `text:reference-mark*`, `text:note`, `office:annotation`; PDF sticky notes and markup annotations; markdown footnote markers |
+| `link` | `target` (external URI or internal anchor name), `title` | docx `@w:anchor`, pptx slide jumps, PDF `GoTo`/`/Dest` and link annotations, markdown link/image titles |
+| `provenance` | `change`, `author`, `dateIso` | docx `w:ins`/`w:del` and move tracking, ODF `text:tracked-changes`/`text:changed-region` |
+| `division` | `name`, `columnCount`, `protected`, `source` | ODF `text:section` and `text:section-source`, tagged PDF `/Sect` and `/Div` |
+
+Four things bound the vocabulary, and each is a decision rather than an omission:
+
+- **Extents are block-scoped.** A construct group wraps the block flow of a section, heading group, shape, or list item. It cannot wrap a sub-sequence of one paragraph's runs, because a run-level extent is not expressible without changing `ContentParagraph`, and 4.1.0 changes no content shape. Run-level constructs keep their existing homes: **an external hyperlink stays on `ContentRun.hyperlink`** — `link` groups are for block-scoped and annotated extents a flat run field cannot express, never a replacement for it — and the inline field, bookmark, and tracked-change cases wait on a run-level mechanism rather than being forced into a wrapper that would split their paragraph.
+- **Two group variants, one per block flow.** `SectionConstructGroup` sits in a section's or heading group's flow and admits heading children; `ShapeConstructGroup` sits in a shape's or list item's and does not — exactly the `SectionChild`/`ShapeChild` split that already existed. A construct nests in and around every other group, so a `provenance` wrapper inside a `contentControl` inside a `division` is a legal (and real) docx shape. Constructs are **not** legal as direct children of a slide, sheet, drawing page, or the package root: those hold containers and leaves, not block flow.
+- **`division` is first-class, not degraded.** [#24](https://github.com/ExaDev/document-schema.js/issues/24) posed ODF `text:section` as a choice between a new generic kind and degrading to `contentControl` with the specifics in residue. It is first-class, on the odf inventory's own recommendation: `ContentSection` cannot host it (that is page geometry, one `pageSize`/`margins` pair, and it does not nest, while a division nests arbitrarily and usually changes no page geometry at all), and burying a structural container in the form-control vocabulary would make `contentControl` mean two unrelated things. It clears #22's no-format-specific-kinds bar on a real analogue — tagged PDF's `/Sect` and `/Div` are the same construct — not on ODF's say-so. It is spelled `division` rather than `section` because `{ kind: 'section' }` is already the page-geometry container descriptor.
+- **Residue is not here.** #22's channel 2 — a per-node and package-level `source: { format, xml }` facility for what has no cross-format meaning — spans the whole content model and remains open on #22. Descriptors are closed objects with no escape hatch, deliberately: a descriptor-only residue field would mint exactly the parallel shape the general facility exists to avoid.
+
+Two harmonisations the inventories asked for are also deliberately absent. There is **no `fieldType` enum**: `instruction` is required and verbatim, so nothing is lost without one, and #24 asks for exactly one new vocabulary — `link`'s internal targets — rather than one per kind, with the four inventories' own corpus gate still standing before a field-type member set could be frozen honestly. And a **sheet-scoped named range** (xlsx defined names and tables, ODF `table:named-expressions`) is a definitions-table entry, not an `anchor`: a sheet group's children are its images and embedded documents, never a block flow, so there is no extent for an anchor to wrap — which is the odf inventory's own verdict for the identical construct.
+
 ## Definitions tables and styles
 
-The package root carries a generic definitions-table facility ([#21](https://github.com/ExaDev/document-schema.js/issues/21)): named tables whose entries tree nodes reference by string id. **Styles are the first tenant**; link and footnote definitions are future tenants of the same mechanism ([markdown-codec#63](https://github.com/ExaDev/markdown-codec/issues/63), [#22](https://github.com/ExaDev/document-schema.js/issues/22)) — which is why the tenant-generic `definitions` table (entries tagged with a `kind` discriminator and an open body, `src/definitions.ts`) sits alongside the styles-specific `styles` table rather than the facility being shaped around styles.
+The package root carries a generic definitions-table facility ([#21](https://github.com/ExaDev/document-schema.js/issues/21)): named tables whose entries tree nodes reference by string id. **Styles were the first tenant**; link, footnote, and comment definitions ride the tenant-generic `definitions` table (entries tagged with a `kind` discriminator and an open body, `src/definitions.ts`) alongside it — which is why that generic table exists rather than the facility being shaped around styles.
+
+4.1.0 adds three more tables of that same generic type at the root ([#24](https://github.com/ExaDev/document-schema.js/issues/24), proposed by [pdf-codec#66](https://github.com/ExaDev/pdf-codec/issues/66)) — no new entry shape is minted anywhere:
+
+- `layers` — optional-content/layer definitions: PDF `/OCProperties` groups and their configuration, ODF Draw's layer model. Definitions only; which content belongs to which layer is a membership fact the producing codec carries on its own item model.
+- `attachments` — package attachments: PDF `/Names /EmbeddedFiles`, `/FileAttachment`, `/EF`, `/AF`, and the docx/ODF package attachments that make the facility cross-format rather than PDF-specific.
+- `destinations` — named destinations and the navigation tree that resolves against them: PDF `/Dests`, the `/Names` name tree, and `/Outlines`. This is the other end of a `link` construct's internal target.
+
+Each is its own root field rather than three more tenants of `definitions`, for the reason `styles` is its own field despite being the facility's first tenant: separate key namespaces, so a layer and a destination may share a name without colliding. The `kind` discriminator still earns its keep inside each, because each holds more than one tenant — a layers table carries group definitions alongside their configuration, and a destinations table carries named destinations alongside outline entries. Per-tenant entry fields stay the tenant's own, never this package's.
 
 A styles entry carries `{ paragraph?, run? }` sub-objects of **resolved canonical properties only**: paragraph `alignment`/`list`/`spacingBeforePt`/`spacingAfterPt`/`lineSpacing`/`indentLeftPt`/`indentFirstLinePt`, run `bold`/`italic`/`underline`/`strike`/`fontFamily`/`sizePt`/`color`. Never `frames`, never `sourcePath`, never `styleId` (per-node facts — a position is a fact about a node, not a style), never a `basedOn` graph (the table is a dictionary, not a program) — and the ban list is **enforced by schema shape** (strict objects that reject those keys outright), not merely documented.
 
@@ -152,7 +212,7 @@ node_modules/document-schema.js/schemas/document-package.schema.json
 node_modules/document-schema.js/schemas/content-document.schema.json
 ```
 
-Each file's `$id` is a jsdelivr URL pinned to the exact npm version — immutable and live on publish, and (see [Versioning by `$schema`](#versioning-by-schema)) the version of anything stamped with it. Both files carry the same hand-authored `$defs` block (the same object emitted twice in one generator run, so the copies cannot drift), covering the recursive paragraph/table/embedded-object, MathML, and package-tree node models that Zod's converter cannot express directly; `content-json-schema-defs.ts` holds those fragments, and a regression test compares each fragment that has a real Zod counterpart against a live `z.toJSONSchema()` of that schema so a field changed without updating its fragment fails a test. The one deliberate cross-file `$ref` is the embedded-object cycle back to a whole `ContentDocument`. Fragments downstream of a `z.custom()` node (`ContentBlock`, `ContentTable`/`Cell`/`Row`, `ContentEmbeddedObject(Block)`, the seven package-tree group wrappers, `MathMlNode`/`Element`/`Attribute`, `ContentFormula`, `MathExpression` and its recursive variants) still need hand re-verification against `src/content.ts`/`src/package-node.ts`/`src/mathml.ts`/`src/math.ts` — see below.
+Each file's `$id` is a jsdelivr URL pinned to the exact npm version — immutable and live on publish, and (see [Versioning by `$schema`](#versioning-by-schema)) the version of anything stamped with it. Both files carry the same hand-authored `$defs` block (the same object emitted twice in one generator run, so the copies cannot drift), covering the recursive paragraph/table/embedded-object, MathML, and package-tree node models that Zod's converter cannot express directly; `content-json-schema-defs.ts` holds those fragments, and a regression test compares each fragment that has a real Zod counterpart against a live `z.toJSONSchema()` of that schema so a field changed without updating its fragment fails a test. The one deliberate cross-file `$ref` is the embedded-object cycle back to a whole `ContentDocument`. Fragments downstream of a `z.custom()` node (`ContentBlock`, `ContentTable`/`Cell`/`Row`, `ContentEmbeddedObject(Block)`, the nine package-tree group wrappers, `MathMlNode`/`Element`/`Attribute`, `ContentFormula`, `MathExpression` and its recursive variants) still need hand re-verification — the construct descriptors themselves do not, since each is a plain `z.strictObject` reaching no opaque node and is held to the live comparison against `src/content.ts`/`src/package-node.ts`/`src/mathml.ts`/`src/math.ts` — see below.
 
 ### `z.custom()` vs `z.lazy()` for recursive schemas
 

package/dist/construct-CdQuI9f5.d.cts

@@ -0,0 +1,204 @@
+import { z } from "zod";
+//#region src/construct.d.ts
+declare const ContentControlTypeSchema: z.ZodEnum<{
+  richText: "richText";
+  plainText: "plainText";
+  checkbox: "checkbox";
+  dropDown: "dropDown";
+  comboBox: "comboBox";
+  date: "date";
+  picture: "picture";
+  repeatingSection: "repeatingSection";
+  button: "button";
+  index: "index";
+  group: "group";
+}>;
+type ContentControlType = z.infer<typeof ContentControlTypeSchema>;
+declare const ContentControlLockSchema: z.ZodEnum<{
+  content: "content";
+  container: "container";
+  both: "both";
+}>;
+type ContentControlLock = z.infer<typeof ContentControlLockSchema>;
+declare const ContentControlDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"contentControl">;
+  controlType: z.ZodEnum<{
+    richText: "richText";
+    plainText: "plainText";
+    checkbox: "checkbox";
+    dropDown: "dropDown";
+    comboBox: "comboBox";
+    date: "date";
+    picture: "picture";
+    repeatingSection: "repeatingSection";
+    button: "button";
+    index: "index";
+    group: "group";
+  }>;
+  tag: z.ZodOptional<z.ZodString>;
+  alias: z.ZodOptional<z.ZodString>;
+  lock: z.ZodOptional<z.ZodEnum<{
+    content: "content";
+    container: "container";
+    both: "both";
+  }>>;
+  value: z.ZodOptional<z.ZodString>;
+  checked: z.ZodOptional<z.ZodBoolean>;
+  options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type ContentControlDescriptor = z.infer<typeof ContentControlDescriptorSchema>;
+declare const FieldDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"field">;
+  instruction: z.ZodString;
+  cachedResult: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type FieldDescriptor = z.infer<typeof FieldDescriptorSchema>;
+declare const AnchorTypeSchema: z.ZodEnum<{
+  bookmark: "bookmark";
+  footnote: "footnote";
+  endnote: "endnote";
+  comment: "comment";
+}>;
+type AnchorType = z.infer<typeof AnchorTypeSchema>;
+declare const AnchorDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"anchor">;
+  anchorType: z.ZodEnum<{
+    bookmark: "bookmark";
+    footnote: "footnote";
+    endnote: "endnote";
+    comment: "comment";
+  }>;
+  name: z.ZodString;
+  definition: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type AnchorDescriptor = z.infer<typeof AnchorDescriptorSchema>;
+declare const LinkTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"external">;
+  uri: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"internal">;
+  anchor: z.ZodString;
+}, z.core.$strict>], "kind">;
+type LinkTarget = z.infer<typeof LinkTargetSchema>;
+declare const LinkDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"link">;
+  target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"external">;
+    uri: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"internal">;
+    anchor: z.ZodString;
+  }, z.core.$strict>], "kind">;
+  title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type LinkDescriptor = z.infer<typeof LinkDescriptorSchema>;
+declare const ProvenanceChangeSchema: z.ZodEnum<{
+  insertion: "insertion";
+  deletion: "deletion";
+  moveFrom: "moveFrom";
+  moveTo: "moveTo";
+  formatChange: "formatChange";
+}>;
+type ProvenanceChange = z.infer<typeof ProvenanceChangeSchema>;
+declare const ProvenanceDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"provenance">;
+  change: z.ZodEnum<{
+    insertion: "insertion";
+    deletion: "deletion";
+    moveFrom: "moveFrom";
+    moveTo: "moveTo";
+    formatChange: "formatChange";
+  }>;
+  author: z.ZodOptional<z.ZodString>;
+  dateIso: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type ProvenanceDescriptor = z.infer<typeof ProvenanceDescriptorSchema>;
+declare const DivisionSourceSchema: z.ZodObject<{
+  href: z.ZodString;
+  sectionName: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type DivisionSource = z.infer<typeof DivisionSourceSchema>;
+declare const DivisionDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"division">;
+  name: z.ZodOptional<z.ZodString>;
+  columnCount: z.ZodOptional<z.ZodNumber>;
+  protected: z.ZodOptional<z.ZodBoolean>;
+  source: z.ZodOptional<z.ZodObject<{
+    href: z.ZodString;
+    sectionName: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type DivisionDescriptor = z.infer<typeof DivisionDescriptorSchema>;
+declare const ConstructDescriptorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"contentControl">;
+  controlType: z.ZodEnum<{
+    richText: "richText";
+    plainText: "plainText";
+    checkbox: "checkbox";
+    dropDown: "dropDown";
+    comboBox: "comboBox";
+    date: "date";
+    picture: "picture";
+    repeatingSection: "repeatingSection";
+    button: "button";
+    index: "index";
+    group: "group";
+  }>;
+  tag: z.ZodOptional<z.ZodString>;
+  alias: z.ZodOptional<z.ZodString>;
+  lock: z.ZodOptional<z.ZodEnum<{
+    content: "content";
+    container: "container";
+    both: "both";
+  }>>;
+  value: z.ZodOptional<z.ZodString>;
+  checked: z.ZodOptional<z.ZodBoolean>;
+  options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"field">;
+  instruction: z.ZodString;
+  cachedResult: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"anchor">;
+  anchorType: z.ZodEnum<{
+    bookmark: "bookmark";
+    footnote: "footnote";
+    endnote: "endnote";
+    comment: "comment";
+  }>;
+  name: z.ZodString;
+  definition: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"link">;
+  target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"external">;
+    uri: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"internal">;
+    anchor: z.ZodString;
+  }, z.core.$strict>], "kind">;
+  title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"provenance">;
+  change: z.ZodEnum<{
+    insertion: "insertion";
+    deletion: "deletion";
+    moveFrom: "moveFrom";
+    moveTo: "moveTo";
+    formatChange: "formatChange";
+  }>;
+  author: z.ZodOptional<z.ZodString>;
+  dateIso: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"division">;
+  name: z.ZodOptional<z.ZodString>;
+  columnCount: z.ZodOptional<z.ZodNumber>;
+  protected: z.ZodOptional<z.ZodBoolean>;
+  source: z.ZodOptional<z.ZodObject<{
+    href: z.ZodString;
+    sectionName: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+}, z.core.$strict>], "kind">;
+type ConstructDescriptor = z.infer<typeof ConstructDescriptorSchema>;
+//#endregion
+export { ProvenanceChange as C, ProvenanceDescriptorSchema as E, LinkTargetSchema as S, ProvenanceDescriptor as T, FieldDescriptor as _, ConstructDescriptor as a, LinkDescriptorSchema as b, ContentControlDescriptorSchema as c, ContentControlType as d, ContentControlTypeSchema as f, DivisionSourceSchema as g, DivisionSource as h, AnchorTypeSchema as i, ContentControlLock as l, DivisionDescriptorSchema as m, AnchorDescriptorSchema as n, ConstructDescriptorSchema as o, DivisionDescriptor as p, AnchorType as r, ContentControlDescriptor as s, AnchorDescriptor as t, ContentControlLockSchema as u, FieldDescriptorSchema as v, ProvenanceChangeSchema as w, LinkTarget as x, LinkDescriptor as y };

package/dist/construct-CdQuI9f5.d.ts

@@ -0,0 +1,204 @@
+import { z } from "zod";
+//#region src/construct.d.ts
+declare const ContentControlTypeSchema: z.ZodEnum<{
+  richText: "richText";
+  plainText: "plainText";
+  checkbox: "checkbox";
+  dropDown: "dropDown";
+  comboBox: "comboBox";
+  date: "date";
+  picture: "picture";
+  repeatingSection: "repeatingSection";
+  button: "button";
+  index: "index";
+  group: "group";
+}>;
+type ContentControlType = z.infer<typeof ContentControlTypeSchema>;
+declare const ContentControlLockSchema: z.ZodEnum<{
+  content: "content";
+  container: "container";
+  both: "both";
+}>;
+type ContentControlLock = z.infer<typeof ContentControlLockSchema>;
+declare const ContentControlDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"contentControl">;
+  controlType: z.ZodEnum<{
+    richText: "richText";
+    plainText: "plainText";
+    checkbox: "checkbox";
+    dropDown: "dropDown";
+    comboBox: "comboBox";
+    date: "date";
+    picture: "picture";
+    repeatingSection: "repeatingSection";
+    button: "button";
+    index: "index";
+    group: "group";
+  }>;
+  tag: z.ZodOptional<z.ZodString>;
+  alias: z.ZodOptional<z.ZodString>;
+  lock: z.ZodOptional<z.ZodEnum<{
+    content: "content";
+    container: "container";
+    both: "both";
+  }>>;
+  value: z.ZodOptional<z.ZodString>;
+  checked: z.ZodOptional<z.ZodBoolean>;
+  options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type ContentControlDescriptor = z.infer<typeof ContentControlDescriptorSchema>;
+declare const FieldDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"field">;
+  instruction: z.ZodString;
+  cachedResult: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type FieldDescriptor = z.infer<typeof FieldDescriptorSchema>;
+declare const AnchorTypeSchema: z.ZodEnum<{
+  bookmark: "bookmark";
+  footnote: "footnote";
+  endnote: "endnote";
+  comment: "comment";
+}>;
+type AnchorType = z.infer<typeof AnchorTypeSchema>;
+declare const AnchorDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"anchor">;
+  anchorType: z.ZodEnum<{
+    bookmark: "bookmark";
+    footnote: "footnote";
+    endnote: "endnote";
+    comment: "comment";
+  }>;
+  name: z.ZodString;
+  definition: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type AnchorDescriptor = z.infer<typeof AnchorDescriptorSchema>;
+declare const LinkTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"external">;
+  uri: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"internal">;
+  anchor: z.ZodString;
+}, z.core.$strict>], "kind">;
+type LinkTarget = z.infer<typeof LinkTargetSchema>;
+declare const LinkDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"link">;
+  target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"external">;
+    uri: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"internal">;
+    anchor: z.ZodString;
+  }, z.core.$strict>], "kind">;
+  title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type LinkDescriptor = z.infer<typeof LinkDescriptorSchema>;
+declare const ProvenanceChangeSchema: z.ZodEnum<{
+  insertion: "insertion";
+  deletion: "deletion";
+  moveFrom: "moveFrom";
+  moveTo: "moveTo";
+  formatChange: "formatChange";
+}>;
+type ProvenanceChange = z.infer<typeof ProvenanceChangeSchema>;
+declare const ProvenanceDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"provenance">;
+  change: z.ZodEnum<{
+    insertion: "insertion";
+    deletion: "deletion";
+    moveFrom: "moveFrom";
+    moveTo: "moveTo";
+    formatChange: "formatChange";
+  }>;
+  author: z.ZodOptional<z.ZodString>;
+  dateIso: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type ProvenanceDescriptor = z.infer<typeof ProvenanceDescriptorSchema>;
+declare const DivisionSourceSchema: z.ZodObject<{
+  href: z.ZodString;
+  sectionName: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type DivisionSource = z.infer<typeof DivisionSourceSchema>;
+declare const DivisionDescriptorSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"division">;
+  name: z.ZodOptional<z.ZodString>;
+  columnCount: z.ZodOptional<z.ZodNumber>;
+  protected: z.ZodOptional<z.ZodBoolean>;
+  source: z.ZodOptional<z.ZodObject<{
+    href: z.ZodString;
+    sectionName: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type DivisionDescriptor = z.infer<typeof DivisionDescriptorSchema>;
+declare const ConstructDescriptorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"contentControl">;
+  controlType: z.ZodEnum<{
+    richText: "richText";
+    plainText: "plainText";
+    checkbox: "checkbox";
+    dropDown: "dropDown";
+    comboBox: "comboBox";
+    date: "date";
+    picture: "picture";
+    repeatingSection: "repeatingSection";
+    button: "button";
+    index: "index";
+    group: "group";
+  }>;
+  tag: z.ZodOptional<z.ZodString>;
+  alias: z.ZodOptional<z.ZodString>;
+  lock: z.ZodOptional<z.ZodEnum<{
+    content: "content";
+    container: "container";
+    both: "both";
+  }>>;
+  value: z.ZodOptional<z.ZodString>;
+  checked: z.ZodOptional<z.ZodBoolean>;
+  options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"field">;
+  instruction: z.ZodString;
+  cachedResult: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"anchor">;
+  anchorType: z.ZodEnum<{
+    bookmark: "bookmark";
+    footnote: "footnote";
+    endnote: "endnote";
+    comment: "comment";
+  }>;
+  name: z.ZodString;
+  definition: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"link">;
+  target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"external">;
+    uri: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"internal">;
+    anchor: z.ZodString;
+  }, z.core.$strict>], "kind">;
+  title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"provenance">;
+  change: z.ZodEnum<{
+    insertion: "insertion";
+    deletion: "deletion";
+    moveFrom: "moveFrom";
+    moveTo: "moveTo";
+    formatChange: "formatChange";
+  }>;
+  author: z.ZodOptional<z.ZodString>;
+  dateIso: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"division">;
+  name: z.ZodOptional<z.ZodString>;
+  columnCount: z.ZodOptional<z.ZodNumber>;
+  protected: z.ZodOptional<z.ZodBoolean>;
+  source: z.ZodOptional<z.ZodObject<{
+    href: z.ZodString;
+    sectionName: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+}, z.core.$strict>], "kind">;
+type ConstructDescriptor = z.infer<typeof ConstructDescriptorSchema>;
+//#endregion
+export { ProvenanceChange as C, ProvenanceDescriptorSchema as E, LinkTargetSchema as S, ProvenanceDescriptor as T, FieldDescriptor as _, ConstructDescriptor as a, LinkDescriptorSchema as b, ContentControlDescriptorSchema as c, ContentControlType as d, ContentControlTypeSchema as f, DivisionSourceSchema as g, DivisionSource as h, AnchorTypeSchema as i, ContentControlLock as l, DivisionDescriptorSchema as m, AnchorDescriptorSchema as n, ConstructDescriptorSchema as o, DivisionDescriptor as p, AnchorType as r, ContentControlDescriptor as s, AnchorDescriptor as t, ContentControlLockSchema as u, FieldDescriptorSchema as v, ProvenanceChangeSchema as w, LinkTarget as x, LinkDescriptor as y };

package/dist/construct.cjs

@@ -0,0 +1,106 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+//#region src/construct.ts
+const ContentControlTypeSchema = zod.z.enum([
+	"richText",
+	"plainText",
+	"checkbox",
+	"dropDown",
+	"comboBox",
+	"date",
+	"picture",
+	"repeatingSection",
+	"button",
+	"index",
+	"group"
+]);
+const ContentControlLockSchema = zod.z.enum([
+	"content",
+	"container",
+	"both"
+]);
+const ContentControlDescriptorSchema = zod.z.strictObject({
+	kind: zod.z.literal("contentControl"),
+	controlType: ContentControlTypeSchema,
+	tag: zod.z.string().optional(),
+	alias: zod.z.string().optional(),
+	lock: ContentControlLockSchema.optional(),
+	value: zod.z.string().optional(),
+	checked: zod.z.boolean().optional(),
+	options: zod.z.array(zod.z.string()).optional()
+});
+const FieldDescriptorSchema = zod.z.strictObject({
+	kind: zod.z.literal("field"),
+	instruction: zod.z.string(),
+	cachedResult: zod.z.string().optional()
+});
+const AnchorTypeSchema = zod.z.enum([
+	"bookmark",
+	"footnote",
+	"endnote",
+	"comment"
+]);
+const AnchorDescriptorSchema = zod.z.strictObject({
+	kind: zod.z.literal("anchor"),
+	anchorType: AnchorTypeSchema,
+	name: zod.z.string(),
+	definition: zod.z.string().optional()
+});
+const LinkTargetSchema = zod.z.discriminatedUnion("kind", [zod.z.strictObject({
+	kind: zod.z.literal("external"),
+	uri: zod.z.string()
+}), zod.z.strictObject({
+	kind: zod.z.literal("internal"),
+	anchor: zod.z.string()
+})]);
+const LinkDescriptorSchema = zod.z.strictObject({
+	kind: zod.z.literal("link"),
+	target: LinkTargetSchema,
+	title: zod.z.string().optional()
+});
+const ProvenanceChangeSchema = zod.z.enum([
+	"insertion",
+	"deletion",
+	"moveFrom",
+	"moveTo",
+	"formatChange"
+]);
+const ProvenanceDescriptorSchema = zod.z.strictObject({
+	kind: zod.z.literal("provenance"),
+	change: ProvenanceChangeSchema,
+	author: zod.z.string().optional(),
+	dateIso: zod.z.string().optional()
+});
+const DivisionSourceSchema = zod.z.strictObject({
+	href: zod.z.string(),
+	sectionName: zod.z.string().optional()
+});
+const DivisionDescriptorSchema = zod.z.strictObject({
+	kind: zod.z.literal("division"),
+	name: zod.z.string().optional(),
+	columnCount: zod.z.number().int().positive().optional(),
+	protected: zod.z.boolean().optional(),
+	source: DivisionSourceSchema.optional()
+});
+const ConstructDescriptorSchema = zod.z.discriminatedUnion("kind", [
+	ContentControlDescriptorSchema,
+	FieldDescriptorSchema,
+	AnchorDescriptorSchema,
+	LinkDescriptorSchema,
+	ProvenanceDescriptorSchema,
+	DivisionDescriptorSchema
+]);
+//#endregion
+exports.AnchorDescriptorSchema = AnchorDescriptorSchema;
+exports.AnchorTypeSchema = AnchorTypeSchema;
+exports.ConstructDescriptorSchema = ConstructDescriptorSchema;
+exports.ContentControlDescriptorSchema = ContentControlDescriptorSchema;
+exports.ContentControlLockSchema = ContentControlLockSchema;
+exports.ContentControlTypeSchema = ContentControlTypeSchema;
+exports.DivisionDescriptorSchema = DivisionDescriptorSchema;
+exports.DivisionSourceSchema = DivisionSourceSchema;
+exports.FieldDescriptorSchema = FieldDescriptorSchema;
+exports.LinkDescriptorSchema = LinkDescriptorSchema;
+exports.LinkTargetSchema = LinkTargetSchema;
+exports.ProvenanceChangeSchema = ProvenanceChangeSchema;
+exports.ProvenanceDescriptorSchema = ProvenanceDescriptorSchema;

package/dist/construct.d.cts

@@ -0,0 +1,2 @@
+import { C as ProvenanceChange, E as ProvenanceDescriptorSchema, S as LinkTargetSchema, T as ProvenanceDescriptor, _ as FieldDescriptor, a as ConstructDescriptor, b as LinkDescriptorSchema, c as ContentControlDescriptorSchema, d as ContentControlType, f as ContentControlTypeSchema, g as DivisionSourceSchema, h as DivisionSource, i as AnchorTypeSchema, l as ContentControlLock, m as DivisionDescriptorSchema, n as AnchorDescriptorSchema, o as ConstructDescriptorSchema, p as DivisionDescriptor, r as AnchorType, s as ContentControlDescriptor, t as AnchorDescriptor, u as ContentControlLockSchema, v as FieldDescriptorSchema, w as ProvenanceChangeSchema, x as LinkTarget, y as LinkDescriptor } from "./construct-CdQuI9f5.cjs";
+export { AnchorDescriptor, AnchorDescriptorSchema, AnchorType, AnchorTypeSchema, ConstructDescriptor, ConstructDescriptorSchema, ContentControlDescriptor, ContentControlDescriptorSchema, ContentControlLock, ContentControlLockSchema, ContentControlType, ContentControlTypeSchema, DivisionDescriptor, DivisionDescriptorSchema, DivisionSource, DivisionSourceSchema, FieldDescriptor, FieldDescriptorSchema, LinkDescriptor, LinkDescriptorSchema, LinkTarget, LinkTargetSchema, ProvenanceChange, ProvenanceChangeSchema, ProvenanceDescriptor, ProvenanceDescriptorSchema };

package/dist/construct.d.ts

@@ -0,0 +1,2 @@
+import { C as ProvenanceChange, E as ProvenanceDescriptorSchema, S as LinkTargetSchema, T as ProvenanceDescriptor, _ as FieldDescriptor, a as ConstructDescriptor, b as LinkDescriptorSchema, c as ContentControlDescriptorSchema, d as ContentControlType, f as ContentControlTypeSchema, g as DivisionSourceSchema, h as DivisionSource, i as AnchorTypeSchema, l as ContentControlLock, m as DivisionDescriptorSchema, n as AnchorDescriptorSchema, o as ConstructDescriptorSchema, p as DivisionDescriptor, r as AnchorType, s as ContentControlDescriptor, t as AnchorDescriptor, u as ContentControlLockSchema, v as FieldDescriptorSchema, w as ProvenanceChangeSchema, x as LinkTarget, y as LinkDescriptor } from "./construct-CdQuI9f5.js";
+export { AnchorDescriptor, AnchorDescriptorSchema, AnchorType, AnchorTypeSchema, ConstructDescriptor, ConstructDescriptorSchema, ContentControlDescriptor, ContentControlDescriptorSchema, ContentControlLock, ContentControlLockSchema, ContentControlType, ContentControlTypeSchema, DivisionDescriptor, DivisionDescriptorSchema, DivisionSource, DivisionSourceSchema, FieldDescriptor, FieldDescriptorSchema, LinkDescriptor, LinkDescriptorSchema, LinkTarget, LinkTargetSchema, ProvenanceChange, ProvenanceChangeSchema, ProvenanceDescriptor, ProvenanceDescriptorSchema };