@openpresentation/opf-pptx 0.24.0 → 0.25.0

package/README.md

@@ -74,7 +74,7 @@ const bytes = await toPptx({
 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)`. Every picture path (image blocks and region images, quote photos, slide and deck background pictures, watermarks, cover logos, header and footer images and logos, picture bullets) reports an unresolved source with exactly one `unresolved-asset` diagnostic at its OPF path and draws the preview's fallback (the placeholder, the background colour, no watermark, or the character bullets), so strict CLI export (`--fail-on warning`) gates it. A local file path that cannot be read is unresolved like any other source (`reason: 'file-unreadable'`), instead of failing the export. Set `strictAssets: true` to turn unresolved or remote image assets into structured `OPFPptxError` failures instead of editable placeholder boxes. The "Image unavailable" placeholder (a dashed panel `OPF image placeholder N` with its label lines, or a cross when no label fits) is one native group `OPF image placeholder N group` (opf-pptx#221) that carries the accessible name (`Image unavailable: <alt>`) as its alt text, so PowerPoint moves or deletes it as one object while each member stays an editable shape; a logo and a header or footer image keep their ungrouped panel (generated furniture is never grouped). In `full` provenance the panel of an image block carries an `OPF_IMAGE_PLACEHOLDER_V1` tag (the slide, the block path, the authored image value and the block's own fields), and `fromPptx` turns it back into that image block; without the tag (`references-only`, `provenance: false`) or with a damaged one (`invalid-image-provenance`) the shapes import as ordinary content.
+`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)`. Every picture path (image blocks and region images, quote photos, slide and deck background pictures, watermarks, cover logos, header and footer images and logos, picture bullets) reports an unresolved source with exactly one `unresolved-asset` diagnostic at its OPF path and draws the preview's fallback (the placeholder, the background colour, no watermark, or the character bullets), so strict CLI export (`--fail-on warning`) gates it. A local file path that cannot be read is unresolved like any other source (`reason: 'file-unreadable'`), instead of failing the export. An `imageResolver` that throws (the CLI's does for a local image it cannot read) is unresolved the same way (`reason: 'resolver-failed'`): the export continues without that image, with its fallback and one `unresolved-asset` warning that carries the resolver's message and says the image was left out (a background keeps the slide's resolved background color, with no picture and no relationship written). `strictAssets: true` turns that failure into a `missing-asset` `OPFPptxError` (`details.reason: 'resolver-failed'`), like every other unresolved source; the CLI's `--fail-on warning` gates the warning. A cancelled export (`AbortError`) and an `OPFPptxError` the resolver throws still propagate. Set `strictAssets: true` to turn unresolved or remote image assets into structured `OPFPptxError` failures instead of editable placeholder boxes. The "Image unavailable" placeholder (a dashed panel `OPF image placeholder N` with its label lines, or a cross when no label fits) is one native group `OPF image placeholder N group` (opf-pptx#221) that carries the accessible name (`Image unavailable: <alt>`) as its alt text, so PowerPoint moves or deletes it as one object while each member stays an editable shape; a logo and a header or footer image keep their ungrouped panel (generated furniture is never grouped). In `full` provenance the panel of an image block carries an `OPF_IMAGE_PLACEHOLDER_V1` tag (the slide, the block path, the authored image value and the block's own fields), and `fromPptx` turns it back into that image block; without the tag (`references-only`, `provenance: false`) or with a damaged one (`invalid-image-provenance`) the shapes import as ordinary content.
 
 Embedded picture bytes are a PNG, JPEG, GIF, WebP or SVG. Bytes that are no readable image (or an SVG that cannot be exported: malformed XML, no `xmlns`, no width and height and no viewBox, or no rasterizer, see below) export what the preview shows, like an unresolved asset: the "Image unavailable" placeholder (nothing for a watermark, the background colour for a background image) and one `unresolved-asset` diagnostic with a `reason` (`unsupported-format`, `svg-malformed`, `svg-no-size`, `svg-too-large`, `svg-unsafe`, `svg-unreadable`, `svg-rasterizer-unavailable`, `svg-render-failed`); `strictAssets` throws `unsupported-image-dimensions` for an unreadable raster, `invalid-svg-image` for an unusable SVG, `svg-rasterizer-unavailable` or `svg-render-failed`.
 
@@ -322,7 +322,7 @@ LibreOffice is not a runtime dependency. When it is installed in CI or a local v
 Public npm package publication is handled by `.github/workflows/release.yml` through npm Trusted Publishing (GitHub Actions OIDC) with npm provenance; no npm token is stored. The owner authorized agents to prepare and publish npm releases whenever a release is required (2026-09-29). This authorization does not waive any gate.
 
 1. Open a release-prep PR containing only the version bump, `CHANGELOG.md` (assembled from `changes/` with `node scripts/changelog-fragments.mjs assemble --version X.Y.Z`), dependency ranges, lockfile and current-instruction docs. Publish in dependency order (core, then renderer, then PPTX, then editor): refresh this repo's lockfile only after the required `@openpresentation/opf` and `@openpresentation/opf-render` versions are on the registry (`npm install --package-lock-only`), then run `npm run test:packed` against them.
-2. Merge after CI is green, then publish by pushing the git tag `opf-pptx-v<version>` (or `@openpresentation/opf-pptx@v<version>`) at the merge commit. The workflow verifies that the tag matches `package.json` and reruns audit, typecheck, validate, tests, packed and browser checks before `npm publish --access public --provenance`. A manual `workflow_dispatch` runs the same job without the tag check and is a fallback only.
+2. Merge after CI is green, then publish by pushing the git tag `opf-pptx-v<version>` (or `@openpresentation/opf-pptx@v<version>`) at the merge commit. The workflow verifies that the tag matches `package.json`, that the push-to-`main` run of `ci.yml` on exactly the tagged commit succeeded (`scripts/ci-evidence.mjs`; it fails closed and re-runs no test, RR-100), and the artifact itself (audit, the packed install, `npm pack --dry-run`) before `npm publish --access public --provenance`. A tag pushed while CI still runs fails at the evidence step; re-run the failed job once CI is green. A manual `workflow_dispatch` runs the same job without the tag check and is a fallback only.
 3. Verify with `npm view @openpresentation/opf-pptx@<version> version gitHead dist.attestations` and, from the core repo, `node scripts/test-pptx-publication.mjs <version> <release-commit> <this-checkout>`. Never republish an existing version.
 
 ## Shared dynamic composition
@@ -414,7 +414,7 @@ Pattern backgrounds export as a native `<a:pattFill>` with explicit foreground a
 
 `code.language` and `metric.trend` export natively from the same core tables the preview reads (RR-07). Code keeps one text box per source line; a language adds coloured runs (theme-derived colours kept at 4.5:1 or more on the #111827 panel) whose text concatenates to the exact line, and an unknown language is exported plain. A trend adds one arrow shape (`upArrow`, `downArrow` or `rightArrow`, alt text "Trend: up") beside the trend word and colours the delta and trend text green, red or neutral; the arrow is part of the metric's provenance group, so the metric re-imports as the one authored payload. `scripts/rr07-native-set.mjs <dir>` builds the native-check decks, preview PNGs and a manifest.
 
-An image background (`{type: "image", src, alt, fit, focus, opacity, recolor, overlay}`, or an image source string, a cover image; core composes it as `backgroundImage` from the slide, deck or theme background) never moves content. Without alt text it exports as the native slide background, an `<a:blipFill>` for the embedded raster (`data:` sources, declared `asset:` ids and `imageResolver` results): `cover` (the default) crops the picture to the slide with `a:srcRect` around the `focus` point (core's `fitImage`), `contain` centers the whole picture with `a:fillRect` insets, `stretch` fills the slide, and `tile` repeats the picture at its intrinsic size (1 picture pixel = 1 reference pixel, 1/96 in) from the top-left corner. With `dpi="0"`, a native tile is sized from the raster's own resolution: PNG `pHYs` in metres; JPEG JFIF density in inches or centimetres, otherwise EXIF `XResolution`/`YResolution`; 96 dpi when absent. The tile scale is that resolution over 96 on each axis. `recolor` becomes `a:grayscl` or `a:duotone` and opacity `a:alphaModFix` on the blip, as for image blocks. With alt text (the background's own only: a referenced asset's alt does not make a background meaningful) the picture is a full-slide `p:pic` at the back of the slide, named `OPF background slides.N`, carrying the text as its `descr` so screen readers read it; the slide background is then the colour scheme's default background colour, which shows around a contained picture and through a translucent one. The overlay is one shape directly above the picture (`OPF background overlay slides.N` for a native fill, `OPF background slides.N overlay` for the picture): the whole slide, or a band along one edge. WebP sources become PNG parts as for pictures. An unresolved image keeps the background color and reports `unresolved-asset` at the background's path (`strictAssets` throws). A JPEG EXIF orientation cannot rotate a background fill, so it reports `unsupported-background-image-orientation`.
+An image background (`{type: "image", src, alt, fit, focus, opacity, recolor, overlay}`, or an image source string, a cover image; core composes it as `backgroundImage` from the slide, deck or theme background) never moves content. Without alt text it exports as the native slide background, an `<a:blipFill>` for the embedded raster (`data:` sources, declared `asset:` ids and `imageResolver` results): `cover` (the default) crops the picture to the slide with `a:srcRect` around the `focus` point (core's `fitImage`), `contain` centers the whole picture with `a:fillRect` insets, `stretch` fills the slide, and `tile` repeats the picture at its intrinsic size (1 picture pixel = 1 reference pixel, 1/96 in) from the top-left corner. With `dpi="0"`, a native tile is sized from the raster's own resolution: PNG `pHYs` in metres; JPEG JFIF density in inches or centimetres, otherwise EXIF `XResolution`/`YResolution`; 96 dpi when absent. The tile scale is that resolution over 96 on each axis. `recolor` becomes `a:grayscl` or `a:duotone` and opacity `a:alphaModFix` on the blip, as for image blocks. With alt text (the background's own only: a referenced asset's alt does not make a background meaningful) the picture is a full-slide `p:pic` at the back of the slide, named `OPF background slides.N`, carrying the text as its `descr` so screen readers read it; the slide background is then the colour scheme's default background colour, which shows around a contained picture and through a translucent one. The overlay is one shape directly above the picture (`OPF background overlay slides.N` for a native fill, `OPF background slides.N overlay` for the picture): the whole slide, or a band along one edge. WebP sources become PNG parts as for pictures. An unresolved image (no source, an unreadable file, or an `imageResolver` that threw) keeps the background the slide would have without the picture and reports `unresolved-asset` at the background's path (`strictAssets` throws): the deck's own background when the slide's was the picture, otherwise the slide's `bg1` through its variant (a dark variant stays dark), written as the native fill such a slide has; text colors are unchanged, and a picture that comes from a theme's own background keeps the canvas color. A JPEG EXIF orientation cannot rotate a background fill, so it reports `unsupported-background-image-orientation`.
 
 Import reads `a:pattFill` with a DrawingML preset and resolvable foreground/background colors, including slide/layout/master inheritance and theme references, as an OPF pattern background. Import does not guess undefined default colors. Import also reads embedded `a:blipFill` pictures as an image background with the exact image bytes as a `data:` URI. Tiles become `tile`. If the tile scale, offset, alignment, flip or source insets differ from the geometry OPF `tile` exports (the picture at its intrinsic size), the import reports `approximate-background-image`. A crop matching the slide aspect becomes `cover`, with the `focus` the crop centers (a crop pinned to an edge reads as the edge-most focus with that crop); centered fill insets matching the image aspect become `contain`; an uncropped fill of another aspect becomes `stretch`. Padded, offset or effect-bearing fills become the closest fit and report `approximate-background-image`. `a:grayscl` and an `a:duotone` of two literal colours become `recolor`. An unchanged tagged background picture (`OPF_IMAGE_V1`) becomes the image background with its alt text, fit, focus, opacity and recolor, and an unchanged tagged overlay (`OPF_IMAGE_OVERLAY_V1`) its overlay. Linked or unreadable pictures report `unsupported-background-image`. `test/background-fills.mjs` and `test/background-images.mjs` cover export, import, native edits, inheritance and diagnostics. Microsoft PowerPoint rendering of these fills has not been verified natively: the resolution-based tile scale, a tiled `p:pic` fill, what PowerPoint shows around a contained or through a translucent native background fill (it has nothing behind the slide background), and negative `a:srcRect` insets.
 

package/dist/index.d.ts

@@ -53,11 +53,12 @@ export interface ContentPlaceholderDiagnostic { code: "content-placeholder"; pat
  * `"svg-unsafe"` (a DOCTYPE with external or markup entities), `"svg-rasterizer-unavailable"` (no `options.svgRasterizer` and `@openpresentation/opf-render`
  * is not installed; always the case in a browser build without `svgRasterizer`) `"svg-render-failed"` (the rasterizer threw or returned no PNG) or `"svg-unreadable"` (a local `.svg` path that could not be read).
  * `reason: "file-unreadable"`: a local raster path that is not a readable file (Node; a browser build leaves local paths to the engine).
- * `strictAssets` throws `unsupported-image-dimensions` for an unreadable raster, `invalid-svg-image` for the SVG content reasons above (and `svg-unreadable`), `svg-rasterizer-unavailable` for a
+ * `reason: "resolver-failed"`: `options.imageResolver` threw for the source (the CLI's does for a local image it cannot read: a missing file, a path outside the asset directory, a file that is no image). The export continues without the image, and `message` is the resolver's own message followed by a note that the image was left out; the fallback is the one of the picture's use (a background keeps the slide's resolved background color).
+ * `strictAssets` throws `missing-asset` (`details.reason: "resolver-failed"`) for such a resolver failure, `unsupported-image-dimensions` for an unreadable raster, `invalid-svg-image` for the SVG content reasons above (and `svg-unreadable`), `svg-rasterizer-unavailable` for a
  * missing rasterizer, `svg-render-failed` for a failed one and `missing-asset` for an unreadable local file instead.
  * Every picture path reports this (image blocks and region images, quote photos, background pictures, watermarks, logos, header/footer images, picture bullets), once per picture.
  */
-export interface UnresolvedAssetDiagnostic { code: "unresolved-asset"; path: string; message: string; reason?: "unresolved-source" | "unsupported-format" | "svg-malformed" | "svg-no-size" | "svg-too-large" | "svg-unsafe" | "svg-rasterizer-unavailable" | "svg-render-failed" | "svg-unreadable" | "file-unreadable" }
+export interface UnresolvedAssetDiagnostic { code: "unresolved-asset"; path: string; message: string; reason?: "unresolved-source" | "unsupported-format" | "svg-malformed" | "svg-no-size" | "svg-too-large" | "svg-unsafe" | "svg-rasterizer-unavailable" | "svg-render-failed" | "svg-unreadable" | "file-unreadable" | "resolver-failed" }
 /** An SVG picture had scripts, `foreignObject`, event handlers, references outside the file, `@import` rules or a DOCTYPE; they were removed from the embedded SVG (on import too). Nothing in an SVG is run or fetched. */
 export interface SvgSanitizedDiagnostic { code: "svg-sanitized"; path: string; message: string }
 /** An SVG image block with a duotone recolor or a non-rectangular shape (or an SVG image background with the tile fit) exports as its PNG raster, not as a native SVG picture, so the effect applies as in the preview (PowerPoint applies opacity, grayscale and a border to an SVG picture, and those stay native). */

package/dist/index.js

@@ -2403,6 +2403,9 @@ function placedImageBands(slide) {
 
 // One slide's export context: core's resolveSlideContext (`core`: composeSlide's options, the records and the diagnostics) and
 // the exporter's colours and measurement-resolved families derived from it.
+// RR-97: the deck's own background stays literal on a slide whose picture background is unreadable and falls back to it (useFallbackBackground).
+const geometryFallbackBackground = presentation => presentation.design?.background;
+
 function exportSlideContext(presentation, slideIndex, baseContext, options) {
   const slide = presentation.slides[slideIndex];
   const effective = { ...presentation, design: { ...presentation.design, ...slide.design } };
@@ -2433,7 +2436,7 @@ function exportSlideContext(presentation, slideIndex, baseContext, options) {
   const text = defaultTextSchemeValues(slideContext);
   slideContext.textColor = text.text ?? resolved.colors.text;
   slideContext.mutedColor = text.muted ?? resolved.colors.mutedText;
-  baseContext.slideSchemeColors[slideIndex] = {table: schemeColorTable(slideContext), keep: authoredLiteralColors(slide, presentation.variables, {...effective.design, colorScheme: undefined, theme: undefined})};
+  baseContext.slideSchemeColors[slideIndex] = {table: schemeColorTable(slideContext), keep: authoredLiteralColors(slide, presentation.variables, {...effective.design, colorScheme: undefined, theme: undefined}, geometryFallbackBackground(presentation))};
   return slideContext;
 }
 
@@ -2733,7 +2736,7 @@ async function addBackgroundImage(slide, presentation, background, slideIndex, s
       treatment, alt, role: 'background', objectName: backgroundImageName(slidePath)
     });
     // addImagePicture reported the unresolved source once (opf-pptx#210).
-    if (!name) return;
+    if (!name) { useFallbackBackground(slide, presentation, background, slideIndex, slideContext, context, options); return; }
     owner = name;
     overlayName = imageOverlayName(name);
   } else {
@@ -2742,6 +2745,7 @@ async function addBackgroundImage(slide, presentation, background, slideIndex, s
     const resolved = await resolveImage(background.src, presentation, options, background.path, outcome);
     if (!resolved) {
       if (!outcome.reported) options.onDiagnostic?.(backgroundUnresolved(background.path));
+      useFallbackBackground(slide, presentation, background, slideIndex, slideContext, context, options);
       return;
     }
     // PptxGenJS embeds the raster and its relationship; packaging replaces its stretched fill with the fitted native fill.
@@ -2760,6 +2764,29 @@ async function addBackgroundImage(slide, presentation, background, slideIndex, s
   if (background.overlay) addImageOverlay(slide, background.overlay, structuredClone(isPlainObject(authored) ? authored.overlay : undefined) ?? {color: background.overlay.color, opacity: background.overlay.opacity}, overlayName, owner, { ...slideContext, slidePath }, effects);
 }
 
+// RR-97: a background picture that cannot be read leaves the background the slide would have without it: the deck's own
+// background (or the theme's) when the slide's was the picture, and the variant's bg1 when the picture is the only background,
+// written as the same native fill (a scheme color through the slide's map, a solid color, a gradient or a pattern) a slide with
+// that background has. It is not the literal canvas color core falls back to for a picture, which is the light default and so
+// white behind the light text of a dark variant. A picture that comes from the theme's own background keeps that canvas color.
+// Only the fill is replaced: the text color was chosen for the picture and is unchanged.
+function useFallbackBackground(slide, presentation, background, slideIndex, slideContext, context, options) {
+  const without = design => Object.fromEntries(Object.entries(design ?? {}).filter(([key]) => key !== 'background'));
+  let twin;
+  if (/^slides\.\d+\.design\.background(\.|$)/.test(background.path ?? '')) twin = {...presentation, slides: presentation.slides.map((entry, index) => index === slideIndex ? {...entry, design: without(entry.design)} : entry)};
+  else if (/^design\.background(\.|$)/.test(background.path ?? '')) twin = {...presentation, design: without(presentation.design)};
+  if (!twin) return;
+  const effective = {...twin, design: {...twin.design, ...twin.slides[slideIndex].design}};
+  const resolved = resolvePresentationContext(effective, options, coreContext(twin, slideIndex, options));
+  const fallback = {...slideContext, backgroundDefinition: resolved.backgroundDefinition, colors: resolved.colors, roles: resolved.roles, colorScheme: resolved.colorScheme, variables: resolved.variables};
+  slide.background = {color: resolved.colors.background};
+  const definition = resolved.backgroundDefinition;
+  const fill = definition === undefined ? null : schemeBackgroundFill(definition, fallback) ?? nativeBackgroundFill(definition, {
+    width: slideContext.dimensions.widthInches, height: slideContext.dimensions.heightInches
+  }, resolved.colors.background, resolved.colors.text, (reference, hex) => schemeColorValue(reference, hex, fallback), reference => resolveBackgroundColorRef(reference, resolved.colorScheme, resolved.variables));
+  if (fill) context.backgroundFills.set(`ppt/slides/slide${slideIndex + 1}.xml`, fill);
+}
+
 const backgroundUnresolved = path => ({code: 'unresolved-asset', path, reason: 'unresolved-source', message: 'The background image needs an embedded raster, a declared asset or a host imageResolver; the slide background color was exported instead.'});
 
 // design.watermark: one native picture per slide, added after the slide image
@@ -4015,7 +4042,7 @@ function histogramBins(values) {
 // was already emitted. `outcome.box` (inches, in) sizes an SVG's fallback raster; `outcome.svg` (out) carries the SVG to
 // attach to the picture the caller adds. Local paths are read by PptxGenJS and checked after embedding.
 async function resolveImage(asset, presentation, options, path, outcome = {}) {
-  const resolved = await resolveImageSource(asset, presentation, options, path);
+  const resolved = await resolveImageSource(asset, presentation, options, path, outcome);
   // A local SVG file is read here (PptxGenJS cannot size it); a raster path is read by PptxGenJS itself.
   if (resolved?.path && /\.svg$/i.test(resolved.path)) {
     let file;
@@ -4107,7 +4134,7 @@ function dataUriBytes(uri) {
   }
 }
 
-async function resolveImageSource(asset, presentation, options, path) {
+async function resolveImageSource(asset, presentation, options, path, outcome = {}) {
   const assetObject = dereferenceAsset(asset, presentation, path);
   const src = typeof assetObject === "string" ? assetObject : assetObject?.src;
   if (!src) {
@@ -4117,9 +4144,21 @@ async function resolveImageSource(asset, presentation, options, path) {
     return null;
   }
 
-  const resolvedByHost = options.imageResolver
-    ? await options.imageResolver(src, { asset: assetObject, presentation, path })
-    : null;
+  let resolvedByHost = null;
+  if (options.imageResolver) {
+    try { resolvedByHost = await options.imageResolver(src, { asset: assetObject, presentation, path }); }
+    catch (error) {
+      // RR-97: a resolver that throws (the CLI's does for an image it cannot read) is an unresolved image, not a failed export: the
+      // picture's own fallback and one `unresolved-asset` warning that carries the resolver's message. A cancelled export and an
+      // exporter error still propagate, and `strictAssets` turns the failure into a `missing-asset` error.
+      if (error instanceof OPFPptxError || error?.name === "AbortError") throw error;
+      const cause = errorMessage(error).trim();
+      if (options.strictAssets) throw new OPFPptxError("missing-asset", cause || "The imageResolver could not read the image.", { path, src, reason: "resolver-failed" });
+      options.onDiagnostic?.({ code: "unresolved-asset", path, reason: "resolver-failed", message: `${cause ? `${/[.!?]$/.test(cause) ? cause : `${cause}.`} ` : "The imageResolver could not read the image. "}The image was left out of the export; the preview's fallback is exported instead (the unavailable-image placeholder, the slide background color, the character bullets, or no watermark).` });
+      outcome.reported = true;
+      return null;
+    }
+  }
   if (resolvedByHost) return normalizeResolvedImage(resolvedByHost, assetObject);
 
   if (src.startsWith("data:")) return { data: src };

package/dist/template-layouts.js

@@ -25,7 +25,7 @@
 // `layout-changed`). A block read from a placeholder of a region gets a `region` pin when plain binding would put it
 // elsewhere; content that document provenance restored is never pinned.
 
-import {composeLayoutAreas, composeSlide, layoutTemplate, bindRegions, regionAccepts} from '@openpresentation/opf/composition';
+import {composeLayoutAreas, composeSlide, isLayoutTemplate, layoutTemplate, bindRegions, regionAccepts} from '@openpresentation/opf/composition';
 import {validateCatalogRecord, catalogRecords, resolveReference} from '@openpresentation/opf';
 import {gallery} from '@openpresentation/gallery';
 import {decodeTextTag, encodeTextTag} from './code-provenance.js';
@@ -38,7 +38,7 @@ const LAYOUT_TYPE = 'application/vnd.openxmlformats-officedocument.presentationm
 const TAGS_TYPE = 'application/vnd.openxmlformats-officedocument.presentationml.tags+xml';
 const EMU = 9525;
 // Region placeholder indexes (coordinator decisions on RR-81): a base per placeholder kind plus the region's position among the
-// layout's regions of that kind, in the record's `regions` order: `obj` 100, `body` 300, `pic` 500, `chart` 700, `tbl` 900,
+// layout's regions of that kind, in the record's `regions` order (core's reading order of the region list): `obj` 100, `body` 300, `pic` 500, `chart` 700, `tbl` 900,
 // `media` 1100 (so the first chart region of every layout is 700, its second 701). PowerPoint's Change Layout pairs a slide's
 // placeholders with the new layout's by `idx`, so only regions of one kind pair (Pillars to Text keeps `obj` with `obj`; a chart
 // bound to Chart beside's `chart` region never lands in Table beside's `tbl` region, as it did with one sequence for every kind).
@@ -85,7 +85,7 @@ export const bindsObject = (type, object) => (BINDS[type] ?? []).includes(object
 export function regionIndexes(record, nativeBodyRegion) {
   const regions = new Map(layoutTemplate(record).regions.map(region => [region.name, region]));
   const counts = {};
-  const indexes = Object.fromEntries(Object.keys(record?.regions ?? {}).filter(name => regions.has(name)).map(name => {
+  const indexes = Object.fromEntries([...regions.keys()].map(name => {
     const type = placeholderType(regions.get(name));
     counts[type] = (counts[type] ?? -1) + 1;
     return [name, REGION_IDX_BASE[type] + counts[type]];
@@ -119,7 +119,7 @@ export function recordHash(record) {
  */
 export function slideTemplate(core) {
   const record = core?.resolved?.layout, provenance = core?.resolved?.provenance?.layout;
-  if (!record || !provenance || !Object.hasOwn(record, 'areas')) return undefined;
+  if (!record || !provenance || !isLayoutTemplate(record)) return undefined;
   try { layoutTemplate(record); } catch { return undefined; }
   return {record, id: provenance.id, group: provenance.group, ...(provenance.source !== undefined ? {source: provenance.source} : {}), reference: provenance.reference, origin: provenance.origin,
     key: templateKey(provenance)};
@@ -127,7 +127,7 @@ export function slideTemplate(core) {
 
 const templateKey = ({group, id, source}) => `${group}\u0000${id}\u0000${source ?? ''}`;
 function isTemplate(record) {
-  if (record === null || typeof record !== 'object' || !Object.hasOwn(record, 'areas')) return false;
+  if (record === null || typeof record !== 'object' || !isLayoutTemplate(record)) return false;
   try { layoutTemplate(record); return true; } catch { return false; }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -65,8 +65,8 @@
   },
   "dependencies": {
     "@node-projects/jszip": "4.3.0",
-    "@openpresentation/gallery": "^4.0.0",
-    "@openpresentation/opf": "^0.24.0",
+    "@openpresentation/gallery": "^5.0.0",
+    "@openpresentation/opf": "^0.25.0",
     "@rgrove/parse-xml": "4.2.3",
     "fast-xml-parser": "^5.8.0",
     "fflate": "^0.8.3",
@@ -74,7 +74,7 @@
     "sharp": "0.35.5"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.24.1"
+    "@openpresentation/opf-render": "^0.25.0"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -98,7 +98,7 @@
     "@expo-google-fonts/roboto": "0.4.3",
     "@expo-google-fonts/roboto-mono": "0.4.2",
     "@expo-google-fonts/tinos": "0.4.2",
-    "@openpresentation/opf-render": "0.24.1",
+    "@openpresentation/opf-render": "0.25.0",
     "@resvg/resvg-js": "2.6.2",
     "esbuild": "0.28.2",
     "playwright": "1.64.0"