@json-to-office/core-docx 3.2.0 → 4.0.0

package/dist/index.js

@@ -246,6 +246,7 @@ var init_minimal_docx_theme = __esm({
       name: "minimal",
       displayName: "Minimal Clean",
       description: "A quiet, warm minimal theme \u2014 Calibri throughout, sage-green ink on ivory neutrals, a large tracked-tight bold title, wide margins and hairline rules",
+      whenToUse: "Quiet documents where the type carries the tone: notes, briefs, drafts and internal papers that want warmth without decoration.",
       version: "4.0.0",
       colors: {
         primary: "#2B302B",
@@ -435,6 +436,7 @@ var init_devportal_docx_theme = __esm({
       name: "devportal",
       displayName: "Field Editorial",
       description: "A compact editorial theme \u2014 Helvetica in near-black ink with a burnt-orange accent, tight condensed titles, letterspaced labels, warm tinted fills and hairline rules",
+      whenToUse: "Developer and product documentation, API guides and technical handbooks: dense text, code and tables that need compact, letterspaced structure.",
       version: "4.0.0",
       colors: {
         primary: "#12191F",
@@ -633,6 +635,7 @@ var init_vermilion_docx_theme = __esm({
       name: "vermilion",
       displayName: "Vermilion Editorial",
       description: "Poster-red editorial system \u2014 vermilion display headings, ink text, warm creams and hairline rules",
+      whenToUse: "Editorial and annual-report work that wants a strong red display voice: covers, feature-style sections, reports built around a few large headings.",
       version: "1.0.0",
       colors: {
         primary: "#282829",
@@ -851,6 +854,7 @@ var init_consulting_docx_theme = __esm({
       name: "consulting",
       displayName: "Consulting House",
       description: "The house style for client and technical reports \u2014 near-black ink, three greys and one deep-blue accent, Calibri body under Arial headings, hairline rules, no fills behind body text, safe fonts only",
+      whenToUse: "Client and technical reports, memos and anything a client will read as the house's own work; the default choice for a report unless the brief names a brand.",
       version: "1.0.0",
       colors: {
         primary: "#1A1F26",
@@ -5051,6 +5055,10 @@ function resolveServiceUrl(propsUrl, servicesUrl, defaultUrl) {
   const withScheme = /^https?:\/\//i.test(raw) ? raw : `http://${raw}`;
   return withScheme.replace(/\/+$/, "");
 }
+var SERVICE_UNAVAILABLE_CODE = "SERVICE_UNAVAILABLE";
+function serviceUnavailable(message) {
+  return Object.assign(new Error(message), { code: SERVICE_UNAVAILABLE_CODE });
+}
 async function postJsonToService(opts) {
   const resolvedHeaders = typeof opts.headers === "function" ? await opts.headers(opts.body) : opts.headers;
   const headers = {
@@ -5070,12 +5078,12 @@ async function postJsonToService(opts) {
     });
   } catch (error) {
     if (error?.name === "AbortError") {
-      throw new Error(
+      throw serviceUnavailable(
         `${opts.serviceLabel} timed out after ${timeoutMs}ms at ${opts.url}.`
       );
     }
     const cause = error instanceof Error ? error.message : String(error);
-    throw new Error(opts.onUnreachable(opts.url, cause));
+    throw serviceUnavailable(opts.onUnreachable(opts.url, cause));
   } finally {
     clearTimeout(timer);
   }
@@ -11770,6 +11778,7 @@ async function processResolvedDocument(document, resolved, themeName, generation
   };
 }
 function createDocumentMetadata(props, generationDate = /* @__PURE__ */ new Date()) {
+  const parsed = props.metadata?.date ? new Date(props.metadata.date) : void 0;
   return {
     title: props.metadata?.title,
     subtitle: props.metadata?.subtitle,
@@ -11778,7 +11787,7 @@ function createDocumentMetadata(props, generationDate = /* @__PURE__ */ new Date
     company: props.metadata?.company,
     version: props.metadata?.version,
     tags: props.metadata?.tags,
-    date: props.metadata?.date ? new Date(props.metadata.date) : generationDate
+    date: parsed && !Number.isNaN(parsed.getTime()) ? parsed : generationDate
   };
 }
 async function extractSections(components, context) {
@@ -11870,7 +11879,12 @@ import {
   normalizeHighchartsChart
 } from "@json-to-office/quality";
 import { DEFAULT_DOCX_RENDERER_ID as DEFAULT_DOCX_RENDERER_ID2 } from "@json-to-office/shared-docx";
-import { designColors as designColors2, resolveDesignColor as resolveDesignColor2 } from "@json-to-office/shared";
+import {
+  designCanvas as designCanvas2,
+  designColors as designColors2,
+  resolveDesignColor as resolveDesignColor2,
+  typeScaleSizes
+} from "@json-to-office/shared";
 
 // src/core/generationContext.ts
 import { applyExportMode } from "@json-to-office/shared";
@@ -12809,6 +12823,93 @@ function walkActive(node, path4, page, visit) {
     (child, index) => walkActive(child, `${path4}/children/${index}`, page, visit)
   );
 }
+function textSizeFact(node, props, path4, typography, role) {
+  const size = effectiveFontSize(node, props, typography);
+  if (size === void 0) return void 0;
+  return {
+    id: `docx:text-size:${path4}`,
+    kind: "docx/text-size",
+    path: path4,
+    role: role ?? styleKey(node, props),
+    fontSizePt: size.fontSizePt,
+    authored: size.authored,
+    ...size.authored && { sizePath: `${path4}/props/font/size` }
+  };
+}
+function tableTextSizeFacts(props, authored, path4, typography, page) {
+  const facts = [];
+  const sizeOf = (holder) => finiteNumber(asRecord(asRecord(holder)?.font)?.size);
+  const authoredSize = (holder, pointer, role) => {
+    const size = sizeOf(holder);
+    if (size === void 0) return;
+    facts.push({
+      id: `docx:text-size:${pointer}`,
+      kind: "docx/text-size",
+      path: pointer,
+      role,
+      fontSizePt: size,
+      authored: true,
+      sizePath: `${pointer}/font/size`
+    });
+  };
+  const cellContent = (holder, pointer, role) => {
+    const content = asRecord(holder)?.content;
+    if (asRecord(content) === void 0) return;
+    walkActive(content, `${pointer}/content`, page, (node, nodePath) => {
+      if (node.name !== "paragraph" && node.name !== "heading") return;
+      const nodeProps = asRecord(node.props) ?? {};
+      if (typeof nodeProps.text !== "string" || nodeProps.text.trim() === "")
+        return;
+      const fact = textSizeFact(node, nodeProps, nodePath, typography, role);
+      if (fact) facts.push(fact);
+    });
+  };
+  if (authored) {
+    authoredSize(
+      authored.cellDefaults,
+      `${path4}/props/cellDefaults`,
+      "tableCell"
+    );
+    authoredSize(
+      authored.headerCellDefaults,
+      `${path4}/props/headerCellDefaults`,
+      "tableHeader"
+    );
+    const columns = Array.isArray(authored.columns) ? authored.columns : [];
+    columns.forEach((column, index) => {
+      const record = asRecord(column) ?? {};
+      const columnPath = `${path4}/props/columns/${index}`;
+      authoredSize(
+        record.cellDefaults,
+        `${columnPath}/cellDefaults`,
+        "tableCell"
+      );
+      authoredSize(record.header, `${columnPath}/header`, "tableHeader");
+      cellContent(record.header, `${columnPath}/header`, "tableHeader");
+      const cells = Array.isArray(record.cells) ? record.cells : [];
+      cells.forEach((cell, cellIndex) => {
+        authoredSize(cell, `${columnPath}/cells/${cellIndex}`, "tableCell");
+        cellContent(cell, `${columnPath}/cells/${cellIndex}`, "tableCell");
+      });
+    });
+  }
+  for (const [key, role] of [
+    ["cellDefaults", "tableCell"],
+    ["headerCellDefaults", "tableHeader"]
+  ]) {
+    const size = sizeOf(props[key]);
+    if (size === void 0) continue;
+    facts.push({
+      id: `docx:text-size:${path4}:${role}`,
+      kind: "docx/text-size",
+      path: path4,
+      role,
+      fontSizePt: size,
+      authored: false
+    });
+  }
+  return facts;
+}
 function prepareDocxQualityDocument(document, options = {}) {
   const themed = options.context ?? resolveThemeContext(normalizeDocument(document)[0], {
     customThemes: options.customThemes,
@@ -12856,6 +12957,75 @@ function prepareDocxQualityDocument(document, options = {}) {
       ...budget
     });
   }
+  for (const role of blockSlotRoles2(themed.document, expanded.blocks)) {
+    addFact({
+      id: `docx:chrome-slot:${role.path}`,
+      kind: "docx/chrome-slot",
+      path: role.path,
+      relatedPaths: [role.invocation],
+      block: role.block,
+      slot: role.slot,
+      role: role.role,
+      present: slotIsFilled(role.value),
+      invocation: role.invocation
+    });
+  }
+  const topLevel = Array.isArray(context.document.children) ? context.document.children : [];
+  let inherited = {};
+  topLevel.forEach((node, index) => {
+    if (node?.name !== "section") return;
+    const props = asRecord(node.props) ?? {};
+    const part = (kind) => props[kind] === "linkToPrevious" ? inherited[kind] : props[kind];
+    const header = part("header");
+    const footer = part("footer");
+    inherited = { header, footer };
+    for (const kind of ["header", "footer"]) {
+      if (!Array.isArray(props[kind])) continue;
+      const drawnByBlock = !Array.isArray(
+        asRecord(
+          asRecord(
+            (Array.isArray(themed.document.children) ? themed.document.children : [])[index]
+          )?.props
+        )?.[kind]
+      );
+      const part2 = props[kind];
+      const visitChrome = (child, childPath) => {
+        if (child.name !== "paragraph" && child.name !== "heading") return;
+        const childProps = asRecord(child.props) ?? {};
+        if (typeof childProps.text !== "string" || childProps.text.trim() === "")
+          return;
+        const fact = textSizeFact(
+          child,
+          childProps,
+          childPath,
+          typography,
+          kind
+        );
+        if (fact)
+          addFact({
+            ...fact,
+            generated: drawnByBlock || authoredPath(childPath) !== childPath
+          });
+      };
+      part2.forEach(
+        (child, childIndex) => walkActive(
+          child,
+          `/children/${index}/props/${kind}/${childIndex}`,
+          basePage,
+          visitChrome
+        )
+      );
+    }
+    addFact({
+      id: `docx:section-chrome:${index}`,
+      kind: "docx/section-chrome",
+      path: `/children/${index}`,
+      index,
+      header: partPresent(header),
+      footer: partPresent(footer),
+      pageNumber: hasPageField(header) || hasPageField(footer)
+    });
+  });
   const paletteHexes = {};
   const visualColors = designColors2(
     resolved.theme.colors,
@@ -12879,12 +13049,34 @@ function prepareDocxQualityDocument(document, options = {}) {
     (value) => `#${resolveDesignColor2(value, visualColors)}`
   ) ?? SERIES_COLOR_TOKENS.filter((token) => paletteHexes[token] !== void 0);
   const authoredPropsAt = (pointer) => asRecord(asRecord(nodeAtPointer(context.document, pointer))?.props);
+  const roleSizesPt = {};
+  for (const key of Object.keys(typography.styles)) {
+    const size = effectiveFontSize(
+      { name: "paragraph" },
+      { themeStyle: key },
+      typography
+    );
+    if (size) roleSizesPt[key] = size.fontSizePt;
+  }
+  const scale = resolved.theme.typography?.scale?.[designCanvas2("docx", resolved.theme.page?.size)];
+  const typeScalePt = [
+    .../* @__PURE__ */ new Set([
+      ...Object.values(roleSizesPt),
+      ...["heading", "body", "mono", "light"].flatMap((role) => {
+        const size = resolveFontSize(resolved.theme, role);
+        return size === void 0 ? [] : [size];
+      }),
+      ...scale ? typeScaleSizes(scale) : []
+    ])
+  ].sort((a, b) => a - b);
   addFact({
     id: "docx:theme",
     kind: "docx/theme",
     path: "/props",
     themeName: context.themeName,
     paletteHexes,
+    typeScalePt,
+    roleSizesPt,
     // `heading` and `body` only. A theme also names `mono` and `light`, but
     // those paint nothing until a component asks for them — counting an
     // unused `Courier New` against a document's family budget would flag a
@@ -12937,6 +13129,15 @@ function prepareDocxQualityDocument(document, options = {}) {
     if (node.name === "table") {
       const fact = tableFact(props, path4, page.availableWidthTwips);
       if (fact) addFact(fact);
+      for (const size of tableTextSizeFacts(
+        props,
+        authoredPropsAt(path4),
+        path4,
+        typography,
+        page
+      )) {
+        addFact({ ...size, generated: authoredPath(size.path) !== size.path });
+      }
       const design = tableDesignFact(
         props,
         path4,
@@ -12995,6 +13196,10 @@ function prepareDocxQualityDocument(document, options = {}) {
     if (node.name === "paragraph" || node.name === "heading") {
       const fact = lineBoxFact(node, props, path4, typography, context.document);
       if (fact) addFact(fact);
+      if (typeof props.text === "string" && props.text.trim() !== "") {
+        const fact2 = textSizeFact(node, props, path4, typography);
+        if (fact2) addFact({ ...fact2, generated: authoredPath(path4) !== path4 });
+      }
     }
     if (node.name === "image" || node.name === "visual") {
       for (const fact of svgTextFacts(props, path4)) addFact(fact);
@@ -13050,6 +13255,17 @@ function prepareDocxQualityDocument(document, options = {}) {
     }
   };
 }
+function slotIsFilled(value) {
+  if (typeof value === "string") return value.trim() !== "";
+  return value !== void 0 && value !== null && value !== false && (!Array.isArray(value) || value.length > 0);
+}
+function partPresent(part) {
+  return Array.isArray(part) && part.length > 0;
+}
+var PAGE_FIELD = /\{(PAGE|PAGE_NUMBER|TOTAL_PAGES|NUMPAGES)\}/;
+function hasPageField(part) {
+  return Array.isArray(part) && PAGE_FIELD.test(JSON.stringify(part));
+}
 
 // src/core/generateFromIr.ts
 var UncompiledComponentError = class extends Error {
@@ -13556,6 +13772,7 @@ function numberParameter(parameters, name, fallback) {
 }
 var docxTableWidthRule = {
   id: "docx/table-width",
+  description: "Explicit column widths that sum past the usable width of their section.",
   code: QUALITY_CODES.TABLE_WIDTH_OVERFLOW,
   category: "integrity",
   defaultSeverity: "warning",
@@ -13603,6 +13820,7 @@ var docxTableWidthRule = {
 };
 var docxHeadingHierarchyRule = {
   id: "docx/heading-hierarchy",
+  description: "A heading that skips a level and breaks the outline.",
   code: QUALITY_CODES.HEADING_SKIP,
   category: "hierarchy",
   defaultSeverity: "info",
@@ -13646,6 +13864,7 @@ function frameTextFacts(facts) {
 }
 var docxTextFitRule = {
   id: "docx/text-fit",
+  description: "A word too wide for its floating frame, or a frame whose wrapped text runs off the sheet.",
   code: QUALITY_CODES.TEXT_OVERFLOW,
   category: "integrity",
   defaultSeverity: "warning",
@@ -13719,6 +13938,7 @@ var docxTextFitRule = {
 var FRAME_COLLISION_MIN_WIDTH_TWIPS = 240;
 var docxFrameCollisionRule = {
   id: "docx/frame-collision",
+  description: "Two page-anchored frames whose estimated text lands on the same region of a page.",
   code: QUALITY_CODES.FRAME_COLLISION,
   category: "integrity",
   defaultSeverity: "warning",
@@ -13815,6 +14035,7 @@ var docxFrameCollisionRule = {
 };
 var docxSvgTextBoundsRule = {
   id: "docx/svg-text-bounds",
+  description: "A text baseline outside an inline SVG\u2019s viewBox, so the words are never painted.",
   code: QUALITY_CODES.SVG_TEXT_CLIPPED,
   category: "integrity",
   defaultSeverity: "warning",
@@ -13850,6 +14071,7 @@ function tenths(value) {
 }
 var docxLineBoxRule = {
   id: "docx/line-box",
+  description: "An `exactly` line box shorter than the capitals it has to hold.",
   code: QUALITY_CODES.LINE_BOX_COLLAPSE,
   category: "legibility",
   defaultSeverity: "warning",
@@ -13903,6 +14125,7 @@ var docxLineBoxRule = {
 };
 var docxPlaceholderRule = {
   id: "docx/placeholder-text",
+  description: "An unfilled scaffold slot, or leftover filler copy.",
   code: QUALITY_CODES.PLACEHOLDER_TEXT,
   category: "integrity",
   defaultSeverity: "warning",
@@ -13921,6 +14144,7 @@ var docxPlaceholderRule = {
 };
 var docxSlotBudgetRule = {
   id: "docx/slot-budget",
+  description: "A block slot holding more words than its budget allows \u2014 a takeaway past the word count the block sets.",
   code: QUALITY_CODES.SLOT_BUDGET,
   category: "composition",
   defaultSeverity: "warning",
@@ -13944,6 +14168,7 @@ var docxSlotBudgetRule = {
 var DEFAULT_MAX_FONT_FAMILIES = 3;
 var docxFontCountRule = {
   id: "docx/font-count",
+  description: "Distinct font families the document can paint.",
   code: QUALITY_CODES.FONT_COUNT,
   category: "brand",
   defaultSeverity: "warning",
@@ -13980,6 +14205,7 @@ var docxFontCountRule = {
 };
 var docxPaletteRule = {
   id: "docx/palette-adherence",
+  description: "A literal colour the resolved theme does not define.",
   code: QUALITY_CODES.OFF_PALETTE,
   category: "brand",
   defaultSeverity: "info",
@@ -14005,6 +14231,7 @@ var docxPaletteRule = {
 var DEFAULT_MAX_TABLE_ROWS_PER_PAGE = 25;
 var docxChartRule = {
   id: "docx/chart-design",
+  description: "What a chart claims about its numbers: the comparison, the palette, the unit and the caption.",
   code: QUALITY_CODES.CHART_OVERLOADED,
   category: "information-design",
   defaultSeverity: "warning",
@@ -14046,6 +14273,7 @@ function seriesColorFix(fact) {
 }
 var docxTableDesignRule = {
   id: "docx/table-design",
+  description: "How a table lays its numbers out: alignment, rounding, rules and length.",
   code: QUALITY_CODES.TABLE_NUMERIC_ALIGN,
   category: "information-design",
   defaultSeverity: "warning",
@@ -14097,6 +14325,233 @@ function alignColumnRight(column) {
   }
   return operations;
 }
+function stringListParameter(parameters, name) {
+  const value = parameters[name];
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+var docxRequiredChromeRule = {
+  id: "docx/required-chrome",
+  description: "A block slot with a role a profile or policy requires \u2014 a takeaway, a source \u2014 left empty. Off until one names roles.",
+  code: QUALITY_CODES.CHROME_MISSING,
+  category: "consistency",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultParameters: { required: [] },
+  evaluate: ({ facts, configuration, profile }) => {
+    const required = stringListParameter(configuration.parameters, "required");
+    if (required.length === 0) return [];
+    return facts.filter(
+      (fact) => fact.kind === "docx/chrome-slot"
+    ).filter((fact) => required.includes(fact.role) && !fact.present).map((fact) => ({
+      path: fact.path,
+      relatedPaths: [fact.invocation],
+      message: `${fact.block} states no ${fact.role} in its "${fact.slot}" slot; the ${profile?.id ?? "selected"} profile expects one on every ${fact.block}.`,
+      suggestion: `Fill the "${fact.slot}" slot. The theme already styles it.`,
+      context: { block: fact.block, slot: fact.slot, role: fact.role }
+    }));
+  }
+};
+var SECTION_CHROME_PARTS = ["header", "footer", "pageNumber"];
+var docxRunningHeadRule = {
+  id: "docx/running-head",
+  description: "A body section without the running head a profile or policy expects. Off until one names parts.",
+  code: QUALITY_CODES.CHROME_MISSING,
+  category: "consistency",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultParameters: { required: [], fromSection: 1 },
+  evaluate: ({ facts, configuration, profile }) => {
+    const required = stringListParameter(
+      configuration.parameters,
+      "required"
+    ).filter(
+      (part) => SECTION_CHROME_PARTS.includes(part)
+    );
+    if (required.length === 0) return [];
+    const from = numberParameter(configuration.parameters, "fromSection", 1);
+    return facts.filter(
+      (fact) => fact.kind === "docx/section-chrome" && fact.index >= from
+    ).flatMap((fact) => {
+      const missing = required.filter((part) => !fact[part]);
+      if (missing.length === 0) return [];
+      const parts = missing.map((part) => part === "pageNumber" ? "page-number field" : part).join(", ");
+      return [
+        {
+          path: fact.path,
+          message: `Section ${fact.index + 1} carries no ${parts}; the ${profile?.id ?? "selected"} profile expects a running head on every section after the cover.`,
+          suggestion: "Invoke a running-head block at the top of the first body section: its section effect fills every later section with the tracker and n / N.",
+          context: { section: fact.index, missing }
+        }
+      ];
+    });
+  }
+};
+var SIZE_TOLERANCE_PT = 0.25;
+function themeFact(facts) {
+  return facts.find(
+    (fact) => fact.kind === "docx/theme"
+  );
+}
+function textSizeFacts(facts) {
+  return facts.filter(
+    (fact) => fact.kind === "docx/text-size"
+  );
+}
+function roleDriftFacts(facts, theme) {
+  const byRole = /* @__PURE__ */ new Map();
+  for (const fact of textSizeFacts(facts)) {
+    byRole.set(fact.role, [...byRole.get(fact.role) ?? [], fact]);
+  }
+  const drifting = /* @__PURE__ */ new Map();
+  for (const [role, members] of byRole) {
+    const sizes = [...new Set(members.map((fact) => fact.fontSizePt))].sort(
+      (a, b) => a - b
+    );
+    if (sizes.length < 2) continue;
+    const expected = theme?.roleSizesPt[role];
+    if (expected === void 0) continue;
+    for (const fact of members) {
+      if (fact.sizePath !== void 0 && !fact.generated && Math.abs(fact.fontSizePt - expected) > SIZE_TOLERANCE_PT)
+        drifting.set(fact, { expected, sizes });
+    }
+  }
+  return drifting;
+}
+function nearestSize(size, scale) {
+  let best;
+  for (const candidate of scale) {
+    if (best === void 0 || Math.abs(candidate - size) < Math.abs(best - size))
+      best = candidate;
+  }
+  return best;
+}
+var docxTypeScaleRule = {
+  id: "docx/type-scale",
+  description: "An authored size the theme never paints: not a style, not a font role, not a step of its scale. Off until a profile or policy enables it.",
+  code: QUALITY_CODES.TYPE_OFF_SCALE,
+  category: "consistency",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultEnabled: false,
+  evaluate: ({ facts }) => {
+    const theme = themeFact(facts);
+    const scale = theme?.typeScalePt ?? [];
+    if (scale.length === 0) return [];
+    const drifting = roleDriftFacts(facts, theme);
+    const offScale = textSizeFacts(facts).filter(
+      (fact) => fact.sizePath !== void 0 && !fact.generated && !drifting.has(fact) && !scale.some(
+        (size) => Math.abs(size - fact.fontSizePt) <= SIZE_TOLERANCE_PT
+      )
+    );
+    const groups = /* @__PURE__ */ new Map();
+    for (const fact of offScale) {
+      const key = `${fact.role}@${fact.fontSizePt}`;
+      groups.set(key, [...groups.get(key) ?? [], fact]);
+    }
+    return [...groups.values()].map((members) => {
+      const [first] = members;
+      const nearest = nearestSize(first.fontSizePt, scale);
+      const sizePaths = members.map((fact) => fact.sizePath);
+      const count = members.length === 1 ? "" : ` (${members.length} places, patched together)`;
+      return {
+        path: sizePaths[0],
+        ...sizePaths.length > 1 && { relatedPaths: sizePaths.slice(1) },
+        message: `${first.fontSizePt}pt is not a size the ${theme.themeName} theme paints; the nearest on its scale is ${nearest}pt${count}.`,
+        suggestion: `Use ${nearest}pt, or drop the size and let the "${first.role}" style set it.`,
+        context: { role: first.role, scale, paths: sizePaths },
+        evidence: {
+          actual: first.fontSizePt,
+          expected: nearest,
+          unit: "pt",
+          values: { source: "theme" }
+        },
+        fixes: sizePaths.map((path4) => ({
+          op: "replace",
+          path: path4,
+          value: nearest
+        }))
+      };
+    });
+  }
+};
+var docxSizeCountRule = {
+  id: "docx/size-count",
+  description: "More distinct text sizes than maximumSizes allows, blocks included. Off until a profile or policy enables it.",
+  code: QUALITY_CODES.TYPE_SIZE_COUNT,
+  category: "consistency",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultEnabled: false,
+  defaultParameters: { maximumSizes: 8 },
+  evaluate: ({ facts, configuration, profile }) => {
+    const maximum = numberParameter(
+      configuration.parameters,
+      "maximumSizes",
+      8
+    );
+    const firstPathBySize = /* @__PURE__ */ new Map();
+    for (const fact of textSizeFacts(facts)) {
+      const size = Math.round(fact.fontSizePt * 4) / 4;
+      if (!firstPathBySize.has(size)) firstPathBySize.set(size, fact.path);
+    }
+    if (firstPathBySize.size <= maximum) return [];
+    const sizes = [...firstPathBySize.keys()].sort((a, b) => a - b);
+    return [
+      {
+        path: themeFact(facts)?.path ?? "/props",
+        relatedPaths: sizes.map((size) => firstPathBySize.get(size)),
+        message: `The document paints ${sizes.length} distinct text sizes (${sizes.join(", ")}pt); the ${profile?.id ?? "selected"} profile allows ${maximum}.`,
+        suggestion: "Keep to the theme styles \u2014 title, headings, body, label, source \u2014 and drop the ad-hoc sizes.",
+        context: { sizes, maximum },
+        evidence: {
+          actual: sizes.length,
+          expected: maximum,
+          values: { source: "profile" }
+        }
+      }
+    ];
+  }
+};
+var docxRoleDriftRule = {
+  id: "docx/role-drift",
+  description: "One heading level, table role or paragraph style painted at two sizes; the theme size is the fix. Off until a profile or policy enables it.",
+  code: QUALITY_CODES.TYPE_ROLE_DRIFT,
+  category: "consistency",
+  defaultSeverity: "warning",
+  defaultCertainty: "deterministic",
+  formats: ["docx"],
+  defaultEnabled: false,
+  evaluate: ({ facts }) => {
+    const theme = themeFact(facts);
+    const findings = [];
+    for (const [fact, { expected, sizes }] of roleDriftFacts(facts, theme)) {
+      const keeper = textSizeFacts(facts).find(
+        (member) => member.role === fact.role && Math.abs(member.fontSizePt - expected) <= SIZE_TOLERANCE_PT
+      );
+      const others = sizes.filter((size) => size !== fact.fontSizePt);
+      const sizePath = fact.sizePath;
+      findings.push({
+        path: sizePath,
+        ...keeper && { relatedPaths: [keeper.path] },
+        message: `"${fact.role}" is painted at ${fact.fontSizePt}pt here and at ${others.join("pt, ")}pt elsewhere; the theme sets it at ${expected}pt.`,
+        suggestion: `Drop the size so "${fact.role}" paints at the theme's ${expected}pt.`,
+        context: { role: fact.role, sizes },
+        evidence: {
+          actual: fact.fontSizePt,
+          expected,
+          unit: "pt",
+          values: { role: fact.role, source: "theme" }
+        },
+        fixes: [{ op: "replace", path: sizePath, value: expected }]
+      });
+    }
+    return findings;
+  }
+};
 var DOCX_QUALITY_RULES = {
   id: "docx/default",
   rules: [
@@ -14111,10 +14566,35 @@ var DOCX_QUALITY_RULES = {
     docxChartRule,
     docxTableDesignRule,
     docxFontCountRule,
-    docxPaletteRule
+    docxPaletteRule,
+    docxRequiredChromeRule,
+    docxRunningHeadRule,
+    docxTypeScaleRule,
+    docxSizeCountRule,
+    docxRoleDriftRule
   ]
 };
 var DOCX_QUALITY_PROFILES = {
+  "client-report": {
+    id: "client-report",
+    formats: ["docx"],
+    description: "Client or public-administration report: a running head with page numbers on every section after the cover, a takeaway and a source wherever a block declares them, no heading skipped, and every size on the theme scale with at most eight in play.",
+    rules: {
+      "docx/required-chrome": {
+        parameters: { required: ["takeaway", "source"] }
+      },
+      "docx/running-head": {
+        parameters: {
+          required: ["header", "footer", "pageNumber"],
+          fromSection: 1
+        }
+      },
+      "docx/heading-hierarchy": { severity: "warning" },
+      "docx/type-scale": { enabled: true },
+      "docx/size-count": { enabled: true, parameters: { maximumSizes: 8 } },
+      "docx/role-drift": { enabled: true }
+    }
+  },
   "executive-report": {
     id: "executive-report",
     formats: ["docx"],
@@ -14136,6 +14616,11 @@ var DOCX_QUALITY_PROFILES = {
 };
 var DOCX_DEFAULT_QUALITY_PROFILE = DOCX_QUALITY_PROFILES["technical-report"];
 var DOCX_PROFILES_BY_ID = DOCX_QUALITY_PROFILES;
+function declaredDocxQualityProfile(document) {
+  const props = document?.props;
+  const id = props?.qualityProfile;
+  return typeof id === "string" && Object.prototype.hasOwnProperty.call(DOCX_PROFILES_BY_ID, id) ? DOCX_PROFILES_BY_ID[id] : void 0;
+}
 function resolveDocxQualityProfile(requested) {
   if (!requested) return void 0;
   const registered = DOCX_PROFILES_BY_ID[requested.id];
@@ -14183,7 +14668,7 @@ function analyzeDocxQuality(doc, options = {}) {
     );
   }
   return docxQualityEngine.analyzeSync(prepared, {
-    profile: resolveDocxQualityProfile(options.profile) ?? DOCX_DEFAULT_QUALITY_PROFILE,
+    profile: resolveDocxQualityProfile(options.profile) ?? declaredDocxQualityProfile(doc) ?? DOCX_DEFAULT_QUALITY_PROFILE,
     policy: options.policy
   });
 }
@@ -14293,17 +14778,655 @@ function formatWarningsText(warnings) {
 
 // src/index.ts
 init_styles();
+
+// src/blueprints/index.ts
+import {
+  blockDependencies,
+  validateBlueprint
+} from "@json-to-office/shared";
+import { collectPlaceholders as collectPlaceholders2 } from "@json-to-office/quality";
+import { existsSync, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/templates/blueprints/client-report.docx.blueprint.json
+var client_report_docx_blueprint_default = {
+  id: "client-report",
+  format: "docx",
+  title: "Client report",
+  description: "A report for a client or a public administration: a cover, key takeaways, KPIs, chart-first sections with a takeaway and a source under every figure, data tables, notes and sources, under a running head that tracks the section and numbers the pages.",
+  whenToUse: "A periodic or one-off report to a client, a board or a public body that reads for the conclusion first and checks the evidence second. Not for a memo or a technical specification.",
+  theme: "consulting",
+  profile: "client-report",
+  definitions: "client-report-blocks.docx.json",
+  numbering: "sections",
+  toc: false,
+  variants: {
+    "data-heavy": {
+      description: "Evidence-led: a KPI row under the takeaways, a chart with its takeaway in the second section, a data table with a note in the third, next steps last.",
+      whenToUse: "The brief comes with numbers: performance, finance, operations, anything the reader will check against a figure.",
+      pages: {
+        min: 4,
+        max: 8
+      },
+      metadata: {
+        title: "{{Title: as on the cover}}",
+        author: "{{Author or team}}",
+        company: "{{Client name}}",
+        date: "{{Month YYYY}}"
+      },
+      children: [
+        {
+          name: "section",
+          children: [
+            {
+              name: "block",
+              props: {
+                ref: "cover",
+                slots: {
+                  title: "{{Title: the report's conclusion in one sentence}}",
+                  subtitle: "{{Subtitle: what the report answers, for whom}}",
+                  client: "{{Client name}}",
+                  date: "{{Month YYYY}}",
+                  confidentiality: "{{Confidentiality: Confidential, or For internal use}}"
+                }
+              }
+            }
+          ]
+        },
+        {
+          name: "section",
+          children: [
+            {
+              name: "block",
+              props: {
+                ref: "running-head",
+                slots: {
+                  confidentiality: "{{Confidentiality: as on the cover}}",
+                  date: "{{Month YYYY}}"
+                }
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "section-opener",
+                slots: {
+                  number: "01",
+                  title: "{{Section title: the finding, as a statement}}",
+                  tracker: "{{Tracker: one or two words}}"
+                }
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "key-takeaways",
+                slots: {
+                  items: [
+                    "{{Takeaway 1: one claim, one sentence, with its number}}",
+                    "{{Takeaway 2: one claim, one sentence, with its number}}",
+                    "{{Takeaway 3: the recommendation that follows}}"
+                  ]
+                }
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "kpi-row",
+                slots: {
+                  items: [
+                    {
+                      value: "{{0.0}}",
+                      label: "{{What it measures}}"
+                    },
+                    {
+                      value: "{{0.0}}",
+                      label: "{{What it measures}}"
+                    },
+                    {
+                      value: "{{0.0}}",
+                      label: "{{What it measures}}"
+                    }
+                  ],
+                  source: "{{Source: system or document, date}}"
+                }
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            }
+          ]
+        },
+        {
+          name: "section",
+          children: [
+            {
+              name: "block",
+              props: {
+                ref: "section-opener",
+                slots: {
+                  number: "02",
+                  title: "{{Section title: the finding, as a statement}}",
+                  tracker: "{{Tracker: one or two words}}"
+                }
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "chart-figure",
+                slots: {
+                  chart: {
+                    name: "highcharts",
+                    props: {
+                      width: "100%",
+                      options: {
+                        chart: {
+                          type: "column",
+                          width: 900,
+                          height: 460
+                        },
+                        title: {
+                          text: null
+                        },
+                        xAxis: {
+                          categories: [
+                            "{{Period 1}}",
+                            "{{Period 2}}",
+                            "{{Period 3}}"
+                          ]
+                        },
+                        yAxis: {
+                          title: {
+                            text: "{{Measure (unit)}}"
+                          }
+                        },
+                        series: [
+                          {
+                            name: "{{Series name}}",
+                            data: [0, 0, 0]
+                          }
+                        ]
+                      }
+                    }
+                  },
+                  caption: "{{Caption: what the chart shows, as a statement}}",
+                  takeaway: "{{Takeaway: the one sentence the reader should keep}}",
+                  source: "{{Source: system or document, date}}"
+                }
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            }
+          ]
+        },
+        {
+          name: "section",
+          children: [
+            {
+              name: "block",
+              props: {
+                ref: "section-opener",
+                slots: {
+                  number: "03",
+                  title: "{{Section title: the finding, as a statement}}",
+                  tracker: "{{Tracker: one or two words}}"
+                }
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "data-table",
+                slots: {
+                  title: "{{Table title: what it compares, and the period}}",
+                  labelHeader: "{{Row label}}",
+                  labels: ["{{Row 1}}", "{{Row 2}}", "{{Row 3}}"],
+                  columns: [
+                    {
+                      header: "{{Measure (unit)}}",
+                      cells: ["{{0.0}}", "{{0.0}}", "{{0.0}}"]
+                    },
+                    {
+                      header: "{{Change}}",
+                      cells: ["{{0.0}}", "{{0.0}}", "{{0.0}}"]
+                    }
+                  ],
+                  source: "{{Source: system or document, date}}"
+                }
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "callout",
+                slots: {
+                  label: "{{Note label}}",
+                  text: "{{Note: a caveat about the numbers, a definition or the method}}"
+                }
+              }
+            }
+          ]
+        },
+        {
+          name: "section",
+          children: [
+            {
+              name: "block",
+              props: {
+                ref: "section-opener",
+                slots: {
+                  number: "04",
+                  title: "{{Section title: the finding, as a statement}}",
+                  tracker: "{{Tracker: one or two words}}"
+                }
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "footnotes"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    narrative: {
+      description: "Argument-led: takeaways, then three sections of prose with one KPI row and one note as evidence, next steps last.",
+      whenToUse: "The brief is a position, an assessment or a recommendation with few numbers; the reader follows an argument.",
+      pages: {
+        min: 3,
+        max: 6
+      },
+      metadata: {
+        title: "{{Title: as on the cover}}",
+        author: "{{Author or team}}",
+        company: "{{Client name}}",
+        date: "{{Month YYYY}}"
+      },
+      children: [
+        {
+          name: "section",
+          children: [
+            {
+              name: "block",
+              props: {
+                ref: "cover",
+                slots: {
+                  title: "{{Title: the report's conclusion in one sentence}}",
+                  subtitle: "{{Subtitle: what the report answers, for whom}}",
+                  client: "{{Client name}}",
+                  date: "{{Month YYYY}}",
+                  confidentiality: "{{Confidentiality: Confidential, or For internal use}}"
+                }
+              }
+            }
+          ]
+        },
+        {
+          name: "section",
+          children: [
+            {
+              name: "block",
+              props: {
+                ref: "running-head",
+                slots: {
+                  confidentiality: "{{Confidentiality: as on the cover}}",
+                  date: "{{Month YYYY}}"
+                }
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "section-opener",
+                slots: {
+                  number: "01",
+                  title: "{{Section title: the finding, as a statement}}",
+                  tracker: "{{Tracker: one or two words}}"
+                }
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "key-takeaways",
+                slots: {
+                  items: [
+                    "{{Takeaway 1: one claim, one sentence, with its number}}",
+                    "{{Takeaway 2: one claim, one sentence, with its number}}",
+                    "{{Takeaway 3: the recommendation that follows}}"
+                  ]
+                }
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            }
+          ]
+        },
+        {
+          name: "section",
+          children: [
+            {
+              name: "block",
+              props: {
+                ref: "section-opener",
+                slots: {
+                  number: "02",
+                  title: "{{Section title: the finding, as a statement}}",
+                  tracker: "{{Tracker: one or two words}}"
+                }
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "callout",
+                slots: {
+                  label: "{{Note label}}",
+                  text: "{{Note: a caveat about the numbers, a definition or the method}}"
+                }
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            }
+          ]
+        },
+        {
+          name: "section",
+          children: [
+            {
+              name: "block",
+              props: {
+                ref: "section-opener",
+                slots: {
+                  number: "03",
+                  title: "{{Section title: the finding, as a statement}}",
+                  tracker: "{{Tracker: one or two words}}"
+                }
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "kpi-row",
+                slots: {
+                  items: [
+                    {
+                      value: "{{0.0}}",
+                      label: "{{What it measures}}"
+                    },
+                    {
+                      value: "{{0.0}}",
+                      label: "{{What it measures}}"
+                    },
+                    {
+                      value: "{{0.0}}",
+                      label: "{{What it measures}}"
+                    }
+                  ],
+                  source: "{{Source: system or document, date}}"
+                }
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            }
+          ]
+        },
+        {
+          name: "section",
+          children: [
+            {
+              name: "block",
+              props: {
+                ref: "section-opener",
+                slots: {
+                  number: "04",
+                  title: "{{Section title: the finding, as a statement}}",
+                  tracker: "{{Tracker: one or two words}}"
+                }
+              }
+            },
+            {
+              name: "paragraph",
+              props: {
+                text: "{{Body: two or three short paragraphs of evidence for the section title, each opening with its claim}}"
+              }
+            },
+            {
+              name: "block",
+              props: {
+                ref: "footnotes"
+              }
+            }
+          ]
+        }
+      ]
+    }
+  }
+};
+
+// src/blueprints/index.ts
+function register(...candidates) {
+  const registry2 = {};
+  for (const candidate of candidates) {
+    const issues = validateBlueprint(candidate);
+    if (issues.length > 0)
+      throw new Error(
+        `Invalid bundled blueprint: ${issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`
+      );
+    const blueprint = candidate;
+    if (blueprint.format !== "docx")
+      throw new Error(`Blueprint ${blueprint.id} is not a DOCX blueprint.`);
+    if (registry2[blueprint.id])
+      throw new Error(
+        `Two bundled blueprints share the id "${blueprint.id}"; the later one would silently replace the earlier.`
+      );
+    registry2[blueprint.id] = blueprint;
+  }
+  return registry2;
+}
+function scanned(known) {
+  let here;
+  try {
+    here = dirname2(fileURLToPath2(import.meta.url));
+  } catch {
+    return [];
+  }
+  const directory = [
+    join2(here, "../templates/blueprints"),
+    join2(here, "templates/blueprints")
+  ].find((path4) => existsSync(path4));
+  if (!directory) return [];
+  return readdirSync(directory).filter((file) => file.endsWith(".docx.blueprint.json")).map((file) => JSON.parse(readFileSync2(join2(directory, file), "utf8"))).filter((candidate) => {
+    const id = candidate?.id;
+    return !(typeof id === "string" && id in known);
+  });
+}
+var bundled = register(client_report_docx_blueprint_default);
+var DOCX_BLUEPRINTS = {
+  ...bundled,
+  ...register(...scanned(bundled))
+};
+function docxBlueprint(id) {
+  return DOCX_BLUEPRINTS[id];
+}
+var MARKER = /^\{\{\s*([\s\S]*?)\s*\}\}$/;
+function instantiateDocxBlueprint(blueprint, options) {
+  if (blueprint.format !== "docx")
+    throw new Error(
+      `Blueprint ${blueprint.id} is a ${blueprint.format} blueprint; this instantiates DOCX ones.`
+    );
+  const variantId = options.variant ?? Object.keys(blueprint.variants)[0];
+  const variant = blueprint.variants[variantId];
+  if (!variant)
+    throw new Error(
+      `Blueprint ${blueprint.id} has no variant "${variantId}"; it has ${Object.keys(
+        blueprint.variants
+      ).join(", ")}.`
+    );
+  const children = structuredClone(variant.children);
+  const blocks = definitionsFor(children, options.definitions, blueprint);
+  const document = {
+    name: "docx",
+    props: {
+      theme: options.theme ?? blueprint.theme,
+      qualityProfile: blueprint.profile,
+      ...Object.keys(blocks).length > 0 && { blocks },
+      metadata: { ...variant.metadata, ...options.metadata }
+    },
+    children
+  };
+  return { document, fillMap: fillMap(document, blocks), variant: variantId };
+}
+function definitionsFor(children, available, blueprint) {
+  const refs = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (Array.isArray(node)) return node.forEach(visit);
+    if (!node || typeof node !== "object") return;
+    const record = node;
+    const props = record.props;
+    if (record.name === "block" && typeof props?.ref === "string")
+      refs.add(props.ref);
+    Object.values(record).forEach(visit);
+  };
+  visit(children);
+  const result = {};
+  for (const ref of refs) {
+    if (!available[ref])
+      throw new Error(
+        `Blueprint ${blueprint.id} invokes "${ref}", which ${blueprint.definitions} does not define.`
+      );
+    for (const name of [...blockDependencies(available, ref), ref])
+      result[name] ??= structuredClone(available[name]);
+  }
+  return result;
+}
+function fillMap(document, blocks) {
+  return collectPlaceholders2(document).filter((occurrence) => occurrence.match.kind === "scaffold-marker").map((occurrence) => {
+    const guidance = occurrence.text.match(MARKER)?.[1] ?? occurrence.text;
+    const base = { path: occurrence.path, marker: occurrence.text, guidance };
+    if (occurrence.path.startsWith("/props/metadata/"))
+      return { ...base, kind: "metadata" };
+    const slot = slotAt(document, occurrence.path, blocks);
+    return slot ? { ...base, kind: "slot", ...slot } : { ...base, kind: "text" };
+  });
+}
+function slotAt(document, pointer, blocks) {
+  const at = pointer.lastIndexOf("/props/slots/");
+  if (at < 0) return void 0;
+  const invocation = valueAt(document, pointer.slice(0, at));
+  const ref = invocation?.props?.ref;
+  if (typeof ref !== "string" || !blocks[ref]) return void 0;
+  const segments = pointer.slice(at + "/props/slots/".length).split("/").map(unescape);
+  let slot = blocks[ref].slots[segments[0]];
+  const names = [segments[0]];
+  for (const segment of segments.slice(1)) {
+    if (!slot) break;
+    if (slot.type === "array" && /^\d+$/.test(segment)) slot = slot.items;
+    else if (slot.type === "object") {
+      slot = slot.properties?.[segment];
+      names.push(segment);
+    } else if (slot.type === "component")
+      break;
+    else slot = void 0;
+  }
+  if (!slot) return void 0;
+  return {
+    block: ref,
+    slot: names.join("."),
+    type: slot.type,
+    ...slot.maxWords !== void 0 && { maxWords: slot.maxWords },
+    ...slot.maxLength !== void 0 && { maxLength: slot.maxLength },
+    ...slot.oneLine !== void 0 && { oneLine: slot.oneLine },
+    ...slot.required !== void 0 && { required: slot.required }
+  };
+}
+function unescape(segment) {
+  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function valueAt(root, pointer) {
+  if (pointer === "") return root;
+  let current = root;
+  for (const segment of pointer.split("/").slice(1).map(unescape)) {
+    if (Array.isArray(current)) current = current[Number(segment)];
+    else if (current && typeof current === "object")
+      current = current[segment];
+    else return void 0;
+  }
+  return current;
+}
+
+// src/index.ts
 init_json();
 
 // src/templates/documents/index.ts
 import fs4 from "fs";
 import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var _dirname = null;
 function getDirname() {
   if (_dirname === null) {
     try {
-      _dirname = path2.dirname(fileURLToPath2(import.meta.url));
+      _dirname = path2.dirname(fileURLToPath3(import.meta.url));
     } catch {
       throw new Error(
         "Cannot resolve file paths in a bundled environment. Example loading from disk is not available."
@@ -15189,6 +16312,7 @@ export {
   ComponentValidationError2 as ComponentValidationError,
   DocumentGenerator as CoreDocumentGenerator,
   DEFAULT_DOCX_RENDERER_ID,
+  DOCX_BLUEPRINTS,
   DOCX_DEFAULT_QUALITY_PROFILE,
   DOCX_QUALITY_PROFILES,
   DOCX_QUALITY_RULES,
@@ -15205,7 +16329,9 @@ export {
   createDocumentGenerator,
   createMinimalTheme,
   createVersion,
+  declaredDocxQualityProfile,
   devportalTheme,
+  docxBlueprint,
   docxQualityEngine,
   docxRendererIds,
   docxRendererStatuses,
@@ -15230,6 +16356,7 @@ export {
   getExampleNames,
   getVisualPrepassStats,
   hasNodeBuiltins,
+  instantiateDocxBlueprint,
   isColumnsComponent,
   isDocxRendererId,
   isHeadingComponent,