@openpresentation/opf-pptx 0.18.2 → 0.19.0

package/DEPENDENCY-NOTES.md

@@ -31,3 +31,5 @@ After `npm ci`, run `npm test` and `npm run test:packed`. The packed check insta
 Run `npm run test:browser` for real browser WebP pixel preservation and rich, conditional and merged/styled table import/preview/export/reimport checks. Local Windows runs use installed Microsoft Edge; other environments first run `npx playwright install --with-deps chromium`. CI and release jobs run the Chromium checks on their built candidate. These assertions cover the named fixtures, not arbitrary Office files.
 
 For a comparison against the preceding release, create a separate empty directory, run `npm init -y` there, then `npm install --ignore-scripts --no-audit --no-fund @openpresentation/opf-pptx@0.5.0`. From this repository run `npm run test:compare-published -- <absolute-consumer-directory> <report.json>`. The script verifies the reference version and registry lockfile integrity, then compares every installed core example's PPTX bytes. The older reference deliberately contains the dependency being removed; it is only a comparison input. Explicit replacement images and fallback fonts make the comparison reproducible. Matching bytes do not establish original-asset fidelity or native viewer equivalence.
+
+RR-81 final 0.19 acceptance uses local core candidate e21c472d88057d9d90cfa507fe91b89063f3f29a and gallery 2 candidate e0a7eee2dfe996e680b34a907cabfe41905e6d99, with renderer 9fbddcb78dbebcb87355922ca92af7d26c24c48d. The gallery is imported directly by the converter. Its final direct dependency declaration and registry lock reconciliation are release gates pending the actual gallery 2 registry release; local linking is not evidence of a published dependency graph. An attempted lock-only install was rejected by automatic approval review because gallery 2 registry reconciliation was explicitly deferred; no interim gallery 1 lock entry was adopted. Packed browser/package-consumer checks against released dependencies remain gated by the existing requiresUnreleasedCore 0.19 contract.

package/README.md

@@ -1,6 +1,6 @@
 # OPF PPTX
 
-Catalogs (FA-23, OPF 0.15, unreleased; requires core 0.15): the package ships and reads no catalog data of its own. `toPptx(presentation, { catalogs })` and `fromPptx(bytes, { catalogs })` take core's registered catalogs (`Catalog[]`: `{ source, layouts?, themes?, colorSchemes?, fontSchemes?, ... }`, records keyed by id, never fetched), the same option opf-render and core's `resolveSlideContext` take. Every reference (slide `layout`, `design.theme`, `colorScheme`, `fontScheme`, a language object's font schemes) resolves through core: the document's embedded `catalogs.<group>` records first, then the registered catalog whose `source` the group names; the first registered catalog is the host default for bare ids, and `"default": false` closes that fallback. Register the gallery snapshot explicitly: `import { defaultCatalog } from "@openpresentation/opf/catalog"; toPptx(deck, { catalogs: [defaultCatalog] })`. A reference that resolves nowhere is reported once per path as core's `unresolved-reference` (kind, reference, path, group, source, fallback); the slide composes automatically and the theme and schemes draw with core's engine defaults (`ENGINE_DEFAULT_THEME`, `ENGINE_DEFAULT_COLOR_SCHEME`, `ENGINE_DEFAULT_FONT_SCHEME`; the theme part's colour scheme is then named `OpenPresentation`). `strictReferences: true` (default: the value of `strictAssets`) makes such a reference fail the export with `OPFPptxError` code `unresolved-reference`, its `path` and core's `diagnostics`. Removed with no alias: the per-source host record option, the `{kind: records[]}` form of `catalogs` (now refused with core's `OPFCatalogsOptionError`, code `invalid-catalogs`), catalog language ids, and catalog social-platform records (core formats socials from its `SOCIAL_PLATFORMS` vocabulary).
+Catalogs (OPF 0.19): export resolves the document's embedded records and host-registered catalogs (`Catalog[]`, never fetched). Register gallery 2 explicitly for export: `import { gallery } from "@openpresentation/gallery"; toPptx(deck, { catalogs: [gallery] })`. Bare ids resolve in the document's custom/default records, then the registered default catalog; `catalogs.default:false` closes that fallback. When import `catalogs` is omitted, foreign PowerPoint layout type/name mapping uses the default catalog from installed `@openpresentation/gallery`; theme and colour-scheme recovery still requires explicitly registered catalogs; `fromPptx(bytes, { catalogs: [] })` explicitly opts out. An unresolved reference emits core's `unresolved-reference` diagnostic and uses engine defaults; `strictReferences:true` refuses the export with `OPFPptxError`. Native layout tags preserve valid catalog sources and opt-outs, and damaged identity/source metadata emits diagnostics instead of creating invalid catalog groups.
 
 API names (RR-55, unreleased; requires core 0.14, and opf-render 0.14 for the optional peer): `toPptx(presentation, { fonts })` takes the fonts handle that opf-render's `loadFonts()` returns (`@openpresentation/opf-render/fonts-node`; core's `Fonts`, an object with at least `textMeasurement`) and no longer reads a top-level `textMeasurement`. `fromPptx(bytes, { signals: true })` resolves to `{ presentation, signals }` (it was `{ document, signals }`). `OPFPptxError` carries `findings` (the `error` findings of core's `format` check, or the variable errors) and `diagnostics` (the layout diagnostics of a `layout-overflow`), not `issues`. `inventoryPptxTypefaces` and `checkPptxTypefaces` are `inventoryTypefaces` and `checkTypefaces`, and `checkTypefaces` takes `{ families }` where it took `{ fonts }`. Each slide is composed with the options of core's `resolveSlideContext`, so the deck's resolved font families (slide design, deck design, theme, then the engine default) are the ones the layout is measured in; a reference that matches no record was reported per kind and never refused the export (0.15 replaces this with one `unresolved-reference` diagnostic and core's engine defaults; see Catalogs above): the default `minimal` theme and `cool-horizon` colour scheme were used, and a slide with no layout, or an unknown one, is composed with no layout record (automatic composition, as in the preview; it used to compose against the `blank` layout, so a layout-less cover is now centred vertically). The package no longer falls back when core lacks a function: it requires core 0.14.
 
@@ -426,7 +426,7 @@ These stay `a:srgbClr`:
 - translucent colors;
 - other engine-derived chrome: card fills and borders, chart panels, series and labels, timeline connectors and markers, and image and media placeholders, plus default text on a card or a literal background. These colors are contrast-selected or derived from roles, not named by the document, and are not yet theme references.
 
-Import reads the first slide master's theme and matches it against the host default catalog only (the first of `fromPptx`'s `catalogs`; nothing is bundled): the bare ids it imports resolve in a document that declares no catalogs. An exact twelve-slot match with one of its colour schemes returns that id; the `clrScheme` name breaks ties. Otherwise the importer returns inline slots, relative to the scheme the `clrScheme` is named after when there is one (`{id:'boost', accent1:'#123456'}`). A theme whose name equals one of its themes' names maps to `design.theme` only if the package's color scheme or heading/body fonts match that theme (its references resolved in its own group first); otherwise `theme-unverified` is reported. With no catalog registered, or a match only in another registered catalog, the colour scheme imports inline and no theme id is recovered; an FF-32 stored reference still restores. A missing theme, or slots that are not opaque sRGB/system colors, report `unsupported-theme-colors` on `design.colorScheme`. Slide colors are still imported as resolved hex. Role overrides such as `primary` have no theme slot and are not recovered. `test/theme-colors.mjs` covers all 14 gallery schemes and 4 gallery themes (registered as `defaultCatalog`), import without catalogs, override, foreign and damaged themes, and the literal-color boundaries. `test/table-theme-colors.mjs` covers named and default table chrome on all 14 schemes and four backgrounds, literals, override slides, the link colors, re-import and a theme switch in the package. This establishes package structure and round-trip, not PowerPoint rendering.
+Import reads the first slide master's theme and matches it against the host default catalog only (the first of `fromPptx`'s `catalogs`): recovered bare ids resolve in a document that declares no catalogs. Theme and colour-scheme recovery does not use the foreign-layout default: omitted catalogs and explicit `catalogs: []` both leave recovery unregistered. An exact twelve-slot match with one of its colour schemes returns that id; the `clrScheme` name breaks ties. Otherwise the importer returns inline slots, relative to the scheme the `clrScheme` is named after when there is one (`{id:'boost', accent1:'#123456'}`). A theme whose name equals one of its themes' names maps to `design.theme` only if the package's color scheme or heading/body fonts match that theme (its references resolved in its own group first); otherwise `theme-unverified` is reported. With omitted catalogs or explicit `catalogs: []`, or a match only in another registered catalog, the colour scheme imports inline and no theme id is recovered; an FF-32 stored reference still restores. A missing theme, or slots that are not opaque sRGB/system colors, report `unsupported-theme-colors` on `design.colorScheme`. Slide colors are still imported as resolved hex. Role overrides such as `primary` have no theme slot and are not recovered. `test/theme-colors.mjs` covers all 14 gallery schemes and 4 gallery themes (registered as `defaultCatalog`), import without catalogs, override, foreign and damaged themes, and the literal-color boundaries. `test/table-theme-colors.mjs` covers named and default table chrome on all 14 schemes and four backgrounds, literals, override slides, the link colors, re-import and a theme switch in the package. This establishes package structure and round-trip, not PowerPoint rendering.
 
 ## JPEG orientation on import
 
@@ -487,3 +487,5 @@ Missing, duplicated or inconsistent furniture tags fall back to current native c
 Native header and footer placeholders (RR-11): the first footer text becomes a `ftr` placeholder, the first footer date a `dt` placeholder (a live `datetime1`-`datetime7` field for `date: true`) and the first footer slide number an `sldNum` placeholder, each at core's exact box with its furniture tag; the slide master and layout carry the three placeholders and `p:hf` flags, and the notes master records that notes pages carry a page number only. A zone `text` with a `{{slide.number}}` is the `sldNum` placeholder (its other words are fixed runs); any other zone `text` is the `ftr` placeholder. Header parts, socials, images and logos, second text/date/number parts and multi-line text stay tagged shapes (PowerPoint has no object for them). A footer text that shares its zone with a logo is only as wide as its words (core's row layout), so its slide placeholder has that box while the master and layout placeholder spans the zone. `fromPptx` reads the placeholders back with or without provenance, and a deck changed through PowerPoint's Insert > Header & Footer dialog imports the change. Every deck, with or without a footer, carries the three master and layout placeholders (flags off when unused), so Insert > Header & Footer works on a deck with no footer. The mapping table, the dialog-edit table and the vetoable decisions are in [docs/native-header-footer.md](docs/native-header-footer.md).
 
 Master furniture (RR-72): a part with no placeholder (a logo or other zone image, socials, header text, a second footer text) that is drawn the same on two or more slides is written once. It goes on the slide master when every slide that shows such furniture draws it, else on a layout shared by the slides that do (one layout per distinct set, so a logo's `onLight` and `onDark` assets get a layout per background tone); a slide that hides it (`design.footer: false`) uses a layout with `showMasterSp="0"`. A part on one slide only, a part with a live field and a part that slide content covers stay on the slide (the last with `furniture-on-slide`, because PowerPoint draws master shapes beneath slide content). The lifted shapes keep their furniture tags (with the slot in place of the slide part), and each slide manifest lists them under `shared`, so `fromPptx` reads them from the layout or master: a master logo returns as its `var:organization.logo.*` reference on every slide. Importers before 0.18 ignore `shared`; shapes on a master or layout without OPF tags (a third-party template) are not imported. See [Master furniture](docs/native-header-footer.md#master-furniture-rr-72).
+
+Multi-series Pareto exports in `chartex: "auto"` as an editable clustered column chart containing every authored series, with a `chart-data-adapted` / `chartex-fallback` diagnostic. This preserves data rather than claiming native multi-series Pareto support. Explicit `chartex: "native"` rejects it with `unsupported-chart-data`; single-series native Pareto is unchanged. `chartex: "fallback"` also retains all series. Native acceptance of any new behavior remains separate.

package/dist/content-topology.js

@@ -18,8 +18,10 @@
 //            | {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?, bullets?, box?, lines?, wrap?}   // box = [x, y, w, h] reference px, 1 decimal
+//   Node     = {t: 'group', id?, ext?, comp?, typed?, pin?, in?, blocks: Node[]}
+//            | {t: 'leaf', k, id?, ext?, typed?, pin?, in?, bullets?, box?, lines?, wrap?}   // box = [x, y, w, h] reference px, 1 decimal
+//   pin = the block's authored `region` pin (OPF 0.19 layout templates, RR-81), restored onto the block
+//   in  = the template region a root block was drawn in (RR-81): where its shapes are, for editors and diagnostics; never restored
 //   typed = true when the authored block spelled out its `type`
 //   bullets = true when the authored list block used the `bullets` key (import names every list `items`), also under `type: 'text'`
 //   lines = N (>= 2) when a rich-text `text` payload exported as N native line
@@ -62,6 +64,8 @@ export const MAX_NODES = 256;
 export const MAX_ID_LENGTH = 256;
 // Native bounds may sit this far outside a stored leaf box (reference px).
 export const BOX_TOLERANCE = 3;
+// A template region name (OPF 0.19), as a `region` pin or the region a block was drawn in.
+const REGION_NAME = /^[a-z][a-z0-9-]{0,63}$/;
 
 const kindOfField = field => field === 'items' || field === 'bullets' ? 'list' : field;
 const isGroup = block => object(block) && (block.type === 'group' || (block.type === undefined && Array.isArray(block.blocks)));
@@ -240,6 +244,12 @@ export function contentTopology(slide, items, slideIndex, report = () => {}) {
     if (lines) wrapped.set(item.path, wrapRecord(lines));
   }
   const base = `slides.${slideIndex}`;
+  // RR-81: the template region each root block was drawn in (core's items[].region).
+  const regionOf = new Map();
+  for (const item of items ?? []) {
+    const root = typeof item?.path === 'string' && typeof item.region === 'string' ? /^(slides\.\d+\.blocks\.\d+)(?:\.|$)/.exec(item.path)?.[1] : undefined;
+    if (root && REGION_NAME.test(item.region) && !regionOf.has(root)) regionOf.set(root, item.region);
+  }
   let nodes = 0;
   const fail = reason => { throw new TopologyError(reason); };
   const leafBox = path => {
@@ -256,6 +266,8 @@ export function contentTopology(slide, items, slideIndex, report = () => {}) {
     }
     if (object(block.extensions)) node.ext = clone(block.extensions);
     if (typeof block.type === 'string') node.typed = true;
+    if (typeof block.region === 'string' && REGION_NAME.test(block.region)) node.pin = block.region;
+    if (regionOf.has(path)) node.in = regionOf.get(path);
     return node;
   };
   const node = (block, path, depth) => {
@@ -431,6 +443,7 @@ export function validateTopology(value) {
     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.pin !== undefined && !REGION_NAME.test(item.pin ?? '')) || (item.in !== undefined && !REGION_NAME.test(item.in ?? ''))) throw Error('Invalid content node region.');
     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.');
@@ -564,6 +577,7 @@ export function rebuildContent(topology, blocks, bounds, placed) {
     if (leaf.node.bullets === true) bulletsKey(payload, leaf.node.typed);
     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);
+    if (leaf.node.pin !== undefined) payload.region = leaf.node.pin;
     return payload;
   };
   const build = item => {
@@ -577,6 +591,7 @@ export function rebuildContent(topology, blocks, bounds, placed) {
     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);
+    if (item.pin !== undefined) group.region = item.pin;
     group.blocks = children;
     return group;
   };

package/dist/document-provenance.js

@@ -345,7 +345,7 @@ const SOURCE_PREFIX = /^(asset:|data:|https?:|file:|\.\.?\/)/i;
 // Metadata fields that hold content references (OPF 0.15: `id` or `name:id`; for audience and purpose a string that is not
 // a reference is free text). `language` is an engine vocabulary (a BCP-47 tag), not a catalog reference.
 const METADATA_REFERENCES = Object.freeze(['narrative', 'tone', 'purpose', 'audience']);
-const LAYOUT_SCHEMA = 'https://openpresentation.org/schema/opf-layout/v1';
+const LAYOUT_SCHEMA = 'https://openpresentation.org/schema/opf-layout/v2';
 const GROUP_NAME = /^[a-z][a-z0-9-]*$/;
 
 function collectStrings(value, into = new Set()) {
@@ -1328,7 +1328,7 @@ export function layoutIntent(storedCatalogs, slideRecords, entries, group, repor
     if (structureMatch && problem === 'source') report({code: 'invalid-document-provenance', path: `slides.${index}.layoutRecord`, message: `slides.${index}.layoutRecord belongs to catalogs.${stated.group}${stated.source ? ` (${stated.source})` : ''}, which the document declares with another source, so the slide's stored layout record was not restored.`});
     const target = layout === undefined ? undefined : resolved.get(layout);
     let restoreLayout = structureMatch;
-    if (structureMatch && layout !== undefined) {
+    if (structureMatch && layout !== undefined && layout !== 'auto') {
       if (!target) {
         restoreLayout = false;
         report({code: 'unresolved-reference', path: `slides.${index}.layout`, message: `Layout '${layout}' resolves neither in the catalogs the PPTX stores nor in a registered catalog, so slides.${index}.layout was not restored; the imported slide keeps its observed arrangement.`});

package/dist/index.d.ts

@@ -89,7 +89,9 @@ export interface ToPptxOptions {
    * clustered column chart as fallback) for the constructs desktop PowerPoint confirmed natively on 2026-09-30 (treemap,
    * histogram, pareto, box-and-whisker, waterfall, funnel) and keeps `world` on the clustered column chart with
    * `chart-data-adapted` (`chartex-fallback`) because the regionMap part, though accepted with `Requires="cx4"`, draws
-   * nothing until PowerPoint fetches map data online. "native" writes every chartex part, the map included (reports
+   * nothing until PowerPoint fetches map data online. Multi-series Pareto also uses editable clustered columns with all series and this diagnostic;
+   * explicit native mode rejects it with unsupported-chart-data before returning bytes. Single-series Pareto stays native.
+   * "native" writes supported chartex parts, the map included (reports
    * `chart-map-geodata`). "fallback" writes clustered columns only
    * (`chartex-fallback`, `histogram-binned`), as releases before FF-22b did. Import of chartex parts is always on.
    */
@@ -166,7 +168,7 @@ export interface ToPptxOptions {
    * against a document group's `catalogs.<group>.source`, and the first is the host default that bare ids use when the document
    * omits `catalogs.default`. Never fetched. Every reference (slide layouts, themes, colour and font schemes) resolves in the
    * document's embedded records first, then here; omitted or `[]`, only embedded records resolve. Register the gallery snapshot
-   * explicitly with `catalogs: [defaultCatalog]` from `@openpresentation/opf/catalog`.
+   * explicitly with `catalogs: [gallery]` from `@openpresentation/gallery`.
    */
   catalogs?: readonly Catalog[];
 }
@@ -177,9 +179,9 @@ export interface FromPptxOptions {
   fallbackName?: string;
   schema?: string;
   /**
-   * The catalogs the host registered (core `Catalog[]`, as in ToPptxOptions; never fetched). Theme and colour-scheme recovery
+   * The catalogs the host registered (core `Catalog[]`, as in ToPptxOptions; never fetched). Omitted catalogs select the default from installed `@openpresentation/gallery` only for foreign layout mapping; explicit `[]` opts out. Theme and colour-scheme recovery requires explicitly registered catalogs and
    * (FF-24) matches the package's theme against the first one, the host default: an exact colour-scheme match imports as its
-   * bare id and a corroborated theme name as `design.theme`. Without catalogs the colour scheme imports as an inline object and
+   * bare id and a corroborated theme name as `design.theme`. With omitted catalogs or explicit `catalogs: []` the colour scheme imports as an inline object and
    * no theme id is recovered. A stored slide layout reference also resolves here.
    */
   catalogs?: readonly Catalog[];
@@ -410,7 +412,8 @@ export interface PptxOpfLink {
    * "block" fed a block (`path`, `blockType`); "title", "subtitle" and "tag" fed that slide field. Other roles name a shape the
    * importer consumed without a block of its own: "furniture" (footer, date, number, section), "background" (the picture of an image background),
    * "image-overlay" (the overlay shape of an image background or image block), "watermark", "logo",
-   * and the members of an OPF-tagged group ("code", "metric", "quote", "timeline", "media", "card-frame").
+   * and the members of an OPF-tagged group ("code", "metric", "quote", "timeline", "media", "card-frame"), and "prompt" (an empty
+   * placeholder: the prompt of a slide PowerPoint added from a layout).
    */
   role: string;
   /** Path in the presentation, for example "slides.2.blocks.1", "slides.0.title", or "slides.1.left" after a tagged round trip. */

package/dist/index.js

@@ -32,6 +32,8 @@ import {INVALID_XML_CHARACTER, nativeSections, writeSectionList} from './section
 import {attachFurnitureFields, furniturePartFields, lineFields, nativeFieldType} from './furniture-fields.js';
 import {attachNativePlaceholders, defaultPlaceholderGeometry, nativeDateText, nativeFurnitureParts, nativePlaceholderForPart, writeNativeMasters} from './native-furniture.js';
 import {liftMasterFurniture} from './master-furniture.js';
+import {gallery} from '@openpresentation/gallery';
+import {applyTemplateLayouts, deckTemplates, foreignLayoutReference, placeholderRegion, readLayoutTag, slideTemplate, writeTemplateLayouts} from './template-layouts.js';
 import {importImageOrientation} from './image-import.js';
 import {extractSignals, normalizeSignalOptions, themeFactsFor} from './import-signals.js';
 import {placeImages, importImages, importImagePlaceholders, isImagePlaceholderGroup, imageName, imageOverlayName, imagePlaceholderGroupName, backgroundImageName, backgroundOverlayName, IMAGE_TREATMENT_KEYS, BACKGROUND_IMAGE_KEYS, IMAGE_PLACEHOLDER_TAG} from './image-provenance.js';
@@ -290,6 +292,10 @@ export async function toPptx(input, options = {}) {
   context.nativeFurnitureBands = new Map();
   // RR-72: each slide's furniture parts and the object names of their shapes, for the slide master and layouts.
   context.furnitureParts = [];
+  // RR-81: the 0.19 template each slide uses (its native slide layout) and the objects bound to a region placeholder.
+  context.templateSlides = [];
+  context.automaticSlides = [];
+  context.placeholderBindings = new Map();
   context.hostDate = options.date;
   context.authored = authored;
   context.codeTags = new Map();
@@ -345,6 +351,22 @@ export async function toPptx(input, options = {}) {
     await addSlide(pptx, presentation, presentation.slides[index], index, context, options);
   }
 
+  // RR-81: when a slide uses a template, every template the deck reaches gets its native layout (registered catalogs, then embedded).
+  // A template's placeholders are composed with the options of the first slide that uses it; a template no slide uses, with the
+  // options of a slide that would (the deck's header and footer, the template's own design) and no placed-image band.
+  const reachableTemplates = deckTemplates(presentation, options.catalogs, reference => resolveReference(presentation, 'layouts', reference, options.catalogs !== undefined ? {catalogs: options.catalogs} : {}));
+  if (context.templateSlides.some(Boolean) || reachableTemplates.length || context.automaticSlides.some(Boolean)) {
+    const plans = context.templateSlides.filter(Boolean), first = plans[0] ?? context.automaticSlides.find(Boolean) ?? {areaOptions: context.firstSlideOptions};
+    const reachable = reachableTemplates;
+    for (const plan of plans) if (!reachable.some(template => template.key === plan.template.key)) reachable.push(plan.template);
+    context.deckTemplates = reachable.map(template => {
+      const used = plans.find(plan => plan.template.key === template.key);
+      if (used) return {...template, areaOptions: used.areaOptions};
+      const core = coreContext({...presentation, slides: [{layout: template.reference}]}, 0, options).options;
+      return {...template, areaOptions: {...core, fontFamilies: first.areaOptions.fontFamilies, textRasterPadding: options.textRasterPadding, placements: []}};
+    });
+  }
+
   // FF-08: pitchFamily per exported family, from each slide's resolved scheme, then the font schemes the document embeds
   // and the registered catalogs its groups name (core catalogRecords).
   context.fontPitch = fontPitchFamilies(presentation.slides.map((slide, index) => exportSlideContext(presentation, index, context, options).fonts),
@@ -429,11 +451,26 @@ export async function fromPptx(input, options = {}) {
     return inheritedParts.get(path);
   };
   const relatedPath = (path, type) => path ? [...cachedRelationships(path).values()].find(rel => rel.type === `http://schemas.openxmlformats.org/officeDocument/2006/relationships/${type}` && rel.targetMode !== 'External' && entries[rel.path])?.path : undefined;
+  // RR-81: the OPF_LAYOUT_V1 tag of each slide's layout (a 0.19 template layout), read once per layout part.
+  const layoutTags = new Map();
+  const layoutTagOf = (layoutPath, index) => {
+    if (!layoutPath) return undefined;
+    if (!layoutTags.has(layoutPath)) layoutTags.set(layoutPath, readLayoutTag(entries, layoutPath, message => options.onDiagnostic?.({code: 'invalid-layout-provenance', path: `slides.${index}.layout`, message})));
+    return layoutTags.get(layoutPath);
+  };
   const furnitureContexts = slidePaths.map((slidePath, index) => {
     const root = parseRequiredXml(entries, slidePath)['p:sld'];
     if (!root) throw new OPFPptxError('invalid-pptx', `PPTX slide is not a PresentationML slide: ${slidePath}.`, {path: slidePath});
     const tree = root['p:cSld']?.['p:spTree'], relationships = parseRelationships(entries, slidePath);
-    return {root, relationships, shapes: nativeTextShapes(tree), pictures: nativePictures(tree),
+    const layoutPath = relatedPath(slidePath, 'slideLayout'), layoutTag = layoutTagOf(layoutPath, index);
+    return {root, relationships, shapes: nativeTextShapes(tree), pictures: nativePictures(tree), layoutTag, foreignLayout: layoutTag ? undefined : foreignLayoutReference(cachedPart(layoutPath)?.['p:sldLayout'], options.catalogs),
+      // RR-81: a region placeholder typed into in PowerPoint has no xfrm of its own; it sits where the template layout puts it.
+      layoutBounds: layoutTag ? shape => {
+        const ph = shape?.['p:nvSpPr']?.['p:nvPr']?.['p:ph'];
+        if (ph?.idx === undefined) return undefined;
+        const match = asArray(cachedPart(layoutPath)?.['p:sldLayout']?.['p:cSld']?.['p:spTree']?.['p:sp']).find(candidate => candidate?.['p:nvSpPr']?.['p:nvPr']?.['p:ph']?.idx === ph.idx);
+        return match ? shapeBounds(match['p:spPr']?.['a:xfrm']) ?? undefined : undefined;
+      } : undefined,
       // RR-11: native footer placeholders resolve their position through the layout and master.
       path: slidePath, slideWidth: Number(presentationRoot['p:sldSz']?.cx), relationshipsOf: cachedRelationships, readPart: cachedPart,
       paragraphs: nativeShapeParagraphs(decodeText(entries[slidePath])),
@@ -512,6 +549,28 @@ export async function fromPptx(input, options = {}) {
     report({code: "invalid-document-provenance", path: "", message: `${errorMessage(error)} Ordinary import keeps the values observed in the PPTX.`});
   }
   if (slideProvenance.length !== imported.slides.length) throw new OPFPptxError("invalid-import-opf", "Slide provenance does not match the imported slides.");
+  // RR-81: a slide on a 0.19 template layout takes that layout's reference (a slide added in PowerPoint, Change Layout), and a
+  // block read from a region placeholder keeps its region with a pin where plain binding would move it (src/template-layouts.js).
+  // Every tagged layout of the package, used or not: an embedded template no slide uses comes back from its tag.
+  const packageLayoutTags = Object.keys(entries).filter(path => /^ppt\/slideLayouts\/slideLayout\d+\.xml$/.test(path)).sort((a, b) => Number(a.match(/\d+/)[0]) - Number(b.match(/\d+/)[0]))
+    .map(path => layoutTagOf(path, 0)).filter(Boolean);
+  if (packageLayoutTags.length) {
+    const restoredContent = new Set(restoredGroups.filter(group => group.applied && group.contentPaths).map(group => group.contentPaths.slide));
+    applyTemplateLayouts(imported, furnitureContexts.map((context, index) => ({tag: context.layoutTag, blockRegions: context.blockRegions, restored: restoredContent.has(index), preservedAutomatic: slideProvenance[index]?.structure !== 'untagged', storedLayout: slideProvenance[index]?.layout})),
+      index => resolveCoreSlideContext(imported, index, options.catalogs !== undefined ? {catalogs: options.catalogs} : {}).resolved.layout, report, packageLayoutTags);
+  }
+  for (const [index, context] of furnitureContexts.entries()) {
+    if (!context.layoutTag && slideProvenance[index]?.structure === 'untagged' && context.foreignLayout !== undefined && imported.slides[index].layout === undefined)
+      {
+        if (context.foreignLayout.startsWith('default:')) {
+          const found = resolveReference({}, 'layouts', context.foreignLayout, {catalogs: options.catalogs ?? [gallery]});
+          const existing = imported.catalogs?.default;
+          if (existing === false || (existing?.source !== undefined && existing.source !== found?.source)) continue;
+          if (found?.source) imported.catalogs = {...imported.catalogs, default: {...imported.catalogs?.default, source: found.source}};
+        }
+        imported.slides[index].layout = context.foreignLayout;
+      }
+  }
   // RR-34: marker runs become cite/footnote on the runs before them, and the references list is rebuilt
   // from the stored record and the footnote boxes (an edited note keeps its edited text).
   restoreCitations(imported, furnitureContexts.map(context => context.annotations?.notes ?? []), report);
@@ -824,6 +883,18 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
     .map((item) => ({payload: payloadFromSlideItem(item, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}`})), bounds: item.visualBounds ?? item.bounds, sources: item.sources ?? []}))
     .filter((entry) => entry.payload);
   const blocks = content.map((entry) => entry.payload);
+  // RR-81: the region of each block read from one region placeholder of the slide's 0.19 template layout (its p:ph idx).
+  if (nativeContext.layoutTag) {
+    const frames = asArray(slideRoot['p:cSld']?.['p:spTree']?.['p:graphicFrame']);
+    const nodeOf = source => {
+      const [kind, position] = source.split(':');
+      return kind === 'sp' ? nativeContext.shapes[position] : kind === 'pic' ? nativeContext.pictures[position] : kind === 'frame' ? frames[position] : undefined;
+    };
+    nativeContext.blockRegions = content.map(entry => {
+      const regions = new Set(entry.sources.map(source => placeholderRegion(nodeOf(source), nativeContext.layoutTag)));
+      return regions.size === 1 ? [...regions][0] : undefined;
+    });
+  }
   // RR-34: a tagged caption re-attaches to the block whose native media shape it names (never by position).
   const annotations = nativeContext.annotations;
   if (annotations?.captions.size) {
@@ -932,9 +1003,13 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
     if (furniture.text.has(index) || nativeContext.imageShapes?.has(index) || nativeContext.watermarkShapes?.has(index) || nativeContext.logoPlaceholderShapes?.has(index) || placeholders.consumed.has(index)) continue;
     if (annotations.consumed.has(shape)) { roles.set(shapeKeys.get(shape), 'annotation'); continue; }
     if (code.consumed.has(shape)||metric.consumed.has(shape)||cards.has(shape)||media.consumed.has(shape)||headings.consumed.has(shape)||plainText.consumed.has(shape)||timelines.consumed.has(shape)||quotes.consumed.has(shape)) continue;
+    // RR-81: a placeholder with no text (no runs, or only empty paragraphs) is PowerPoint's prompt ("Click to add text" on a slide
+    // added from a layout), not content. A picture, chart or table in a placeholder is a p:pic or p:graphicFrame, read below.
+    if (shape['p:nvSpPr']?.['p:nvPr']?.['p:ph'] !== undefined && !(paragraphs[index] ?? []).some(paragraph => paragraph.text)) { roles.set(shapeKeys.get(shape), 'prompt'); continue; }
     const ordinaryBody = Object.hasOwn(shape, 'p:txBody') && !shape['p:nvSpPr']?.['p:nvPr']?.['p:custDataLst']?.['p:tags'];
     const item = importShape(shape, dimensions, paragraphs[index], ordinaryBody || furniture.taggedText.has(index) || media.captionShapes.has(shape));
     if (item && ordinaryBody) item.readNativeBody = () => readBody(index);
+    if (item && !item.bounds && nativeContext.layoutBounds) item.bounds = nativeContext.layoutBounds(shape) ?? item.bounds;
     // A damaged/edited furniture group falls back to current native text,
     // including cleared text boxes, without inventing a title or shape label.
     if (item && (furniture.taggedText.has(index) || media.captionShapes.has(shape))) item.sourceText = true;
@@ -2002,6 +2077,17 @@ async function addSlide(pptx, presentation, authoredSlide, slideIndex, context,
   // Core resolves every shared design key once (slide design, deck design, then the layout record's design): the text alignment of
   // each item (item.alignment), and each image item's own fit and treatment (item.image).
   const geometry = composeSlide(opfSlide, composeOptions);
+  if (slideIndex === 0) context.firstSlideOptions = composeOptions;
+  // RR-81: a list core broke into columns (listColumns) is drawn as one measured list whose lines sit in their columns: each line
+  // is its own shape at core's geometry, as in every list, and line names, numbering and provenance run across the columns.
+  // Core's item.text is the whole list (every entry at its column's position); the lines are taken from listColumns, which replace
+  // the entries rather than add to them, so each entry is drawn once.
+  for (const item of geometry.items) if (item.listColumns?.length > 1 && item.text?.listEntries) item.text = {...item.text, listEntries: item.listColumns.flatMap(column => column.text?.listEntries ?? [])};
+  // RR-81: a slide on a 0.19 template uses that template's native slide layout (src/template-layouts.js), whose placeholders
+  // core composes with this slide's options (canvas, the deck's header and footer, direction) and its placed-image bands.
+  const template = slideTemplate(slideContext.core);
+  if (template) context.templateSlides[slideIndex] = {template, areaOptions: {...composeOptions, placements: placedImageBands(opfSlide)}};
+  else if (opfSlide.layout === undefined || opfSlide.layout === 'auto') context.automaticSlides[slideIndex] = {areaOptions: composeOptions, title: geometry.items.find(item => item.field === 'title')};
   // The default footer band (date left, text center, number right): where a footer added natively lands (RR-11).
   if (slideIndex === 0) context.defaultFooterOptions = composeOptions;
   slideContext.zoneBand = zoneBands(composeOptions);
@@ -2035,6 +2121,13 @@ async function addSlide(pptx, presentation, authoredSlide, slideIndex, context,
   // Cover and section slides: the deck logo core composed at the top-left of the free area, after the watermark and before content.
   if (geometry.logo) await addLogo(slide, presentation, geometry.logo, slideIndex, slideContext, context, options);
   for (const item of geometry.items) {
+    // RR-81: the lone picture, chart or table of a `none` region binds to that region's placeholder on the slide layout. A captioned
+    // object or one drawn on a card stays a free shape: Change Layout would move it away from its caption or card.
+    const boundRegion = template && item.region !== undefined && ['image', 'chart', 'table'].includes(item.field) && !item.caption && !item.frameBox
+      ? geometry.regions?.find(region => region.name === item.region && region.flow === 'none' && region.content?.length === 1 && !region.overflow?.length) : undefined;
+    if ((template || context.automaticSlides[slideIndex]) && item.field === 'title' && typeof item.value === 'string' && item.text?.lines?.length === 1 && !item.text.overflow && !item.text.richLines)
+      context.placeholderBindings.set(`OPF heading ${item.path} line 0`, {slide: slideIndex, region: 'Title', object: 'title'});
+    const drawnBefore = boundRegion && {images: context.images.size, placeholders: context.imagePlaceholders.size, charts: context.chartHeadings.size, tables: context.tableHeaders.size};
     // Card text sits on a literal card fill, not the slide background: keep it literal.
     const itemContext = item.frameBox ? {...slideContext, textColor: slideContext.colors.text, mutedColor: slideContext.colors.mutedText} : slideContext;
     const region = { x: item.box.x / 96, y: item.box.y / 96, w: item.box.width / 96, h: item.box.height / 96 };
@@ -2091,6 +2184,12 @@ async function addSlide(pptx, presentation, authoredSlide, slideIndex, context,
         addCaption(slide, item, mediaName, itemContext, exportHelpers, (code, message) => new OPFPptxError(code, message, {path: item.caption.path}));
       }
     }
+    if (drawnBefore) {
+      const added = (map, size) => [...map.keys()].slice(size);
+      const names = item.field === 'image' ? (context.imagePlaceholders.size === drawnBefore.placeholders ? added(context.images, drawnBefore.images) : [])
+        : item.field === 'chart' ? added(context.chartHeadings, drawnBefore.charts).filter(name => !context.chartex.has(name)) : added(context.tableHeaders, drawnBefore.tables);
+      if (names.length === 1) context.placeholderBindings.set(names[0], {slide: slideIndex, region: boundRegion.name, object: item.field === 'image' ? 'picture' : item.field});
+    }
   }
   // RR-34: the footnote area core reserved above the footer band (rule plus one tagged text box per listed line).
   addFootnotes(slide, geometry.footnotes, slideIndex, slideContext, exportHelpers, (code, message) => new OPFPptxError(code, message, {path: `slides.${slideIndex}`}));
@@ -2106,6 +2205,13 @@ async function addSlide(pptx, presentation, authoredSlide, slideIndex, context,
   }
 }
 
+// RR-81: the placed-image bands of a slide (its image blocks with a `placement`), which a template layout reserves as the slide does.
+function placedImageBands(slide) {
+  return (Array.isArray(slide?.blocks) ? slide.blocks : [])
+    .filter(block => isPlainObject(block) && isPlainObject(block.placement) && typeof block.placement.edge === 'string' && (block.image !== undefined || block.type === 'image'))
+    .map(({placement}) => ({edge: placement.edge, ...(placement.size !== undefined ? {size: placement.size} : {}), ...(placement.inset !== undefined ? {inset: placement.inset} : {})}));
+}
+
 // 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.
 function exportSlideContext(presentation, slideIndex, baseContext, options) {
@@ -2536,7 +2642,7 @@ function applyChartTextSize(xml, size) {
 }
 
 function addChartPayload(slide, chart, region, context, options = {}, path = "chart", presentation) {
-  const chartData = toPptxChartData(chart, context.chartexMode, presentation);
+  const chartData = toPptxChartData(chart, context.chartexMode, presentation, path);
   if (!chartData.series) {
     // Never lose a chart silently: the placeholder frame stands in for it, and a diagnostic names the reason.
     options.onDiagnostic?.({code: "chart-data-unplottable", path, message: chartData.message, reason: chartData.reason});
@@ -3454,7 +3560,7 @@ function textRuns(value, context, fallbackFontSize) {
  * goes through core's strict `chartNumber` (a string that is not a plain decimal is a gap, reported once per chart as
  * `chart-value-not-numeric`). `formats` holds the Excel codes of the columns' number formats per exported series.
  */
-function toPptxChartData(chart, chartexMode = 'auto', presentation) {
+function toPptxChartData(chart, chartexMode = 'auto', presentation, path = 'chart') {
   const unplottable = (reason, summary, message) => ({reason, summary, message: `${message} No native chart was exported; a placeholder frame stands in for it.`});
   // A dataset reference is inlined from the document first (composition normally hands over the inline copy already).
   const source = isDatasetRef(chart?.data) ? inlineChartData(chart, presentation) : chart;
@@ -3473,19 +3579,25 @@ function toPptxChartData(chart, chartexMode = 'auto', presentation) {
   const columnCodes = (resolvedData.formats ?? []).map(excelCode);
   const diagnostics = resolvedData.diagnostics.filter((entry) => entry.severity === 'warning' && entry.code !== 'chart-value-not-numeric');
   const rejected = resolvedData.diagnostics.filter((entry) => entry.code === 'chart-value-not-numeric');
-  const resolved = resolveChartType(chart.type).spec;
+  const {id: chartId, spec: resolved} = resolveChartType(chart.type);
   // A chartex type (treemap, histogram, pareto, box & whisker, waterfall, funnel, map) has no classic construct. Natively
   // it is written as its cx:chartSpace part and the clustered column chart of the same data is its mc:Fallback
   // (src/chartex.js). 'auto' (the default) does that for the constructs the native PowerPoint check confirmed and keeps
   // the unconfirmed map on the clustered column chart alone; 'fallback' keeps every chartex id there. The fallback is
   // reported as chartex-fallback, never silent.
-  const native = chartexMode === 'native' || (chartexMode === 'auto' && resolved.family === 'chartex' && !resolved.unconfirmed);
+  const multiSeriesPareto = chartId === 'pareto' && data.columns.length > 2;
+  if (multiSeriesPareto && chartexMode === 'native') {
+    throw new OPFPptxError('unsupported-chart-data', 'Native Pareto supports one value series. Use chartex auto or fallback to export every series as an editable clustered column chart.', {path, series: data.columns.slice(1)});
+  }
+  const native = chartexMode === 'native' || (chartexMode === 'auto' && resolved.family === 'chartex' && !resolved.unconfirmed && !multiSeriesPareto);
   const chartex = resolved.family === 'chartex' && native ? resolved : null;
   const spec = resolved.family === 'chartex' ? CHARTEX_FALLBACK : resolved;
   const typeName = stringifyText(chart.type);
   const adaptations = [];
   if (resolved.family === 'chartex' && !native) {
-    const reason = chartexMode === 'fallback'
+    const reason = multiSeriesPareto && chartexMode === 'auto'
+      ? 'that cannot represent multiple value series natively; all authored series are preserved in the fallback'
+      : chartexMode === 'fallback'
       ? 'that this exporter does not write'
       : 'that PowerPoint has not yet accepted natively from this exporter (pass chartex: \'native\' to write its chartex part)';
     adaptations.push({adaptation: "chartex-fallback", message: `The '${typeName}' chart is a PowerPoint extension (chartex) chart ${reason}; its data is exported as a native clustered column chart instead.`});
@@ -4059,6 +4171,16 @@ async function normalizePptxZip(raw, context) {
     }
     reportPerSlideNotesScriptFonts(context.scriptFonts, slideThemes);
   }
+  // RR-81: one native slide layout per 0.19 template the slides use, under each slide's master, and the objects bound to its
+  // placeholders (src/template-layouts.js). Before RR-72, which copies a slide's own layout for a furniture variant.
+  if (context.templateSlides.some(Boolean) || context.deckTemplates?.length || context.automaticSlides.some(Boolean)) {
+    try {
+      writeTemplateLayouts(output, context.templateSlides, context.deckTemplates ?? [], context.placeholderBindings,
+        (path, xml) => context.scriptFonts ? partScriptFonts(path, xml, context.scriptFonts, 0) : xml, {records: context.provenanceMode === 'full', automaticSlides: context.automaticSlides});
+    } catch (error) {
+      throw new OPFPptxError('packaging-failed', 'Native slide layouts for the layout templates could not be written.', {cause: errorMessage(error)});
+    }
+  }
   // RR-72: furniture drawn the same on several slides moves to the slide master or a layout (src/master-furniture.js).
   try {
     liftMasterFurniture(output, context.furnitureParts, diagnostic => context.reportDiagnostic?.(diagnostic));

package/dist/master-furniture.js

@@ -157,7 +157,7 @@ export function liftMasterFurniture(output, slides, report = () => {}) {
       const showsMaster = plan.candidates.size ? common.every(slot => free(plan, slot)) : !common.length;
       const extras = [...plan.candidates.keys()].filter(slot => free(plan, slot) && (showsMaster ? !common.includes(slot) && counts.get(id(slot, value(plan, slot))) >= 2
         : common.includes(slot) || counts.get(id(slot, value(plan, slot))) >= 2)).sort();
-      const key = `${showsMaster ? 1 : 0}\u0001${extras.map(slot => id(slot, value(plan, slot))).join('\u0001')}`;
+      const key = `${plan.layout}\u0002${showsMaster ? 1 : 0}\u0001${extras.map(slot => id(slot, value(plan, slot))).join('\u0001')}`;
       plan.extras = extras;
       plan.lifted = new Map([...(showsMaster ? common.map(slot => [slot, 'master']) : []), ...extras.map(slot => [slot, 'layout'])]);
       plan.layoutKey = showsMaster && !extras.length ? undefined : key;
@@ -228,20 +228,38 @@ export function liftMasterFurniture(output, slides, report = () => {}) {
   for (const {master, group, common, layouts} of assignments) {
     const showing = group.find(plan => common.every(slot => free(plan, slot)) && plan.candidates.size);
     for (const slot of common) transplant(master, showing, slot);
-    // The layout the slides use now (each master has one), copied once per layout key.
-    const base = group[0].layout;
+    // The layout a slide uses now, copied once per layout key: the master's one layout, or the slide's 0.19 template layout (RR-81),
+    // whose variant keeps its placeholders and its OPF_LAYOUT_V1 tag (`Pillars (no furniture)`).
     let masterXml = partXml(master), masterRels = partRels(master);
     let number = 0;
+    const templateNumbers = new Map();
     for (const layout of layouts.values()) {
+      const base = layout.source.layout;
       const path = `ppt/slideLayouts/slideLayout${nextLayout++}.xml`;
-      const name = layout.source.extras.length ? `OPF furniture ${++number}` : 'OPF no furniture';
+      const baseRels = has(relsOf(base)) ? read(relsOf(base)) : '';
+      const tagRels = relationships(baseRels).filter(rel => rel.type === `${REL}/tags` && !rel.external);
+      const baseName = unescapeAttribute(read(base).match(/<p:cSld\b[^>]*\bname="([^"]*)"/)?.[1] ?? '');
+      let name;
+      if (tagRels.length) {
+        const count = (templateNumbers.get(base) ?? 0) + (layout.source.extras.length ? 1 : 0);
+        templateNumbers.set(base, count);
+        name = layout.source.extras.length ? `${baseName} (furniture ${count})` : `${baseName} (no furniture)`;
+      } else name = layout.source.extras.length ? `OPF furniture ${++number}` : 'OPF no furniture';
       let xml = read(base).replace(/(<p:cSld\b[^>]*?\bname=")[^"]*(")/, `$1${escapeAttribute(name)}$2`);
       if (!layout.showsMaster) xml = xml.replace(/<p:sldLayout\b[^>]*>/, open => `${open.slice(0, -1).replace(/\s+showMasterSp="[^"]*"/, '')} showMasterSp="0">`);
-      const baseRels = has(relsOf(base)) ? read(relsOf(base)) : '';
-      // A copied layout keeps only its master relationship; the furniture brings its own.
+      // A copied layout keeps only its master relationship and its own tags (a copy of each tag part); the furniture brings its own.
       const masterRel = relationships(baseRels).find(rel => rel.type === `${REL}/slideMaster`);
       if (!masterRel) throw new Error(`${base} has no slide master relationship.`);
-      stage(path, xml, `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${masterRel.node}</Relationships>`);
+      let copiedRels = masterRel.node;
+      for (const rel of tagRels) {
+        const source = resolvePart(base, rel.target);
+        let n = 0, copy;
+        do copy = `ppt/tags/opfLayoutVariant${++n}.xml`; while (has(copy));
+        output[copy] = [output[source][0], options];
+        types = types.replace('</Types>', `<Override PartName="/${copy}" ContentType="${TAGS_TYPE}"/></Types>`);
+        copiedRels += `<Relationship Id="${rel.id}" Type="${REL}/tags" Target="${escapeAttribute(relativeTarget(path, copy))}"/>`;
+      }
+      stage(path, xml, `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${copiedRels}</Relationships>`);
       types = types.replace('</Types>', `<Override PartName="/${path}" ContentType="${LAYOUT_TYPE}"/></Types>`);
       for (const slot of layout.source.extras) transplant(path, layout.source, slot);
       const result = relationshipId(masterRels, `${REL}/slideLayout`, relativeTarget(master, path), false);

package/dist/template-layouts.js

@@ -0,0 +1,514 @@
+// RR-81: OPF 0.19 layout templates as native PowerPoint slide layouts (core docs/programs/release-readiness/0.19-layouts.md,
+// section 8).
+//
+// Export. When a slide of the deck uses a template, every template the deck can reach becomes one `p:sldLayout` under each
+// slide master (one per theme and script profile), so Change Layout reaches all of them (design question 7): the templates of
+// the registered catalogs in catalog order, then the templates the document embeds (`custom` first, then the other groups by
+// name), each by id. Automatic slides also get an OPF auto titleOnly layout. Named by the record's `name`, with one placeholder per area of the empty layout that core's
+// `composeLayoutAreas` composes at the deck size (nothing collapsed): `title` (`ctrTitle` with a `subTitle` below it on
+// `cover` and `section`), `subTitle` for a `subtitle` area, and per body region a placeholder typed by what it accepts
+// (`placeholderType`). The layout keeps RR-11's date, footer and slide-number placeholders and `p:hf` (it starts as a copy of
+// the layout the slide used), and carries an OPF_LAYOUT_V1 tag in its common slide data: the layout's id, group, source, the
+// reference its first slide wrote, a hash of the record and the placeholder index of every region. Slides relate to it. A
+// slide whose areas collapse still uses the full layout: its own geometry is explicit.
+//
+// A `none` region that holds one picture, chart or table binds that object to its placeholder (`p:ph idx` at the composed
+// geometry), so PowerPoint's Reset, Change Picture and Change Layout move it. Blocks of flowing regions, text blocks and
+// everything else stay editable shapes at core's geometry (the slide's OPF_SLIDE_V1 content topology names the region of
+// each root block); the slide does not instantiate those placeholders, so a filled slide shows no prompt.
+//
+// Accepted one-line plain titles bind to the native title placeholder; long and rich titles remain tagged line shapes.
+// Automatic slides use OPF auto (titleOnly), independently of registered catalogs. Layout prompts carry explicit OPF typography.
+//
+// Import. Foreign layouts map by type or a case-insensitive built-in name when v2 built-ins are registered. A slide whose layout carries OPF_LAYOUT_V1 takes that layout's reference when it has none (a slide added in
+// PowerPoint, or an export without provenance) or when its stored layout names another layout (Change Layout:
+// `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 {validateCatalogRecord, catalogRecords, resolveReference} from '@openpresentation/opf';
+import {gallery} from '@openpresentation/gallery';
+import {decodeTextTag, encodeTextTag} from './code-provenance.js';
+
+export const LAYOUT_TAG = 'OPF_LAYOUT_V1';
+const dec = new TextDecoder('utf-8', {fatal: true}), enc = new TextEncoder();
+const REL = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+const NS = 'http://schemas.openxmlformats.org/presentationml/2006/main';
+const LAYOUT_TYPE = 'application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml';
+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,
+// `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).
+// The indexes stay clear of PowerPoint's subtitle (1) and date, footer and slide-number placeholders (10, 11, 12, RR-11), and
+// Each kind reserves 200 indexes so a 144-region custom grid cannot collide across kinds. They
+// depend on the record only, so they are the same under every slide master.
+export const REGION_IDX_BASE = Object.freeze({obj: 100, body: 300, pic: 500, chart: 700, tbl: 900, media: 1100});
+export const SUBTITLE_IDX = 1;
+const NAME = /^[a-z][a-z0-9-]*$/;
+const MAX_REGIONS = 144;
+
+/**
+ * The PowerPoint layout type of a built-in id (design section 8); every other template is `cust`. `statement` is `cust` too
+ * (coordinator decision on RR-81): `titleOnly` would contradict its message placeholder.
+ */
+export const POWERPOINT_LAYOUT_TYPES = Object.freeze({
+  cover: 'title', section: 'secHead', text: 'obj', list: 'obj', agenda: 'obj', faq: 'obj',
+  'two-column': 'twoObj', comparison: 'twoObj', 'image-beside': 'picTx',
+});
+const CENTERED_TITLE = new Set(['cover', 'section']);
+
+/**
+ * The placeholder type of a body region: `pic` when it accepts only pictures (or is a `media` region whose leaf kinds are
+ * pictures and video), `chart` when only charts, `tbl` when only tables, `media` when only video, `body` when only text and
+ * lists, otherwise a content placeholder, `obj` (written without a type, as PowerPoint does).
+ */
+export function placeholderType(region) {
+  const accepts = new Set(region.accepts);
+  const only = (...kinds) => [...accepts].every(kind => kinds.includes(kind));
+  if (only('image')) return 'pic';
+  if (only('chart')) return 'chart';
+  if (only('table')) return 'tbl';
+  if (only('video')) return 'media';
+  if (region.role === 'media' && accepts.has('image') && only('image', 'video', 'group')) return 'pic';
+  if (only('text', 'list')) return 'body';
+  return 'obj';
+}
+
+/** Which slide objects a placeholder of each type takes (binding a `none` region's lone object). */
+const BINDS = {title: ['title'], ctrTitle: ['title'], pic: ['picture'], chart: ['chart'], tbl: ['table'], obj: ['picture', 'chart', 'table']};
+export const bindsObject = (type, object) => (BINDS[type] ?? []).includes(object);
+
+/** The placeholder index of each region: its kind's base plus its position among the regions of that kind (REGION_IDX_BASE). */
+export function regionIndexes(record) {
+  const regions = new Map(layoutTemplate(record).regions.map(region => [region.name, region]));
+  const counts = {};
+  return Object.fromEntries(Object.keys(record?.regions ?? {}).filter(name => regions.has(name)).map(name => {
+    const type = placeholderType(regions.get(name));
+    counts[type] = (counts[type] ?? -1) + 1;
+    return [name, REGION_IDX_BASE[type] + counts[type]];
+  }));
+}
+
+// FNV-1a (64-bit) of the record's canonical JSON: evidence of which record the layout was made from.
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
+  if (value !== null && typeof value === 'object') return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+  return JSON.stringify(value);
+}
+export function recordHash(record) {
+  let hash = 0xcbf29ce484222325n;
+  for (const byte of enc.encode(canonical(record))) hash = BigInt.asUintN(64, (hash ^ BigInt(byte)) * 0x100000001b3n);
+  return hash.toString(16).padStart(16, '0');
+}
+
+/**
+ * The template a slide uses, from core's slide context (`resolveSlideContext`): undefined for automatic composition and 0.18
+ * records. `provenance` is core's provenance of the resolved layout reference.
+ */
+export function slideTemplate(core) {
+  const record = core?.resolved?.layout, provenance = core?.resolved?.provenance?.layout;
+  if (!record || !provenance || !Object.hasOwn(record, 'areas')) 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)};
+}
+
+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;
+  try { layoutTemplate(record); return true; } catch { return false; }
+}
+
+/**
+ * Every template the deck can reach, in the order its layouts are written: the registered catalogs' templates in catalog order
+ * (each catalog's ids as it lists them), then the document's embedded templates (`custom` first, then the other groups by name,
+ * each by id). `resolve(reference)` is core's resolveReference for the deck's layouts; a record is listed under the first
+ * reference that resolves to it, and a record no reference reaches is left out.
+ */
+export function deckTemplates(document, catalogs, resolve) {
+  const result = [], seen = new Set();
+  const add = (references, matches) => {
+    for (const reference of references) {
+      let found;
+      try { found = resolve(reference); } catch { found = undefined; }
+      if (!found || !matches(found) || !isTemplate(found.record)) continue;
+      const template = {record: found.record, id: found.id, group: found.group, ...(found.source !== undefined ? {source: found.source} : {}), reference, origin: found.origin};
+      template.key = templateKey(template);
+      if (!seen.has(template.key)) { seen.add(template.key); result.push(template); }
+      return;
+    }
+  };
+  const groups = document?.catalogs !== null && typeof document?.catalogs === 'object' ? document.catalogs : {};
+  for (const catalog of Array.isArray(catalogs) ? catalogs : []) {
+    const named = Object.keys(groups).filter(name => name !== 'custom' && groups[name]?.source === catalog?.source);
+    for (const [id, record] of Object.entries(catalog?.layouts ?? {})) {
+      if (!NAME.test(id) || !isTemplate(record)) continue;
+      add([id, `default:${id}`, ...named.map(name => `${name}:${id}`)], found => found.origin === 'host' && found.id === id && found.source === catalog.source);
+    }
+  }
+  const names = Object.keys(groups).filter(name => NAME.test(name)).sort((a, b) => a === 'custom' ? -1 : b === 'custom' ? 1 : a < b ? -1 : a > b ? 1 : 0);
+  for (const group of names) for (const id of Object.keys(groups[group]?.layouts ?? {}).filter(id => NAME.test(id)).sort()) {
+    add(group === 'custom' ? [id, `custom:${id}`] : [`${group}:${id}`], found => found.origin === 'document' && found.group === group && found.id === id);
+  }
+  return result;
+}
+
+const escapeXml = value => String(value).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+const attribute = (xml, name) => new RegExp(`\\s${name}="([^"]*)"`).exec(xml)?.[1];
+const relsOf = path => path.replace(/([^/]+)$/, '_rels/$1.rels');
+const unescapeAttribute = value => value.replace(/&quot;/g, '"').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+
+function resolvePart(source, target) {
+  if (target.startsWith('/')) return target.slice(1);
+  const parts = source.split('/').slice(0, -1);
+  for (const piece of target.split('/')) {
+    if (piece === '..') parts.pop();
+    else if (piece !== '.' && piece) parts.push(piece);
+  }
+  return parts.join('/');
+}
+function relativeTarget(source, path) {
+  const from = source.split('/').slice(0, -1), to = path.split('/');
+  let common = 0;
+  while (common < from.length && common < to.length - 1 && from[common] === to[common]) common++;
+  return [...Array(from.length - common).fill('..'), ...to.slice(common)].join('/');
+}
+const relationships = xml => [...xml.matchAll(/<Relationship\b[^>]*\/>/g)].map(([node]) => ({node, id: attribute(node, 'Id'), type: attribute(node, 'Type') ?? '',
+  target: unescapeAttribute(attribute(node, 'Target') ?? ''), external: attribute(node, 'TargetMode') === 'External'}));
+function addRelationship(relsXml, type, target) {
+  const taken = new Set(relationships(relsXml).map(rel => rel.id));
+  let n = 1, rid;
+  do rid = `rId${n++}`; while (taken.has(rid));
+  return {rid, relsXml: relsXml.replace('</Relationships>', `<Relationship Id="${rid}" Type="${type}" Target="${escapeXml(target)}"/></Relationships>`)};
+}
+
+/**
+ * The placeholders of one template layout in EMU: [{name, type, idx?, x, y, cx, cy, anchor?}]. Core's composeLayoutAreas
+ * composes the empty layout as composeSlide composes a slide with a one-line title and subtitle and every region kept:
+ * `template.areaOptions` are composeSlide's options of a slide on the template (canvas, the deck's header and footer, direction)
+ * plus its placed-image `placements`, so each box is where that slide's region lands, bled regions reaching the slide edge.
+ */
+export function layoutPlaceholders(template) {
+  const {record, id} = template;
+  const parsed = layoutTemplate(record);
+  const {areas} = composeLayoutAreas(record, {...template.areaOptions, textMeasurement: undefined});
+  const regions = new Map(parsed.regions.map(region => [region.name, region]));
+  const indexes = regionIndexes(record);
+  const emu = box => ({x: Math.round(box.x * EMU), y: Math.round(box.y * EMU), cx: Math.max(0, Math.round(box.width * EMU)), cy: Math.max(0, Math.round(box.height * EMU))});
+  const result = [];
+  for (const area of areas) {
+    if (area.name === 'title') {
+      if (CENTERED_TITLE.has(id) && area.parts) {
+        // `cover` and `section`: PowerPoint's centred title over its subtitle, at core's title and subtitle sub-boxes.
+        result.push({name: 'Title', type: 'ctrTitle', anchor: 'b', ...emu(area.parts.title)});
+        result.push({name: 'Subtitle', type: 'subTitle', idx: SUBTITLE_IDX, anchor: 't', ...emu(area.parts.subtitle)});
+      } else result.push({name: 'Title', type: CENTERED_TITLE.has(id) ? 'ctrTitle' : 'title', ...emu(area.box)});
+      continue;
+    }
+    if (area.name === 'subtitle') { result.push({name: 'Subtitle', type: 'subTitle', idx: SUBTITLE_IDX, anchor: 't', ...emu(area.box)}); continue; }
+    const region = regions.get(area.name);
+    if (region) result.push({name: region.name, type: placeholderType(region), idx: indexes[region.name], ...emu(area.box)});
+  }
+  const sample = composeSlide({title: 'Title', subtitle: 'Subtitle', blocks: [{text: 'Body'}]}, {...template.areaOptions, layout: record, textMeasurement: undefined});
+  for (const placeholder of result) {
+    const field = placeholder.type === 'title' || placeholder.type === 'ctrTitle' ? 'title' : placeholder.type === 'subTitle' ? 'subtitle' : 'text';
+    const item = sample.items.find(item => item.field === field);
+    if (item?.textStyle && item.text?.fontSize) placeholder.style = {...item.textStyle, fontSize: item.text.fontSize, alignment: item.alignment};
+  }
+  return result;
+}
+
+const PROMPTS = {title: 'Click to edit Master title style', ctrTitle: 'Click to edit Master title style', subTitle: 'Click to edit Master subtitle style', body: 'Click to edit Master text styles', obj: 'Click to edit Master text styles'};
+function placeholderShape(placeholder, id) {
+  const style = placeholder.style;
+  const align = {left: 'l', center: 'ctr', right: 'r'}[style?.alignment] ?? 'l';
+  // Each copy inherits its own master's chosen heading/body fonts (including script-profile variants).
+  const fontRole = placeholder.type === 'title' || placeholder.type === 'ctrTitle' ? 'mj' : 'mn';
+  const defaults = style ? `<a:defRPr sz="${Math.round(style.fontSize * 75)}"${Number(style.fontWeight) >= 600 ? ' b="1"' : ''}><a:latin typeface="${fontRole === 'mj' ? '+mj-lt' : '+mn-lt'}"/><a:ea typeface="+${fontRole}-ea"/><a:cs typeface="+${fontRole}-cs"/></a:defRPr>` : '';
+  const listStyle = defaults ? `<a:lstStyle>${Array.from({length: 9}, (_, level) => `<a:lvl${level + 1}pPr algn="${align}">${defaults}</a:lvl${level + 1}pPr>`).join('')}</a:lstStyle>` : '<a:lstStyle/>';
+  const typeAttribute = placeholder.type === 'obj' ? '' : ` type="${placeholder.type}"`;
+  const idx = placeholder.idx !== undefined ? ` idx="${placeholder.idx}"` : '';
+  const prompt = PROMPTS[placeholder.type];
+  const paragraph = prompt ? `<a:p><a:r><a:rPr lang="en-US"/><a:t>${prompt}</a:t></a:r></a:p>` : '<a:p><a:endParaRPr lang="en-US"/></a:p>';
+  return `<p:sp><p:nvSpPr><p:cNvPr id="${id}" name="${escapeXml(placeholder.name)}"/><p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr><p:nvPr><p:ph${typeAttribute}${idx}/></p:nvPr></p:nvSpPr>` +
+    `<p:spPr><a:xfrm><a:off x="${placeholder.x}" y="${placeholder.y}"/><a:ext cx="${placeholder.cx}" cy="${placeholder.cy}"/></a:xfrm></p:spPr>` +
+    `<p:txBody><a:bodyPr${placeholder.anchor ? ` anchor="${placeholder.anchor}"` : ''}/>${listStyle}${paragraph}</p:txBody></p:sp>`;
+}
+
+/**
+ * The OPF_LAYOUT_V1 value of a template layout. With `record` (full provenance) a template the document embeds carries its
+ * record, so a template no slide uses comes back on import (document provenance stores only the records slides reference).
+ */
+export function layoutTagValue(template, {record = false} = {}) {
+  return {v: 1, id: template.id, group: template.group, ...(template.source !== undefined ? {source: template.source} : {}), reference: template.reference,
+    hash: recordHash(template.record), regions: Object.fromEntries(Object.entries(regionIndexes(template.record)).map(([name, idx]) => [String(idx), name])),
+    ...(record && template.origin === 'document' ? {record: template.record} : {})};
+}
+
+/**
+ * Write the template layouts of the finished package and bind the placeholder objects. `output` maps a package path to
+ * [bytes, zipOptions]; runs after the per-script slide masters and before RR-72 lifts furniture. `slides[i]` is slide i's
+ * template plan ({template, areaOptions}) or undefined; `templates` (deckTemplates, each with the `areaOptions` its placeholders
+ * are composed with) are the layouts to write under every slide master, in order (a slide's own template is added when missing). `bindings`
+ * maps an object name on a slide to {slide, region, object} (`picture`, `chart` or `table`). `partText(path, xml)` applies the
+ * deck's language to a generated part.
+ */
+export function writeTemplateLayouts(output, slides, templates, bindings = new Map(), partText = (path, xml) => xml, {records = false, automaticSlides = []} = {}) {
+  if (!slides.some(Boolean) && !templates.length && !automaticSlides.some(Boolean)) return;
+  const all = [...templates];
+  for (const plan of slides) if (plan && !all.some(template => template.key === plan.template.key)) all.push({...plan.template, areaOptions: plan.areaOptions});
+  const has = path => Object.hasOwn(output, path);
+  const read = path => dec.decode(output[path][0]);
+  const options = output['ppt/presentation.xml'][1];
+  const write = (path, xml) => { output[path] = [enc.encode(xml), output[path]?.[1] ?? options]; };
+  let types = read('[Content_Types].xml');
+  const presentation = read('ppt/presentation.xml'), presentationRels = relationships(read('ppt/_rels/presentation.xml.rels'));
+  // Slide parts in presentation order.
+  const slidePaths = [...presentation.matchAll(/<p:sldId\b[^>]*\br:id="([^"]+)"/g)].map(match => {
+    const rel = presentationRels.find(item => item.id === match[1]);
+    return rel ? resolvePart('ppt/presentation.xml', rel.target) : undefined;
+  });
+  const related = (path, type) => {
+    if (!has(relsOf(path))) return undefined;
+    const rel = relationships(read(relsOf(path))).find(item => !item.external && item.type === `${REL}/${type}`);
+    return rel ? resolvePart(path, rel.target) : undefined;
+  };
+  const used = [...presentation.matchAll(/<p:sldMasterId\b[^>]*\bid="(\d+)"/g), ...Object.keys(output).filter(path => /^ppt\/slideMasters\/slideMaster\d+\.xml$/.test(path))
+    .flatMap(path => [...read(path).matchAll(/<p:sldLayoutId\b[^>]*\bid="(\d+)"/g)])].map(match => Number(match[1]));
+  let nextLayoutId = Math.max(2147483648, ...used) + 1;
+  let nextLayout = Math.max(0, ...Object.keys(output).map(path => Number(/^ppt\/slideLayouts\/slideLayout(\d+)\.xml$/.exec(path)?.[1] ?? 0))) + 1;
+  let nextTag = Math.max(0, ...Object.keys(output).map(path => Number(/^ppt\/tags\/opfLayout(\d+)\.xml$/.exec(path)?.[1] ?? 0))) + 1;
+  const created = new Map(); // master + template key -> {path, placeholders}
+  // Every slide master that holds a slide, in slide order, with the layout its slides use now (the copy each new layout starts from).
+  const masters = new Map();
+  for (const [index, slidePath] of slidePaths.entries()) {
+    if (!slidePath || !has(slidePath)) throw new Error(`Slide ${index + 1} is missing.`);
+    const base = related(slidePath, 'slideLayout'), master = base && related(base, 'slideMaster');
+    if (!base || !master) throw new Error(`Slide ${index + 1} has no slide layout and master.`);
+    if (!masters.has(master)) masters.set(master, base);
+  }
+  for (const [master, base] of masters) {
+    const taken = new Set(Object.keys(output).filter(part => /^ppt\/slideLayouts\/slideLayout\d+\.xml$/.test(part) && related(part, 'slideMaster') === master)
+      .map(part => unescapeAttribute(read(part).match(/<p:cSld\b[^>]*\bname="([^"]*)"/)?.[1] ?? '')));
+    for (const template of all) {
+      const key = `${master}\u0001${template.key}`;
+      const path = `ppt/slideLayouts/slideLayout${nextLayout++}.xml`, tagPath = `ppt/tags/opfLayout${nextTag++}.xml`;
+      let name = typeof template.record.name === 'string' && template.record.name.trim() ? template.record.name : template.id;
+      if (taken.has(name)) name = `${name} (${template.group}:${template.id})`;
+      taken.add(name);
+      const type = POWERPOINT_LAYOUT_TYPES[template.id] ?? 'cust';
+      const placeholders = layoutPlaceholders(template);
+      let xml = read(base);
+      xml = xml.replace(/<p:sldLayout\b[^>]*>/, open => `${open.slice(0, -1).replace(/\s+(?:type|userDrawn|showMasterSp)="[^"]*"/g, '')} type="${type}" userDrawn="1">`);
+      xml = xml.replace(/(<p:cSld\b[^>]*?)(\s+name="[^"]*")?(\s*>)/, (match, open, _name, close) => `${open} name="${escapeXml(name)}"${close}`);
+      let nextId = Math.max(1, ...[...xml.matchAll(/<p:cNvPr\b[^>]*\bid="(\d+)"/g)].map(match => Number(match[1]))) + 1;
+      const shapes = placeholders.map(placeholder => placeholderShape(placeholder, nextId++)).join('');
+      const groupEnd = xml.indexOf('</p:grpSpPr>');
+      if (groupEnd < 0 || /<p:custDataLst>\s*<p:tags\b[^>]*\/>\s*<\/p:custDataLst>\s*<\/p:cSld>/.test(xml)) throw new Error(`${base} cannot take template placeholders.`);
+      xml = xml.slice(0, groupEnd + '</p:grpSpPr>'.length) + shapes + xml.slice(groupEnd + '</p:grpSpPr>'.length);
+      // A copied layout keeps only its master relationship; the tag brings its own.
+      const masterRel = relationships(has(relsOf(base)) ? read(relsOf(base)) : '').find(rel => rel.type === `${REL}/slideMaster`);
+      if (!masterRel) throw new Error(`${base} has no slide master relationship.`);
+      const tagged = addRelationship(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${masterRel.node}</Relationships>`,
+        `${REL}/tags`, relativeTarget(path, tagPath));
+      xml = xml.replace('</p:spTree>', `</p:spTree><p:custDataLst><p:tags r:id="${tagged.rid}"/></p:custDataLst>`);
+      write(path, partText(path, xml));
+      write(relsOf(path), tagged.relsXml);
+      output[tagPath] = [enc.encode(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?><p:tagLst xmlns:p="${NS}"><p:tag name="${LAYOUT_TAG}" val="${encodeTextTag(layoutTagValue(template, {record: records}))}"/></p:tagLst>`), options];
+      types = types.replace('</Types>', `<Override PartName="/${path}" ContentType="${LAYOUT_TYPE}"/><Override PartName="/${tagPath}" ContentType="${TAGS_TYPE}"/></Types>`);
+      const masterRels = has(relsOf(master)) ? read(relsOf(master)) : '';
+      const added = addRelationship(masterRels, `${REL}/slideLayout`, relativeTarget(master, path));
+      write(relsOf(master), added.relsXml);
+      const masterXml = read(master);
+      if (!masterXml.includes('</p:sldLayoutIdLst>')) throw new Error(`${master} has no layout list.`);
+      write(master, masterXml.replace('</p:sldLayoutIdLst>', `<p:sldLayoutId id="${nextLayoutId++}" r:id="${added.rid}"/></p:sldLayoutIdLst>`));
+      created.set(key, {path, placeholders: new Map(placeholders.map(item => [item.name, item]))});
+    }
+  }
+  // Automatic composition is its own titleOnly layout, independently of catalog region templates.
+  for (const [master, base] of masters) {
+    const first = automaticSlides.find((plan, index) => plan && related(related(slidePaths[index], 'slideLayout'), 'slideMaster') === master);
+    if (!first) continue;
+    const path = `ppt/slideLayouts/slideLayout${nextLayout++}.xml`, tagPath = `ppt/tags/opfLayout${nextTag++}.xml`;
+    // Reuse accepted title geometry; an empty slide needs only the engine's default prompt, never a re-fit through the caller's measurement provider.
+    const title = first.title ?? composeSlide({title: 'Title'}, {...first.areaOptions, layout: undefined, textMeasurement: undefined}).items.find(item => item.field === 'title');
+    const placeholder = {name: 'Title', type: 'title', x: Math.round(title.box.x * EMU), y: Math.round(title.box.y * EMU), cx: Math.round(title.box.width * EMU), cy: Math.round(title.box.height * EMU), style: {...title.textStyle, fontSize: title.text.fontSize, alignment: title.alignment}};
+    let xml = read(base).replace(/<p:sldLayout\b[^>]*>/, open => `${open.slice(0, -1).replace(/\s+(?:type|userDrawn|showMasterSp)="[^"]*"/g, '')} type="titleOnly" userDrawn="1">`);
+    xml = xml.replace(/(<p:cSld\b[^>]*?)(\s+name="[^"]*")?(\s*>)/, (match, open, _name, close) => `${open} name="OPF auto"${close}`);
+    const nextId = Math.max(1, ...[...xml.matchAll(/<p:cNvPr\b[^>]*\bid="(\d+)"/g)].map(match => Number(match[1]))) + 1;
+    xml = xml.replace('</p:grpSpPr>', `</p:grpSpPr>${placeholderShape(placeholder, nextId)}`);
+    const masterRel = relationships(read(relsOf(base))).find(rel => rel.type === `${REL}/slideMaster`);
+    const tagged = addRelationship(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${masterRel.node}</Relationships>`, `${REL}/tags`, relativeTarget(path, tagPath));
+    xml = xml.replace('</p:spTree>', `</p:spTree><p:custDataLst><p:tags r:id="${tagged.rid}"/></p:custDataLst>`);
+    write(path, partText(path, xml)); write(relsOf(path), tagged.relsXml);
+    output[tagPath] = [enc.encode(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?><p:tagLst xmlns:p="${NS}"><p:tag name="${LAYOUT_TAG}" val="${encodeTextTag({v: 1, id: 'auto', group: 'custom', reference: 'auto', hash: recordHash({auto: true}), regions: {}})}"/></p:tagLst>`), options];
+    types = types.replace('</Types>', `<Override PartName="/${path}" ContentType="${LAYOUT_TYPE}"/><Override PartName="/${tagPath}" ContentType="${TAGS_TYPE}"/></Types>`);
+    const added = addRelationship(read(relsOf(master)), `${REL}/slideLayout`, relativeTarget(master, path));
+    write(relsOf(master), added.relsXml);
+    write(master, read(master).replace('</p:sldLayoutIdLst>', `<p:sldLayoutId id="${nextLayoutId++}" r:id="${added.rid}"/></p:sldLayoutIdLst>`));
+    created.set(`${master}\u0001auto`, {path, placeholders: new Map([['Title', placeholder]])});
+  }
+  for (const [index, plan] of slidePaths.map((_, index) => slides[index]).entries()) {
+    if (!plan && !automaticSlides[index]) continue;
+    const slidePath = slidePaths[index];
+    const master = related(related(slidePath, 'slideLayout'), 'slideMaster');
+    const layout = created.get(`${master}\u0001${plan ? plan.template.key : 'auto'}`);
+    if (!layout) throw new Error(`Slide ${index + 1} has no template layout.`);
+    const slideRels = relsOf(slidePath);
+    write(slideRels, read(slideRels).replace(/<Relationship\b[^>]*\/>/g, node => attribute(node, 'Type') === `${REL}/slideLayout` ? node.replace(/\sTarget="[^"]*"/, ` Target="${relativeTarget(slidePath, layout.path)}"`) : node));
+    // The lone picture, chart or table of a `none` region becomes its placeholder's content.
+    let slideXml = read(slidePath), changed = false;
+    for (const [objectName, binding] of bindings) {
+      if (binding.slide !== index) continue;
+      const placeholder = layout.placeholders.get(binding.region);
+      if (!placeholder || !bindsObject(placeholder.type, binding.object)) continue;
+      const ph = `<p:ph${placeholder.type === 'obj' ? '' : ` type="${placeholder.type}"`}${placeholder.idx !== undefined ? ` idx="${placeholder.idx}"` : ''}/>`;
+      const element = binding.object === 'picture' ? 'pic' : binding.object === 'title' ? 'sp' : 'graphicFrame';
+      const pattern = new RegExp(`<p:${element}>[\\s\\S]*?<\\/p:${element}>`, 'g');
+      slideXml = slideXml.replace(pattern, shape => {
+        if (unescapeAttribute(shape.match(/<p:cNvPr\b[^>]*\bname="([^"]*)"/)?.[1] ?? '') !== objectName || /<p:ph\b/.test(shape)) return shape;
+        changed = true;
+        let next = shape.replace(/<p:nvPr\s*\/>/, '<p:nvPr></p:nvPr>').replace(/<p:nvPr>/, `<p:nvPr>${ph}`);
+        if (element === 'pic') {
+          next = /<a:picLocks\b[^>]*\/>/.test(next) ? next.replace(/<a:picLocks\b([^>]*?)\s*\/>/, (match, rest) => /noGrp=/.test(rest) ? match : `<a:picLocks noGrp="1"${rest}/>`)
+            : next.replace(/<p:cNvPicPr\s*\/>/, '<p:cNvPicPr><a:picLocks noGrp="1"/></p:cNvPicPr>').replace(/<p:cNvPicPr>(?!<a:picLocks)/, '<p:cNvPicPr><a:picLocks noGrp="1"/>');
+        } else if (element === 'sp') {
+          next = next.replace(/<p:cNvSpPr\b([^>]*)\/>/, '<p:cNvSpPr$1><a:spLocks noGrp="1"/></p:cNvSpPr>');
+        } else if (element === 'graphicFrame') {
+          next = /<a:graphicFrameLocks\b[^>]*\/>/.test(next) ? next.replace(/<a:graphicFrameLocks\b([^>]*?)\s*\/>/, (match, rest) => /noGrp=/.test(rest) ? match : `<a:graphicFrameLocks noGrp="1"${rest}/>`)
+            : next.replace(/<p:cNvGraphicFramePr\s*\/>/, '<p:cNvGraphicFramePr><a:graphicFrameLocks noGrp="1"/></p:cNvGraphicFramePr>');
+        }
+        return next;
+      });
+    }
+    if (changed) write(slidePath, slideXml);
+  }
+  write('[Content_Types].xml', types);
+}
+
+// ---------------------------------------------------------------------------
+// Import
+
+function tagIdentityError(tag) {
+  if (!NAME.test(tag?.id ?? '') || !NAME.test(tag?.group ?? '')) return 'invalid id or group';
+  const reference = /^(?:([a-z][a-z0-9-]*):)?([a-z][a-z0-9-]*)$/.exec(tag.reference ?? '');
+  if (!reference || reference[2] !== tag.id || (reference[1] !== undefined && reference[1] !== tag.group)) return 'reference does not match id and group';
+  if (reference[1] === undefined && !['custom', 'default'].includes(tag.group)) return 'bare reference cannot name an external catalog';
+  if (tag.source !== undefined && (typeof tag.source !== 'string' || !/^(?:https:\/\/[^\s]+|pkg:[^\s]+)$/.test(tag.source))) return 'invalid catalog source';
+  if (tag.group === 'custom' && tag.source !== undefined) return 'custom catalog cannot have a source';
+  if (tag.group !== 'custom' && tag.source === undefined) return 'catalog source is missing';
+  return undefined;
+}
+
+/** The validated OPF_LAYOUT_V1 value of a slide layout part, or undefined. `report(message)` names a damaged tag. */
+export function readLayoutTag(entries, layoutPath, report = () => {}) {
+  if (!layoutPath || !entries[layoutPath]) return undefined;
+  const xml = dec.decode(entries[layoutPath]);
+  const rid = xml.match(/<\/p:spTree>\s*<p:custDataLst>([\s\S]*?)<\/p:custDataLst>/)?.[1]?.match(/<p:tags\b[^>]*\br:id="([^"]+)"/)?.[1];
+  if (!rid || !entries[relsOf(layoutPath)]) return undefined;
+  const rel = relationships(dec.decode(entries[relsOf(layoutPath)])).find(item => item.id === rid && item.type === `${REL}/tags` && !item.external);
+  const tagPath = rel && resolvePart(layoutPath, rel.target);
+  if (!tagPath || !entries[tagPath]) return undefined;
+  const tag = [...dec.decode(entries[tagPath]).matchAll(/<p:tag\b[^>]*\/>/g)].map(([node]) => node).find(node => attribute(node, 'name') === LAYOUT_TAG);
+  if (!tag) return undefined;
+  try {
+    const value = decodeTextTag(unescapeAttribute(attribute(tag, 'val') ?? ''));
+    if (value === null || typeof value !== 'object' || Array.isArray(value) || value.v !== 1) throw Error('unknown version');
+    const identityError = tagIdentityError(value);
+    if (identityError) throw Error(identityError);
+    if (typeof value.reference !== 'string' || !/^(?:[a-z][a-z0-9-]*:)?[a-z][a-z0-9-]*$/.test(value.reference) || typeof value.hash !== 'string') throw Error('invalid reference');
+    if (value.record !== undefined && (value.record === null || typeof value.record !== 'object' || Array.isArray(value.record))) throw Error('invalid record');
+    const regions = value.regions;
+    if (regions === null || typeof regions !== 'object' || Array.isArray(regions) || Object.keys(regions).length > MAX_REGIONS
+      || Object.entries(regions).some(([idx, name]) => !/^\d{1,4}$/.test(idx) || typeof name !== 'string' || !NAME.test(name) || name.length > 64)) throw Error('invalid regions');
+    return value;
+  } catch (error) {
+    report(`The OPF layout tag of ${layoutPath} is damaged (${error.message}); the slide layout is read as a foreign layout.`);
+    return undefined;
+  }
+}
+
+/** The region of a native slide object from its placeholder index, through the layout tag. */
+export function placeholderRegion(node, tag) {
+  if (!tag) return undefined;
+  const nv = node?.['p:nvSpPr'] ?? node?.['p:nvPicPr'] ?? node?.['p:nvGraphicFramePr'];
+  const idx = nv?.['p:nvPr']?.['p:ph']?.idx;
+  return idx === undefined ? undefined : tag.regions[String(idx)];
+}
+
+const bareId = reference => /^(?:([a-z][a-z0-9-]*):)?([a-z][a-z0-9-]*)$/.exec(reference ?? '');
+
+/**
+ * After document provenance: each slide's layout from its tagged slide layout, and the region pins of blocks read from region
+ * placeholders. `slides[i]` = {tag, blockRegions, restored}; `recordOf(index)` resolves the slide's layout record.
+ */
+export function applyTemplateLayouts(imported, slides, recordOf, report = () => {}, layoutTags = []) {
+  const usable = tag => {
+    const error = tagIdentityError(tag);
+    const existing = imported.catalogs?.[tag?.group];
+    const conflict = existing === false || (existing?.source !== undefined && existing.source !== tag.source);
+    if (!error && !conflict) return true;
+    report({code: 'invalid-layout-provenance', path: `catalogs.${tag?.group}`, message: `The PowerPoint layout tag was not restored (${error ?? 'catalog source conflicts with document provenance'}).`});
+    return false;
+  };
+  // Restore unused embedded templates only with consistent, schema-valid catalog provenance.
+  for (const tag of layoutTags) {
+    if (!tag?.record || !usable(tag) || recordHash(tag.record) !== tag.hash) continue;
+    if (imported.catalogs?.[tag.group]?.layouts?.[tag.id] !== undefined) continue;
+    if (!isTemplate(tag.record)) continue;
+    let valid = false;
+    try { valid = validateCatalogRecord('layouts', {$schema: 'https://openpresentation.org/schema/opf-layout/v2', id: tag.id, ...tag.record}).valid; } catch { valid = false; }
+    if (!valid) { report({code: 'invalid-layout-provenance', path: `catalogs.${tag.group}.layouts.${tag.id}`, message: `The layout record stored with the PowerPoint layout of ${tag.reference} does not validate; it was not restored.`}); continue; }
+    imported.catalogs = {...imported.catalogs, [tag.group]: {...(tag.source ? {source: tag.source} : {}), ...imported.catalogs?.[tag.group], layouts: {...imported.catalogs?.[tag.group]?.layouts, [tag.id]: structuredClone(tag.record)}}};
+  }
+  for (const [index, entry] of slides.entries()) {
+    const slide = imported.slides[index], tag = entry?.tag;
+    if (!slide || !tag || !usable(tag)) continue;
+    const qualified = bareId(tag.reference)?.[1];
+    if (qualified && tag.source && (!imported.catalogs?.[qualified] || typeof imported.catalogs[qualified] !== 'object'))
+      imported.catalogs = {...imported.catalogs, [qualified]: {source: tag.source}};
+    if (tag.id === 'auto' && entry.preservedAutomatic && (entry.storedLayout === undefined || entry.storedLayout === 'auto')) { if (entry.storedLayout === 'auto') slide.layout = 'auto'; continue; }
+    if (slide.layout === undefined) slide.layout = tag.reference;
+    else if (slide.layout !== tag.reference) {
+      const match = bareId(slide.layout);
+      const same = match && match[2] === tag.id && (match[1] === undefined || match[1] === tag.group);
+      if (!same) {
+        report({code: 'layout-changed', path: `slides.${index}.layout`, message: `The slide uses the PowerPoint layout of ${tag.reference} (Change Layout), not its stored layout ${slide.layout}; slides.${index}.layout is now ${tag.reference} and its content is bound by that layout.`});
+        slide.layout = tag.reference;
+      }
+    }
+    if (entry.restored || !Array.isArray(slide.blocks) || !entry.blockRegions?.some(Boolean)) continue;
+    let record;
+    try { record = recordOf(index); layoutTemplate(record); } catch { continue; }
+    const regions = new Map(layoutTemplate(record).regions.map(region => [region.name, region]));
+    for (const [position, name] of entry.blockRegions.entries()) {
+      const block = slide.blocks[position], region = regions.get(name);
+      if (!name || !region || !block || typeof block !== 'object' || block.region !== undefined || !regionAccepts(region, block)) continue;
+      const bound = bindRegions(slide, record, {slideIndex: index}).regions.find(item => [...item.blocks, ...item.overflow].some(node => node.block === position));
+      if (bound?.name !== name) block.region = name;
+    }
+  }
+}
+
+/** Map foreign PowerPoint layouts to available v2 built-ins; no layout reconstruction or migration aliases. */
+export function foreignLayoutReference(layout, catalogs = [gallery]) {
+  const types = {title: 'cover', secHead: 'section', obj: 'text', tx: 'text', twoObj: 'two-column', twoTxTwoObj: 'two-column', picTx: 'image-beside'};
+  const type = layout?.type;
+  if (type === 'blank' || type === 'titleOnly') return 'auto';
+  const options = catalogs === undefined ? {} : {catalogs};
+  // Use core's default catalog resolution: a same-id record in another host catalog must never supply a misleading name match.
+  const builtins = catalogRecords({}, 'layouts', options).filter(entry => entry.group === 'default' && isTemplate(entry.record))
+    .filter(entry => Object.hasOwn(POWERPOINT_LAYOUT_TYPES, entry.id) || ['image', 'gallery', 'chart', 'chart-beside', 'table', 'table-beside', 'code', 'pillars', 'process', 'timeline', 'quote', 'metrics', 'scorecard', 'hero', 'dashboard', 'team', 'logos', 'statement', 'closing'].includes(entry.id))
+    .filter(entry => resolveReference({}, 'layouts', `default:${entry.id}`, options)?.source === entry.source);
+  const id = types[type];
+  if (id) return builtins.some(entry => entry.id === id) ? `default:${id}` : undefined;
+  if (type === 'cust') {
+    const name = String(layout?.['p:cSld']?.name ?? '').trim().toLowerCase();
+    const matched = builtins.find(entry => entry.id.toLowerCase() === name || String(entry.record.name ?? '').trim().toLowerCase() === name);
+    return matched ? `default:${matched.id}` : 'auto';
+  }
+  return 'auto';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.18.2",
+  "version": "0.19.0",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -64,8 +64,9 @@
     "test:determinism": "node test/determinism.mjs"
   },
   "dependencies": {
+    "@openpresentation/gallery": "^2.0.0",
     "@node-projects/jszip": "4.3.0",
-    "@openpresentation/opf": "^0.18.4",
+    "@openpresentation/opf": "^0.19.0",
     "@rgrove/parse-xml": "4.2.3",
     "fast-xml-parser": "^5.8.0",
     "fflate": "^0.8.3",
@@ -73,7 +74,7 @@
     "sharp": "0.35.5"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.18.2"
+    "@openpresentation/opf-render": "^0.19.1"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -97,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.18.2",
+    "@openpresentation/opf-render": "0.19.1",
     "@resvg/resvg-js": "2.6.2",
     "esbuild": "0.28.2",
     "playwright": "1.63.0"