@mapled/cli 0.9.0 → 0.10.0

package/dist/licenses/entities.LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) Felix Böhm
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/dist/licenses/parse5.LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013-2019 Ivan Nikulin (ifaaan@gmail.com, https://github.com/inikulin)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/scan.d.ts

@@ -32,7 +32,7 @@ export type Read = {
 };
 export type ScanResult = {
     framework: string | null;
-    parser: "typescript" | "tokens";
+    parser: "typescript" | "tokens" | "html";
     files: number;
     pages: ManifestPage[];
     bindings: ManifestBinding[];

package/dist/scan.js

@@ -1200,7 +1200,10 @@ export async function scanRepository(dir, opts) {
                     ...(read.component ? { component: read.component } : {}),
                     file: relFile(read.file),
                     collection: read.collection,
-                    target: "collection",
+                    // a list shows any record of the collection, a single is its one record; one read
+                    // record of a collection is that record — Mapled doesn't offer the page as the
+                    // Preview of another (recordRoutes.ts)
+                    target: isList || read.method === "getSingle" ? "collection" : "other",
                 });
             }
             if (read.bySlug && /\[[^\]]+\]/.test(page)) {

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,6 +1,6 @@
 {
   "name": "@mapled/cli",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Mapled CLI — sign in, link a project, generate TypeScript types for its content, create forms and check the site's integration.",
   "license": "MIT",
   "homepage": "https://mapled.io",
@@ -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"
   }