@avocadostudio-ai/shared 0.4.0 → 0.5.1

package/dist/block-manifest.d.ts

@@ -15,6 +15,7 @@ export declare const fieldMetaSchema: z.ZodObject<{
         imageAlt: "imageAlt";
         color: "color";
         headingLevel: "headingLevel";
+        reference: "reference";
     }>;
     label: z.ZodOptional<z.ZodString>;
     inlineEditable: z.ZodOptional<z.ZodBoolean>;
@@ -34,6 +35,7 @@ export declare const fieldMetaSchema: z.ZodObject<{
         }>>;
     }, z.core.$strip>>;
     multiline: z.ZodOptional<z.ZodBoolean>;
+    referenceLabelKey: z.ZodOptional<z.ZodString>;
     inline: z.ZodOptional<z.ZodBoolean>;
     decorators: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -57,6 +59,7 @@ export declare const listFieldMetaSchema: z.ZodObject<{
             imageAlt: "imageAlt";
             color: "color";
             headingLevel: "headingLevel";
+            reference: "reference";
         }>;
         label: z.ZodOptional<z.ZodString>;
         inlineEditable: z.ZodOptional<z.ZodBoolean>;
@@ -76,6 +79,7 @@ export declare const listFieldMetaSchema: z.ZodObject<{
             }>>;
         }, z.core.$strip>>;
         multiline: z.ZodOptional<z.ZodBoolean>;
+        referenceLabelKey: z.ZodOptional<z.ZodString>;
         inline: z.ZodOptional<z.ZodBoolean>;
         decorators: z.ZodOptional<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -98,6 +102,7 @@ export declare const listFieldMetaSchema: z.ZodObject<{
             imageAlt: "imageAlt";
             color: "color";
             headingLevel: "headingLevel";
+            reference: "reference";
         }>;
         label: z.ZodOptional<z.ZodString>;
         inlineEditable: z.ZodOptional<z.ZodBoolean>;
@@ -117,6 +122,7 @@ export declare const listFieldMetaSchema: z.ZodObject<{
             }>>;
         }, z.core.$strip>>;
         multiline: z.ZodOptional<z.ZodBoolean>;
+        referenceLabelKey: z.ZodOptional<z.ZodString>;
         inline: z.ZodOptional<z.ZodBoolean>;
         decorators: z.ZodOptional<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -145,6 +151,7 @@ export declare const blockDefinitionSchema: z.ZodObject<{
             imageAlt: "imageAlt";
             color: "color";
             headingLevel: "headingLevel";
+            reference: "reference";
         }>;
         label: z.ZodOptional<z.ZodString>;
         inlineEditable: z.ZodOptional<z.ZodBoolean>;
@@ -164,6 +171,7 @@ export declare const blockDefinitionSchema: z.ZodObject<{
             }>>;
         }, z.core.$strip>>;
         multiline: z.ZodOptional<z.ZodBoolean>;
+        referenceLabelKey: z.ZodOptional<z.ZodString>;
         inline: z.ZodOptional<z.ZodBoolean>;
         decorators: z.ZodOptional<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -187,6 +195,7 @@ export declare const blockDefinitionSchema: z.ZodObject<{
                 imageAlt: "imageAlt";
                 color: "color";
                 headingLevel: "headingLevel";
+                reference: "reference";
             }>;
             label: z.ZodOptional<z.ZodString>;
             inlineEditable: z.ZodOptional<z.ZodBoolean>;
@@ -206,6 +215,7 @@ export declare const blockDefinitionSchema: z.ZodObject<{
                 }>>;
             }, z.core.$strip>>;
             multiline: z.ZodOptional<z.ZodBoolean>;
+            referenceLabelKey: z.ZodOptional<z.ZodString>;
             inline: z.ZodOptional<z.ZodBoolean>;
             decorators: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
@@ -228,6 +238,7 @@ export declare const blockDefinitionSchema: z.ZodObject<{
                 imageAlt: "imageAlt";
                 color: "color";
                 headingLevel: "headingLevel";
+                reference: "reference";
             }>;
             label: z.ZodOptional<z.ZodString>;
             inlineEditable: z.ZodOptional<z.ZodBoolean>;
@@ -247,6 +258,7 @@ export declare const blockDefinitionSchema: z.ZodObject<{
                 }>>;
             }, z.core.$strip>>;
             multiline: z.ZodOptional<z.ZodBoolean>;
+            referenceLabelKey: z.ZodOptional<z.ZodString>;
             inline: z.ZodOptional<z.ZodBoolean>;
             decorators: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
@@ -281,6 +293,7 @@ export declare const blockManifestSchema: z.ZodObject<{
                 imageAlt: "imageAlt";
                 color: "color";
                 headingLevel: "headingLevel";
+                reference: "reference";
             }>;
             label: z.ZodOptional<z.ZodString>;
             inlineEditable: z.ZodOptional<z.ZodBoolean>;
@@ -300,6 +313,7 @@ export declare const blockManifestSchema: z.ZodObject<{
                 }>>;
             }, z.core.$strip>>;
             multiline: z.ZodOptional<z.ZodBoolean>;
+            referenceLabelKey: z.ZodOptional<z.ZodString>;
             inline: z.ZodOptional<z.ZodBoolean>;
             decorators: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
@@ -323,6 +337,7 @@ export declare const blockManifestSchema: z.ZodObject<{
                     imageAlt: "imageAlt";
                     color: "color";
                     headingLevel: "headingLevel";
+                    reference: "reference";
                 }>;
                 label: z.ZodOptional<z.ZodString>;
                 inlineEditable: z.ZodOptional<z.ZodBoolean>;
@@ -342,6 +357,7 @@ export declare const blockManifestSchema: z.ZodObject<{
                     }>>;
                 }, z.core.$strip>>;
                 multiline: z.ZodOptional<z.ZodBoolean>;
+                referenceLabelKey: z.ZodOptional<z.ZodString>;
                 inline: z.ZodOptional<z.ZodBoolean>;
                 decorators: z.ZodOptional<z.ZodArray<z.ZodObject<{
                     name: z.ZodString;
@@ -364,6 +380,7 @@ export declare const blockManifestSchema: z.ZodObject<{
                     imageAlt: "imageAlt";
                     color: "color";
                     headingLevel: "headingLevel";
+                    reference: "reference";
                 }>;
                 label: z.ZodOptional<z.ZodString>;
                 inlineEditable: z.ZodOptional<z.ZodBoolean>;
@@ -383,6 +400,7 @@ export declare const blockManifestSchema: z.ZodObject<{
                     }>>;
                 }, z.core.$strip>>;
                 multiline: z.ZodOptional<z.ZodBoolean>;
+                referenceLabelKey: z.ZodOptional<z.ZodString>;
                 inline: z.ZodOptional<z.ZodBoolean>;
                 decorators: z.ZodOptional<z.ZodArray<z.ZodObject<{
                     name: z.ZodString;

package/dist/block-manifest.js

@@ -36,7 +36,7 @@ export const jsonSchemaLikeSchema = z.lazy(() => z.object({
  */
 const FIELD_KINDS = [
     "text", "richtext", "url", "link", "file", "image", "imageAlt",
-    "enum", "color", "number", "boolean", "headingLevel"
+    "enum", "color", "number", "boolean", "headingLevel", "reference"
 ];
 const _everyKindListed = true;
 void _everyKindListed;
@@ -54,6 +54,13 @@ export const fieldMetaSchema = z.object({
     })
         .optional(),
     multiline: z.boolean().optional(),
+    /*
+     * Travels with the manifest because the panel is what reads it, and the panel
+     * is in a different process. A key this schema omits is stripped here, not
+     * rejected — so a reference would have arrived in the editor with nothing to
+     * label it and no sign that anything had been declared.
+     */
+    referenceLabelKey: z.string().optional(),
     inline: z.boolean().optional(),
     decorators: z
         .array(z.object({ name: z.string().min(1), title: z.string().optional() }))

package/dist/blocks/_registry.d.ts

@@ -18,8 +18,27 @@ export declare function isImagePlaceholder(url: string | undefined | null): bool
  * 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.
+ *
+ * `reference` is a *pointer the CMS owns*, and it is not a flavour of `link`.
+ * A Storyblok story link is `{ linktype: "story", id: <uuid>, cached_url: "faq" }`
+ * and the Delivery API renders it per language — `/faq` on the German page,
+ * `/fr/faq` on the French one. Neither string is what the document holds.
+ * Contentful entry links and Sanity references have the same shape and the same
+ * problem. Declare one as `link` and the projection stops being invertible in
+ * both directions at once: the diff reports every reference on every page as
+ * changed because the rendered href never equals the stored object, and writing
+ * the href back replaces the reference with a hard-coded URL, which silently
+ * stops following renames — the one thing the reference was for.
+ *
+ * So the panel shows it and does not edit it. The value is carried through
+ * untouched, the way `avocadoUnknownBlock` carries a rich-text node the pivot
+ * cannot model, and `referenceLabelKey` says where to find something a person
+ * can read. Re-pointing a reference needs a picker that knows the CMS's own
+ * document ids, which only the integration has; until it exists, showing the
+ * target and refusing the edit is the honest answer and the corrupting one is
+ * a text input.
  */
-export type FieldKind = "text" | "richtext" | "url" | "link" | "file" | "image" | "imageAlt" | "enum" | "color" | "number" | "boolean" | "headingLevel";
+export type FieldKind = "text" | "richtext" | "url" | "link" | "file" | "image" | "imageAlt" | "enum" | "color" | "number" | "boolean" | "headingLevel" | "reference";
 /** Recommended image dimensions for an image field. */
 export type ImageSpec = {
     aspectRatio: "landscape" | "square" | "portrait";
@@ -76,6 +95,38 @@ export type FieldMeta = {
     }[];
     /** Whether the field is required. Auto-derived from Zod schema at registration. */
     required?: boolean;
+    /**
+     * This field is edited in the property panel and nowhere else, by design.
+     *
+     * Not every editable prop is *drawn* as an element. A `sectionId` becomes an
+     * HTML `id`; a video's `poster` and an input's `placeholder` are attributes;
+     * a form field's `key` and `type` are configuration. None of them has an
+     * element that could carry `data-editable-target`, so the preview cannot
+     * offer them and the panel is the whole of their UI.
+     *
+     * `editableCoverage` takes this as "no marker expected", which is what makes
+     * the number mean something: without it a correct integration reports 88%
+     * and the integrator gating on it has to hard-code a magic threshold, at
+     * which point a real regression that drops one marker while a new field adds
+     * another slips through. With it, 100% is reachable and anything less is
+     * actionable.
+     *
+     * `inlineEditable: false` is a *different* statement, and narrower: it says a
+     * text field is not typed into on the page, and it says nothing about images.
+     * Use this one when there is no element at all.
+     */
+    panelOnly?: boolean;
+    /**
+     * For `kind: "reference"`: the key inside the value holding something a
+     * person can read.
+     *
+     * Optional, because the common spellings are tried anyway — Storyblok's
+     * `cached_url`, a `slug`, a `title`, a `name`. Set it when the reference
+     * carries a readable key under a name nothing would guess, or when it carries
+     * several and the wrong one wins. Purely a display concern: it never selects
+     * what is written, because a reference is not written here at all.
+     */
+    referenceLabelKey?: string;
 };
 /** Metadata for list-type props (features, items, cards). */
 export type ListFieldMeta = {
@@ -116,6 +167,14 @@ export type BlockRegistration = {
 };
 /** Test seam: forget what has already been warned about. */
 export declare function resetListFieldWarnings(): void;
+/** Whether `type` is currently backed by Avocado's own definition. */
+export declare function isBuiltinBlock(type: string): boolean;
+/**
+ * Register one of Avocado's own blocks. Internal — a site uses `registerBlock`,
+ * and registering over a built-in name deliberately drops the built-in flag
+ * with the built-in schema.
+ */
+export declare function registerBuiltinBlock(type: string, config: BlockRegistration): void;
 export declare function registerBlock(type: string, config: BlockRegistration): void;
 /** Get metadata for a registered block type, or undefined. */
 export declare function getBlockMeta(type: string): BlockMeta | undefined;
@@ -205,6 +264,19 @@ export declare function isInBlockCatalogue(type: string): boolean;
 export declare function catalogueBlockTypes(): string[];
 /** Declared types with no registration behind them — a typo, or a missing import. */
 export declare function undeclaredBlockTypes(): string[];
+/**
+ * Something a person can read out of a reference value.
+ *
+ * A reference is opaque by design — the panel shows it and never rewrites it —
+ * but "opaque" must not mean `[object Object]` in the one place a person looks
+ * to check which document a CTA points at. Storyblok spells the readable half
+ * `cached_url`, Contentful puts a `slug` or `title` on the resolved entry,
+ * Sanity hands over a bare `_ref`. Falls back to the id, and then to nothing,
+ * which the panel renders as "not set" rather than as a broken label.
+ *
+ * `referenceLabelKey` wins when the meta declares it.
+ */
+export declare function referenceLabel(value: unknown, labelKey?: string): string;
 export declare function getPropDisplayName(blockType: string | undefined, propKey: string): string;
 export declare function defaultListItemForBlock(type: BlockType, listKey: string): Record<string, unknown> | null;
 /** Base schema — accepts any block type. Used for ingesting external site content with custom blocks. */

package/dist/blocks/_registry.js

@@ -68,6 +68,72 @@ function unwrapZod(schema) {
     }
     return current;
 }
+/**
+ * The object shapes a list's rows can take.
+ *
+ * A monomorphic list has one. A polymorphic list — `z.discriminatedUnion`, the
+ * shape our own docs tell an integrator to use when rows differ — has one per
+ * branch and no `.shape` of its own. Reading `.element.shape` and stopping there
+ * declared every correct polymorphic list unbacked, warned about it at startup,
+ * and prescribed `z.array(z.object({ … }))`: the one edit that really would
+ * break it, because collapsing the union is what stops each row narrowing to its
+ * own field set. The panel never used this path — it reads the JSON Schema,
+ * where the branches survive as `anyOf` — so the lists worked exactly as
+ * declared while their author was being told they could not.
+ */
+function listElementBranches(element) {
+    const unwrapped = unwrapZod(element);
+    if (!unwrapped)
+        return undefined;
+    const ownShape = unwrapped.shape;
+    if (ownShape)
+        return [{ discriminantValues: [], shape: ownShape }];
+    const def = unwrapped.def ?? unwrapped._def;
+    const options = def?.options;
+    if (!Array.isArray(options) || options.length === 0)
+        return undefined;
+    const discriminator = def?.discriminator;
+    const branches = [];
+    for (const option of options) {
+        const optionShape = unwrapZod(option)?.shape;
+        if (!optionShape)
+            continue;
+        branches.push({
+            discriminantValues: discriminator ? literalValuesOf(optionShape[discriminator]) : [],
+            shape: optionShape
+        });
+    }
+    return branches.length > 0 ? branches : undefined;
+}
+/** The values a discriminant field admits, spelled as the strings a row carries. */
+function literalValuesOf(schema) {
+    const def = unwrapZod(schema)?.def ?? unwrapZod(schema)?._def;
+    if (!def)
+        return [];
+    if (Array.isArray(def.values))
+        return def.values.map(String); // z.literal in Zod 4
+    if (def.value !== undefined)
+        return [String(def.value)]; // z.literal in Zod 3
+    if (def.entries)
+        return Object.values(def.entries).map(String); // z.enum
+    return [];
+}
+/**
+ * Fill in `required` from the Zod shapes a field set can be backed by.
+ *
+ * More than one shape means the set spans branches, and a key only one branch
+ * declares cannot be required of a row that might be another branch.
+ */
+function deriveRequired(fields, shapes) {
+    for (const [key, field] of Object.entries(fields)) {
+        if (field.required !== undefined)
+            continue;
+        const backing = shapes.filter((s) => s[key]);
+        if (backing.length === 0)
+            continue;
+        field.required = backing.length === shapes.length && backing.every((s) => !s[key].isOptional());
+    }
+}
 const warnedListFields = new Set();
 function warnUnbackedListField(type, listKey, present) {
     const key = `${type}.${listKey}`;
@@ -91,8 +157,35 @@ function warnUnbackedListField(type, listKey, present) {
 export function resetListFieldWarnings() {
     warnedListFields.clear();
 }
+/**
+ * The block types Avocado itself defines, as opposed to a site's own.
+ *
+ * A site that renders its own `Hero` registers it under that name, and from
+ * then on the name is all the two shapes have in common. Anything that reasons
+ * about a block by hard-coded key — the demo-content migrations in
+ * `session-state`, which stamp `imageUrl` and a `left`/`right` pair onto
+ * whatever is called `Hero` or `TwoColumn` — is reasoning about *our* schema,
+ * and must not run against a schema it has never seen. Registration order
+ * settles it: whoever registered last owns the name, so the flag is written on
+ * every call rather than only on the first.
+ */
+const _builtinBlockTypes = G.__ase_builtinBlockTypes ?? (G.__ase_builtinBlockTypes = new Set());
+/** Whether `type` is currently backed by Avocado's own definition. */
+export function isBuiltinBlock(type) {
+    return _builtinBlockTypes.has(type);
+}
+/**
+ * Register one of Avocado's own blocks. Internal — a site uses `registerBlock`,
+ * and registering over a built-in name deliberately drops the built-in flag
+ * with the built-in schema.
+ */
+export function registerBuiltinBlock(type, config) {
+    registerBlock(type, config);
+    _builtinBlockTypes.add(type);
+}
 export function registerBlock(type, config) {
     _blockSchemas[type] = config.schema;
+    _builtinBlockTypes.delete(type);
     // Auto-derive `required` on each FieldMeta from the Zod schema shape
     const shape = config.schema.shape;
     if (shape) {
@@ -112,18 +205,20 @@ export function registerBlock(type, config) {
                 // Without the outer unwrap, `z.array(...).optional()` — which is how a
                 // list should be declared — looked like no array at all, so every
                 // optional list silently skipped its own `required` derivation.
-                const elementShape = unwrapZod(listZod)?.element?.shape;
-                if (!elementShape) {
+                const branches = listElementBranches(unwrapZod(listZod)?.element);
+                if (!branches) {
                     warnUnbackedListField(type, listKey, listZod !== undefined);
                     continue;
                 }
-                for (const [itemKey, itemField] of Object.entries(listMeta.itemFields)) {
-                    if (itemField.required !== undefined)
+                // `itemFields` is the union of every branch — the set a row is edited
+                // against when its discriminant matches nothing — so a key is required
+                // there only if every branch has it and no branch makes it optional.
+                deriveRequired(listMeta.itemFields, branches.map((b) => b.shape));
+                for (const [value, branchFields] of Object.entries(listMeta.itemFieldsByType ?? {})) {
+                    const matching = branches.filter((b) => b.discriminantValues.includes(value));
+                    if (matching.length === 0)
                         continue;
-                    const zodItem = elementShape[itemKey];
-                    if (zodItem) {
-                        itemField.required = !zodItem.isOptional();
-                    }
+                    deriveRequired(branchFields, matching.map((b) => b.shape));
                 }
             }
         }
@@ -391,6 +486,47 @@ export function undeclaredBlockTypes() {
         return [];
     return [...declared].filter((t) => !(t in _blockSchemas));
 }
+/**
+ * Something a person can read out of a reference value.
+ *
+ * A reference is opaque by design — the panel shows it and never rewrites it —
+ * but "opaque" must not mean `[object Object]` in the one place a person looks
+ * to check which document a CTA points at. Storyblok spells the readable half
+ * `cached_url`, Contentful puts a `slug` or `title` on the resolved entry,
+ * Sanity hands over a bare `_ref`. Falls back to the id, and then to nothing,
+ * which the panel renders as "not set" rather than as a broken label.
+ *
+ * `referenceLabelKey` wins when the meta declares it.
+ */
+export function referenceLabel(value, labelKey) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "string" || typeof value === "number")
+        return String(value).trim();
+    if (typeof value !== "object" || Array.isArray(value))
+        return "";
+    const rec = value;
+    const readable = (key) => {
+        const candidate = rec[key];
+        return typeof candidate === "string" || typeof candidate === "number" ? String(candidate).trim() : "";
+    };
+    if (labelKey) {
+        const declared = readable(labelKey);
+        if (declared !== "")
+            return declared;
+    }
+    for (const key of ["cached_url", "slug", "url", "href", "title", "name", "label"]) {
+        const found = readable(key);
+        if (found !== "")
+            return found;
+    }
+    for (const key of ["_ref", "id", "_id", "uuid", "entryId"]) {
+        const found = readable(key);
+        if (found !== "")
+            return found;
+    }
+    return "";
+}
 export function getPropDisplayName(blockType, propKey) {
     if (!blockType)
         return propKey;
@@ -429,6 +565,14 @@ function defaultScalarForField(field, fieldKey) {
         return false;
     if (field.kind === "enum")
         return Array.isArray(field.options) && field.options.length > 0 ? field.options[0] : "";
+    /*
+     * A reference points at a document in the CMS. There is no default one, and
+     * `"New Story link"` in a field the site resolves to a URL is a broken link
+     * dressed as content. An added row simply has no reference until somebody
+     * sets one upstream.
+     */
+    if (field.kind === "reference")
+        return null;
     return `New ${label}`;
 }
 export function defaultListItemForBlock(type, listKey) {

package/dist/blocks/banner.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("Banner", {
+registerBuiltinBlock("Banner", {
     schema: z.object({
         text: z.string().min(1),
         variant: z.enum(["info", "success", "warning"]).default("info").catch("info"),

package/dist/blocks/card-grid.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("CardGrid", {
+registerBuiltinBlock("CardGrid", {
     schema: z.object({
         title: z.string().min(1),
         subtitle: z.string().optional(),

package/dist/blocks/card.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("Card", {
+registerBuiltinBlock("Card", {
     schema: z.object({
         title: z.string().min(1),
         description: z.string().min(1),

package/dist/blocks/carousel.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock, IMAGE_PLACEHOLDER } from "./_registry.js";
+import { registerBuiltinBlock, IMAGE_PLACEHOLDER } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("Carousel", {
+registerBuiltinBlock("Carousel", {
     schema: z.object({
         items: z.array(z.object({
             id: z.string().optional(),

package/dist/blocks/cta.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("CTA", {
+registerBuiltinBlock("CTA", {
     schema: z.object({
         title: z.string().min(1),
         description: z.string().min(1),

package/dist/blocks/embed.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("Embed", {
+registerBuiltinBlock("Embed", {
     schema: z.object({
         embedType: z.enum(["map", "social", "custom"]).default("map").catch("map"),
         url: z.string().min(1),

package/dist/blocks/faq-accordion.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("FAQAccordion", {
+registerBuiltinBlock("FAQAccordion", {
     schema: z.object({
         title: z.string().min(1),
         items: z.array(z.object({ id: z.string().optional(), q: z.string().min(1), a: z.string().min(1) })).min(1)

package/dist/blocks/feature-grid.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("FeatureGrid", {
+registerBuiltinBlock("FeatureGrid", {
     schema: z.object({
         title: z.string().min(1),
         columns: z.enum(["2", "3", "4"]).default("3").catch("3"),

package/dist/blocks/footer.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("Footer", {
+registerBuiltinBlock("Footer", {
     schema: z.object({
         copyright: z.string().min(1),
         columns: z.array(z.object({ id: z.string().optional(), title: z.string().min(1), links: z.string().min(1) })).min(1)

package/dist/blocks/gallery.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock, IMAGE_PLACEHOLDER } from "./_registry.js";
+import { registerBuiltinBlock, IMAGE_PLACEHOLDER } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("Gallery", {
+registerBuiltinBlock("Gallery", {
     schema: z.object({
         title: z.string().optional(),
         headingLevel: z.string().optional(),

package/dist/blocks/hero.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock, IMAGE_PLACEHOLDER } from "./_registry.js";
+import { registerBuiltinBlock, IMAGE_PLACEHOLDER } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("Hero", {
+registerBuiltinBlock("Hero", {
     schema: z.object({
         heading: z.string().min(1),
         subheading: z.string().min(1),

package/dist/blocks/quote.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("Quote", {
+registerBuiltinBlock("Quote", {
     schema: z.object({
         quote: z.string().min(1),
         author: z.string().optional(),

package/dist/blocks/rich-text.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("RichText", {
+registerBuiltinBlock("RichText", {
     schema: z.object({
         title: z.string(),
         body: z.string().min(1)

package/dist/blocks/site-header.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
 const navLinkLeaf = z.object({
     id: z.string().optional(),
@@ -7,7 +7,7 @@ const navLinkLeaf = z.object({
     href: z.string().min(1),
     newTab: z.boolean().optional(),
 });
-registerBlock("SiteHeader", {
+registerBuiltinBlock("SiteHeader", {
     schema: z.object({
         siteName: z.string().min(1),
         logoUrl: z.string().min(1),

package/dist/blocks/stats.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("Stats", {
+registerBuiltinBlock("Stats", {
     schema: z.object({
         title: z.string().optional(),
         stats: z.array(z.object({

package/dist/blocks/table.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("Table", {
+registerBuiltinBlock("Table", {
     schema: z.object({
         title: z.string().optional(),
         headingLevel: z.string().optional(),

package/dist/blocks/tabs.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { registerBlock } from "./_registry.js";
+import { registerBuiltinBlock } from "./_registry.js";
 import { f } from "./_helpers.js";
-registerBlock("Tabs", {
+registerBuiltinBlock("Tabs", {
     schema: z.object({
         title: z.string().optional(),
         tabs: z.array(z.object({