@cudoment/cudoc 0.6.0 → 0.8.0

package/dist/node/resolve-embed.js

@@ -1,14 +1,33 @@
 import path from "node:path";
 import { fromHtml } from "hast-util-from-html";
 import { parse as parseYaml } from "yaml";
-import { collectSections } from "../sections.js";
+import { collectSections, } from "../sections.js";
 import { idToken, nodeText, visibleHeadingText, } from "../document.js";
 import { findHeadingByAnchorId, findParentHeading, getHeadingAnchorId, } from "../internal/core/query/sections.js";
+import { TREE_CLASS, TREE_KIND, TREE_PRINT_ATTRIBUTE } from "../paged.js";
 import { sourceFileOf } from "./roots.js";
+import { compareCodePoints, compareNames, documentName, hierarchyOf, nfc, } from "./tree.js";
+/**
+ * How a tree names and sorts documents, for a consumer that lists documents
+ * the way a tree embed does, such as an export's navigation.
+ */
+export { compareNames, documentName, nfc } from "./tree.js";
 import { parseSrcSet } from "./local-target.js";
 import { transformedSection } from "./replace.js";
 import { EXTERNAL_URL, decodeComponent, declaredIds, documentIndex, idsInNode, } from "./references.js";
 const SPEC_KEYS = ["sources", "select", "render", "replace"];
+const TABLE_KEYS = ["type", "columns"];
+const TREE_KEYS = [
+    "type",
+    "open",
+    "print",
+    "depth",
+    "headings",
+    "order",
+    "columns",
+];
+/** The `order` entry that stands for every name the list does not give. */
+const REST = "...";
 const SELECTION_KEYS = ["anchors", "titles", "depth", "includeChildren"];
 const REPLACEMENT_KEYS = ["find", "replace", "regex", "flags"];
 const COLUMN_KEYS = ["header", "value", "link", "minWidth"];
@@ -64,6 +83,38 @@ const validateColumn = (column, at) => {
             cell.skipTablesWithHeaders.some((h) => typeof h !== "string")))
         throw new Error(`cudoc: ${at}.value.skipTablesWithHeaders must be strings`);
 };
+const validateTree = (render) => {
+    const count = (key, least, most) => {
+        const value = render[key];
+        if (value === undefined)
+            return;
+        if (!Number.isInteger(value) ||
+            value < least ||
+            (most !== undefined && value > most))
+            throw new Error(`cudoc: render.${key} must be ${most === undefined
+                ? `an integer of at least ${least}`
+                : `an integer from ${least} to ${most}`}`);
+    };
+    count("open", 0);
+    count("print", 1);
+    count("depth", 1);
+    count("headings", 0, 5);
+    const order = render.order;
+    if (order === undefined)
+        return;
+    if (!Array.isArray(order) ||
+        order.some((name) => typeof name !== "string" || !name.trim()))
+        throw new Error("cudoc: render.order must be a list of names");
+    const seen = new Set();
+    for (const name of order) {
+        const key = nfc(name);
+        if (seen.has(key))
+            throw new Error(name === REST
+                ? `cudoc: render.order has ${REST} twice; it stands for every name not listed, once`
+                : `cudoc: render.order names "${name}" twice`);
+        seen.add(key);
+    }
+};
 export function parseEmbedSpec(value) {
     const spec = parseYaml(value, { maxAliasCount: 100 });
     if (!spec || typeof spec !== "object" || Array.isArray(spec))
@@ -79,16 +130,26 @@ export function parseEmbedSpec(value) {
         if (!spec.render ||
             typeof spec.render !== "object" ||
             Array.isArray(spec.render) ||
-            spec.render.type !== "table")
-            throw new Error('cudoc: render must be "section" or a mapping with type: table');
+            !["table", "tree"].includes(spec.render.type))
+            throw new Error('cudoc: render must be "section" or a mapping with type: table or type: tree');
+        const known = spec.render.type === "tree" ? TREE_KEYS : TABLE_KEYS;
         for (const key of Object.keys(spec.render))
-            if (!["type", "columns"].includes(key))
-                throw new Error(`cudoc: render: unknown key "${key}". Known keys: type, columns`);
+            if (!known.includes(key))
+                throw new Error(`cudoc: render: unknown key "${key}". Known keys: ${known.join(", ")}`);
         if (spec.render.columns !== undefined) {
             if (!Array.isArray(spec.render.columns) || !spec.render.columns.length)
                 throw new Error("cudoc: render.columns must be a non-empty array");
             spec.render.columns.forEach((column, index) => validateColumn(column, `render.columns[${index}]`));
         }
+        if (spec.render.type === "tree") {
+            validateTree(spec.render);
+            // A tree copies no section text, so neither would change anything,
+            // and an author who wrote one expects it to.
+            if (spec.select !== undefined)
+                throw new Error("cudoc: select does not apply to a tree; its levels come from folders, and render.headings adds sections");
+            if (spec.replace !== undefined)
+                throw new Error("cudoc: replace does not apply to a tree, which copies no section text");
+        }
     }
     if (spec.select) {
         if (typeof spec.select !== "object" || Array.isArray(spec.select))
@@ -165,7 +226,13 @@ export function parseEmbedBlock(value, documentId, number) {
         throw new Error(`cudoc: ${where}: ${message}`, { cause });
     }
 }
-export function resolveDocumentReference(library, reference, from) {
+/**
+ * What a source names, read without looking anything up: the library path it
+ * spells, relative to `from` or from the top with a leading `/`, and its
+ * anchor, percent-decoded. A URL, a backslash and a climb out of the library
+ * fail here.
+ */
+const sourcePath = (reference, from) => {
     const hash = reference.indexOf("#");
     const pathname = hash < 0 ? reference : reference.slice(0, hash);
     let anchor;
@@ -178,18 +245,66 @@ export function resolveDocumentReference(library, reference, from) {
     }
     if (/^[a-z][\w+.-]*:/i.test(pathname) || pathname.includes("\\"))
         throw new Error(`cudoc: embed source must be a local document: ${reference}`);
-    const id = (pathname
+    const target = pathname
         ? pathname.startsWith("/")
             ? pathname.slice(1)
             : path.posix.join(path.posix.dirname(from), pathname)
-        : from).replace(/\.mdx?$/i, "");
+        : from;
+    const id = target.replace(/\.mdx?$/i, "");
     if (id === ".." || id.startsWith("../"))
         throw new Error(`cudoc: embed source escapes root: ${reference}`);
+    return { pathname, target, ...(anchor === undefined ? {} : { anchor }) };
+};
+export function resolveDocumentReference(library, reference, from) {
+    const { target, anchor } = sourcePath(reference, from);
+    const id = target.replace(/\.mdx?$/i, "");
     const document = documentIndex(library).byId.get(id);
     if (!document)
         throw new Error(`cudoc: missing document ${reference} referenced from ${from}`);
     return { document, anchor };
 }
+/**
+ * Whether a tree on `page` lists private documents: only when the page is
+ * private itself. One that names no collected document counts as public.
+ */
+const listsPrivate = (library, page) => documentIndex(library).byId.get(page)?.private === true;
+/**
+ * Reads one source of a tree. A path ending in `/` names a folder, and the
+ * documents directly below it become the tree's first level; any other path
+ * names a document, or with `#anchor` one of its sections, as for any embed.
+ * Ids are matched in NFC, so a source names a document whose file name is
+ * stored in NFD. A folder holding no document fails, and so does a document
+ * path that is really a folder, with a hint to add the `/`. Given `page`,
+ * the document the tree lands on, a folder whose documents are all private
+ * fails too unless that page is private, since the tree leaves them out.
+ */
+export function resolveTreeSource(library, reference, from, page) {
+    const { pathname, target, anchor } = sourcePath(reference, from);
+    const hierarchy = hierarchyOf(library);
+    if (pathname.endsWith("/")) {
+        if (anchor !== undefined)
+            throw new Error(`cudoc: a folder source takes no anchor: ${reference}`);
+        const normal = path.posix.normalize(target || ".").replace(/\/+$/, "");
+        if (normal === ".." || normal.startsWith("../"))
+            throw new Error(`cudoc: embed source escapes root: ${reference}`);
+        const folder = normal === "." ? "" : normal;
+        const documents = hierarchy.below(folder);
+        if (!documents.length)
+            throw new Error(`cudoc: no documents in folder ${reference} referenced from ${from}`);
+        if (page !== undefined &&
+            !listsPrivate(library, page) &&
+            documents.every((document) => document.private))
+            throw new Error(`cudoc: folder ${reference} referenced from ${from} holds only private documents, which a tree on ${page} leaves out`);
+        return { folder, documents };
+    }
+    const id = target.replace(/\.mdx?$/i, "");
+    const document = documentIndex(library).byId.get(id) ?? hierarchy.document(id);
+    if (document)
+        return { document, ...(anchor === undefined ? {} : { anchor }) };
+    throw new Error(`cudoc: missing document ${reference} referenced from ${from}${hierarchy.below(path.posix.normalize(id)).length
+        ? `; a folder source ends with /, as in ${pathname}/`
+        : ""}`);
+}
 const visitNodes = (node, fn) => {
     fn(node);
     node.children?.forEach((n) => visitNodes(n, fn));
@@ -345,7 +460,7 @@ const rewriteAttributes = (tag, rewrite) => {
     }
     return result + tag.slice(index);
 };
-function rebase(tree, document, library, prefix, destination, moved) {
+function rebase(tree, document, library, prefix, destination, placed) {
     const ids = new Set();
     visitNodes(tree, (node) => {
         idsInNode(node).forEach((id) => ids.add(id));
@@ -398,25 +513,35 @@ function rebase(tree, document, library, prefix, destination, moved) {
         const target = documentIndex(library).byPath.get(absolute);
         return `${target?.route ?? absolute}${match[2]}`;
     };
-    // Every candidate of a responsive image is a path of its own; the width or
-    // density after it stays as written.
-    const sourceSrcSet = (value) => parseSrcSet(value)
-        .map(({ url, descriptor }) => [sourceUrl(url), descriptor].filter(Boolean).join(" "))
-        .join(", ");
+    // A node an inner copy already placed holds the page's addresses, and read
+    // as source paths again they could name another document, or climb from
+    // the wrong directory. Only a fragment naming an id this copy renames
+    // follows the new name.
+    const pageUrl = (url) => {
+        if (!url.startsWith("#"))
+            return url;
+        const id = decodeComponent(url.slice(1));
+        return ids.has(id) ? `#${prefix}${id}` : url;
+    };
     visitNodes(tree, (node) => {
+        const url = placed.has(node) ? pageUrl : sourceUrl;
+        // Every candidate of a responsive image is a path of its own; the width
+        // or density after it stays as written.
+        const srcSet = (value) => parseSrcSet(value)
+            .map(({ url: candidate, descriptor }) => [url(candidate), descriptor].filter(Boolean).join(" "))
+            .join(", ");
         const id = node.data?.hProperties?.id;
         if (typeof id === "string")
             node.data.hProperties.id = `${prefix}${id}`;
         if (typeof node.url === "string")
-            node.url = sourceUrl(node.url);
+            node.url = url(node.url);
         // An image a host made a component of is still an image of the source.
         const image = node.data?.cudocImage;
         if (image && typeof image.url === "string")
-            node.data.cudocImage = { ...image, url: sourceUrl(image.url) };
+            node.data.cudocImage = { ...image, url: url(image.url) };
         // Once per element, however deeply the copy was nested: an inner embed
         // already moved it from its own source to `destination`.
-        if (destination && Array.isArray(node.attributes) && !moved.has(node)) {
-            moved.add(node);
+        if (destination && Array.isArray(node.attributes) && !placed.has(node)) {
             directories ??= {
                 from: fileDirectory(library, document),
                 to: fileDirectory(library, destination),
@@ -439,17 +564,18 @@ function rebase(tree, document, library, prefix, destination, moved) {
                 : rewriteAttributes(tag, (name, value) => name === "id"
                     ? `${prefix}${value}`
                     : name === "srcset"
-                        ? sourceSrcSet(value)
+                        ? srcSet(value)
                         : REBASED_ATTRIBUTES.has(name)
-                            ? sourceUrl(value)
+                            ? url(value)
                             : undefined));
         const attrs = node.data?.hProperties;
         for (const key of ["href", "src", "poster", "data", "xLinkHref"])
             if (typeof attrs?.[key] === "string")
-                attrs[key] = sourceUrl(attrs[key]);
+                attrs[key] = url(attrs[key]);
         for (const key of ["srcSet", "srcset"])
             if (typeof attrs?.[key] === "string")
-                attrs[key] = sourceSrcSet(attrs[key]);
+                attrs[key] = srcSet(attrs[key]);
+        placed.add(node);
     });
 }
 /** The default columns of a summary table, as they have always been. */
@@ -514,7 +640,9 @@ const sectionTables = (tree, skipHeaders) => {
  * problem, which is worded as what the column asked for and what the section
  * has, so an author can tell a wrong coordinate from a missing table.
  */
-export function extractCell(library, column, row, context) {
+export function extractCell(library, column, row, context, 
+/** The tree line the cell is for, handed to an extractor. */
+node) {
     const spec = columnSpec(column);
     const where = `${row.document.id}${row.section.anchorId ? `#${row.section.anchorId}` : ""}`;
     const linkTo = () => {
@@ -556,6 +684,7 @@ export function extractCell(library, column, row, context) {
             library,
             documentId: context.documentId,
             column,
+            ...(node ? { node } : {}),
         });
         const text = typeof result === "string" ? result : result?.text;
         if (!text)
@@ -616,14 +745,292 @@ export function buildEmbedTable(library, columns, rows, context) {
         ],
     };
 }
+/** The default line of a tree: the title linked to its node, then the summary. */
+export const DEFAULT_TREE_COLUMNS = ["link", "summary"];
+/** Whether a column is computed by a registered function, which may read anything. */
+const usesExtractor = (columns) => columns.some((column) => typeof column === "object" &&
+    typeof column.value === "object" &&
+    "extractor" in column.value);
+/** Whether an `order` entry names a node: its name, or its title, in NFC. */
+export const namesTreeNode = (entry, node) => {
+    const name = nfc(entry);
+    return node.name === name || nfc(node.title) === name;
+};
+/**
+ * A document's `#` title, from the top-level block at `from` on: a `#`
+ * heading there, or one inside a top-level `header` element, where Docusaurus
+ * puts the heading it reads the page title from.
+ */
+const titleHeading = (tree, from = 0) => {
+    for (let index = from; index < tree.children.length; index++) {
+        const node = tree.children[index];
+        const heading = node.type === "heading"
+            ? node
+            : node.data?.hName === "header"
+                ? node.children?.find((child) => child.type === "heading")
+                : undefined;
+        if (heading?.depth === 1)
+            return {
+                heading: heading,
+                index,
+            };
+    }
+    return undefined;
+};
+/** Heading depths from `from` to the deepest `headings` reaches, `##` being 2. */
+const headingDepths = (from, headings) => {
+    const depths = [];
+    for (let depth = Math.max(from, 2); depth <= headings + 1; depth++)
+        depths.push(depth);
+    return depths;
+};
+/**
+ * The lines of a tree, without cells when `cells` is false, and every
+ * document they were read from.
+ */
+function buildTree(library, sources, render, from, context, cells = true) {
+    const hierarchy = hierarchyOf(library);
+    const depth = render.depth ?? Infinity;
+    const headings = render.headings ?? 0;
+    const columns = render.columns ?? DEFAULT_TREE_COLUMNS;
+    const rows = new Map();
+    const documents = new Set();
+    // A page that is not private lists no private document it was not asked
+    // for by name: a folder or a parent would otherwise put one on it, and the
+    // export, which leaves private documents out, could not link to it.
+    const privateListed = listsPrivate(library, context.documentId);
+    const listed = (document) => !document.private || privateListed;
+    const create = (row, kind, name, level) => {
+        documents.add(row.document.id);
+        const node = {
+            id: `${row.document.id}${row.section.anchorId ? `#${row.section.anchorId}` : ""}`,
+            kind,
+            documentId: row.document.id,
+            ...(row.section.anchorId ? { anchorId: row.section.anchorId } : {}),
+            name,
+            title: row.section.title,
+            url: row.url,
+            sourcePath: row.document.sourcePath,
+            level,
+            cells: [],
+            children: [],
+        };
+        rows.set(node, row);
+        return node;
+    };
+    /** The headings of `sections` nested by depth under a line at `level`. */
+    const nest = (document, sections, level) => {
+        const top = [];
+        // A heading past `depth` is still pushed, without a node, so the ones
+        // under it are left out with it rather than moved up a level.
+        const stack = [];
+        for (const section of sections) {
+            while (stack.length && stack.at(-1).depth >= section.heading.depth)
+                stack.pop();
+            const above = stack.at(-1);
+            const at = (above?.level ?? level) + 1;
+            const node = at <= depth && (!above || above.node)
+                ? headingNode(document, section, at)
+                : undefined;
+            stack.push({ depth: section.heading.depth, level: at, node });
+            if (node)
+                (above ? above.node.children : top).push(node);
+        }
+        return top;
+    };
+    const headingNode = (document, section, level) => {
+        const row = buildEmbedRow(document, section.anchorId, section.tree);
+        return create(row, "heading", nfc(row.section.title), level);
+    };
+    /** A section a source names, with the headings of its own below it. */
+    const sectionNode = (document, section) => {
+        const node = headingNode(document, section, 1);
+        const depths = headingDepths(section.heading.depth + 1, headings);
+        if (1 < depth && depths.length)
+            node.children = nest(document, collectSections(section.tree, { depth: depths }), 1);
+        return node;
+    };
+    const documentNode = (document, level) => {
+        // The `#` title is the line's title, and what follows it, up to the next
+        // `#`, is what the line summarizes; anything above it, such as an
+        // outliner's property lines, is not.
+        const tree = document.tree;
+        const found = titleHeading(tree);
+        const name = documentName(document.id);
+        const named = typeof document.frontmatter.title === "string"
+            ? document.frontmatter.title.trim()
+            : "";
+        const title = (found && visibleHeadingText(found.heading)) ||
+            named ||
+            name;
+        const node = create({
+            document,
+            section: {
+                title,
+                tree: found
+                    ? {
+                        ...tree,
+                        children: tree.children.slice(found.index, titleHeading(tree, found.index + 1)?.index),
+                    }
+                    : tree,
+            },
+            url: document.route,
+        }, "document", name, level);
+        if (level >= depth)
+            return node;
+        const sections = headings
+            ? nest(document, collectSections(tree, { depth: headingDepths(2, headings) }), level)
+            : [];
+        node.children = [
+            ...sections,
+            ...sorted(hierarchy
+                .children(document)
+                .filter(listed)
+                .map((child) => documentNode(child, level + 1))),
+        ];
+        return node;
+    };
+    const first = [];
+    for (const reference of sources) {
+        const source = resolveTreeSource(library, reference, from, context.documentId);
+        if ("folder" in source)
+            first.push(...sorted(source.documents
+                .filter(listed)
+                .map((document) => documentNode(document, 1))));
+        else if (source.anchor === undefined)
+            first.push(documentNode(source.document, 1));
+        else
+            first.push(...collectSections(source.document.tree, {
+                anchors: [source.anchor],
+            }).map((section) => sectionNode(source.document, section)));
+    }
+    let nodes = first;
+    if (render.order?.length) {
+        const order = render.order;
+        const rest = order.indexOf(REST);
+        const rank = (node) => {
+            const at = order.findIndex((entry, index) => index !== rest && namesTreeNode(entry, node));
+            return at >= 0 ? at : rest >= 0 ? rest : order.length;
+        };
+        nodes = first
+            .map((node, index) => ({ node, index, rank: rank(node) }))
+            .sort((a, b) => a.rank - b.rank || a.index - b.index)
+            .map(({ node }) => node);
+    }
+    if (cells) {
+        // Deepest first, so an extractor finds the lines below complete.
+        const fill = (node) => {
+            node.children.forEach(fill);
+            const row = rows.get(node);
+            node.cells = columns.map((column) => extractCell(library, column, row, context, node).cell);
+        };
+        nodes.forEach(fill);
+    }
+    return { nodes, documents };
+}
+/** Documents in the order a tree lists them: by title, then name, then id. */
+const sorted = (nodes) => nodes.sort((a, b) => compareNames(a.title, b.title) ||
+    compareNames(a.name, b.name) ||
+    compareCodePoints(a.id, b.id));
+/**
+ * The lines of a tree embed as data, the same lines the renderer draws, for
+ * a program that writes the tree in a form of its own, such as an outliner's
+ * blocks. `spec` is an embed whose render is a tree; sources resolve from
+ * `context.documentId`, which extractors also receive. Nodes come in the
+ * order the tree shows them, every level down to `depth`, whatever `open`
+ * and `print` say; equal input gives equal output, order and all.
+ */
+export function resolveTree(library, input, context) {
+    const spec = parseEmbedSpec(JSON.stringify(input));
+    if (typeof spec.render !== "object" || spec.render.type !== "tree")
+        throw new Error("cudoc: resolveTree needs an embed whose render is a tree");
+    return buildTree(library, spec.sources, spec.render, context.documentId, context).nodes;
+}
+/**
+ * The mdast a tree renders to: nested lists, an item with children wrapped
+ * in a `details` element whose `summary` is the item's line, open down to
+ * `open` levels. Portable elements only, so it works without a script on
+ * every host. The outer list carries the `cudoc-tree` class, `data.cudoc.kind`
+ * `tree` and, when `print` is set, `data-cudoc-print`, which the print HTML
+ * and Word read.
+ */
+export function buildEmbedTree(nodes, render) {
+    const open = render.open ?? 1;
+    const text = (value) => ({ type: "text", value });
+    const line = (node) => {
+        const shown = node.cells.filter((cell) => cell.text);
+        // A line has to say something: with every column empty, the title.
+        return {
+            type: "paragraph",
+            children: (shown.length ? shown : [{ text: node.title }]).flatMap((cell, index) => [
+                ...(index ? [text(" · ")] : []),
+                cell.url
+                    ? { type: "link", url: cell.url, children: [text(cell.text)] }
+                    : text(cell.text),
+            ]),
+        };
+    };
+    const list = (items, outer) => ({
+        type: "list",
+        ordered: false,
+        spread: false,
+        ...(outer
+            ? {
+                data: {
+                    hProperties: {
+                        className: [TREE_CLASS],
+                        ...(render.print ? { [TREE_PRINT_ATTRIBUTE]: render.print } : {}),
+                    },
+                    cudoc: { kind: TREE_KIND },
+                },
+            }
+            : {}),
+        children: items.map((node) => node.children.length
+            ? {
+                type: "listItem",
+                spread: false,
+                children: [
+                    {
+                        type: "blockquote",
+                        data: {
+                            hName: "details",
+                            ...(node.level <= open
+                                ? { hProperties: { open: true } }
+                                : {}),
+                        },
+                        children: [
+                            { ...line(node), data: { hName: "summary" } },
+                            list(node.children, false),
+                        ],
+                    },
+                ],
+            }
+            : {
+                type: "listItem",
+                spread: false,
+                data: { hProperties: { className: [`${TREE_CLASS}-leaf`] } },
+                children: [line(node)],
+            }),
+    });
+    return { type: "root", children: [list(nodes, true)] };
+}
 /** Resolve a configured embed from immutable persisted documents. */
 export function resolveEmbed(library, input, context) {
     const spec = parseEmbedSpec(JSON.stringify(input));
     let occurrence = 0;
     const reserved = new Set();
     const destination = documentIndex(library).byId.get(context.documentId);
-    // Elements whose required modules already start from `destination`.
-    const moved = new WeakSet();
+    // Nodes already on the page: those a copy rebased, whose paths and
+    // required modules now start from `destination`, and those a table or a
+    // tree wrote there. A copy around them renames their ids, and leaves the
+    // rest as it is.
+    const placed = new WeakSet();
+    const place = (root) => {
+        visitNodes(root, (node) => {
+            placed.add(node);
+        });
+        return root;
+    };
     if (destination)
         for (const id of declaredIds(destination.tree))
             reserved.add(id);
@@ -632,6 +1039,15 @@ export function resolveEmbed(library, input, context) {
     // block is still current; `*` when an extractor ran, which may read anything.
     const dependencies = new Set();
     const expand = (spec, from) => {
+        // A tree copies no section, so nothing in it expands or cycles; what it
+        // depends on is every document a line was read from.
+        if (typeof spec.render === "object" && spec.render.type === "tree") {
+            const tree = buildTree(library, spec.sources, spec.render, from, context);
+            tree.documents.forEach((id) => dependencies.add(id));
+            if (usesExtractor(spec.render.columns ?? DEFAULT_TREE_COLUMNS))
+                dependencies.add("*");
+            return place(buildEmbedTree(tree.nodes, spec.render));
+        }
         const children = [];
         const rows = [];
         for (const source of spec.sources) {
@@ -680,7 +1096,7 @@ export function resolveEmbed(library, input, context) {
                     do {
                         prefix = `${context.prefix ?? "embed"}-${++occurrence}-`;
                     } while (sectionIds.some((id) => reserved.has(`${prefix}${id}`)));
-                    rebase(section, document, library, prefix, destination, moved);
+                    rebase(section, document, library, prefix, destination, placed);
                     sectionIds.forEach((id) => reserved.add(`${prefix}${id}`));
                     children.push(...section.children);
                 }
@@ -691,11 +1107,9 @@ export function resolveEmbed(library, input, context) {
         }
         if (spec.render && spec.render !== "section") {
             const columns = spec.render.columns ?? DEFAULT_TABLE_COLUMNS;
-            if (columns.some((column) => typeof column === "object" &&
-                typeof column.value === "object" &&
-                "extractor" in column.value))
+            if (usesExtractor(columns))
                 dependencies.add("*");
-            return buildEmbedTable(library, columns, rows, context);
+            return place(buildEmbedTable(library, columns, rows, context));
         }
         return { type: "root", children };
     };