@mapled/cli 0.9.0 → 0.11.0

package/dist/scanHtml.d.ts

@@ -0,0 +1,38 @@
+import type { ScanResult } from "./scan.js";
+import type { Schema } from "./schema.js";
+/** `mapled scan` for a plain HTML site (§19.2, "@mapled/vanilla"): the
+    pages are the site's .html files, the bindings are what their
+    `data-mapled-*` attributes declare — read the way the runtime reads
+    them (packages/vanilla/src/runtime.ts, `compile`): a path starts at a
+    single from the document and at the record inside a list or a record,
+    an each repeats the items of a group, a <template> counts only as the
+    first one of a list or an each, a list or a record inside a repeated
+    template is never read. The target is the sink the attribute names —
+    `markdown` renders rich text, an <img> an image, `bind-href` a link —
+    so a field bound where it can't render shows as a mismatch. What the
+    runtime can't tell apart — an empty field and a misspelled key — the
+    scan can: it has the schema. Nothing on the page runs or leaves the
+    machine; only the manifest does, on `bindings push`. */
+export type HtmlElement = {
+    name: string;
+    attrs: Map<string, string>;
+    children: HtmlElement[];
+};
+/** The elements of a page and their attributes — parse5's tree (html5.ts),
+    a <template>'s children being its content. Built without recursion:
+    a page nests up to MAX_OPEN elements, deeper throws TooDeep. */
+export declare function parseHtml(text: string): HtmlElement;
+/** Where a file is served and the key its bindings start with:
+    index.html → "/" (index), blog/index.html → "/blog/" (blog/index),
+    post.html → "/post.html" (post). What sits in public/ is served from
+    the root, as static hosts and Vite serve it. A name a key can't spell
+    as it is — a space, a letter outside ASCII, too long — keeps what it
+    can and adds a hash of the file, so two files never share a key. */
+export declare function htmlPage(file: string): {
+    route: string;
+    key: string;
+};
+export declare function scanHtml(dir: string, opts: {
+    schema: Schema;
+    maxFiles?: number;
+}): Promise<ScanResult>;

package/dist/scanHtml.js

@@ -0,0 +1,519 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { MAX_OPEN, parseDocument, TooDeep } from "./html5.js";
+import { targetFor } from "./manifest.js";
+const HTML_NS = "http://www.w3.org/1999/xhtml";
+const MAX_DEPTH = MAX_OPEN;
+/** The elements of a page and their attributes — parse5's tree (html5.ts),
+    a <template>'s children being its content. Built without recursion:
+    a page nests up to MAX_OPEN elements, deeper throws TooDeep. */
+export function parseHtml(text) {
+    const root = { name: "#document", attrs: new Map(), children: [] };
+    const pending = [[parseDocument(text), root]];
+    for (let at = 0; at < pending.length; at++) {
+        const [node, into] = pending[at];
+        pending[at] = undefined;
+        for (let child = node.firstChild; child; child = child.nextSibling) {
+            if (child.tagName === undefined)
+                continue;
+            const attrs = new Map();
+            for (const a of child.attrs ?? [])
+                if (!a.namespace)
+                    attrs.set(a.name, a.value);
+            const el = { name: child.tagName, attrs, children: [] };
+            into.children.push(el);
+            const template = child.tagName === "template" && child.namespaceURI === HTML_NS;
+            pending.push([template && child.content ? child.content : child, el]);
+        }
+    }
+    return root;
+}
+/* ---- pages ---- */
+const SKIP_DIRS = new Set(["node_modules", "vendor", "dist", "build", "out", "coverage", "storybook-static", "mapled"]);
+const HTML_FILE = /\.html?$/i;
+async function listHtml(dir, max) {
+    const files = [];
+    let truncated = false;
+    const walk = async (rel, depth) => {
+        if (depth > 12)
+            return;
+        let entries;
+        try {
+            entries = await readdir(path.join(dir, rel), { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        for (const e of entries) {
+            const next = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory()) {
+                if (SKIP_DIRS.has(e.name) || e.name.startsWith("."))
+                    continue;
+                await walk(next, depth + 1);
+            }
+            else if (e.isFile() && HTML_FILE.test(e.name)) {
+                if (files.length >= max) {
+                    truncated = true;
+                    return;
+                }
+                files.push(next);
+            }
+        }
+    };
+    await walk("", 0);
+    return { files, truncated };
+}
+const hash8 = (text) => createHash("sha256").update(text).digest("hex").slice(0, 8);
+/** Where a file is served and the key its bindings start with:
+    index.html → "/" (index), blog/index.html → "/blog/" (blog/index),
+    post.html → "/post.html" (post). What sits in public/ is served from
+    the root, as static hosts and Vite serve it. A name a key can't spell
+    as it is — a space, a letter outside ASCII, too long — keeps what it
+    can and adds a hash of the file, so two files never share a key. */
+export function htmlPage(file) {
+    const served = file.replace(/^public\//, "");
+    const parts = served.split("/");
+    const base = parts[parts.length - 1];
+    const dirs = parts.slice(0, -1).map(encodeURIComponent);
+    const isIndex = /^index\.html?$/i.test(base);
+    const route = isIndex ? `/${dirs.map((d) => `${d}/`).join("")}` : `/${[...dirs, encodeURIComponent(base)].join("/")}`;
+    const bare = served.replace(/\.html$/, "");
+    if (/^[A-Za-z0-9][A-Za-z0-9._/-]{0,59}$/.test(bare))
+        return { route, key: bare };
+    const kept = bare.replace(/[^A-Za-z0-9._/-]/g, "-").slice(0, 51);
+    return { route, key: `${/^[A-Za-z0-9]/.test(kept) ? "" : "p"}${kept}-${hash8(served)}` };
+}
+/** A binding key within the manifest's 120 characters: a longer one
+    keeps its start and ends in a hash of the whole (the caller makes
+    sure two of them don't meet). */
+function boundKey(key) {
+    return key.length <= 120 ? key : `${key.slice(0, 111)}-${hash8(key)}`;
+}
+/** Why Mapled's Preview can't open a route, or null — the API's rules
+    (lib/recordRoutes.ts, previewPath) and the manifest's length. */
+const SAFE_PATH = /^\/[A-Za-z0-9._~!$&'()*+,;=:@%/[\]-]*(?:\?[A-Za-z0-9._~!$&'()*+,;=:@%/[\]-]*)?$/;
+function unusable(route) {
+    if (route.length > 200)
+        return "longer than 200 characters";
+    if (!SAFE_PATH.test(route) || route.includes("//") || route.includes(".."))
+        return `not a path Mapled opens`;
+    const query = route.indexOf("?");
+    if (query !== -1 && new URLSearchParams(route.slice(query + 1)).has("mapled-preview"))
+        return "mapled-preview is the parameter of Mapled's preview token";
+    return null;
+}
+/* ---- what the attributes declare ---- */
+const P = "data-mapled-";
+const KEY = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const SEGMENT = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+/** The runtime's path grammar (packages/vanilla/src/paths.ts). */
+function segmentsOf(text) {
+    const segments = text.trim().split(".");
+    if (segments.length > 8)
+        return null;
+    return segments.every((s) => SEGMENT.test(s)) ? segments : null;
+}
+/** The attributes the runtime fills (sinks.ts ATTRIBUTES). */
+const ATTRIBUTES = new Set(["href", "src", "alt", "title", "aria-label", "placeholder", "datetime"]);
+/** Field types the runtime renders in a sink the API's table doesn't
+    list for it (lib/bindings.ts COMPATIBLE): a yes or no becomes "true" or
+    "false" (paths.ts asText); a link template takes a string or a number,
+    percent-encoded (url.ts fillTemplate). They bind as the field's own
+    type, which Mapled grades as it is. Rich text, an image or a file the
+    runtime would show too — as raw Markdown or an asset id: those stay a
+    mismatch (Anton, 2026-09-23). */
+const ALSO_RENDERS = {
+    text: ["boolean"],
+    template: ["long_text", "number", "enum", "date", "datetime", "color"],
+};
+const effectiveType = (f) => f.computed?.resultType ?? f.type;
+/** A field by its key or a previous one (§33.5) — Mapled serves both. */
+const fieldOf = (collection, key) => collection?.fields.find((f) => f.key === key) ?? collection?.fields.find((f) => f.aliases?.includes(key));
+export async function scanHtml(dir, opts) {
+    const notes = [];
+    const max = opts.maxFiles ?? 2000;
+    const { files, truncated } = await listHtml(dir, max);
+    if (truncated)
+        notes.push(`Only the first ${max} HTML files were read.`);
+    const collections = new Map(opts.schema.collections.map((c) => [c.key, c]));
+    const found = new Map();
+    const pages = [];
+    const unknown = [];
+    const notSingles = [];
+    const bare = [];
+    const badPaths = [];
+    const nested = [];
+    const noTemplate = [];
+    const unusableRoutes = [];
+    const tooDeep = [];
+    const notGroups = [];
+    const seenRoutes = new Set();
+    const pageKeys = new Set();
+    for (const file of files) {
+        let text;
+        try {
+            text = await readFile(path.join(dir, file), "utf8");
+        }
+        catch {
+            continue;
+        }
+        // attribute names are case-insensitive: DATA-MAPLED-BIND is the same attribute
+        if (text.length > 2_000_000 || !/data-mapled-/i.test(text))
+            continue;
+        const { route: served, key: plainKey } = htmlPage(file);
+        if (seenRoutes.has(served))
+            continue;
+        let doc;
+        try {
+            doc = parseHtml(text);
+        }
+        catch (e) {
+            if (!(e instanceof TooDeep))
+                throw e;
+            tooDeep.push(file);
+            continue;
+        }
+        seenRoutes.add(served);
+        let pageKey = plainKey;
+        for (let n = 2; pageKeys.has(pageKey); n++)
+            pageKey = `${plainKey.slice(0, 51)}-${hash8(`${file}#${n}`)}`;
+        pageKeys.add(pageKey);
+        const at = (what) => `${what} (${file})`;
+        const routes = new Set();
+        /** reads of each collection so far — a record with none inside still reads its collection */
+        const reads = new Map();
+        const add = (route, b) => {
+            routes.add(route);
+            reads.set(b.collection, (reads.get(b.collection) ?? 0) + 1);
+            const uses = found.get(b.base) ?? { all: [], seen: new Set() };
+            const id = `${route}\n${b.target}\n${b.presence ? 1 : 0}`;
+            if (!uses.seen.has(id)) {
+                uses.seen.add(id);
+                uses.all.push({ ...b, route, file });
+            }
+            found.set(b.base, uses);
+        };
+        /** A path read in a scope: the binding it makes, or the note it earns. */
+        const use = (scope, route, path, sink) => {
+            const segments = segmentsOf(path);
+            if (!segments) {
+                badPaths.push(at(path.trim().slice(0, 40) || '""'));
+                return;
+            }
+            if (scope.kind === "group") {
+                if (scope.fields && !scope.fields.has(segments[0]))
+                    unknown.push(at(path.trim()));
+                return;
+            }
+            let collection;
+            let collectionKey;
+            let rest;
+            if (scope.kind === "page") {
+                if (segments.length < 2) {
+                    bare.push(at(path.trim()));
+                    return;
+                }
+                collectionKey = segments[0];
+                collection = collections.get(collectionKey);
+                if (collection && collection.kind !== "single") {
+                    notSingles.push(at(path.trim()));
+                    return;
+                }
+                rest = segments.slice(1);
+            }
+            else {
+                collectionKey = scope.collection;
+                collection = collections.get(collectionKey);
+                rest = segments;
+            }
+            const fieldKey = rest[0];
+            const field = fieldOf(collection, fieldKey);
+            // inside a list or a record of an unknown collection the collection is the note
+            if (scope.kind === "page" ? !collection || !field : collection !== undefined && !field)
+                unknown.push(at(path.trim()));
+            // a group's sub-field: the schema knows which there are
+            else if (field?.group && rest.length > 1 && !field.group.fields.some((f) => f.key === rest[1]))
+                unknown.push(at(path.trim()));
+            // an each repeats a group's items: the runtime refuses anything else with "type"
+            else if (sink === "each" && field && rest.length === 1 && !field.group && !["json", "location"].includes(effectiveType(field)))
+                notGroups.push(at(path.trim()));
+            add(route, {
+                base: `${pageKey}:${collectionKey}.${fieldKey}`,
+                collection: collectionKey,
+                field: fieldKey,
+                target: targetOf(sink, field, rest.length),
+                natural: field ? targetFor(effectiveType(field)) : "other",
+                ...(sink === "presence" ? { presence: true } : {}),
+            });
+        };
+        /** The attributes an element declares for itself. */
+        const own = (el, scope, route) => {
+            const bind = el.attrs.get(`${P}bind`);
+            if (bind !== undefined)
+                use(scope, route, bind, bindSink(el));
+            for (const [name, value] of el.attrs) {
+                if (!name.startsWith(`${P}bind-`))
+                    continue;
+                const attr = name.slice(P.length + 5);
+                if (ATTRIBUTES.has(attr))
+                    use(scope, route, value, attributeSink(el.name, attr));
+            }
+            for (const name of ["show", "hide"]) {
+                const value = el.attrs.get(`${P}${name}`);
+                if (value !== undefined)
+                    use(scope, route, value, "presence");
+            }
+            const link = el.attrs.get(`${P}link`);
+            if (link !== undefined)
+                for (const m of link.matchAll(/\{([^{}]*)\}/g))
+                    use(scope, route, m[1], "template");
+        };
+        /** A list: the collection, and the fields of its first template. The
+            runtime reads every list of the page from the document, wherever
+            it sits — the page's own route. */
+        const readList = (el, collectionKey, depth) => {
+            add(served, { base: `${pageKey}:${collectionKey}`, collection: collectionKey, target: "collection", natural: "collection" });
+            const template = el.children.find((c) => c.name === "template");
+            if (!template)
+                noTemplate.push(at(collectionKey));
+            else
+                for (const c of template.children)
+                    visit(c, { kind: "record", collection: collectionKey }, served, true, false, depth + 1);
+        };
+        /** A record inside a record isn't read — but the lists inside it are:
+            the runtime lifts them to the page (runtime.ts, compile). */
+        const liftLists = (el, depth) => {
+            if (depth > MAX_DEPTH)
+                return;
+            for (const c of el.children) {
+                if (c.name === "template" || c.attrs.has(`${P}each`) && !c.attrs.has(`${P}list`) && !c.attrs.has(`${P}record`))
+                    continue;
+                const list = c.attrs.get(`${P}list`);
+                const record = c.attrs.get(`${P}record`);
+                if (list === undefined && record === undefined) {
+                    liftLists(c, depth + 1);
+                    continue;
+                }
+                const collectionKey = (list ?? record ?? "").trim();
+                if (!KEY.test(collectionKey))
+                    badPaths.push(at(collectionKey.slice(0, 40) || '""'));
+                else if (list !== undefined) {
+                    if (!collections.has(collectionKey))
+                        unknown.push(at(collectionKey));
+                    readList(c, collectionKey, depth);
+                }
+                else {
+                    nested.push(at(collectionKey));
+                    liftLists(c, depth + 1);
+                }
+            }
+        };
+        const visit = (el, scope, route, inTemplate, inRecord, depth) => {
+            if (depth > MAX_DEPTH || el.name === "template")
+                return;
+            const list = el.attrs.get(`${P}list`);
+            const record = el.attrs.get(`${P}record`);
+            const each = el.attrs.get(`${P}each`);
+            if (list !== undefined || record !== undefined) {
+                const collectionKey = (list ?? record ?? "").trim();
+                if (inTemplate) {
+                    nested.push(at(collectionKey || el.name));
+                    return;
+                }
+                if (!KEY.test(collectionKey)) {
+                    badPaths.push(at(collectionKey.slice(0, 40) || '""'));
+                    return;
+                }
+                if (list === undefined && inRecord) {
+                    nested.push(at(collectionKey));
+                    liftLists(el, depth + 1);
+                    return;
+                }
+                if (!collections.has(collectionKey))
+                    unknown.push(at(collectionKey));
+                if (list !== undefined)
+                    return readList(el, collectionKey, depth);
+                // one record for what is inside: its own attributes and its children,
+                // at the address the record is read from
+                const param = el.attrs.get(`${P}slug-param`);
+                const slugField = slugFieldOf(collections.get(collectionKey));
+                const byQuery = param !== undefined && el.attrs.get(`${P}slug`) === undefined;
+                // the runtime reads the parameter by its exact name
+                const address = byQuery ? `${served}?${encodeURIComponent(param)}=[${slugField ?? "slug"}]` : served;
+                const inner = { kind: "record", collection: collectionKey };
+                const before = reads.get(collectionKey) ?? 0;
+                own(el, inner, address);
+                for (const c of el.children)
+                    visit(c, inner, address, false, true, depth + 1);
+                if (byQuery) {
+                    add(address, { base: `${pageKey}:${collectionKey}[route]`, collection: collectionKey, ...(slugField ? { field: slugField } : {}), target: "route_param", natural: "route_param" });
+                }
+                else if ((reads.get(collectionKey) ?? 0) === before) {
+                    // one fixed record, not the collection: Mapled offers a page for any record only when it lists them
+                    add(address, { base: `${pageKey}:${collectionKey}`, collection: collectionKey, target: "other", natural: "other" });
+                }
+                return;
+            }
+            if (each !== undefined) {
+                use(scope, route, each, "each");
+                const template = el.children.find((c) => c.name === "template");
+                if (!template) {
+                    noTemplate.push(at(each.trim()));
+                    return;
+                }
+                const items = { kind: "group", fields: groupFields(scope, each) };
+                for (const c of template.children)
+                    visit(c, items, route, true, inRecord, depth + 1);
+                return;
+            }
+            own(el, scope, route);
+            for (const c of el.children)
+                visit(c, scope, route, inTemplate, inRecord, depth + 1);
+        };
+        /** The sub-fields of the group an each repeats, when the schema says. */
+        const groupFields = (scope, each) => {
+            const segments = segmentsOf(each);
+            if (!segments)
+                return null;
+            let field;
+            if (scope.kind === "page" && segments.length === 2)
+                field = fieldOf(collections.get(segments[0]), segments[1]);
+            else if (scope.kind === "record" && segments.length === 1)
+                field = fieldOf(collections.get(scope.collection), segments[0]);
+            return field?.group ? new Set(field.group.fields.map((f) => f.key)) : null;
+        };
+        // the runtime's root is the document element: its own attributes, then what is inside
+        const html = doc.children.find((c) => c.name === "html");
+        if (html) {
+            own(html, { kind: "page" }, served);
+            for (const c of html.children)
+                visit(c, { kind: "page" }, served, false, false, 1);
+        }
+        if (routes.size === 0)
+            routes.add(served);
+        for (const route of routes) {
+            const why = unusable(route);
+            if (why)
+                unusableRoutes.push(`${route} (${file}: ${why})`);
+            pages.push({ route, file });
+        }
+    }
+    const list = (items) => {
+        const unique = [...new Set(items)];
+        return `${unique.slice(0, 5).join(", ")}${unique.length > 5 ? ", …" : ""}`;
+    };
+    const count = (items) => new Set(items).size;
+    if (unknown.length > 0) {
+        notes.push(`${count(unknown) === 1 ? "This path names" : "These paths name"} nothing in the schema: ${list(unknown)}. A misspelled field empties its place on the page, a misspelled single leaves the page's own HTML.`);
+    }
+    if (bare.length > 0)
+        notes.push(`Outside a list, an each or a record a path starts with a single's key (home.headline): ${list(bare)}.`);
+    if (notSingles.length > 0)
+        notes.push(`A collection is read with data-mapled-list or data-mapled-record, not from the document: ${list(notSingles)}.`);
+    if (badPaths.length > 0)
+        notes.push(`Not a Mapled path or key: ${list(badPaths)}.`);
+    if (nested.length > 0)
+        notes.push(`A list or a record inside a repeated template, or a record inside a record, isn't read: ${list(nested)}.`);
+    if (notGroups.length > 0)
+        notes.push(`An each repeats the items of a group — ${count(notGroups) === 1 ? "this field isn't one" : "these fields aren't"}: ${list(notGroups)}.`);
+    if (noTemplate.length > 0)
+        notes.push(`A list or an each without a <template> isn't filled: ${list(noTemplate)}.`);
+    if (tooDeep.length > 0)
+        notes.push(`Elements nest deeper than ${MAX_OPEN} levels, so the scan didn't read ${count(tooDeep) === 1 ? "this page" : "these pages"}: ${list(tooDeep)}.`);
+    if (unusableRoutes.length > 0)
+        notes.push(`Preview can't open ${count(unusableRoutes) === 1 ? "this address" : "these addresses"} — rename the file or the slug parameter: ${list(unusableRoutes)}.`);
+    // keys within the manifest's 120 characters, and still one per binding
+    const keyed = [...found].flatMap(([base, { all }]) => variants(base, all)).sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+    const used = new Set(keyed.filter((b) => b.key.length <= 120).map((b) => b.key));
+    const bindings = keyed.map((b) => {
+        if (b.key.length <= 120)
+            return b;
+        let key = boundKey(b.key);
+        for (let n = 2; used.has(key); n++)
+            key = boundKey(`${b.key}#${n}`);
+        used.add(key);
+        return { ...b, key };
+    });
+    const sortedPages = pages.sort((a, b) => (a.route < b.route ? -1 : a.route > b.route ? 1 : 0));
+    const sortedBindings = bindings.sort((a, b) => a.page < b.page ? -1 : a.page > b.page ? 1 : a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+    return { framework: "plain-html", parser: "html", files: files.length, pages: sortedPages, bindings: sortedBindings, notes };
+}
+/** The bindings of one key: every distinct way the page reads the field
+    — a date format on a short text is a mismatch even when an <h1> reads
+    the same field well — whatever the order of the HTML. The field's
+    own target keeps the plain key. Being shown or hidden by a field adds
+    nothing where the same address reads it otherwise too — an each does
+    (it can fail on its own). Keys are full length here: the caller
+    bounds them. */
+function variants(base, all) {
+    const read = new Set(all.filter((f) => !f.presence).map((f) => f.route));
+    const readAs = new Set(all.filter((f) => !f.presence).map((f) => `${f.route}\n${f.target}`));
+    const kept = all.filter((f) => !f.presence || !(f.target === "other" ? read.has(f.route) : readAs.has(`${f.route}\n${f.target}`)));
+    const rank = (f) => (f.target === f.natural ? 0 : 1);
+    kept.sort((a, b) => rank(a) - rank(b) || (a.route < b.route ? -1 : a.route > b.route ? 1 : 0) || (a.target < b.target ? -1 : a.target > b.target ? 1 : 0));
+    const targets = new Map();
+    for (const f of kept)
+        targets.set(f.target, (targets.get(f.target) ?? 0) + 1);
+    return kept.map((f, i) => {
+        const key = i === 0 ? base : targets.get(f.target) === 1 ? `${base}[${f.target}]` : `${base}[${i + 1}]`;
+        return {
+            key,
+            page: f.route,
+            file: f.file,
+            collection: f.collection,
+            ...(f.field !== undefined ? { field: f.field } : {}),
+            target: f.target,
+        };
+    });
+}
+const slugFieldOf = (collection) => collection?.fields.find((f) => f.type === "slug")?.key;
+/** What `data-mapled-bind` renders on this element. */
+function bindSink(el) {
+    if (el.name === "img")
+        return "image";
+    switch (el.attrs.get(`${P}format`)) {
+        case "markdown":
+            return "rich_text";
+        case "date":
+        case "datetime":
+            return "date";
+        case "number":
+            return "number";
+        default:
+            return "text";
+    }
+}
+function attributeSink(element, attr) {
+    switch (attr) {
+        case "href":
+            return "link";
+        case "src":
+            return element === "img" ? "image" : "link";
+        case "alt":
+            return "image_alt";
+        case "datetime":
+            return "date";
+        default:
+            return "text";
+    }
+}
+/** The binding's target: the sink, for a value read at the field itself.
+    Deeper paths (a group's sub-field, a linked record's field) and eaches
+    bind the field as a whole — Mapled grades those as it can't check. */
+function targetOf(sink, field, depth) {
+    if (sink === "each" || depth > 1)
+        return "other";
+    const type = field ? effectiveType(field) : undefined;
+    if (sink === "presence")
+        return type === "boolean" ? "boolean" : "other";
+    const target = sink === "template" ? "link" : sink;
+    if (!type)
+        return target;
+    // a relation or a group bound directly has no single value to render
+    const natural = targetFor(type);
+    if (natural === "other")
+        return "other";
+    return ALSO_RENDERS[sink]?.includes(type) ? natural : target;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mapled/cli",
-  "version": "0.9.0",
-  "description": "Mapled CLI — sign in, link a project, generate TypeScript types for its content, create forms and check the site's integration.",
+  "version": "0.11.0",
+  "description": "Mapled CLI — sign in, link a project, generate TypeScript types for its content, create forms, preview drafts and check the site's integration.",
   "license": "MIT",
   "homepage": "https://mapled.io",
   "keywords": [
@@ -23,13 +23,15 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node build.mjs",
     "test": "vitest run",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "prepare": "npm run build"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
+    "esbuild": "^0.28.2",
+    "parse5": "7.3.0",
     "typescript": "^5.9.0",
     "vitest": "^4.1.11"
   }