@avocadostudio-ai/shared 0.3.3 → 0.5.0

package/dist/editable-coverage.js

@@ -0,0 +1,368 @@
+/**
+ * Which editable fields does a rendered preview actually offer?
+ *
+ * The overlay finds every job it does by walking `[data-editable-target]`, so a
+ * field the site never marked is a field with no inline editing, no hover pill
+ * and — for an image — no Change button. Nothing about that is visible: the
+ * property panel is built from this same manifest and never looks at the page,
+ * so an unmarked field still appears there, still edits, and still saves. The
+ * preview simply offers less than the panel does, quietly and forever.
+ *
+ * `missingEditableTargetsWarning` in preview-adapter catches the all-or-nothing
+ * case at runtime. This is the graded one, and it is the case that actually
+ * recurs: instrumentation is per-component work spread over a dozen files, so
+ * it gets done on one branch, not merged, and re-lost on the next. The symptom
+ * is always a single missing button, reported as a bug in the button.
+ *
+ * The manifest already knows every editable field of every block type, and the
+ * rendered page already carries the block type on each wrapper. Nothing further
+ * is needed to answer the question exactly — only somebody asking it, which is
+ * what this is for: an integrator asserts on it in their own test suite, and a
+ * branch that drops the markers goes red instead of going quiet.
+ */
+import { resolveManifestFieldMeta } from "./block-manifest.js";
+/**
+ * The field kinds a marker is expected for: the ones something on the page
+ * *draws*.
+ *
+ * A renderer emits `data-editable-target` for an element, and only these three
+ * are elements. `enum`, `boolean`, `number`, `color` and `headingLevel` are
+ * settings — they change how something looks rather than being a thing on the
+ * page. `url`, `link` and `file` are attributes on an anchor whose *label* is
+ * the text field next to them, and `imageAlt` is an attribute on the image. A
+ * checker that demanded markers for those would report gaps that cannot be
+ * closed, which is the fastest way to get a checker ignored.
+ */
+const DRAWN_KINDS = new Set(["text", "richtext", "image"]);
+/**
+ * Does this field need an element marked for it?
+ *
+ * `inlineEditable: false` on a text field is the site saying the string is not
+ * something anybody edits on the page — an anchor id, a slug fragment, a
+ * machine value that happens to be typed as text. Honouring it is what keeps
+ * this checker worth reading: PBA declares seven of those, and counting them as
+ * gaps would have made the first report 16% instead of 19% and every one of the
+ * extra findings unfixable.
+ *
+ * It is not consulted for images. There, "inline editable" means typing into
+ * it, which nobody does to a photo; the marker is what carries the Change
+ * button, and the panel offering one is the site saying the image is editable.
+ */
+function needsMarker(meta) {
+    // The site has said outright that nothing on the page draws this — a
+    // `sectionId`, a `<video poster>`, an input's `placeholder`. See `panelOnly`.
+    if (meta.panelOnly)
+        return false;
+    if (!DRAWN_KINDS.has(meta.kind))
+        return false;
+    if (meta.kind === "image")
+        return true;
+    return meta.inlineEditable !== false;
+}
+/**
+ * Elements that cannot contain anything.
+ *
+ * The overlay mounts its image Change button by *appending it into* the marked
+ * element, so a marker on an `<img>` is inert — the attribute is in the HTML,
+ * the editor finds the field, and no button can ever appear. It looks
+ * instrumented from every angle except the one that matters, and this package's
+ * own Card and Hero renderers both did it on their full-bleed variants.
+ */
+const VOID_ELEMENTS = new Set([
+    "area", "base", "br", "col", "embed", "hr", "img", "input",
+    "link", "meta", "param", "source", "track", "wbr",
+]);
+/** One element: its tag name, and the raw attribute text, quotes respected. */
+const TAG_RE = /<([a-zA-Z][\w-]*)((?:"[^"]*"|'[^']*'|[^>"'])*)>/g;
+const BLOCK_ID_RE = /\bdata-block-id="([^"]*)"/;
+const BLOCK_TYPE_RE = /\bdata-block-type="([^"]*)"/;
+const TARGET_RE = /\bdata-editable-target="([^"]*)"/;
+/**
+ * Read the marked blocks out of a rendered page's HTML.
+ *
+ * A linear scan: each `data-editable-target` belongs to the most recently seen
+ * block. That is exact when block wrappers are siblings, which is the contract
+ * `getPreviewWrapperProps` describes — one wrapper per block, not nested. A
+ * site that nests blocks inside blocks will see inner fields attributed to the
+ * outer one; it would also confuse the overlay's own `closest()` walk, so it is
+ * out of contract on both ends rather than a limitation of this function.
+ */
+export function extractMarkedBlocks(html) {
+    const blocks = [];
+    let current = null;
+    for (const match of html.matchAll(TAG_RE)) {
+        const tag = match[1].toLowerCase();
+        const attrs = match[2] ?? "";
+        const blockId = BLOCK_ID_RE.exec(attrs)?.[1];
+        const blockType = BLOCK_TYPE_RE.exec(attrs)?.[1];
+        if (blockId !== undefined || blockType !== undefined) {
+            current = {
+                blockType: blockType ?? "",
+                ...(blockId !== undefined ? { blockId } : {}),
+                paths: [],
+            };
+            blocks.push(current);
+        }
+        const target = TARGET_RE.exec(attrs)?.[1];
+        if (target !== undefined && current) {
+            current.paths.push(target);
+            if (VOID_ELEMENTS.has(tag))
+                (current.voidPaths ??= []).push(target);
+        }
+    }
+    return blocks;
+}
+/** Does this prop hold anything a renderer would draw? */
+function hasContent(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (typeof value === "string")
+        return value.trim() !== "";
+    if (Array.isArray(value))
+        return value.length > 0;
+    return true;
+}
+/** `cards[2].title` → `cards[].title`; anything else unchanged. */
+function generalizeIndex(path) {
+    return path.replace(/\[\d+\]/g, "[]");
+}
+/**
+ * Is this field marked — at its own path, or at a finer one inside it?
+ *
+ * A prop the manifest calls `buttons` is not always drawn as one element. A
+ * renderer that maps over it and marks `buttons[].label` on each button has
+ * instrumented that field *better* than a single marker on the container would,
+ * and reporting it as missing is the kind of unclosable finding that gets a
+ * checker ignored. Villa hit exactly this, and it was one of the six gaps that
+ * kept its report off 100%.
+ *
+ * The prefix test is on `key[` and `key.` rather than on `key`, so `title` is
+ * not counted as covering `titleColor`.
+ */
+function isCovered(key, paths) {
+    if (paths.has(key))
+        return true;
+    for (const path of paths) {
+        if (path.startsWith(`${key}[`) || path.startsWith(`${key}.`))
+            return true;
+    }
+    return false;
+}
+/**
+ * The item fields a list is expected to have markers for, given what is in it.
+ *
+ * Two refinements of "every field the manifest declares for this list", both
+ * for the same reason the top-level fields already consult `props`: an element
+ * that was never drawn cannot carry a marker, and reporting it is a finding
+ * nobody can act on.
+ *
+ * 1. A field no item has a value for is not expected. `imageUrl` is optional on
+ *    every card block here, and a page whose cards are all text would otherwise
+ *    report a missing image marker on every one of them.
+ *
+ * 2. When the list is polymorphic — `discriminator` plus `itemFieldsByType`,
+ *    the shape a `oneOf` schema derives and a permissive one has to declare —
+ *    each item is measured against *its own* branch. TwoColumn is the case: a
+ *    `type: "image"` child has `src` and `alt` and no `label`, and asking it for
+ *    a button label is asking the renderer to draw a field the item does not
+ *    have.
+ *
+ * With no props in hand there is nothing to narrow by, so every declared field
+ * is expected — the behaviour before this existed.
+ */
+function expectedItemFields(listMeta, items) {
+    /*
+     * The discriminator is never content. It decides which shape the item is —
+     * `derivePolymorphicListField` deletes it from every branch it builds for
+     * exactly that reason — and a list whose metadata was declared rather than
+     * derived has nothing doing the same, so a `type` typed as a plain string
+     * arrives here looking like an ordinary text field nobody marked.
+     */
+    const isContent = ([key, meta]) => key !== listMeta.discriminator && needsMarker(meta);
+    const declared = Object.entries(listMeta.itemFields ?? {}).filter(isContent);
+    if (!items)
+        return declared;
+    const expected = new Map();
+    for (const raw of items) {
+        if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+            continue;
+        const item = raw;
+        const branchKey = listMeta.discriminator ? String(item[listMeta.discriminator] ?? "") : "";
+        const fields = listMeta.itemFieldsByType?.[branchKey] ?? listMeta.itemFields ?? {};
+        for (const entry of Object.entries(fields)) {
+            if (!isContent(entry))
+                continue;
+            if (!hasContent(item[entry[0]]))
+                continue;
+            expected.set(entry[0], entry[1]);
+        }
+    }
+    return [...expected];
+}
+export function editableCoverage(manifest, blocks) {
+    const definitions = new Map(manifest.blocks.map((block) => [block.type, block]));
+    // Aggregate by type: a missing marker is a property of the component, not of
+    // the one instance that happened to render first.
+    const pathsByType = new Map();
+    const exampleIdByType = new Map();
+    const unknownBlockTypes = new Set();
+    /*
+     * Props that at least one instance of a type actually had. Only consulted
+     * when some instance supplied props at all — a caller that passes none gets
+     * the old behaviour, where every declared field is expected.
+     */
+    const filledByType = new Map();
+    const sawPropsForType = new Set();
+    const voidByType = new Map();
+    /** Every list item seen for a type, by list key — what `expectedItemFields` narrows by. */
+    const listItemsByType = new Map();
+    for (const block of blocks) {
+        if (!block.blockType)
+            continue;
+        if (!definitions.has(block.blockType)) {
+            unknownBlockTypes.add(block.blockType);
+            continue;
+        }
+        let paths = pathsByType.get(block.blockType);
+        if (!paths) {
+            paths = new Set();
+            pathsByType.set(block.blockType, paths);
+            if (block.blockId)
+                exampleIdByType.set(block.blockType, block.blockId);
+        }
+        for (const path of block.paths)
+            paths.add(generalizeIndex(path));
+        if (block.voidPaths?.length) {
+            let voids = voidByType.get(block.blockType);
+            if (!voids) {
+                voids = new Set();
+                voidByType.set(block.blockType, voids);
+            }
+            for (const path of block.voidPaths)
+                voids.add(generalizeIndex(path));
+        }
+        if (!block.props)
+            continue;
+        sawPropsForType.add(block.blockType);
+        let filled = filledByType.get(block.blockType);
+        if (!filled) {
+            filled = new Set();
+            filledByType.set(block.blockType, filled);
+        }
+        let lists = listItemsByType.get(block.blockType);
+        if (!lists) {
+            lists = new Map();
+            listItemsByType.set(block.blockType, lists);
+        }
+        for (const [key, value] of Object.entries(block.props)) {
+            if (hasContent(value))
+                filled.add(key);
+            if (Array.isArray(value)) {
+                const seen = lists.get(key);
+                if (seen)
+                    seen.push(...value);
+                else
+                    lists.set(key, [...value]);
+            }
+        }
+    }
+    let expected = 0;
+    let marked = 0;
+    const gaps = [];
+    for (const [blockType, paths] of pathsByType) {
+        const definition = definitions.get(blockType);
+        const { fields, listFields } = resolveManifestFieldMeta(definition);
+        const missing = [];
+        const missingItemFields = [];
+        const unmarkedLists = [];
+        const voids = voidByType.get(blockType) ?? new Set();
+        const markedOnVoidElement = [];
+        const knowsContent = sawPropsForType.has(blockType);
+        const filled = filledByType.get(blockType) ?? new Set();
+        for (const [key, meta] of Object.entries(fields)) {
+            if (!needsMarker(meta))
+                continue;
+            // Nothing drew it, so nothing could have marked it.
+            if (knowsContent && !filled.has(key))
+                continue;
+            expected += 1;
+            if (!isCovered(key, paths)) {
+                missing.push(key);
+            }
+            else if (meta.kind === "image" && voids.has(key)) {
+                // Marked, found by the editor, and unable to hold the button.
+                markedOnVoidElement.push(key);
+            }
+            else {
+                marked += 1;
+            }
+        }
+        for (const [listKey, listMeta] of Object.entries(listFields)) {
+            const listPresent = [...paths].some((path) => path.startsWith(`${listKey}[]`));
+            const drawnItemFields = expectedItemFields(listMeta, knowsContent ? (listItemsByType.get(blockType)?.get(listKey) ?? []) : undefined);
+            if (drawnItemFields.length === 0)
+                continue;
+            // An empty list on every page is not an instrumentation question either,
+            // and with props in hand we can say so instead of guessing.
+            if (knowsContent && !filled.has(listKey))
+                continue;
+            if (!listPresent) {
+                // Could be an empty list on this page. Not counted against coverage.
+                unmarkedLists.push(listKey);
+                continue;
+            }
+            for (const [itemKey, itemMeta] of drawnItemFields) {
+                const path = `${listKey}[].${itemKey}`;
+                expected += 1;
+                if (!paths.has(path)) {
+                    missingItemFields.push(path);
+                }
+                else if (itemMeta.kind === "image" && voids.has(path)) {
+                    markedOnVoidElement.push(path);
+                }
+                else {
+                    marked += 1;
+                }
+            }
+        }
+        if (missing.length > 0 ||
+            missingItemFields.length > 0 ||
+            unmarkedLists.length > 0 ||
+            markedOnVoidElement.length > 0) {
+            const exampleBlockId = exampleIdByType.get(blockType);
+            gaps.push({
+                blockType,
+                ...(exampleBlockId ? { exampleBlockId } : {}),
+                missing,
+                missingItemFields,
+                unmarkedLists,
+                markedOnVoidElement,
+            });
+        }
+    }
+    return { expected, marked, gaps, unknownBlockTypes: [...unknownBlockTypes] };
+}
+/** A report a person can read in a terminal. */
+export function formatEditableCoverage(report) {
+    const lines = [];
+    const pct = report.expected === 0 ? 100 : Math.round((report.marked / report.expected) * 100);
+    lines.push(`editable fields marked: ${report.marked}/${report.expected} (${pct}%)`);
+    for (const gap of report.gaps) {
+        const where = gap.exampleBlockId ? ` (e.g. ${gap.exampleBlockId})` : "";
+        lines.push(`  ${gap.blockType}${where}`);
+        for (const key of gap.missing)
+            lines.push(`    unmarked  ${key}`);
+        for (const key of gap.missingItemFields)
+            lines.push(`    unmarked  ${key}`);
+        for (const key of gap.markedOnVoidElement) {
+            lines.push(`    marked on a void element (no button can mount)  ${key}`);
+        }
+        for (const key of gap.unmarkedLists) {
+            lines.push(`    no marker for any item of ${key}[] — empty on this page, or not instrumented`);
+        }
+    }
+    if (report.unknownBlockTypes.length > 0) {
+        lines.push(`  not in the manifest, skipped: ${report.unknownBlockTypes.join(", ")}`);
+    }
+    return lines.join("\n");
+}

package/dist/editor-block-meta.d.ts

@@ -0,0 +1,70 @@
+/**
+ * What the property panel should render for one block type.
+ *
+ * There are two sources and they disagree. The **manifest** is what the site
+ * serves over HTTP: its own schema, its own labels, its own list metadata. The
+ * **registry** is whatever is registered in the process doing the rendering —
+ * and in the editor that is its *own* bundled copy of `@avocadostudio-ai/blocks`,
+ * which registers the built-in types on import. A site that calls
+ * `registerBlocks` fills the registry inside the *orchestrator*; the editor's
+ * in-browser registry is a third source of truth that nobody registered into.
+ *
+ * This used to be inline in `PropertyPanel`, with the rule "the manifest decides
+ * *which* fields exist; the registry supplies richer metadata for any field in
+ * both". That is right when the site's `Hero` really is Avocado's `Hero`, and
+ * exactly wrong when the site re-registered that name with its own shape — which
+ * is the common case, because these are the names blocks *have*. A real
+ * integration collided on seven of its eight types and got a property panel
+ * describing Avocado's blocks: its `Left column` list was labelled
+ * `Left column items`, its `Variant` became `Style variant`.
+ *
+ * So the rule is now about *who said it*, not *who has it*:
+ *
+ * - The manifest **declared** the field (it is in `definition.fields`, not merely
+ *   derived from the JSON schema) → the site said this out loud, and wins.
+ * - The manifest only **derived** it → the site said nothing beyond the schema,
+ *   and the registry's entry is a better answer than an inference, because it
+ *   carries `imageSpec`, `options`, `inlineEditable` and a human label.
+ *
+ * It also carries `discriminator` and `itemFieldsByType` through, which the old
+ * merge dropped by constructing a two-key object. That was pure data loss: the
+ * manifest carries both, and without them the panel narrows nothing, so every
+ * row of a polymorphic list is measured against the merged union of all
+ * branches. Rows whose branch has no text field then fall back to `Item 4`,
+ * `Item 5` — in the case that found this, a bullet list and a pair of CTAs, both
+ * fully described in the manifest the panel had in hand.
+ */
+import type { BlockMeta, FieldMeta, ListFieldMeta } from "./blocks/_registry.ts";
+/** The shape this needs from a manifest entry — a structural subset of `BlockDefinition`. */
+export type EditorBlockDefinition = {
+    type: string;
+    displayName?: string;
+    propsSchema: Record<string, unknown>;
+    fields?: Record<string, unknown>;
+    listFields?: Record<string, unknown>;
+};
+/**
+ * Merge one manifest block definition with whatever the local registry knows
+ * about the same type.
+ *
+ * `registryMeta` is `undefined` for a type the registry has never heard of — a
+ * net-new block — and then the manifest is simply the answer.
+ */
+export declare function resolveEditorBlockMeta(definition: EditorBlockDefinition, registryMeta: BlockMeta | undefined): BlockMeta;
+/**
+ * The fields one list row is actually edited with.
+ *
+ * Polymorphic lists narrow to the branch named by the row's own discriminant
+ * value; anything else — no discriminator, or a value with no branch — falls
+ * back to the union in `itemFields`, which is the pre-narrowing behaviour and
+ * the right answer when there is nothing to narrow by.
+ *
+ * Exported because the panel and the editing-surface check must agree exactly.
+ * A checker that approximates this reports gaps the panel does not have, and
+ * misses the ones it does.
+ */
+export declare function resolveListItemFields(listField: ListFieldMeta, item: Record<string, unknown>): {
+    fields: Record<string, FieldMeta>;
+    discriminantValue: string;
+    matchedBranch: boolean;
+};

package/dist/editor-block-meta.js

@@ -0,0 +1,131 @@
+/**
+ * What the property panel should render for one block type.
+ *
+ * There are two sources and they disagree. The **manifest** is what the site
+ * serves over HTTP: its own schema, its own labels, its own list metadata. The
+ * **registry** is whatever is registered in the process doing the rendering —
+ * and in the editor that is its *own* bundled copy of `@avocadostudio-ai/blocks`,
+ * which registers the built-in types on import. A site that calls
+ * `registerBlocks` fills the registry inside the *orchestrator*; the editor's
+ * in-browser registry is a third source of truth that nobody registered into.
+ *
+ * This used to be inline in `PropertyPanel`, with the rule "the manifest decides
+ * *which* fields exist; the registry supplies richer metadata for any field in
+ * both". That is right when the site's `Hero` really is Avocado's `Hero`, and
+ * exactly wrong when the site re-registered that name with its own shape — which
+ * is the common case, because these are the names blocks *have*. A real
+ * integration collided on seven of its eight types and got a property panel
+ * describing Avocado's blocks: its `Left column` list was labelled
+ * `Left column items`, its `Variant` became `Style variant`.
+ *
+ * So the rule is now about *who said it*, not *who has it*:
+ *
+ * - The manifest **declared** the field (it is in `definition.fields`, not merely
+ *   derived from the JSON schema) → the site said this out loud, and wins.
+ * - The manifest only **derived** it → the site said nothing beyond the schema,
+ *   and the registry's entry is a better answer than an inference, because it
+ *   carries `imageSpec`, `options`, `inlineEditable` and a human label.
+ *
+ * It also carries `discriminator` and `itemFieldsByType` through, which the old
+ * merge dropped by constructing a two-key object. That was pure data loss: the
+ * manifest carries both, and without them the panel narrows nothing, so every
+ * row of a polymorphic list is measured against the merged union of all
+ * branches. Rows whose branch has no text field then fall back to `Item 4`,
+ * `Item 5` — in the case that found this, a bullet list and a pair of CTAs, both
+ * fully described in the manifest the panel had in hand.
+ */
+import { resolveManifestFieldMeta } from "./block-manifest.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Keys the definition stated for itself, as opposed to keys inferred from its schema. */
+function declaredKeys(source) {
+    return isRecord(source) ? new Set(Object.keys(source)) : new Set();
+}
+/**
+ * Merge one manifest block definition with whatever the local registry knows
+ * about the same type.
+ *
+ * `registryMeta` is `undefined` for a type the registry has never heard of — a
+ * net-new block — and then the manifest is simply the answer.
+ */
+export function resolveEditorBlockMeta(definition, registryMeta) {
+    const derived = resolveManifestFieldMeta(definition);
+    if (!registryMeta) {
+        return {
+            displayName: definition.displayName ?? definition.type,
+            fields: derived.fields,
+            ...(Object.keys(derived.listFields).length > 0 ? { listFields: derived.listFields } : {})
+        };
+    }
+    const declaredFields = declaredKeys(definition.fields);
+    const fields = {};
+    for (const [key, fromManifest] of Object.entries(derived.fields)) {
+        const fromRegistry = registryMeta.fields[key];
+        // The site said it out loud, or the registry has nothing to add.
+        fields[key] = declaredFields.has(key) || !fromRegistry ? fromManifest : fromRegistry;
+    }
+    const declaredLists = declaredKeys(definition.listFields);
+    const listFields = {};
+    for (const [key, fromManifest] of Object.entries(derived.listFields)) {
+        const fromRegistry = registryMeta.listFields?.[key];
+        if (!fromRegistry || declaredLists.has(key)) {
+            listFields[key] = fromManifest;
+            continue;
+        }
+        const declaredItems = declaredKeys(isRecord(definition.listFields?.[key])
+            ? definition.listFields[key].itemFields
+            : undefined);
+        const itemFields = {};
+        for (const [itemKey, itemFromManifest] of Object.entries(fromManifest.itemFields)) {
+            const itemFromRegistry = fromRegistry.itemFields[itemKey];
+            itemFields[itemKey] =
+                declaredItems.has(itemKey) || !itemFromRegistry ? itemFromManifest : itemFromRegistry;
+        }
+        listFields[key] = {
+            ...fromManifest,
+            ...(fromManifest.label ?? fromRegistry.label
+                ? { label: fromManifest.label ?? fromRegistry.label }
+                : {}),
+            itemFields,
+            // Never synthesised, never dropped: whichever source has a branch map, keep it.
+            ...(fromManifest.discriminator ?? fromRegistry.discriminator
+                ? { discriminator: fromManifest.discriminator ?? fromRegistry.discriminator }
+                : {}),
+            ...(fromManifest.itemFieldsByType ?? fromRegistry.itemFieldsByType
+                ? { itemFieldsByType: fromManifest.itemFieldsByType ?? fromRegistry.itemFieldsByType }
+                : {})
+        };
+    }
+    return {
+        ...registryMeta,
+        displayName: definition.displayName ?? registryMeta.displayName,
+        fields,
+        ...(Object.keys(listFields).length > 0 ? { listFields } : {})
+    };
+}
+/**
+ * The fields one list row is actually edited with.
+ *
+ * Polymorphic lists narrow to the branch named by the row's own discriminant
+ * value; anything else — no discriminator, or a value with no branch — falls
+ * back to the union in `itemFields`, which is the pre-narrowing behaviour and
+ * the right answer when there is nothing to narrow by.
+ *
+ * Exported because the panel and the editing-surface check must agree exactly.
+ * A checker that approximates this reports gaps the panel does not have, and
+ * misses the ones it does.
+ */
+export function resolveListItemFields(listField, item) {
+    if (!listField.discriminator) {
+        return { fields: listField.itemFields, discriminantValue: "", matchedBranch: false };
+    }
+    const raw = item[listField.discriminator];
+    const discriminantValue = raw === undefined || raw === null ? "" : String(raw);
+    const branch = listField.itemFieldsByType?.[discriminantValue];
+    return {
+        fields: branch ?? listField.itemFields,
+        discriminantValue,
+        matchedBranch: Boolean(branch)
+    };
+}

package/dist/index.d.ts

@@ -2,11 +2,17 @@ export { EDITOR_PROTOCOL_VERSION } from "./protocol.ts";
 export { getConfiguredDraftSecret, getSafeInternalRedirectPath, validateDraftSecret, type DraftSecretValidationResult } from "./draft-mode.ts";
 export type { FieldDiffKind, FieldDiff, BlockDiffStatus, BlockDiff, PageDiffStatus, PageDiff, PublishDiff, SiteConfigFieldDiff, SiteConfigDiff, } from "./publish-diff.ts";
 export { isImagePath, toAltPath, isAltPath, toImagePath, setPropAtPath } from "./editable-path.ts";
-export { parseLink, resolveLink, normalizeLinkPath, isKnownRoute, internalPathForUrl, rankLinkTargets, scoreLinkCandidate, suggestLinkTarget, newTabKeyFor, linkAttrs, type LinkKind, type ParsedLink, type ResolvedLink, type LinkPageOption, } from "./links.ts";
+export { extractMarkedBlocks, editableCoverage, formatEditableCoverage } from "./editable-coverage.ts";
+export type { MarkedBlock, BlockCoverageGap, EditableCoverage } from "./editable-coverage.ts";
+export { panelCoverage, formatPanelCoverage, deriveRowLabel } from "./panel-coverage.ts";
+export type { PanelCoverage, PanelFinding, PanelFindingCode } from "./panel-coverage.ts";
+export { resolveEditorBlockMeta, resolveListItemFields } from "./editor-block-meta.ts";
+export type { EditorBlockDefinition } from "./editor-block-meta.ts";
+export { parseLink, resolveLink, normalizeLinkPath, isKnownRoute, internalPathForUrl, rankLinkTargets, rankFileTargets, suggestLinkTargets, scoreLinkCandidate, suggestLinkTarget, newTabKeyFor, linkAttrs, isFilePath, knownFileExtensions, linksInRichText, type LinkKind, type ParsedLink, type ResolvedLink, type LinkPageOption, type LinkFileOption, type LinkSuggestions, } from "./links.ts";
 export { parseInline, parseRichText, parseRichTextBlocks, normalizeRichTextBody, resolveRichTextHeadingLevel, clampMarkdownHeadings, unescapeMarkdownText, isRichTextDoc, fromMarkdown, toMarkdown, mergeRichTextDoc, NODE, MARK, type InlineToken, type RichTextBlock, type RichTextList, type RichTextListItem, type RichTextDoc, type RichTextNode, type RichTextMark } from "@avocadostudio-ai/richtext";
 export { blockDefinitionSchema, blockManifestSchema, buildBlockManifest, jsonSchemaLikeSchema, validateByJsonSchemaLike, findManifestSchemaIssue, type ManifestSchemaIssue, validateManifestDefaultProps, deriveFieldMetaFromSchema, resolveManifestFieldMeta, isProseMirrorDocSchema, type BlockDefinition, type BlockManifest } from "./block-manifest.ts";
 export { z } from "zod";
-export { type FieldKind, type ImageSpec, type FieldMeta, type ListFieldMeta, type BlockMeta, type BlockType, type BlockInstance, type BlockRegistration, IMAGE_PLACEHOLDER, isImagePlaceholder, registerBlock, resetListFieldWarnings, getBlockMeta, getAllBlockMeta, getImageFields, getListImageFields, getMediaFields, isFieldInlineEditable, getImageSpec, isChrome, getChromeTypes, blockSchemas, allowedBlockTypes, declareBlockCatalogue, getBlockCatalogue, isInBlockCatalogue, catalogueBlockTypes, undeclaredBlockTypes, getPropDisplayName, defaultListItemForBlock, blockInstanceSchema, blockInstanceSchemaLenient, validateBlockProps, getBlockJsonSchema, } from "./blocks/_registry.ts";
+export { type FieldKind, type ImageSpec, type FieldMeta, type ListFieldMeta, type BlockMeta, type BlockType, type BlockInstance, type BlockRegistration, IMAGE_PLACEHOLDER, isImagePlaceholder, registerBlock, resetListFieldWarnings, getBlockMeta, getAllBlockMeta, blockAcceptsProp, blockListItemAcceptsKey, getImageFields, getListImageFields, getMediaFields, isFieldInlineEditable, getImageSpec, isChrome, getChromeTypes, blockSchemas, allowedBlockTypes, declareBlockCatalogue, getBlockCatalogue, isInBlockCatalogue, catalogueBlockTypes, undeclaredBlockTypes, getPropDisplayName, defaultListItemForBlock, blockInstanceSchema, blockInstanceSchemaLenient, validateBlockProps, getBlockJsonSchema, } from "./blocks/_registry.ts";
 export { defaultPropsForType, declaredDefaultPropsForType, resolveHeadingTag, resolveItemHeadingTag, DEFAULT_HEADING_LEVELS, } from "./blocks/index.ts";
 export { blockTypeToCamel, camelToBlockType, blockTypeToLower, lowerToBlockType, } from "./block-names.ts";
 export { makeAddBlock, generateBlockId, makeAddItem, generateItemId, ensureItemIds, type AddBlockOp, type MakeAddBlockOptions, type AddItemOp, type MakeAddItemOptions, } from "./ops/builders.ts";

package/dist/index.js

@@ -1,7 +1,10 @@
 export { EDITOR_PROTOCOL_VERSION } from "./protocol.js";
 export { getConfiguredDraftSecret, getSafeInternalRedirectPath, validateDraftSecret } from "./draft-mode.js";
 export { isImagePath, toAltPath, isAltPath, toImagePath, setPropAtPath } from "./editable-path.js";
-export { parseLink, resolveLink, normalizeLinkPath, isKnownRoute, internalPathForUrl, rankLinkTargets, scoreLinkCandidate, suggestLinkTarget, newTabKeyFor, linkAttrs, } from "./links.js";
+export { extractMarkedBlocks, editableCoverage, formatEditableCoverage } from "./editable-coverage.js";
+export { panelCoverage, formatPanelCoverage, deriveRowLabel } from "./panel-coverage.js";
+export { resolveEditorBlockMeta, resolveListItemFields } from "./editor-block-meta.js";
+export { parseLink, resolveLink, normalizeLinkPath, isKnownRoute, internalPathForUrl, rankLinkTargets, rankFileTargets, suggestLinkTargets, scoreLinkCandidate, suggestLinkTarget, newTabKeyFor, linkAttrs, isFilePath, knownFileExtensions, linksInRichText, } from "./links.js";
 /*
  * The rich-text grammar lives in `@avocadostudio-ai/richtext`, which owns the
  * parser and every CMS converter and has no dependencies of its own. It is
@@ -34,7 +37,7 @@ export {
 // Constants & helpers
 IMAGE_PLACEHOLDER, isImagePlaceholder, 
 // Registry functions
-registerBlock, resetListFieldWarnings, getBlockMeta, getAllBlockMeta, getImageFields, getListImageFields, getMediaFields, isFieldInlineEditable, getImageSpec, isChrome, getChromeTypes, 
+registerBlock, resetListFieldWarnings, getBlockMeta, getAllBlockMeta, blockAcceptsProp, blockListItemAcceptsKey, getImageFields, getListImageFields, getMediaFields, isFieldInlineEditable, getImageSpec, isChrome, getChromeTypes, 
 // Backwards-compatible exports
 blockSchemas, allowedBlockTypes, 
 // The catalogue a site actually renders — see `declareBlockCatalogue`