@openpresentation/opf-render 0.13.1 → 0.15.0

package/dist/svg.js

@@ -1,15 +1,25 @@
-import { layoutTable, fitList, fitRichText, composeSlide, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, textWidthMeasurer, fitText, textColorForFill, chartColorForFill } from "@openpresentation/opf/composition";
+// The layout engine lives in core's `/composition` entry. Every name is a static import, so a core without one fails to
+// load instead of switching a feature (script fonts, right-to-left, patterns, code colours, trend arrows) off.
 import {
-  catalogs as bundledCatalogs,
-  resolveColorRef as resolveCoreColorRef,
-  validatePresentation
+  layoutTable, fitList, fitRichText, composeSlide, resolveTextStyle, textWidthMeasurer, fitText, textColorForFill, chartColorForFill,
+  resolveColorRef as resolveCoreColorRef, resolveScriptFonts, paragraphDirection, physicalAlignment, patternRuns,
+  metricTrendMark as coreMetricTrendMark, tokenizeCode, codeLineRuns, codeSyntaxPaletteForScheme, resolveChartData,
+  resolveColorRoles, defaultSlideBackground, timelineMarkerShapes, timelineTextColor, layoutWatermark,
+  codeHighlightLines, codeLineNumbers, codeHighlightBands, codeHighlightColors, fitImage, intrinsicImageAspect, intrinsicImageSize,
+  ENGINE_DEFAULT_THEME, ENGINE_DEFAULT_COLOR_SCHEME, ENGINE_DEFAULT_FONT_SCHEME, ENGINE_DEFAULT_CHART_TYPES
+} from "@openpresentation/opf/composition";
+// The renderer is a library: it never imports a catalog. Hosts register theirs (`options.catalogs`, core `Catalog[]`, for
+// example `defaultCatalog` from `@openpresentation/opf/catalog`) and core resolves every reference against them.
+import {
+  hasContentVariables,
+  isTemplate,
+  resolveSlideContext,
+  resolveVariables,
+  validate
 } from "@openpresentation/opf";
-// Optional core exports are read from the namespace so an older published core
-// still loads; resolveScriptFonts ships with core FF-18.
-import * as opfCore from "@openpresentation/opf";
 import { adjustedFontSize, baselineShift, createScriptFonts } from "./script-fonts.js";
 import { disabledFeaturesStyle } from "./font-compatibility.js";
-import { fontPolicyFor } from "./font-policy.js";
+import { fontPolicyFor } from "@openpresentation/opf/font-policy";
 import { isDatasetChart, isDatasetTable, renderCatalogChart } from "./charts.js";
 import { renderCaption, renderFootnotes } from "./annotations.js";
 
@@ -29,49 +39,26 @@ export const runtimePolicy = Object.freeze({
   deterministicLocalExecution: true
 });
 
+// What draws when nothing resolves: core's engine defaults (OPF 0.15 ships no catalog records), and the chart type a chart
+// without one previews as.
 export const engineDefaults = Object.freeze({
-  catalogs: Object.freeze({
-    narratives: Object.freeze({ source: "https://www.pptx.gallery/narratives" }),
-    themes: Object.freeze({ source: "https://www.pptx.gallery/themes" }),
-    colorSchemes: Object.freeze({ source: "https://www.pptx.gallery/color-schemes" }),
-    fontSchemes: Object.freeze({ source: "https://www.pptx.gallery/font-schemes" }),
-    languages: Object.freeze({ source: "https://www.pptx.gallery/languages" }),
-    layouts: Object.freeze({ source: "https://www.pptx.gallery/layouts" }),
-    chartTypes: Object.freeze({ source: "https://www.pptx.gallery/chart-types" }),
-    tones: Object.freeze({ source: "https://www.pptx.gallery/tones" }),
-    audiences: Object.freeze({ source: "https://www.pptx.gallery/audiences" }),
-    socialPlatforms: Object.freeze({ source: "https://www.pptx.gallery/social-platforms" })
-  }),
-  theme: "minimal",
-  colorScheme: "cool-horizon",
-  language: "english",
-  narrative: "classic-story",
-  tone: "formal",
-  audience: "executives",
-  fontScheme: Object.freeze({
-    pptx: Object.freeze({ latin: "aptos", ea: "microsoft-yahei", cs: "nirmala-ui" }),
-    google: Object.freeze({ latin: "roboto", ea: "noto-sans-sc", cs: "noto-sans" })
-  }),
-  chartTypes: Object.freeze([
-    "stacked-column-3x",
-    "stacked-area-3x",
-    "line-with-markers-3x"
-  ])
+  theme: ENGINE_DEFAULT_THEME,
+  colorScheme: ENGINE_DEFAULT_COLOR_SCHEME,
+  fontScheme: ENGINE_DEFAULT_FONT_SCHEME,
+  chartType: ENGINE_DEFAULT_CHART_TYPES[0]
 });
 
-// Last-resort font scheme shared by every engine (core pagination, opf-editor and
-// opf-pptx): DEFAULT_FONT_SCHEME in @openpresentation/opf. It applies only when the
-// slide, deck and resolved theme name no font scheme. fontScheme.google is kept for a
-// future Google Slides target and is not used by this renderer.
-const DEFAULT_FONT_SCHEME = engineDefaults.fontScheme.pptx.latin;
-
+/**
+ * `details.findings` (`invalid-opf`) are the error findings of core `validate`; `details.diagnostics` hold the
+ * layout or variable diagnostics that explain the other codes. `findings` and `path` are also set on the error.
+ */
 export class OPFRenderError extends Error {
   constructor(code, message, details = {}) {
     super(message);
     this.name = "OPFRenderError";
     this.code = code;
     this.details = details;
-    if (details.issues) this.issues = details.issues;
+    if (details.findings) this.findings = details.findings;
     if (details.path) this.path = details.path;
   }
 }
@@ -158,7 +145,6 @@ const FIELD_TYPE = Object.freeze({
 });
 
 const DEFAULT_DIMENSIONS = { width: 1280, height: 720 };
-const DEFAULT_SOURCE_PREFIX = "https://www.pptx.gallery/";
 
 
 function parseInput(input) {
@@ -186,39 +172,40 @@ function parseInput(input) {
 // Template variables (core resolveVariables, RR-32): a deck that uses content variables, or a template, is resolved
 // to a concrete deck before composition, so the preview and the PPTX exporter see the same text, numbers, dates and
 // images. A template previews with each unfilled variable's example; a normal deck with an unfilled required
-// variable is refused. Decks without content variables are returned untouched. Read from the namespace so an older
-// published core still loads.
+// variable is refused. Decks without content variables are returned untouched.
 function resolveTemplateInput(presentation, options) {
-  if (typeof opfCore.resolveVariables !== "function" || !isPlainObject(presentation)) return presentation;
+  if (!isPlainObject(presentation)) return presentation;
   const values = options.variables;
   // variables: false draws the document as authored, tokens and var: references included (the template editing view).
   if (values === false) return presentation;
   if (values !== undefined && !isPlainObject(values)) {
     throw new OPFRenderError("invalid-variables", "The variables option must be an object keyed by variable id.", { path: "options.variables" });
   }
-  const template = opfCore.isTemplate(presentation);
-  if (!template && !opfCore.hasContentVariables(presentation) && !(values && Object.keys(values).length)) return presentation;
-  const result = opfCore.resolveVariables(presentation, values ?? {}, { examples: template });
+  const template = isTemplate(presentation);
+  if (!template && !hasContentVariables(presentation) && !(values && Object.keys(values).length)) return presentation;
+  const result = resolveVariables(presentation, values ?? {}, { examples: template });
   const errors = result.diagnostics.filter((entry) => entry.severity === "error");
   if (errors.length) {
     const unfilled = errors.some((entry) => entry.code === "variable-unfilled");
     throw new OPFRenderError(unfilled ? "unfilled-variables" : "invalid-variables", errors[0].message, {
-      issues: errors,
+      diagnostics: errors,
       path: errors[0].path
     });
   }
   for (const entry of result.diagnostics) {
-    if (entry.code === "variable-example-used") options.onDiagnostic?.({ code: "variable-example-used", path: entry.path, message: entry.message, id: entry.id });
+    if (entry.code === "variable-example-used" || entry.code === "variable-builtin-missing") options.onDiagnostic?.({ code: entry.code, path: entry.path, message: entry.message, id: entry.id });
   }
   return result.presentation;
 }
 
-function assertValidBoundary(presentation) {
-  const result = validatePresentation(presentation);
-  if (!result.valid) {
+// The boundary check is the format check only (schema and the cross-field rules a schema cannot say): layout, accessibility
+// and content findings are `validate`'s job, and drawing a slide reports what it cannot fit.
+function assertValidBoundary(presentation, options) {
+  const report = validate(presentation, { only: ["format"], ...(options.catalogs !== undefined ? { catalogs: options.catalogs } : {}) });
+  if (!report.valid) {
     throw new OPFRenderError("invalid-opf", "OPF validation failed.", {
-      issues: result.errors,
-      result
+      findings: report.findings.filter((finding) => finding.severity === "error"),
+      report
     });
   }
 }
@@ -239,123 +226,6 @@ function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
-function referenceId(reference) {
-  if (typeof reference === "string") return reference;
-  if (isPlainObject(reference) && typeof reference.id === "string") return reference.id;
-  return null;
-}
-
-function normalizeSourceRecords(value) {
-  if (!value) return [];
-  if (Array.isArray(value)) return value;
-  if (Array.isArray(value.records)) return value.records;
-  return [];
-}
-
-function findById(records, id) {
-  return records.find((record) => record && record.id === id) ?? null;
-}
-
-function defaultCatalogFor(kind) {
-  return Array.isArray(bundledCatalogs[kind]) ? bundledCatalogs[kind] : [];
-}
-
-// CatalogEntry.source is one source or an ordered search path (first match wins; the
-// default catalog is appended by the callers). An array concatenates each source's
-// records in order, so the findById chain keeps the first match. Non-string entries are
-// ignored. Nothing is fetched: a source resolves from options.catalogSources or, for the
-// bundled default prefixes, from the bundled snapshot.
-function sourceRecordsFor(kind, source, options) {
-  if (Array.isArray(source)) return source.flatMap((entry) => sourceRecordsFor(kind, entry, options));
-  if (typeof source !== "string" || !source) return [];
-  const bySource = options.catalogSources?.[source];
-  if (bySource) return normalizeSourceRecords(bySource);
-  if (source.startsWith(DEFAULT_SOURCE_PREFIX) || source.startsWith("pkg:@openpresentation/opf/")) {
-    return defaultCatalogFor(kind);
-  }
-  return [];
-}
-
-function engineDefaultId(kind) {
-  if (kind === "fontSchemes") return DEFAULT_FONT_SCHEME;
-  if (kind === "chartTypes") return engineDefaults.chartTypes[0];
-  const key = kind.endsWith("s") ? kind.slice(0, -1) : kind;
-  return engineDefaults[key];
-}
-
-function findCatalogRecord(kind, id, context) {
-  if (!id) return null;
-  const documentCatalog = context.presentation.catalogs?.[kind];
-  return findById(normalizeSourceRecords(documentCatalog), id) ??
-    findById(sourceRecordsFor(kind, documentCatalog?.source, context.options), id) ??
-    findById(normalizeSourceRecords(context.options.catalogs?.[kind]), id) ??
-    findById(sourceRecordsFor(kind, engineDefaults.catalogs[kind]?.source, context.options), id) ??
-    findById(defaultCatalogFor(kind), id);
-}
-
-// Font schemes follow the shared core rule (resolveFontSchemeReference in
-// @openpresentation/opf): an id that matches no record reports one
-// `unresolved-font-scheme` diagnostic and uses the DEFAULT_FONT_SCHEME record as the
-// base, with sibling overrides on top, so preview and PPTX export use the same fonts.
-function resolveFontSchemeRecord(reference, context, path) {
-  const id = referenceId(reference);
-  const found = findCatalogRecord("fontSchemes", id, context);
-  const base = found ?? findCatalogRecord("fontSchemes", DEFAULT_FONT_SCHEME, context) ?? {};
-  const scheme = cloneWithSortedKeys(isPlainObject(reference) ? { ...base, ...reference } : base);
-  if (!id || found) return { scheme };
-  return { scheme, diagnostic: { code: "unresolved-font-scheme", path, id, fallback: DEFAULT_FONT_SCHEME, message: `Font scheme '${id}' is not in the inline or bundled catalogs; using the default font scheme '${DEFAULT_FONT_SCHEME}'.` } };
-}
-
-// Generated socials furniture formats handles in core. Core applies inline
-// document records first; the host supplies the rest in resolution order.
-function socialPlatformRecords(context) {
-  const kind = "socialPlatforms";
-  return [
-    ...sourceRecordsFor(kind, context.presentation.catalogs?.[kind]?.source, context.options),
-    ...normalizeSourceRecords(context.options.catalogs?.[kind]),
-    ...sourceRecordsFor(kind, engineDefaults.catalogs[kind]?.source, context.options),
-    ...defaultCatalogFor(kind)
-  ];
-}
-
-function resolveCatalogRecord(kind, reference, context, path, fallbackId = engineDefaultId(kind)) {
-  const id = referenceId(reference) ?? fallbackId;
-  const documentCatalog = context.presentation.catalogs?.[kind];
-  const documentRecords = normalizeSourceRecords(documentCatalog);
-  const injectedRecords = normalizeSourceRecords(context.options.catalogs?.[kind]);
-  const documentSource = documentCatalog?.source;
-  const sourceRecords = sourceRecordsFor(kind, documentSource, context.options);
-  const defaultSource = engineDefaults.catalogs[kind]?.source;
-  const engineSourceRecords = sourceRecordsFor(kind, defaultSource, context.options);
-  const defaultRecords = defaultCatalogFor(kind);
-
-  const record =
-    (id ? findById(documentRecords, id) : null) ??
-    (id ? findById(sourceRecords, id) : null) ??
-    (id ? findById(injectedRecords, id) : null) ??
-    (id ? findById(engineSourceRecords, id) : null) ??
-    (id ? findById(defaultRecords, id) : null);
-
-  if (record) {
-    return isPlainObject(reference)
-      ? cloneWithSortedKeys({ ...record, ...reference })
-      : cloneWithSortedKeys(record);
-  }
-
-  if (isPlainObject(reference)) {
-    return cloneWithSortedKeys(reference);
-  }
-
-  throw new OPFRenderError("catalog-resolution-failed", `Could not resolve ${kind} reference '${id}'.`, {
-    kind,
-    id,
-    path,
-    source: documentSource ?? defaultSource ?? null
-  });
-}
-
-const resolveDimensions = resolveCanvasDimensions;
-
 function colorFromScheme(scheme, slot, fallback) {
   if (!slot) return fallback;
   if (typeof slot === "string") {
@@ -421,14 +291,20 @@ function resolveBackgroundColor(value, design, fallback) {
   return resolveColorRefIn(value, { colorScheme: design.colorScheme, colors: { primary, secondary, accent }, variables: design.variables }, fallback);
 }
 
+// Image sources the background string shorthand accepts (a cover image); any other string is a theme slot or a hex colour.
+const IMAGE_BACKGROUND_SOURCE = /^(asset:|https:\/\/|data:|\.\/|\.\.\/)/;
+
+// The slide's single background color, or null when there is none (a gradient, or no color the engine can read).
+// With no definition, or a picture, the scheme's default slide background (core defaultSlideBackground) is the canvas.
 function resolveBackground(background, colorScheme, design) {
-  if (!background) return colorFromScheme(colorScheme, "light1", "#FFFFFF");
-  if (typeof background === "string") return colorFromScheme(colorScheme, background, "#FFFFFF");
-  if (background.type === "theme") return colorFromScheme(colorScheme, background.slot, "#FFFFFF");
+  const canvas = defaultSlideBackground(colorScheme);
+  if (!background) return canvas;
+  if (typeof background === "string") return IMAGE_BACKGROUND_SOURCE.test(background) ? canvas : colorFromScheme(colorScheme, background, canvas);
+  if (background.type === "theme") return colorFromScheme(colorScheme, background.slot, canvas);
   if (background.type === "solid") return resolveBackgroundColor(background.color, design, "#FFFFFF");
   if (background.type === "gradient") return null;
   if (background.type === "pattern") return resolveBackgroundColor(background.pattern?.backgroundColor, design, "#FFFFFF");
-  return colorFromScheme(colorScheme, "light1", "#FFFFFF");
+  return canvas;
 }
 
 
@@ -456,40 +332,30 @@ function tagFill(design) {
   return contrastRatio(design.colors.primary, background) < TAG_MIN_CONTRAST ? design.colors.text : design.colors.primary;
 }
 
-function resolveDesign(presentation, slide, context, index) {
+const LINK_URL = /^(https?:|mailto:|tel:)/i;
+
+// What the renderer paints with, from the records core's `resolveSlideContext` resolved (slide design, then deck design, then
+// theme, then the engine default, per field: the one order every engine uses). The theme and the colour scheme keep their
+// sorted keys, so the output does not depend on the order a catalog lists a field in. A reference that resolves nowhere never
+// throws (unless `strictReferences`): the context falls back to core's engine defaults (ENGINE_DEFAULT_THEME, _COLOR_SCHEME,
+// _FONT_SCHEME; a layout to automatic composition) and reports `unresolved-reference`, which is forwarded as a render diagnostic.
+function resolveDesign(presentation, slide, slideContext) {
   const deckDesign = presentation.design ?? {};
   const slideDesign = slide.design ?? {};
-
-  const theme = resolveCatalogRecord(
-    "themes",
-    slideDesign.theme ?? deckDesign.theme ?? engineDefaults.theme,
-    context,
-    "design.theme"
-  );
-  const colorScheme = resolveCatalogRecord(
-    "colorSchemes",
-    slideDesign.colorScheme ?? deckDesign.colorScheme ?? theme.colorScheme ?? engineDefaults.colorScheme,
-    context,
-    "design.colorScheme"
-  );
-  const fontPath = slideDesign.fontScheme !== undefined ? `slides.${index}.design.fontScheme`
-    : deckDesign.fontScheme !== undefined ? "design.fontScheme"
-    : slideDesign.theme !== undefined ? `slides.${index}.design.theme` : "design.theme";
-  const { scheme: fontScheme, diagnostic: fontSchemeDiagnostic } = resolveFontSchemeRecord(
-    slideDesign.fontScheme ?? deckDesign.fontScheme ?? theme.fontScheme ?? DEFAULT_FONT_SCHEME,
-    context,
-    fontPath
-  );
-  const dimensions = resolveDimensions(slideDesign.dimensions ?? deckDesign.dimensions ?? theme.dimensions);
+  const { options: composeOptions, diagnostics, resolved } = slideContext;
+  const theme = cloneWithSortedKeys(resolved.theme);
+  const colorScheme = cloneWithSortedKeys(resolved.colorScheme);
+  const fontScheme = cloneWithSortedKeys(resolved.fontScheme);
+  const dimensions = { width: composeOptions.width, height: composeOptions.height };
   const backgroundDefinition = slideDesign.background ?? deckDesign.background ?? theme.background;
-  const primary = normalizeColor(colorScheme.primary, null) ?? colorFromScheme(colorScheme, "accent1", "#2563EB");
-  const secondary = normalizeColor(colorScheme.secondary, null) ?? colorFromScheme(colorScheme, "accent2", "#0F766E");
-  const accent = normalizeColor(colorScheme.accent, null) ?? colorFromScheme(colorScheme, "accent3", "#F59E0B");
+  const { primary, secondary, accent } = resolveColorRoles(colorScheme);
   const variables = presentation.variables ?? {};
   // background/surface/text roles depend on the background itself, so a background reference sees only the scheme and the three accent roles.
   const backgroundColor = resolveBackground(backgroundDefinition, colorScheme, { colorScheme, colors: { primary, secondary, accent }, variables });
-  const darkBackground = colorLuminance(backgroundColor ?? "#FFFFFF") < 0.179;
-  const textColor = colorFromScheme(colorScheme, darkBackground ? "light1" : "dark1", darkBackground ? "#FFFFFF" : "#111827");
+  // One resolution for every role (core resolveColorRoles), shared with the PPTX export and the validator. Whether the background is dark
+  // (relative luminance under 0.179) is core's decision in the slide context, the one composition uses for logos and bullets.
+  const roles = resolveColorRoles(colorScheme, { background: backgroundColor });
+  const darkBackground = composeOptions.darkBackground === true;
 
   return {
     ...deckDesign,
@@ -502,18 +368,20 @@ function resolveDesign(presentation, slide, context, index) {
     background: backgroundDefinition,
     backgroundColor,
     colors: {
-      background: colorFromScheme(colorScheme, "light1", "#FFFFFF"),
-      surface: colorFromScheme(colorScheme, darkBackground ? "dark2" : "light2", darkBackground ? "#1E293B" : "#F8FAFC"),
-      text: textColor,
-      mutedText: colorFromScheme(colorScheme, darkBackground ? "light2" : "dark2", darkBackground ? "#E2E8F0" : "#334155"),
+      background: roles.background,
+      surface: roles.surface,
+      text: roles.text,
+      mutedText: roles.textSecondary,
       primary,
       secondary,
       accent,
+      hyperlink: roles.hyperlink,
+      followedHyperlink: roles.followedHyperlink,
       border: colorFromScheme(colorScheme, "accent5", "#CBD5E1")
     },
-    fonts: resolveFontFamilies(fontScheme),
+    fonts: { ...composeOptions.fontFamilies },
     darkBackground,
-    diagnostics: fontSchemeDiagnostic ? [fontSchemeDiagnostic] : []
+    diagnostics: diagnostics.map((entry) => ({ ...entry }))
   };
 }
 
@@ -521,23 +389,14 @@ function resolveDesign(presentation, slide, context, index) {
  * Script font slots, language tags and direction for one slide from core
  * `resolveScriptFonts` (FF-18). The latin slot is always the renderer's design
  * font; a script slot that core fills from the latin family follows it too.
- * Without core support every slot repeats the latin family.
+ * A language core cannot resolve is reported (`language-preview-unresolved`) and every slot repeats the latin family.
  */
-function scriptProfile(presentation, index, design, context) {
+function scriptProfile(presentation, index, design, context, language) {
   let resolved;
-  if (typeof opfCore.resolveScriptFonts === "function") {
-    try { resolved = opfCore.resolveScriptFonts(presentation, { slideIndex: index }); }
-    catch (error) {
-      reportLanguageDiagnostic(context, { code: "language-preview-unresolved", path: "language",
-        message: "Script fonts could not be resolved (" + (error instanceof Error ? error.message : String(error)) + "), so the preview uses the design font for every script, sets no lang and lays out every paragraph left to right." });
-    }
-  } else if (presentation.language !== undefined) {
-    reportLanguageDiagnostic(context, { code: "language-preview-unavailable", path: "language",
-      message: "The installed @openpresentation/opf has no resolveScriptFonts (FF-18), so the preview uses the design font for every script, sets no lang and lays out every paragraph left to right. Use a core release with the language model." });
-  }
-  if (resolved?.rtl === true && typeof opfCore.paragraphDirection !== "function") {
-    reportLanguageDiagnostic(context, { code: "paragraph-direction-unavailable", path: "language",
-      message: "The installed @openpresentation/opf has no paragraphDirection, so the preview lays out every paragraph of this right-to-left deck left to right, as the PPTX export does. Use a core release that exports it." });
+  try { resolved = resolveScriptFonts(presentation, { slideIndex: index, ...(context.options.catalogs !== undefined ? { catalogs: context.options.catalogs } : {}), ...(language === undefined ? {} : { language }) }); }
+  catch (error) {
+    reportLanguageDiagnostic(context, { code: "language-preview-unresolved", path: "language",
+      message: "Script fonts could not be resolved (" + (error instanceof Error ? error.message : String(error)) + "), so the preview uses the design font for every script, sets no lang and lays out every paragraph left to right." });
   }
   const slots = role => {
     const latin = design.fonts[role];
@@ -594,33 +453,6 @@ function reportGlyphFallback(context, note) {
   });
 }
 
-function inferLayoutId(slide) {
-  if (slide.layout) return slide.layout;
-  if (slide.blocks?.length) return "blank";
-  if (PROMOTED_REGION_KEYS.some((key) => key in slide)) return "blank";
-  if (slide.chart) return "chart-1x";
-  if (slide.table) return "table-1x";
-  if (slide.image) return "image-1x";
-  if (slide.video) return "media-1x";
-  // Unspecified code layout uses the same automatic flow as core pagination
-  // and PPTX export. An explicit code-1x preset still reserves its own slots.
-  if (slide.code !== undefined) return "blank";
-  if (slide.items || slide.bullets) return "list-1x";
-  if (slide.text || slide.metric || slide.quote || slide.timeline) return "text-1x";
-  if (slide.subtitle) return "title-subtitle";
-  return "title";
-}
-
-function resolveLayout(slide, context, index) {
-  const layoutId = inferLayoutId(slide);
-  try {
-    return resolveCatalogRecord("layouts", layoutId, context, `slides.${index}.layout`);
-  } catch (error) {
-    if (error instanceof OPFRenderError && isPlainObject(slide.layout)) return slide.layout;
-    throw error;
-  }
-}
-
 function contentPayloadFromHost(host, path, slot) {
   if (!isPlainObject(host)) {
     return { type: "text", field: "text", value: host, slot: slot ?? "text", path };
@@ -687,9 +519,37 @@ function normalizeFutureContent(slide, slidePath) {
   });
 }
 
-function bindSlide(presentation, slide, layout, index, context) {
+// The core catalog options every resolution takes: the host's catalogs, unchanged, and its strict reference policy.
+function catalogOptions(options) {
+  return { ...(options.catalogs !== undefined ? { catalogs: options.catalogs } : {}), ...(options.strictReferences === true ? { strictReferences: true } : {}) };
+}
+
+function resolveContext(presentation, index, context) {
+  try {
+    return resolveSlideContext(presentation, index, {
+      fonts: { textMeasurement: context.options.textMeasurement },
+      ...catalogOptions(context.options),
+      date: context.options.date
+    });
+  } catch (error) {
+    // Strict references: core refuses a reference that resolves nowhere (OPFUnresolvedReferenceError) instead of falling back.
+    if (Array.isArray(error?.diagnostics) && error.diagnostics.some(entry => entry?.code === "unresolved-reference")) {
+      throw new OPFRenderError("unresolved-reference", error.message, { diagnostics: error.diagnostics, path: error.diagnostics[0].path, cause: error.message });
+    }
+    throw error;
+  }
+}
+
+function bindSlide(presentation, slide, index, context) {
   const slidePath = `slides.${index}`;
-  const placeholders = Array.isArray(layout.placeholders) ? layout.placeholders : [];
+  // Core resolves the slide's canvas, layout, theme, colour scheme, font scheme and family names the one way every engine must
+  // (slide design, deck design, theme, engine default), from the records the document embeds and the catalogs the host
+  // registered (`options.catalogs`, passed unchanged); `fonts` carries the measurement the host loaded. A slide with no
+  // `layout` composes automatically; one whose reference resolves nowhere does too, with an `unresolved-reference` diagnostic,
+  // or the render fails under `strictReferences`.
+  const slideContext = resolveContext(presentation, index, context);
+  const layout = slideContext.options.layout;
+  const placeholders = Array.isArray(layout?.placeholders) ? layout.placeholders : [];
   const titleBindings = [];
 
   for (let i = 0; i < placeholders.length; i += 1) {
@@ -715,15 +575,38 @@ function bindSlide(presentation, slide, layout, index, context) {
   ];
   const blocks = blockContent(slide, slidePath);
 
-  const design = resolveDesign(presentation, slide, context, index);
+  const design = resolveDesign(presentation, slide, slideContext);
   // Script fonts (FF-19): each text run is measured and drawn with its script
   // slot's face; the latin slot stays the design font scheme's family.
   const scriptFonts = createScriptFonts(scriptProfile(presentation, index, design, context), context.options.textMeasurement, {
     glyphFallback: context.options.glyphFallback,
     onFallback: note => reportGlyphFallback(context, note)
   });
-  const textMeasurement = scriptFonts.textMeasurement ?? context.options.textMeasurement;
-  // fontScheme.accent (the tag and quote text) exists only with a core that resolves it; it takes the same look-alike policy.
+  // FA-13: a run with its own language (TextRun.lang, which core puts on the fragment style as `lang`) is measured and drawn with the
+  // script fonts of that language (the Japanese or the Simplified Chinese face for Han text); every other run uses the deck's.
+  const languageScripts = new Map();
+  const scriptFontsFor = lang => {
+    if (typeof lang !== "string" || !lang) return undefined;
+    if (!languageScripts.has(lang)) {
+      let own;
+      try {
+        const profile = scriptProfile(presentation, index, design, context, lang);
+        own = profile.languageSource === "option" && profile.bcp47?.toLowerCase() !== scriptFonts.profile?.bcp47?.toLowerCase()
+          ? createScriptFonts(profile, context.options.textMeasurement, { glyphFallback: context.options.glyphFallback, onFallback: note => reportGlyphFallback(context, note) })
+          : undefined;
+      } catch { own = undefined; }
+      languageScripts.set(lang, own);
+    }
+    return languageScripts.get(lang);
+  };
+  let textMeasurement = scriptFonts.textMeasurement ?? context.options.textMeasurement;
+  if (scriptFonts.textMeasurement) {
+    const deckMeasurement = scriptFonts.textMeasurement;
+    const pick = style => scriptFontsFor(style?.lang)?.textMeasurement ?? deckMeasurement;
+    textMeasurement = { ...deckMeasurement, measure: (text, size, style) => pick(style).measure(text, size, style) };
+    if (typeof deckMeasurement.outlineBounds === "function") textMeasurement.outlineBounds = (text, size, style) => (pick(style).outlineBounds ?? deckMeasurement.outlineBounds)(text, size, style);
+  }
+  // fontScheme.accent (the tag and quote text) takes the same look-alike policy.
   // RR-17 (FF-41): a family that names its weight (Arial Black, Segoe UI Semibold and Light) keeps its own name through composition, so each run
   // resolves it again and draws the replacement's encoded weight (Montserrat 900, Red Hat Display 600 and 300); resolving the role to the
   // replacement family first would draw every run at 400 or 700 and measure it that way. Every other family resolves once, here.
@@ -731,9 +614,10 @@ function bindSlide(presentation, slide, layout, index, context) {
     const named = design.fonts[role], resolved = resolveTextStyle({fontFamily:named,fontWeight:role === "heading" ? 700 : 400},textMeasurement).fontFamily;
     design.fonts[role] = fontPolicyFor(named)?.replacement?.weight !== undefined && resolved.toLowerCase() !== named.toLowerCase() ? named : resolved;
   }
-  const geometry = composeSlide(slide, { ...design.dimensions, layout, presentation, slideIndex: index, fonts: design.fonts, contentAlignment:design.contentAlignment, titleAlignment:design.titleAlignment, textRasterPadding:context.options.textRasterPadding, contentBox:design.contentBox, darkBackground: design.darkBackground, textMeasurement, date: context.options.date, socialPlatforms: socialPlatformRecords(context) });
+  const geometry = composeSlide(slide, { ...slideContext.options, fontFamilies: design.fonts, textRasterPadding:context.options.textRasterPadding, textMeasurement });
   return {
     scriptFonts,
+    scriptFontsFor,
     textMeasurement,
     geometry,
     assets: presentation.assets ?? {},
@@ -750,17 +634,29 @@ function bindSlide(presentation, slide, layout, index, context) {
   };
 }
 
+// `options.fonts` is the handle `loadFonts()` returns (or any object with a `textMeasurement` and, to embed faces in the SVG, an
+// `embeddedFonts` list). The renderer reads the two as plain options from here on.
+function normalizeOptions(options) {
+  const { fonts, ...rest } = options ?? {};
+  return { ...rest, textMeasurement: fonts?.textMeasurement, embeddedFonts: fonts?.embeddedFonts };
+}
+
+/**
+ * Resolve a presentation for drawing: template variables filled, the boundary check passed, and every slide bound to its
+ * layout, design, script fonts and composed geometry. `renderSvg` and `renderSlideSvg` draw from this.
+ */
 export function resolvePresentation(input, options = {}) {
+  return resolveDeck(input, normalizeOptions(options));
+}
+
+function resolveDeck(input, options) {
   const presentation = resolveTemplateInput(parseInput(input), options);
   if (options.validate !== false) {
-    assertValidBoundary(presentation);
+    assertValidBoundary(presentation, options);
   }
 
   const context = { presentation, options };
-  const slides = presentation.slides.map((slide, index) => {
-    const layout = resolveLayout(slide, context, index);
-    return bindSlide(presentation, slide, layout, index, context);
-  });
+  const slides = presentation.slides.map((slide, index) => bindSlide(presentation, slide, index, context));
 
   return {
     presentation,
@@ -769,21 +665,28 @@ export function resolvePresentation(input, options = {}) {
   };
 }
 
+/**
+ * The SVG of every slide of the deck, in order. `skipHidden: true` leaves out slides marked `hidden` (the sequence the player
+ * presents); the result is then shorter than the deck, so an index no longer names the slide at that index.
+ */
 export function renderSvg(input, options = {}) {
-  const resolved = resolvePresentation(input, options);
-  const slideIndex = options.slideIndex ?? 0;
-  if (!Number.isInteger(slideIndex) || slideIndex < 0 || slideIndex >= resolved.slides.length) {
-    throw new OPFRenderError("slide-index-out-of-range", `Slide index ${slideIndex} is out of range.`, {
-      slideIndex,
+  const drawn = normalizeOptions(options);
+  const resolved = resolveDeck(input, drawn);
+  const indexes = resolved.slides.map((_, index) => index).filter(index => !(options.skipHidden === true && resolved.presentation.slides[index]?.hidden === true));
+  return indexes.map(index => renderResolvedSlide(resolved, index, drawn));
+}
+
+/** The SVG of one slide of the deck (a zero-based index). */
+export function renderSlideSvg(input, index, options = {}) {
+  const drawn = normalizeOptions(options);
+  const resolved = resolveDeck(input, drawn);
+  if (!Number.isInteger(index) || index < 0 || index >= resolved.slides.length) {
+    throw new OPFRenderError("slide-index-out-of-range", `Slide index ${index} is out of range.`, {
+      slideIndex: index,
       slideCount: resolved.slides.length
     });
   }
-  return renderResolvedSlide(resolved, slideIndex, options);
-}
-
-export function renderSvgDeck(input, options = {}) {
-  const resolved = resolvePresentation(input, options);
-  return resolved.slides.map((_, index) => renderResolvedSlide(resolved, index, options));
+  return renderResolvedSlide(resolved, index, drawn);
 }
 
 function renderResolvedSlide(resolved, slideIndex, options) {
@@ -794,10 +697,10 @@ function renderResolvedSlide(resolved, slideIndex, options) {
   // Only a language the document names sets lang; the renderer default does not.
   const lang = script?.languageSource === "document" || script?.languageSource === "option" ? script.bcp47 : undefined;
   const { width, height } = bound.design.dimensions;
-  const title = bound.slide.title ?? resolved.presentation.name ?? `Slide ${slideIndex + 1}`;
+  // The title may be TextRun[] (FA-10): the accessible name is its plain text.
+  const title = (Array.isArray(bound.slide.title) ? flattenText(bound.slide.title) : bound.slide.title) ?? resolved.presentation.name ?? `Slide ${slideIndex + 1}`;
   const content = [
     renderBackground(bound, width, height, options),
-    renderSlideImage(bound, options),
     renderBranding(bound, resolved.presentation, width, height, options),
     ...renderSlideContent(bound, width, height, options),
     // RR-34: the footnote area core reserved above the footer band, after the content and before the furniture.
@@ -833,6 +736,8 @@ function renderResolvedSlide(resolved, slideIndex, options) {
 
 function renderBackground(bound, width, height, options) {
   const background = bound.design.background;
+  // An image background (core SlideComposition.backgroundImage) fills the canvas and moves nothing.
+  if (bound.geometry.backgroundImage) return renderBackgroundImage(bound.geometry.backgroundImage, bound, width, height, options);
   if (isPlainObject(background) && background.type === "gradient") {
     const id = `opf-s${bound.index + 1}-background`;
     const stops = Array.isArray(background.gradient?.stops) ? background.gradient.stops : [];
@@ -861,25 +766,12 @@ function renderBackground(bound, width, height, options) {
       })
     ].join("\n");
   }
-
-  if(isPlainObject(background) && background.type==='image'){
-    const imageItem={value:background.image,path:`${bound.path}.design.background.image`};
-    if(background.image.fit==='tile'){
-      const size=Math.min(width,height)/4,id=`opf-s${bound.index+1}-image-tile`;
-      return tag('g',{opacity:background.opacity??1},tag('defs',{},tag('pattern',{id,width:size,height:size,patternUnits:'userSpaceOnUse'},renderImage(imageItem,{x:0,y:0,width:size,height:size},bound,options)))+tag('rect',{width,height,fill:`url(#${id})`}));
-    }
-    return tag('g',{opacity:background.opacity??1},renderImage(imageItem,{x:0,y:0,width,height},bound,{...options,imageFit:background.image.fit??'cover'}));
-  }
   if(isPlainObject(background) && background.type==='pattern'){
     const pattern=background.pattern??{},id=`opf-s${bound.index+1}-pattern`,color=resolveBackgroundColor(pattern.foregroundColor,bound.design,bound.design.colors.text),preset=pattern.preset;
-    // Without core's pattern table (an older core) five presets keep their hand-drawn approximation. diagStripe is the
-    // engine id that PPTX export writes as wdUpDiag, so both draw the same rising stripe.
-    const stroke=(d,width=1)=>tag('path',{d,fill:'none',stroke:color,'stroke-width':width});
     // RR-07: every DrawingML preset (core PATTERN_PRESETS) is an 8x8 bitmap, one unit per 1/96 inch, anchored at the slide origin.
-    const runs=typeof opfCore.patternRuns==='function'?opfCore.patternRuns(preset):undefined;
-    const bitmap=runs?tag('path',{d:runs.map(run=>`M${run.x} ${run.y}h${run.width}v1h-${run.width}z`).join(''),fill:color,'shape-rendering':'crispEdges'}):'';
-    const legacy=preset==='ltHorz'?tag('path',{d:'M0 4H8',stroke:color,'stroke-width':1}):preset==='diagStripe'||preset==='wdUpDiag'?tag('path',{d:'M-2 2L2 -2M0 8L8 0M6 10L10 6',stroke:color,'stroke-width':2}):preset==='pct5'?tag('circle',{cx:2,cy:2,r:.8,fill:color}):preset==='openDmnd'?stroke('M0 4L4 0L8 4L4 8Z'):preset==='wave'?stroke('M0 4C2 1 2 1 4 4S6 7 8 4'):'';
-    const mark=bitmap||legacy;
+    // diagStripe is the engine id that PPTX export writes as wdUpDiag, so both draw the same rising stripe.
+    const runs=patternRuns(preset);
+    const mark=runs?tag('path',{d:runs.map(run=>`M${run.x} ${run.y}h${run.width}v1h-${run.width}z`).join(''),fill:color,'shape-rendering':'crispEdges'}):'';
     if(!mark)reportDiagnostic({code:'unsupported-pattern',path:`${bound.path}.design.background.pattern.preset`,message:`Pattern ${preset} is not implemented by the SVG preview.`},options);
     return tag('g',{opacity:background.opacity??1},tag('rect',{width,height,fill:bound.design.backgroundColor??'#FFFFFF'})+tag('defs',{},tag('pattern',{id,width:8,height:8,patternUnits:'userSpaceOnUse'},mark))+tag('rect',{width,height,fill:`url(#${id})`}));
   }
@@ -888,43 +780,81 @@ function renderBackground(bound, width, height, options) {
     y: 0,
     width,
     height,
-    opacity: typeof background==='object'?background?.opacity??1:1,
+    opacity: isPlainObject(background) && background.type !== 'image' ? background.opacity ?? 1 : 1,
     fill: bound.design.backgroundColor ?? bound.design.colors.background,
     ...traceAttrs(options, `${bound.path}.design.background`)
   });
 }
 
-// design.slideImage: the shared composition frame, beneath branding and content.
-// crop covers the frame and fit centers the whole image, matching native a:srcRect.
-// Treatments mirror the native picture: the preset mask (core outline), recolor
-// and alphaModFix on the pixels only, the centered line, then the overlay shape.
-function renderSlideImage(bound, options) {
-  const image = bound.geometry.slideImage;
-  if (!image) return '';
-  const trace = options.trace ? { 'data-opf-slide-image': image.path, 'data-opf-slide-image-position': image.position } : {};
-  const value = image.alt === undefined ? image.value : { ...normalizeAsset(image.value), alt: image.alt };
-  const picture = renderImage({ value, path: image.sourcePath }, image.box, bound, { ...options, imageFit: image.fill === 'crop' ? 'cover' : 'contain' });
-  // Unresolved sources keep the ordinary placeholder without treatments, like the export.
-  if (!picture.startsWith('<image')) return tag('g', trace, picture);
-  const id = `opf-s${bound.index + 1}-slide-image`, shape = image.shape, defs = [];
-  const masked = shape && shape.preset !== 'rect';
-  if (masked) defs.push(tag('clipPath', { id: `${id}-clip` }, tag('path', { d: shape.path })));
-  const matrix = slideImageRecolorMatrix(image.recolor, bound);
-  if (matrix) defs.push(tag('filter', { id: `${id}-recolor`, 'color-interpolation-filters': 'sRGB' }, tag('feColorMatrix', { type: 'matrix', values: matrix })));
-  let pixels = matrix || image.opacity !== undefined ? tag('g', { filter: matrix ? `url(#${id}-recolor)` : undefined, opacity: image.opacity === undefined ? undefined : preciseNumber(image.opacity) }, picture) : picture;
-  if (masked) pixels = tag('g', { 'clip-path': `url(#${id}-clip)` }, pixels);
-  const children = [defs.length ? tag('defs', {}, defs.join('')) : '', pixels];
+// FA-22 image background, in the paint order of the geometry contract: the canvas colour (the colour scheme's default slide
+// background), the picture (recolor and opacity on its pixels only, as for an image block), then the overlay (the whole canvas
+// or an edge band). cover, contain
+// and stretch use the shared fit math with the focus point; tile repeats the picture at its intrinsic size (1 picture px = 1
+// reference px) from the canvas top-left. alt is the picture's accessible name; without alt the picture is decorative.
+function renderBackgroundImage(background, bound, width, height, options) {
+  const canvas = tag("rect", { x: 0, y: 0, width, height, fill: bound.design.backgroundColor ?? bound.design.colors.background, ...traceAttrs(options, `${bound.path}.design.background`) });
+  const item = { value: background.alt === undefined ? background.src : { src: background.src, alt: background.alt }, path: background.path };
+  const drawOptions = { ...options, imageDecorative: background.alt === undefined };
+  const picture = background.fit === "tile"
+    ? renderTiledImage(item, background.box, bound, drawOptions)
+    : renderImage(item, background.box, bound, { ...drawOptions, imageFit: background.fit, imageFocus: background.focus, imagePicture: background.picture });
+  // An unresolved source draws the ordinary placeholder at the background's opacity (as 0.14 did), without recolor or overlay.
+  if (isImagePlaceholder(picture)) return [canvas, background.opacity !== undefined ? tag("g", { opacity: background.opacity }, picture) : picture].join("\n");
+  const id = `opf-s${bound.index + 1}-background`, matrix = imageRecolorMatrix(background.recolor, bound);
+  const defs = matrix ? tag("defs", {}, tag("filter", { id: `${id}-recolor`, "color-interpolation-filters": "sRGB" }, tag("feColorMatrix", { type: "matrix", values: matrix }))) : "";
+  const pixels = matrix || background.opacity !== undefined ? tag("g", { filter: matrix ? `url(#${id}-recolor)` : undefined, opacity: background.opacity === undefined ? undefined : preciseNumber(background.opacity) }, picture) : picture;
+  return [canvas, defs, pixels, background.overlay ? renderImageOverlay(background.overlay, bound, options) : ""].filter(Boolean).join("\n");
+}
+
+// tile: a pattern cell of the picture's intrinsic size, anchored at the canvas origin.
+function renderTiledImage(item, box, bound, options) {
+  const { source, drawable } = resolveImageSource(item, bound, options);
+  if (!drawable) return renderImage(item, box, bound, options);
+  const size = intrinsicImageSize(source) ?? { width: Math.min(box.width, box.height) / 4, height: Math.min(box.width, box.height) / 4 };
+  const id = `opf-s${bound.index + 1}-background-tile`;
+  const cell = tag("image", { x: 0, y: 0, width: stableNumber(size.width), height: stableNumber(size.height), href: source, preserveAspectRatio: "none" });
+  return tag("defs", {}, tag("pattern", { id, x: 0, y: 0, width: stableNumber(size.width), height: stableNumber(size.height), patternUnits: "userSpaceOnUse" }, cell))
+    + tag("rect", { x: box.x, y: box.y, width: box.width, height: box.height, fill: `url(#${id})`, ...imageAccessibility(normalizeAsset(item.value), options), ...traceAttrs(options, item.path) });
+}
+
+// FA-22 image block (core ComposedItem.image): the picture in its frame (image.box) with the block's fit and focus, clipped to
+// the frame's shape unless it is a rectangle, with recolor and opacity on the pixels only; then the line centered on the shape
+// outline; then the overlay (the frame's shape, or an edge band). The outlines are core's imageShape() paths, so the preview
+// draws exactly the native preset geometry, in the paint order the export writes. A placed block (image.placement) arrives
+// with its band as the region and needs nothing else. An unresolved source keeps the ordinary placeholder without treatments.
+function renderImageBlock(item, bound, options) {
+  const image = item.image;
+  if (!image) throw new OPFRenderError("missing-image-geometry", "Image rendering requires a coordinated core build with image block geometry (ComposedItem.image).", { path: item.path });
+  const picture = renderImage(item, image.box, bound, { ...options, imageFit: image.fit, imageFocus: image.focus, imagePicture: image.picture });
+  const trace = options.trace && image.placement ? { "data-opf-image-placement": image.placement.edge } : {};
+  if (isImagePlaceholder(picture)) return Object.keys(trace).length ? tag("g", trace, picture) : picture;
+  const id = `opf-s${bound.index + 1}-image-${item.path.replace(/[^A-Za-z0-9]+/g, "-")}`, shape = image.shape, defs = [];
+  const masked = shape && shape.preset !== "rect";
+  if (masked) defs.push(tag("clipPath", { id: `${id}-clip` }, tag("path", { d: shape.path })));
+  const matrix = imageRecolorMatrix(image.recolor, bound);
+  if (matrix) defs.push(tag("filter", { id: `${id}-recolor`, "color-interpolation-filters": "sRGB" }, tag("feColorMatrix", { type: "matrix", values: matrix })));
+  let pixels = matrix || image.opacity !== undefined ? tag("g", { filter: matrix ? `url(#${id}-recolor)` : undefined, opacity: image.opacity === undefined ? undefined : preciseNumber(image.opacity) }, picture) : picture;
+  if (masked) pixels = tag("g", { "clip-path": `url(#${id}-clip)` }, pixels);
+  const children = [defs.length ? tag("defs", {}, defs.join("")) : "", pixels];
   if (image.border) {
-    const paint = slideImagePaint(image.border.color, bound, bound.design.colors.border);
-    children.push(tag('path', { d: shape?.path ?? rectanglePath(image.box), fill: 'none', stroke: paint.color, 'stroke-opacity': paint.alpha < 1 ? preciseNumber(paint.alpha) : undefined, 'stroke-width': stableNumber(image.border.width), 'stroke-linejoin': 'miter', 'stroke-miterlimit': 8 }));
-  }
-  if (image.overlay) {
-    const paint = slideImagePaint(image.overlay.color, bound, bound.design.colors.text);
-    children.push(tag('path', { d: image.overlay.shape?.path ?? rectanglePath(image.overlay.box), fill: paint.color, 'fill-opacity': preciseNumber(paint.alpha * image.overlay.opacity), ...(options.trace ? { 'data-opf-slide-image-overlay': `${image.path}.overlay` } : {}) }));
+    const paint = imagePaint(image.border.color, bound, bound.design.colors.border);
+    children.push(tag("path", { d: shape?.path ?? rectanglePath(image.box), fill: "none", stroke: paint.color, "stroke-opacity": paint.alpha < 1 ? preciseNumber(paint.alpha) : undefined, "stroke-width": stableNumber(image.border.width), "stroke-linejoin": "miter", "stroke-miterlimit": 8 }));
   }
-  return tag('g', trace, children.filter(Boolean).join(''));
+  if (image.overlay) children.push(renderImageOverlay(image.overlay, bound, options));
+  if (children.length === 2 && !children[0] && !Object.keys(trace).length) return pixels;
+  return tag("g", trace, children.filter(Boolean).join(""));
 }
 
+// One overlay (shared by image backgrounds and image blocks): its outline filled with the colour, the colour's alpha times the
+// overlay opacity.
+function renderImageOverlay(overlay, bound, options) {
+  const paint = imagePaint(overlay.color, bound, bound.design.colors.text);
+  return tag("path", { d: overlay.shape?.path ?? rectanglePath(overlay.box), fill: paint.color, "fill-opacity": preciseNumber(paint.alpha * overlay.opacity), ...(options.trace ? { "data-opf-image-overlay": overlay.path } : {}) });
+}
+
+// The placeholder renderImage draws for a source it cannot resolve.
+const isImagePlaceholder = svg => svg.startsWith("<g") && svg.includes('data-opf-asset-status="unresolved"');
+
 // Native alpha and color-matrix values keep 1/100000 precision; three decimals would drift.
 const preciseNumber = value => String(Math.round(value * 1e6) / 1e6);
 
@@ -933,18 +863,18 @@ function rectanglePath(box) {
 }
 
 // ColorRef -> opaque #RRGGBB plus the AA byte as alpha, as the native srgbClr + alpha.
-function slideImagePaint(value, bound, fallback) {
+function imagePaint(value, bound, fallback) {
   const hex = resolveColorRef(value, bound, fallback) ?? fallback;
   const raw = normalizeColor(hex, fallback).slice(1);
   return { color: `#${raw.slice(0, 6).toUpperCase()}`, alpha: raw.length === 8 ? parseInt(raw.slice(6), 16) / 255 : 1 };
 }
 
 // Rec. 601 luminance on sRGB values; duotone maps it linearly from dark to light.
-function slideImageRecolorMatrix(recolor, bound) {
+function imageRecolorMatrix(recolor, bound) {
   if (!recolor) return undefined;
   const weights = [0.299, 0.587, 0.114];
   const channels = recolor.type === 'duotone'
-    ? [slideImagePaint(recolor.dark, bound, '#000000'), slideImagePaint(recolor.light, bound, '#FFFFFF')].map(paint => [1, 3, 5].map(at => parseInt(paint.color.slice(at, at + 2), 16) / 255))
+    ? [imagePaint(recolor.dark, bound, '#000000'), imagePaint(recolor.light, bound, '#FFFFFF')].map(paint => [1, 3, 5].map(at => parseInt(paint.color.slice(at, at + 2), 16) / 255))
     : [[0, 0, 0], [1, 1, 1]];
   const [dark, light] = channels;
   const rows = [0, 1, 2].map(channel => [...weights.map(weight => preciseNumber((light[channel] - dark[channel]) * weight)), 0, preciseNumber(dark[channel])].join(' '));
@@ -970,16 +900,23 @@ function reportDiagnostic(diagnostic, options) {
   options.onDiagnostic?.(diagnostic);
 }
 
+// FA-09: Chart.alt is the chart's accessible name: a role="img" group with aria-label, which also makes the drawn marks and labels
+// inside presentational. An empty alt marks the chart decorative (aria-hidden). Without alt the SVG is unchanged.
+function chartText(chart, alt) {
+  if (typeof alt !== "string" || !chart) return chart;
+  return alt === "" ? tag("g", { "aria-hidden": "true" }, chart) : tag("g", { role: "img", "aria-label": alt }, chart);
+}
+
 function renderPayload(item, box, bound, options) {
   if (!box) return "";
   if (item.field === "items" || item.field === "bullets") return renderList(item, box, bound, options);
   switch (item.type) {
     case "chart":
-      return renderChart(item, box, bound, options);
+      return chartText(renderChart(item, box, bound, options), item.value?.alt);
     case "table":
       return renderTable(item, box, bound, options);
     case "image":
-      return renderImage(item, box, bound, options);
+      return renderImageBlock(item, bound, options);
     case "video":
       return renderMedia(item, box, bound, options);
     case "code":
@@ -1000,10 +937,9 @@ function renderPayload(item, box, bound, options) {
 function renderTextPayload(item, box, bound, options) {
   return (Array.isArray(item.value) ? renderRichTextBox : renderTextBox)(Array.isArray(item.value) ? item.value : flattenText(item.value), box, bound, {
     path: item.path,
-    // Core resolves one alignment per composed item for every engine. The
-    // fallback keeps cores published before item.alignment working: titles
-    // follow design.titleAlignment only (unset is left, as in core composition).
-    align: item.alignment ?? (item.field === "title" ? bound.design.titleAlignment ?? "left" : bound.design.contentAlignment),
+    // Core resolves one alignment per composed item for every engine, from the slide's design, the deck's design
+    // and the layout record's design (SlideComposition.design).
+    align: item.alignment,
     fontSize: item.field === "title" ? 54 : item.field === "tag" ? 16 : 25,
     // fontScheme.accent draws the tag; core's textStyle (item.textStyle) already carries it, this is the fallback family.
     fontFamily: item.field === "title" ? bound.design.fonts.heading : item.field === "tag" ? bound.design.fonts.accent ?? bound.design.fonts.body : bound.design.fonts.body,
@@ -1021,7 +957,7 @@ function renderTextPayload(item, box, bound, options) {
 
 function renderList(item, box, bound, options) {
   const scale=Math.min(bound.design.dimensions.width,bound.design.dimensions.height)/720;
-  const fit=item.text?.listEntries?item.text:fitList(item.value,box,25*scale,((bound.composition??bound.geometry.composition).minFontSize??16)*scale,{style:{fontFamily:bound.design.fonts.body,fontWeight:400,path:item.path},textMeasurement:options.textMeasurement,...(item.payload?.numbering!==undefined?{numbering:item.payload.numbering}:{})});
+  const fit=item.text?.listEntries?item.text:fitList(item.value,box,25*scale,((bound.composition??bound.geometry.composition).minFontSize??16)*scale,{style:{fontFamily:bound.design.fonts.body,fontWeight:400,path:item.path},...(bound.design.fonts.code?{codeFontFamily:bound.design.fonts.code}:{}),textMeasurement:options.textMeasurement,...(item.payload?.numbering!==undefined?{numbering:item.payload.numbering}:{})});
   const children=[];
   // design.listBullet=image: core attaches the icon logo as item.bulletImage and its box (entry.bulletBox: 0.65 em, as PowerPoint draws a:buBlip). An icon that cannot be drawn keeps the glyph marker.
   const bullet=item.bulletImage?resolveBulletImage(item.bulletImage,bound,options):undefined;
@@ -1063,6 +999,13 @@ function resolveImageSource(item, bound, options) {
   return { asset, source: svg ?? source, drawable, missingReference };
 }
 
+// The accessible name of a drawn picture: its alt text, else the caller's label; a decorative picture (an image background
+// without alt) is hidden from assistive technology.
+function imageAccessibility(asset, options) {
+  if (options.imageDecorative) return { "aria-hidden": "true" };
+  return { role: "img", "aria-label": asset.alt ?? options.imageLabel ?? "Image" };
+}
+
 const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
 
 // The base64 data URI of a drawable SVG, else null. Drawable: a data URI whose type is image/svg+xml, whose text is
@@ -1209,12 +1152,29 @@ function resolveBulletImage(bulletImage, bound, options) {
   return undefined;
 }
 
+// A drawable picture in `box` with `options.imageFit`: cover (the default for content), contain or stretch. cover takes
+// `options.imageFocus`: centered, it is the native center crop; anywhere else the picture is placed by core's fit math
+// (`options.imagePicture`, core's ImageFitPlacement when core read the aspect, else fitImage on core's intrinsicImageAspect
+// of the resolved source, for pictures a host imageResolver supplies) and
+// clipped to the box by a nested viewport. A logo keeps its anchor (`options.imageAnchor`).
 function renderImage(item, box, bound, options) {
   const { asset, source, drawable, missingReference } = resolveImageSource(item, bound, options);
   if (drawable) {
+    const fit = options.imageFit ?? "contain", focus = options.imageFocus;
+    const attrs = { href: source, ...imageAccessibility(asset, options), ...traceAttrs(options, item.path), ...generatedAttrs(options) };
+    if (fit === "cover" && focus && !options.imageAnchor && (focus.x !== 0.5 || focus.y !== 0.5)) {
+      // The drawable source (after asset references and the host imageResolver): core reads its size (intrinsicImageAspect).
+      const aspect = options.imagePicture ? undefined : intrinsicImageAspect(source);
+      const placement = options.imagePicture ?? (aspect ? fitImage(box, "cover", aspect, focus) : undefined);
+      if (placement) {
+        const picture = placement.image;
+        return tag("svg", { x: box.x, y: box.y, width: box.width, height: box.height, overflow: "hidden" },
+          tag("image", { x: stableNumber(picture.x - box.x), y: stableNumber(picture.y - box.y), width: stableNumber(picture.width), height: stableNumber(picture.height), preserveAspectRatio: "none", ...attrs }));
+      }
+    }
     return tag("image", { x: box.x, y: box.y, width: box.width, height: box.height,
-      href: source, preserveAspectRatio: options.imageAnchor === "left" ? "xMinYMid meet" : options.imageAnchor === "right" ? "xMaxYMid meet" : (options.imageFit ?? (bound.design.imageFill === "crop" ? "cover" : "contain")) === "cover" ? "xMidYMid slice" : "xMidYMid meet", role: "img", "aria-label": asset.alt ?? options.imageLabel ?? "Image",
-      ...traceAttrs(options, item.path), ...generatedAttrs(options) });
+      preserveAspectRatio: options.imageAnchor === "left" ? "xMinYMid meet" : options.imageAnchor === "right" ? "xMaxYMid meet" : fit === "cover" ? "xMidYMid slice" : fit === "stretch" ? "none" : "xMidYMid meet",
+      ...attrs });
   }
   const reason=missingReference?'missing-reference':!asset.src?'missing-source':'unsupported-source';
   const message=missingReference?`Image asset ${missingReference} is missing; supply the referenced asset or resolve it in the host.`:'Image requires an embedded raster or SVG data URI, or a host imageResolver.';
@@ -1311,6 +1271,7 @@ function renderCode(item, box, bound, options) {
     if (invalid) throw new OPFRenderError('invalid-code-text', `Code text contains U+${invalid[0].codePointAt(0).toString(16).toUpperCase().padStart(4,'0')} at UTF-16 offset ${invalid.index}, which XML cannot represent; edit that character before rendering.`, {path:part.path});
   }
   const syntax = codeSyntax(item, layout, bound, options);
+  const highlight = codeHighlight(item, layout, bound);
   const children = [
     tag("rect", {
       x: box.x,
@@ -1323,13 +1284,27 @@ function renderCode(item, box, bound, options) {
       ...traceAttrs(options, item.path)
     })
   ];
+  // FA-13: code.highlight is one band per run of marked lines, behind the line text; the marked lines keep the syntax colours and
+  // the others are dimmed (core's codeHighlight* helpers, the same ones the PPTX export calls).
+  if (highlight) {
+    const body = layout.parts.find(part => part.role === "body");
+    for (const band of highlight.bands) {
+      children.push(tag("rect", {
+        x: stableNumber(box.x + 1), y: stableNumber(body.box.y + band.first * body.fit.lineHeight), width: stableNumber(box.width - 2),
+        height: stableNumber((band.last - band.first + 1) * body.fit.lineHeight), fill: highlight.colors.band,
+        ...(options.trace ? { "data-opf-code-highlight": "true" } : {})
+      }));
+    }
+  }
   for (const part of layout.parts) {
-    if (!part.fit) throw new OPFRenderError('layout-overflow', 'Code content has no usable internal space; increase its cell size before rendering.', {path:part.path,issues:layout.diagnostics});
-    const lines=part.fit.sourceLines.map((line,index)=>tag('text',{
+    if (!part.fit) throw new OPFRenderError('layout-overflow', 'Code content has no usable internal space; increase its cell size before rendering.', {path:part.path,diagnostics:layout.diagnostics});
+    const lines=part.fit.sourceLines.map((line,index)=>{
+    const lineColors=highlight&&part.role==='body'?(highlight.marked.has(highlight.numbers[index])?highlight.colors.lit:highlight.colors.dim):undefined;
+    return tag('text',{
       x:stableNumber(part.box.x),y:stableNumber(part.box.y+part.fit.fontSize+index*part.fit.lineHeight),
       'text-anchor':'start','font-family':fontStack(part.style.fontFamily,'monospace'),
       'font-size':stableNumber(part.fit.fontSize),'font-weight':part.style.fontWeight,'font-style':part.style.italic?'italic':undefined,
-      'xml:space':'preserve',style:'white-space:pre','text-rendering':'geometricPrecision',fill:part.role==='body'?'#E5E7EB':'#93C5FD',
+      'xml:space':'preserve',style:'white-space:pre','text-rendering':'geometricPrecision',fill:part.role==='body'?(lineColors?.plain??'#E5E7EB'):'#93C5FD',
       ...traceAttrs(options,part.path),...(options.trace?{'data-opf-code-role':part.role,'data-opf-generated':part.generated?'true':undefined,
         'data-opf-text-start':line.start,'data-opf-text-end':line.end,'data-opf-text-next-start':line.nextStart,'data-opf-line-boundary':line.boundary}:{}),
     },line.segments.map(segment=>segmentSpan({
@@ -1338,7 +1313,8 @@ function renderCode(item, box, bound, options) {
       ...(segment.kind==='tab'?{textLength:stableNumber(segment.width),lengthAdjust:'spacingAndGlyphs'}:{}),
       ...(options.trace?{'data-opf-segment':segment.kind,'data-opf-text-start':segment.start,'data-opf-text-end':segment.end}:{}),
       // Code stays left to right; script runs still take their slot fonts.
-    },segment,part.text.slice(segment.start,segment.end),part.style,bound,'monospace',{rtl:false,fontSize:part.fit.fontSize},part.role==='body'?syntax:undefined)).join('')));
+    },segment,part.text.slice(segment.start,segment.end),part.style,bound,'monospace',{rtl:false,fontSize:part.fit.fontSize},part.role==='body'?(syntax&&lineColors?{...syntax,palette:lineColors}:syntax):undefined)).join(''));
+    });
     children.push(tag('g',{...traceAttrs(options,part.path),...(options.trace?{'data-opf-code-role':part.role,'data-opf-generated':part.generated?'true':undefined,
       'data-opf-box-x':part.box.x,'data-opf-box-y':part.box.y,'data-opf-box-width':part.box.width,'data-opf-box-height':part.box.height}:{}),
       ...(part.fit.overflow?{'data-opf-overflow':'true'}:{})},lines.join('\n')));
@@ -1357,7 +1333,7 @@ function renderMetric(item, box, bound, options) {
     const invalid=/[\u0000-\u0008\u000B\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE\uFFFF]/u.exec(part.text);
     if (invalid) throw new OPFRenderError('invalid-metric-text',`Metric text contains U+${invalid[0].codePointAt(0).toString(16).toUpperCase().padStart(4,'0')} at UTF-16 offset ${invalid.index}, which XML cannot represent; edit that character before rendering.`,{path:part.path});
     if (!part.visible) continue;
-    if (!part.fit||part.linePositions?.length!==part.fit.sourceLines.length) throw new OPFRenderError('layout-overflow','Metric content has no accepted internal line positions; increase its cell size or coordinate package versions.',{path:part.path,issues:layout.diagnostics});
+    if (!part.fit||part.linePositions?.length!==part.fit.sourceLines.length) throw new OPFRenderError('layout-overflow','Metric content has no accepted internal line positions; increase its cell size or coordinate package versions.',{path:part.path,diagnostics:layout.diagnostics});
     const partRtl=paragraphRtl(bound,part.text);
     // Anchor untabbed lines at the accepted alignment edge, as PPTX export does,
     // so a shaper whose advance differs from the accepted width keeps the edge.
@@ -1393,37 +1369,58 @@ function renderMetric(item, box, bound, options) {
   return tag('g',{...traceAttrs(options,item.path),...(options.trace?{'data-opf-metric-container':'true'}:{})},children.join('\n'));
 }
 
-// The trend arrow and colour for a laid-out metric (core metricTrendMark); undefined without a trend or without core support.
+// The trend arrow and colour for a laid-out metric (core metricTrendMark); undefined without a trend.
 function metricTrendMark(layout,bound,options) {
-  if (typeof opfCore.metricTrendMark!=='function') return undefined;
-  return opfCore.metricTrendMark(layout,{background:bound.design.backgroundColor??bound.design.colors.background});
+  return coreMetricTrendMark(layout,{background:bound.design.backgroundColor??bound.design.colors.background});
 }
 
 function renderQuote(item, box, bound, options) {
   const layout = item.quoteLayout;
   if (!layout) throw new OPFRenderError('missing-quote-layout', 'Quote rendering requires a coordinated core build with shared quote geometry.', {path:item.path});
   const children = layout.parts.map(part => {
-    if (!part.fit) throw new OPFRenderError('layout-overflow', 'Quote content has no usable internal space; increase its cell size before rendering.', {path:part.path,issues:layout.diagnostics});
+    if (!part.fit) throw new OPFRenderError('layout-overflow', 'Quote content has no usable internal space; increase its cell size before rendering.', {path:part.path,diagnostics:layout.diagnostics});
+    const fill=part.role==='footer'?bound.design.colors.mutedText:bound.design.colors.text;
+    // FA-10: a TextRun[] quote body is laid out by core's rich-text layouter; its runs (quotation marks joined to the first and last) draw like body runs.
+    if(part.runs&&part.fit.richLines)return renderRichLines(part.runs,part.fit,part.box,bound,{path:part.path,fill,fontFamily:part.requestedStyle.fontFamily,diagnosticsHandled:true,textOffset:-1,options});
     return renderTextBox(part.text,part.box,bound,{
       path:part.path,fit:part.fit,textStyle:part.style,fontFamily:part.requestedStyle.fontFamily,
-      fill:part.role==='footer'?bound.design.colors.mutedText:bound.design.colors.text,
+      fill,
       diagnosticsHandled:true,options,
     });
   });
+  // FA-12: the attributed person's headshot, cropped to fill the core circle frame (the clip is the outline the native ellipse picture uses).
+  if (layout.photo) children.push(renderQuotePhoto(layout.photo, item, bound, options));
   return tag("g", traceAttrs(options, item.path), children.join("\n"));
 }
 
+function renderQuotePhoto(photo, item, bound, options) {
+  const picture = renderImage({ value: photo.value, path: photo.path }, photo.box, bound, { ...options, imageFit: 'cover' });
+  // An unresolved source keeps the ordinary placeholder, unmasked, like the export.
+  if (isImagePlaceholder(picture)) return picture;
+  const id = `opf-s${bound.index + 1}-quote-photo-${item.path.replace(/[^A-Za-z0-9]+/g, '-')}`;
+  return tag('g', {}, tag('defs', {}, tag('clipPath', { id }, tag('path', { d: photo.shape.path }))) + tag('g', { 'clip-path': `url(#${id})` }, picture));
+}
+
 function renderTimeline(item, box, bound, options) {
   const layout=item.timelineLayout;
   if(!layout)throw new OPFRenderError('missing-timeline-layout','Timeline rendering requires a coordinated core build with shared timeline geometry.',{path:item.path});
   const scale=Math.min(bound.design.dimensions.width,bound.design.dimensions.height)/720;
   const children=[tag('line',{...layout.connector,stroke:bound.design.colors.border,'stroke-width':3*scale,...traceAttrs(options,item.path)})];
-  for(const marker of layout.markers)children.push(tag('circle',{cx:marker.x,cy:marker.y,r:marker.radius,fill:bound.design.colors.primary,...traceAttrs(options,marker.path)}));
+  // FA-11: status colors come from the deck (core's timelineMarkerShapes / timelineTextColor); a marker with no status draws the plain primary circle.
+  const background=bound.design.backgroundColor??bound.design.colors.background;
+  const statusColors={background,primary:bound.design.colors.primary,text:bound.design.colors.text,mutedText:bound.design.colors.mutedText};
+  for(const marker of layout.markers){
+    if(!marker.status){
+      children.push(tag('circle',{cx:marker.x,cy:marker.y,r:marker.radius,fill:bound.design.colors.primary,...traceAttrs(options,marker.path)}));
+      continue;
+    }
+    for(const shape of timelineMarkerShapes(marker,statusColors))children.push(tag('circle',{cx:shape.cx,cy:shape.cy,r:shape.radius,fill:shape.fill??'none',...(shape.stroke?{stroke:shape.stroke.color,'stroke-width':shape.stroke.width}:{}),...traceAttrs(options,marker.path),...(options.trace?{'data-opf-timeline-status':marker.status,'data-opf-timeline-shape':shape.role}:{})}));
+  }
   for(const part of layout.parts){
-    if(!part.fit)throw new OPFRenderError('layout-overflow','Timeline field has no usable space; change the arrangement or paginate events.',{path:part.path,issues:layout.diagnostics});
+    if(!part.fit)throw new OPFRenderError('layout-overflow','Timeline field has no usable space; change the arrangement or paginate events.',{path:part.path,diagnostics:layout.diagnostics});
     children.push(tag('g',options.trace?{'data-opf-timeline-role':part.role}:{},renderTextBox(part.text,part.box,bound,{
       path:part.path,fit:part.fit,textStyle:part.style,fontFamily:part.requestedStyle.fontFamily,align:part.alignment,
-      fill:bound.design.colors.text,diagnosticsHandled:true,options,
+      fill:part.status?timelineTextColor(part,statusColors):bound.design.colors.text,diagnosticsHandled:true,options,
     })));
   }
   return tag('g',{...traceAttrs(options,item.path),...(options.trace?{'data-opf-timeline-arrangement':layout.arrangement}:{})},children.join('\n'));
@@ -1431,7 +1428,7 @@ function renderTimeline(item, box, bound, options) {
 
 function renderTable(item, box, bound, options) {
   const scale = Math.min(bound.design.dimensions.width, bound.design.dimensions.height) / 720;
-  const layout = layoutTable(item.value, box, {scale, minFontSize:(bound.composition ?? bound.geometry.composition).minFontSize, fontFamily:bound.design.fonts.body, textMeasurement:options.textMeasurement, path:item.path, presentation:bound.presentation, ...(bound.geometry?.direction === "rtl" ? {direction:"rtl"} : {})});
+  const layout = layoutTable(item.value, box, {scale, minFontSize:(bound.composition ?? bound.geometry.composition).minFontSize, fontFamily:bound.design.fonts.body, ...(bound.design.fonts.code ? {codeFontFamily:bound.design.fonts.code} : {}), textMeasurement:options.textMeasurement, path:item.path, presentation:bound.presentation, ...(bound.geometry?.direction === "rtl" ? {direction:"rtl"} : {})});
   const children = [];
   // RR-54: a dataset table has no rows or columns of its own to point at; every cell reports the table's authored path.
   const own = isDatasetTable(item, bound) ? () => item.path : (path) => path;
@@ -1512,12 +1509,12 @@ function renderTableBorders(defaultEdges, explicitEdges, scale, bound, options)
 }
 
 function renderChart(item, box, bound, options) {
-  // Catalog chart types (kept, deprecated and aliased ids) preview the native
+  // Catalog chart types preview the native
   // construct opf-pptx exports; other ids keep the legacy single-series preview.
   const rendered = renderCatalogChart(item, box, bound, options, { tag, traceAttrs, stableNumber, renderTextBox, reportDiagnostic });
   if (rendered) return rendered;
   const chart = item.value ?? {};
-  const chartType = chart.type ?? engineDefaults.chartTypes[0];
+  const chartType = chart.type ?? engineDefaults.chartType;
   const data = inlineChartRows(legacyChartData(chart, bound));
   // A dataset-backed chart has no data.rows of its own: its parts report the chart's authored path.
   const part = isDatasetChart(item, bound) ? () => item.path : (path) => path;
@@ -1611,10 +1608,9 @@ function renderChart(item, box, bound, options) {
 }
 
 // RR-54: the legacy sketch reads the same resolved rows as the catalog charts (mapping, datasets and strict numbers). Data that does
-// not resolve, or a core without the resolver, is read as authored.
+// not resolve is read as authored.
 function legacyChartData(chart, bound) {
-  if (typeof opfCore.resolveChartData !== "function") return chart.data;
-  const resolved = opfCore.resolveChartData(chart, bound.presentation);
+  const resolved = resolveChartData(chart, bound.presentation);
   return resolved.ok ? { rows: resolved.rows, resolved: true } : chart.data;
 }
 
@@ -1648,7 +1644,17 @@ function renderFurniture(bound, presentation, width, height, options, kind) {
 function renderBranding(bound,presentation,width,height,options) {
   const design={...presentation.design,...bound.slide.design}, pieces=[];
   const rootFor=key=>bound.slide.design?.[key]!==undefined?`${bound.path}.design.${key}`:`design.${key}`;
-  if(design.watermark){
+  // FA-13: a text watermark is one line of the heading font in the theme text colour, centered and rotated as core's layoutWatermark says.
+  if(design.watermark&&typeof design.watermark==='object'&&typeof design.watermark.text==='string'){
+    const mark=layoutWatermark(design.watermark.text,{width,height},{fontFamily:bound.design.fonts.heading,fontWeight:700,textMeasurement:options.textMeasurement});
+    if(mark){
+      const opacity=typeof design.watermark.opacity==='number'&&Number.isFinite(design.watermark.opacity)?Math.min(1,Math.max(0,design.watermark.opacity)):.08;
+      const cx=width/2,cy=height/2;
+      pieces.push(tag('g',{opacity:stableNumber(opacity),transform:`rotate(${stableNumber(mark.rotation)} ${stableNumber(cx)} ${stableNumber(cy)})`,...traceAttrs(options,rootFor('watermark'))},
+        tag('text',{x:stableNumber(cx),y:stableNumber(cy+mark.fontSize*.35),'text-anchor':'middle','font-family':fontStack(mark.style.fontFamily,bound.design.fontScheme.type),'font-size':stableNumber(mark.fontSize),'font-weight':mark.fontWeight,
+          fill:bound.design.colors.text,'xml:space':'preserve','text-rendering':'geometricPrecision'},escapeText(mark.text))));
+    }
+  } else if(design.watermark){
     pieces.push(tag('g',{opacity:typeof design.watermark==='object'?design.watermark.opacity??.08:.08},renderImage({value:design.watermark,path:rootFor('watermark')},{x:width*.3,y:height*.3,width:width*.4,height:height*.4},bound,{...options,imageFit:'contain'})));
   }
   // Cover and section slides: the deck logo core composed at the top-left of the free area, anchored left.
@@ -1675,20 +1681,16 @@ function fontStack(family, type) {
 // alignment and measured advances are unchanged.
 const RIGHT_TO_LEFT_ISOLATE = "\u2067", POP_DIRECTIONAL_ISOLATE = "\u2069";
 // Core owns the rule (paragraphDirection, core #134), so preview and export agree.
-// Without it (published core 0.11.0) every paragraph is left to right, as in export.
-const coreParagraphDirection = typeof opfCore.paragraphDirection === "function" ? opfCore.paragraphDirection : null;
 // RR-05: authored alignment is logical for right-to-left text, so `left` is the start edge (drawn at the right of a
-// right-to-left line) and `right` the end edge. Core owns the rule; the fallback only serves a core without it, which
-// also reports no line directions, so it never flips.
-const physicalAlignment = typeof opfCore.physicalAlignment === "function" ? opfCore.physicalAlignment : alignment => alignment;
+// right-to-left line) and `right` the end edge. Core owns that rule too (physicalAlignment, imported above).
 /** Maps a source offset of the text to whether its paragraph is right to left. */
 function paragraphRtl(bound, text) {
-  if (bound.scriptFonts?.rtl !== true || !coreParagraphDirection) return () => false;
+  if (bound.scriptFonts?.rtl !== true) return () => false;
   const source = String(text ?? ""), spans = [];
   let start = 0;
   for (const match of source.matchAll(/\r\n|\r|\n/g)) { spans.push([start, match.index]); start = match.index + match[0].length; }
   spans.push([start, source.length]);
-  const rtl = spans.map(([from, to]) => coreParagraphDirection(source.slice(from, to), "rtl") === "rtl");
+  const rtl = spans.map(([from, to]) => paragraphDirection(source.slice(from, to), "rtl") === "rtl");
   return offset => { for (let index = spans.length - 1; index >= 0; index--) if (offset >= spans[index][0]) return rtl[index]; return rtl[0]; };
 }
 
@@ -1710,7 +1712,7 @@ function nestedReset(style, run) {
 
 function scriptLine(text, style, bound, type, { rtl = false, placement, trace, fontSize } = {}) {
   const value = String(text ?? "");
-  const scripts = bound.scriptFonts;
+  const scripts = (style?.lang && bound.scriptFontsFor?.(style.lang)) || bound.scriptFonts;
   rtl = rtl && value !== "";
   const isolate = content => rtl ? `${RIGHT_TO_LEFT_ISOLATE}${content}${POP_DIRECTIONAL_ISOLATE}` : content;
   const runs = value && scripts ? scripts.plan(value, style) : [{ text: value, own: true }];
@@ -1759,7 +1761,7 @@ function segmentSpan(attrs, segment, text, style, bound, type, options, syntax)
   // Syntax highlighting (RR-07): a coloured text segment becomes consecutive sibling tspans, one per run, each a
   // traced segment of its own source range holding one text node (the editor's caret mapping reads that), the first
   // keeping the accepted x and the rest flowing after it. Plain code keeps one tspan per accepted segment.
-  const runs = syntax && segment.kind !== "tab" ? opfCore.codeLineRuns(syntax.tokens, segment.start, segment.end) : undefined;
+  const runs = syntax && segment.kind !== "tab" ? codeLineRuns(syntax.tokens, segment.start, segment.end) : undefined;
   if (runs?.some(run => run.kind)) {
     return runs.map((run, index) => {
       const sizeOf = line => line.sizeAdjust && options?.fontSize > 0 ? stableNumber(adjustedFontSize(options.fontSize, line.sizeAdjust)) : undefined;
@@ -1773,16 +1775,27 @@ function segmentSpan(attrs, segment, text, style, bound, type, options, syntax)
   return tag("tspan", { ...attrs, "font-family": scripted.family, "font-size": scripted.sizeAdjust && options?.fontSize > 0 ? stableNumber(adjustedFontSize(options.fontSize, scripted.sizeAdjust)) : undefined }, scripted.content);
 }
 
+// FA-13: the marked lines of code.highlight, their bands (runs of displayed lines) and the lit/dimmed colours, from core (the PPTX
+// export calls the same functions); undefined when the code marks no line.
+function codeHighlight(item, layout, bound) {
+  const highlight = item.value?.highlight;
+  if (!Array.isArray(highlight)) return undefined;
+  const body = layout.parts.find(part => part.role === "body");
+  if (!body?.fit) return undefined;
+  const lines = codeHighlightLines(highlight, body.text).lines;
+  if (!lines.length) return undefined;
+  return { marked: new Set(lines), numbers: codeLineNumbers(body.fit.sourceLines), bands: codeHighlightBands(body.fit.sourceLines, lines), colors: codeHighlightColors(bound.design.colorScheme) };
+}
+
 // Token ranges of the code body and the palette to paint them with; undefined for plain code (an unknown language,
-// no language, or a core without the shared highlighter). The preview and the PPTX export read the same tables.
+// no language). The preview and the PPTX export read the same tables.
 function codeSyntax(item, layout, bound, options) {
   const body = layout.parts.find(part => part.role === "body");
   const language = typeof item.value?.language === "string" ? item.value.language : layout.parts.find(part => part.role === "language")?.text;
   if (!body || !language) return undefined;
-  if (typeof opfCore.tokenizeCode !== "function") return undefined;
-  const tokens = opfCore.tokenizeCode(body.text, language);
+  const tokens = tokenizeCode(body.text, language);
   if (!tokens.length) return undefined;
-  return { tokens, palette: opfCore.codeSyntaxPaletteForScheme(bound.design.colorScheme) };
+  return { tokens, palette: codeSyntaxPaletteForScheme(bound.design.colorScheme) };
 }
 
 // Faces flagged embed:"used" (the vendored open, Intos and script-pack faces) are embedded only when the slide's own markup draws
@@ -1840,8 +1853,8 @@ function renderEmbeddedFonts(fonts = []) {
 
 function renderRichTextBox(value, box, bound, config) {
   const scale=Math.min(bound.design.dimensions.width,bound.design.dimensions.height)/720;
-  const fit=config.fit??fitRichText(value,box,config.fontSize*scale,((bound.composition??bound.geometry.composition).minFontSize??16)*scale,{style:{fontFamily:config.fontFamily,fontWeight:config.fontWeight??400,path:config.path},textMeasurement:config.options.textMeasurement});
-  if(fit.overflow&&!config.diagnosticsHandled){const diagnostic={code:'text-overflow',path:config.path,message:'Mixed-style text exceeds its cell at the minimum font size.'};reportDiagnostic(diagnostic,config.options);if((bound.composition??bound.geometry.composition).overflow==='error')throw new OPFRenderError('layout-overflow',diagnostic.message,{issues:[diagnostic]});}
+  const fit=config.fit??fitRichText(value,box,config.fontSize*scale,((bound.composition??bound.geometry.composition).minFontSize??16)*scale,{style:{fontFamily:config.fontFamily,fontWeight:config.fontWeight??400,path:config.path},...(bound.design.fonts.code?{codeFontFamily:bound.design.fonts.code}:{}),textMeasurement:config.options.textMeasurement});
+  if(fit.overflow&&!config.diagnosticsHandled){const diagnostic={code:'text-overflow',path:config.path,message:'Mixed-style text exceeds its cell at the minimum font size.'};reportDiagnostic(diagnostic,config.options);if((bound.composition??bound.geometry.composition).overflow==='error')throw new OPFRenderError('layout-overflow',diagnostic.message,{diagnostics:[diagnostic]});}
   return renderRichLines(value,fit,box,bound,config);
 }
 
@@ -1866,10 +1879,11 @@ function trimRichLineEdges(line,textMeasurement) {
 }
 
 function renderRichLines(value,fit,box,bound,config) {
-  const logicalAlignment=fit.placement?.alignment??config.align??bound.design.contentAlignment;
+  const logicalAlignment=fit.placement?.alignment??config.align??bound.geometry.design.contentAlignment;
   // Each line takes its paragraph's direction from core (every wrapped line shares it) and its physical edge from that.
   const lineAlignment=index=>fit.placement?.lines[index]?.alignment??physicalAlignment(logicalAlignment,fit.directions?.[index]);
-  let textOffset=0;
+  // A rich quote body draws its quotation marks inside the first and last run; config.textOffset (-1) keeps every traced offset on the authored text.
+  let textOffset=config.textOffset??0;
   const runOffsets=value.map(run=>{const start=textOffset;textOffset+=(typeof run==='string'?run:run.text).length;return start;});
   const richRtl=paragraphRtl(bound,value.map(run=>typeof run==='string'?run:run.text).join(''));
   // With no measurement provider, fragment advances are estimates. Let SVG
@@ -1901,19 +1915,23 @@ function renderRichLines(value,fit,box,bound,config) {
     // Estimated (natural-flow) lines keep logical order; the browser reorders them.
     const fragmentX=rtl&&!naturalFlow?line.width-fragment.x-fragment.width:fragment.x;
     const position=asFlow?{'baseline-shift':fragment.baselineShift?stableNumber(-fragment.baselineShift):undefined}:{x:stableNumber(originX+fragmentX),y:stableNumber(baseline+fragment.baselineShift)};
+    // A link run is drawn as PowerPoint draws one: underlined, in the scheme hyperlink color unless the run sets its own color.
+    const linked = fragment.kind !== 'marker' && typeof run.link === 'string' && LINK_URL.test(run.link);
     const runFill = run.color == null
-      ? config.fill
+      ? (linked ? bound.design.colors.hyperlink : config.fill)
       : resolveColorRef(run.color, bound, config.fill);
     let fixedAdvance=(fragment.kind==='tab'||placed)&&fragment.width>0;
-    const scripted=fragment.kind==='tab'?{content:escapeText(fragment.text)}:scriptLine(fragment.text,fragment.style,bound,bound.design.fontScheme.type,{rtl:rtl&&!asFlow,
+    // FA-13: an inline code run falls back to a monospace face, and a run with its own language declares it.
+    const runLang=fragment.kind!=='tab'&&fragment.style.lang?(bound.scriptFontsFor?.(fragment.style.lang)?.profile.bcp47??fragment.style.lang):undefined;
+    const scripted=fragment.kind==='tab'?{content:escapeText(fragment.text)}:scriptLine(fragment.text,fragment.style,bound,run.code===true?'monospace':bound.design.fontScheme.type,{rtl:rtl&&!asFlow,
       placement:fixedAdvance&&!asFlow?{x:originX+fragmentX,width:fragment.width,fontSize:fragment.fontSize}:undefined,fontSize:fragment.fontSize});
     if(scripted.positioned)fixedAdvance=false;
     const content=`${edges.first?RIGHT_TO_LEFT_ISOLATE:''}${scripted.content}${edges.last?POP_DIRECTIONAL_ISOLATE:''}`;
     // RR-34: a citation/footnote marker is generated text (no source range): it is traced as a marker
     // segment without text offsets, so editors never read it as part of the run, and it is not linked.
     const marker=fragment.kind==='marker';
-    const rendered=tag(asFlow?'tspan':'text',{...(config.options.trace?marker?{'data-opf-segment':'marker','data-opf-marker':fragment.text}:{'data-opf-text-start':runOffsets[fragment.runIndex]+fragment.start,'data-opf-text-end':runOffsets[fragment.runIndex]+fragment.end,'data-opf-segment':fragment.kind}:{}),...position,'xml:space':'preserve','text-rendering':asFlow?undefined:'geometricPrecision',textLength:fixedAdvance?stableNumber(fragment.width):undefined,lengthAdjust:fixedAdvance?'spacingAndGlyphs':undefined,'font-family':scripted.family??fontStack(fragment.style.fontFamily,bound.design.fontScheme.type),'font-size':stableNumber(adjustedFontSize(fragment.fontSize,scripted.sizeAdjust)),'font-weight':fragment.style.fontWeight,'font-style':fragment.style.italic?'italic':asFlow?'normal':undefined,'text-decoration':marker?undefined:[run.underline?'underline':'',run.strikethrough?'line-through':''].filter(Boolean).join(' ')||undefined,fill:runFill},content);
-    if(!marker&&run.link&&/^(https?:|mailto:)/i.test(run.link))return tag('a',{href:run.link,target:'_blank',rel:'noopener noreferrer'},rendered);
+    const rendered=tag(asFlow?'tspan':'text',{...(runLang?{lang:runLang,'xml:lang':runLang}:{}),...(config.options.trace?marker?{'data-opf-segment':'marker','data-opf-marker':fragment.text}:{'data-opf-text-start':runOffsets[fragment.runIndex]+fragment.start,'data-opf-text-end':runOffsets[fragment.runIndex]+fragment.end,'data-opf-segment':fragment.kind}:{}),...position,'xml:space':'preserve','text-rendering':asFlow?undefined:'geometricPrecision',textLength:fixedAdvance?stableNumber(fragment.width):undefined,lengthAdjust:fixedAdvance?'spacingAndGlyphs':undefined,'font-family':scripted.family??fontStack(fragment.style.fontFamily,run.code===true?'monospace':bound.design.fontScheme.type),'font-size':stableNumber(adjustedFontSize(fragment.fontSize,scripted.sizeAdjust)),'font-weight':fragment.style.fontWeight,'font-style':fragment.style.italic?'italic':asFlow?'normal':undefined,'text-decoration':marker?undefined:[run.underline||linked?'underline':'',run.strikethrough?'line-through':''].filter(Boolean).join(' ')||undefined,fill:runFill},content);
+    if(linked)return tag('a',{href:run.link,target:'_blank',rel:'noopener noreferrer'},rendered);
     return rendered;
     };
     if(naturalFlow&&lineHasTab) {
@@ -1958,13 +1976,13 @@ function renderTextBox(text, box, bound, config) {
     const diagnostic = { code: "text-overflow", path: config.path,
       message: "Text exceeds its cell at the minimum font size; shorten it, increase its space, or split the slide." };
     reportDiagnostic(diagnostic, config.options);
-    if ((bound.composition ?? bound.geometry.composition).overflow === "error") throw new OPFRenderError("layout-overflow", diagnostic.message, { path: diagnostic.path, issues: [diagnostic] });
+    if ((bound.composition ?? bound.geometry.composition).overflow === "error") throw new OPFRenderError("layout-overflow", diagnostic.message, { path: diagnostic.path, diagnostics: [diagnostic] });
   }
   const size = fit.fontSize;
   const totalHeight = fit.lines.length * fit.lineHeight;
   const startY = config.verticalAlign === "middle"
     ? box.y + Math.max(0, (box.height - totalHeight) / 2) + size : box.y + size;
-  const logicalAlignment=fit.placement?.alignment??config.align??bound.design.contentAlignment;
+  const logicalAlignment=fit.placement?.alignment??config.align??bound.geometry.design.contentAlignment;
   const type = config.fontFamily === bound.design.fonts.code ? "monospace" : bound.design.fontScheme.type;
   const source = String(text ?? ""), boxRtl = paragraphRtl(bound, source);
   let cursor = 0;