@openpresentation/opf 0.26.2 → 0.26.4

package/dist/source.js

@@ -1,10 +1,376 @@
-import { createLocator, parsePointer } from './chunk-LUQYSUXS.js';
-export { analyzeJsonSyntax, applyTextEdits } from './chunk-LUQYSUXS.js';
+import { readMarkdown, frontMatter, splitSegments, isOutline, NOTES, fenceStart, fenceClose, COMMENT, SLIDE_OPTION_KEYS, FENCE_KINDS } from './chunk-MN7DRK57.js';
+export { BLOCK_AS_VALUES, BLOCK_OPTION_KEYS, FENCE_ATTRIBUTES, FENCE_KINDS, LINE_KEYWORDS, METRIC_KEYS, SLIDE_OPTION_KEYS, SPAN_FLAGS, SPAN_VALUES } from './chunk-MN7DRK57.js';
+import './chunk-O6BY3AU2.js';
+import { splitLines } from './chunk-QAEBYDKY.js';
+import './chunk-6NBTZYYD.js';
+import { rememberByText, createLocator, parsePointer } from './chunk-XFOOKVRI.js';
+export { analyzeJsonSyntax, applyTextEdits } from './chunk-XFOOKVRI.js';
 import './chunk-XRMV2GMB.js';
-import './chunk-N6CNJCIF.js';
+import './chunk-F4HFDP6I.js';
 import { findNodeAtOffset, getNodePath, parseTree } from 'jsonc-parser';
+import { parseDocument, isMap, isSeq, isScalar, isAlias } from 'yaml';
 
+var read = rememberByText(readText);
+function readText(text) {
+  const bom = text.startsWith("\uFEFF") ? 1 : 0;
+  const body = bom ? text.slice(1) : text;
+  const document = parseDocument(body, { prettyErrors: false, uniqueKeys: false, merge: false, strict: false });
+  return { text: body, root: document.contents ?? null, shift: bom };
+}
+var isBlank = (char) => char === " " || char === "	" || char === "\n" || char === "\r";
+function endOf(text, node) {
+  let end = node.range[1];
+  const start = node.range[0];
+  while (end > start && isBlank(text[end - 1])) end--;
+  return end;
+}
+var startOf = (node) => node.range[0];
+var keyName = (key) => isScalar(key) ? String(key.value) : isAlias(key) ? void 0 : key !== null && typeof key === "object" && "toString" in key ? String(key.toString()) : void 0;
+var hasText = (text, node) => !!node && node.range[0] < endOf(text, node);
+var pairKey = (pair) => pair.key ?? null;
+var pairValue = (pair) => pair.value ?? null;
+function colonEnd(text, key) {
+  let at = key.range[1];
+  while (text[at] === " " || text[at] === "	") at++;
+  return text[at] === ":" ? at + 1 : key.range[1];
+}
+function member(node, segment) {
+  if (isMap(node)) {
+    const pair = node.items.find((item) => keyName(item.key) === segment);
+    return pair ? { pair, value: pairValue(pair) } : void 0;
+  }
+  if (isSeq(node)) {
+    if (!/^(?:0|[1-9][0-9]*)$/.test(segment)) return void 0;
+    const item = node.items[Number(segment)];
+    return item === void 0 ? void 0 : { value: item };
+  }
+  return void 0;
+}
+function openOf(text, value) {
+  const start = startOf(value);
+  if (isMap(value) && !value.flow) {
+    const first = value.items[0];
+    const key = first ? pairKey(first) : null;
+    if (key) return { offset: startOf(key), length: key.range[1] - startOf(key) };
+  }
+  return { offset: start, length: Math.min(1, endOf(text, value) - start) };
+}
+function locateYaml(text, segments, part) {
+  const { text: body, root, shift } = read(text);
+  if (!root || !hasText(body, root)) return void 0;
+  let value = root;
+  let pair;
+  let depth = 0;
+  for (const segment of segments) {
+    const next = value ? member(value, segment) : void 0;
+    if (!value || !next) break;
+    pair = next.pair;
+    value = next.value;
+    depth++;
+  }
+  const exact = depth === segments.length;
+  const key = pair ? pairKey(pair) : null;
+  const keySpan = key ? { offset: startOf(key), length: key.range[1] - startOf(key) } : void 0;
+  const keyAndColon = key ? { offset: startOf(key), length: colonEnd(body, key) - startOf(key) } : void 0;
+  const valueSpan = hasText(body, value) ? { offset: startOf(value), length: endOf(body, value) - startOf(value) } : void 0;
+  const choose = (wanted) => {
+    switch (wanted) {
+      case "value":
+        return valueSpan ?? keyAndColon;
+      case "open":
+        return hasText(body, value) ? openOf(body, value) : keyAndColon;
+      case "key":
+        return keySpan;
+      case "colon":
+        return keyAndColon;
+      case "entry":
+        return keySpan ? { offset: keySpan.offset, length: (valueSpan ? valueSpan.offset + valueSpan.length : (keyAndColon?.offset ?? 0) + (keyAndColon?.length ?? 0)) - keySpan.offset } : void 0;
+    }
+  };
+  const found = choose(part) ?? choose("value") ?? (depth === 0 ? { offset: startOf(root), length: endOf(body, root) - startOf(root) } : void 0);
+  return found ? { offset: found.offset + shift, length: found.length, exact } : void 0;
+}
+function pathAtYaml(text, offset) {
+  const { text: body, root, shift } = read(text);
+  const at = offset - shift;
+  const none = { path: [], part: "none" };
+  if (!root || !hasText(body, root) || at < startOf(root) || at > endOf(body, root)) return none;
+  const span = (node) => ({ offset: startOf(node) + shift, length: endOf(body, node) - startOf(node) });
+  const inside = (node) => hasText(body, node) && at >= startOf(node) && at <= endOf(body, node);
+  const walk = (node, path) => {
+    if (isMap(node)) {
+      for (const pair of node.items) {
+        const key = pairKey(pair);
+        const value = pairValue(pair);
+        const name = keyName(pair.key);
+        if (name === void 0) continue;
+        if (key && at >= startOf(key) && at <= key.range[1]) return { path: [...path, name], part: "key", range: span(key) };
+        if (inside(value)) return walk(value, [...path, name]);
+        if (key && at > key.range[1] && at <= (hasText(body, value) ? startOf(value) : colonEnd(body, key))) {
+          const end = hasText(body, value) ? startOf(value) : colonEnd(body, key);
+          return { path: [...path, name], part: "between", range: { offset: startOf(key) + shift, length: end - startOf(key) } };
+        }
+      }
+      return { path, part: "between", range: span(node) };
+    }
+    if (isSeq(node)) {
+      for (const [index, item] of node.items.entries()) if (inside(item)) return walk(item, [...path, String(index)]);
+      return { path, part: "between", range: span(node) };
+    }
+    return { path, part: "value", range: span(node) };
+  };
+  return walk(root, []);
+}
+
+// src/source-markdown.ts
+var BLANK = /^\s*$/;
+var readMarkdown2 = rememberByText((text) => readMarkdown(text));
+var scanMemo = rememberByText((text) => scanUncached(text));
+var isFenceKind = (word) => FENCE_KINDS.includes(word);
+function scanMarkdown(source2, options = {}) {
+  return options.split === void 0 ? scanMemo(source2) : scanUncached(source2, options);
+}
+function scanUncached(source2, options = {}) {
+  let lines = splitLines(source2);
+  if (lines[0]?.text.startsWith("\uFEFF")) lines = [{ ...lines[0], text: lines[0].text.slice(1), start: lines[0].start + 1 }, ...lines.slice(1)];
+  const scan = { slides: [], separators: [], comments: [], fences: [], notes: [] };
+  const matter = frontMatter(lines);
+  let body = lines;
+  if (matter === "unterminated") {
+    const first = lines[0];
+    scan.frontMatter = { from: first.start, to: source2.length, line: 1, yamlFrom: first.end, yamlTo: source2.length, closed: false };
+    body = lines.slice(1);
+  } else if (matter) {
+    const closing = lines[matter.end - 1];
+    scan.frontMatter = { from: lines[0].start, to: closing.end, line: 1, yamlFrom: matter.yaml.start, yamlTo: matter.yaml.end, closed: true };
+    body = lines.slice(matter.end);
+  }
+  const split = options.split ?? "auto";
+  const segments = splitSegments(body, split === "headings" || split === "auto" && isOutline(body) ? "headings" : "rules");
+  const inSegment = new Set(segments.flat());
+  for (const line of body) if (!inSegment.has(line) && !BLANK.test(line.text)) scan.separators.push(line.start);
+  let index = 0;
+  for (const segment of segments) {
+    const first = segment.find((line) => !BLANK.test(line.text));
+    if (!first) continue;
+    const last = [...segment].reverse().find((line) => !BLANK.test(line.text));
+    scan.slides.push({ index, from: first.start, to: last.end, line: first.no });
+    scanSegment(segment, index, scan);
+    index++;
+  }
+  return scan;
+}
+function scanSegment(lines, slide, scan) {
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const text = line.text;
+    if (BLANK.test(text)) {
+      i++;
+      continue;
+    }
+    if (NOTES.test(text)) {
+      scan.notes.push({ from: line.start, to: lines.at(-1).end, line: line.no, slide });
+      return;
+    }
+    const open = fenceStart(text);
+    if (open) {
+      const close = fenceClose(open.fence);
+      let end = i + 1;
+      while (end < lines.length && !close.test(lines[end].text)) end++;
+      const closed = end < lines.length;
+      const last = closed ? lines[end] : lines.at(-1);
+      const indent = /^ */.exec(text)[0].length;
+      const marker = open.fence;
+      const infoFrom = line.start + indent + marker.length + /^[ \t]*/.exec(text.slice(indent + marker.length))[0].length;
+      const word = /^[^\s{]*/.exec(open.info)[0];
+      const bodyLines = lines.slice(i + 1, closed ? end : lines.length);
+      scan.fences.push({
+        from: line.start,
+        to: last.end,
+        line: line.no,
+        marker,
+        info: open.info,
+        infoFrom,
+        infoTo: infoFrom + open.info.length,
+        word,
+        kind: isFenceKind(word) ? word : "code",
+        bodyFrom: bodyLines[0]?.start ?? line.end,
+        bodyTo: bodyLines.at(-1)?.end ?? line.end,
+        closed,
+        slide
+      });
+      i = closed ? end + 1 : lines.length;
+      continue;
+    }
+    if (COMMENT.test(text)) {
+      let end = i;
+      while (end < lines.length && !lines[end].text.includes("-->", end === i ? lines[end].text.indexOf("<!--") + 4 : 0)) end++;
+      const closed = end < lines.length;
+      const last = closed ? lines[end] : lines.at(-1);
+      const open2 = text.indexOf("<!--");
+      const innerFrom = line.start + open2 + 4;
+      const closeAt = closed ? last.start + last.text.indexOf("-->", end === i ? open2 + 4 : 0) : last.end;
+      const inner = source(lines, i, closed ? end : lines.length - 1).slice(open2 + 4);
+      const kind = /^\s*(slide|block)(?::|(?=\s*(?:-->|$)))/.exec(inner);
+      scan.comments.push({ from: line.start, to: closed ? closeAt + 3 : last.end, line: line.no, kind: kind?.[1] ?? "comment", innerFrom, innerTo: closeAt, closed, slide });
+      i = closed ? end + 1 : lines.length;
+      continue;
+    }
+    i++;
+  }
+}
+function source(lines, first, last) {
+  return lines.slice(first, last + 1).map((line) => line.text).join(" ");
+}
+var segmentsOfPointer = (path) => path.map((segment) => `/${segment.replaceAll("~", "~0").replaceAll("/", "~1")}`).join("");
+var SLIDE_OPTIONS = new Set(SLIDE_OPTION_KEYS);
+var OPTIONS_COMMENT = /^\s*<!--/;
+function firstLine(text, range) {
+  const end = text.slice(range.start, range.end).search(/[\r\n]/);
+  return { offset: range.start, length: end < 0 ? range.end - range.start : end };
+}
+function optionToken(text, comment, key, nth = 0) {
+  const inner = text.slice(comment.start, comment.end);
+  const open = inner.indexOf("<!--");
+  const colon = inner.indexOf(":", open);
+  const from = colon < 0 ? open + 4 : colon + 1;
+  const pattern = /(?:^|[\s,])([A-Za-z][\w-]*)(=("(?:[^"\\]|\\.)*"|[^\s,"]+))?/g;
+  const tail = inner.slice(from);
+  let seen = 0;
+  for (const match of tail.matchAll(pattern)) {
+    if (match[1] !== key) continue;
+    if (seen++ !== nth) continue;
+    const keyStart = comment.start + from + match.index + match[0].indexOf(match[1]);
+    const keySpan = { offset: keyStart, length: key.length };
+    const value = match[3] === void 0 ? void 0 : { offset: keyStart + key.length + 1, length: match[3].length };
+    return { key: keySpan, ...value ? { value } : {}, entry: { offset: keyStart, length: (value ? value.offset + value.length : keyStart + key.length) - keyStart } };
+  }
+  return void 0;
+}
+var MARKER = /^( {0,3}(?:#{1,6}|[-+*]|\d{1,9}[.)])[ \t]+)/;
+function afterMarker(text, range) {
+  const line = firstLine(text, range);
+  const lineText = text.slice(line.offset, line.offset + line.length);
+  const match = MARKER.exec(lineText);
+  if (!match) return void 0;
+  const lead = match[1];
+  const markerLength = lead.trimEnd().length;
+  const content = lineText.slice(lead.length);
+  const trimmed = content.replace(/(?:^|[ \t]+)#+[ \t]*$/, "").trimEnd();
+  return { marker: { offset: line.offset + lead.length - lead.trimStart().length, length: markerLength - (lead.length - lead.trimStart().length) }, content: { offset: line.offset + lead.length, length: trimmed.length } };
+}
+function embeddedFenceAt(scan, offset) {
+  return scan.fences.find((fence) => (fence.kind === "opf-block" || fence.kind === "opf-slide") && offset >= fence.from && offset <= fence.to);
+}
+function locateMarkdown(text, segments, part) {
+  const { ctx, front } = readMarkdown2(text);
+  if (segments.length === 0) {
+    const trimmed = text.replace(/\s+$/, "").length;
+    return trimmed > 0 ? { offset: 0, length: trimmed, exact: true } : void 0;
+  }
+  if (segments[0] !== "slides") {
+    if (!front) return void 0;
+    const found = locateYaml(text.slice(front.start, front.end), segments, part);
+    if (found) return { offset: found.offset + front.start, length: found.length, exact: found.exact };
+    return { offset: front.start, length: Math.max(0, front.end - front.start), exact: false };
+  }
+  const slidesSpan = () => {
+    const first = ctx.ranges.get("/slides/0");
+    let last;
+    for (let index = 0; ctx.ranges.get(`/slides/${index}`); index++) last = ctx.ranges.get(`/slides/${index}`);
+    return first && last ? { start: first.start, end: last.end } : void 0;
+  };
+  let consumed = segments.length;
+  let range;
+  for (; consumed > 1; consumed--) {
+    range = ctx.ranges.get(segmentsOfPointer(segments.slice(0, consumed)));
+    if (range) break;
+  }
+  if (!range) {
+    const whole = slidesSpan();
+    return whole ? { offset: whole.start, length: whole.end - whole.start, exact: segments.length === 1 } : void 0;
+  }
+  const exact = consumed === segments.length;
+  const field = segments[2];
+  if (consumed >= 3 && field !== void 0 && SLIDE_OPTIONS.has(field) && OPTIONS_COMMENT.test(text.slice(range.start, range.end))) {
+    const beatIndex = field === "beat" && consumed === 3 && segments[3] !== void 0 && /^\d+$/.test(segments[3]) ? Number(segments[3]) : 0;
+    const token = optionToken(text, range, field, beatIndex);
+    if (token) {
+      const span = part === "key" ? token.key : part === "entry" || part === "colon" ? token.entry : token.value ?? token.key;
+      return { ...span, exact: exact || field === "beat" && consumed === 3 && segments.length === 4 };
+    }
+  }
+  if (!exact) {
+    const fence = embeddedFenceAt(scanMarkdown(text), range.start);
+    if (fence) {
+      const rest = consumed >= 4 && segments[2] === "blocks" ? segments.slice(4) : consumed === 3 ? segments.slice(2) : void 0;
+      const inside = rest?.length ? locateYaml(text.slice(fence.bodyFrom, fence.bodyTo), rest, part) : void 0;
+      if (inside) return { offset: inside.offset + fence.bodyFrom, length: inside.length, exact: inside.exact };
+    }
+  }
+  const title = consumed === 3 && (field === "title" || field === "subtitle");
+  const item = exact && segments.length >= 4 && /^\d+$/.test(segments[segments.length - 1]) && segments[segments.length - 2] !== "blocks";
+  if (exact && (title || item)) {
+    const marked = afterMarker(text, range);
+    if (marked) {
+      const span = part === "key" ? marked.marker : part === "entry" ? firstLine(text, range) : marked.content;
+      if (span.length > 0) return { ...span, exact: true };
+    }
+  }
+  if (part === "open") return { ...firstLine(text, range), exact };
+  return { offset: range.start, length: Math.max(0, range.end - range.start), exact };
+}
+var unescapeSegment = (segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~");
+var spanOf = (range) => ({ offset: range.start, length: range.end - range.start });
+function pathAtMarkdown(text, offset) {
+  const { ctx, front } = readMarkdown2(text);
+  if (front && offset >= front.start && offset <= front.end) {
+    const inside = pathAtYaml(text.slice(front.start, front.end), offset - front.start);
+    return { path: inside.path, part: inside.part === "none" ? "between" : inside.part, ...inside.range ? { range: { offset: inside.range.offset + front.start, length: inside.range.length } } : {} };
+  }
+  const scan = scanMarkdown(text);
+  const fence = embeddedFenceAt(scan, offset);
+  if (fence && offset >= fence.bodyFrom && offset <= fence.bodyTo) {
+    const inside = pathAtYaml(text.slice(fence.bodyFrom, fence.bodyTo), offset - fence.bodyFrom);
+    if (inside.part !== "none" && inside.path.length) {
+      const block = fence.kind === "opf-block" ? blockIndex(ctx.ranges, fence.slide, fence.from) : -1;
+      const prefix = block >= 0 ? ["slides", String(fence.slide), "blocks", String(block)] : ["slides", String(fence.slide)];
+      return { path: [...prefix, ...inside.path], part: inside.part, ...inside.range ? { range: { offset: inside.range.offset + fence.bodyFrom, length: inside.range.length } } : {} };
+    }
+  }
+  let best;
+  for (const [pointer, range] of ctx.ranges) {
+    if (!pointer.startsWith("/slides/") || offset < range.start || offset > range.end) continue;
+    const depth = pointer.split("/").length;
+    if (!best || depth > best.depth || depth === best.depth && range.end - range.start < best.range.end - best.range.start) best = { pointer, range, depth };
+  }
+  if (!best) return { path: [], part: "none" };
+  const path = best.pointer.split("/").slice(1).map(unescapeSegment);
+  const field = path[2];
+  if (path.length === 3 && field && SLIDE_OPTIONS.has(field) && OPTIONS_COMMENT.test(text.slice(best.range.start, best.range.end))) {
+    for (const key of SLIDE_OPTIONS) {
+      for (let nth = 0; ; nth++) {
+        const token = optionToken(text, best.range, key, nth);
+        if (!token) break;
+        const at = key === "beat" ? [path[0], path[1], key, String(nth)] : [path[0], path[1], key];
+        if (offset >= token.key.offset && offset <= token.key.offset + token.key.length) return { path: at, part: "key", range: token.key };
+        if (token.value && offset >= token.value.offset && offset <= token.value.offset + token.value.length) return { path: at, part: "value", range: token.value };
+      }
+    }
+    return { path: path.slice(0, 2), part: "between", range: spanOf(best.range) };
+  }
+  return { path, part: "value", range: spanOf(best.range) };
+}
+function blockIndex(ranges, slide, start) {
+  for (let index = 0; ranges.has(`/slides/${slide}/blocks/${index}`); index++) if (ranges.get(`/slides/${slide}/blocks/${index}`).start === start) return index;
+  return -1;
+}
+
+// src/source-locate.ts
+var indexOrKey = (segment) => /^(?:0|[1-9][0-9]*)$/.test(segment) ? Number(segment) : segment;
 var isJson = (format) => format === "json";
+var isMarkdown = (format) => format === "md" || format === "markdown";
 var parseText = (text) => parseTree(text.startsWith("\uFEFF") ? ` ${text.slice(1)}` : text, [], { allowTrailingComma: true, allowEmptyContent: true, disallowComments: false });
 function segmentsOf(pointer) {
   if (Array.isArray(pointer)) return pointer.map(String);
@@ -15,7 +381,7 @@ function segmentsOf(pointer) {
     return void 0;
   }
 }
-function member(node, segment) {
+function member2(node, segment) {
   if (node.type === "array") return /^(?:0|[1-9][0-9]*)$/.test(segment) ? node.children?.[Number(segment)] : void 0;
   if (node.type === "object") return node.children?.find((property) => property.children?.[0]?.value === segment);
   return void 0;
@@ -37,17 +403,26 @@ function partOf(value, property, part) {
   }
 }
 function locate(text, format, pointer, options = {}) {
-  if (!isJson(format)) return void 0;
   const segments = segmentsOf(pointer);
-  const root = segments ? parseText(text) : void 0;
-  if (!segments || !root) return void 0;
+  if (!segments) return void 0;
   const part = options.part ?? "value";
   const place = createLocator(text);
+  if (format === "yaml") {
+    const found2 = locateYaml(text, segments, part);
+    return found2 ? { ...place(found2.offset, found2.length), ...found2.exact ? {} : { exact: false } } : void 0;
+  }
+  if (isMarkdown(format)) {
+    const found2 = locateMarkdown(text, segments, part);
+    return found2 ? { ...place(found2.offset, found2.length), ...found2.exact ? {} : { exact: false } } : void 0;
+  }
+  if (!isJson(format)) return void 0;
+  const root = parseText(text);
+  if (!root) return void 0;
   let value = root;
   let property;
   let depth = 0;
   for (const segment of segments) {
-    const next = value ? member(value, segment) : void 0;
+    const next = value ? member2(value, segment) : void 0;
     if (!value || !next) break;
     if (value.type === "object") {
       property = next;
@@ -64,9 +439,13 @@ function locate(text, format, pointer, options = {}) {
   return { ...place(found.offset, found.length), ...exact ? {} : { exact: false } };
 }
 function pathAt(text, format, offset) {
+  const place = createLocator(text);
+  if (format === "yaml" || isMarkdown(format)) {
+    const found = format === "yaml" ? pathAtYaml(text, offset) : pathAtMarkdown(text, offset);
+    return { path: found.path.map(indexOrKey), part: found.part, ...found.range ? { range: place(found.range.offset, found.range.length) } : {} };
+  }
   if (!isJson(format)) return void 0;
   const root = parseText(text);
-  const place = createLocator(text);
   const none = { path: [], part: "none" };
   if (!root || offset < root.offset || offset > root.offset + root.length) return none;
   const node = findNodeAtOffset(root, offset, true);
@@ -87,4 +466,4 @@ function pathAt(text, format, offset) {
   return { path: getNodePath(node), part: "value", range: range(node) };
 }
 
-export { locate, pathAt };
+export { locate, pathAt, scanMarkdown };

package/dist/spec/schemas/opf.schema.json

@@ -62,14 +62,12 @@
       "examples": ["Bob Lee", ["Bob Lee", "Carla Diaz"]]
     },
     "audience": {
-      "x-opf-catalog": "audiences",
       "oneOf": [
         { "type": "string" },
         { "$ref": "#/$defs/Audience" },
         {
           "type": "array",
           "items": {
-            "x-opf-catalog": "audiences",
             "oneOf": [
               { "type": "string" },
               { "$ref": "#/$defs/Audience" }
@@ -98,7 +96,6 @@
       ]
     },
     "purpose": {
-      "x-opf-catalog": "purposes",
       "oneOf": [
         { "type": "string" },
         { "$ref": "#/$defs/Purpose" }
@@ -127,7 +124,6 @@
       ]
     },
     "tone": {
-      "x-opf-catalog": "tones",
       "oneOf": [{ "$ref": "#/$defs/CatalogReference" }, { "$ref": "#/$defs/Tone" }],
       "description": "Desired tone for the presentation. Accepts either:\n- A tones reference: a bare id ('formal') or 'name:id' for a record of a named catalogs group.\n- An inline Tone object for custom tone metadata or overrides on a referenced record. Object form has the fields of https://openpresentation.org/schema/opf-tone/v1.\n\nA reference resolves like every content reference (see catalogs); one that resolves nowhere is the warning opf/unresolved-reference. Nothing is drawn from the tone.",
       "examples": [
@@ -185,7 +181,6 @@
       "default": false
     },
     "narrative": {
-      "x-opf-catalog": "narratives",
       "$ref": "#/$defs/CatalogReference",
       "description": "The deck's narrative plan, by reference: a bare narratives id ('classic-story') or 'name:id' for a record of a named catalogs group ('acme:founder-pitch'). The deck holds only this pointer; the plan (the arc, its beats and what each beat must do) lives in the record, which has the fields of https://openpresentation.org/schema/opf-narrative/v1. A narrative the document defines itself is a record in catalogs.custom.narratives, referenced here by its key.\n\nSlides link themselves to beats with slides[].beat. Core validate warns about a slides[].beat id the resolved narrative does not define and about a root 'duration' outside its 'duration' range, and reports a beat that no slide references. The preview and the PPTX export draw nothing from the narrative; opf-pptx stores the reference for round-trip.\n\nThe reference resolves like every content reference (see catalogs); one that resolves nowhere is the warning opf/unresolved-reference, never an error.\n\nDeck-level concerns that are not part of the storyline (audience, tone, takeaway, duration) live as siblings on the presentation root.",
       "examples": ["classic-story", "problem-solution", "scqa", "pitch-deck", "acme:founder-pitch"]
@@ -282,7 +277,6 @@
       ],
       "properties": {
         "id": {
-          "x-opf-catalog": "audiences",
           "$ref": "#/$defs/CatalogReference",
           "description": "Optional audiences reference (a bare id or 'name:id') resolved before applying the inline overrides.",
           "examples": ["executive", "board", "engineering-team"]
@@ -345,7 +339,6 @@
       ],
       "properties": {
         "id": {
-          "x-opf-catalog": "purposes",
           "$ref": "#/$defs/CatalogReference",
           "description": "Optional purposes reference (a bare id or 'name:id') resolved before applying the inline overrides.",
           "examples": ["inform", "decide", "align", "persuade", "educate"]
@@ -425,12 +418,10 @@
           "examples": ["Latn", "Cyrl", "Grek", "Arab", "Hebr", "Jpan", "Kore", "Hans", "Hant", "Deva", "Thai"]
         },
         "fontScheme": {
-          "x-opf-catalog": "fontSchemes",
           "$ref": "#/$defs/CatalogReference",
           "description": "Font-scheme reference (a bare id or 'name:id') for this language's script slot when targeting PowerPoint output. Its major/minor families fill the language's script slot (eastAsian or complexScript, chosen by 'script') unless the effective design font scheme sets that slot itself; the latin slot always follows the design font scheme. Without it, engines use the default script fonts of their language vocabulary."
         },
         "googleFontScheme": {
-          "x-opf-catalog": "fontSchemes",
           "$ref": "#/$defs/CatalogReference",
           "description": "Font-scheme reference (a bare id or 'name:id') used in place of 'fontScheme' when resolving script fonts for Google Slides output."
         },
@@ -458,7 +449,6 @@
       ],
       "properties": {
         "id": {
-          "x-opf-catalog": "tones",
           "$ref": "#/$defs/CatalogReference",
           "description": "Optional tones reference (a bare id or 'name:id') resolved before applying the inline overrides.",
           "examples": ["formal", "casual", "technical", "persuasive"]
@@ -658,13 +648,11 @@
       "description": "Visual design system applied to the presentation; individual slides may override fields via Slide.design.",
       "properties": {
         "theme": {
-          "x-opf-catalog": "themes",
           "$ref": "#/$defs/CatalogReference",
           "description": "Theme for the deck: a themes reference, a bare id ('minimal') or 'name:id' ('acme:brand'). The theme supplies the default colour scheme, font scheme, background and dimensions; design.colorScheme, design.fontScheme, design.background and design.dimensions override it field by field. A reference that resolves nowhere is the warning opf/unresolved-reference and engines use the engine default theme.",
           "examples": ["minimal", "classic", "bold", "acme:brand"]
         },
         "colorScheme": {
-          "x-opf-catalog": "colorSchemes",
           "oneOf": [
             { "type": "string" },
             { "$ref": "#/$defs/ColorScheme" }
@@ -678,7 +666,6 @@
           ]
         },
         "fontScheme": {
-          "x-opf-catalog": "fontSchemes",
           "oneOf": [
             { "type": "string" },
             { "$ref": "#/$defs/FontScheme" }
@@ -798,7 +785,6 @@
       "description": "Color palette used by the design system. Every slot and role is a hex color ('#RGB', '#RRGGBB' or '#RRGGBBAA'); a color-scheme name or a 'var:<id>' reference is not valid here, because those resolve through the scheme. The slot fields (accent1-accent6, dark1, dark2, light1, light2, hyperlink, followedHyperlink) mirror color-scheme.schema.json (https://openpresentation.org/schema/opf-color-scheme/v1) so library records and inline OPF overrides are interchangeable on those fields.\n\nTwo parallel models are supported and may be mixed:\n- OOXML slots - the 12-slot PowerPoint theme model that round-trips directly to OOXML. Use these for full control over the palette as PowerPoint sees it.\n- Abstract roles (primary, secondary, accent, background, surface, text, textSecondary) - OPF-specific semantic aliases the engine maps onto the OOXML slots. Convenient for inline overrides without thinking in slot numbers; not part of the catalog record schema.\n\nIn design.colorScheme, 'id' resolves a colorSchemes record as the base; slot and role overrides on the same object take precedence over the resolved scheme. The string form of design.colorScheme is equivalent to setting only 'id'.",
       "properties": {
         "id": {
-          "x-opf-catalog": "colorSchemes",
           "$ref": "#/$defs/CatalogReference",
           "description": "Colour-scheme reference (a bare id or 'name:id') resolved as the base; slot and role overrides on the surrounding ColorScheme object take precedence over the resolved scheme.",
           "examples": ["cool-horizon", "boost", "burnt-orange", "ocean-depth", "corporate-blue"]
@@ -905,7 +891,6 @@
       "description": "Typography selections used by the design system. The pair fields (major, minor) and refinement fields (type, app, languageFamily) mirror font-scheme.schema.json (https://openpresentation.org/schema/opf-font-scheme/v1) so library records and inline OPF overrides are interchangeable on those fields.\n\nTwo parallel models are supported and may be mixed:\n- OOXML pairs (major, minor) - heading and body family names that round-trip directly to PowerPoint majorFont/minorFont entries.\n- Abstract roles (heading, body, accent, code) - OPF-specific font family names the engine maps onto the OOXML pair when serializing. Convenient for inline overrides and for adding accent/code roles that don't have a direct OOXML slot. Catalog records may also carry 'code' (for example the consolas and courier-new records); heading, body and accent are not part of the catalog record schema. A role is a family name only: weight, style and tracking come from the text styles, and PowerPoint has no numeric weight.\n\nIn design.fontScheme, 'id' resolves a fontSchemes record as the base; pair and role overrides on the same object take precedence over the resolved scheme. The string form of design.fontScheme is equivalent to setting only 'id'.",
       "properties": {
         "id": {
-          "x-opf-catalog": "fontSchemes",
           "$ref": "#/$defs/CatalogReference",
           "description": "Font-scheme reference (a bare id or 'name:id') resolved as the base; field overrides on the surrounding FontScheme object take precedence over the resolved scheme.",
           "examples": ["aptos", "tenorite", "seaford", "noto-sans", "modern-sans", "classic-serif"]
@@ -1952,7 +1937,6 @@
           "description": "Optional reference to one or more beats of the deck's narrative (each value is the id of a beat in the narrative record that the root 'narrative' resolves to). A single string declares the slide's primary beat; an array declares that one slide covers multiple beats. Declares the slide's role in the story arc; does not constrain ordering or structure. Core validate warns about a beat id the resolved narrative does not define, and reports a beat that no slide references. Slides without a beat are valid; multiple slides may share a beat."
         },
         "layout": {
-          "x-opf-catalog": "layouts",
           "$ref": "#/$defs/CatalogReference",
           "description": "Optional layout: a layouts reference, a bare id ('pillars') or 'name:id' ('acme:hero'), or 'auto'. When omitted or 'auto', the slide is composed with no layout record: engines arrange title, subtitle, tag and content automatically, a slide with no body payload is a cover (vertically centered), and design hints apply; there is no finding. 'auto' is reserved, so no catalog may define a layout of that id, and opf format drops it. A layout is a grid template (layout.schema.json): the slide's content stays flat and binds to the layout's regions by reading order, role and kind, a block may pin itself to a region with 'region', and an empty region collapses. A reference that resolves nowhere is the warning opf/unresolved-reference (and the 'unresolved-reference' diagnostic of resolveSlideContext), the slide composes automatically, and a strict export fails. A layout id of the 0.18 default catalog that 0.19 no longer has is such a reference: 0.19 has no migration path for layouts. A layout never changes what a slide contains, and engines never substitute a different layout.",
           "examples": ["cover", "pillars", "chart-beside", "auto", "acme:hero"]

package/dist/spec/schemas/theme.schema.json

@@ -50,14 +50,12 @@
       ]
     },
     "colorScheme": {
-      "x-opf-catalog": "colorSchemes",
       "type": "string",
       "pattern": "^(?:[a-z][a-z0-9-]*:)?[a-z][a-z0-9-]*$",
       "description": "The theme's default colour scheme: a reference (a bare id or 'name:id') resolved like design.colorScheme, but in the theme's own catalogs group first.",
       "examples": ["cool-horizon", "boost", "burnt-orange"]
     },
     "fontScheme": {
-      "x-opf-catalog": "fontSchemes",
       "type": "string",
       "pattern": "^(?:[a-z][a-z0-9-]*:)?[a-z][a-z0-9-]*$",
       "description": "The theme's default font scheme: a reference (a bare id or 'name:id') resolved like design.fontScheme, but in the theme's own catalogs group first.",

package/dist/validator.js

@@ -1,3 +1,3 @@
-export { DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-LUQYSUXS.js';
+export { DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-XFOOKVRI.js';
 export { promotedRegionKeys } from './chunk-XRMV2GMB.js';
-import './chunk-N6CNJCIF.js';
+import './chunk-F4HFDP6I.js';

package/dist/yaml.js

@@ -1,7 +1,8 @@
-export { OPFYamlError, YAML_SCHEMA_URL, fromYaml, parseYamlData, scanYamlComments, toYaml } from './chunk-7YZ72FRP.js';
-import './chunk-6JAFSZVL.js';
-import './chunk-O2ST5ZKL.js';
-import './chunk-LUQYSUXS.js';
+export { OPFYamlError, YAML_SCHEMA_URL, fromYaml, parseYamlData, scanYamlComments, toYaml } from './chunk-PIO73BQ6.js';
+import './chunk-RYZPBJLB.js';
+import './chunk-QAEBYDKY.js';
+import './chunk-6NBTZYYD.js';
+import './chunk-XFOOKVRI.js';
 import './chunk-XRMV2GMB.js';
-import './chunk-JI3PHXPJ.js';
-import './chunk-N6CNJCIF.js';
+import './chunk-EQ6S5SEZ.js';
+import './chunk-F4HFDP6I.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf",
-  "version": "0.26.2",
+  "version": "0.26.4",
   "description": "Canonical Open Presentation Format schemas, TypeScript types, local validation and composition; in Node, the file API and the CLI defaults register the pptx.gallery catalog of @openpresentation/gallery.",
   "license": "MIT",
   "author": "Open Presentation",
@@ -145,7 +145,7 @@
     "ajv-formats": "^3.0.1",
     "jsonc-parser": "3.3.1",
     "yaml": "^2.9.1",
-    "@openpresentation/gallery": "^0.26.2"
+    "@openpresentation/gallery": "^0.26.4"
   },
   "devDependencies": {
     "@expo-google-fonts/arimo": "0.4.3",
@@ -165,8 +165,8 @@
     "typescript": "~5.9.3"
   },
   "peerDependencies": {
-    "@openpresentation/opf-pptx": "^0.26.2",
-    "@openpresentation/opf-render": "^0.26.2"
+    "@openpresentation/opf-pptx": "^0.26.4",
+    "@openpresentation/opf-render": "^0.26.4"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-pptx": {
@@ -186,5 +186,5 @@
     "test:packed": "node test/packed-install-smoke.mjs",
     "pack:dry-run": "pnpm run build:deps && pnpm run build && npm pack --dry-run --cache /tmp/opf-npm-cache"
   },
-  "gitHead": "0440759ebddc9ea01fdf52c88a0406e21c955375"
+  "gitHead": "8809122a74a43aa99cdd383a856839ad6f018af6"
 }

package/dist/conversion-BKCKBECG.js

@@ -1,18 +0,0 @@
-export { convertFiles, deckFileFormat, exportFormatOf, openDeck, planConversion, readInput, saveDeck, writePlanned } from './chunk-5VJCLUUA.js';
-import './chunk-XFK4KPKK.js';
-import './chunk-OFWBICDO.js';
-import './chunk-UJSAR6GF.js';
-import './chunk-PJSPHHRK.js';
-import './chunk-TKQ2VFV5.js';
-import './chunk-L65YNP4J.js';
-import './chunk-NWO6HT4F.js';
-import './chunk-Q6KMKTEH.js';
-import './chunk-CRCOQ4K2.js';
-import './chunk-7YZ72FRP.js';
-import './chunk-6JAFSZVL.js';
-import './chunk-O2ST5ZKL.js';
-import './chunk-LN2ASLMF.js';
-import './chunk-LUQYSUXS.js';
-import './chunk-XRMV2GMB.js';
-import './chunk-JI3PHXPJ.js';
-import './chunk-N6CNJCIF.js';