@agent-native/core 0.157.8 → 0.157.10

package/dist/ingestion/pptx.js

@@ -25,10 +25,13 @@ export async function parsePptxPresentation(fileBuffer) {
             target: slideMasterRelationship.target,
         })
         : undefined;
+    const droppedSlides = [];
     const slidePaths = slideIds.flatMap((id) => {
         const relationship = relationships.get(id);
-        if (!relationship)
+        if (!relationship) {
+            droppedSlides.push(`r:id="${id}" has no matching relationship in ppt/_rels/presentation.xml.rels`);
             return [];
+        }
         return [
             relationship.target.startsWith("/")
                 ? relationship.target.slice(1)
@@ -36,51 +39,83 @@ export async function parsePptxPresentation(fileBuffer) {
         ];
     });
     if (slidePaths.length === 0) {
+        // Scanning the package recovers every slide the rels could not name, so
+        // the unresolved ids above are no longer missing content.
+        droppedSlides.length = 0;
         slidePaths.push(...Object.keys(zip.files)
             .filter((path) => /^ppt\/slides\/slide\d+\.xml$/.test(path))
             .sort((a, b) => slideNumber(a) - slideNumber(b)));
     }
+    const unresolvedSlideIdCount = droppedSlides.length;
     // Deck-wide fallback, used when a slide's own layout→master chain can't be
     // resolved (missing rels, unusual authoring tools) — see
     // `resolveSlideMasterContext` below for the per-slide resolution that
     // presentations with more than one slide master actually need.
-    const theme = await parseTheme(zip, parseXml);
+    const theme = await parseTheme(zip, parseXml, slideMasterRelationship);
+    const tableStyles = await parseTableStyles(zip, parseXml);
     const masterColorInfo = slideMasterRelationship
         ? await parseMasterColorInfo({
             zip,
             target: slideMasterRelationship.target,
             parseXml,
         })
-        : { clrMap: {}, titleFillByLevel: {}, bodyFillByLevel: {} };
+        : {
+            clrMap: {},
+            titleDefaultsByLevel: {},
+            bodyDefaultsByLevel: {},
+            otherDefaultsByLevel: {},
+            placeholderDefaults: [],
+            background: null,
+        };
     const colorContext = {
         themeColorsByName: theme.colorsByName,
         clrMap: masterColorInfo.clrMap,
     };
-    const resolveFillsByLevel = (fillsByLevel) => Object.fromEntries(Object.entries(fillsByLevel).map(([level, fill]) => [
-        Number(level),
-        parseColor(fill, colorContext),
-    ]));
     const placeholderDefaults = {
-        title: resolveFillsByLevel(masterColorInfo.titleFillByLevel),
-        body: resolveFillsByLevel(masterColorInfo.bodyFillByLevel),
+        title: resolveRunDefaultsByLevel(masterColorInfo.titleDefaultsByLevel, colorContext),
+        body: resolveRunDefaultsByLevel(masterColorInfo.bodyDefaultsByLevel, colorContext),
+        other: resolveRunDefaultsByLevel(masterColorInfo.otherDefaultsByLevel, colorContext),
+        layoutPlaceholders: [],
+        masterPlaceholders: resolvePlaceholderShapeDefaults(masterColorInfo.placeholderDefaults, colorContext),
+    };
+    const fallbackBackground = parseBackgroundNode(masterColorInfo.background, colorContext);
+    const fallbackContext = {
+        colorContext,
+        placeholderDefaults,
+        ...(fallbackBackground ? { background: fallbackBackground } : {}),
+        layerElements: [],
+        layerImages: [],
     };
     const themeCache = new Map();
     const masterInfoCache = new Map();
+    const templateContextCache = new Map();
     const slides = [];
+    let hiddenSlideCount = 0;
     for (const slidePath of slidePaths) {
         const xml = await zip.file(slidePath)?.async("string");
-        if (!xml)
+        if (!xml) {
+            droppedSlides.push(`${slidePath} is missing from the package`);
             continue;
+        }
         let slide;
         try {
             slide = parseXml(xml);
         }
-        catch {
+        catch (error) {
+            droppedSlides.push(`${slidePath} could not be parsed: ${error instanceof Error ? error.message : String(error)}`);
+            continue;
+        }
+        // `show="0"` is the author having removed this slide from the deck's own
+        // flow. Importing it anyway hands every deck back slides its presenter
+        // had already cut.
+        if (stringValue(record(record(slide)?.["p:sld"])?.["@_show"]) === "0") {
+            hiddenSlideCount += 1;
             continue;
         }
         const metadata = parsePptxSlideMetadata(slide);
         let elements = [];
         const images = [];
+        const tablesDegraded = { count: 0 };
         const relationshipPath = slidePath.replace(/slides\/(slide\d+\.xml)/, "slides/_rels/$1.rels");
         const slideRelationshipsXml = await zip
             .file(relationshipPath)
@@ -97,9 +132,13 @@ export async function parsePptxPresentation(fileBuffer) {
             zip,
             parseXml,
             slideRelationships,
+            slideWidthEmu,
+            slideHeightEmu,
             themeCache,
             masterInfoCache,
-        })) ?? { colorContext, placeholderDefaults };
+            templateContextCache,
+        })) ?? fallbackContext;
+        const number = slideNumber(slidePath);
         elements = await parseSlideElements({
             xml,
             parseXml,
@@ -109,11 +148,18 @@ export async function parsePptxPresentation(fileBuffer) {
             slideWidthEmu,
             slideHeightEmu,
             images,
+            tablesDegraded,
             colorContext: slideMasterContext.colorContext,
             placeholderDefaults: slideMasterContext.placeholderDefaults,
+            slideNumber: slides.length + 1,
+            tableStyles,
         });
+        // The template layer sits behind the slide's own scene graph: it is the
+        // background band, brand mark and silhouette the layout draws under
+        // everything the slide itself places.
+        images.unshift(...slideMasterContext.layerImages);
+        elements.unshift(...substituteSlideNumber(slideMasterContext.layerElements, slides.length + 1));
         const texts = flattenElementText(elements);
-        const number = slideNumber(slidePath);
         const notesXml = await zip
             .file(`ppt/notesSlides/notesSlide${number}.xml`)
             ?.async("string");
@@ -134,19 +180,41 @@ export async function parsePptxPresentation(fileBuffer) {
             elements,
             widthEmu: slideWidthEmu,
             heightEmu: slideHeightEmu,
-            backgroundColor: extractSlideBackgroundColor(slide, slideMasterContext.colorContext),
+            backgroundColor: extractSlideBackground(slide, slideMasterContext.colorContext) ??
+                slideMasterContext.background,
             ...(backgroundGrid ? { backgroundGrid } : {}),
             notes,
             layoutHint: guessLayoutHint(texts, images.length > 0),
+            ...(tablesDegraded.count > 0
+                ? { tablesDegraded: tablesDegraded.count }
+                : {}),
             ...metadata,
         });
     }
+    // A short import must never come back looking complete: every slide the deck
+    // still presents has to survive, and slides the author hid are the only
+    // legitimate shortfall.
+    const expectedSlideCount = slidePaths.length + unresolvedSlideIdCount - hiddenSlideCount;
+    if (slides.length !== expectedSlideCount) {
+        throw new Error(`Invalid PPTX: expected ${expectedSlideCount} slides but parsed ${slides.length}` +
+            (hiddenSlideCount > 0
+                ? ` (${hiddenSlideCount} hidden slide${hiddenSlideCount === 1 ? "" : "s"} excluded)`
+                : "") +
+            (droppedSlides.length > 0
+                ? `; dropped: ${droppedSlides.join("; ")}`
+                : ""));
+    }
     const firstSlide = slides[0]?.texts ?? [];
     const title = [...firstSlide]
         .sort((a, b) => (b.fontSize ?? 0) - (a.fontSize ?? 0))[0]
         ?.content.trim()
         .slice(0, 200) || "Imported Presentation";
-    return { title, slides, theme };
+    return {
+        title,
+        slides,
+        theme,
+        ...(hiddenSlideCount > 0 ? { hiddenSlideCount } : {}),
+    };
 }
 /**
  * Google Slides exports decorative grids as connector shapes on the slide
@@ -246,19 +314,21 @@ function relsPathForPptxPart(path) {
     const file = slashIndex >= 0 ? path.slice(slashIndex + 1) : path;
     return `${dir ? `${dir}/` : ""}_rels/${file}.rels`;
 }
-/**
- * Walks this slide's own `slideLayout` → `slideMaster` → `theme` relationship
- * chain so slides that belong to a different master than the deck's first
- * one (a presentation with more than one master) resolve `schemeClr`
- * aliases and placeholder defaults against their own palette instead of an
- * unrelated master's. Returns `undefined` when any hop in that chain is
- * missing, letting the caller fall back to the deck-wide default.
- */
 async function resolveSlideMasterContext(args) {
     const layoutRelationship = [...args.slideRelationships.values()].find((relationship) => relationship.type.endsWith("/slideLayout"));
     if (!layoutRelationship)
         return undefined;
     const layoutPath = resolvePptxRelationshipPath("ppt/slides", layoutRelationship.target);
+    let cached = args.templateContextCache.get(layoutPath);
+    if (!cached) {
+        cached = buildSlideTemplateContext({ ...args, layoutPath });
+        args.templateContextCache.set(layoutPath, cached);
+    }
+    return cached;
+}
+async function buildSlideTemplateContext(args) {
+    const layoutPath = args.layoutPath;
+    const layoutXml = await args.zip.file(layoutPath)?.async("string");
     const layoutRelsXml = await args.zip
         .file(relsPathForPptxPart(layoutPath))
         ?.async("string");
@@ -279,6 +349,12 @@ async function resolveSlideMasterContext(args) {
         args.masterInfoCache.set(masterPath, masterInfoPromise);
     }
     const masterInfo = await masterInfoPromise;
+    const layoutRoot = layoutXml
+        ? record(record(args.parseXml(layoutXml))?.["p:sldLayout"])
+        : null;
+    const layoutPlaceholderDefaults = layoutXml
+        ? parsePlaceholderShapeDefaults(layoutXml, args.parseXml)
+        : [];
     const masterRelsXml = await args.zip
         .file(relsPathForPptxPart(masterPath))
         ?.async("string");
@@ -299,21 +375,117 @@ async function resolveSlideMasterContext(args) {
         themeColorsByName: theme.colorsByName,
         clrMap: masterInfo.clrMap,
     };
-    const resolveFillsByLevel = (fillsByLevel) => Object.fromEntries(Object.entries(fillsByLevel).map(([level, fill]) => [
-        Number(level),
-        parseColor(fill, colorContext),
-    ]));
+    const background = parseBackgroundNode(record(layoutRoot?.["p:cSld"])?.["p:bg"], colorContext) ?? parseBackgroundNode(masterInfo.background, colorContext);
+    // `showMasterSp="0"` is a layout opting out of the master's own decoration;
+    // honouring it is the difference between reproducing a template and
+    // stamping the master's furniture onto slides that deliberately hid it.
+    const layerImages = [];
+    const layerElements = [];
+    const layerSources = [];
+    if (masterInfo.xml && stringValue(layoutRoot?.["@_showMasterSp"]) !== "0") {
+        layerSources.push({
+            xml: masterInfo.xml,
+            path: masterPath,
+            prefix: "master",
+        });
+    }
+    if (layoutXml) {
+        layerSources.push({ xml: layoutXml, path: layoutPath, prefix: "layout" });
+    }
+    for (const source of layerSources) {
+        layerElements.push(...(await parseTemplateLayerElements({
+            zip: args.zip,
+            parseXml: args.parseXml,
+            xml: source.xml,
+            path: source.path,
+            idPrefix: source.prefix,
+            slideWidthEmu: args.slideWidthEmu,
+            slideHeightEmu: args.slideHeightEmu,
+            images: layerImages,
+            colorContext,
+        })));
+    }
     return {
         colorContext,
+        ...(background ? { background } : {}),
+        layerElements,
+        layerImages,
         placeholderDefaults: {
-            title: resolveFillsByLevel(masterInfo.titleFillByLevel),
-            body: resolveFillsByLevel(masterInfo.bodyFillByLevel),
+            title: resolveRunDefaultsByLevel(masterInfo.titleDefaultsByLevel, colorContext),
+            body: resolveRunDefaultsByLevel(masterInfo.bodyDefaultsByLevel, colorContext),
+            other: resolveRunDefaultsByLevel(masterInfo.otherDefaultsByLevel, colorContext),
+            layoutPlaceholders: resolvePlaceholderShapeDefaults(layoutPlaceholderDefaults, colorContext),
+            masterPlaceholders: resolvePlaceholderShapeDefaults(masterInfo.placeholderDefaults, colorContext),
         },
     };
 }
+/**
+ * A slideLayout's and slideMaster's *non*-placeholder `<p:sp>`/`<p:pic>`/
+ * `<p:cxnSp>`/`<p:grpSp>` are where a template's visual identity actually
+ * lives — full-bleed bands, brand marks, logos, silhouettes. Reading only
+ * placeholder shapes for their inherited defaults threw all of it away, so
+ * slides whose entire design came from the layout imported as blank white
+ * cards. Placeholder shapes are skipped here: their content is prompt text,
+ * and their geometry/colors already reach the slide through
+ * `PlaceholderDefaults`.
+ */
+async function parseTemplateLayerElements(args) {
+    const relsXml = await args.zip
+        .file(relsPathForPptxPart(args.path))
+        ?.async("string");
+    const relationships = relsXml
+        ? parseRelationships(args.parseXml(relsXml))
+        : new Map();
+    const elements = [];
+    const images = [];
+    const tablesDegraded = { count: 0 };
+    for (const fragment of extractDirectShapeFragments(args.xml, "spTree")) {
+        if (/<p:ph[\s/>]/.test(fragment))
+            continue;
+        elements.push(...(await parseShapeFragment(fragment, {
+            parseXml: args.parseXml,
+            zip: args.zip,
+            slideRelationships: relationships,
+            slideWidthEmu: args.slideWidthEmu,
+            slideHeightEmu: args.slideHeightEmu,
+            images,
+            tablesDegraded,
+            colorContext: args.colorContext,
+            context: { matrix: IDENTITY_MAT, rotation: 0 },
+        })));
+    }
+    // A template layer's icons and logos are frequently EMF/WMF vector art,
+    // which no browser can render and which the import boundary rejects for the
+    // whole deck. Dropping the deck's every other slide over a layout logo is
+    // strictly worse than importing without it, so unrenderable *layer* art is
+    // left out; a slide's own images still fail loudly.
+    const renderable = new Set(images.filter(isBrowserRenderableImage));
+    args.images.push(...renderable);
+    return elements
+        .filter((element) => !element.image || renderable.has(element.image))
+        .map((element) => ({ ...element, id: `${args.idPrefix}-${element.id}` }));
+}
+const BROWSER_RENDERABLE_IMAGE_MIME_TYPES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+    "image/svg+xml",
+    "image/bmp",
+]);
+function isBrowserRenderableImage(image) {
+    return BROWSER_RENDERABLE_IMAGE_MIME_TYPES.has(image.mimeType);
+}
 /** Resolves a slide master's color-alias mapping plus its title/body default text-color fills (from p:txStyles), so placeholder text without its own explicit color can inherit the right one. */
 async function parseMasterColorInfo(args) {
-    const empty = { clrMap: {}, titleFillByLevel: {}, bodyFillByLevel: {} };
+    const empty = {
+        clrMap: {},
+        titleDefaultsByLevel: {},
+        bodyDefaultsByLevel: {},
+        otherDefaultsByLevel: {},
+        placeholderDefaults: [],
+        background: null,
+    };
     const path = args.target.startsWith("/")
         ? args.target.slice(1)
         : "ppt/" + args.target.replace(/^\.\.\//, "");
@@ -327,18 +499,82 @@ async function parseMasterColorInfo(args) {
     const txStyles = record(root["p:txStyles"]);
     return {
         clrMap,
-        titleFillByLevel: levelFillsFromTextStyle(record(txStyles?.["p:titleStyle"])),
-        bodyFillByLevel: levelFillsFromTextStyle(record(txStyles?.["p:bodyStyle"])),
+        titleDefaultsByLevel: levelDefaultsFromTextStyle(record(txStyles?.["p:titleStyle"])),
+        bodyDefaultsByLevel: levelDefaultsFromTextStyle(record(txStyles?.["p:bodyStyle"])),
+        otherDefaultsByLevel: levelDefaultsFromTextStyle(record(txStyles?.["p:otherStyle"])),
+        placeholderDefaults: parsePlaceholderShapeDefaults(xml, args.parseXml),
+        background: record(record(root["p:cSld"])?.["p:bg"]),
+        xml,
     };
 }
-/** Reads a `<p:titleStyle>`/`<p:bodyStyle>` node's per-level (`a:lvl1pPr`..`a:lvl9pPr`) default run fill, keyed 0-indexed to match `ParsedPptxParagraph.level` (`a:lvl1pPr` is level 0, `a:lvl2pPr` is level 1, etc.) — using only the first level's default for every nested bullet level silently drops the distinct colors PowerPoint themes commonly assign to deeper levels. */
-function levelFillsFromTextStyle(style) {
-    const fills = {};
+/** Reads a `<p:titleStyle>`/`<p:bodyStyle>`/`<a:lstStyle>` node's per-level (`a:lvl1pPr`..`a:lvl9pPr`) `<a:defRPr>`, keyed 0-indexed to match `ParsedPptxParagraph.level` (`a:lvl1pPr` is level 0, `a:lvl2pPr` is level 1, etc.) — using only the first level's default for every nested bullet level silently drops the distinct styling PowerPoint themes commonly assign to deeper levels. The whole `defRPr` is kept, not just its fill: size, typeface and bold/italic are inherited by exactly the same chain the color is, and a placeholder run that declares none of them is the common case, not the exception. */
+function levelDefaultsFromTextStyle(style) {
+    const defaults = {};
     for (let level = 0; level < 9; level++) {
-        const defRPr = record(record(style?.[`a:lvl${level + 1}pPr`])?.["a:defRPr"]);
-        fills[level] = record(defRPr?.["a:solidFill"]);
+        defaults[level] = record(record(style?.[`a:lvl${level + 1}pPr`])?.["a:defRPr"]);
+    }
+    return defaults;
+}
+function resolveRunDefaultsByLevel(defaultsByLevel, colorContext) {
+    return Object.fromEntries(Object.entries(defaultsByLevel).map(([level, defRPr]) => [
+        Number(level),
+        runProperties(defRPr, {}, colorContext),
+    ]));
+}
+/** Parses every direct placeholder shape out of a slideLayout's or slideMaster's `p:spTree`, keyed by that shape's own `<p:ph>` `type`/`idx` — reuses `extractDirectShapeFragments`, since layouts and masters share the same `spTree` structure slides do. */
+function parsePlaceholderShapeDefaults(xml, parseXml) {
+    const placeholders = [];
+    for (const fragment of extractDirectShapeFragments(xml, "spTree")) {
+        const node = record(record(parseXml(fragment))?.["p:sp"]);
+        const ph = record(record(record(node?.["p:nvSpPr"])?.["p:nvPr"])?.["p:ph"]);
+        if (!node || !ph)
+            continue;
+        const transform = readTransform(node, "p:spPr");
+        placeholders.push({
+            type: stringValue(ph["@_type"]),
+            idx: stringValue(ph["@_idx"]),
+            defaultsByLevel: levelDefaultsFromTextStyle(record(record(node["p:txBody"])?.["a:lstStyle"])),
+            ...(transform.width > 0 && transform.height > 0 ? { transform } : {}),
+        });
     }
-    return fills;
+    return placeholders;
+}
+/** Resolves a set of raw placeholder-shape defaults' `schemeClr` references against the slide's theme/clrMap (the raw nodes are cached before the theme is known, so resolution happens per-call instead). */
+function resolvePlaceholderShapeDefaults(raw, colorContext) {
+    return raw.map((placeholder) => ({
+        type: placeholder.type,
+        idx: placeholder.idx,
+        runDefaultsByLevel: resolveRunDefaultsByLevel(placeholder.defaultsByLevel, colorContext),
+        transform: placeholder.transform,
+    }));
+}
+const IDENTITY_MAT = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };
+/** Composes two transforms so `inner` is applied to a point first, then `outer`. */
+function composeMat(outer, inner) {
+    return {
+        a: outer.a * inner.a + outer.c * inner.b,
+        b: outer.b * inner.a + outer.d * inner.b,
+        c: outer.a * inner.c + outer.c * inner.d,
+        d: outer.b * inner.c + outer.d * inner.d,
+        e: outer.a * inner.e + outer.c * inner.f + outer.e,
+        f: outer.b * inner.e + outer.d * inner.f + outer.f,
+    };
+}
+function scaleMat(sx, sy) {
+    return { a: sx, b: 0, c: 0, d: sy, e: 0, f: 0 };
+}
+function translateMat(tx, ty) {
+    return { a: 1, b: 0, c: 0, d: 1, e: tx, f: ty };
+}
+function rotateAroundMat(degrees, cx, cy) {
+    const radians = (degrees * Math.PI) / 180;
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    const rotation = { a: cos, b: sin, c: -sin, d: cos, e: 0, f: 0 };
+    return composeMat(translateMat(cx, cy), composeMat(rotation, translateMat(-cx, -cy)));
+}
+function applyMatPoint(m, x, y) {
+    return { x: m.a * x + m.c * y + m.e, y: m.b * x + m.d * y + m.f };
 }
 const SHAPE_ELEMENT_NAMES = new Set([
     "sp",
@@ -347,14 +583,14 @@ const SHAPE_ELEMENT_NAMES = new Set([
     "cxnSp",
     "graphicFrame",
 ]);
+/** Standard 16:9 widescreen slide size — a last-resort content box for a placeholder shape whose own `<a:xfrm>` is missing and the deck's own slide size wasn't determinable either. */
+const FALLBACK_SLIDE_WIDTH_EMU = 12192000;
+const FALLBACK_SLIDE_HEIGHT_EMU = 6858000;
 async function parseSlideElements(args) {
     const fragments = extractDirectShapeFragments(args.xml, "spTree");
     const elements = [];
     const context = {
-        originX: 0,
-        originY: 0,
-        scaleX: 1,
-        scaleY: 1,
+        matrix: IDENTITY_MAT,
         rotation: 0,
     };
     for (const fragment of fragments) {
@@ -403,16 +639,28 @@ async function parseShapeFragment(fragment, args) {
         const groupTransform = readTransform(node, "p:grpSpPr");
         const groupXfrm = record(record(node["p:grpSpPr"])?.["a:xfrm"]);
         const childOffset = readPoint(groupXfrm?.["a:chOff"]);
-        const childExtent = readPoint(groupXfrm?.["a:chExt"]);
+        // `a:chExt` carries `cx`/`cy` attributes like `a:ext`, not `x`/`y` like
+        // `a:off`/`a:chOff` — using `readPoint` here silently read 0, which made
+        // every scaled group (chExt != ext) fall back to an identity scale and
+        // rendered children at their unscaled local size (e.g. a connector/line
+        // shape's width/height came out too large, overflowing the canvas).
+        const childExtent = readExtent(groupXfrm?.["a:chExt"]);
         const groupScaleX = childExtent.x > 0 ? groupTransform.width / childExtent.x : 1;
         const groupScaleY = childExtent.y > 0 ? groupTransform.height / childExtent.y : 1;
+        // Places this group's children into the parent's coordinate space,
+        // ignoring the group's own rotation for now.
+        let localToParent = composeMat(translateMat(groupTransform.x - childOffset.x * groupScaleX, groupTransform.y - childOffset.y * groupScaleY), scaleMat(groupScaleX, groupScaleY));
+        // PowerPoint rotates the entire *placed* group box — every child already
+        // positioned by `localToParent` above — as a rigid body around that
+        // box's own center, not each child around its own center. Composing this
+        // rotation on top of the placement (instead of only summing `rotation`
+        // degrees, as before) is what makes children actually orbit the group's
+        // pivot instead of just spinning in place.
+        if (groupTransform.rotation) {
+            localToParent = composeMat(rotateAroundMat(groupTransform.rotation, groupTransform.x + groupTransform.width / 2, groupTransform.y + groupTransform.height / 2), localToParent);
+        }
         const nextContext = {
-            originX: args.context.originX +
-                args.context.scaleX * (groupTransform.x - childOffset.x * groupScaleX),
-            originY: args.context.originY +
-                args.context.scaleY * (groupTransform.y - childOffset.y * groupScaleY),
-            scaleX: args.context.scaleX * groupScaleX,
-            scaleY: args.context.scaleY * groupScaleY,
+            matrix: composeMat(args.context.matrix, localToParent),
             rotation: args.context.rotation + (groupTransform.rotation ?? 0),
         };
         const output = [];
@@ -424,21 +672,64 @@ async function parseShapeFragment(fragment, args) {
         }
         return output;
     }
-    const transform = applyTransform(readTransform(node, "p:spPr"), args.context);
+    if (entry === "graphicFrame") {
+        return parseGraphicFrameFragment(node, args);
+    }
+    const localTransform = readTransform(node, "p:spPr");
     const id = readShapeId(node);
     const name = readShapeName(node);
-    const placeholderType = stringValue(record(record(record(node["p:nvSpPr"])?.["p:nvPr"])?.["p:ph"])?.["@_type"]);
+    const placeholder = record(record(record(node["p:nvSpPr"])?.["p:nvPr"])?.["p:ph"]);
+    const placeholderType = stringValue(placeholder?.["@_type"]);
+    const placeholderIdx = stringValue(placeholder?.["@_idx"]);
+    // A placeholder shape (`<p:ph>`) commonly omits its own `<a:xfrm>` on the
+    // slide, inheriting position/size from the matching placeholder on the
+    // slide layout/master instead. Try the layout's own placeholder shape
+    // first, then the master's — same order as the color inheritance chain
+    // above — and only fall back to the slide's own content box when neither
+    // defines explicit geometry for this placeholder either (real for
+    // `idx="4294967295"` sentinel placeholders in some Google Slides exports).
+    // Without that last-resort fallback the shape would land at a literal 0×0
+    // box, making real title/body text invisible instead of just mispositioned.
+    const hasOwnSize = localTransform.width > 0 && localTransform.height > 0;
+    const inheritedTransform = entry === "sp" && !hasOwnSize && placeholder && args.placeholderDefaults
+        ? resolvePlaceholderTransform({
+            type: placeholderType,
+            idx: placeholderIdx,
+            defaults: args.placeholderDefaults,
+        })
+        : undefined;
+    const effectiveLocalTransform = entry === "sp" && !hasOwnSize
+        ? {
+            ...localTransform,
+            x: inheritedTransform?.x ?? 0,
+            y: inheritedTransform?.y ?? 0,
+            width: inheritedTransform?.width ??
+                args.slideWidthEmu ??
+                FALLBACK_SLIDE_WIDTH_EMU,
+            height: inheritedTransform?.height ??
+                args.slideHeightEmu ??
+                FALLBACK_SLIDE_HEIGHT_EMU,
+        }
+        : localTransform;
+    const transform = applyTransform(effectiveLocalTransform, args.context);
     const shapeProperties = record(node["p:spPr"]);
-    const rawText = parseTextBody(node, args.colorContext);
-    const placeholderDefaultColor = placeholderType === "title" || placeholderType === "ctrTitle"
-        ? args.placeholderDefaults?.title
-        : placeholderType
-            ? args.placeholderDefaults?.body
-            : undefined;
-    const text = applyPlaceholderDefaultColor(rawText, placeholderDefaultColor);
+    const rawText = parseTextBody(node, args.colorContext, {
+        relationships: args.slideRelationships,
+        slideNumber: args.slideNumber,
+    });
+    const placeholderRunDefaults = placeholder && args.placeholderDefaults
+        ? resolvePlaceholderRunDefaults({
+            type: placeholderType,
+            idx: placeholderIdx,
+            defaults: args.placeholderDefaults,
+        })
+        : undefined;
+    const text = applyAutofitScale(applyPlaceholderRunDefaults(rawText, placeholderRunDefaults), record(record(node["p:txBody"])?.["a:bodyPr"]));
     const fill = parseShapeFill(shapeProperties, args.colorContext);
     const line = parseShapeLine(shapeProperties, args.colorContext);
     const shapeType = stringValue(record(shapeProperties?.["a:prstGeom"])?.["@_prst"]);
+    const shapeAdjustments = parseShapeAdjustments(shapeProperties);
+    const geometry = parseCustomGeometry(shapeProperties, effectiveLocalTransform);
     if (entry === "pic") {
         const embedId = stringValue(record(record(node["p:blipFill"])?.["a:blip"])?.["@_r:embed"]);
         if (!embedId)
@@ -466,6 +757,12 @@ async function parseShapeFragment(fragment, args) {
                 name,
                 kind: "image",
                 ...transform,
+                // A picture is painted inside its `p:spPr` geometry, not its bounding
+                // box: dropping the shape here is what turns a portrait cropped to an
+                // `ellipse` frame back into the hard square its box happens to be.
+                shapeType,
+                ...(shapeAdjustments ? { shapeAdjustments } : {}),
+                ...(geometry ? { geometry } : {}),
                 image: image.image,
             },
         ];
@@ -480,8 +777,17 @@ async function parseShapeFragment(fragment, args) {
                 kind: "text",
                 ...transform,
                 shapeType,
+                ...(shapeAdjustments ? { shapeAdjustments } : {}),
+                ...(geometry ? { geometry } : {}),
                 ...(fill ? { fill } : {}),
-                ...(line ? { lineColor: line.color, lineWidth: line.width } : {}),
+                ...(line
+                    ? {
+                        lineColor: line.color,
+                        lineWidth: line.width,
+                        lineHeadEnd: line.headEnd,
+                        lineTailEnd: line.tailEnd,
+                    }
+                    : {}),
                 ...parseTextBoxProperties(node),
                 paragraphs: text,
             },
@@ -495,13 +801,255 @@ async function parseShapeFragment(fragment, args) {
                 kind: "shape",
                 ...transform,
                 shapeType,
+                ...(shapeAdjustments ? { shapeAdjustments } : {}),
+                ...(geometry ? { geometry } : {}),
                 ...(fill ? { fill } : {}),
-                ...(line ? { lineColor: line.color, lineWidth: line.width } : {}),
+                ...(line
+                    ? {
+                        lineColor: line.color,
+                        lineWidth: line.width,
+                        lineHeadEnd: line.headEnd,
+                        lineTailEnd: line.tailEnd,
+                    }
+                    : {}),
             },
         ];
     }
     return [];
 }
+/**
+ * `p:graphicFrame` has no `p:spPr` (its transform lives at `p:xfrm` directly)
+ * and its content is `a:graphic/a:graphicData` rather than `p:txBody` — most
+ * commonly a table, but also charts, SmartArt, and embedded OLE objects that
+ * have no shape structure we can reconstruct. Only tables convert; anything
+ * else is counted as a dropped-content fidelity signal instead of silently
+ * vanishing with no signal at all.
+ */
+function parseGraphicFrameFragment(node, args) {
+    const table = parseGraphicFrameTable(node, args.colorContext, {
+        relationships: args.slideRelationships,
+        slideNumber: args.slideNumber,
+    }, args.tableStyles);
+    if (!table) {
+        args.tablesDegraded.count += 1;
+        return [];
+    }
+    // Google Slides always writes the sentinel `3000000x3000000` into a table
+    // graphicFrame's `<a:ext>`; the authored `<a:tblGrid>`/`<a:tr h>` is the
+    // real geometry, and PowerPoint sizes tables from it too. Trusting the ext
+    // rendered an 88%-wide grid at 33% and perfectly square, wrapping every
+    // header one character per line.
+    const frameTransform = transformFromXfrmNode(record(node["p:xfrm"]));
+    const gridWidth = sumOf(table.columnWidthsEmu);
+    const gridHeight = sumOf(table.rowHeightsEmu);
+    const transform = applyTransform({
+        ...frameTransform,
+        width: gridWidth ?? frameTransform.width,
+        height: gridHeight ?? frameTransform.height,
+    }, args.context);
+    return [
+        {
+            id: readShapeId(node),
+            name: readShapeName(node),
+            kind: "table",
+            ...transform,
+            table,
+        },
+    ];
+}
+/** Reads a graphicFrame's `a:graphic/a:graphicData/a:tbl` into a row/cell grid. Returns `undefined` for a non-table graphicFrame (chart/SmartArt/OLE) or a table with no rows. */
+function parseGraphicFrameTable(node, context, text, tableStyles) {
+    const graphicData = record(record(node["a:graphic"])?.["a:graphicData"]);
+    const tbl = record(graphicData?.["a:tbl"]);
+    if (!tbl)
+        return undefined;
+    const rawRows = asArray(tbl["a:tr"]);
+    const rawGridColumns = asArray(record(tbl["a:tblGrid"])?.["a:gridCol"]);
+    const columnWidthsEmu = rawGridColumns
+        .map((rawColumn) => positiveAttributeNumber(rawColumn, "@_w"))
+        .filter((width) => width !== undefined);
+    const rowHeightsEmu = rawRows
+        .map((rawRow) => positiveAttributeNumber(rawRow, "@_h"))
+        .filter((height) => height !== undefined);
+    const tblPr = record(tbl["a:tblPr"]);
+    const style = tableStyles?.get(normalizeTableStyleId(innerText(tblPr?.["a:tableStyleId"])));
+    const banding = {
+        firstRow: xmlBoolean(tblPr?.["@_firstRow"]),
+        lastRow: xmlBoolean(tblPr?.["@_lastRow"]),
+        firstCol: xmlBoolean(tblPr?.["@_firstCol"]),
+        lastCol: xmlBoolean(tblPr?.["@_lastCol"]),
+        bandRow: xmlBoolean(tblPr?.["@_bandRow"]),
+        bandCol: xmlBoolean(tblPr?.["@_bandCol"]),
+    };
+    const columnCount = Math.max(rawGridColumns.length, ...rawRows.map((rawRow) => asArray(record(rawRow)?.["a:tc"]).length));
+    const rows = rawRows.map((rawRow, rowIndex) => {
+        const row = record(rawRow);
+        const cells = [];
+        for (const [columnIndex, rawCell] of asArray(row?.["a:tc"]).entries()) {
+            const cell = record(rawCell);
+            if (!cell)
+                continue;
+            // A merge-continuation cell's content is already represented once, by
+            // the spanning cell's gridSpan/rowSpan below.
+            if (xmlBoolean(cell["@_hMerge"]) || xmlBoolean(cell["@_vMerge"]))
+                continue;
+            const gridSpan = Number(cell["@_gridSpan"]);
+            const rowSpan = Number(cell["@_rowSpan"]);
+            const tcPr = record(cell["a:tcPr"]);
+            const styleParts = tableStyleParts(banding, rowIndex, columnIndex);
+            const fill = TABLE_CELL_FILL_ELEMENTS.some((name) => tcPr?.[name] !== undefined)
+                ? parseShapeFill(tcPr, context)
+                : tableStylePartFill(style, styleParts, context);
+            const borders = resolveTableCellBorders({
+                tcPr,
+                style,
+                styleParts,
+                context,
+                firstColumn: columnIndex === 0,
+                lastColumn: columnIndex + Math.max(1, Number(cell["@_gridSpan"]) || 1) >=
+                    columnCount,
+                firstRow: rowIndex === 0,
+                lastRow: rowIndex + Math.max(1, Number(cell["@_rowSpan"]) || 1) >=
+                    rawRows.length,
+            });
+            cells.push({
+                paragraphs: parseTextBodyParagraphs(record(cell["a:txBody"]), context, text),
+                ...(Number.isFinite(gridSpan) && gridSpan > 1
+                    ? { colSpan: gridSpan }
+                    : {}),
+                ...(Number.isFinite(rowSpan) && rowSpan > 1 ? { rowSpan } : {}),
+                ...(fill ? { fill } : {}),
+                ...(borders ? { borders } : {}),
+            });
+        }
+        return cells;
+    });
+    return rows.length > 0
+        ? {
+            rows,
+            ...(columnWidthsEmu.length > 0 ? { columnWidthsEmu } : {}),
+            ...(rowHeightsEmu.length > 0 ? { rowHeightsEmu } : {}),
+        }
+        : undefined;
+}
+async function parseTableStyles(zip, parseXml) {
+    const styles = new Map();
+    const xml = await zip.file("ppt/tableStyles.xml")?.async("string");
+    if (!xml)
+        return styles;
+    const list = record(record(parseXml(xml))?.["a:tblStyleLst"]);
+    if (!list)
+        return styles;
+    for (const raw of asArray(list["a:tblStyle"])) {
+        const style = record(raw);
+        const id = stringValue(style?.["@_styleId"]);
+        if (style && id)
+            styles.set(normalizeTableStyleId(id), style);
+    }
+    const fallback = styles.get(normalizeTableStyleId(stringValue(list["@_def"]) ?? ""));
+    if (fallback)
+        styles.set("", fallback);
+    return styles;
+}
+function normalizeTableStyleId(value) {
+    return value.replace(/[{}\s]/g, "").toLowerCase();
+}
+/**
+ * The table style parts that apply to one cell, lowest precedence first
+ * (ECMA-376 §20.1.4.2). The corner parts (`nwCell`, `seCell`, ...) are not
+ * resolved — no table style shipped by the decks this parser was built
+ * against defines them.
+ */
+function tableStyleParts(banding, rowIndex, columnIndex) {
+    const parts = ["wholeTbl"];
+    if (banding.bandCol) {
+        const band = columnIndex - (banding.firstCol ? 1 : 0);
+        if (band >= 0)
+            parts.push(band % 2 === 0 ? "band1V" : "band2V");
+    }
+    if (banding.bandRow) {
+        const band = rowIndex - (banding.firstRow ? 1 : 0);
+        if (band >= 0)
+            parts.push(band % 2 === 0 ? "band1H" : "band2H");
+    }
+    if (banding.firstCol && columnIndex === 0)
+        parts.push("firstCol");
+    if (banding.firstRow && rowIndex === 0)
+        parts.push("firstRow");
+    return parts;
+}
+/** `a:tcPr`'s own fill elements. Their presence — not the color they resolve to — is what makes a cell's fill an override, since `a:noFill` is an explicit "no fill" that has to beat the table style. */
+const TABLE_CELL_FILL_ELEMENTS = ["a:noFill", "a:solidFill", "a:gradFill"];
+const TABLE_BORDER_SIDES = [
+    { side: "left", cellElement: "a:lnL", edge: "a:left", inside: "a:insideV" },
+    { side: "right", cellElement: "a:lnR", edge: "a:right", inside: "a:insideV" },
+    { side: "top", cellElement: "a:lnT", edge: "a:top", inside: "a:insideH" },
+    {
+        side: "bottom",
+        cellElement: "a:lnB",
+        edge: "a:bottom",
+        inside: "a:insideH",
+    },
+];
+function resolveTableCellBorders(args) {
+    const atEdge = {
+        left: args.firstColumn,
+        right: args.lastColumn,
+        top: args.firstRow,
+        bottom: args.lastRow,
+    };
+    const borders = {};
+    for (const { side, cellElement, edge, inside } of TABLE_BORDER_SIDES) {
+        // A cell that declares the side at all decides it, including
+        // `<a:lnL><a:noFill/></a:lnL>` — that is the author switching the style's
+        // rule off for this cell, not a missing value to fall back from.
+        const declared = record(args.tcPr?.[cellElement]);
+        const border = declared
+            ? parseTableBorderLine(declared, args.context)
+            : tableStylePartBorder(args.style, args.styleParts, atEdge[side] ? edge : inside, args.context);
+        if (border)
+            borders[side] = border;
+    }
+    return Object.keys(borders).length > 0 ? borders : undefined;
+}
+/** Walks the cell's style parts highest precedence first, stopping at the first part that declares this side — including one that declares it as `a:noFill`. */
+function tableStylePartBorder(style, parts, side, context) {
+    for (let index = parts.length - 1; index >= 0; index -= 1) {
+        const borderSet = record(record(record(style?.[`a:${parts[index]}`])?.["a:tcStyle"])?.["a:tcBdr"]);
+        const declared = record(borderSet?.[side]);
+        if (declared)
+            return parseTableBorderLine(record(declared["a:ln"]), context);
+    }
+    return undefined;
+}
+function tableStylePartFill(style, parts, context) {
+    for (let index = parts.length - 1; index >= 0; index -= 1) {
+        const fill = record(record(record(style?.[`a:${parts[index]}`])?.["a:tcStyle"])?.["a:fill"]);
+        if (fill)
+            return parseShapeFill(fill, context);
+    }
+    return undefined;
+}
+/** An `a:ln` cell edge. `undefined` means "draws nothing here": either the line declares `a:noFill`, or its fill is one this parser cannot resolve to a color. */
+function parseTableBorderLine(line, context) {
+    if (!line || line["a:noFill"] !== undefined)
+        return undefined;
+    const color = parseColor(record(line["a:solidFill"]), context);
+    if (!color)
+        return undefined;
+    const widthEmu = positiveAttributeNumber(line, "@_w");
+    const preset = stringValue(record(line["a:prstDash"])?.["@_val"]);
+    const dash = !preset || preset === "solid"
+        ? undefined
+        : preset === "dot" || preset === "sysDot"
+            ? "dotted"
+            : "dashed";
+    return {
+        color,
+        ...(widthEmu ? { widthEmu } : {}),
+        ...(dash ? { dash } : {}),
+    };
+}
 function extractDirectShapeFragments(xml, container) {
     const containerMatch = new RegExp(`<p:${container}\\b[^>]*>`, "i").exec(xml);
     if (!containerMatch)
@@ -559,14 +1107,20 @@ function findMatchingXmlTag(xml, start, localName) {
     }
     return -1;
 }
+/** Every shape flavour carries its `<p:cNvPr>` under its own non-visual wrapper. Missing one (`p:cxnSpPr`, for connectors) means that shape gets a fresh random id on every import, breaking the `data-slide-object-id` stability contract. */
+function readNonVisualProperties(node) {
+    return (record(record(node["p:nvSpPr"])?.["p:cNvPr"]) ??
+        record(record(node["p:nvPicPr"])?.["p:cNvPr"]) ??
+        record(record(node["p:nvCxnSpPr"])?.["p:cNvPr"]) ??
+        record(record(node["p:nvGraphicFramePr"])?.["p:cNvPr"]) ??
+        record(record(node["p:nvGrpSpPr"])?.["p:cNvPr"]));
+}
 function readShapeId(node) {
-    const cNvPr = record(record(node["p:nvSpPr"])?.["p:cNvPr"]) ??
-        record(record(node["p:nvPicPr"])?.["p:cNvPr"]);
-    return (stringValue(cNvPr?.["@_id"]) ??
+    return (stringValue(readNonVisualProperties(node)?.["@_id"]) ??
         `shape-${Math.random().toString(36).slice(2)}`);
 }
 function readShapeName(node) {
-    return stringValue(record(record(node["p:nvSpPr"])?.["p:cNvPr"])?.["@_name"]);
+    return stringValue(readNonVisualProperties(node)?.["@_name"]);
 }
 function readPoint(value) {
     const point = record(value);
@@ -583,7 +1137,10 @@ function readExtent(value) {
     };
 }
 function readTransform(node, key) {
-    const xfrm = record(record(node[key])?.["a:xfrm"]);
+    return transformFromXfrmNode(record(record(node[key])?.["a:xfrm"]));
+}
+/** Shared by `readTransform` (a wrapper-nested `a:xfrm`, e.g. `p:spPr/a:xfrm`) and `graphicFrame`, whose `p:xfrm` sits directly on the node instead of inside a wrapper element. */
+function transformFromXfrmNode(xfrm) {
     const off = readPoint(xfrm?.["a:off"]);
     const ext = readExtent(xfrm?.["a:ext"]);
     const rawRotation = Number(xfrm?.["@_rot"]);
@@ -592,26 +1149,74 @@ function readTransform(node, key) {
         y: off.y,
         width: ext.x,
         height: ext.y,
+        ...(xfrm?.["@_flipH"] !== undefined && xmlBoolean(xfrm["@_flipH"])
+            ? { flipH: true }
+            : {}),
+        ...(xfrm?.["@_flipV"] !== undefined && xmlBoolean(xfrm["@_flipV"])
+            ? { flipV: true }
+            : {}),
         ...(Number.isFinite(rawRotation) && rawRotation !== 0
             ? { rotation: rawRotation / 60000 }
             : {}),
     };
 }
 function applyTransform(transform, context) {
+    const scaleX = Math.hypot(context.matrix.a, context.matrix.b);
+    const scaleY = Math.hypot(context.matrix.c, context.matrix.d);
+    const width = transform.width * scaleX;
+    const height = transform.height * scaleY;
+    // Map the shape's own (un-rotated) box center through the accumulated
+    // group matrix so a child inside a rotated group orbits the group's pivot
+    // — the box's own visual spin is applied separately below via `rotation`,
+    // so only the center (not the whole box) needs to go through the matrix.
+    const center = applyMatPoint(context.matrix, transform.x + transform.width / 2, transform.y + transform.height / 2);
+    const rotation = (transform.rotation ?? 0) + context.rotation;
     return {
-        x: context.originX + transform.x * context.scaleX,
-        y: context.originY + transform.y * context.scaleY,
-        width: transform.width * context.scaleX,
-        height: transform.height * context.scaleY,
-        ...(transform.rotation || context.rotation
-            ? { rotation: (transform.rotation ?? 0) + context.rotation }
-            : {}),
+        x: center.x - width / 2,
+        y: center.y - height / 2,
+        width,
+        height,
+        ...(transform.flipH ? { flipH: true } : {}),
+        ...(transform.flipV ? { flipV: true } : {}),
+        ...(rotation ? { rotation } : {}),
     };
 }
-function parseTextBody(node, context) {
-    const txBody = record(node["p:txBody"]);
+/** A slide-number field on a slideLayout/slideMaster is parsed once and shared by every slide using that layout, so its value cannot be known at parse time. This token stands in until `substituteSlideNumber` resolves it per slide — the alternative, keeping the cached "‹#›" glyph, is the literal placeholder text showing up on 36 of 36 slides. */
+const SLIDE_NUMBER_TOKEN = "\u0001slidenum\u0001";
+/** Replaces `SLIDE_NUMBER_TOKEN` in shared template-layer elements, cloning only the elements that actually carry one. */
+function substituteSlideNumber(elements, slideNumber) {
+    return elements.map((element) => {
+        if (!element.paragraphs?.some((paragraph) => paragraph.runs.some((run) => run.content.includes(SLIDE_NUMBER_TOKEN)))) {
+            return element;
+        }
+        return {
+            ...element,
+            paragraphs: element.paragraphs.map((paragraph) => ({
+                ...paragraph,
+                runs: paragraph.runs.map((run) => ({
+                    ...run,
+                    content: run.content.replaceAll(SLIDE_NUMBER_TOKEN, String(slideNumber)),
+                })),
+            })),
+        };
+    });
+}
+function parseTextBody(node, context, text) {
+    return parseTextBodyParagraphs(record(node["p:txBody"]), context, text);
+}
+/** PowerPoint's `buAutoNum` variants (arabicPeriod, alphaLcPeriod, romanUcPeriod, ...) all number the same underlying sequence — approximating every variant with arabic digits keeps list order/grouping correct even though the glyph style doesn't match `type` exactly. */
+function formatAutoNumBullet(n) {
+    return `${n}.`;
+}
+/** Core `a:p` paragraph parsing, shared by a shape's `p:txBody` and a table cell's `a:txBody` (which sit at different paths in their parent node, so the caller resolves the `txBody` record itself). */
+function parseTextBodyParagraphs(txBody, context, text) {
     if (!txBody)
         return [];
+    // `a:buAutoNum` carries no explicit number — PowerPoint derives it from
+    // paragraph order — so the sequence has to be tracked per nesting level as
+    // paragraphs are walked in document order, restarting whenever a deeper
+    // level's own sequence begins or a non-auto-numbered paragraph interrupts it.
+    const autoNumCounters = new Map();
     return asArray(txBody["a:p"]).map((rawParagraph) => {
         const paragraph = record(rawParagraph);
         const pPr = record(paragraph?.["a:pPr"]);
@@ -622,34 +1227,67 @@ function parseTextBody(node, context) {
             if (content) {
                 runs.push({
                     content,
-                    ...runProperties(record(run?.["a:rPr"]), {}, context),
+                    ...runProperties(record(run?.["a:rPr"]), {}, context, text?.relationships),
                 });
             }
         }
         for (const rawField of asArray(paragraph?.["a:fld"])) {
             const field = record(rawField);
-            const content = innerText(field?.["a:t"]);
+            // A slide-number field caches the authoring tool's placeholder glyph
+            // ("‹#›") in its `<a:t>`; importing that literally puts the glyph on
+            // the slide instead of the number it stands for.
+            const content = stringValue(field?.["@_type"]) === "slidenum"
+                ? (text?.slideNumber?.toString() ?? SLIDE_NUMBER_TOKEN)
+                : innerText(field?.["a:t"]);
             if (content) {
                 runs.push({
                     content,
-                    ...runProperties(record(field?.["a:rPr"]), {}, context),
+                    ...runProperties(record(field?.["a:rPr"]), {}, context, text?.relationships),
                 });
             }
         }
+        // `<a:br/>` was rewritten into a bare newline run before parsing, so it
+        // carries none of its neighbours' styling and would otherwise collapse to
+        // the default font size mid-paragraph.
+        for (const [index, run] of runs.entries()) {
+            if (run.content !== "\n" || run.fontSize !== undefined)
+                continue;
+            const source = runs[index - 1] ?? runs[index + 1];
+            if (source)
+                runs[index] = { ...source, content: "\n" };
+        }
         const bullet = record(pPr?.["a:buChar"]);
         const bulletColor = parseColor(record(pPr?.["a:buClr"]), context);
         const bulletFont = stringValue(record(pPr?.["a:buFont"])?.["@_typeface"]);
         const bulletSize = Number(record(pPr?.["a:buSzPts"])?.["@_val"]);
-        const lineSpacing = parseParagraphSpacing(pPr?.["a:lnSpc"]);
+        const lineSpacing = parseParagraphSpacing(pPr?.["a:lnSpc"], runs[0]?.fontSize);
         const spaceBeforePt = parsePoints(pPr?.["a:spcBef"]);
         const spaceAfterPt = parsePoints(pPr?.["a:spcAft"]);
         const alignment = mapAlignment(stringValue(pPr?.["@_algn"]));
+        const level = Number.isFinite(Number(pPr?.["@_lvl"]))
+            ? Number(pPr?.["@_lvl"])
+            : 0;
+        let autoNumBullet;
+        if (pPr?.["a:buAutoNum"] !== undefined && pPr?.["a:buNone"] === undefined) {
+            for (const key of [...autoNumCounters.keys()]) {
+                if (key > level)
+                    autoNumCounters.delete(key);
+            }
+            const next = (autoNumCounters.get(level) ?? 0) + 1;
+            autoNumCounters.set(level, next);
+            autoNumBullet = formatAutoNumBullet(next);
+        }
+        else if (bullet?.["@_char"] === undefined) {
+            autoNumCounters.clear();
+        }
         return {
             runs,
             ...(alignment ? { alignment } : {}),
             ...(bullet?.["@_char"] && !pPr?.["a:buNone"]
                 ? { bulletChar: String(bullet["@_char"]) }
-                : {}),
+                : autoNumBullet
+                    ? { bulletChar: autoNumBullet }
+                    : {}),
             ...(bulletColor ? { bulletColor } : {}),
             ...(bulletFont ? { bulletFontFamily: bulletFont } : {}),
             ...(Number.isFinite(bulletSize) && bulletSize > 0
@@ -667,9 +1305,42 @@ function parseTextBody(node, context) {
             ...(lineSpacing !== undefined ? { lineSpacing } : {}),
             ...(spaceBeforePt !== undefined ? { spaceBeforePt } : {}),
             ...(spaceAfterPt !== undefined ? { spaceAfterPt } : {}),
+            ...(pPr?.["@_rtl"] !== undefined && xmlBoolean(pPr["@_rtl"])
+                ? { rtl: true }
+                : {}),
         };
     });
 }
+/**
+ * `<a:normAutofit fontScale="90000" lnSpcReduction="10000"/>` is the shrink
+ * PowerPoint already computed and baked into the file when the author's text
+ * overflowed its shape. Ignoring it renders that text at its nominal size,
+ * spilling out of the box the author saw it fit into. A bare `<a:normAutofit/>`
+ * carries no scale — computing one ourselves would need text measurement, so
+ * it is left alone rather than guessed at.
+ */
+function applyAutofitScale(paragraphs, bodyPr) {
+    const autofit = record(bodyPr?.["a:normAutofit"]);
+    if (!autofit)
+        return paragraphs;
+    const fontScale = Number(autofit["@_fontScale"]) / 100000;
+    const lineReduction = Number(autofit["@_lnSpcReduction"]) / 100000;
+    const scale = Number.isFinite(fontScale) && fontScale > 0 ? fontScale : 1;
+    const lineScale = Number.isFinite(lineReduction) && lineReduction > 0 && lineReduction < 1
+        ? 1 - lineReduction
+        : 1;
+    if (scale === 1 && lineScale === 1)
+        return paragraphs;
+    return paragraphs.map((paragraph) => ({
+        ...paragraph,
+        ...(paragraph.lineSpacing !== undefined
+            ? { lineSpacing: roundTo(paragraph.lineSpacing * lineScale, 4) }
+            : {}),
+        runs: paragraph.runs.map((run) => run.fontSize === undefined
+            ? run
+            : { ...run, fontSize: roundTo(run.fontSize * scale, 2) }),
+    }));
+}
 function parseTextBoxProperties(node) {
     const bodyPr = record(record(node["p:txBody"])?.["a:bodyPr"]);
     if (!bodyPr)
@@ -689,12 +1360,120 @@ function parseTextBoxProperties(node) {
                 : { verticalAlign: "top" }),
     };
 }
+/** Point count each straight/curve command carries, keyed by tag. `a:arcTo` and `a:close` carry none and are read separately. */
+const PATH_COMMAND_POINTS = {
+    "a:moveTo": 1,
+    "a:lnTo": 1,
+    "a:quadBezTo": 2,
+    "a:cubicBezTo": 3,
+};
+/** `a:prstGeom/a:avLst` adjustments, keyed by guide name. A deck that overrides a preset's `adj` (a 50%-radius pill, a block arc's start and sweep) records it here and nowhere else, so a consumer reproducing the preset from its defaults alone draws the wrong shape. */
+function parseShapeAdjustments(shapeProperties) {
+    const guides = asArray(record(record(shapeProperties?.["a:prstGeom"])?.["a:avLst"])?.["a:gd"]);
+    const adjustments = {};
+    for (const raw of guides) {
+        const guide = record(raw);
+        const name = stringValue(guide?.["@_name"]);
+        // Only the literal `val <n>` form is a value; anything else is a formula
+        // referencing other guides, which reproducing here would mean shipping
+        // OOXML's whole guide language.
+        const value = Number(stringValue(guide?.["@_fmla"])?.match(/^val\s+(-?\d+)$/)?.[1]);
+        if (name && Number.isFinite(value))
+            adjustments[name] = value;
+    }
+    return Object.keys(adjustments).length > 0 ? adjustments : undefined;
+}
+/**
+ * `a:custGeom`'s authored outline. Every command maps 1:1 onto an SVG path
+ * segment, so the shape can be reproduced exactly rather than flattened to
+ * the rectangle its bounding box happens to be.
+ */
+function parseCustomGeometry(shapeProperties, shapeBox) {
+    const custGeom = record(shapeProperties?.["a:custGeom"]);
+    if (!custGeom)
+        return undefined;
+    const paths = [];
+    for (const rawList of asArray(custGeom["a:pathLst"])) {
+        for (const rawPath of asArray(record(rawList)?.["a:path"])) {
+            const node = record(rawPath);
+            if (!node)
+                continue;
+            const commands = readPathCommands(node);
+            if (!commands)
+                continue;
+            // A path with no `w`/`h` states its points in the shape's own EMU space.
+            const w = Number(node["@_w"]) || shapeBox.width;
+            const h = Number(node["@_h"]) || shapeBox.height;
+            if (!(w > 0) || !(h > 0))
+                continue;
+            paths.push({ w, h, commands });
+        }
+    }
+    return paths.length > 0 ? { kind: "custom", paths } : undefined;
+}
+/**
+ * Rebuilds one `a:path`'s command sequence from the order stamped on by
+ * `annotatePathCommandOrder`. Returns `undefined` — not a partial list — when
+ * any command is unreadable: a path missing a segment is not a simpler path,
+ * it is a different and wrong one, and the caller's fallback (the shape's
+ * plain box) is at least a state a reader can recognize as unreproduced.
+ */
+function readPathCommands(path) {
+    const ordered = [];
+    let unreadable = false;
+    const push = (node, command) => {
+        const order = Number(node?.[PATH_COMMAND_ORDER_ATTRIBUTE]);
+        if (!command || !Number.isFinite(order))
+            unreadable = true;
+        else
+            ordered.push({ order, command });
+    };
+    for (const [tag, count] of Object.entries(PATH_COMMAND_POINTS)) {
+        for (const raw of asArray(path[tag])) {
+            const node = record(raw);
+            const points = asArray(node?.["a:pt"]).map((raw) => {
+                const pt = record(raw);
+                return { x: Number(pt?.["@_x"]), y: Number(pt?.["@_y"]) };
+            });
+            const usable = points.length === count &&
+                points.every((pt) => Number.isFinite(pt.x) && Number.isFinite(pt.y));
+            push(node, usable
+                ? {
+                    kind: tag.slice(2),
+                    points,
+                }
+                : undefined);
+        }
+    }
+    for (const raw of asArray(path["a:arcTo"])) {
+        const node = record(raw);
+        const arc = {
+            kind: "arcTo",
+            wR: Number(node?.["@_wR"]),
+            hR: Number(node?.["@_hR"]),
+            stAng: Number(node?.["@_stAng"]),
+            swAng: Number(node?.["@_swAng"]),
+        };
+        const usable = [arc.wR, arc.hR, arc.stAng, arc.swAng].every((value) => Number.isFinite(value));
+        push(node, usable ? arc : undefined);
+    }
+    for (const raw of asArray(path["a:close"])) {
+        push(record(raw), { kind: "close" });
+    }
+    if (unreadable || ordered.length === 0)
+        return undefined;
+    ordered.sort((a, b) => a.order - b.order);
+    return ordered.map((entry) => entry.command);
+}
 function parseShapeFill(shapeProperties, context) {
     if (!shapeProperties)
         return undefined;
     if (shapeProperties["a:noFill"] !== undefined)
         return undefined;
-    return parseColor(record(shapeProperties["a:solidFill"]), context);
+    const solid = parseColor(record(shapeProperties["a:solidFill"]), context);
+    if (solid)
+        return solid;
+    return parseGradientFill(record(shapeProperties["a:gradFill"]), context);
 }
 function parseShapeLine(shapeProperties, context) {
     const line = record(shapeProperties?.["a:ln"]);
@@ -704,23 +1483,95 @@ function parseShapeLine(shapeProperties, context) {
     if (!color)
         return undefined;
     const width = Number(line["@_w"]);
+    const headEnd = parseLineEnd(line["a:headEnd"]);
+    const tailEnd = parseLineEnd(line["a:tailEnd"]);
     return {
         color,
         ...(Number.isFinite(width) && width > 0 ? { width } : {}),
+        ...(headEnd ? { headEnd } : {}),
+        ...(tailEnd ? { tailEnd } : {}),
     };
 }
-/** Placeholder text has no explicit color of its own when the author relied on the slide master's default run properties — apply that inherited color to any run that didn't resolve one, using each paragraph's own nested-bullet level (falling back to level 0's color when a deeper level has no default of its own). */
-function applyPlaceholderDefaultColor(paragraphs, colorsByLevel) {
-    if (!colorsByLevel)
+function parseLineEnd(node) {
+    const end = record(node);
+    const type = stringValue(end?.["@_type"]);
+    if (!type)
+        return undefined;
+    const w = stringValue(end?.["@_w"]);
+    const len = stringValue(end?.["@_len"]);
+    return { type, ...(w ? { w } : {}), ...(len ? { len } : {}) };
+}
+/** Placeholder types that inherit from each other: a slide's `ctrTitle` falls back to the layout/master's `title` shape, a `subTitle` to its `body` shape. Matching the type as a literal string instead sent every title slide past the shape that actually defines its look, down to the `<p:txStyles>` boilerplate that `PlaceholderDefaults.masterPlaceholders` documents as the last resort. */
+const PLACEHOLDER_TYPE_GROUPS = [
+    ["title", "ctrTitle"],
+    ["body", "subTitle", "obj"],
+];
+function placeholderTypeCandidates(type) {
+    const group = PLACEHOLDER_TYPE_GROUPS.find((names) => names.includes(type));
+    return group ? [type, ...group.filter((name) => name !== type)] : [type];
+}
+/** Finds the layout/master placeholder shape a slide's own `<p:ph>` inherits from: an exact `type`+`idx` match first, then `type` alone (a title's `idx` is commonly a sentinel like `4294967295` that won't match anything real), then the same two passes for that type's aliases, then — for a slide placeholder with no `type` at all, a generic content placeholder — `idx` alone. */
+function findMatchingPlaceholderShape(placeholders, type, idx) {
+    if (type) {
+        for (const candidate of placeholderTypeCandidates(type)) {
+            const match = placeholders.find((p) => p.type === candidate && p.idx === idx) ??
+                placeholders.find((p) => p.type === candidate);
+            if (match)
+                return match;
+        }
+        return undefined;
+    }
+    return placeholders.find((p) => p.idx === idx);
+}
+/** `<p:txStyles>` groups its per-level defaults into three buckets by placeholder type — `titleStyle` for title-ish placeholders, `bodyStyle` for body/content-ish ones (including a bare `<p:ph/>` with no `type`, which the schema defaults to `"body"`), and `otherStyle` for everything else (`dt`, `ftr`, `sldNum`, ...). */
+function txStylesTierForType(type) {
+    if (type === "title" || type === "ctrTitle")
+        return "title";
+    if (type === undefined ||
+        type === "body" ||
+        type === "subTitle" ||
+        type === "obj")
+        return "body";
+    return "other";
+}
+/** Resolves a placeholder run's inherited property chain — this slide's own layout placeholder shape, then the slide master's own placeholder shape, then the master's generic `<p:txStyles>` bucket for this placeholder's type — per nesting level, so a paragraph at level N gets level N's own defaults instead of only ever level 0's. Merging is per-property, not per-tier: a layout that declares only a size still inherits the master's color. */
+function resolvePlaceholderRunDefaults(args) {
+    const layoutMatch = findMatchingPlaceholderShape(args.defaults.layoutPlaceholders, args.type, args.idx);
+    const masterMatch = findMatchingPlaceholderShape(args.defaults.masterPlaceholders, args.type, args.idx);
+    const txStylesByLevel = args.defaults[txStylesTierForType(args.type)];
+    const merged = {};
+    let any = false;
+    for (let level = 0; level < 9; level++) {
+        const properties = {
+            ...txStylesByLevel[level],
+            ...masterMatch?.runDefaultsByLevel[level],
+            ...layoutMatch?.runDefaultsByLevel[level],
+        };
+        merged[level] = properties;
+        if (Object.keys(properties).length > 0)
+            any = true;
+    }
+    return any ? merged : undefined;
+}
+/** Resolves a placeholder shape's inherited position/size — this slide's own layout placeholder shape's own `<a:xfrm>` first, then the slide master's, mirroring `resolvePlaceholderColorsByLevel`'s layout-before-master order. Returns `undefined` when neither defines explicit geometry for this placeholder type either (real for `idx="4294967295"` sentinel placeholders in some Google Slides exports), letting the caller fall back to a full-slide content box. */
+function resolvePlaceholderTransform(args) {
+    const layoutMatch = findMatchingPlaceholderShape(args.defaults.layoutPlaceholders, args.type, args.idx);
+    const masterMatch = findMatchingPlaceholderShape(args.defaults.masterPlaceholders, args.type, args.idx);
+    return layoutMatch?.transform ?? masterMatch?.transform;
+}
+/** Placeholder text commonly declares no color, size or typeface of its own, relying entirely on the layout/master defaults — apply those to any property a run didn't resolve itself, using each paragraph's own nested-bullet level (falling back to level 0 when a deeper level has no default of its own). */
+function applyPlaceholderRunDefaults(paragraphs, defaultsByLevel) {
+    if (!defaultsByLevel)
         return paragraphs;
     return paragraphs.map((paragraph) => {
         const level = paragraph.level ?? 0;
-        const color = colorsByLevel[level] ?? colorsByLevel[0];
-        if (!color)
+        const own = defaultsByLevel[level];
+        const defaults = own && Object.keys(own).length > 0 ? own : defaultsByLevel[0];
+        if (!defaults || Object.keys(defaults).length === 0)
             return paragraph;
         return {
             ...paragraph,
-            runs: paragraph.runs.map((run) => (run.color ? run : { ...run, color })),
+            runs: paragraph.runs.map((run) => ({ ...defaults, ...run })),
         };
     });
 }
@@ -819,32 +1670,42 @@ function readColorTransforms(node) {
         const raw = stringValue(record(node[key])?.["@_val"]);
         return raw !== undefined ? Number(raw) / 100000 : undefined;
     };
+    const alphaRaw = stringValue(record(node["a:alpha"])?.["@_val"]);
     return {
         lumMod: percent("a:lumMod"),
         lumOff: percent("a:lumOff"),
         tint: percent("a:tint"),
         shade: percent("a:shade"),
+        ...(alphaRaw !== undefined
+            ? { alphaPercent: Number(alphaRaw) / 1000 }
+            : {}),
     };
 }
+/** Colors flow through the parser as plain `#rrggbb` hex strings, and every consumer just drops that string straight into CSS — an 8-digit `#rrggbbaa` hex is valid CSS and needs no consumer changes, so alpha rides along as extra hex digits instead of a new color shape. */
 function applyColorTransforms(hex, transforms) {
-    const { lumMod, lumOff, tint, shade } = transforms;
-    if (lumMod === undefined &&
-        lumOff === undefined &&
-        tint === undefined &&
-        shade === undefined) {
-        return hex;
+    const { lumMod, lumOff, tint, shade, alphaPercent } = transforms;
+    let result = hex;
+    if (lumMod !== undefined ||
+        lumOff !== undefined ||
+        tint !== undefined ||
+        shade !== undefined) {
+        const [h, s, initialL] = hexToHsl(hex);
+        let l = initialL;
+        if (lumMod !== undefined)
+            l *= lumMod;
+        if (lumOff !== undefined)
+            l += lumOff;
+        if (tint !== undefined)
+            l = l * tint + (1 - tint);
+        if (shade !== undefined)
+            l *= shade;
+        result = hslToHex(h, s, Math.min(1, Math.max(0, l)));
     }
-    const [h, s, initialL] = hexToHsl(hex);
-    let l = initialL;
-    if (lumMod !== undefined)
-        l *= lumMod;
-    if (lumOff !== undefined)
-        l += lumOff;
-    if (tint !== undefined)
-        l = l * tint + (1 - tint);
-    if (shade !== undefined)
-        l *= shade;
-    return hslToHex(h, s, Math.min(1, Math.max(0, l)));
+    if (alphaPercent !== undefined) {
+        const alphaByte = Math.max(0, Math.min(255, Math.round((alphaPercent / 100) * 255)));
+        result = `${result}${alphaByte.toString(16).padStart(2, "0")}`;
+    }
+    return result;
 }
 function parseColor(value, context) {
     if (!value)
@@ -883,16 +1744,55 @@ function parseColor(value, context) {
         ? applyColorTransforms(fallbackColor, transforms)
         : undefined;
 }
-function parseParagraphSpacing(value) {
+// `a:lnSpc` is either a unitless percent (`a:spcPct`, e.g. 100% = single
+// spacing) or an absolute point size (`a:spcPts`, e.g. "52pt line height").
+// Every consumer of the returned `lineSpacing` (html-converter.ts, and our
+// own PPTX export re-imported through this same parser) treats it as a
+// unitless ratio multiplied by the run's font size — so an absolute
+// `spcPts` value must be normalized to that same ratio here, by dividing by
+// the paragraph's own font size, or a 52pt line spacing on 52pt text
+// silently becomes a ~52x line-height and pushes the paragraph thousands of
+// pixels off the slide instead of the intended single-spaced line.
+// No real deck design intentionally sets exact line spacing under ~0.8x a
+// paragraph's own font size — anything tighter reads as overlapping text,
+// not a stylistic choice. Below that floor is a strong signal the exporting
+// tool (including our own dom-to-pptx-based export, whose line-height
+// pixel measurement isn't always attached to the same element it read the
+// font size from) wrote a spcPts value that doesn't correspond to this
+// paragraph's actual font size, so clamp rather than render it unreadable.
+const MIN_LINE_SPACING_RATIO = 0.8;
+const MAX_LINE_SPACING_RATIO = 3;
+// `a:spcPct` is a percentage of *single* line spacing, and single spacing in
+// PowerPoint and Google Slides is the font's own line height (ascent +
+// descent + line gap), not its em size — the same quantity CSS calls
+// `line-height: normal`. Treating `100%` as CSS `line-height: 1` therefore
+// shipped every body paragraph ~17% tighter than the source, which is what
+// five unrelated decks were independently reported for. CSS cannot scale
+// `normal`, so a constant stands in for it.
+// ponytail: one constant for every font; per-font ascent/descent metrics if a
+// specific deck's leading still reads off.
+const SINGLE_LINE_SPACING_RATIO = 1.2;
+// Must match html-converter's `DEFAULT_PPTX_FONT_SIZE_PT`: the ratio returned
+// here is divided out again against whatever font size that renderer puts on
+// the paragraph, so guessing a different default silently scales the line box.
+const DEFAULT_FONT_SIZE_PT = 18;
+function parseParagraphSpacing(value, fontSizePt) {
     const node = record(value);
     const percent = Number(record(node?.["a:spcPct"])?.["@_val"]);
-    if (Number.isFinite(percent) && percent > 0)
-        return percent / 100000;
-    return parsePoints(node?.["a:spcPts"]);
+    if (Number.isFinite(percent) && percent > 0) {
+        return (percent / 100000) * SINGLE_LINE_SPACING_RATIO;
+    }
+    const points = parsePoints(node?.["a:spcPts"]);
+    if (points === undefined)
+        return undefined;
+    const ratio = points / (fontSizePt && fontSizePt > 0 ? fontSizePt : DEFAULT_FONT_SIZE_PT);
+    return Math.min(MAX_LINE_SPACING_RATIO, Math.max(MIN_LINE_SPACING_RATIO, ratio));
 }
+/** `<a:spcBef>`/`<a:spcAft>` nest the value one level down (`<a:spcBef><a:spcPts val="1600"/></a:spcBef>`), while `<a:lnSpc>`'s caller unwraps `a:spcPts` itself — reading `@_val` off the outer node alone silently produced NaN for every paragraph spacing in every deck. */
 function parsePoints(value) {
     const node = record(value);
-    const points = Number(node?.["@_val"]);
+    const target = record(node?.["a:spcPts"]) ?? node;
+    const points = Number(target?.["@_val"]);
     return Number.isFinite(points) && points >= 0 ? points / 100 : undefined;
 }
 function mapAlignment(value) {
@@ -979,11 +1879,104 @@ function flattenElementText(elements) {
     }
     return output;
 }
-function extractSlideBackgroundColor(value, context) {
+function extractSlideBackground(value, context) {
     const root = record(value);
     const cSld = record(record(root?.["p:sld"])?.["p:cSld"] ?? root?.["p:cSld"]);
-    const bgPr = record(record(cSld?.["p:bg"])?.["p:bgPr"]);
-    return parseColor(record(bgPr?.["a:solidFill"]), context);
+    return parseBackgroundNode(cSld?.["p:bg"], context);
+}
+/** Resolves a `<p:bg>` into a CSS `background` value. Reading only `a:solidFill` left every gradient-backed deck rendering white — which, on a template whose text is white by design, is an entirely invisible slide. */
+function parseBackgroundNode(value, context) {
+    const bg = record(value);
+    if (!bg)
+        return undefined;
+    const bgPr = record(bg["p:bgPr"]);
+    if (bgPr) {
+        const solid = parseColor(record(bgPr["a:solidFill"]), context);
+        if (solid)
+            return solid;
+        const gradient = parseGradientFill(record(bgPr["a:gradFill"]), context);
+        if (gradient)
+            return gradient;
+        // `<a:pattFill>` is a two-color hatch we can't reproduce as a single CSS
+        // value; its background color is still far closer than white.
+        const pattern = record(bgPr["a:pattFill"]);
+        if (pattern) {
+            return (parseColor(record(pattern["a:bgClr"]), context) ??
+                parseColor(record(pattern["a:fgClr"]), context));
+        }
+        return undefined;
+    }
+    // `<p:bgRef idx="1001"><a:schemeClr val="lt1"/></p:bgRef>` references the
+    // theme's fill-style list; the referenced color is the whole of it for the
+    // solid styles that idx 1001-1003 resolve to in practice.
+    return parseColor(record(bg["p:bgRef"]), context);
+}
+/**
+ * Converts an `<a:gradFill>` into a CSS gradient. Collapsing to the first
+ * stop, as before, flattened four-stop brand gradients into one flat block.
+ *
+ * OOXML's `<a:lin ang>` is measured clockwise from the positive x-axis in
+ * screen coordinates (y down); CSS measures clockwise from "up". The two
+ * differ by exactly 90°.
+ */
+function parseGradientFill(gradFill, context) {
+    if (!gradFill)
+        return undefined;
+    const stops = asArray(record(gradFill["a:gsLst"])?.["a:gs"]).flatMap((rawStop) => {
+        const stop = record(rawStop);
+        const color = parseColor(stop, context);
+        if (!color)
+            return [];
+        const position = Number(stop?.["@_pos"]);
+        return [
+            {
+                color,
+                position: Number.isFinite(position) ? position / 1000 : undefined,
+            },
+        ];
+    });
+    if (stops.length === 0)
+        return undefined;
+    if (stops.length === 1)
+        return stops[0].color;
+    const stopList = stops
+        .map((stop) => stop.position === undefined
+        ? stop.color
+        : `${stop.color} ${roundTo(stop.position, 2)}%`)
+        .join(", ");
+    const path = record(gradFill["a:path"]);
+    if (path) {
+        const rect = record(path["a:fillToRect"]);
+        const centerX = fillToRectCenter(rect, "@_l", "@_r");
+        const centerY = fillToRectCenter(rect, "@_t", "@_b");
+        return `radial-gradient(circle at ${centerX}% ${centerY}%, ${stopList})`;
+    }
+    const angle = Number(record(gradFill["a:lin"])?.["@_ang"]);
+    const cssAngle = Number.isFinite(angle)
+        ? (((angle / 60000 + 90) % 360) + 360) % 360
+        : 180;
+    return `linear-gradient(${roundTo(cssAngle, 2)}deg, ${stopList})`;
+}
+/** `<a:fillToRect>` gives inset percentages from each edge; the focus point is the center of the rect they collapse to. */
+function fillToRectCenter(rect, nearAttribute, farAttribute) {
+    const near = percentAttribute(rect, nearAttribute) ?? 50;
+    const far = percentAttribute(rect, farAttribute) ?? 50;
+    return roundTo((near + (100 - far)) / 2, 2);
+}
+/** DrawingML writes these as either `"50%"` or the 1000ths-of-a-percent integer `50000`. */
+function percentAttribute(node, attribute) {
+    const raw = node?.[attribute];
+    if (raw === undefined || raw === null)
+        return undefined;
+    const text = String(raw).trim();
+    const value = Number(text.replace(/%$/, ""));
+    if (!Number.isFinite(value))
+        return undefined;
+    return text.endsWith("%") ? value : value / 1000;
+}
+function roundTo(value, digits) {
+    const factor = 10 ** digits;
+    return Math.round(value * factor) / factor;
 }
 export function parsePptxSlideMetadata(value) {
     const slide = record(value)?.["p:sld"] ?? value;
@@ -993,8 +1986,30 @@ export function parsePptxSlideMetadata(value) {
         ...(detectSplitByParagraph(slide) ? { splitByParagraph: true } : {}),
     };
 }
-async function parseTheme(zip, parseXml) {
-    return parseThemeFromPath(zip, parseXml, "ppt/theme/theme1.xml");
+/**
+ * The deck's exposed palette is the *slide* master's theme, not
+ * `ppt/theme/theme1.xml`. In every Google Slides export theme1 belongs to the
+ * notes master, so hardcoding that path persisted a stock scheme that appears
+ * nowhere in the deck and poisoned every restyle, generated slide and export
+ * that reads it.
+ */
+async function parseTheme(zip, parseXml, slideMasterRelationship) {
+    const masterPath = slideMasterRelationship
+        ? resolvePptxRelationshipPath("ppt", slideMasterRelationship.target)
+        : undefined;
+    const masterRelsXml = masterPath
+        ? await zip.file(relsPathForPptxPart(masterPath))?.async("string")
+        : undefined;
+    const themeTarget = masterRelsXml
+        ? [...parseRelationships(parseXml(masterRelsXml)).values()].find((relationship) => relationship.type.endsWith("/theme"))?.target
+        : undefined;
+    const themePath = themeTarget
+        ? resolvePptxRelationshipPath("ppt/slideMasters", themeTarget)
+        : "ppt/theme/theme1.xml";
+    const theme = await parseThemeFromPath(zip, parseXml, themePath);
+    return theme.colors.length > 0
+        ? theme
+        : parseThemeFromPath(zip, parseXml, "ppt/theme/theme1.xml");
 }
 async function parseThemeFromPath(zip, parseXml, themePath) {
     const xml = await zip.file(themePath)?.async("string");
@@ -1120,10 +2135,15 @@ function extractBackgroundFillEmbedId(slide) {
     const blip = record(record(bgPr?.["a:blipFill"])?.["a:blip"]);
     return stringValue(blip?.["@_r:embed"]);
 }
-function runProperties(value, inherited, context) {
+function runProperties(value, inherited, context, relationships) {
     if (!value)
         return inherited;
     const size = Number(value["@_sz"]);
+    // `<a:hlinkClick r:id>` points at an external relationship whose Target is
+    // the URL; without it, a deck's own "click here" instructions import as
+    // styled but inert text.
+    const linkId = stringValue(record(value["a:hlinkClick"])?.["@_r:id"]);
+    const href = linkId ? relationships?.get(linkId)?.target : undefined;
     const color = parseColor(record(value["a:solidFill"]), context);
     const fontFamily = stringValue(record(value["a:latin"])?.["@_typeface"]) ??
         stringValue(record(value["a:ea"])?.["@_typeface"]) ??
@@ -1140,6 +2160,7 @@ function runProperties(value, inherited, context) {
         ...(color ? { color } : {}),
         ...(fontFamily ? { fontFamily } : {}),
         ...(value["@_u"] && value["@_u"] !== "none" ? { underline: true } : {}),
+        ...(href ? { href } : {}),
     };
 }
 function parseRelationships(value) {
@@ -1194,16 +2215,47 @@ async function loadPptxDependencies() {
             ignoreAttributes: false,
             attributeNamePrefix: "@_",
             trimValues: false,
+            // A numeric-looking `<a:t>` body is still text: fast-xml-parser's default
+            // `parseTagValue: true` turns a type specimen "0123456789" into the
+            // number 123456789 and a spec line "CMYK: 00, 00, 00, 00" loses its
+            // leading zeros — content corruption, not a styling loss.
+            parseTagValue: false,
         });
         return {
             loadZip: (data) => zipModule.default.loadAsync(data),
-            parseXml: (xml) => parser.parse(xml),
+            parseXml: (xml) => parser.parse(annotatePathCommandOrder(normalizeHardLineBreaks(xml))),
         };
     }
     catch {
         throw new Error("Structured PPTX parsing requires the optional jszip and fast-xml-parser dependencies.");
     }
 }
+/**
+ * `<a:br/>` is a hard line break sitting *between* `<a:r>` runs, but the
+ * parser is not built with `preserveOrder`, so that interleaving is absent
+ * from the parsed tree — an `a:br` array with no position in it is
+ * unrecoverable. Rewriting each break into an ordinary run carrying a newline
+ * keeps it in document order, which is the one thing a position-less tree
+ * cannot reconstruct later. (A global `preserveOrder: true` would instead
+ * rewrite every accessor in this file.)
+ */
+function normalizeHardLineBreaks(xml) {
+    return xml.replace(/<a:br(?:\s[^>]*?)?\/>|<a:br(?:\s[^>]*?)?>[\s\S]*?<\/a:br>/g, "<a:r><a:t>\n</a:t></a:r>");
+}
+/** Attribute `annotatePathCommandOrder` stamps on, as the parser exposes it. */
+const PATH_COMMAND_ORDER_ATTRIBUTE = "@_an-order";
+/**
+ * An `<a:path>`'s children are a *sequence* — `moveTo`, `lnTo`, `cubicBezTo`,
+ * `close` — and, exactly as with `<a:br/>` above, a tree built without
+ * `preserveOrder` groups them by tag name and loses the one property a path
+ * is made of. Stamping document order onto each command before parsing keeps
+ * it recoverable; these six tag names appear nowhere else in the format, so
+ * the global rewrite cannot touch anything but a path.
+ */
+function annotatePathCommandOrder(xml) {
+    let order = 0;
+    return xml.replace(/<a:(?:moveTo|lnTo|cubicBezTo|quadBezTo|arcTo|close)\b/g, (match) => `${match} an-order="${order++}"`);
+}
 function slideNumber(value) {
     return Number(value.match(/slide(\d+)/)?.[1] ?? 0);
 }
@@ -1227,3 +2279,16 @@ function record(value) {
 function stringValue(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+function positiveAttributeNumber(value, attribute) {
+    const parsed = Number(record(value)?.[attribute]);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function sumOf(values) {
+    if (!values || values.length === 0)
+        return undefined;
+    const total = values.reduce((sum, value) => sum + value, 0);
+    return total > 0 ? total : undefined;
+}
+function xmlBoolean(value) {
+    return value === true || value === 1 || /^(?:1|true)$/i.test(String(value));
+}