@openpresentation/opf-pptx 0.11.6 → 0.11.7

package/README.md

@@ -1,6 +1,6 @@
 # OPF PPTX
 
-Version 0.11.6 exports the treemap, histogram, pareto, box-and-whisker, waterfall and funnel charts as native chartex parts by default (`toPptx({chartex: 'auto'})`; `world` stays a clustered column with `chart-data-adapted`; pass `chartex: 'fallback'` for the previous output) and gives chartex text the deck's label colour and font (no API removed). Version 0.11.5 writes the slide tag run as a theme color reference (`a:schemeClr accent1`) where the deck theme holds the primary there (no API change; the color is unchanged). Version 0.11.4 re-imports quote payloads (each native quote line carries an `OPF_QUOTE_V1` tag) and slide-image payloads from an unchanged export, writes the theme's `a:ea` and `a:cs` only for slots a script font is selected for, and requires core `^0.11.3` (the 70 legacy gallery layout ids and their geometry; install it with renderer 0.11.6 and editor 0.10.4 so export and preview resolve the same core; no API removed). Version 0.11.3 adds the opt-in `toPptx({ chartex: 'native' })` export of the seven chartex chart types and always imports chartex charts (no API removed; the default output is unchanged). Version 0.11.2 exports the classic chart types as native chart constructs and writes named and default table colours, text pairs and hyperlink colours as theme references (no API or dependency change; resolved colours are unchanged). Version 0.11.1 exports `design.watermark` as a native picture (it re-imports) and embeds byte-identical media parts once, with no API or dependency change. Version 0.11.0 requires core `^0.11.2` (cover slides are centered between header and footer furniture) and the optional `@openpresentation/opf-render` peer `^0.11.0`; install them together so export and preview resolve the same core. Version 0.10.0 required core `^0.11.1` and the peer `^0.10.0`. It adds native slide-number and date fields, socials, slide-image treatments, theme color schemes, script-slot fonts and RTL, re-import of design and metadata references, native underline and current-body formatting on import, and UTC-canonical `zipDate` (see the changelog for the intentional contract changes).
+Version 0.11.7 requires `@openpresentation/opf` ^0.11.4 and exports the design fields natively (cover and section logos, header and footer logos, picture bullets, the accent font), writes every chart's text at the size the preview draws, round-trips the slide content structure, sections, extensions, assets and brand images through PPTX provenance (a fresh export of a plain deck re-imports in its authored form, so read a root payload field before `blocks[0]`), writes slide sections as PowerPoint's section list, and degrades an SVG image to the preview's placeholder instead of aborting; install it with renderer 0.11.9 and editor 0.10.6 so export and preview resolve the same core (no API removed). Version 0.11.6 exports the treemap, histogram, pareto, box-and-whisker, waterfall and funnel charts as native chartex parts by default (`toPptx({chartex: 'auto'})`; `world` stays a clustered column with `chart-data-adapted`; pass `chartex: 'fallback'` for the previous output) and gives chartex text the deck's label colour and font (no API removed). Version 0.11.5 writes the slide tag run as a theme color reference (`a:schemeClr accent1`) where the deck theme holds the primary there (no API change; the color is unchanged). Version 0.11.4 re-imports quote payloads (each native quote line carries an `OPF_QUOTE_V1` tag) and slide-image payloads from an unchanged export, writes the theme's `a:ea` and `a:cs` only for slots a script font is selected for, and requires core `^0.11.3` (the 70 legacy gallery layout ids and their geometry; install it with renderer 0.11.6 and editor 0.10.4 so export and preview resolve the same core; no API removed). Version 0.11.3 adds the opt-in `toPptx({ chartex: 'native' })` export of the seven chartex chart types and always imports chartex charts (no API removed; the default output is unchanged). Version 0.11.2 exports the classic chart types as native chart constructs and writes named and default table colours, text pairs and hyperlink colours as theme references (no API or dependency change; resolved colours are unchanged). Version 0.11.1 exports `design.watermark` as a native picture (it re-imports) and embeds byte-identical media parts once, with no API or dependency change. Version 0.11.0 requires core `^0.11.2` (cover slides are centered between header and footer furniture) and the optional `@openpresentation/opf-render` peer `^0.11.0`; install them together so export and preview resolve the same core. Version 0.10.0 required core `^0.11.1` and the peer `^0.10.0`. It adds native slide-number and date fields, socials, slide-image treatments, theme color schemes, script-slot fonts and RTL, re-import of design and metadata references, native underline and current-body formatting on import, and UTC-canonical `zipDate` (see the changelog for the intentional contract changes).
 
 Version 0.9.1 kept core `^0.11.0` and raised the optional `@openpresentation/opf-render` peer to `^0.9.0` so it coexists with editor 0.8.0. ColorRef / `variables` on content colors still hex-resolve through core `resolveColorRef()` before PptxGenJS `srgbClr` export. Unrecognized run colors such as `color:'invalid'` still validate and fall back to the theme text color. Native DrawingML `schemeClr` and theme `clrScheme` writes, and native `p:hf` headers/footers, are not in this release. Import still flattens theme colors to hex. Metric, quote and timeline layout placeholders and the corrected text-bullet contract from 0.8.1 are retained.
 
@@ -55,6 +55,8 @@ await fs.promises.writeFile("quarterly-review.pptx", bytes);
 
 `toPptx` returns a `Uint8Array` containing a PowerPoint-openable `.pptx`. It does not fetch remote assets. Data URI images and local paths can be embedded directly; hosts that need private asset loading should pass `imageResolver(src, context)`. Set `strictAssets: true` to turn unresolved or remote image assets into structured `OPFPptxError` failures instead of editable placeholder boxes.
 
+Embedded picture bytes must be a PNG, JPEG, GIF or WebP. An SVG (or bytes that are no readable image) has no raster for PowerPoint, so, like an unresolved asset, it exports what the preview shows: the "Image unavailable" placeholder (nothing for a watermark, the background colour for a background image) and one `unresolved-asset` diagnostic with `reason: "unsupported-format"`; `strictAssets` throws `unsupported-image-dimensions`. To embed the artwork, return a raster from `imageResolver`; the exporter has no rasterizer of its own, and opf-render's `svgToPng(svg)` is the usual one: have `imageResolver` return `{data: await svgToPng(svgText), mediaType: "image/png"}` for an SVG source (the SVG text is yours to read from the data URI or file).
+
 `fromPptx` parses an existing `.pptx` buffer locally and returns an OPF document that validates with `@openpresentation/opf`:
 
 ```js
@@ -82,7 +84,8 @@ The first exporter keeps the public API stable while using `pptxgenjs` internall
 - Root payloads, `blocks[]`, and promoted region keys become editable slide objects in deterministic regions. Promoted keys use the OPF 3x3 region vocabulary (`top`, `middle`, `bottom`, `left`, `center`, `right`).
 - Text, lists, metrics, quotes, timelines, code, tables, and inline-data charts are emitted as editable PowerPoint text, table, and chart objects. Content ColorRef values (hex, scheme slots/roles, and `var:<id>`) resolve through core `resolveColorRef()`. Slot and role names become native `a:schemeClr` references when the exported theme holds that exact color; hex, `var:<id>` and slide-override colors stay `a:srgbClr` (see [Theme color scheme](#theme-color-scheme)). Each classic chart type the core catalog keeps (one per Aspose.Slides `ChartType`: clustered/stacked/100% stacked column and bar, line and stacked line with or without markers, area/stacked/100% area, pie, doughnut, scatter with markers, radar/radar with markers/filled radar) is written as its exact native construct; deprecated core ids export as their replacement; other ids keep the previous best-effort mapping. The chartex types treemap, histogram, pareto, box & whisker, waterfall and funnel are written as native Office 2016 chartex parts (confirmed in desktop PowerPoint on 2026-09-30; see [Chartex charts](#chartex-charts-ff-22b)); the map (`world`) stays a clustered column chart by default and reports `chart-data-adapted` (`chartex-fallback`) until PowerPoint accepts its regionMap part (`chartex: "native"` writes it anyway, `chartex: "fallback"` writes clustered columns for every chartex id). A pie or doughnut chart, or a one-series chartex construct, plots only its first series and reports `chart-data-adapted` (`series-dropped`) when it has more.
 - A chart whose data is one column of values (a histogram or dot plot) has no category column. A histogram or Pareto chart bins the values itself (PowerPoint's histogram with an explicit automatic bin count, no diagnostic) and re-imports as authored; any other chart type plots the values against their row numbers and reports `chart-data-adapted` (`row-numbers`). With `chartex: "fallback"` a histogram is binned into equal-width bins (Sturges' count, at most 50) and written as a column chart of the counts (`histogram-binned`; the binned counts do not round-trip). Cells parse as in every chart ("12%", "$5" and "1,234" count) and cells that hold no number are skipped, not plotted as 0. Chart data that cannot be plotted (no numbers, no rows, or an external data source), an empty table and unsupported content keep a placeholder frame with a plain-language description (never a dump of the source data or URLs) and report `chart-data-unplottable` or `content-placeholder` with a `reason`; content is never dropped without a diagnostic.
-- Image assets are embedded only when supplied as data URIs, local paths, or host-resolved bytes/paths. Remote asset URLs are never fetched by the runtime path.
+- Image assets are embedded only when supplied as data URIs, local paths, or host-resolved bytes/paths. Remote asset URLs are never fetched by the runtime path. A picture's native description is the authored `alt` (never a stand-in such as `preencoded.png` or the file path), and a distinct asset `title` is the picture's native `title`; `fromPptx` reads both back.
+- A chart cell that holds no number (`null`, an empty or non-numeric string, a boolean) is a gap in the native chart: its cache has no point at that row (`c:ptCount` keeps the row count), its workbook cell is blank, and it re-imports as `null`. An actual zero stays zero.
 - ZIP entries, generated chart/workbook part names, core-property timestamps, and nested chart workbook timestamps are normalized for reproducible bytes. [Export determinism](docs/export-determinism.md) lists the tested time zone, locale, clock and host-font controls and each known variance (WebP conversion, font registries, ICU segmentation, timestamps).
 - The package names only the document's chosen fonts. Chart text (data labels, axes, legend, titles) uses the chart slide's body font in `latin`/`ea`/`cs`; each embedded chart workbook uses the same fonts in its styles and theme; run `pitchFamily` follows the font scheme type (monospace is fixed pitch, serif is roman); and `docProps/app.xml` "Fonts Used" lists the fonts the package actually uses. The theme keeps PptxGenJS's per-script supplements (`THEME_SCRIPT_SUPPLEMENTS`) and empty `ea`/`cs` slots unless a script font was selected for that slot (see [Languages, right-to-left text and script fonts](#languages-right-to-left-text-and-script-fonts)).
 - `checkPptxTypefaces(bytes, {fonts, monospace, themeScripts})` (optional `themeScripts: {major: {ea, cs}, minor: {ea, cs}}` names the East Asian / complex-script families the author selected; a selected theme slot that is empty or different is reported as `theme-script-slot`, an unselected one may stay empty) inventories every `typeface`, workbook font name and "Fonts Used" entry in every XML part, including nested packages, and reports each font outside that policy. `inventoryPptxTypefaces()` returns the raw inventory.
@@ -128,6 +131,8 @@ The first importer is mechanical and schema-compatible:
 - Conditional table styles, merged-cell geometry, cell fills/borders/alignment, unsupported text fills/colors, and internal hyperlink actions are not fully reconstructed. `onDiagnostic` reports unsupported table style references, merges, fonts/colors/fills and links with native frame/cell paths. Table paths use the native graphic-frame and row indexes, including a header row. The shared core 0.6.0 layout sizes rows from their content and reports `text-overflow` when text cannot fit at the minimum size. These checks establish native XML conversion, not visual parity with PowerPoint.
 - Unknown non-text shapes and unsupported graphic frames become editable text fallback blocks instead of failing the import.
 - Catalog references (`design.theme`, `colorScheme`, `fontScheme`, `dimensions`, `background`, slide `layout`), slide ids and authoring metadata (`narrative`, `tone`, `audience`, `purpose`, `language`, `organization`, `speaker`, ...) are stored at export in `OPF_DOCUMENT_V1` / `OPF_SLIDE_V1` customer-data tags. Import restores a reference while the theme colors, theme fonts, slide size, background or slide arrangement it produced are unchanged. After an edit, the observed native values stay and `design-reference-changed` / `layout-reference-changed` name the reference. `toPptx` option `provenance: 'references-only' | false` limits or disables these invisible tags. Slide layout intent (layout id, type, composition, composition hints and the inline layout record) lives in each `OPF_SLIDE_V1` record, so a slide keeps its layout even without the document tag, for example when it is pasted into another deck (FF-29). See [document round trips](docs/document-roundtrip.md) for exactly what is embedded.
+- The slide's content structure is part of `OPF_SLIDE_V1` too (`full` mode): nested `group` blocks, promoted regions (`left`, `top:left`, ...), a root payload (`text`, `items`, `chart`, ...) versus `blocks`, block `id`s and `extensions`, group `composition`, with the reference-pixel box of every leaf from the same composition the export drew. Import matches the native shapes to those boxes and rebuilds the authored form while the slide's arrangement is unchanged, so `slide.type` validates again; a slide whose blocks no longer fit the stored boxes keeps its flat blocks and reports `content-structure-changed` at `slides.N`; a duplicated slide reports `duplicate-block-id` and drops the repeated id. The document tag also stores `filename`, root `extensions`, slide `section` and `extensions`, `design.logo` (deck and slide) and the whole `assets` registry; a `data:` source that is not an exported picture is stored inline up to 256 KiB, so an organization logo or speaker photo given as a data URI round-trips.
+- Slide `section` labels are written as PowerPoint's native section list (`p14:sectionLst` in `ppt/presentation.xml`, whatever the `provenance` option): one section per run of consecutive slides with the same label, runs without a label as `Default Section`, with deterministic ids. Import reads the list back (`Default Section` means no section); it wins over the stored value and over the section text a footer shows (`section-reference-changed` at `slides.N.section`), except that an edited footer line keeps its text while the list still equals the stored value. The native PowerPoint check of the sections pane and save/reopen is a separate gate (`scratchpad/spec-gaps-native/`).
 
 There is no AI classification pass in the OSS runtime. Hosts can run optional cleanup or semantic remapping after `fromPptx` returns.
 
@@ -248,6 +253,15 @@ Slide-image treatments export from core's normalized geometry as native DrawingM
 
 A deck or slide watermark (`design.watermark`) exports as one native picture named `OPF watermark` per slide, after the slide image and its overlay, if any, and before all content (the preview's paint order, so a background slide image lies beneath the watermark), at the preview's frame: the centered 40% by 40% box at 30%/30% of the slide, fitted without cropping. Its opacity is `a:alphaModFix` (the object form's `opacity`, otherwise the preview default 0.08), and its alt text is the asset's `alt`, otherwise `Watermark`. `design.watermark = false` on a slide exports none. An unchanged export imports back as `design.watermark` (at deck level when every slide carries the same one); an edited picture stays ordinary content and reports `invalid-watermark-provenance`. An unresolved image reports `unresolved-asset` and an object with no `src` reports `watermark-not-exported`.
 
+### Brand assets, picture bullets and the accent font (spec-gap closure A)
+
+These design fields need the core that composes them (`resolveLogo`, `geometry.logo`, `item.bulletImage`, `fontScheme.accent`; core 0.11.4 or the coordinated source). On core 0.11.3 the export carries none of them and is byte-identical to the previous output. Each one is drawn at the box core composes, which the preview draws too (see core `docs/design-resolution.md`, "Brand assets and layout hints").
+
+- **Cover and section logo** (`design.logo`, a slide's own `design.logo`, else the primary organization's `logo`). One native picture named `OPF logo`, after the watermark and before the content, fitted without cropping into core's `geometry.logo` box (56 px high at 720 px, up to four times as wide), anchored at the box's left edge and vertically centered, exactly the preview's `xMinYMid meet`. Its alt text is the asset's `alt`, otherwise `Logo`. A LogoSet picks its variant from the slide background (a dark background takes the light variants); the exporter's dark test is the one that already chooses the text colour. An unresolved or unreadable logo draws the preview's "Image unavailable" panel in the box and reports `unresolved-asset` at the logo's path (`strictAssets` throws). Content slides never get one. The picture carries an `OPF_LOGO_V1` tag (slide, source path, variant, the exact picture properties): an unchanged export consumes the picture on import (it is not content; `design.logo` itself returns from the document tag), and an edited, ambiguous or damaged one stays an ordinary picture and reports `invalid-logo-provenance`. When nothing else restored a logo (an export with `provenance: false`, or with `references-only`, which stores no sources), the consumed picture's own image becomes `design.logo` (the slide's own for a slide-level logo), so the logo is never lost; it is a single image, not the LogoSet. A PPTX with no OPF tags imports the picture as an ordinary image block and invents no `design.logo`.
+- **Header and footer `logo: true`.** A generated image part in the part's box (the icon variant), exported like an `image` part with the furniture picture tag replaced by an `OPF_LOGO_V1` tag with role `furniture`. The slide's furniture manifest lists it under a separate `logos` key (`{kind, zone, drawn}`), never in `parts` or `definitions`, because every released importer validates those two strictly. It re-imports as `logo: true`, never as an `image` data URI; without a resolvable logo core reports `unresolved-content` at `<zone>.logo`, nothing is drawn and `logo: true` still returns (`drawn: false`).
+- **Picture bullets** (`design.listBullet: image`, resolved to the icon logo by core as `item.bulletImage`). Every entry's first line carries `<a:buSzPct val="100000"/><a:buBlip><a:blip r:embed=…/></a:buBlip>` in place of the character bullet, so the marker is the text size, like the preview's square marker. PptxGenJS embeds the icon once per slide (a picture named `OPF bullet image`); packaging removes that picture and keeps the media part and its relationship for the `a:buBlip` elements. Marker indent and text positions are those of the character bullets. An icon that cannot be embedded keeps the character bullets and reports `unresolved-asset` once per slide at the logo's path. Import recognizes `a:buBlip` paragraphs as list paragraphs; `design.listBullet` returns from the stored design hint (a PPTX without tags has no hint). PowerPoint shows a picture bullet at the picture's own aspect ratio; use a square icon for the preview's square marker. The released 0.11.6 importer does not know `a:buBlip` and imports such a list as plain text lines.
+- **`fontScheme.accent`.** Core resolves the accent role for the slide tag (eyebrow) and the quote body, so their runs carry the accent typeface in `a:latin`, `a:ea` and `a:cs` with the catalog's pitch family when the family is known; theme major/minor fonts, every other run and the theme are unchanged. The accent family appears in `docProps/app.xml` "Fonts Used" like any other used font; `checkPptxTypefaces` callers list it in `options.fonts`. `design.fontScheme` (with `accent`) returns from the document tag.
+
 An unchanged export imports every treatment field back. An edited overlay drops only the overlay and reports `invalid-slide-image-provenance`. An edited picture or effect drops the slide image. See core `docs/image-treatments.md` for the vocabulary and the unsupported effects: blur, shadows, soft edges and background removal. PowerPoint's luminance weights for grayscale and duotone are unverified natively.
 
 Tests compare SVG/native fit and crop geometry across nine synthetic raster fixtures and cover all eight JPEG orientations. Keynote 14.4 visually preserves proportions for wide/tall fit/crop and displays all eight orientations correctly. This does not establish Microsoft PowerPoint raster parity or WebP support in every Office version.
@@ -271,7 +285,7 @@ Node conversion lazily loads the pinned open-source Sharp dependency and require
 
 ## Native background fills
 
-Fixed solid and linear-gradient backgrounds now export as native slide fills, keeping the background editable without rasterizing slide content. Deck defaults, inline theme overrides and per-slide overrides are resolved before export. Solid opacity, gradient stop colors/positions and combined color/background alpha are preserved. Empty and single-stop gradients follow the SVG preview's transparent/solid behavior; descending stop positions clamp to the preceding stop.
+Fixed solid and linear-gradient backgrounds now export as native slide fills, keeping the background editable without rasterizing slide content. Deck defaults, inline theme overrides and per-slide overrides are resolved before export. Solid opacity, gradient stop colors/positions and combined color/background alpha are preserved. Solid, gradient-stop and pattern colors are ColorRefs, resolved like table fills and run colors: a `var:` variable or a colour-scheme slot or role name (`accent2`, `primary`) paints its colour, and a slot the deck theme holds exactly is written as `a:schemeClr`. The slide's default text contrast follows the resolved colour. Empty and single-stop gradients follow the SVG preview's transparent/solid behavior; descending stop positions clamp to the preceding stop.
 
 Diagonal gradients require a coordinate conversion: the preview uses an SVG object-bounding-box gradient, while native unscaled DrawingML angles use slide coordinates. Export converts both the physical gradient direction and stop interval. Tests compare 990 sample positions from serialized SVG/native properties across 33 gradients and three aspect ratios, plus solid opacity, inheritance, native edits and repeated imports/exports. Integer native angles/positions introduce small rounding differences. The mapping follows the [DrawingML linear-gradient angle definition](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.drawing.lineargradientfill?view=openxml-3.0.1).
 

package/dist/background.js

@@ -33,21 +33,23 @@ export const nativePatternPreset = preset => presetPatterns.has(preset) ? preset
 // The SVG preview paints the pattern background color and foreground marks,
 // defaulting to white and the slide text color. Other engine-defined presets
 // have no DrawingML equivalent; like the preview, only their background color remains.
-// `scheme(reference, hex)` names the theme color for an authored slot/role
-// reference whose drawn color the deck theme holds exactly (FF-24); pattern
-// colors then become a:schemeClr, keeping any background opacity as alpha.
-export function nativeBackgroundFill(background, {width, height}, fallback = 'FFFFFF', foreground = '000000', scheme = () => undefined) {
+// `resolve(reference)` turns a ColorRef (a `var:` variable, a colour-scheme slot or
+// role name) into a hex colour, as for table fills and run colours; literals pass
+// through. `scheme(reference, hex)` names the theme color for an authored slot/role
+// reference whose drawn color the deck theme holds exactly (FF-24); solid, gradient
+// and pattern colors then become a:schemeClr, keeping any background opacity as alpha.
+export function nativeBackgroundFill(background, {width, height}, fallback = 'FFFFFF', foreground = '000000', scheme = () => undefined, resolve = value => value) {
   if (typeof background === 'string' && /^#[\da-f]{3}(?:[\da-f]{3}(?:[\da-f]{2})?)?$/i.test(background)) background = {type: 'solid', color: background};
   if (!background || typeof background !== 'object') return null;
   const opacity = background.opacity ?? 1;
-  if (background.type === 'solid' || background.type === 'theme') return `<a:solidFill>${colorXml(background.type === 'theme' ? fallback : background.color, opacity, fallback)}</a:solidFill>`;
+  const paint = (value, base) => {
+    const hex = resolve(value), c = color(hex, base), themeValue = c.alpha === 1 ? scheme(value, c.hex) : undefined;
+    if (!themeValue) return colorXml(hex, opacity, base);
+    const alpha = Math.round(clamp(opacity) * 100000);
+    return `<a:schemeClr val="${themeValue}">${alpha === 100000 ? '' : `<a:alpha val="${alpha}"/>`}</a:schemeClr>`;
+  };
+  if (background.type === 'solid' || background.type === 'theme') return `<a:solidFill>${background.type === 'theme' ? colorXml(fallback, opacity, fallback) : paint(background.color, fallback)}</a:solidFill>`;
   if (background.type === 'pattern') {
-    const paint = (value, base) => {
-      const c = color(value, base), themeValue = c.alpha === 1 ? scheme(value, c.hex) : undefined;
-      if (!themeValue) return colorXml(value, opacity, base);
-      const alpha = Math.round(clamp(opacity) * 100000);
-      return `<a:schemeClr val="${themeValue}">${alpha === 100000 ? '' : `<a:alpha val="${alpha}"/>`}</a:schemeClr>`;
-    };
     const pattern = background.pattern ?? {}, back = paint(pattern.backgroundColor, 'FFFFFF');
     const preset = nativePatternPreset(pattern.preset);
     if (!preset) return `<a:solidFill>${back}</a:solidFill>`;
@@ -56,7 +58,7 @@ export function nativeBackgroundFill(background, {width, height}, fallback = 'FF
   if (background.type !== 'gradient') return null;
   const stops = background.gradient?.stops ?? [];
   if (!stops.length) return '<a:noFill/>';
-  if (stops.length === 1) return `<a:solidFill>${colorXml(stops[0].color, opacity, fallback)}</a:solidFill>`;
+  if (stops.length === 1) return `<a:solidFill>${paint(stops[0].color, fallback)}</a:solidFill>`;
   const radians = turn(background.gradient?.angle ?? 0) * Math.PI / 180;
   const c = Math.cos(radians), s = Math.sin(radians), span = Math.abs(c) + Math.abs(s);
   const angle = Math.round(turn(Math.atan2(s / height, c / width) * 180 / Math.PI) * 60000) % 21600000;
@@ -65,7 +67,7 @@ export function nativeBackgroundFill(background, {width, height}, fallback = 'FF
     // SVG clamps a descending stop to the preceding position.
     prior = Math.max(prior, stop.position);
     const position = Math.round(((prior - .5) / span + .5) * 100000);
-    return `<a:gs pos="${position}">${colorXml(stop.color, opacity, fallback)}</a:gs>`;
+    return `<a:gs pos="${position}">${paint(stop.color, fallback)}</a:gs>`;
   }).join('');
   return `<a:gradFill rotWithShape="0"><a:gsLst>${nativeStops}</a:gsLst><a:lin ang="${angle}" scaled="0"/></a:gradFill>`;
 }

package/dist/chartex.js

@@ -121,9 +121,9 @@ function layoutProperties(spec, series, hasCategories) {
 // the style's tx1 grey on a dark theme), so every axis, data label set and
 // legend carries the deck's label colour and font explicitly, like the classic
 // chart path writes into every c:txPr.
-function textProperties(labelColor, font) {
+function textProperties(labelColor, font, size) {
   const face = escapeXml(font);
-  return `<cx:txPr><a:bodyPr/><a:lstStyle/><a:p><a:pPr><a:defRPr sz="900">${solidFill(labelColor)}<a:latin typeface="${face}"/><a:ea typeface="${face}"/><a:cs typeface="${face}"/></a:defRPr></a:pPr><a:endParaRPr lang="en-US"/></a:p></cx:txPr>`;
+  return `<cx:txPr><a:bodyPr/><a:lstStyle/><a:p><a:pPr><a:defRPr sz="${size}">${solidFill(labelColor)}<a:latin typeface="${face}"/><a:ea typeface="${face}"/><a:cs typeface="${face}"/></a:defRPr></a:pPr><a:endParaRPr lang="en-US"/></a:p></cx:txPr>`;
 }
 
 function dataLabels(spec, text) {
@@ -159,7 +159,7 @@ function axes(spec, gridColor, text) {
  * layout is PptxGenJS's: Sheet1, headings in row 1, categories in column A and
  * one series per following column.
  */
-export function chartexPartXml({spec, series, hasCategories, number, workbookRelId, fill, labelColor, gridColor, font, palette}) {
+export function chartexPartXml({spec, series, hasCategories, number, workbookRelId, fill, labelColor, gridColor, font, palette, textSize}) {
   const rows = series[0].labels.length;
   const range = (letter) => `Sheet1!$${letter}$2:$${letter}$${rows + 1}`;
   const categories = hasCategories
@@ -169,7 +169,7 @@ export function chartexPartXml({spec, series, hasCategories, number, workbookRel
     const points = entry.values.map((value, row) => value === null || !Number.isFinite(value) ? '' : `<cx:pt idx="${row}">${numberText(value)}</cx:pt>`).join('');
     return `<cx:data id="${index}">${categories}<cx:numDim type="${spec.dimension}"><cx:f>${range(columnLetters(index + 2))}</cx:f><cx:lvl ptCount="${rows}" formatCode="General">${points}</cx:lvl></cx:numDim></cx:data>`;
   }).join('');
-  const text = textProperties(labelColor, font);
+  const text = textProperties(labelColor, font, textSize);
   const plotted = series.map((entry, index) => {
     const color = palette[index % palette.length];
     const letter = columnLetters(index + 2);
@@ -214,7 +214,7 @@ const STYLE_ENTRIES = [
   'dataPointMarkerLayout', 'dataPointWireframe', 'dataTable', 'downBar', 'dropLine', 'errorBar', 'floor', 'gridlineMajor', 'gridlineMinor', 'hiLoLine',
   'leaderLine', 'legend', 'plotArea', 'plotArea3D', 'seriesAxis', 'seriesLine', 'title', 'trendline', 'trendlineLabel', 'upBar', 'valueAxis', 'wall',
 ];
-export function chartStyleXml({labelColor = '000000', gridColor = '000000', font = 'Aptos'} = {}) {
+export function chartStyleXml({labelColor = '000000', gridColor = '000000', font = 'Aptos', textSize} = {}) {
   // Text and chrome colours are the deck's label and border colours (what the classic chart path writes), not the
   // theme's tx1: PowerPoint applies the style part to chartex labels that carry no cx:txPr of their own.
   const textColor = `<a:srgbClr val="${labelColor}"/>`;
@@ -226,9 +226,9 @@ export function chartStyleXml({labelColor = '000000', gridColor = '000000', font
     switch (name) {
       case 'dataPointMarkerLayout': return '<cs:dataPointMarkerLayout symbol="circle" size="5"/>';
       case 'axisTitle': return entry(name, {fontColor: textColor, size: '1000'});
-      case 'categoryAxis': case 'valueAxis': case 'seriesAxis': return entry(name, {fontColor: textColor, spPr: faintLine, size: '900'});
-      case 'chartArea': return entry(name, {mods: 'allowNoFillOverride allowNoLineOverride', spPr: `<a:solidFill><a:schemeClr val="bg1"/></a:solidFill>${faintLine}`, size: '1000'});
-      case 'dataLabel': case 'dataLabelCallout': case 'dataTable': case 'legend': case 'trendlineLabel': return entry(name, {fontColor: textColor, size: '900'});
+      case 'categoryAxis': case 'valueAxis': case 'seriesAxis': return entry(name, {fontColor: textColor, spPr: faintLine, size: textSize});
+      case 'chartArea': return entry(name, {mods: 'allowNoFillOverride allowNoLineOverride', spPr: `<a:solidFill><a:schemeClr val="bg1"/></a:solidFill>${faintLine}`, size: textSize});
+      case 'dataLabel': case 'dataLabelCallout': case 'dataTable': case 'legend': case 'trendlineLabel': return entry(name, {fontColor: textColor, size: textSize});
       case 'dataPoint': case 'dataPoint3D': case 'dataPointWireframe': case 'upBar': case 'floor': case 'wall':
         return entry(name, {fillIdx: '1', fillColor: '<cs:styleClr val="auto"/>', spPr: '<a:solidFill><a:schemeClr val="phClr"/></a:solidFill>'});
       case 'dataPointLine': case 'dataPointMarker': case 'trendline': case 'seriesLine': case 'hiLoLine': case 'dropLine': case 'leaderLine': case 'errorBar':
@@ -294,7 +294,7 @@ export function attachChartexParts(entries, chartex, parseRelationships) {
       const base = `ppt/charts/chartEx${number}.xml`;
       entries[base] = encoder.encode(chartexPartXml({...chart, number, workbookRelId: 'rId1'}));
       entries[`ppt/charts/_rels/chartEx${number}.xml.rels`] = encoder.encode(chartexRelationshipsXml({workbookTarget: workbook.target, number}));
-      entries[`ppt/charts/style${number}.xml`] = encoder.encode(chartStyleXml({labelColor: chart.labelColor, gridColor: chart.gridColor, font: chart.font}));
+      entries[`ppt/charts/style${number}.xml`] = encoder.encode(chartStyleXml({labelColor: chart.labelColor, gridColor: chart.gridColor, font: chart.font, textSize: chart.textSize}));
       entries[`ppt/charts/colors${number}.xml`] = encoder.encode(chartColorStyleXml());
       overrides.push(`<Override PartName="/${base}" ContentType="${CHARTEX_CONTENT_TYPES.chart}"/>`,
         `<Override PartName="/ppt/charts/style${number}.xml" ContentType="${CHARTEX_CONTENT_TYPES.style}"/>`,

package/dist/code-provenance.js

@@ -86,7 +86,7 @@ export function nativeShapeParagraphs(xml, rootElement = 'p:sld') {
       }
       if (child['a:pPr'] !== undefined) {
         level = Number(child[':@']?.lvl ?? 0);
-        bullet = child['a:pPr'].some(node=>node['a:buChar'] !== undefined || node['a:buAutoNum'] !== undefined);
+        bullet = child['a:pPr'].some(node=>node['a:buChar'] !== undefined || node['a:buBlip'] !== undefined || node['a:buAutoNum'] !== undefined);
       }
     }
     return {text,maxFontSize,bullet,level,fields};

package/dist/content-topology.js

@@ -0,0 +1,295 @@
+// Content topology (spec-gap closure P1): the structure of a slide's content
+// survives a PPTX round trip through the OPF_SLIDE_V1 record.
+//
+// PowerPoint has no native counterpart for OPF's content structure: nested
+// groups, promoted regions (`left`, `top:left` ...), a root payload (`text`,
+// `items` ...) versus `blocks`, block ids, block extensions and group
+// composition. Import rebuilds flat blocks from the native shapes in reading
+// order. The topology record stores the structure and the reference-pixel box
+// of every leaf, taken from the same `composeSlide` geometry the exporter draws
+// from. Import matches each imported block to the smallest stored leaf whose
+// box contains the block's native bounds and rebuilds the authored form. The
+// record holds ids, extensions, composition and boxes only: never text, images
+// or payload values, which the native shapes supply.
+//
+// Record (stored as `content` in OPF_SLIDE_V1, `full` mode only):
+//
+//   Topology = {form: 'root', field, box?}                 // one root payload on the slide
+//            | {form: 'root', fields: [{field, box?}]}     // root shorthand with several payloads
+//            | {form: 'blocks', blocks: Node[]}
+//            | {form: 'regions', regions: {[key]: Node}}   // key = promoted region key
+//   Node     = {t: 'group', id?, ext?, comp?, typed?, blocks: Node[]}
+//            | {t: 'leaf', k, id?, ext?, typed?, box?}      // box = [x, y, w, h] reference px, 1 decimal
+//   typed = true when the authored block spelled out its `type`
+//
+// Tags are untrusted input: every field is type-, count- and depth-checked
+// before use, and the rebuilt slide still has to validate with the document.
+
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const clone = value => value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+
+export const CONTENT_KINDS = Object.freeze(['text', 'list', 'image', 'video', 'chart', 'table', 'code', 'metric', 'quote', 'timeline']);
+export const ROOT_PAYLOAD_FIELDS = Object.freeze(['text', 'items', 'bullets', 'image', 'video', 'chart', 'table', 'code', 'metric', 'quote', 'timeline']);
+const HORIZONTAL = ['left', 'center', 'right', 'left+center', 'center+right', 'left+center+right'];
+const VERTICAL = ['top', 'middle', 'bottom', 'top+middle', 'middle+bottom', 'top+middle+bottom'];
+export const REGION_KEYS = Object.freeze([...HORIZONTAL, ...VERTICAL, ...VERTICAL.flatMap(row => HORIZONTAL.map(column => `${row}:${column}`))]);
+const REGION_KEY_PATTERN = /^[a-z]+(\+[a-z]+)*(:[a-z]+(\+[a-z]+)*)?$/;
+const REGION_KEY_SET = new Set(REGION_KEYS);
+// Groups nest at most this deep (a leaf inside three groups). Deeper structures
+// are valid OPF but are not stored; the slide then imports as flat blocks.
+export const MAX_GROUP_DEPTH = 3;
+export const MAX_NODES = 256;
+// Ids are any schema string up to this length (the empty string included); a
+// longer id leaves the slide's topology unstored, and import rejects it the same way.
+export const MAX_ID_LENGTH = 256;
+// Native bounds may sit this far outside a stored leaf box (reference px).
+export const BOX_TOLERANCE = 3;
+
+const kindOfField = field => field === 'items' || field === 'bullets' ? 'list' : field;
+const isGroup = block => object(block) && (block.type === 'group' || (block.type === undefined && Array.isArray(block.blocks)));
+const round1 = value => Math.round(value * 10) / 10;
+
+function blockKind(block) {
+  if (typeof block.type === 'string' && block.type !== 'group') return CONTENT_KINDS.includes(block.type) ? block.type : null;
+  for (const field of ROOT_PAYLOAD_FIELDS) if (block[field] !== undefined) return kindOfField(field);
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Export
+
+/**
+ * The topology of `slide`'s content with leaf boxes from `items` (the
+ * `composeSlide` geometry items of that slide). Returns undefined when the
+ * slide has no content, or when its structure cannot be represented (an
+ * unknown payload, groups nested deeper than MAX_GROUP_DEPTH, too many nodes);
+ * `report(reason)` then names why.
+ */
+export function contentTopology(slide, items, slideIndex, report = () => {}) {
+  if (!object(slide)) return undefined;
+  const boxes = new Map();
+  for (const item of items ?? []) if (typeof item?.path === 'string' && object(item.box)) boxes.set(item.path, item.box);
+  const base = `slides.${slideIndex}`;
+  let nodes = 0;
+  const fail = reason => { throw new TopologyError(reason); };
+  const leafBox = path => {
+    for (const field of ROOT_PAYLOAD_FIELDS) {
+      const box = boxes.get(`${path}.${field}`);
+      if (box) return [box.x, box.y, box.width, box.height].map(round1);
+    }
+    return undefined;
+  };
+  const identity = (block, node, path) => {
+    if (typeof block.id === 'string') {
+      if (block.id.length > MAX_ID_LENGTH) fail(`${path}.id is longer than ${MAX_ID_LENGTH} characters`);
+      node.id = block.id;
+    }
+    if (object(block.extensions)) node.ext = clone(block.extensions);
+    if (typeof block.type === 'string') node.typed = true;
+    return node;
+  };
+  const node = (block, path, depth) => {
+    if (!object(block)) fail(`${path} is not a content block`);
+    if (++nodes > MAX_NODES) fail(`the slide has more than ${MAX_NODES} content nodes`);
+    if (isGroup(block)) {
+      if (depth >= MAX_GROUP_DEPTH) fail(`groups nest deeper than ${MAX_GROUP_DEPTH} levels`);
+      const group = identity(block, {t: 'group'}, path);
+      if (object(block.composition)) group.comp = clone(block.composition);
+      group.blocks = (Array.isArray(block.blocks) ? block.blocks : []).map((child, index) => node(child, `${path}.blocks.${index}`, depth + 1));
+      return group;
+    }
+    const kind = blockKind(block);
+    if (!kind) fail(`${path} has no known content payload`);
+    const leaf = identity(block, {t: 'leaf', k: kind}, path);
+    const box = leafBox(path);
+    if (box) leaf.box = box;
+    return leaf;
+  };
+  try {
+    // Core precedence: promoted regions win over blocks, blocks over a root payload.
+    const regionKeys = Object.keys(slide).filter(key => REGION_KEY_SET.has(key) && object(slide[key]));
+    if (regionKeys.length) return {form: 'regions', regions: Object.fromEntries(regionKeys.map(key => [key, node(slide[key], `${base}.${key}`, 0)]))};
+    if (Array.isArray(slide.blocks)) {
+      if (!slide.blocks.length) return undefined;
+      return {form: 'blocks', blocks: slide.blocks.map((block, index) => node(block, `${base}.blocks.${index}`, 0))};
+    }
+    // Root shorthand: one payload is the common case; several payload fields
+    // on one slide compose as one item each (`slides.N.<field>`).
+    const fields = ROOT_PAYLOAD_FIELDS.filter(name => slide[name] !== undefined).map(field => {
+      const box = boxes.get(`${base}.${field}`);
+      return box ? {field, box: [box.x, box.y, box.width, box.height].map(round1)} : {field};
+    });
+    if (!fields.length) return undefined;
+    if (fields.length === 1) return {form: 'root', ...fields[0]};
+    return {form: 'root', fields};
+  } catch (error) {
+    if (!(error instanceof TopologyError)) throw error;
+    report(error.message);
+    return undefined;
+  }
+}
+
+class TopologyError extends Error {}
+
+// ---------------------------------------------------------------------------
+// Import: validation
+
+const validBox = value => value === undefined || (Array.isArray(value) && value.length === 4 && value.every(number => typeof number === 'number' && Number.isFinite(number) && Math.abs(number) < 1e7));
+const validId = value => value === undefined || (typeof value === 'string' && value.length <= MAX_ID_LENGTH);
+const validField = value => object(value) && ROOT_PAYLOAD_FIELDS.includes(value.field) && validBox(value.box);
+/** The root payload leaves of a root-form record: [{field, box?}]. */
+export const rootFields = topology => topology.fields ?? [{field: topology.field, box: topology.box}];
+
+/** Throws when `value` is not a well-formed topology record. Returns it otherwise. */
+export function validateTopology(value) {
+  if (!object(value)) throw Error('Invalid content topology.');
+  let nodes = 0;
+  const node = (item, depth) => {
+    if (!object(item)) throw Error('Invalid content node.');
+    if (++nodes > MAX_NODES) throw Error(`Content topology has more than ${MAX_NODES} nodes.`);
+    if (!validId(item.id)) throw Error('Invalid content node id.');
+    if (item.ext !== undefined && !object(item.ext)) throw Error('Invalid content node extensions.');
+    if (item.typed !== undefined && item.typed !== true) throw Error('Invalid content node type flag.');
+    if (item.t === 'group') {
+      if (depth >= MAX_GROUP_DEPTH) throw Error(`Content groups nest deeper than ${MAX_GROUP_DEPTH} levels.`);
+      if (item.comp !== undefined && !object(item.comp)) throw Error('Invalid group composition.');
+      if (!Array.isArray(item.blocks)) throw Error('Invalid group blocks.');
+      for (const child of item.blocks) node(child, depth + 1);
+      return;
+    }
+    if (item.t !== 'leaf') throw Error('Unknown content node type.');
+    if (!CONTENT_KINDS.includes(item.k)) throw Error('Unknown content kind.');
+    if (item.comp !== undefined) throw Error('A content leaf has no composition.');
+    if (!validBox(item.box)) throw Error('Invalid content box.');
+  };
+  switch (value.form) {
+    case 'root': {
+      if (value.fields !== undefined) {
+        if (value.field !== undefined || value.box !== undefined) throw Error('Invalid root payload record.');
+        if (!Array.isArray(value.fields) || !value.fields.length || value.fields.length > ROOT_PAYLOAD_FIELDS.length || !value.fields.every(validField)) throw Error('Invalid root payload fields.');
+        if (new Set(value.fields.map(item => item.field)).size !== value.fields.length) throw Error('Repeated root payload field.');
+        return value;
+      }
+      if (!ROOT_PAYLOAD_FIELDS.includes(value.field)) throw Error('Unknown root payload field.');
+      if (!validBox(value.box)) throw Error('Invalid content box.');
+      return value;
+    }
+    case 'blocks':
+      if (!Array.isArray(value.blocks) || !value.blocks.length) throw Error('Invalid content blocks.');
+      for (const child of value.blocks) node(child, 0);
+      return value;
+    case 'regions': {
+      if (!object(value.regions)) throw Error('Invalid content regions.');
+      const keys = Object.keys(value.regions);
+      if (!keys.length || keys.length > REGION_KEYS.length) throw Error('Invalid content regions.');
+      for (const key of keys) {
+        if (!REGION_KEY_PATTERN.test(key) || !REGION_KEY_SET.has(key)) throw Error(`Unknown region key ${key}.`);
+        node(value.regions[key], 0);
+      }
+      return value;
+    }
+    default:
+      throw Error('Unknown content form.');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Import: rebuild
+
+const compatible = (leafKind, kind) => leafKind === kind || (['text', 'list'].includes(leafKind) && ['text', 'list'].includes(kind));
+const containsOrigin = (box, bounds) => bounds.x >= box[0] - BOX_TOLERANCE && bounds.y >= box[1] - BOX_TOLERANCE
+  && bounds.x <= box[0] + box[2] + BOX_TOLERANCE && bounds.y <= box[1] + box[3] + BOX_TOLERANCE;
+const contains = (box, bounds) => containsOrigin(box, bounds)
+  && bounds.x + bounds.width <= box[0] + box[2] + BOX_TOLERANCE && bounds.y + bounds.height <= box[1] + box[3] + BOX_TOLERANCE;
+
+/**
+ * Rebuild the authored content form from the imported flat `blocks` and their
+ * native `bounds` (reference px, one entry per block, null when unknown).
+ * Returns {fields} (slide properties to set: root field, `blocks` or region
+ * keys; a `null` value removes the property) and the restored block ids, or
+ * {reason} when a block matches no leaf or several blocks land on one leaf.
+ * Leaves with no block are dropped: empty payloads export nothing.
+ */
+export function rebuildContent(topology, blocks, bounds) {
+  if (!Array.isArray(blocks) || !Array.isArray(bounds) || blocks.length !== bounds.length) return {reason: 'the imported blocks carry no native bounds'};
+  const leaves = [];
+  const collect = item => {
+    if (item.t === 'group') { for (const child of item.blocks) collect(child); return; }
+    leaves.push({node: item, kind: item.k, box: item.box, matches: []});
+  };
+  if (topology.form === 'root') for (const item of rootFields(topology)) leaves.push({node: item, field: item.field, kind: kindOfField(item.field), box: item.box, matches: []});
+  else if (topology.form === 'blocks') topology.blocks.forEach(collect);
+  else Object.values(topology.regions).forEach(collect);
+  const kindOf = block => blockKind(block) ?? 'text';
+  for (const [index, block] of blocks.entries()) {
+    const native = bounds[index];
+    if (!object(native)) return {reason: `block ${index} has no native bounds`};
+    const kind = kindOf(block);
+    const smallest = (a, b) => (a.box[2] * a.box[3]) - (b.box[2] * b.box[3]) || (a.kind === kind ? -1 : 0) - (b.kind === kind ? -1 : 0);
+    let candidates = leaves.filter(leaf => leaf.box && compatible(leaf.kind, kind) && contains(leaf.box, native)).sort(smallest);
+    // Overflowing content (overflow: 'warn') runs past its box: the lines of a
+    // long list or timeline still start inside it, so the origin decides.
+    if (!candidates.length) candidates = leaves.filter(leaf => leaf.box && compatible(leaf.kind, kind) && containsOrigin(leaf.box, native)).sort(smallest);
+    if (!candidates.length) return {reason: `block ${index} (${kind}) lies in no stored content box`};
+    candidates[0].matches.push(index);
+  }
+  for (const leaf of leaves) {
+    if (leaf.matches.length <= 1) continue;
+    // A list's native lines can arrive as several bullet blocks when another
+    // object interleaves with them in reading order; they rejoin their list.
+    if (leaf.kind === 'list' && leaf.matches.every(index => blocks[index]?.type === 'list' && Array.isArray(blocks[index].items))) {
+      const merged = {...blocks[leaf.matches[0]], items: leaf.matches.flatMap(index => blocks[index].items)};
+      leaf.matches = [leaf.matches[0]];
+      leaf.payload = merged;
+      continue;
+    }
+    return {reason: `${leaf.matches.length} blocks lie in one stored content box`};
+  }
+  const ids = [];
+  const payloadOf = leaf => {
+    if (!leaf.matches.length) return undefined;
+    const payload = clone(leaf.payload ?? blocks[leaf.matches[0]]);
+    // The imported block always names its type; the authored one may have left it implicit.
+    if (!leaf.node.typed) delete payload.type;
+    if (leaf.node.id !== undefined) { payload.id = leaf.node.id; ids.push(leaf.node.id); }
+    if (leaf.node.ext !== undefined) payload.extensions = clone(leaf.node.ext);
+    return payload;
+  };
+  const build = item => {
+    if (item.t !== 'group') {
+      const leaf = leaves.find(entry => entry.node === item);
+      return leaf ? payloadOf(leaf) : undefined;
+    }
+    const children = item.blocks.map(build).filter(Boolean);
+    if (!children.length) return undefined;
+    const group = item.typed ? {type: 'group'} : {};
+    if (item.id !== undefined) { group.id = item.id; ids.push(item.id); }
+    if (item.ext !== undefined) group.extensions = clone(item.ext);
+    if (item.comp !== undefined) group.composition = clone(item.comp);
+    group.blocks = children;
+    return group;
+  };
+  const fields = {blocks: null};
+  if (topology.form === 'root') {
+    for (const leaf of leaves) {
+      const payload = payloadOf(leaf);
+      if (payload === undefined) continue;
+      // The slide `type` is restored separately; the imported block names any
+      // list by `items`, so an authored `bullets` payload takes its key back.
+      const {type: _type, ...rest} = payload;
+      if (leaf.field === 'bullets' && rest.items !== undefined && rest.bullets === undefined) { rest.bullets = rest.items; delete rest.items; }
+      Object.assign(fields, rest);
+    }
+    return {fields, ids};
+  }
+  if (topology.form === 'blocks') {
+    const rebuilt = topology.blocks.map(build).filter(Boolean);
+    if (rebuilt.length) fields.blocks = rebuilt;
+    return {fields, ids};
+  }
+  for (const [key, item] of Object.entries(topology.regions)) {
+    const host = build(item);
+    if (host !== undefined) fields[key] = host;
+  }
+  return {fields, ids};
+}