@avocadostudio-ai/shared 0.3.2 → 0.4.0

package/dist/api-responses.d.ts

@@ -52,6 +52,11 @@ export declare const chatStartResponseSchema: z.ZodObject<{
 }, z.core.$loose>;
 export declare const slugsResponseSchema: z.ZodObject<{
     slugs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    pages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
 export declare const bootstrapResponseSchema: z.ZodObject<{
     slugs: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/api-responses.js

@@ -58,6 +58,18 @@ export const chatStartResponseSchema = z.object({
 }).passthrough();
 export const slugsResponseSchema = z.object({
     slugs: z.array(z.string()).optional(),
+    /*
+     * The same pages the `slugs` array names, with the title and the URL that
+     * `/draft/slugs` has always returned beside them. The editor parsed this
+     * response and kept only the bare slugs, so the link picker had nothing to
+     * label a page with; `path` is what a locale-prefixed site navigates to when
+     * it differs from the slug (see docs/ideas/page-identity-punch-list.md).
+     */
+    pages: z.array(z.object({
+        slug: z.string(),
+        path: z.string().optional(),
+        title: z.string().optional(),
+    }).passthrough()).optional(),
 }).passthrough();
 export const bootstrapResponseSchema = z.object({
     slugs: z.array(z.string()).optional(),

package/dist/block-manifest.d.ts

@@ -1,24 +1,16 @@
 import { z } from "zod";
 import type { FieldMeta, ListFieldMeta } from "./blocks/_registry.ts";
 export declare const jsonSchemaLikeSchema: z.ZodType<Record<string, unknown>>;
-/**
- * Field metadata a site may declare alongside the JSON schema.
- *
- * JSON Schema describes what a value *is*; this describes how a person edits
- * it, and the two are not the same question. A one-word headline and a six
- * sentence body are both `{"type":"string"}`, so a manifest carrying only the
- * schema gives them the same one-line input — which is exactly what happened to
- * every integration with a real prose field. `kind` and `multiline` have no
- * JSON Schema spelling, so they have to travel beside it.
- */
 export declare const fieldMetaSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         number: "number";
         boolean: "boolean";
+        file: "file";
         enum: "enum";
         text: "text";
         richtext: "richtext";
         url: "url";
+        link: "link";
         image: "image";
         imageAlt: "imageAlt";
         color: "color";
@@ -55,10 +47,12 @@ export declare const listFieldMetaSchema: z.ZodObject<{
         kind: z.ZodEnum<{
             number: "number";
             boolean: "boolean";
+            file: "file";
             enum: "enum";
             text: "text";
             richtext: "richtext";
             url: "url";
+            link: "link";
             image: "image";
             imageAlt: "imageAlt";
             color: "color";
@@ -94,10 +88,12 @@ export declare const listFieldMetaSchema: z.ZodObject<{
         kind: z.ZodEnum<{
             number: "number";
             boolean: "boolean";
+            file: "file";
             enum: "enum";
             text: "text";
             richtext: "richtext";
             url: "url";
+            link: "link";
             image: "image";
             imageAlt: "imageAlt";
             color: "color";
@@ -139,10 +135,12 @@ export declare const blockDefinitionSchema: z.ZodObject<{
         kind: z.ZodEnum<{
             number: "number";
             boolean: "boolean";
+            file: "file";
             enum: "enum";
             text: "text";
             richtext: "richtext";
             url: "url";
+            link: "link";
             image: "image";
             imageAlt: "imageAlt";
             color: "color";
@@ -179,10 +177,12 @@ export declare const blockDefinitionSchema: z.ZodObject<{
             kind: z.ZodEnum<{
                 number: "number";
                 boolean: "boolean";
+                file: "file";
                 enum: "enum";
                 text: "text";
                 richtext: "richtext";
                 url: "url";
+                link: "link";
                 image: "image";
                 imageAlt: "imageAlt";
                 color: "color";
@@ -218,10 +218,12 @@ export declare const blockDefinitionSchema: z.ZodObject<{
             kind: z.ZodEnum<{
                 number: "number";
                 boolean: "boolean";
+                file: "file";
                 enum: "enum";
                 text: "text";
                 richtext: "richtext";
                 url: "url";
+                link: "link";
                 image: "image";
                 imageAlt: "imageAlt";
                 color: "color";
@@ -269,10 +271,12 @@ export declare const blockManifestSchema: z.ZodObject<{
             kind: z.ZodEnum<{
                 number: "number";
                 boolean: "boolean";
+                file: "file";
                 enum: "enum";
                 text: "text";
                 richtext: "richtext";
                 url: "url";
+                link: "link";
                 image: "image";
                 imageAlt: "imageAlt";
                 color: "color";
@@ -309,10 +313,12 @@ export declare const blockManifestSchema: z.ZodObject<{
                 kind: z.ZodEnum<{
                     number: "number";
                     boolean: "boolean";
+                    file: "file";
                     enum: "enum";
                     text: "text";
                     richtext: "richtext";
                     url: "url";
+                    link: "link";
                     image: "image";
                     imageAlt: "imageAlt";
                     color: "color";
@@ -348,10 +354,12 @@ export declare const blockManifestSchema: z.ZodObject<{
                 kind: z.ZodEnum<{
                     number: "number";
                     boolean: "boolean";
+                    file: "file";
                     enum: "enum";
                     text: "text";
                     richtext: "richtext";
                     url: "url";
+                    link: "link";
                     image: "image";
                     imageAlt: "imageAlt";
                     color: "color";

package/dist/block-manifest.js

@@ -23,8 +23,25 @@ export const jsonSchemaLikeSchema = z.lazy(() => z.object({
  * every integration with a real prose field. `kind` and `multiline` have no
  * JSON Schema spelling, so they have to travel beside it.
  */
+/*
+ * The same list as `FieldKind`, and pinned to it.
+ *
+ * A Zod enum cannot be derived from a union type, so this is the second place
+ * the kinds are written — and it drifted the moment a kind was added: `file`
+ * went into `FieldKind`, every derivation started emitting it, and this schema
+ * went on rejecting it, which surfaced as a type error three packages away in
+ * the MCP server rather than as anything about field kinds. The
+ * `satisfies`-flavoured assignment below makes the compiler check the two lists
+ * against each other here, where the mismatch is.
+ */
+const FIELD_KINDS = [
+    "text", "richtext", "url", "link", "file", "image", "imageAlt",
+    "enum", "color", "number", "boolean", "headingLevel"
+];
+const _everyKindListed = true;
+void _everyKindListed;
 export const fieldMetaSchema = z.object({
-    kind: z.enum(["text", "richtext", "url", "image", "imageAlt", "enum", "color", "number", "boolean", "headingLevel"]),
+    kind: z.enum(FIELD_KINDS),
     label: z.string().optional(),
     inlineEditable: z.boolean().optional(),
     options: z.array(z.string()).optional(),
@@ -184,6 +201,55 @@ export function validateByJsonSchemaLike(schema, value) {
 // ---------------------------------------------------------------------------
 const IMAGE_KEY_RE = /(?:image|img)(?:Url|Src)?$|^(?:src|imageUrl|logoUrl|heroImage)$/i;
 const IMAGE_ALT_KEY_RE = /(?:Alt)$/;
+const LINK_KEY_RE = /(?:href|link)$/i;
+/*
+ * Prop names that hold a document rather than a route.
+ *
+ * Deliberately narrow. `download`, `pdf`, `file`, `doc`, `attachment`,
+ * `brochure`, `datasheet` and `menu` are the words sites use, each optionally
+ * followed by Url/Href/Link/Path — so `menuPdf`, `downloadUrl` and
+ * `brochureHref` all land here, and `menuLabel` does not. A name this misses
+ * simply stays a `link`, which is where it already was; the cost of guessing
+ * wrong in the other direction is a page picker offered for a PDF.
+ */
+const FILE_KEY_RE = /(?:^|[a-z])(?:download|pdf|file|doc|document|attachment|brochure|datasheet|menu)(?:Url|Href|Link|Path)?$/i;
+/*
+ * A `contentMediaType` that means "this is a file to download".
+ *
+ * Not simply "anything that is not an image": `text/html`, `text/plain` and
+ * `text/markdown` are prose a block renders inline, and treating them as
+ * documents would put a file picker on a body field. `application/json` is
+ * excluded for the same reason — a config blob is data the block reads, not
+ * something a visitor downloads. What is left is `application/*` (pdf, msword,
+ * vnd.*, zip) plus the two text types that really are files.
+ */
+const FILE_MEDIA_TYPE_RE = /^application\/(?!json\b)|^text\/(?:csv|calendar)\b/i;
+/**
+ * A prop the CMS owns, which no editor may offer as a control.
+ *
+ * A leading underscore is the near-universal marker for a document's own
+ * bookkeeping — Sanity's `_key`, `_type`, `_id`, `_ref`, `_rev`; GraphQL's
+ * `__typename`. These reach a block's schema legitimately: a site that projects
+ * CMS array members has to carry `_key` through, because `_key` is the *address*
+ * a field-level publish patches by (`pageBuilder[_key=="home-hero"].heading.de`).
+ * Declaring it keeps the ops engine from stripping it off an edited item.
+ *
+ * But "the block can store it" was being read as "a person may type it". The
+ * property panel derives its controls from the schema, so `_key` rendered as an
+ * empty text box — empty because the projection hands the editor its own `id`,
+ * not the CMS key — labelled " key", sitting directly under a CTA's Label. That
+ * is not merely a stray control: the value a user typed into it would become the
+ * item's `_key`, which is the thing the publish diff addresses the array member
+ * by. Editing it re-points or orphans the patch, and the same derivation feeds
+ * the planner's block contracts, so the model was being shown `_key` as a prop
+ * it could set.
+ *
+ * Underscore-prefixed props are therefore stored, projected and published as
+ * before, and never editable by anyone.
+ */
+function isInternalPropKey(key) {
+    return key.startsWith("_");
+}
 function labelFromKey(key) {
     // ctaText → "CTA text", imageUrl → "Image", logoAlt → "Logo alt",
     // background_image → "Background image", video_url → "Video", src → "Src"
@@ -224,14 +290,59 @@ function inferFieldKind(key, schema) {
         return "imageAlt";
     if (IMAGE_KEY_RE.test(key))
         return "image";
+    /*
+     * A document prop, named as one. `menuPdf`, `brochureFile`, `datasheetDoc`,
+     * `downloadUrl` — all of them hold a path to a file rather than a route, and
+     * inferring them as `link` puts them in front of the page picker and the
+     * dead-route warning, which are both the wrong question. Checked before the
+     * link pattern precisely because `downloadUrl` and `fileHref` match both.
+     */
+    if (FILE_KEY_RE.test(key))
+        return "file";
+    /*
+     * A schema can also say so outright, and a `contentMediaType` of anything but
+     * an image means a document — the same standard vocabulary the markdown case
+     * above uses, so an integrator needs no proprietary annotation to get the
+     * right control.
+     */
+    if (typeof schema.contentMediaType === "string" && FILE_MEDIA_TYPE_RE.test(schema.contentMediaType)) {
+        return "file";
+    }
+    /*
+     * A custom block's `ctaHref` is a link, and inferring it as plain text gave
+     * an integrator's editors a bare box where the built-in blocks get a page
+     * picker. Checked after the image patterns so `imageUrl` and `logoUrl` still
+     * resolve to images — those end in "Url" too.
+     */
+    if (LINK_KEY_RE.test(key))
+        return "link";
     return "text";
 }
+/**
+ * A list item's `id` is identity, not content.
+ *
+ * The same argument as `_key` above, one convention over: every one of this
+ * package's own list blocks carries an optional `id` on each item, used as the
+ * React key and as the handle an operation addresses the item by. Derived from
+ * the schema it looks like any other optional string, so the panel drew a text
+ * box for it and the planner was shown it as a prop it could set — and a value
+ * typed there re-points or orphans the very patch that would save it.
+ *
+ * Scoped to list items deliberately. A top-level `id` prop on a block is a
+ * perfectly ordinary content field (an anchor, a slug, an embed's video id) and
+ * is left alone.
+ */
+function isItemIdentityKey(key) {
+    return key === "id";
+}
 function deriveItemFields(itemSchema) {
     const fields = {};
     const props = isObject(itemSchema.properties) ? itemSchema.properties : {};
     for (const [key, propSchema] of Object.entries(props)) {
         if (!isObject(propSchema))
             continue;
+        if (isInternalPropKey(key) || isItemIdentityKey(key))
+            continue;
         // Skip opaque object/array props (they'd render as "[object Object]"), but
         // keep richtext docs — those self-identify and get the richtext editor.
         const t = typeof propSchema.type === "string" ? propSchema.type : undefined;
@@ -325,6 +436,8 @@ export function deriveFieldMetaFromSchema(propsSchema) {
     for (const [key, propSchema] of Object.entries(props)) {
         if (!isObject(propSchema))
             continue;
+        if (isInternalPropKey(key))
+            continue;
         const type = typeof propSchema.type === "string" ? propSchema.type : undefined;
         // Array of a discriminated union (oneOf/anyOf of object branches) →
         // polymorphic list field: per-branch fields keyed by the discriminant value.

package/dist/blocks/_helpers.d.ts

@@ -3,8 +3,29 @@ export declare const f: {
     readonly text: (label?: string) => FieldMeta;
     readonly longtext: (label?: string) => FieldMeta;
     readonly richtext: (label?: string) => FieldMeta;
+    /** A resource address — an iframe src, a video file. Never an internal page. */
     readonly url: (label?: string) => FieldMeta;
+    /** A navigation target: an internal page, or an external URL / mailto / tel / anchor. */
+    readonly link: (label?: string) => FieldMeta;
+    /**
+     * The "open in new tab" companion for a link prop. Named by convention
+     * (`newTabKeyFor`) so the property panel renders it inside the link control
+     * rather than as a row of its own — the same pairing as `image`/`imageAlt`.
+     */
+    readonly newTab: (label?: string) => FieldMeta;
     readonly image: (label?: string, imageSpec?: ImageSpec) => FieldMeta;
+    /**
+     * A single emoji or symbol glyph, or the URL of a small image.
+     *
+     * Text in the panel, and deliberately *not* editable on the page. Whatever a
+     * person types into an icon goes through `renderBlockIcon`, which draws only a
+     * glyph or an image and renders **nothing** for anything else — so an inline
+     * edit that typed a word ("rocket", the name the planner reaches for) would
+     * make the icon silently disappear with the value stored and invisible. The
+     * panel's labelled box is the affordance that fits a value from a constrained
+     * vocabulary; a cursor blinking inside the emoji is not.
+     */
+    readonly icon: (label?: string) => FieldMeta;
     readonly imageAlt: (label?: string) => FieldMeta;
     readonly headingLevel: () => FieldMeta;
 };

package/dist/blocks/_helpers.js

@@ -2,8 +2,29 @@ export const f = {
     text: (label) => ({ kind: "text", label }),
     longtext: (label) => ({ kind: "text", label, multiline: true }),
     richtext: (label) => ({ kind: "richtext", label }),
+    /** A resource address — an iframe src, a video file. Never an internal page. */
     url: (label) => ({ kind: "url", label, inlineEditable: false }),
+    /** A navigation target: an internal page, or an external URL / mailto / tel / anchor. */
+    link: (label) => ({ kind: "link", label, inlineEditable: false }),
+    /**
+     * The "open in new tab" companion for a link prop. Named by convention
+     * (`newTabKeyFor`) so the property panel renders it inside the link control
+     * rather than as a row of its own — the same pairing as `image`/`imageAlt`.
+     */
+    newTab: (label = "Open in new tab") => ({ kind: "boolean", label, inlineEditable: false }),
     image: (label, imageSpec) => ({ kind: "image", label, inlineEditable: false, ...(imageSpec ? { imageSpec } : {}) }),
+    /**
+     * A single emoji or symbol glyph, or the URL of a small image.
+     *
+     * Text in the panel, and deliberately *not* editable on the page. Whatever a
+     * person types into an icon goes through `renderBlockIcon`, which draws only a
+     * glyph or an image and renders **nothing** for anything else — so an inline
+     * edit that typed a word ("rocket", the name the planner reaches for) would
+     * make the icon silently disappear with the value stored and invisible. The
+     * panel's labelled box is the affordance that fits a value from a constrained
+     * vocabulary; a cursor blinking inside the emoji is not.
+     */
+    icon: (label = "Icon (single emoji)") => ({ kind: "text", label, inlineEditable: false }),
     imageAlt: (label) => ({ kind: "imageAlt", label }),
     headingLevel: () => ({ kind: "headingLevel", label: "Heading type", inlineEditable: false }),
 };

package/dist/blocks/_registry.d.ts

@@ -1,8 +1,25 @@
 import { z } from "zod";
 export declare const IMAGE_PLACEHOLDER = "/hero-generated.svg";
 export declare function isImagePlaceholder(url: string | undefined | null): boolean;
-/** Semantic kind for a block prop field. */
-export type FieldKind = "text" | "richtext" | "url" | "image" | "imageAlt" | "enum" | "color" | "number" | "boolean" | "headingLevel";
+/**
+ * Semantic kind for a block prop field.
+ *
+ * `link` and `url` are both href-valued strings and deliberately distinct.
+ * `link` is a *navigation target* — it may address a page on this site, so it
+ * gets the page picker, the dead-route warning, and the rename rewriter.
+ * `url` is a *resource address* — an embed's iframe src, a video file, an OG
+ * image — which is never an internal page, and where offering a list of pages
+ * would be noise.
+ *
+ * `file` is a *document*: a menu PDF, a price list, a consent form. It is a
+ * third thing and not a flavour of either, because the question you ask of it
+ * is different. A `link` is checked against the site's pages; a `file` must not
+ * be, or every document on the site reports as a dead link. A `url` is checked
+ * against nothing at all; a `file` can be checked against what the site's asset
+ * store actually holds, which is the only way anyone finds out that a menu link
+ * has been pointing at a filename with a typo in it since August.
+ */
+export type FieldKind = "text" | "richtext" | "url" | "link" | "file" | "image" | "imageAlt" | "enum" | "color" | "number" | "boolean" | "headingLevel";
 /** Recommended image dimensions for an image field. */
 export type ImageSpec = {
     aspectRatio: "landscape" | "square" | "portrait";
@@ -104,10 +121,52 @@ export declare function registerBlock(type: string, config: BlockRegistration):
 export declare function getBlockMeta(type: string): BlockMeta | undefined;
 /** Get all registered block metadata. */
 export declare function getAllBlockMeta(): Readonly<Record<string, BlockMeta>>;
+/**
+ * Does this block type declare this prop?
+ *
+ * The only honest answer to "is `heading` a real prop" is the one the block's
+ * own schema gives, and it is the question two very different callers need: the
+ * plan normalizer, deciding whether a prop name the model emitted needs
+ * repairing, and the planner prompt, deciding whether a prop-name correction is
+ * even true of this site's catalogue. Both used to answer it by comparing the
+ * block type against a literal from Avocado's own catalogue, which is a fact
+ * about our names rather than about the site's schema — so a site that brings
+ * its own blocks got a confident wrong answer. Asking here means they cannot
+ * drift apart again.
+ *
+ * Manifest-registered blocks may carry a schema richer than their derived meta,
+ * so the schema gets the second look rather than the first refusal. An
+ * unregistered type answers `false`, which callers must read as "no evidence",
+ * not as "no".
+ */
+export declare function blockAcceptsProp(blockType: string, prop: string): boolean;
+/**
+ * Does this block type's list `listKey` declare an item field named `itemKey`?
+ * The list-shaped counterpart of `blockAcceptsProp`, with the same contract: a
+ * block with no declared list metadata answers `false` for every key, meaning
+ * "no evidence".
+ */
+export declare function blockListItemAcceptsKey(blockType: string, listKey: string, itemKey: string): boolean;
 /** Get the set of prop keys that are image fields for a block type. */
 export declare function getImageFields(blockType: string): Set<string>;
 /** Get list props that contain image fields: Map<listKey, Set<imageFieldKey>>. */
 export declare function getListImageFields(blockType: string): Map<string, Set<string>>;
+/**
+ * Every prop key on a block type that addresses a *resource* rather than a page
+ * — images, iframe sources, video files — at any depth, scalar and list-item
+ * props flattened into one set.
+ *
+ * Renaming a page rewrites the links that point at it, and the rewriter cannot
+ * tell a link from any other string: it walks the props and remaps every value
+ * that starts with the old slug. That silently rewrote `/pricing/demo.mp4` into
+ * `/plans/demo.mp4` on a rename — an asset path is not a route, and renaming a
+ * page does not move the file. This set is what the walker skips.
+ *
+ * It is an exclusion rather than a `kind: "link"` allow-list on purpose: a
+ * custom block that ships no field metadata still has its links rewritten, the
+ * way it always did.
+ */
+export declare function getMediaFields(blockType: string): Set<string>;
 /** Check if a block type is a chrome block (structurally pinned). */
 export declare function isChrome(type: string): boolean;
 /** Get all registered chrome block type names. */

package/dist/blocks/_registry.js

@@ -141,6 +141,45 @@ export function getBlockMeta(type) {
 export function getAllBlockMeta() {
     return _blockMeta;
 }
+/**
+ * Does this block type declare this prop?
+ *
+ * The only honest answer to "is `heading` a real prop" is the one the block's
+ * own schema gives, and it is the question two very different callers need: the
+ * plan normalizer, deciding whether a prop name the model emitted needs
+ * repairing, and the planner prompt, deciding whether a prop-name correction is
+ * even true of this site's catalogue. Both used to answer it by comparing the
+ * block type against a literal from Avocado's own catalogue, which is a fact
+ * about our names rather than about the site's schema — so a site that brings
+ * its own blocks got a confident wrong answer. Asking here means they cannot
+ * drift apart again.
+ *
+ * Manifest-registered blocks may carry a schema richer than their derived meta,
+ * so the schema gets the second look rather than the first refusal. An
+ * unregistered type answers `false`, which callers must read as "no evidence",
+ * not as "no".
+ */
+export function blockAcceptsProp(blockType, prop) {
+    if (!blockType || !prop)
+        return false;
+    const meta = _blockMeta[blockType];
+    if (meta?.fields && prop in meta.fields)
+        return true;
+    const shape = _blockSchemas[blockType]?.shape;
+    return Boolean(shape && prop in shape);
+}
+/**
+ * Does this block type's list `listKey` declare an item field named `itemKey`?
+ * The list-shaped counterpart of `blockAcceptsProp`, with the same contract: a
+ * block with no declared list metadata answers `false` for every key, meaning
+ * "no evidence".
+ */
+export function blockListItemAcceptsKey(blockType, listKey, itemKey) {
+    if (!blockType || !listKey || !itemKey)
+        return false;
+    const itemFields = _blockMeta[blockType]?.listFields?.[listKey]?.itemFields;
+    return Boolean(itemFields && itemKey in itemFields);
+}
 /** Cache for getImageFields results. */
 const _imageFieldsCache = new Map();
 /** Get the set of prop keys that are image fields for a block type. */
@@ -182,6 +221,46 @@ export function getListImageFields(blockType) {
     _listImageFieldsCache.set(blockType, result);
     return result;
 }
+/** Cache for getMediaFields results. */
+const _mediaFieldsCache = new Map();
+/**
+ * Every prop key on a block type that addresses a *resource* rather than a page
+ * — images, iframe sources, video files — at any depth, scalar and list-item
+ * props flattened into one set.
+ *
+ * Renaming a page rewrites the links that point at it, and the rewriter cannot
+ * tell a link from any other string: it walks the props and remaps every value
+ * that starts with the old slug. That silently rewrote `/pricing/demo.mp4` into
+ * `/plans/demo.mp4` on a rename — an asset path is not a route, and renaming a
+ * page does not move the file. This set is what the walker skips.
+ *
+ * It is an exclusion rather than a `kind: "link"` allow-list on purpose: a
+ * custom block that ships no field metadata still has its links rewritten, the
+ * way it always did.
+ */
+export function getMediaFields(blockType) {
+    const cached = _mediaFieldsCache.get(blockType);
+    if (cached)
+        return cached;
+    const meta = _blockMeta[blockType];
+    const result = new Set();
+    const collect = (fields) => {
+        for (const [key, fm] of Object.entries(fields)) {
+            if (fm.kind === "image" || fm.kind === "url")
+                result.add(key);
+        }
+    };
+    if (meta) {
+        collect(meta.fields);
+        for (const listMeta of Object.values(meta.listFields ?? {})) {
+            collect(listMeta.itemFields);
+            for (const branch of Object.values(listMeta.itemFieldsByType ?? {}))
+                collect(branch);
+        }
+    }
+    _mediaFieldsCache.set(blockType, result);
+    return result;
+}
 /** Check if a block type is a chrome block (structurally pinned). */
 export function isChrome(type) {
     return _blockMeta[type]?.chrome === true;
@@ -332,7 +411,7 @@ function defaultScalarForField(field, fieldKey) {
     const label = field.label?.trim() || fieldKey;
     if (field.kind === "text" || field.kind === "richtext" || field.kind === "imageAlt")
         return `New ${label}`;
-    if (field.kind === "url")
+    if (field.kind === "url" || field.kind === "link")
         return "/";
     if (field.kind === "image")
         return IMAGE_PLACEHOLDER;
@@ -340,6 +419,14 @@ function defaultScalarForField(field, fieldKey) {
         return "#0f766e";
     if (field.kind === "number")
         return 0;
+    /*
+     * Without this a boolean item field seeded a *string* ("New Open in new tab")
+     * into a new list item, which the block's own zod schema then rejected — the
+     * add-item op failed on a value this function produced. Latent until link
+     * fields introduced the first boolean inside a list.
+     */
+    if (field.kind === "boolean")
+        return false;
     if (field.kind === "enum")
         return Array.isArray(field.options) && field.options.length > 0 ? field.options[0] : "";
     return `New ${label}`;

package/dist/blocks/banner.js

@@ -7,6 +7,7 @@ registerBlock("Banner", {
         variant: z.enum(["info", "success", "warning"]).default("info").catch("info"),
         ctaText: z.string().optional(),
         ctaHref: z.string().optional(),
+        ctaNewTab: z.boolean().optional(),
         backgroundColor: z.string().optional(),
         textColor: z.string().optional(),
     }),
@@ -18,7 +19,8 @@ registerBlock("Banner", {
             text: f.text("Banner text"),
             variant: { kind: "enum", label: "Variant", options: ["info", "success", "warning"], inlineEditable: false },
             ctaText: f.text("Button label"),
-            ctaHref: f.url("Button link"),
+            ctaHref: f.link("Button link"),
+            ctaNewTab: f.newTab(),
             backgroundColor: { kind: "color", label: "Background color", inlineEditable: false },
             textColor: { kind: "color", label: "Text color", inlineEditable: false },
         },

package/dist/blocks/card-grid.js

@@ -14,6 +14,7 @@ registerBlock("CardGrid", {
             description: z.string().min(1),
             ctaText: z.string().min(1),
             ctaHref: z.string().min(1),
+            ctaNewTab: z.boolean().optional(),
             imageUrl: z.string().min(1).optional(),
             imageAlt: z.string().min(1).optional()
         }))
@@ -37,7 +38,8 @@ registerBlock("CardGrid", {
                     title: f.text("Card title"),
                     description: f.longtext("Card description"),
                     ctaText: f.text("Button text"),
-                    ctaHref: f.url("Button link"),
+                    ctaHref: f.link("Button link"),
+                    ctaNewTab: f.newTab(),
                     imageUrl: f.image("Card image", { aspectRatio: "landscape", width: 768, height: 512 }),
                     imageAlt: f.imageAlt("Card image alt text"),
                 }

package/dist/blocks/card.js

@@ -7,6 +7,7 @@ registerBlock("Card", {
         description: z.string().min(1),
         ctaText: z.string().min(1),
         ctaHref: z.string().min(1),
+        ctaNewTab: z.boolean().optional(),
         imageUrl: z.string().min(1).optional(),
         imageAlt: z.string().min(1).optional(),
         variant: z.enum(["default", "full-bleed"]).default("default").catch("default"),
@@ -19,7 +20,8 @@ registerBlock("Card", {
             title: f.text("Card title"),
             description: f.longtext("Card description"),
             ctaText: f.text("Button text"),
-            ctaHref: f.url("Button link"),
+            ctaHref: f.link("Button link"),
+            ctaNewTab: f.newTab(),
             imageUrl: f.image("Card image", { aspectRatio: "landscape", width: 768, height: 512 }),
             imageAlt: f.imageAlt("Card image alt text"),
             variant: { kind: "enum", label: "Variant", options: ["default", "full-bleed"], inlineEditable: false },

package/dist/blocks/carousel.js

@@ -11,6 +11,7 @@ registerBlock("Carousel", {
             description: z.string().optional(),
             ctaText: z.string().optional(),
             ctaHref: z.string().optional(),
+            ctaNewTab: z.boolean().optional(),
         })).min(1),
         autoplay: z.enum(["true", "false"]).default("false").catch("false"),
         interval: z.number().optional(),
@@ -32,7 +33,8 @@ registerBlock("Carousel", {
                     heading: f.text("Heading"),
                     description: f.longtext("Description"),
                     ctaText: f.text("Button label"),
-                    ctaHref: f.url("Button link"),
+                    ctaHref: f.link("Button link"),
+                    ctaNewTab: f.newTab(),
                 }
             }
         }