@uniweb/semantic-parser 1.8.1 → 1.10.0

package/AGENTS.md

@@ -165,7 +165,7 @@ Key patterns — the staircase rule (each heading relates to the one before it):
 - **Subtitle**: one step below the title, directly adjacent — and each further one-step descent (or same-size repeat) is another subtitle line. String or array.
 - **Items**: a heading two or more steps below the previous one, a step back up, or any heading after body content starts a new group.
 - **Banner Pattern**: an image (with banner role or followed by a heading) at the start of the first group stays with the headline.
-- **Dividers**: a `horizontalRule` explicitly closes the current group; it composes with the heading rules rather than replacing them.
+- **Dividers**: a `divider` (`---` in markdown) explicitly closes the current group; it composes with the heading rules rather than replacing them.
 - **Main Content**: the first group is main if it's the only group, has a more important heading level than the second group, or has no heading at all.
 - **Body Headings**: `body.headings` fills only from nested content (blockquote children, list items) — a section's headline never spills there.
 

package/README.md

@@ -280,6 +280,24 @@ or `[#id]{k=v}` references. Two artifacts ship to consumers:
 The two views stay in lockstep — both record every inline inset the
 parser sees, in source order.
 
+### Inline Icons and Pictures
+
+An icon or a picture beside text stays in its paragraph, and it is carried
+the same two ways:
+
+1. **`children` carries an `icon` or an `image` entry** — the icon's library
+   and name, the picture's resolved `url` and its `alt`.
+
+2. **`text` carries a marker at its position** —
+   `<uniweb-icon data-index="N"></uniweb-icon>` or
+   `<uniweb-image data-index="N"></uniweb-image>`, where `N` is its ordinal
+   among the paragraph's icons, or among its pictures
+   (`children.filter(c => c.type === 'image')[N]`).
+
+A renderer that reads `text` as HTML and does not know a marker draws
+nothing for it, as for any empty element it does not know. kit's `<Render>`
+draws an icon with `<Icon>` and a picture with `<Image>`.
+
 ## Use Cases
 
 - **Component-based websites**: Extract structured data for React/Vue components

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/semantic-parser",
-  "version": "1.8.1",
+  "version": "1.10.0",
   "description": "Semantic parser for ProseMirror/TipTap content structures",
   "type": "module",
   "main": "./src/index.js",

package/src/builders/doc.js

@@ -23,8 +23,9 @@
  * This builder was written with its own spelling for several concepts, and
  * `parseContent` emits a DIFFERENT one for the same thing: a link's text is
  * `text` here and `label` there; an image's address is `src` here and `url`
- * there; a video's cover is a string here and `{ src | url | identifier }`
  * there; a list item is a plain string here and a whole content GROUP there.
+ * (A video's cover was a fourth — an editor's `coverImg` — until the parser
+ * stopped reading the editor's `Video`, 2026-10-18; both sides say `poster`.)
  *
  * ⛔ EVERY ONE OF THOSE MISMATCHES FAILED SILENTLY, which is why the rule is
  * now written down. Measured 2026-09-16, all four on the shapes a caller would
@@ -180,16 +181,13 @@ function iconNode({ src, url, library, name, size, color }) {
 const PLAYBACK_FLAGS = ['autoplay', 'muted', 'loop', 'controls']
 
 function videoNode(video) {
-  const { src, url, alt, caption, placement, poster, coverImg } = video
+  const { src, url, alt, caption, placement, poster } = video
   const attrs = { src: src || url, role: 'video' }
   if (alt) attrs.alt = alt
   if (caption) attrs.caption = caption
   // The cover is `poster`, what the parser emits for a video and what a
-  // component reads. `coverImg` is an editor's spelling — a string, or an
-  // object whose `src` or `url` is the address; an `identifier` alone names
-  // no address, so it gives none.
-  const cover = poster || (typeof coverImg === 'string' ? coverImg : coverImg?.src || coverImg?.url)
-  if (cover) attrs.poster = cover
+  // component reads. ⛔ Until 2026-10-18 an editor's `coverImg` was taken too.
+  if (poster) attrs.poster = poster
   if (placement) attrs.placement = placement
   for (const flag of PLAYBACK_FLAGS) if (typeof video[flag] === 'boolean') attrs[flag] = video[flag]
   return { type: 'image', attrs }

package/src/processors/groups.js

@@ -417,20 +417,6 @@ function processGroupContent(elements, options = {}) {
                     body.icons.push(element.attrs);
                     break;
 
-                case "button":
-                    // Map button to link with role
-                    body.links.push({
-                        href: element.attrs?.href || '',
-                        label: element.text || '',
-                        role: element.attrs?.variant ? `button-${element.attrs.variant}` : 'button',
-                        variant: element.attrs?.variant || 'primary',
-                        size: element.attrs?.size,
-                        icon: element.attrs?.icon,
-                        target: element.attrs?.target,
-                        class: element.attrs?.class,
-                    });
-                    break;
-
                 case "blockquote":
                     // Process blockquote content recursively
                     const quoteContent = processGroupContent(element.children);
@@ -514,31 +500,10 @@ function processGroupContent(elements, options = {}) {
                     body.media.push({ refId: element.refId, kind: "inset" });
                     break;
 
-                case "form":
-                    // Route FormBlock data by the schema id it targets, so it
-                    // shares a namespace with tagged markdown data blocks
-                    // (```yaml:<id>``` also lands at data[<id>]). When no
-                    // schemaId is present (legacy content), fall back to the
-                    // literal key "form" — eventual deprecation.
-                    {
-                        const payload = element.data || element.attrs;
-                        const key = element.schemaId || "form";
-                        body.data[key] = payload;
-                    }
-                    break;
-
-                case "card-group":
-                    // Map cards to data by type: data.person = [...], data.event = [...]
-                    // Each card type becomes a key, with an array of cards of that type
-                    (element.cards || []).forEach(card => {
-                        const cardType = card.cardType || 'card';
-                        if (!body.data[cardType]) body.data[cardType] = [];
-                        // Remove cardType from the card object since it's now the key
-                        const { cardType: _, ...cardData } = card;
-                        body.data[cardType].push(cardData);
-                    });
-                    break;
-
+                // ⛔ A `form` element was routed here until 2026-10-18 — the
+                // editor's form node, its data at `data[<schema id>]`, else at
+                // `data.form`. The node is read nowhere now: a form's data is a
+                // tagged data block, which lands at `data[<tag>]` above.
             }
         }
     }

package/src/processors/sequence.js

@@ -3,7 +3,6 @@ import {
     escapeText,
     escapeAttribute as escapeAttr,
     sanitizeMathML,
-    sanitizeSVG,
     isSafeLink,
     isLinkTarget,
     isStyleName,
@@ -18,12 +17,20 @@ import {
 // rule that a text node held HTML — so `<img src=x onerror=…>` written in
 // content ran on the published page, and `if a<b then` showed as `if a`.
 
+/** Check if an inline node is an icon: an `image` with role "icon". */
+function isIconNode(node) {
+    return node.type === "image" && node.attrs?.role === "icon";
+}
+
 /**
- * Check if an inline node is an icon.
- * TipTap editor uses type "UniwebIcon"; markdown pipeline uses type "image" with role "icon".
+ * Is an inline node a picture — an `image` that is not an icon, a video or a
+ * file? These are the nodes processInlineElements() delivers as `image`
+ * children, so the marker's ordinal (getTextContent) counts exactly them.
  */
-function isIconNode(node) {
-    return node.type === "UniwebIcon" || (node.type === "image" && node.attrs?.role === "icon");
+function isInlinePicture(node) {
+    if (node?.type !== "image" || isIconNode(node)) return false;
+    const role = node.attrs?.role;
+    return role !== "video" && role !== "pdf";
 }
 
 /**
@@ -207,11 +214,6 @@ function createSequenceElement(node, options = {}) {
                 mathml: sanitizeMathML(node.attrs?.mathml || ""),
                 attrs,
             };
-        case "ImageBlock":
-            return {
-                type: "image",
-                attrs: parseImgBlock(attrs, options),
-            };
         case "image":
             // `role` decides which content array this lands in — the contract
             // published in docs/reference/content-structure.md ("Media Assets"):
@@ -234,28 +236,20 @@ function createSequenceElement(node, options = {}) {
             // poster/autoplay/muted/loop/controls, so the author's declaration
             // was demoted to an image AND its playback attrs were dropped —
             // while the build had already generated a poster for it
-            // (@uniweb/build site/assets.js). Note this does NOT route to
-            // parseVideoBlock: that reader speaks the editor's dialect
-            // (coverImg, info), not the markdown one.
+            // (@uniweb/build site/assets.js).
             if (attrs?.role === "video") {
                 return {
                     type: "video",
                     attrs: parseMarkdownVideo(attrs, options),
                 };
             }
-            // Standard ProseMirror image node - resolve attrs the same way as
-            // ImageBlock so info.identifier lands as a CDN URL. CLI-deployed
-            // content uses this node type; without parseImgBlock the url
+            // Standard ProseMirror image node - read through parseImgBlock, so
+            // its address lands in `url`. Without parseImgBlock the url
             // wouldn't be populated and components render an empty slot.
             return {
                 type: "image",
                 attrs: parseImgBlock(attrs || {}, options),
             };
-        case "Video":
-            return {
-                type: "video",
-                attrs: parseVideoBlock(attrs, options),
-            };
         case "bulletList":
         case "orderedList": {
             const listItems = content
@@ -305,90 +299,26 @@ function createSequenceElement(node, options = {}) {
             return { type: "table", rows, attrs };
         }
 
-        // `divider` is what content-reader emits; `horizontalRule` and
-        // `DividerBlock` are the editor's spellings. All three are one element.
-        //
         // The reader's own name was NOT listed here until 2026-07-30 — markdown
         // dividers reached consumers only by falling through `default:`, which
         // happens to produce `{ type: 'divider', content: '' }` and happens to
         // match what everything downstream keys on. It worked by coincidence,
         // and the coincidence would have broken the moment `default:` changed.
+        //
+        // ⭐ The vocabulary's names are the only ones read. ⛔ Until 2026-10-18 the
+        // editor's spellings were read too: `DividerBlock` and `horizontalRule` as
+        // a divider, and its form node — `StructuredContent`, and `FormBlock`, its
+        // name before 2026-07-31 — as a `form` element whose data landed at
+        // `content.data[<schema id>]`. The editor writes `divider` and `dataBlock`
+        // itself now, and no writer produces the others, as none does its
+        // `card-group`, `document-group`, `ImageBlock`, `Video`, `UniwebIcon`,
+        // `Icon` and `button` nodes.
         case "divider":
-        case "DividerBlock":
-        case "horizontalRule":
             return {
                 type: "divider",
                 attrs,
             };
 
-        // Custom TipTap elements
-        case "card-group":
-            return {
-                type: "card-group",
-                cards:
-                    node.content
-                        ?.filter((c) => c.type === "card" && !c.attrs?.hidden)
-                        .map((card) => parseCardBlock(card.attrs)) || [],
-            };
-
-        case "document-group":
-            // The editor's older container: one `document` element per document
-            // it holds, so a document is one kind of content whichever node
-            // wrote it (`documentFromEditorNode`). Until 2026-09-29 this was a
-            // `document-group` element whose documents became `content.links`.
-            return (node.content || [])
-                .filter((c) => c.type === "document")
-                .map((doc) => ({
-                    type: "document",
-                    attrs: documentFromEditorNode(doc.attrs),
-                }));
-
-        // The editor renamed this node to `StructuredContent` (2026-07-31,
-        // editor-internal). Both are accepted: the new name is what the editor
-        // emits now, and the old one still arrives from documents authored
-        // before the rename, which the framework never rewrites.
-        case "StructuredContent":
-        case "FormBlock":
-            // Parse form data (can be JSON string or object)
-            let formData = attrs?.data;
-            if (typeof formData === "string") {
-                try {
-                    formData = JSON.parse(formData);
-                } catch (err) {
-                    // Keep as string
-                }
-            }
-
-            return {
-                type: "form",
-                schemaId: attrs?.activeSchemaId || null,
-                data: formData,
-                attrs,
-            };
-
-        case "button": {
-            let textContent = getTextContent(content, options);
-
-            if (!textContent) return null;
-
-            return {
-                type: "button",
-                text: textContent,
-                children: processInlineElements(content, options),
-                attrs,
-            };
-        }
-        case "UniwebIcon":
-            return {
-                type: "icon",
-                attrs: parseUniwebIcon(attrs),
-            };
-        case "Icon":
-            return {
-                type: "icon",
-                attrs: parseIconBlock(attrs),
-            };
-
         default:
             return {
                 type: node.type,
@@ -487,16 +417,22 @@ function getTextContent(content, options = {}) {
     // one with `children.filter(c => c.type === 'icon')[index]`. Referencing by
     // ordinal rather than serializing the attrs keeps an inline `svg` blob out
     // of the text stream and leaves `children` the single source of truth.
+    //
+    // A picture beside text is marked the same way, by its ordinal among the
+    // pictures of this array — `children.filter(c => c.type === 'image')[index]`.
     const iconOrdinals = new Map();
+    const pictureOrdinals = new Map();
     let nextIcon = 0;
+    let nextPicture = 0;
     for (const node of content) {
         if (isIconNode(node)) iconOrdinals.set(node, nextIcon++);
+        else if (isInlinePicture(node)) pictureOrdinals.set(node, nextPicture++);
     }
 
     return groups
         .reduce((prev, group) => {
             const inner = group.nodes.reduce(
-                (acc, node) => acc + renderInlineNode(node, iconOrdinals),
+                (acc, node) => acc + renderInlineNode(node, iconOrdinals, pictureOrdinals),
                 "",
             );
             if (!inner && !group.link) return prev;
@@ -509,7 +445,7 @@ function getTextContent(content, options = {}) {
  * Render one inline node to HTML, applying every mark EXCEPT link — the
  * anchor is applied per group by getTextContent, since it may span nodes.
  */
-function renderInlineNode(curr, iconOrdinals) {
+function renderInlineNode(curr, iconOrdinals, pictureOrdinals) {
     return [curr]
         .reduce((prev, curr) => {
             const { type, marks = [], text } = curr;
@@ -517,24 +453,13 @@ function renderInlineNode(curr, iconOrdinals) {
             if (type === "text") {
                 let styledText = escapeText(text || "");
 
-                // Apply marks in order: textStyle, highlight, bold, italic, link
-                // This ensures proper nesting
-
-                // textStyle (color)
-                if (marks.some((mark) => mark.type === "textStyle")) {
-                    const color = marks.find(
-                        (mark) => mark.type === "textStyle"
-                    )?.attrs?.color;
-                    // A theme token's name, or nothing — it lands inside `var(--…)`.
-                    if (typeof color === "string" && /^[a-zA-Z0-9-]+$/.test(color)) {
-                        styledText = `<span style="color: var(--${color})">${styledText}</span>`;
-                    }
-                }
-
-                // highlight
-                if (marks.some((mark) => mark.type === "highlight")) {
-                    styledText = `<span style="background-color: var(--highlight)">${styledText}</span>`;
-                }
+                // Apply marks in order: span, code, bold, italic — the link is
+                // applied per group by getTextContent. This ensures proper nesting.
+                //
+                // ⛔ Until 2026-10-18 the editor's `textStyle` (a theme color) and
+                // `highlight` marks were applied first. The editor saves both as
+                // the vocabulary's `span` — `[x]{accent}`, `[x]{highlight}` — so
+                // neither is read now.
 
                 // span (bracketed spans with class/id/attributes)
                 if (marks.some((mark) => mark.type === "span")) {
@@ -637,6 +562,18 @@ function renderInlineNode(curr, iconOrdinals) {
                 const index = iconOrdinals?.get(curr);
                 if (index === undefined) return prev;
                 return prev + `<uniweb-icon data-index="${index}"></uniweb-icon>`;
+            } else if (isInlinePicture(curr)) {
+                // A picture sitting IN the prose — `as the figure ![](./cells.jpg)
+                // shows` — marked for the icon's reason: a renderer draws it with a
+                // component (kit's <Image>), from the entry processInlineElements()
+                // puts in `children`, its address resolved there.
+                //
+                // ⛔ Until 2026-10-18 it fell through to the catch-all below, as an
+                // icon did before 2026-08-12: the text kept a gap, the picture stayed
+                // in `children` and `content.images`, and a walker drew nothing.
+                const index = pictureOrdinals?.get(curr);
+                if (index === undefined) return prev;
+                return prev + `<uniweb-image data-index="${index}"></uniweb-image>`;
             } else {
                 // console.warn(`unhandled text content type: ${type}`, curr);
                 return prev;
@@ -653,9 +590,9 @@ function processInlineElements(content, options = {}) {
         if (isIconNode(item)) {
             items.push({
                 type: "icon",
-                attrs: parseUniwebIcon(item.attrs),
+                attrs: parseIcon(item.attrs),
             });
-        } else if (item.type === "image" || item.type === "ImageBlock") {
+        } else if (item.type === "image") {
             // A media node that stayed inside its paragraph — content-reader
             // hoists a standalone one to the document root, but an image sitting
             // beside text does not qualify (parser/block.js `isBlockEligible`).
@@ -715,6 +652,11 @@ function processInlineElements(content, options = {}) {
  * layout, so a framework package never composes a serve location or guesses an
  * origin — a host may move its assets without a framework release.
  *
+ * ⛔ No asset host is built into this package: a reference resolves through this
+ * pattern, or is the address the content holds. Until 2026-10-17 an
+ * `info.identifier` (`{version}/{filename}`) was composed against a fixed host;
+ * it is not read.
+ *
  * ⛔ Three ways this returns '' — "unresolved", never a guess:
  *   - **no pattern** (the host declared none) — absent ⇒ absent
  *   - **an unknown placeholder** — never emit a half-substituted URL
@@ -750,8 +692,9 @@ function processInlineElements(content, options = {}) {
  * the one every fallback path already resolves to. The convention is: unprefixed
  * identifies the primary; a prefix names the attr it belongs to.
  *
- * `url` rides in the primary slot because the editor's `ImageBlock` uses it where
- * markdown's `image` uses `src`; both mean the same reference.
+ * `url` rides in the primary slot because the editor's `ImageBlock` used it where
+ * `image` uses `src`. This parser reads `src` alone since 2026-10-18; the entry
+ * stays because this list is exported and read outside it.
  */
 export const ASSET_SLOTS = [
     { urls: ["src", "url"], id: "assetId", ext: "assetExt" },
@@ -791,72 +734,6 @@ function secondaryAssetUrl(attrs, options, urlAttr) {
     return resolved || attrs?.[urlAttr] || "";
 }
 
-// ⛔ LEGACY BELOW — the PHP-estate identifier path. Do not extend it.
-//
-// `{version}/{filename}` identifiers have no current producer — the CLI emits
-// `src`, and editors store the URL their host hands them. Only content authored
-// against the original hosted service still carries one, and the hardcoded host
-// below cannot be correct for any other deployment: the CLI can be pointed at
-// any host. New references use `assetId`/`assetExt` above.
-const ASSET_BASE_URL = "https://assets.uniweb.app/";
-
-/**
- * Resolve an asset identifier ({version}/{filename}) to a direct URL.
- * Assets are hosted at assets.uniweb.app under dist/{version}/base.{ext}.
- */
-function resolveAssetIdentifier(identifier) {
-    if (!identifier || typeof identifier !== "string") return "";
-    // ⛔ An identifier that is ALREADY a URL or a rooted path is not an
-    // identifier — it is a serve URL sitting in the identifier slot, and it is
-    // usable exactly as it stands. Composing it against the legacy base
-    // destroys it: `split("/")` on `/gateway/asset/dist/{id}/base.png` takes
-    // `""` as the version and `"gateway"` as the filename, yielding
-    // `https://assets.uniweb.app/dist//base.gateway` — not a 404 and not a
-    // validation failure, a URL-shaped string that renders a broken image and
-    // reads like a missing file.
-    //
-    // The legacy grammar is `{version}/{filename}` with no leading slash, so
-    // nothing legitimate is caught here. Passing it through is not constructing
-    // a serve location: it is declining to construct one over a value that is
-    // already an address. (Measured 2026-08-17 against a real producer.)
-    if (/^(?:[a-z][a-z0-9+.-]*:|\/\/|\/)/i.test(identifier)) return identifier;
-    const [version, filename] = identifier.split("/");
-    if (!filename) return "";
-    const ext = filename.substring(filename.lastIndexOf(".") + 1);
-    return `${ASSET_BASE_URL}dist/${version}/base.${ext}`;
-}
-
-function makeAssetUrl(info) {
-    const src = info?.src || info?.url || "";
-    if (src) return src;
-    if (info?.identifier) return resolveAssetIdentifier(info.identifier);
-    return "";
-}
-
-function parseCardBlock(itemAttrs) {
-    const { address, ...others } = itemAttrs;
-
-    let parsedAddress = null;
-
-    try {
-        if (address) {
-            parsedAddress = JSON.parse(address);
-        }
-    } catch {}
-
-    const { coverImg = null, icon } = others;
-
-    if (icon) {
-        others.icon = parseUniwebIcon(icon);
-    }
-
-    return {
-        ...others,
-        address: parsedAddress,
-        coverImg: makeAssetUrl(coverImg),
-    };
-}
-
 // A document authored in markdown: `![Annual report](./report.pdf){role=pdf …}`.
 //
 // Read through `parseImgBlock`, which resolves the address and the preview's the
@@ -900,146 +777,47 @@ function fileFacts(url, attrs = {}) {
     };
 }
 
-// The editor's older `document` node — its `title`, `coverImg` and `src` (or
-// asset identifier) — read into the same shape a markdown document has.
-function documentFromEditorNode(itemAttrs) {
-    const {
-        href,
-        downloadUrl,
-        title = "",
-        alt = "",
-        coverImg,
-        author,
-        description,
-        fileType,
-    } = parseDocumentBlock(itemAttrs || {});
-    const url = href || downloadUrl || "";
-    return {
-        url,
-        ...fileFacts(url, itemAttrs),
-        alt: alt || title,
-        caption: title,
-        role: "pdf",
-        ...(coverImg && { preview: coverImg }),
-        ...(author && { author }),
-        ...(description && { description }),
-        ...(fileType && { fileType }),
-    };
-}
-
-function parseDocumentBlock(itemAttrs) {
-    const { src, info = {}, coverImg = null, ...others } = itemAttrs;
-
-    let ele = {
-        ...others,
-        coverImg: makeAssetUrl(coverImg),
-    };
-
-    if (src) {
-        ele.href = src;
-    } else {
-        const { identifier = "" } = info;
-
-        if (identifier) {
-            ele.downloadUrl = resolveAssetIdentifier(identifier);
-        }
-    }
-
-    return ele;
-}
-
-function parseUniwebIcon(itemAttrs) {
-    const { svg, url, src, size, color, preserveColors, href, target, library, name } = itemAttrs || {};
+/**
+ * An icon: named (`library` + `name`, resolved at render through the icon
+ * corpus) or a file (`src`) — `![Logo](icon:./logo.svg)` or
+ * `![Logo](./logo.svg){role=icon}`, both documented in AGENTS.md and
+ * docs/reference/content-structure.md. Until 2026-07-30 a file-sourced icon
+ * delivered `{}` and rendered nothing. `url` is the key kit's <Icon> fetches
+ * from. Keys are omitted when absent.
+ *
+ * ⛔ Until 2026-10-18 this also read the editor's `UniwebIcon` (an inline `svg`,
+ * a `url`, `preserveColors`, a `family:id` name) and its `Icon` node.
+ */
+function parseIcon(itemAttrs) {
+    const { src, size, color, href, target, library, name } = itemAttrs || {};
 
-    // Build object with only defined fields — icon source varies:
-    // TipTap editor: svg/url (resolved inline)
-    // Markdown pipeline: library + name (resolved at runtime via CDN)
-    //                    OR a file, which arrives as `src`
     const icon = {};
-    // Markup from content, so rebuilt from the SVG allowlist (`../sanitize.js`).
-    if (svg) icon.svg = sanitizeSVG(svg);
-    // Standard ProseMirror `image` nodes use `src`; the editor's `UniwebIcon`
-    // uses `url`. Honor either, exactly as parseImgBlock does below — a
-    // file-sourced icon is authored `![Logo](icon:./logo.svg)` or
-    // `![Logo](./logo.svg){role=icon}` (both documented in AGENTS.md and
-    // docs/reference/content-structure.md), and reaches here as `src` with no
-    // library/name. Until 2026-07-30 this reader dropped it, so every
-    // documented file-sourced icon delivered `{}` and rendered nothing.
-    // `url` is the key kit's <Icon> fetches from.
-    if (url || src) icon.url = url || src;
+    if (src) icon.url = src;
     if (size) icon.size = size;
     if (color) icon.color = color;
-    if (preserveColors) icon.preserveColors = preserveColors;
     if (href) icon.href = href;
     if (target) icon.target = target;
-    // The editor carries the family inside `name` as `family:id`; the markdown
-    // pipeline carries them separately. Normalize to the separate form, which
-    // is what `<Icon library name />` consumes.
-    let resolvedLibrary = library;
-    let resolvedName = name;
-    if (!resolvedLibrary && typeof name === "string" && name.includes(":")) {
-        const [family, ...rest] = name.split(":");
-        resolvedLibrary = family;
-        resolvedName = rest.join(":");
-    }
-    if (resolvedLibrary) icon.library = resolvedLibrary;
-    if (resolvedName) icon.name = resolvedName;
-
-    return icon;
-}
-
-// The editor's `Icon` node carries an inline SVG blob plus a theme. Return an
-// ATTRS OBJECT, like every other parser in this file — not the bare `svg`
-// string it used to return.
-//
-// The string form was a live bug, not just an inconsistency: kit renders a
-// sequence icon with `<Icon {...element.attrs} />` (styled/Prose/index.jsx),
-// and spreading a string yields indexed character props — `{0:'<', 1:'s', …}`
-// — so the icon rendered as nothing and React saw a wall of unknown props. It
-// failed silently because `attrs.svg` on a string is `undefined`, never an
-// error.
-//
-// Keys are omitted when absent so a consumer can distinguish "not provided"
-// from "empty", matching parseUniwebIcon's shape above.
-function parseIconBlock(itemAttrs) {
-    const { svg, theme } = itemAttrs || {};
-
-    const icon = {};
-    if (svg) icon.svg = sanitizeSVG(svg);
-    if (theme) icon.theme = theme;
+    if (library) icon.library = library;
+    if (name) icon.name = name;
 
     return icon;
 }
 
 function parseImgBlock(itemAttrs, options) {
     let {
-        info: imgInfo,
-        targetId,
         caption = "",
         alt = "",
         src,
-        url,
         href = "",
         target = "",
         role,
-        credit, // the editor's word for `author` — delivered as `author`
         id, // {#fig-id} cross-reference label — preserved so Press
             // adapters can emit \label{id} (LaTeX) / <id> (Typst).
-        // ── Markdown-authored attributes ────────────────────────────────
-        // This function was written for the EDITOR's `ImageBlock` node and
-        // later reused for the markdown `image` node (see `case "image"`), so
-        // its vocabulary was the editor's. Everything markdown declares and
-        // the editor does not was therefore tokenized, declared, and then
-        // dropped one layer before delivery — the published "Image
-        // Attributes" table (docs/reference/content-structure.md) reached no
-        // component, and neither did the `role=pdf` set added 2026-07-29 for
-        // the editor's `document` fold-in. Carried 2026-07-30.
-        //
-        // ⭐ An element now holds the vocabulary's words, whichever node it
-        // came from. ⛔ Until 2026-10-15 it also held the editor's `direction`
-        // and two things derived from it — `imgPos` (left/right) and a
-        // layout `size` (basic/lg/full, `basic` for every image without one) —
-        // plus `filter` and `theme`, none of which a stored document holds. A
+        // ⭐ An element holds the vocabulary's words. ⛔ This function was
+        // written for the editor's `ImageBlock` and read its words too — `url`,
+        // `credit`, an `info` envelope (`contentType`, `viewType`, `contentId`)
+        // and `targetId` — until 2026-10-18; and until 2026-10-15 its
+        // `direction`, `imgPos`, a layout `size`, `filter` and `theme`. A
         // component handing the element to kit's <Image> passed that `size` as
         // Image's avatar preset, so a "wide" image drew as a 96px square.
         width,
@@ -1053,39 +831,18 @@ function parseImgBlock(itemAttrs, options) {
         description, // role=pdf — describes the RESOURCE, not the image (≠ alt)
     } = itemAttrs;
 
-    let { contentType, viewType, contentId, identifier } = imgInfo || {};
-
     caption = stripTags(caption);
-    const attribution = author || credit;
 
-    // Reference precedence. Standard ProseMirror `image` nodes use `src`; the
-    // custom `ImageBlock` node uses `url`. Honor either so callers don't have to
-    // pre-normalize.
-    //
     // ⭐ A store-held asset (`assetId`) wins WHEN IT RESOLVES — not merely when
     // it is present. That distinction is the whole reason a producer can write
     // `assetId` alongside `src` before any deployment declares
     // `config.assets.url`: until one does, resolution yields '' and the node
     // renders through `src` exactly as it does today. Content written now stays
     // correct whichever order the halves arrive in.
-    //
-    // `identifier` is the LEGACY estate path and keeps its old precedence over a
-    // stale `src`.
-    const assetUrl = assetUrlFromAttrs(itemAttrs, options);
-    if (assetUrl) {
-        url = assetUrl;
-    } else if (identifier) {
-        url = makeAssetUrl(imgInfo);
-    } else if (!url && src) {
-        url = src;
-    }
+    const url = assetUrlFromAttrs(itemAttrs, options) || src || undefined;
 
     return {
-        contentType,
-        viewType,
-        contentId: targetId || contentId,
         url,
-        value: identifier || "",
         alt: alt || caption,
         caption,
         href,
@@ -1104,24 +861,21 @@ function parseImgBlock(itemAttrs, options) {
             const p = secondaryAssetUrl(itemAttrs, options, "preview");
             return p ? { preview: p } : {};
         })()),
-        ...(attribution && { author: attribution }),
+        ...(author && { author }),
         ...(description && { description }),
     };
 }
 
 // A video authored in markdown: `![alt](./demo.mp4){role=video …}`.
 //
-// Distinct from parseVideoBlock below, which reads the EDITOR's `Video` node
-// (`coverImg`, `info`). The two surfaces name the same concepts differently and
-// collapsing them would drop one side's spelling; this reader carries the
-// attribute set that docs/reference/content-structure.md publishes for the
-// video role, and the shape it documents: `{ src, href, target }` plus the
-// playback flags.
+// This reader carries the attribute set that docs/reference/content-structure.md
+// publishes for the video role, and the shape it documents: `{ src, href,
+// target }` plus the playback flags. ⛔ Until 2026-10-18 the editor's `Video`
+// node had a reader of its own, `parseVideoBlock`, and this one took the
+// editor's `url` and `info` too.
 function parseMarkdownVideo(itemAttrs, options) {
     const {
         src,
-        url,
-        info,
         poster,
         alt = "",
         caption = "",
@@ -1136,18 +890,11 @@ function parseMarkdownVideo(itemAttrs, options) {
         placement, // where it sits in a flow, same as parseImgBlock
     } = itemAttrs || {};
 
-    // Reference precedence, now genuinely identical to parseImgBlock: a
-    // resolvable store-held asset, then the legacy identifier, then the authored
-    // src/url.
-    //
-    // ⚠️ The comment here used to claim identifier-precedence "matching
-    // parseImgBlock" while the code did the opposite — it passed `src` INTO
-    // `makeAssetUrl`, which returns a src/url before it ever looks at
-    // `identifier`. So image and video resolved differently for years and the
-    // comment asserted they did not. Aligned to the documented intent (2026-08-17).
+    // Reference precedence, as parseImgBlock's: a resolvable store-held asset,
+    // then the address the node holds.
     const assetUrl = assetUrlFromAttrs(itemAttrs, options);
     const video = {
-        src: assetUrl || makeAssetUrl(info) || url || src || "",
+        src: assetUrl || src || "",
         alt,
         caption: stripTags(caption),
         role,
@@ -1172,33 +919,6 @@ function parseMarkdownVideo(itemAttrs, options) {
     return video;
 }
 
-function parseVideoBlock(itemAttrs, options) {
-    let {
-        src,
-        caption = "",
-        info = {},
-        coverImg = {},
-        alt,
-        href = "",
-        target = "",
-        placement, // where it sits in a flow; the editor's `direction` is not read
-    } = itemAttrs;
-
-    // Same precedence as parseImgBlock / parseMarkdownVideo: a resolvable
-    // store-held asset, then the legacy identifier, then the authored src.
-    const video = assetUrlFromAttrs(itemAttrs, options) || makeAssetUrl(info) || src || "";
-
-    return {
-        src: video,
-        caption,
-        coverImg: makeAssetUrl(coverImg),
-        alt,
-        href,
-        target,
-        ...(placement && { placement }),
-    };
-}
-
 function stripTags(htmlString) {
     if (!htmlString || typeof htmlString !== "string") return "";
 
@@ -1260,7 +980,7 @@ function isLink(item, options = {}) {
 
                 for (let i = 0; i < originalContent.length; i++) {
                     if (isIconNode(originalContent[i])) {
-                        const iconAttrs = parseUniwebIcon(originalContent[i].attrs);
+                        const iconAttrs = parseIcon(originalContent[i].attrs);
                         if (i < linkIndex) {
                             // Take the last icon before the link
                             iconBefore = iconAttrs;