@agent-native/core 0.146.0 → 0.146.2

package/dist/deploy/build.js

@@ -23,7 +23,7 @@ import { INTEGRATION_RECOVERY_RUNTIME_MARKER, INTEGRATION_RETRY_SWEEP_PATH, INTE
 import { isValidCron } from "../jobs/cron.js";
 import { RECURRING_JOBS_SWEEP_PATH, RECURRING_JOBS_SWEEP_TOKEN_SUBJECT, } from "../jobs/scheduler-dispatch.js";
 import { normalizeAppBasePath } from "../server/app-base-path.js";
-import { DEFAULT_SPECULATION_RULES_PATH, resolveSsrCacheHeaders, } from "../shared/cache-control.js";
+import { DEFAULT_SPECULATION_RULES_PATH, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, } from "../shared/cache-control.js";
 import { mcpEmbedStaticAssetRouteRules } from "../shared/mcp-embed-headers.js";
 import { AGENT_NATIVE_SOCIAL_IMAGE_ALT, AGENT_NATIVE_SOCIAL_IMAGE_CACHE_BUSTER, AGENT_NATIVE_SOCIAL_IMAGE_HEIGHT, AGENT_NATIVE_SOCIAL_IMAGE_PATH, AGENT_NATIVE_SOCIAL_IMAGE_TYPE, AGENT_NATIVE_SOCIAL_IMAGE_WIDTH, } from "../shared/social-meta.js";
 import { generateActionRegistryForProject } from "../vite/action-types-plugin.js";
@@ -652,6 +652,7 @@ export function generateWorkerEntry(routes, pluginPaths, defaultPluginStems = []
     // The worker ships as a static bundle with no access to runtime env, so the
     // deployment-wide SSR cache policy is baked in from this build's env.
     const ssrCacheHeaders = resolveSsrCacheHeaders();
+    const ssrCacheKeyHeaders = resolveSsrCacheKeyHeaders();
     const routeImports = [];
     const routeRegistrations = [];
     for (let i = 0; i < routes.length; i++) {
@@ -971,9 +972,8 @@ function injectHeadScript(html, script) {
 }
 
 // Resolved from AGENT_NATIVE_SSR_CACHE at build time.
-const SSR_CACHE_CONTROL = ${JSON.stringify(ssrCacheHeaders["cache-control"])};
-const SSR_CDN_CACHE_CONTROL = ${JSON.stringify(ssrCacheHeaders["cdn-cache-control"])};
-const SSR_NETLIFY_CDN_CACHE_CONTROL = ${JSON.stringify(ssrCacheHeaders["netlify-cdn-cache-control"])};
+const SSR_CACHE_HEADERS = ${JSON.stringify(ssrCacheHeaders)};
+const SSR_CACHE_KEY_HEADERS = ${JSON.stringify(ssrCacheKeyHeaders)};
 const DEFAULT_SPECULATION_RULES_PATH = ${JSON.stringify(DEFAULT_SPECULATION_RULES_PATH)};
 const IMMUTABLE_ASSET_CACHE_CONTROL = ${JSON.stringify(IMMUTABLE_ASSET_CACHE_CONTROL)};
 const IMMUTABLE_ASSET_PATHS = new Set(${JSON.stringify([...new Set(immutableAssetPaths)].sort())});
@@ -1057,13 +1057,12 @@ function applyDefaultSsrCacheHeader(headers, status, pathname) {
     else headers.delete("vary");
   }
 
-  headers.set("cache-control", SSR_CACHE_CONTROL);
-  headers.set("cdn-cache-control", SSR_CDN_CACHE_CONTROL);
-  // Netlify function responses are dynamic by default and can otherwise show
-  // Cache-Status fwd=bypass even with Cache-Control: public. Keep this
-  // Netlify-specific header so SSR HTML/.data are served from the shared
-  // durable CDN cache instead of stampeding origin — for every visitor.
-  headers.set("netlify-cdn-cache-control", SSR_NETLIFY_CDN_CACHE_CONTROL);
+  for (const [name, value] of Object.entries(SSR_CACHE_HEADERS)) {
+    headers.set(name, value);
+  }
+  for (const [name, value] of Object.entries(SSR_CACHE_KEY_HEADERS)) {
+    headers.set(name, value);
+  }
 }
 
 function applyDefaultSpeculationRulesHeader(headers, status, basePath) {
@@ -3464,6 +3463,22 @@ function createBrowserOnlyServerStubPlugin() {
         },
     };
 }
+export function resolveNitroBuildReplacements(env = process.env) {
+    return {
+        // Netlify exposes DEPLOY_ID only while building. Embed it into the Nitro
+        // function so preview OAuth relays can target this immutable deployment
+        // even though the value is unavailable in the function runtime.
+        "process.env.AGENT_NATIVE_BUILD_ID": JSON.stringify(env.DEPLOY_ID?.trim() || env.AGENT_NATIVE_BUILD_ID?.trim() || ""),
+        "process.env.AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID": JSON.stringify(env.GA_MEASUREMENT_ID?.trim() || ""),
+        "process.env.AGENT_NATIVE_BUILD_GTM_CONTAINER_ID": JSON.stringify(env.GTM_CONTAINER_ID?.trim() || ""),
+        // Netlify's netlify.toml environment is available while this deploy
+        // build runs, but is not injected into the deployed Function. Nitro is
+        // a separate server build, so embed release migration ownership here as
+        // well as in the Vite server bundle.
+        "process.env.AGENT_NATIVE_RELEASE_MIGRATIONS": JSON.stringify(env.AGENT_NATIVE_RELEASE_MIGRATIONS?.trim() || ""),
+        "process.env.AGENT_NATIVE_BUILD_DEPLOY_CONTEXT": JSON.stringify(env.CONTEXT?.trim() || ""),
+    };
+}
 async function buildWithNitro() {
     console.log(`[deploy] Building for preset "${preset}" via Nitro...`);
     const appBasePath = normalizeConfiguredAppBasePath();
@@ -3547,17 +3562,7 @@ export default bundle;
         virtual: {
             "virtual:agents-bundle": agentsBundleModuleSource,
         },
-        replace: {
-            // Netlify exposes DEPLOY_ID only while building. Embed it into the Nitro
-            // function so preview OAuth relays can target this immutable deployment
-            // even though the value is unavailable in the function runtime.
-            "process.env.AGENT_NATIVE_BUILD_ID": JSON.stringify(process.env.DEPLOY_ID?.trim() ||
-                process.env.AGENT_NATIVE_BUILD_ID?.trim() ||
-                ""),
-            "process.env.AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID": JSON.stringify(process.env.GA_MEASUREMENT_ID?.trim() || ""),
-            "process.env.AGENT_NATIVE_BUILD_GTM_CONTAINER_ID": JSON.stringify(process.env.GTM_CONTAINER_ID?.trim() || ""),
-            "process.env.AGENT_NATIVE_BUILD_DEPLOY_CONTEXT": JSON.stringify(process.env.CONTEXT?.trim() || ""),
-        },
+        replace: resolveNitroBuildReplacements(),
         // Replace browser-only renderers (Excalidraw/Mermaid) with an inert proxy in
         // the server bundle. Without this, Nitro's Rolldown build pulls the real
         // Excalidraw into a shared vendor chunk imported statically by the SSR render

package/dist/file-upload/actions/upload-image.d.ts

@@ -17,11 +17,11 @@ declare const _default: import("../../action.js").ActionDefinition<{
     id?: undefined;
     provider?: undefined;
 } | {
+    error?: undefined;
     configured?: undefined;
     connectPath?: undefined;
     url: string;
     id: string;
     provider: string;
-    error?: undefined;
 }>;
 export default _default;

package/dist/ingestion/pptx.d.ts

@@ -6,6 +6,7 @@ export interface ParsedPptxTextRun {
     color?: string;
     fontFamily?: string;
     underline?: boolean;
+    href?: string;
 }
 export interface ParsedPptxParagraph {
     runs: ParsedPptxTextRun[];

package/dist/ingestion/pptx.js

@@ -40,7 +40,32 @@ export async function parsePptxPresentation(fileBuffer) {
             .filter((path) => /^ppt\/slides\/slide\d+\.xml$/.test(path))
             .sort((a, b) => slideNumber(a) - slideNumber(b)));
     }
+    // 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 masterColorInfo = slideMasterRelationship
+        ? await parseMasterColorInfo({
+            zip,
+            target: slideMasterRelationship.target,
+            parseXml,
+        })
+        : { clrMap: {}, titleFillByLevel: {}, bodyFillByLevel: {} };
+    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),
+    };
+    const themeCache = new Map();
+    const masterInfoCache = new Map();
     const slides = [];
     for (const slidePath of slidePaths) {
         const xml = await zip.file(slidePath)?.async("string");
@@ -63,6 +88,18 @@ export async function parsePptxPresentation(fileBuffer) {
         const slideRelationships = slideRelationshipsXml
             ? parseRelationships(parseXml(slideRelationshipsXml))
             : new Map();
+        // Presentations can mix multiple masters (e.g. combined templates), each
+        // with its own color map / theme / placeholder defaults — resolve this
+        // slide's own layout→master chain instead of reusing whichever master
+        // happened to be first in the presentation, falling back to the
+        // deck-wide default above only when that chain can't be resolved.
+        const slideMasterContext = (await resolveSlideMasterContext({
+            zip,
+            parseXml,
+            slideRelationships,
+            themeCache,
+            masterInfoCache,
+        })) ?? { colorContext, placeholderDefaults };
         elements = await parseSlideElements({
             xml,
             parseXml,
@@ -72,6 +109,8 @@ export async function parsePptxPresentation(fileBuffer) {
             slideWidthEmu,
             slideHeightEmu,
             images,
+            colorContext: slideMasterContext.colorContext,
+            placeholderDefaults: slideMasterContext.placeholderDefaults,
         });
         const texts = flattenElementText(elements);
         const number = slideNumber(slidePath);
@@ -95,7 +134,7 @@ export async function parsePptxPresentation(fileBuffer) {
             elements,
             widthEmu: slideWidthEmu,
             heightEmu: slideHeightEmu,
-            backgroundColor: extractSlideBackgroundColor(slide),
+            backgroundColor: extractSlideBackgroundColor(slide, slideMasterContext.colorContext),
             ...(backgroundGrid ? { backgroundGrid } : {}),
             notes,
             layoutHint: guessLayoutHint(texts, images.length > 0),
@@ -184,6 +223,123 @@ async function parseMasterGrid(args) {
         lineWidthEmu,
     };
 }
+/** Resolves an OOXML relationship `Target` (package-absolute like "/ppt/foo.xml", or relative like "../slideMasters/slideMaster1.xml") against the directory of the part that declared it. */
+function resolvePptxRelationshipPath(baseDir, target) {
+    if (target.startsWith("/"))
+        return target.slice(1);
+    const segments = `${baseDir}/${target}`.split("/");
+    const resolved = [];
+    for (const segment of segments) {
+        if (segment === "." || segment === "")
+            continue;
+        if (segment === "..")
+            resolved.pop();
+        else
+            resolved.push(segment);
+    }
+    return resolved.join("/");
+}
+/** The `_rels/<file>.rels` part that carries relationships for a given OOXML part path. */
+function relsPathForPptxPart(path) {
+    const slashIndex = path.lastIndexOf("/");
+    const dir = slashIndex >= 0 ? path.slice(0, slashIndex) : "";
+    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);
+    const layoutRelsXml = await args.zip
+        .file(relsPathForPptxPart(layoutPath))
+        ?.async("string");
+    if (!layoutRelsXml)
+        return undefined;
+    const layoutRelationships = parseRelationships(args.parseXml(layoutRelsXml));
+    const masterRelationship = [...layoutRelationships.values()].find((relationship) => relationship.type.endsWith("/slideMaster"));
+    if (!masterRelationship)
+        return undefined;
+    const masterPath = resolvePptxRelationshipPath("ppt/slideLayouts", masterRelationship.target);
+    let masterInfoPromise = args.masterInfoCache.get(masterPath);
+    if (!masterInfoPromise) {
+        masterInfoPromise = parseMasterColorInfo({
+            zip: args.zip,
+            target: masterRelationship.target,
+            parseXml: args.parseXml,
+        });
+        args.masterInfoCache.set(masterPath, masterInfoPromise);
+    }
+    const masterInfo = await masterInfoPromise;
+    const masterRelsXml = await args.zip
+        .file(relsPathForPptxPart(masterPath))
+        ?.async("string");
+    const masterRelationships = masterRelsXml
+        ? parseRelationships(args.parseXml(masterRelsXml))
+        : new Map();
+    const themeRelationship = [...masterRelationships.values()].find((relationship) => relationship.type.endsWith("/theme"));
+    if (!themeRelationship)
+        return undefined;
+    const themePath = resolvePptxRelationshipPath("ppt/slideMasters", themeRelationship.target);
+    let themePromise = args.themeCache.get(themePath);
+    if (!themePromise) {
+        themePromise = parseThemeFromPath(args.zip, args.parseXml, themePath);
+        args.themeCache.set(themePath, themePromise);
+    }
+    const theme = await themePromise;
+    const colorContext = {
+        themeColorsByName: theme.colorsByName,
+        clrMap: masterInfo.clrMap,
+    };
+    const resolveFillsByLevel = (fillsByLevel) => Object.fromEntries(Object.entries(fillsByLevel).map(([level, fill]) => [
+        Number(level),
+        parseColor(fill, colorContext),
+    ]));
+    return {
+        colorContext,
+        placeholderDefaults: {
+            title: resolveFillsByLevel(masterInfo.titleFillByLevel),
+            body: resolveFillsByLevel(masterInfo.bodyFillByLevel),
+        },
+    };
+}
+/** 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 path = args.target.startsWith("/")
+        ? args.target.slice(1)
+        : "ppt/" + args.target.replace(/^\.\.\//, "");
+    const xml = await args.zip.file(path)?.async("string");
+    if (!xml)
+        return empty;
+    const root = record(record(args.parseXml(xml))?.["p:sldMaster"]);
+    if (!root)
+        return empty;
+    const clrMap = parseClrMapNode(record(root["p:clrMap"]));
+    const txStyles = record(root["p:txStyles"]);
+    return {
+        clrMap,
+        titleFillByLevel: levelFillsFromTextStyle(record(txStyles?.["p:titleStyle"])),
+        bodyFillByLevel: levelFillsFromTextStyle(record(txStyles?.["p:bodyStyle"])),
+    };
+}
+/** 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 = {};
+    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"]);
+    }
+    return fills;
+}
 const SHAPE_ELEMENT_NAMES = new Set([
     "sp",
     "pic",
@@ -273,9 +429,15 @@ async function parseShapeFragment(fragment, args) {
     const name = readShapeName(node);
     const placeholderType = stringValue(record(record(record(node["p:nvSpPr"])?.["p:nvPr"])?.["p:ph"])?.["@_type"]);
     const shapeProperties = record(node["p:spPr"]);
-    const text = parseTextBody(node);
-    const fill = parseShapeFill(shapeProperties);
-    const line = parseShapeLine(shapeProperties);
+    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 fill = parseShapeFill(shapeProperties, args.colorContext);
+    const line = parseShapeLine(shapeProperties, args.colorContext);
     const shapeType = stringValue(record(shapeProperties?.["a:prstGeom"])?.["@_prst"]);
     if (entry === "pic") {
         const embedId = stringValue(record(record(node["p:blipFill"])?.["a:blip"])?.["@_r:embed"]);
@@ -446,7 +608,7 @@ function applyTransform(transform, context) {
             : {}),
     };
 }
-function parseTextBody(node) {
+function parseTextBody(node, context) {
     const txBody = record(node["p:txBody"]);
     if (!txBody)
         return [];
@@ -460,7 +622,7 @@ function parseTextBody(node) {
             if (content) {
                 runs.push({
                     content,
-                    ...runProperties(record(run?.["a:rPr"]), {}),
+                    ...runProperties(record(run?.["a:rPr"]), {}, context),
                 });
             }
         }
@@ -470,12 +632,12 @@ function parseTextBody(node) {
             if (content) {
                 runs.push({
                     content,
-                    ...runProperties(record(field?.["a:rPr"]), {}),
+                    ...runProperties(record(field?.["a:rPr"]), {}, context),
                 });
             }
         }
         const bullet = record(pPr?.["a:buChar"]);
-        const bulletColor = parseColor(record(pPr?.["a:buClr"]));
+        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"]);
@@ -527,18 +689,18 @@ function parseTextBoxProperties(node) {
                 : { verticalAlign: "top" }),
     };
 }
-function parseShapeFill(shapeProperties) {
+function parseShapeFill(shapeProperties, context) {
     if (!shapeProperties)
         return undefined;
     if (shapeProperties["a:noFill"] !== undefined)
         return undefined;
-    return parseColor(record(shapeProperties["a:solidFill"]));
+    return parseColor(record(shapeProperties["a:solidFill"]), context);
 }
-function parseShapeLine(shapeProperties) {
+function parseShapeLine(shapeProperties, context) {
     const line = record(shapeProperties?.["a:ln"]);
     if (!line || line["a:noFill"] !== undefined)
         return undefined;
-    const color = parseColor(record(line["a:solidFill"]));
+    const color = parseColor(record(line["a:solidFill"]), context);
     if (!color)
         return undefined;
     const width = Number(line["@_w"]);
@@ -547,15 +709,163 @@ function parseShapeLine(shapeProperties) {
         ...(Number.isFinite(width) && width > 0 ? { width } : {}),
     };
 }
-function parseColor(value) {
+/** 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)
+        return paragraphs;
+    return paragraphs.map((paragraph) => {
+        const level = paragraph.level ?? 0;
+        const color = colorsByLevel[level] ?? colorsByLevel[0];
+        if (!color)
+            return paragraph;
+        return {
+            ...paragraph,
+            runs: paragraph.runs.map((run) => (run.color ? run : { ...run, color })),
+        };
+    });
+}
+/** PowerPoint's default `bg1`/`tx1`-style alias mapping, used whenever a master doesn't declare its own `<p:clrMap>`. */
+const IDENTITY_CLR_MAP = {
+    bg1: "lt1",
+    tx1: "dk1",
+    bg2: "lt2",
+    tx2: "dk2",
+    accent1: "accent1",
+    accent2: "accent2",
+    accent3: "accent3",
+    accent4: "accent4",
+    accent5: "accent5",
+    accent6: "accent6",
+    hlink: "hlink",
+    folHlink: "folHlink",
+};
+const CLR_MAP_ALIASES = Object.keys(IDENTITY_CLR_MAP);
+/** Reads a `<p:clrMap .../>` or `<a:overrideClrMapping .../>` node's alias attributes into an alias→theme-slot map. */
+function parseClrMapNode(node) {
+    const map = {};
+    if (!node)
+        return map;
+    for (const alias of CLR_MAP_ALIASES) {
+        const target = stringValue(node[`@_${alias}`]);
+        if (target)
+            map[alias] = target;
+    }
+    return map;
+}
+function resolveSchemeColorName(name, context) {
+    if (!context)
+        return undefined;
+    const slot = context.clrMap[name] ?? IDENTITY_CLR_MAP[name] ?? name;
+    return context.themeColorsByName[slot];
+}
+function hexToHsl(hex) {
+    const r = parseInt(hex.slice(1, 3), 16) / 255;
+    const g = parseInt(hex.slice(3, 5), 16) / 255;
+    const b = parseInt(hex.slice(5, 7), 16) / 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const l = (max + min) / 2;
+    if (max === min)
+        return [0, 0, l];
+    const d = max - min;
+    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    let h;
+    switch (max) {
+        case r:
+            h = (g - b) / d + (g < b ? 6 : 0);
+            break;
+        case g:
+            h = (b - r) / d + 2;
+            break;
+        default:
+            h = (r - g) / d + 4;
+    }
+    return [h * 60, s, l];
+}
+function hslToHex(h, s, l) {
+    const toByte = (v) => Math.max(0, Math.min(255, Math.round(v * 255)))
+        .toString(16)
+        .padStart(2, "0");
+    if (s === 0) {
+        const gray = toByte(l);
+        return `#${gray}${gray}${gray}`;
+    }
+    const hue2rgb = (p, q, t) => {
+        let tt = t;
+        if (tt < 0)
+            tt += 1;
+        if (tt > 1)
+            tt -= 1;
+        if (tt < 1 / 6)
+            return p + (q - p) * 6 * tt;
+        if (tt < 1 / 2)
+            return q;
+        if (tt < 2 / 3)
+            return p + (q - p) * (2 / 3 - tt) * 6;
+        return p;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    const hNorm = h / 360;
+    const r = hue2rgb(p, q, hNorm + 1 / 3);
+    const g = hue2rgb(p, q, hNorm);
+    const b = hue2rgb(p, q, hNorm - 1 / 3);
+    return `#${toByte(r)}${toByte(g)}${toByte(b)}`;
+}
+function readColorTransforms(node) {
+    if (!node)
+        return {};
+    const percent = (key) => {
+        const raw = stringValue(record(node[key])?.["@_val"]);
+        return raw !== undefined ? Number(raw) / 100000 : undefined;
+    };
+    return {
+        lumMod: percent("a:lumMod"),
+        lumOff: percent("a:lumOff"),
+        tint: percent("a:tint"),
+        shade: percent("a:shade"),
+    };
+}
+function applyColorTransforms(hex, transforms) {
+    const { lumMod, lumOff, tint, shade } = transforms;
+    if (lumMod === undefined &&
+        lumOff === undefined &&
+        tint === undefined &&
+        shade === undefined) {
+        return hex;
+    }
+    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)));
+}
+function parseColor(value, context) {
     if (!value)
         return undefined;
-    const rgb = stringValue(record(value["a:srgbClr"])?.["@_val"]);
-    if (rgb)
-        return `#${rgb}`;
-    const scheme = stringValue(record(value["a:schemeClr"])?.["@_val"]);
+    const srgbNode = record(value["a:srgbClr"]);
+    const rgb = stringValue(srgbNode?.["@_val"]);
+    if (rgb) {
+        return applyColorTransforms(`#${rgb}`, readColorTransforms(srgbNode));
+    }
+    const schemeNode = record(value["a:schemeClr"]);
+    const scheme = stringValue(schemeNode?.["@_val"]);
     if (!scheme)
         return undefined;
+    const transforms = readColorTransforms(schemeNode);
+    const resolved = resolveSchemeColorName(scheme, context);
+    if (resolved)
+        return applyColorTransforms(resolved, transforms);
+    // No theme/clrMap available for this slot (or the theme didn't define
+    // it) — fall back to a coarse dark/light guess along the standard
+    // identity mapping, so tx1/dk1/bg1/lt1 text stays visible rather than
+    // silently vanishing.
     const pptxDarkColor = "#000000"; // guard:allow-raw-color - PPTX dark scheme fallback
     const pptxLightColor = "#ffffff"; // guard:allow-raw-color - PPTX light scheme fallback
     const fallback = {
@@ -563,8 +873,15 @@ function parseColor(value) {
         dk2: pptxDarkColor,
         lt1: pptxLightColor,
         lt2: pptxLightColor,
+        tx1: pptxDarkColor,
+        tx2: pptxDarkColor,
+        bg1: pptxLightColor,
+        bg2: pptxLightColor,
     };
-    return fallback[scheme];
+    const fallbackColor = fallback[scheme];
+    return fallbackColor
+        ? applyColorTransforms(fallbackColor, transforms)
+        : undefined;
 }
 function parseParagraphSpacing(value) {
     const node = record(value);
@@ -662,11 +979,11 @@ function flattenElementText(elements) {
     }
     return output;
 }
-function extractSlideBackgroundColor(value) {
+function extractSlideBackgroundColor(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"]));
+    return parseColor(record(bgPr?.["a:solidFill"]), context);
 }
 export function parsePptxSlideMetadata(value) {
     const slide = record(value)?.["p:sld"] ?? value;
@@ -677,28 +994,36 @@ export function parsePptxSlideMetadata(value) {
     };
 }
 async function parseTheme(zip, parseXml) {
-    const xml = await zip.file("ppt/theme/theme1.xml")?.async("string");
+    return parseThemeFromPath(zip, parseXml, "ppt/theme/theme1.xml");
+}
+async function parseThemeFromPath(zip, parseXml, themePath) {
+    const xml = await zip.file(themePath)?.async("string");
     if (!xml)
-        return undefined;
+        return { colors: [], colorsByName: {}, fonts: [] };
     const root = record(parseXml(xml));
     const elements = record(record(root?.["a:theme"])?.["a:themeElements"]);
     const scheme = record(elements?.["a:clrScheme"]);
     const colors = [];
+    const colorsByName = {};
     for (const [key, value] of Object.entries(scheme ?? {})) {
         if (key.startsWith("@_"))
             continue;
         const color = record(value);
         const rgb = stringValue(record(color?.["a:srgbClr"])?.["@_val"]);
         const system = stringValue(record(color?.["a:sysClr"])?.["@_lastClr"]);
-        if (rgb || system)
-            colors.push(`#${rgb ?? system}`);
+        if (!rgb && !system)
+            continue;
+        const hex = `#${rgb ?? system}`;
+        colors.push(hex);
+        const slotName = key.replace(/^a:/, "");
+        colorsByName[slotName] = hex;
     }
     const fontScheme = record(elements?.["a:fontScheme"]);
     const fonts = ["a:majorFont", "a:minorFont"].flatMap((key) => {
         const value = stringValue(record(record(fontScheme?.[key])?.["a:latin"])?.["@_typeface"]);
         return value ? [value] : [];
     });
-    return colors.length || fonts.length ? { colors, fonts } : undefined;
+    return { colors, colorsByName, fonts };
 }
 function collectTextRuns(value, runs, inherited = {}) {
     const node = record(value);
@@ -795,11 +1120,11 @@ function extractBackgroundFillEmbedId(slide) {
     const blip = record(record(bgPr?.["a:blipFill"])?.["a:blip"]);
     return stringValue(blip?.["@_r:embed"]);
 }
-function runProperties(value, inherited) {
+function runProperties(value, inherited, context) {
     if (!value)
         return inherited;
     const size = Number(value["@_sz"]);
-    const rgb = stringValue(record(record(value["a:solidFill"])?.["a:srgbClr"])?.["@_val"]);
+    const color = parseColor(record(value["a:solidFill"]), context);
     const fontFamily = stringValue(record(value["a:latin"])?.["@_typeface"]) ??
         stringValue(record(value["a:ea"])?.["@_typeface"]) ??
         stringValue(record(value["a:cs"])?.["@_typeface"]);
@@ -812,7 +1137,7 @@ function runProperties(value, inherited) {
             ? { italic: true }
             : {}),
         ...(Number.isFinite(size) && size > 0 ? { fontSize: size / 100 } : {}),
-        ...(rgb ? { color: `#${rgb}` } : {}),
+        ...(color ? { color } : {}),
         ...(fontFamily ? { fontFamily } : {}),
         ...(value["@_u"] && value["@_u"] !== "none" ? { underline: true } : {}),
     };

package/dist/notifications/routes.d.ts

@@ -13,13 +13,13 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
     count: number;
     updated?: undefined;
-    error?: undefined;
     ok?: undefined;
+    error?: undefined;
 } | {
     count?: undefined;
     updated: number;
-    error?: undefined;
     ok?: undefined;
+    error?: undefined;
 } | {
     count?: undefined;
     updated?: undefined;

package/dist/observability/routes.d.ts

@@ -62,6 +62,6 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/progress/routes.d.ts

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;