@openpresentation/opf-render 0.11.8 → 0.12.0

package/dist/svg.js

@@ -7,9 +7,11 @@ import {
 // 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 { createScriptFonts } from "./script-fonts.js";
+import { adjustedFontSize, baselineShift, createScriptFonts } from "./script-fonts.js";
 import { disabledFeaturesStyle } from "./font-compatibility.js";
+import { fontPolicyFor } from "./font-policy.js";
 import { renderCatalogChart } from "./charts.js";
+import { renderCaption, renderFootnotes } from "./annotations.js";
 
 export const packageName = "@openpresentation/opf-render";
 
@@ -181,6 +183,36 @@ function parseInput(input) {
   throw new OPFRenderError("invalid-input", "OPF input must be a parsed object, JSON string, or Uint8Array.");
 }
 
+// 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.
+function resolveTemplateInput(presentation, options) {
+  if (typeof opfCore.resolveVariables !== "function" || !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 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,
+      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 });
+  }
+  return result.presentation;
+}
+
 function assertValidBoundary(presentation) {
   const result = validatePresentation(presentation);
   if (!result.valid) {
@@ -228,8 +260,14 @@ 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 (!source) return [];
+  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/")) {
@@ -341,6 +379,12 @@ function normalizeColor(value, fallback) {
 
 /** Resolve content ColorRef via core; keep authored #RRGGBB / #RRGGBBAA casing. */
 function resolveColorRef(value, bound, fallback) {
+  return resolveColorRefIn(value, bound.design, fallback);
+}
+
+// `design` supplies colorScheme, colors (roles) and variables; resolveDesign passes a
+// partial one for the background, before the text-dependent roles exist.
+function resolveColorRefIn(value, design, fallback) {
   if (value == null || value === "") return fallback;
   if (typeof value !== "string") return fallback;
   const trimmed = value.trim();
@@ -348,9 +392,9 @@ function resolveColorRef(value, bound, fallback) {
   // Packed-browser editor checks keep toolbar hex like #2563eb as authored.
   if (/^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/.test(trimmed)) return trimmed;
   if (/^#[0-9a-fA-F]{3}$/.test(trimmed)) return normalizeColor(trimmed, fallback);
-  const colors = bound.design.colors ?? {};
+  const colors = design.colors ?? {};
   return resolveCoreColorRef(trimmed, {
-    colorScheme: bound.design.colorScheme ?? {},
+    colorScheme: design.colorScheme ?? {},
     roles: {
       primary: colors.primary,
       secondary: colors.secondary,
@@ -360,18 +404,30 @@ function resolveColorRef(value, bound, fallback) {
       text: colors.text,
       textSecondary: colors.mutedText
     },
-    variables: bound.design.variables,
+    variables: design.variables,
     fallback
   });
 }
 
-function resolveBackground(background, colorScheme) {
+// Background fills: a literal hex keeps normalizeColor's behaviour (uppercase, alpha kept);
+// anything else is a ColorRef (var:id, scheme slot or role) resolved like table fills and run
+// colours, falling back exactly as an unparseable literal did.
+// Roles resolve through the colour scheme only: background, surface and text are derived from the
+// background itself (the contrast text), so a reference must not see them.
+function resolveBackgroundColor(value, design, fallback) {
+  const literal = normalizeColor(value, null);
+  if (literal) return literal;
+  const { primary, secondary, accent } = design.colors ?? {};
+  return resolveColorRefIn(value, { colorScheme: design.colorScheme, colors: { primary, secondary, accent }, variables: design.variables }, fallback);
+}
+
+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");
-  if (background.type === "solid") return normalizeColor(background.color, "#FFFFFF");
+  if (background.type === "solid") return resolveBackgroundColor(background.color, design, "#FFFFFF");
   if (background.type === "gradient") return null;
-  if (background.type === "pattern") return normalizeColor(background.pattern?.backgroundColor, "#FFFFFF");
+  if (background.type === "pattern") return resolveBackgroundColor(background.pattern?.backgroundColor, design, "#FFFFFF");
   return colorFromScheme(colorScheme, "light1", "#FFFFFF");
 }
 
@@ -385,6 +441,21 @@ function colorLuminance(color) {
   return channels[0] * 0.2126 + channels[1] * 0.7152 + channels[2] * 0.0722;
 }
 
+// FF-61: WCAG 2.x contrast ratio, (L1 + 0.05) / (L2 + 0.05) with L1 the lighter relative luminance. The slide tag
+// draws in the primary colour unless that is under 4.5:1 against the slide background; opf-pptx applies the same
+// rule with the same arithmetic (test/tag-colour.mjs in both repositories pins the same colour pairs).
+const TAG_MIN_CONTRAST = 4.5;
+function contrastRatio(first, second) {
+  const a = colorLuminance(first), b = colorLuminance(second);
+  return (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
+}
+// The slide background the tag sits on: the resolved solid or pattern colour, else (gradient) the scheme light1,
+// the colour the background rect also falls back to and opf-pptx uses for a background that is not one colour.
+function tagFill(design) {
+  const background = design.backgroundColor ?? design.colors.background;
+  return contrastRatio(design.colors.primary, background) < TAG_MIN_CONTRAST ? design.colors.text : design.colors.primary;
+}
+
 function resolveDesign(presentation, slide, context, index) {
   const deckDesign = presentation.design ?? {};
   const slideDesign = slide.design ?? {};
@@ -411,7 +482,12 @@ function resolveDesign(presentation, slide, context, index) {
   );
   const dimensions = resolveDimensions(slideDesign.dimensions ?? deckDesign.dimensions ?? theme.dimensions);
   const backgroundDefinition = slideDesign.background ?? deckDesign.background ?? theme.background;
-  const backgroundColor = resolveBackground(backgroundDefinition, colorScheme);
+  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 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");
 
@@ -422,7 +498,7 @@ function resolveDesign(presentation, slide, context, index) {
     colorScheme,
     fontScheme,
     dimensions,
-    variables: presentation.variables ?? {},
+    variables,
     background: backgroundDefinition,
     backgroundColor,
     colors: {
@@ -430,12 +506,13 @@ function resolveDesign(presentation, slide, context, index) {
       surface: colorFromScheme(colorScheme, darkBackground ? "dark2" : "light2", darkBackground ? "#1E293B" : "#F8FAFC"),
       text: textColor,
       mutedText: colorFromScheme(colorScheme, darkBackground ? "light2" : "dark2", darkBackground ? "#E2E8F0" : "#334155"),
-      primary: normalizeColor(colorScheme.primary, null) ?? colorFromScheme(colorScheme, "accent1", "#2563EB"),
-      secondary: normalizeColor(colorScheme.secondary, null) ?? colorFromScheme(colorScheme, "accent2", "#0F766E"),
-      accent: normalizeColor(colorScheme.accent, null) ?? colorFromScheme(colorScheme, "accent3", "#F59E0B"),
+      primary,
+      secondary,
+      accent,
       border: colorFromScheme(colorScheme, "accent5", "#CBD5E1")
     },
     fonts: resolveFontFamilies(fontScheme),
+    darkBackground,
     diagnostics: fontSchemeDiagnostic ? [fontSchemeDiagnostic] : []
   };
 }
@@ -494,18 +571,26 @@ function reportLanguageDiagnostic(context, diagnostic) {
  */
 function reportGlyphFallback(context, note) {
   context.glyphFallbackDiagnostics ??= new Set();
-  const key = `${note.fontFamily}\u0000${note.fallbackFamily}\u0000${note.path ?? ""}`;
+  const key = `${note.fontFamily}\u0000${note.fallbackFamily}\u0000${note.placeholder ?? ""}\u0000${note.path ?? ""}`;
   if (context.glyphFallbackDiagnostics.has(key)) return;
   context.glyphFallbackDiagnostics.add(key);
+  // FF-45: a symbol-encoded family's note lists the codes drawn as their Unicode equivalents, or as the placeholder.
+  const symbol = Array.isArray(note.codes);
+  const codes = symbol ? note.codes.slice(0, 8).map(code => `0x${code}`).join(", ") : "";
   context.options.onDiagnostic?.({
     code: "font-glyph-fallback",
     ...(note.path ? { path: note.path } : {}),
     // The note is reported once per family pair and path: it names characters the face lacks, such as these, not every one.
-    message: `'${note.fontFamily}' lacks glyphs for characters such as ${note.characters.slice(0, 8).map(character => `U+${character.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}`).join(", ")}; the preview draws those with '${note.fallbackFamily}'. The PPTX keeps the chosen font.`,
+    message: symbol
+      ? (note.placeholder
+        ? `'${note.fontFamily}' is symbol-encoded; codes such as ${codes} have no Unicode equivalent that a loaded face draws, so the preview draws the placeholder '${note.placeholder}' with '${note.fallbackFamily}'. The PPTX keeps the chosen font and the original codes.`
+        : `'${note.fontFamily}' is symbol-encoded and not bundled; the preview draws codes such as ${codes} as their Unicode equivalents with '${note.fallbackFamily}'. The PPTX keeps the chosen font and the original codes.`)
+      : `'${note.fontFamily}' lacks glyphs for characters such as ${note.characters.slice(0, 8).map(character => `U+${character.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}`).join(", ")}; the preview draws those with '${note.fallbackFamily}'. The PPTX keeps the chosen font.`,
     fontFamily: note.fontFamily,
     fallbackFamily: note.fallbackFamily,
     scripts: [...note.scripts],
-    characters: [...note.characters]
+    characters: [...note.characters],
+    ...(symbol ? { codes: [...note.codes], ...(note.placeholder ? { placeholder: note.placeholder } : {}) } : {})
   });
 }
 
@@ -638,8 +723,15 @@ function bindSlide(presentation, slide, layout, index, context) {
     onFallback: note => reportGlyphFallback(context, note)
   });
   const textMeasurement = scriptFonts.textMeasurement ?? context.options.textMeasurement;
-  for (const role of ["heading","body","code"]) design.fonts[role] = resolveTextStyle({fontFamily:design.fonts[role],fontWeight:role === "heading" ? 700 : 400},textMeasurement).fontFamily;
-  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, textMeasurement, date: context.options.date, socialPlatforms: socialPlatformRecords(context) });
+  // fontScheme.accent (the tag and quote text) exists only with a core that resolves it; it 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.
+  for (const role of ["heading","body","code","accent"]) if (design.fonts[role] !== undefined) {
+    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) });
   return {
     scriptFonts,
     textMeasurement,
@@ -657,7 +749,7 @@ function bindSlide(presentation, slide, layout, index, context) {
 }
 
 export function resolvePresentation(input, options = {}) {
-  const presentation = parseInput(input);
+  const presentation = resolveTemplateInput(parseInput(input), options);
   if (options.validate !== false) {
     assertValidBoundary(presentation);
   }
@@ -706,10 +798,18 @@ function renderResolvedSlide(resolved, slideIndex, 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.
+    renderFootnotes(bound, options, drawHelpers),
     renderFurniture(bound, resolved.presentation, width, height, options, "header"),
     renderFurniture(bound, resolved.presentation, width, height, options, "footer")
   ].filter(Boolean);
   const children = [renderEmbeddedFonts(embeddedFontsFor(options.embeddedFonts, content)), ...content].filter(Boolean);
+  // FF-44: Chromium (123+) trims adjacent fullwidth punctuation by default (CSS text-spacing-trim: normal; a sequence such as
+  // 「」。 is up to 10 percent narrower), but measurement and PowerPoint advance every such character by its full width, so the browser
+  // would stretch the glyphs back to the pinned textLength. space-all keeps the drawn advances equal to the measured ones. Only slides
+  // that draw such punctuation carry it, so other output is unchanged.
+  const drawn = content.join("");
+  const trimsPunctuation = /[　-〿＀-￯]/.test(drawn) || (script?.scriptRole === "eastAsian" && /[‘-”]/.test(drawn));
 
   return tag(
     "svg",
@@ -722,6 +822,7 @@ function renderResolvedSlide(resolved, slideIndex, options) {
       height,
       lang,
       "xml:lang": lang,
+      style: trimsPunctuation ? "text-spacing-trim:space-all" : undefined,
       ...traceAttrs(options, bound.path)
     },
     `\n${children.join("\n")}\n`
@@ -737,7 +838,7 @@ function renderBackground(bound, width, height, options) {
     const dx=Math.cos(angle)*50,dy=Math.sin(angle)*50;
     const stopTags = stops.map((stop, index) => tag("stop", {
       offset: stableNumber((stop.position ?? index / Math.max(1, stops.length - 1)) * 100) + "%",
-      "stop-color": normalizeColor(stop.color, bound.design.colors.background)
+      "stop-color": resolveBackgroundColor(stop.color, bound.design, bound.design.colors.background)
     }));
     return [
       tag("defs", traceAttrs(options, `${bound.path}.design.background`), tag("linearGradient", {
@@ -768,13 +869,17 @@ function renderBackground(bound, width, height, options) {
     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=normalizeColor(pattern.foregroundColor,bound.design.colors.text),preset=pattern.preset;
-    // 8px cells approximating DrawingML presets. diagStripe is the engine id that
-    // PPTX export writes as wdUpDiag, so both draw the same rising stripe.
+    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});
-    const mark=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'):'';
+    // 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;
     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:normalizeColor(pattern.backgroundColor,'#FFFFFF')})+tag('defs',{},tag('pattern',{id,width:8,height:8,patternUnits:'userSpaceOnUse'},mark))+tag('rect',{width,height,fill:`url(#${id})`}));
+    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})`}));
   }
   return tag("rect", {
     x: 0,
@@ -849,9 +954,12 @@ function renderSlideContent(bound, width, height, options) {
   return bound.geometry.items.map(item => {
     const frame=item.frameBox;
     const surface=frame ? tag('rect',{x:frame.x,y:frame.y,width:frame.width,height:frame.height,rx:8*Math.min(width,height)/720,fill:bound.design.colors.surface,stroke:bound.design.colors.border,...traceAttrs(options,item.path)}) : '';
-    return surface+renderPayload(item, item.box, { ...bound, composition: item.composition }, options);
+    // RR-34: a captioned item draws its media in item.box and its caption band after it (src/annotations.js).
+    return surface+renderPayload(item, item.box, { ...bound, composition: item.composition }, options)+(item.caption?renderCaption(item,{ ...bound, composition: item.composition },options,drawHelpers):'');
   });
 }
+// Draw helpers injected into src/annotations.js (captions and footnote areas).
+const drawHelpers = { tag, renderTextBox, renderRichLines };
 
 function reportDiagnostic(diagnostic, options) {
   const key = `${diagnostic.code}:${diagnostic.path}:${diagnostic.reason ?? ''}`;
@@ -895,11 +1003,13 @@ function renderTextPayload(item, box, bound, options) {
     // follow design.titleAlignment only (unset is left, as in core composition).
     align: item.alignment ?? (item.field === "title" ? bound.design.titleAlignment ?? "left" : bound.design.contentAlignment),
     fontSize: item.field === "title" ? 54 : item.field === "tag" ? 16 : 25,
-    fontFamily: item.field === "title" ? bound.design.fonts.heading : bound.design.fonts.body,
+    // 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,
     fontWeight: item.field === "title" ? 700 : 400,
     // The slide tag is the eyebrow label: it draws in the primary colour (scheme accent1), as the
-    // PPTX export writes it. Every other text payload here uses the text colour.
-    fill: item.field === "tag" ? bound.design.colors.primary : bound.design.colors.text,
+    // PPTX export writes it, or in the text colour when the primary is under 4.5:1 against the
+    // slide background (FF-61). Every other text payload here uses the text colour.
+    fill: item.field === "tag" ? tagFill(bound.design) : bound.design.colors.text,
     fit: item.text,
     textStyle: item.textStyle,
     diagnosticsHandled: Boolean(item.text),
@@ -909,10 +1019,13 @@ 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});
+  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 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;
   for(const entry of fit.listEntries){
-    children.push(tag('text',{x:stableNumber(entry.marker.x),y:stableNumber(entry.marker.y),'font-family':fontStack(entry.marker.style.fontFamily,bound.design.fontScheme.type),'font-size':stableNumber(entry.marker.fontSize),fill:bound.design.colors.text,'aria-hidden':'true'},escapeText(entry.marker.text)));
+    if(bullet){const box=entry.bulletBox??{x:entry.marker.x,y:entry.marker.y-entry.marker.fontSize*.65,width:entry.marker.fontSize*.65,height:entry.marker.fontSize*.65};children.push(tag('image',{x:stableNumber(box.x),y:stableNumber(box.y),width:stableNumber(box.width),height:stableNumber(box.height),href:bullet,preserveAspectRatio:'xMidYMid meet','aria-hidden':'true',...(options.trace?{'data-opf-generated':'true'}:{})}));}
+    else children.push(tag('text',{x:stableNumber(entry.marker.x),y:stableNumber(entry.marker.y),'font-family':fontStack(entry.marker.style.fontFamily,bound.design.fontScheme.type),'font-size':stableNumber(entry.marker.fontSize),...numberMarkerStyle(entry.marker),fill:bound.design.colors.text,'aria-hidden':'true',...(entry.marker.anchor==='end'?{'text-anchor':'end'}:{})},escapeText(entry.marker.text)));
     const config={path:entry.textPath,align:'left',fill:bound.design.colors.text,rich:Array.isArray(entry.value),options};
     children.push(renderRichLines(typeof entry.value==='string'?[entry.value]:entry.value,entry.text,entry.textBox,bound,config));
     if(entry.description)children.push(renderRichLines(typeof entry.descriptionValue==='string'?[entry.descriptionValue]:entry.descriptionValue,entry.description,entry.descriptionBox,bound,{...config,path:entry.descriptionPath,rich:Array.isArray(entry.descriptionValue),fill:bound.design.colors.mutedText}));
@@ -920,7 +1033,15 @@ function renderList(item, box, bound, options) {
   return tag('g',{...traceAttrs(options,item.path),...(fit.overflow?{'data-opf-overflow':'true'}:{})},children.join('\n'));
 }
 
-function renderImage(item, box, bound, options) {
+// A numbered list's marker (numbering) draws the number with the weight and slant core measured it at: PowerPoint draws an
+// auto-number in the first run's character formatting. Bullet markers carry no such attributes.
+function numberMarkerStyle(marker) {
+  if (!marker.number) return {};
+  return {'font-weight':marker.style.fontWeight===400?undefined:marker.style.fontWeight,'font-style':marker.style.italic?'italic':undefined};
+}
+
+// Follows asset: references and the host imageResolver to the drawable source of an image value.
+function resolveImageSource(item, bound, options) {
   let asset = normalizeAsset(item.value);
   const seen = new Set();
   let missingReference;
@@ -933,13 +1054,168 @@ function renderImage(item, box, bound, options) {
     asset = {...normalizeAsset(bound.assets[id]),...overrides};
   }
   const source = options.imageResolver?.(asset.src, { asset, path: item.path }) ?? asset.src;
-  if (typeof source === "string" && /^data:image\/(png|jpeg|gif|webp);base64,/i.test(source)) {
+  // An SVG data URI (base64 or text, any encoding) is drawn as an image too, as a base64 URI: an SVG used as an image never
+  // runs scripts or loads anything outside itself, in a browser or in the PNG/PDF rasterizer.
+  const svg = typeof source === "string" ? svgImageSource(source) : null;
+  const drawable = svg !== null || (typeof source === "string" && /^data:image\/(png|jpeg|gif|webp);base64,/i.test(source));
+  return { asset, source: svg ?? source, drawable, missingReference };
+}
+
+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
+// well-formed XML (and safe: no external or markup entity) with an <svg> root in the SVG namespace and an intrinsic size
+// (width and height, or a viewBox) - the same checks opf-pptx makes before it writes a native SVG picture over a PNG
+// fallback - so a document the export refuses (malformed, unsafe, no size) is the placeholder in the preview too, and the
+// two agree. The scripts, foreign objects and external references a valid document may carry are never run or loaded: an
+// SVG used as an image reaches nothing outside itself.
+function svgImageSource(uri) {
+  const header = /^data:([^;,]*)((?:;[^;,]*)*),/i.exec(uri);
+  if (!header || !/^image\/svg\+xml$/i.test(header[1])) return null;
+  let bytes;
+  try {
+    const payload = uri.slice(header[0].length);
+    bytes = /;base64/i.test(header[2]) ? Uint8Array.from(atob(payload.replace(/\s+/g, "")), char => char.charCodeAt(0)) : new TextEncoder().encode(decodeURIComponent(payload));
+  } catch { return null; }
+  if (bytes.length > SVG_IMAGE_MAX_BYTES) return null;
+  let text;
+  try { text = decodeSvgText(bytes); } catch { return null; }
+  const root = svgRootAttributes(text);
+  if (!root || !svgHasIntrinsicSize(root)) return null;
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += 0x8000) binary += String.fromCharCode(...bytes.subarray(index, index + 0x8000));
+  return `data:image/svg+xml;base64,${btoa(binary)}`;
+}
+
+const SVG_IMAGE_MAX_BYTES = 8 * 1024 * 1024;
+
+// UTF-8 (with or without a BOM), UTF-16 with a BOM, or the encoding the XML declaration names; throws on bytes the encoding cannot decode.
+function decodeSvgText(bytes) {
+  let start = 0, label = "utf-8";
+  if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) start = 3;
+  else if (bytes[0] === 0xff && bytes[1] === 0xfe) { label = "utf-16le"; start = 2; }
+  else if (bytes[0] === 0xfe && bytes[1] === 0xff) { label = "utf-16be"; start = 2; }
+  else {
+    const declared = /^\s*<\?xml\b[^>]*\bencoding\s*=\s*["']([A-Za-z0-9._-]+)["']/.exec(String.fromCharCode(...bytes.subarray(0, 200)))?.[1];
+    if (declared && !/^utf-?8$/i.test(declared)) label = declared;
+  }
+  return new TextDecoder(label, { fatal: true }).decode(bytes.subarray(start));
+}
+
+const SVG_START_TAG = /<([A-Za-z_][\w.-]*(?::[A-Za-z_][\w.-]*)?)((?:\s+[^\s=\/>"'<]+\s*=\s*(?:"[^"<]*"|'[^'<]*'))*)\s*(\/?)>/y;
+const SVG_ATTRIBUTE = /\s+([^\s=\/>"'<]+)\s*=\s*(?:"([^"<]*)"|'([^'<]*)')/y;
+const SVG_END_TAG = /<\/([A-Za-z_][\w.-]*(?::[A-Za-z_][\w.-]*)?)\s*>/y;
+
+// The root element's attributes (references expanded) of a well-formed, safe SVG document in the SVG namespace, else null.
+// A small XML check, not a parser: tags nest and close, attributes are quoted and unique, the one root is <svg>, text sits
+// inside it, and every reference is one of the five predefined entities, a numeric reference or a plain-text entity the
+// DOCTYPE declares. An entity that is external or contains markup, or expansions beyond the size limit, refuse the document.
+function svgRootAttributes(text) {
+  const stack = [], entities = new Map();
+  let index = 0, rootDone = false, rootAttributes = null, expansion = 0;
+  const references = value => value.replace(/&([^;\s&<]*);?/g, (all, name) => {
+    if (!all.endsWith(";")) throw new Error("reference");
+    if (/^(?:amp|lt|gt|quot|apos|#\d{1,7}|#x[0-9a-fA-F]{1,6})$/.test(name)) return all;
+    if (!entities.has(name)) throw new Error("undeclared entity");
+    const expanded = entities.get(name);
+    if ((expansion += expanded.length) > SVG_IMAGE_MAX_BYTES) throw new Error("entity expansion");
+    return expanded;
+  });
+  try {
+    while (index < text.length) {
+      if (text[index] !== "<") {
+        const end = text.indexOf("<", index), chunk = text.slice(index, end < 0 ? text.length : end);
+        index += chunk.length;
+        if (!stack.length) { if (chunk.trim()) return null; }
+        else { if (chunk.includes("]]>")) return null; references(chunk); }
+        continue;
+      }
+      if (text.startsWith("<!--", index)) {
+        const end = text.indexOf("-->", index + 4);
+        if (end < 0) return null;
+        index = end + 3;
+      } else if (text.startsWith("<![CDATA[", index)) {
+        const end = text.indexOf("]]>", index + 9);
+        if (end < 0 || !stack.length) return null;
+        index = end + 3;
+      } else if (text.startsWith("<?", index)) {
+        const end = text.indexOf("?>", index + 2);
+        if (end < 0) return null;
+        index = end + 2;
+      } else if (text.startsWith("<!DOCTYPE", index)) {
+        if (rootDone || stack.length || rootAttributes) return null;
+        const match = /^<!DOCTYPE\s+[^\[>]*(?:\[([\s\S]*?)\]\s*)?>/.exec(text.slice(index));
+        if (!match) return null;
+        for (const declaration of (match[1] ?? "").matchAll(/<!ENTITY\b[^>]*>/g)) {
+          const entity = /^<!ENTITY\s+([A-Za-z_][\w.-]*)\s+(?:"([^"]*)"|'([^']*)')\s*>$/.exec(declaration[0]);
+          const value = entity?.[2] ?? entity?.[3];
+          if (!entity || value.includes("&") || value.includes("<")) return null;
+          entities.set(entity[1], value);
+        }
+        index += match[0].length;
+      } else if (text.startsWith("</", index)) {
+        SVG_END_TAG.lastIndex = index;
+        const match = SVG_END_TAG.exec(text);
+        if (!match || stack.pop() !== match[1]) return null;
+        index = SVG_END_TAG.lastIndex;
+        if (!stack.length) rootDone = true;
+      } else {
+        SVG_START_TAG.lastIndex = index;
+        const match = SVG_START_TAG.exec(text);
+        if (!match) return null;
+        index = SVG_START_TAG.lastIndex;
+        const [, qualified, source, selfClosing] = match;
+        const attributes = [], names = new Set();
+        SVG_ATTRIBUTE.lastIndex = 0;
+        for (let attribute; source && (attribute = SVG_ATTRIBUTE.exec(source));) {
+          if (names.has(attribute[1])) return null;
+          names.add(attribute[1]);
+          attributes.push([attribute[1], references(attribute[2] ?? attribute[3])]);
+        }
+        if (!stack.length) {
+          if (rootDone || rootAttributes) return null;
+          const colon = qualified.indexOf(":");
+          if (qualified.slice(colon + 1) !== "svg") return null;
+          const namespace = colon < 0 ? "xmlns" : `xmlns:${qualified.slice(0, colon)}`;
+          if (!attributes.some(([key, value]) => key === namespace && value === SVG_NAMESPACE)) return null;
+          rootAttributes = Object.fromEntries(attributes);
+        }
+        if (selfClosing) { if (!stack.length) rootDone = true; }
+        else stack.push(qualified);
+      }
+    }
+  } catch { return null; }
+  return stack.length || !rootAttributes ? null : rootAttributes;
+}
+
+// The root has an intrinsic size: width and height lengths, or a viewBox (the same rule core and opf-pptx use).
+function svgHasIntrinsicSize(attributes) {
+  const length = value => { const match = value && /^\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)\s*(px|pt|pc|mm|cm|in|q)?\s*$/i.exec(value); return match && Number(match[1]) > 0 ? Number(match[1]) : undefined; };
+  const box = (attributes.viewBox ?? "").trim().split(/[\s,]+/).map(Number);
+  const view = box.length === 4 && box.every(Number.isFinite) && box[2] > 0 && box[3] > 0;
+  return Boolean((length(attributes.width) && length(attributes.height)) || view);
+}
+
+// The drawable data URI of a picture bullet, or undefined (after reporting unresolved-asset once) so the glyph marker stays.
+function resolveBulletImage(bulletImage, bound, options) {
+  const { drawable, source, asset, missingReference } = resolveImageSource({ value: bulletImage.source, path: bulletImage.path }, bound, options);
+  if (drawable) return source;
+  const reason=missingReference?'missing-reference':!asset.src?'missing-source':'unsupported-source';
+  const message=missingReference?`Bullet image asset ${missingReference} is missing; the preview draws the character bullet.`:'A picture bullet requires an embedded raster data URI or a host imageResolver; the preview draws the character bullet.';
+  if (options.strictAssets) throw new OPFRenderError("unresolved-asset", message, { path: bulletImage.path,reason });
+  reportDiagnostic({code:'unresolved-asset',path:bulletImage.path,message,reason,source:asset.src,assetId:missingReference,description:asset.alt??asset.title??'Bullet image',placeholder:'glyph'},options);
+  return undefined;
+}
+
+function renderImage(item, box, bound, options) {
+  const { asset, source, drawable, missingReference } = resolveImageSource(item, bound, options);
+  if (drawable) {
     return tag("image", { x: box.x, y: box.y, width: box.width, height: box.height,
-      href: source, preserveAspectRatio: (options.imageFit ?? (bound.design.imageFill === "crop" ? "cover" : "contain")) === "cover" ? "xMidYMid slice" : "xMidYMid meet", role: "img", "aria-label": asset.alt ?? "Image",
-      ...traceAttrs(options, item.path) });
+      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) });
   }
   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 data URI or a host imageResolver.';
+  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.';
   if (options.strictAssets) throw new OPFRenderError("unresolved-asset", message, { path: item.path,reason });
   const fill = bound.design.colors.surface;
   const scale=Math.min(bound.design.dimensions.width,bound.design.dimensions.height)/720;
@@ -981,7 +1257,7 @@ function renderImage(item, box, bound, options) {
     const size=Math.max(0,Math.min(inner.width,inner.height,24*scale)),icon=centeredBox(inner,size,size);
     children.push(tag('path',{d:`M ${icon.x} ${icon.y} L ${icon.x+size} ${icon.y+size} M ${icon.x+size} ${icon.y} L ${icon.x} ${icon.y+size}`,fill:'none',stroke:textColor,'stroke-width':Math.min(2*scale,size/8),'aria-hidden':'true'}));
   }
-  return tag("g", {...traceAttrs(options,item.path),'data-opf-asset-status':'unresolved',role:'img','aria-label':`Image unavailable: ${description}`},children.join("\n"));
+  return tag("g", {...traceAttrs(options,item.path),...generatedAttrs(options),'data-opf-asset-status':'unresolved',role:'img','aria-label':`Image unavailable: ${description}`},children.join("\n"));
 }
 
 function renderMedia(item, box, bound, options) {
@@ -1032,6 +1308,7 @@ function renderCode(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-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 children = [
     tag("rect", {
       x: box.x,
@@ -1059,7 +1336,7 @@ 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})).join('')));
+    },segment,part.text.slice(segment.start,segment.end),part.style,bound,'monospace',{rtl:false,fontSize:part.fit.fontSize},part.role==='body'?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')));
@@ -1071,6 +1348,9 @@ function renderMetric(item, box, bound, options) {
   const layout=item.metricLayout;
   if (!layout) throw new OPFRenderError('missing-metric-layout','Metric rendering requires coordinated core metric geometry.',{path:item.path});
   const children=[];
+  // RR-07: a trend draws an arrow beside its word and colours the trend and delta text, from core's accepted geometry.
+  const trendMark=metricTrendMark(layout,bound,options);
+  const partFill=part=>trendMark&&(part.role==='trend'||part.role==='delta')?trendMark.color:part.role==='value'?bound.design.colors.primary:bound.design.colors.text;
   for (const part of layout.parts) {
     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});
@@ -1086,30 +1366,37 @@ function renderMetric(item, box, bound, options) {
       if(factor&&!line.segments.some(segment=>segment.kind==='tab'))return tag('text',{x:stableNumber(origin.x+line.width*factor),y:stableNumber(origin.baseline),'text-anchor':factor===1?'end':'middle',
         'font-family':fontStack(part.style.fontFamily,bound.design.fontScheme.type),'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==='value'?bound.design.colors.primary:bound.design.colors.text,
+        'xml:space':'preserve',style:'white-space:pre','text-rendering':'geometricPrecision',fill:partFill(part),
         ...traceAttrs(options,part.path),...(options.trace?{'data-opf-metric-role':part.role,'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({
         ...(options.trace?{'data-opf-segment':segment.kind,'data-opf-text-start':segment.start,'data-opf-text-end':segment.end}:{}),
-      },segment,part.text.slice(segment.start,segment.end),part.style,bound,bound.design.fontScheme.type,{rtl:partRtl(line.start)})).join(''));
+      },segment,part.text.slice(segment.start,segment.end),part.style,bound,bound.design.fontScheme.type,{rtl:partRtl(line.start),fontSize:part.fit.fontSize})).join(''));
       return tag('text',{x:stableNumber(origin.x),y:stableNumber(origin.baseline),'text-anchor':'start',
         'font-family':fontStack(part.style.fontFamily,bound.design.fontScheme.type),'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==='value'?bound.design.colors.primary:bound.design.colors.text,
+        'xml:space':'preserve',style:'white-space:pre','text-rendering':'geometricPrecision',fill:partFill(part),
         ...traceAttrs(options,part.path),...(options.trace?{'data-opf-metric-role':part.role,'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({x:stableNumber(origin.x+segment.x),
         ...(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}:{}),
-      },segment,part.text.slice(segment.start,segment.end),part.style,bound,bound.design.fontScheme.type,{rtl:partRtl(line.start)})).join(''));
+      },segment,part.text.slice(segment.start,segment.end),part.style,bound,bound.design.fontScheme.type,{rtl:partRtl(line.start),fontSize:part.fit.fontSize})).join(''));
     });
     children.push(tag('g',{...traceAttrs(options,part.path),...(options.trace?{'data-opf-metric-role':part.role,
       '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')));
   }
+  if (trendMark) children.push(tag('g',{role:'img','aria-label':trendMark.ariaLabel},tag('polygon',{points:trendMark.points.map(([x,y])=>`${stableNumber(x)},${stableNumber(y)}`).join(' '),fill:trendMark.color})));
   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.
+function metricTrendMark(layout,bound,options) {
+  if (typeof opfCore.metricTrendMark!=='function') return undefined;
+  return opfCore.metricTrendMark(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});
@@ -1142,7 +1429,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});
+  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, ...(bound.geometry?.direction === "rtl" ? {direction:"rtl"} : {})});
   const children = [];
   const separateBorders = layout.rows.some(row => row.cells.some(cell => cell.style?.borders));
   const defaultEdges = [], explicitEdges = [];
@@ -1348,12 +1635,20 @@ function renderBranding(bound,presentation,width,height,options) {
   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.
+  const logo=bound.geometry.logo;
+  if(logo)pieces.push(renderImage({value:logo.source,path:logo.path},logo.box,bound,{...options,imageAnchor:logo.anchor??'left',imageLabel:'Logo',imageGenerated:true}));
   return pieces.join('');
 }
 
+// A family name is written unquoted only when it is a valid sequence of CSS identifiers; a word that starts with a digit
+// ("Source Sans 3", "Noto Sans Symbols 2") or any other non-identifier character makes an unquoted name invalid CSS, which
+// drops the whole font-family in a browser (FF-45). Such names are single-quoted (the attribute is double-quoted).
+const cssIdentifierSequence = /^(?:-?(?:[A-Za-z_ -￿]|\\.)(?:[\w -￿-]|\\.)*)(?: (?:-?(?:[A-Za-z_ -￿]|\\.)(?:[\w -￿-]|\\.)*))*$/;
+const cssFamily = name => cssIdentifierSequence.test(name) && !/^(?:inherit|initial|unset|default|serif|sans-serif|monospace|cursive|fantasy|system-ui)$/i.test(name) ? name : `'${name.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
 function fontStack(family, type) {
   const fallback = type === "serif" ? "serif" : type === "monospace" ? "monospace" : "sans-serif";
-  return `${[family].flat().join(", ")}, ${fallback}`;
+  return `${[family].flat().map(cssFamily).join(", ")}, ${fallback}`;
 }
 
 // Unicode directional isolates (FF-19): each paragraph (text between hard line
@@ -1366,6 +1661,10 @@ 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;
 /** 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;
@@ -1393,43 +1692,81 @@ function nestedReset(style, run) {
   return parent && !disabledFeaturesStyle([run.stack ?? run.family].flat()[0]) ? RESET_POLICY_FEATURES : undefined;
 }
 
-function scriptLine(text, style, bound, type, { rtl = false, placement, trace } = {}) {
+function scriptLine(text, style, bound, type, { rtl = false, placement, trace, fontSize } = {}) {
   const value = String(text ?? "");
   const scripts = 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 }];
-  if (runs.length === 1) {
+  // RR-38: PowerPoint's baseline of a line in Arabic Typesetting sits above core's (one em below the line top): the caller moves it up by `baselineShift` em.
+  const shiftOf = list => { const shift = baselineShift(list); return shift ? { baselineShift: shift } : {}; };
+  // FF-45: symbol runs (Wingdings, Symbol, Webdings codes drawn as their Unicode equivalents) are always positioned when the
+  // line is placed, one tspan per glyph at the verified symbol font's advance, so a single mapped glyph is never stretched to it.
+  const symbols = runs.some(run => run.symbol);
+  if (runs.length === 1 && !(symbols && placement && placement.width > 0)) {
     const [run] = runs;
-    return { content: isolate(escapeText(value)), family: run.own ? undefined : fontStack(run.stack ?? run.family, type) };
+    // RR-38: a replacement the policy scales (Arabic Typesetting -> Noto Naskh Arabic, 0.64) is drawn at the scaled size; the caller applies it.
+    return { content: isolate(escapeText(run.own ? value : run.text)), family: run.own ? undefined : fontStack(run.stack ?? run.family, type), ...(run.sizeAdjust ? { sizeAdjust: run.sizeAdjust } : {}), ...shiftOf(runs) };
   }
+  const baseSize = placement?.fontSize ?? fontSize;
+  const adjusted = run => run.sizeAdjust && baseSize > 0 ? stableNumber(adjustedFontSize(baseSize, run.sizeAdjust)) : undefined;
   const widths = placement && placement.width > 0 ? scripts.runWidths(runs, placement.fontSize, style) : undefined;
   if (!widths) {
     return { content: isolate(runs.map(run => run.own ? escapeText(run.text)
-      : tag("tspan", { "font-family": fontStack(run.stack ?? run.family, type), style: nestedReset(style, run) }, escapeText(run.text))).join("")) };
+      : tag("tspan", { "font-family": fontStack(run.stack ?? run.family, type), "font-size": adjusted(run), style: nestedReset(style, run) }, escapeText(run.text))).join("")), ...shiftOf(runs) };
   }
+  const natural = symbols ? scripts.runWidths(runs, placement.fontSize, style, { natural: true }) : undefined;
   const total = widths.reduce((sum, width) => sum + width, 0), factor = total > 0 ? placement.width / total : 1;
   let advance = 0, offset = 0;
   const content = runs.map((run, index) => {
     const width = widths[index] * factor, left = rtl ? placement.width - advance - width : advance;
     advance += width;
     const start = offset;
-    offset += run.text.length;
+    offset += run.symbol ? run.symbol.source.length : run.text.length;
+    // A symbol glyph keeps the open face's shape: it is compressed to its code's advance only when wider, never stretched.
+    const pinned = run.symbol ? natural[index] > width + 1e-6 : width > 0;
     return tag("tspan", {
       x: stableNumber(placement.x + left),
-      textLength: width > 0 ? stableNumber(width) : undefined, lengthAdjust: width > 0 ? "spacingAndGlyphs" : undefined,
+      textLength: pinned ? stableNumber(width) : undefined, lengthAdjust: pinned ? "spacingAndGlyphs" : undefined,
       "font-family": run.own ? undefined : fontStack(run.family, type),
+      "font-size": adjusted(run),
       style: run.own ? undefined : nestedReset(style, run),
       ...(trace ? trace(start, offset) : {})
     }, isolate(escapeText(run.text)));
   }).join("");
-  return { content, positioned: true };
+  return { content, positioned: true, ...shiftOf(runs) };
 }
 
 /** One positioned code/metric segment tspan; its script runs flow inside it (no textLength). */
-function segmentSpan(attrs, segment, text, style, bound, type, options) {
+function segmentSpan(attrs, segment, text, style, bound, type, options, syntax) {
   const scripted = segment.kind === "tab" ? { content: escapeText(text) } : scriptLine(text, style, bound, type, options);
-  return tag("tspan", { ...attrs, "font-family": scripted.family }, scripted.content);
+  // 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;
+  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;
+      const piece = scriptLine(text.slice(run.start - segment.start, run.end - segment.start), style, bound, type, options);
+      const own = { ...attrs };
+      if (index > 0) delete own.x;
+      if (own["data-opf-text-start"] !== undefined) { own["data-opf-text-start"] = run.start; own["data-opf-text-end"] = run.end; }
+      return tag("tspan", { ...own, fill: run.kind ? syntax.palette[run.kind] : undefined, "font-family": piece.family, "font-size": sizeOf(piece) }, piece.content);
+    }).join("");
+  }
+  return tag("tspan", { ...attrs, "font-family": scripted.family, "font-size": scripted.sizeAdjust && options?.fontSize > 0 ? stableNumber(adjustedFontSize(options.fontSize, scripted.sizeAdjust)) : undefined }, scripted.content);
+}
+
+// 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.
+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);
+  if (!tokens.length) return undefined;
+  return { tokens, palette: opfCore.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
@@ -1492,8 +1829,30 @@ function renderRichTextBox(value, box, bound, config) {
   return renderRichLines(value,fit,box,bound,config);
 }
 
+// A rich line without its leading and trailing whitespace: fragments keep their order and styles, positions and widths follow the trimmed text.
+// Returns null when there is nothing to trim or the line holds a tab.
+function trimRichLineEdges(line,textMeasurement) {
+  const fragments=line.fragments.map(fragment=>({...fragment}));
+  if(!fragments.length||fragments.some(fragment=>fragment.kind==='tab'))return null;
+  const width=(fragment,text)=>text?textWidthMeasurer(fragment.style,textMeasurement)(text,fragment.fontSize):0;
+  let changed=false;
+  while(fragments.length&&!/\S/.test(fragments[0].text)){fragments.shift();changed=true;}
+  while(fragments.length&&!/\S/.test(fragments.at(-1).text)){fragments.pop();changed=true;}
+  if(!fragments.length)return null;
+  const first=fragments[0],last=fragments.at(-1);
+  const lead=/^\s*/.exec(first.text)[0],trail=/\s*$/.exec(last.text)[0];
+  if(lead){first.text=first.text.slice(lead.length);first.start+=lead.length;first.width-=width(first,lead);changed=true;}
+  if(trail){last.text=last.text.slice(0,-trail.length);last.end-=trail.length;last.width-=width(last,trail);changed=true;}
+  if(!changed)return null;
+  let x=0;
+  for(const fragment of fragments){fragment.x=x;x+=fragment.width;}
+  return {...line,fragments,width:x};
+}
+
 function renderRichLines(value,fit,box,bound,config) {
-  const alignment=fit.placement?.alignment??config.align??bound.design.contentAlignment;
+  const logicalAlignment=fit.placement?.alignment??config.align??bound.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;
   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(''));
@@ -1502,13 +1861,21 @@ function renderRichLines(value,fit,box,bound,config) {
   // those estimates into visible gaps. Supplied measurements keep exact origins.
   const naturalFlow=!config.options.textMeasurement?.measure&&!fit.placement;
   const hasTabs=fit.richLines.some(line=>line.fragments.some(fragment=>fragment.kind==='tab'));
-  const content=fit.richLines.map((line,lineIndex)=>{
+  const content=fit.richLines.map((sourceLine,lineIndex)=>{
+    const alignment=lineAlignment(lineIndex);
+    const sourceFirst=sourceLine.fragments[0],rtl=fit.directions?fit.directions[lineIndex]==='rtl':richRtl(sourceFirst?runOffsets[sourceFirst.runIndex]+sourceFirst.start:0);
+    // PowerPoint ignores whitespace at either edge of a right-aligned right-to-left line, so the glyph edge stays on the box edge (RR-05).
+    const edgeTrim=rtl&&alignment==='right'?trimRichLineEdges(sourceLine,config.options.textMeasurement):null;
+    const line=edgeTrim??sourceLine;
     const lineHasTab=line.fragments.some(fragment=>fragment.kind==='tab');
     const flow=naturalFlow&&!lineHasTab;
     const offset=alignment==='right'?box.width-line.width:alignment==='center'?(box.width-line.width)/2:0;
     const placed=fit.placement?.lines[lineIndex];
-    const originX=placed?.x??box.x+offset,baseline=placed?.baseline??box.y+line.baseline;
-    const firstFragment=line.fragments[0],rtl=richRtl(firstFragment?runOffsets[firstFragment.runIndex]+firstFragment.start:0);
+    // RR-38: a line with runs in a policy replacement (Arabic Typesetting) takes PowerPoint's baseline of the real font, above core's.
+    const lineShift=bound.scriptFonts?baselineShift(...line.fragments.filter(fragment=>fragment.kind!=='tab'&&fragment.text).map(fragment=>bound.scriptFonts.plan(fragment.text,fragment.style))):0;
+    const shiftPx=lineShift*Math.max(fit.fontSize,...line.fragments.map(fragment=>fragment.fontSize));
+    const originX=placed?placed.x+(edgeTrim?sourceLine.width-line.width:0):box.x+offset,baseline=(placed?.baseline??box.y+line.baseline)-shiftPx;
+    const firstFragment=line.fragments[0];
     const renderFragment=(fragment,asFlow,edges={})=>{
     const run=fragment.run;
     // Accepted outline placement owns the horizontal advance. Geometric precision
@@ -1523,11 +1890,14 @@ function renderRichLines(value,fit,box,bound,config) {
       : 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,
-      placement:fixedAdvance&&!asFlow?{x:originX+fragmentX,width:fragment.width,fontSize:fragment.fontSize}:undefined});
+      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:''}`;
-    const rendered=tag(asFlow?'tspan':'text',{...(config.options.trace?{'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(fragment.fontSize),'font-weight':fragment.style.fontWeight,'font-style':fragment.style.italic?'italic':asFlow?'normal':undefined,'text-decoration':[run.underline?'underline':'',run.strikethrough?'line-through':''].filter(Boolean).join(' ')||undefined,fill:runFill},content);
-    if(run.link&&/^(https?:|mailto:)/i.test(run.link))return tag('a',{href:run.link,target:'_blank',rel:'noopener noreferrer'},rendered);
+    // 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);
     return rendered;
     };
     if(naturalFlow&&lineHasTab) {
@@ -1544,13 +1914,14 @@ function renderRichLines(value,fit,box,bound,config) {
     if(!flow)return fragments.join('\n');
     const x=alignment==='right'?box.x+box.width:alignment==='center'?box.x+box.width/2:box.x;
     const first=line.fragments[0];
-    return tag('text',{x:stableNumber(x),y:stableNumber(box.y+line.baseline),'text-anchor':alignment==='right'?'end':alignment==='center'?'middle':'start','xml:space':'preserve','font-family':fontStack(first?.style.fontFamily??config.fontFamily,bound.design.fontScheme.type),'font-size':stableNumber(first?.fontSize??fit.fontSize),'font-weight':first?.style.fontWeight??config.fontWeight??400,'font-style':first?.style.italic?'italic':undefined,[NO_POLICY_FEATURES]:true},fragments.join(''));
+    return tag('text',{x:stableNumber(x),y:stableNumber(box.y+line.baseline-shiftPx),'text-anchor':alignment==='right'?'end':alignment==='center'?'middle':'start','xml:space':'preserve','font-family':fontStack(first?.style.fontFamily??config.fontFamily,bound.design.fontScheme.type),'font-size':stableNumber(first?.fontSize??fit.fontSize),'font-weight':first?.style.fontWeight??config.fontWeight??400,'font-style':first?.style.italic?'italic':undefined,[NO_POLICY_FEATURES]:true},fragments.join(''));
   });
   let cursor=0;
   const whole=value.map(run=>typeof run==='string'?run:run.text).join('');
   const lineTrace=config.options.trace?fit.richLines.map((line,index)=>{
     if(index){const newline=/^(\r\n|\r|\n)/.exec(whole.slice(cursor));if(newline)cursor+=newline[0].length;}
     const start=cursor;cursor+=(fit.lines[index]??'').length;
+    const alignment=lineAlignment(index);
     const offset=alignment==='right'?box.width-line.width:alignment==='center'?(box.width-line.width)/2:0;
     const placed=fit.placement?.lines[index];
     return {start,end:cursor,x:placed?.x??box.x+offset,y:placed?.y??box.y+line.y,height:placed?.height??line.height,
@@ -1577,42 +1948,50 @@ function renderTextBox(text, box, bound, config) {
   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 alignment=fit.placement?.alignment??config.align??bound.design.contentAlignment;
-  const anchor = alignment === "center" ? "middle" : alignment === "right" ? "end" : "start";
-  const x = alignment === "center" ? box.x + box.width / 2 : alignment === "right" ? box.x + box.width : box.x;
+  const logicalAlignment=fit.placement?.alignment??config.align??bound.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;
   const lines = fit.lines.map((line, index) => {
+    // Logical alignment (RR-05): a right-to-left line starts at the right edge.
+    const alignment=fit.placement?.lines[index]?.alignment??physicalAlignment(logicalAlignment,fit.directions?.[index]);
+    const anchor = alignment === "center" ? "middle" : alignment === "right" ? "end" : "start";
+    const x = alignment === "center" ? box.x + box.width / 2 : alignment === "right" ? box.x + box.width : box.x;
     const sourceLine=fit.sourceLines?.[index],placed=fit.placement?.lines[index],factor=alignment==='right'?1:alignment==='center'?.5:0;
     // The line's paragraph decides its direction: source offsets when layout has them, else the next match.
     const found=sourceLine?sourceLine.start:source.indexOf(line,cursor),lineStart=found>=0?found:cursor;cursor=lineStart+line.length;
-    const rtl=boxRtl(lineStart);
+    const rtl=fit.directions?fit.directions[index]==='rtl':boxRtl(lineStart);
     const origin=placed?.x??x-(sourceLine?.width??0)*factor;
     const tabs=sourceLine?.segments.some(segment=>segment.kind==='tab');
-    let content,family,positioned=false;
+    let content,family,positioned=false,trimWidth=0,sizeAdjust,shift=0;
     if(tabs) content=sourceLine.segments.map(segment=>{
       const segmentText=line.slice(segment.start-sourceLine.start,segment.end-sourceLine.start),fixed=segment.kind==='tab'||placed;
       const traced=(start,end)=>config.options.trace?{'data-opf-source-start':start,'data-opf-source-end':end,'data-opf-segment':segment.kind}:{};
       const scripted=segment.kind==='tab'?{content:escapeText(segmentText)}:scriptLine(segmentText,style,bound,type,{rtl,
-        placement:placed?{x:origin+segment.x,width:segment.width,fontSize:size}:undefined,
+        placement:placed?{x:origin+segment.x,width:segment.width,fontSize:size}:undefined,fontSize:size,
         trace:config.options.trace?(start,end)=>traced(segment.start+start,segment.start+end):undefined});
       if(scripted.positioned)return scripted.content;
       return tag('tspan',{
         x:stableNumber(origin+segment.x),textLength:fixed?stableNumber(segment.width):undefined,
-        lengthAdjust:fixed?'spacingAndGlyphs':undefined,'font-family':scripted.family,
+        lengthAdjust:fixed?'spacingAndGlyphs':undefined,'font-family':scripted.family,'font-size':scripted.sizeAdjust?stableNumber(adjustedFontSize(size,scripted.sizeAdjust)):undefined,
         ...traced(segment.start,segment.end),
       },scripted.content);
     }).join('');
-    else ({content,family,positioned=false}=scriptLine(line,style,bound,type,{rtl,placement:placed?.width>0?{x:placed.x,width:placed.width,fontSize:size}:undefined}));
+    else {
+      // PowerPoint ignores whitespace at either edge of a right-aligned right-to-left line (the glyph edge stays on the box edge, native check
+      // 2026-10-02), so a soft-wrapped line that keeps its trailing space, or a leading space, draws without it (RR-05).
+      const edge=rtl&&alignment==='right'?/^(\s*)([\s\S]*?)(\s*)$/.exec(line):null,trimmed=edge&&edge[2]&&(edge[1]||edge[3])?edge:null;
+      if(trimmed){const measureEdge=textWidthMeasurer(style,config.options.textMeasurement);trimWidth=measureEdge(trimmed[1],size)+measureEdge(trimmed[3],size);}
+      ({content,family,positioned=false,sizeAdjust,baselineShift:shift=0}=scriptLine(trimmed?trimmed[2]:line,style,bound,type,{rtl,placement:placed?.width>0?{x:placed.x+trimWidth,width:placed.width-trimWidth,fontSize:size}:undefined,fontSize:size}));
+    }
     // Positioned script runs carry their own x and textLength (FF-19).
     const start=tabs||positioned;
     return tag("text", {
-    x: stableNumber(tabs?origin:positioned?placed.x:placed?placed.x+placed.width*factor:x), y: stableNumber(placed?.baseline??startY + index * fit.lineHeight),
+    x: stableNumber(tabs?origin:positioned?placed.x:placed?placed.x+placed.width*factor:x), y: stableNumber((placed?.baseline??startY + index * fit.lineHeight) - shift * size),
     "text-anchor": start?'start':anchor, "font-family": family ?? fontStack(style.fontFamily, type),
-    "font-size": stableNumber(size), "font-weight": style.fontWeight, "font-style": style.italic ? "italic" : undefined, fill: config.fill,
+    "font-size": stableNumber(adjustedFontSize(size,sizeAdjust)), "font-weight": style.fontWeight, "font-style": style.italic ? "italic" : undefined, fill: config.fill,
     'xml:space':'preserve',style:'white-space:pre','text-rendering':config.options.textMeasurement?.measure?'geometricPrecision':undefined,
-    textLength:!start&&placed?.width>0?stableNumber(placed.width):undefined,lengthAdjust:!start&&placed?.width>0?'spacingAndGlyphs':undefined,
+    textLength:!start&&placed?.width>0?stableNumber(placed.width-trimWidth):undefined,lengthAdjust:!start&&placed?.width>0?'spacingAndGlyphs':undefined,
     ...traceAttrs(config.options, config.path),
     ...(config.options.trace&&sourceLine?{'data-opf-source-start':sourceLine.start,'data-opf-source-end':sourceLine.end,'data-opf-source-next-start':sourceLine.nextStart,'data-opf-line-boundary':sourceLine.boundary}:{}),
   }, content);
@@ -1681,6 +2060,11 @@ function traceAttrs(options, path) {
   return options.trace ? { "data-opf-path": path } : {};
 }
 
+// Generated pictures (the deck logo) are drawn from design fields, not authored content: editors skip them.
+function generatedAttrs(options) {
+  return options.trace && options.imageGenerated ? { "data-opf-generated": "true" } : {};
+}
+
 function stableNumber(value) {
   if (Number.isInteger(value)) return String(value);
   return Number(value).toFixed(3).replace(/\.?0+$/, "");
@@ -1706,7 +2090,7 @@ const NO_POLICY_FEATURES = Symbol("noPolicyFeatures");
 const RESET_POLICY_FEATURES = "font-variant-ligatures:normal;font-feature-settings:normal";
 function withPolicyFeatures(name, attrs) {
   if (attrs[NO_POLICY_FEATURES]) return attrs;
-  const family = (name === "text" || name === "tspan") && typeof attrs["font-family"] === "string" ? attrs["font-family"].split(",")[0].trim() : undefined;
+  const family = (name === "text" || name === "tspan") && typeof attrs["font-family"] === "string" ? attrs["font-family"].split(",")[0].trim().replace(/^'(.*)'$/, "$1") : undefined;
   const features = family && disabledFeaturesStyle(family);
   return features ? { ...attrs, style: attrs.style ? `${attrs.style};${features}` : features } : attrs;
 }