@avocadostudio-ai/shared 0.1.0

package/dist/blocks/_registry.js

@@ -0,0 +1,271 @@
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Placeholder image — used as default value for all image slots.
+// Treat this as "no image set" throughout the UI.
+// ---------------------------------------------------------------------------
+export const IMAGE_PLACEHOLDER = "/hero-generated.svg";
+export function isImagePlaceholder(url) {
+    if (!url)
+        return true;
+    const cleaned = url.split("?")[0].replace(/^\/+/, "");
+    return cleaned === IMAGE_PLACEHOLDER.replace(/^\/+/, "");
+}
+// ---------------------------------------------------------------------------
+// Block registry
+// ---------------------------------------------------------------------------
+// Use globalThis to ensure a single registry survives Next.js webpack module duplication
+// across RSC / SSR / API route layers. Without this, registerBlock() in custom blocks
+// populates a different registry copy than buildBlockManifest() reads.
+const G = globalThis;
+const _blockSchemas = G.__ase_blockSchemas ?? (G.__ase_blockSchemas = {});
+const _blockMeta = G.__ase_blockMeta ?? (G.__ase_blockMeta = {});
+/**
+ * Register a block type. Can be called at module load time.
+ * Re-registering the same type overwrites the previous registration.
+ */
+export function registerBlock(type, config) {
+    _blockSchemas[type] = config.schema;
+    // Auto-derive `required` on each FieldMeta from the Zod schema shape
+    const shape = config.schema.shape;
+    if (shape) {
+        for (const [key, field] of Object.entries(config.meta.fields)) {
+            if (field.required !== undefined)
+                continue; // explicit override
+            const zodField = shape[key];
+            if (zodField) {
+                field.required = !zodField.isOptional();
+            }
+        }
+        // List item fields
+        if (config.meta.listFields) {
+            for (const [listKey, listMeta] of Object.entries(config.meta.listFields)) {
+                const listZod = shape[listKey];
+                // Unwrap ZodArray → element (ZodObject)
+                const elementShape = listZod?.element?.shape;
+                if (!elementShape)
+                    continue;
+                for (const [itemKey, itemField] of Object.entries(listMeta.itemFields)) {
+                    if (itemField.required !== undefined)
+                        continue;
+                    const zodItem = elementShape[itemKey];
+                    if (zodItem) {
+                        itemField.required = !zodItem.isOptional();
+                    }
+                }
+            }
+        }
+    }
+    _blockMeta[type] = config.meta;
+    if (!config.meta.chrome && !allowedBlockTypes.includes(type)) {
+        allowedBlockTypes.push(type);
+    }
+}
+/** Get metadata for a registered block type, or undefined. */
+export function getBlockMeta(type) {
+    return _blockMeta[type];
+}
+/** Get all registered block metadata. */
+export function getAllBlockMeta() {
+    return _blockMeta;
+}
+/** Cache for getImageFields results. */
+const _imageFieldsCache = new Map();
+/** Get the set of prop keys that are image fields for a block type. */
+export function getImageFields(blockType) {
+    const cached = _imageFieldsCache.get(blockType);
+    if (cached)
+        return cached;
+    const meta = _blockMeta[blockType];
+    const result = new Set();
+    if (meta) {
+        for (const [key, fm] of Object.entries(meta.fields)) {
+            if (fm.kind === "image")
+                result.add(key);
+        }
+    }
+    _imageFieldsCache.set(blockType, result);
+    return result;
+}
+/** Cache for getListImageFields results. */
+const _listImageFieldsCache = new Map();
+/** Get list props that contain image fields: Map<listKey, Set<imageFieldKey>>. */
+export function getListImageFields(blockType) {
+    const cached = _listImageFieldsCache.get(blockType);
+    if (cached)
+        return cached;
+    const meta = _blockMeta[blockType];
+    const result = new Map();
+    if (meta?.listFields) {
+        for (const [listKey, listMeta] of Object.entries(meta.listFields)) {
+            const imageKeys = new Set();
+            for (const [fieldKey, fieldMeta] of Object.entries(listMeta.itemFields)) {
+                if (fieldMeta.kind === "image")
+                    imageKeys.add(fieldKey);
+            }
+            if (imageKeys.size > 0)
+                result.set(listKey, imageKeys);
+        }
+    }
+    _listImageFieldsCache.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;
+}
+/** Get all registered chrome block type names. */
+export function getChromeTypes() {
+    return Object.entries(_blockMeta).filter(([, meta]) => meta.chrome).map(([type]) => type);
+}
+/** Check if a field is inline-editable based on its metadata kind. */
+export function isFieldInlineEditable(type, fieldPath) {
+    const meta = _blockMeta[type];
+    if (!meta)
+        return true; // no metadata = allow (backwards compat)
+    // Handle nested paths like "features[0].title" → list "features", item field "title"
+    const listMatch = fieldPath.match(/^([a-zA-Z_]+)\[\d+\]\.(.+)$/);
+    if (listMatch) {
+        const [, listKey, itemField] = listMatch;
+        const listMeta = meta.listFields?.[listKey];
+        if (!listMeta)
+            return true;
+        const fm = listMeta.itemFields[itemField];
+        if (!fm)
+            return true;
+        if (fm.inlineEditable !== undefined)
+            return fm.inlineEditable;
+        return fm.kind === "text" || fm.kind === "richtext";
+    }
+    const fm = meta.fields[fieldPath];
+    if (!fm)
+        return true;
+    if (fm.inlineEditable !== undefined)
+        return fm.inlineEditable;
+    return fm.kind === "text" || fm.kind === "richtext";
+}
+/** Resolve the ImageSpec for a block field, handling both scalar and list item paths. */
+export function getImageSpec(blockType, fieldPath) {
+    const meta = _blockMeta[blockType];
+    if (!meta)
+        return undefined;
+    // Handle list item paths like "cards[0].imageUrl" → listField "cards", itemField "imageUrl"
+    const listMatch = fieldPath.match(/^([a-zA-Z_]+)\[\d+\]\.(.+)$/);
+    if (listMatch) {
+        const [, listKey, itemField] = listMatch;
+        return meta.listFields?.[listKey]?.itemFields[itemField]?.imageSpec;
+    }
+    // Also support bare "listKey.itemField" (no index) as a convenience lookup
+    const dotMatch = fieldPath.match(/^([a-zA-Z_]+)\.(.+)$/);
+    if (dotMatch) {
+        const [, listKey, itemField] = dotMatch;
+        const fromList = meta.listFields?.[listKey]?.itemFields[itemField]?.imageSpec;
+        if (fromList)
+            return fromList;
+    }
+    return meta.fields[fieldPath]?.imageSpec;
+}
+// ---------------------------------------------------------------------------
+// Backwards-compatible exports
+// ---------------------------------------------------------------------------
+/**
+ * Block schemas keyed by type name.
+ * Prefer `registerBlock()` for new blocks; this object is kept for backwards compat.
+ */
+export const blockSchemas = _blockSchemas;
+export const allowedBlockTypes = G.__ase_allowedBlockTypes ?? (G.__ase_allowedBlockTypes = []);
+export function getPropDisplayName(blockType, propKey) {
+    if (!blockType)
+        return propKey;
+    const meta = _blockMeta[blockType];
+    if (!meta)
+        return propKey;
+    // Check scalar fields
+    const fm = meta.fields[propKey];
+    if (fm?.label)
+        return fm.label;
+    // Check list fields
+    const lm = meta.listFields?.[propKey];
+    if (lm?.label)
+        return lm.label;
+    return propKey;
+}
+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")
+        return "/";
+    if (field.kind === "image")
+        return IMAGE_PLACEHOLDER;
+    if (field.kind === "color")
+        return "#0f766e";
+    if (field.kind === "number")
+        return 0;
+    if (field.kind === "enum")
+        return Array.isArray(field.options) && field.options.length > 0 ? field.options[0] : "";
+    return `New ${label}`;
+}
+export function defaultListItemForBlock(type, listKey) {
+    const meta = _blockMeta[type];
+    const listMeta = meta?.listFields?.[listKey];
+    if (!listMeta)
+        return null;
+    const item = {};
+    for (const [fieldKey, fieldMeta] of Object.entries(listMeta.itemFields)) {
+        item[fieldKey] = defaultScalarForField(fieldMeta, fieldKey);
+    }
+    return item;
+}
+/** Base schema — accepts any block type. Used for ingesting external site content with custom blocks. */
+export const blockInstanceSchemaLenient = z.object({
+    id: z.string().min(1),
+    type: z.string().min(1),
+    props: z.record(z.string(), z.unknown())
+});
+/** Strict variant — rejects block types not in the shared registry. */
+export const blockInstanceSchema = blockInstanceSchemaLenient.extend({
+    type: z.string().min(1).refine((t) => t in _blockSchemas, { message: "Unknown block type" }),
+});
+export function validateBlockProps(type, props) {
+    const schema = _blockSchemas[type];
+    if (!schema)
+        return { success: false, error: new z.ZodError([{ code: "custom", message: `Unknown block type: ${type}`, path: [] }]) };
+    return schema.safeParse(props);
+}
+// ---------------------------------------------------------------------------
+// JSON Schema generation
+// ---------------------------------------------------------------------------
+/**
+ * Recursively strip validation-only constraints from a JSON schema object.
+ * The editor only needs structural info (types, properties, enums), not
+ * validation rules like minLength, minimum, $schema, additionalProperties.
+ */
+function stripValidationConstraints(obj) {
+    if (Array.isArray(obj))
+        return obj.map(stripValidationConstraints);
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (key === "$schema" || key === "additionalProperties" || key === "minLength" || key === "minimum" || key === "minItems" || key === "propertyNames" || key === "default")
+            continue;
+        // Strip "required" only when it's the JSON Schema keyword (array of field names),
+        // not when it's a property definition (e.g. ContactForm's "required" boolean field)
+        if (key === "required" && Array.isArray(value))
+            continue;
+        result[key] = stripValidationConstraints(value);
+    }
+    return result;
+}
+/**
+ * Get a structural JSON schema for a registered block type.
+ * Strips validation constraints (minLength, etc.) — the editor only needs
+ * the shape to know which fields exist and their types.
+ */
+export function getBlockJsonSchema(type) {
+    const schema = _blockSchemas[type];
+    if (!schema)
+        return undefined;
+    const raw = z.toJSONSchema(schema);
+    return stripValidationConstraints(raw);
+}

package/dist/blocks/banner.d.ts

@@ -0,0 +1 @@
+export declare function bannerDefaultProps(): Record<string, unknown>;

package/dist/blocks/banner.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { registerBlock } from "./_registry.js";
+import { f } from "./_helpers.js";
+registerBlock("Banner", {
+    schema: z.object({
+        text: z.string().min(1),
+        variant: z.enum(["info", "success", "warning"]).default("info").catch("info"),
+        ctaText: z.string().optional(),
+        ctaHref: z.string().optional(),
+        backgroundColor: z.string().optional(),
+        textColor: z.string().optional(),
+    }),
+    meta: {
+        displayName: "Banner",
+        description: "Full-width announcement or alert bar with optional call-to-action button. Use variant for preset themes, or backgroundColor/textColor for custom colors.",
+        category: "content",
+        fields: {
+            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"),
+            backgroundColor: { kind: "color", label: "Background color", inlineEditable: false },
+            textColor: { kind: "color", label: "Text color", inlineEditable: false },
+        },
+    }
+});
+export function bannerDefaultProps() {
+    return {
+        text: "We just launched something new — check it out!",
+        variant: "info",
+        ctaText: "Learn more",
+        ctaHref: "/",
+    };
+}

package/dist/blocks/card-grid.d.ts

@@ -0,0 +1 @@
+export declare function cardGridDefaultProps(): Record<string, unknown>;

package/dist/blocks/card-grid.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { registerBlock } from "./_registry.js";
+import { f } from "./_helpers.js";
+registerBlock("CardGrid", {
+    schema: z.object({
+        title: z.string().min(1),
+        subtitle: z.string().optional(),
+        columns: z.enum(["2", "3", "4"]).default("3").catch("3"),
+        cardVariant: z.enum(["default", "full-bleed"]).default("default").catch("default"),
+        cards: z
+            .array(z.object({
+            id: z.string().optional(),
+            title: z.string().min(1),
+            description: z.string().min(1),
+            ctaText: z.string().min(1),
+            ctaHref: z.string().min(1),
+            imageUrl: z.string().min(1).optional(),
+            imageAlt: z.string().min(1).optional()
+        }))
+            .min(1)
+    }),
+    meta: {
+        displayName: "Card Grid",
+        description: "Grid of cards, each with title, description, and CTA.",
+        category: "content",
+        fields: {
+            title: f.text("Section title"),
+            subtitle: f.text("Subtitle"),
+            columns: { kind: "enum", label: "Columns", options: ["2", "3", "4"], inlineEditable: false },
+            cardVariant: { kind: "enum", label: "Card style", options: ["default", "full-bleed"], inlineEditable: false },
+            headingLevel: f.headingLevel(),
+        },
+        listFields: {
+            cards: {
+                label: "Cards",
+                itemFields: {
+                    title: f.text("Card title"),
+                    description: f.longtext("Card description"),
+                    ctaText: f.text("Button text"),
+                    ctaHref: f.url("Button link"),
+                    imageUrl: f.image("Card image", { aspectRatio: "landscape", width: 768, height: 512 }),
+                    imageAlt: f.imageAlt("Card image alt text"),
+                }
+            }
+        }
+    }
+});
+export function cardGridDefaultProps() {
+    return {
+        title: "Explore more",
+        columns: "3",
+        cards: [
+            {
+                title: "Fast setup",
+                description: "Create and ship updates quickly.",
+                ctaText: "Get started",
+                ctaHref: "/"
+            },
+            {
+                title: "Safe updates",
+                description: "Schema-validated edits reduce breakage.",
+                ctaText: "See how",
+                ctaHref: "/pricing"
+            },
+            {
+                title: "Team workflow",
+                description: "Collaborate with clear, reviewable changes.",
+                ctaText: "Read guide",
+                ctaHref: "/"
+            }
+        ]
+    };
+}

package/dist/blocks/card.d.ts

@@ -0,0 +1 @@
+export declare function cardDefaultProps(): Record<string, unknown>;

package/dist/blocks/card.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { registerBlock } from "./_registry.js";
+import { f } from "./_helpers.js";
+registerBlock("Card", {
+    schema: z.object({
+        title: z.string().min(1),
+        description: z.string().min(1),
+        ctaText: z.string().min(1),
+        ctaHref: z.string().min(1),
+        imageUrl: z.string().min(1).optional(),
+        imageAlt: z.string().min(1).optional(),
+        variant: z.enum(["default", "full-bleed"]).default("default").catch("default"),
+    }),
+    meta: {
+        displayName: "Card",
+        description: "Single prominent card with a CTA. Use 'full-bleed' variant for background image with dark overlay and white text.",
+        category: "content",
+        fields: {
+            title: f.text("Card title"),
+            description: f.longtext("Card description"),
+            ctaText: f.text("Button text"),
+            ctaHref: f.url("Button link"),
+            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 },
+            headingLevel: f.headingLevel(),
+        }
+    }
+});
+export function cardDefaultProps() {
+    return {
+        title: "Launch faster",
+        description: "Go from idea to published changes in minutes.",
+        ctaText: "Learn more",
+        ctaHref: "/pricing"
+    };
+}

package/dist/blocks/carousel.d.ts

@@ -0,0 +1 @@
+export declare function carouselDefaultProps(): Record<string, unknown>;

package/dist/blocks/carousel.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { registerBlock, IMAGE_PLACEHOLDER } from "./_registry.js";
+import { f } from "./_helpers.js";
+registerBlock("Carousel", {
+    schema: z.object({
+        items: z.array(z.object({
+            id: z.string().optional(),
+            imageUrl: z.string().min(1),
+            imageAlt: z.string().optional(),
+            heading: z.string().optional(),
+            description: z.string().optional(),
+            ctaText: z.string().optional(),
+            ctaHref: z.string().optional(),
+        })).min(1),
+        autoplay: z.enum(["true", "false"]).default("false").catch("false"),
+        interval: z.number().optional(),
+    }),
+    meta: {
+        displayName: "Carousel",
+        description: "Image/content slideshow with prev/next navigation and dot indicators.",
+        category: "content",
+        fields: {
+            autoplay: { kind: "enum", label: "Autoplay", options: ["true", "false"], inlineEditable: false },
+            interval: { kind: "number", label: "Interval (ms)", inlineEditable: false },
+        },
+        listFields: {
+            items: {
+                label: "Slides",
+                itemFields: {
+                    imageUrl: f.image("Slide image", { aspectRatio: "landscape", width: 1200, height: 600 }),
+                    imageAlt: f.imageAlt("Image alt text"),
+                    heading: f.text("Heading"),
+                    description: f.longtext("Description"),
+                    ctaText: f.text("Button label"),
+                    ctaHref: f.url("Button link"),
+                }
+            }
+        }
+    }
+});
+export function carouselDefaultProps() {
+    return {
+        items: [
+            { imageUrl: IMAGE_PLACEHOLDER, imageAlt: "First slide", heading: "Welcome", description: "Get started with our platform.", ctaText: "Get started", ctaHref: "/" },
+            { imageUrl: IMAGE_PLACEHOLDER, imageAlt: "Second slide", heading: "Features", description: "Discover what makes us different." },
+            { imageUrl: IMAGE_PLACEHOLDER, imageAlt: "Third slide", heading: "Get Started", description: "Sign up today and start building.", ctaText: "Sign up", ctaHref: "/pricing" },
+        ],
+        autoplay: "false",
+        interval: 5000,
+    };
+}

package/dist/blocks/cta.d.ts

@@ -0,0 +1 @@
+export declare function ctaDefaultProps(): Record<string, unknown>;

package/dist/blocks/cta.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { registerBlock } from "./_registry.js";
+import { f } from "./_helpers.js";
+registerBlock("CTA", {
+    schema: z.object({
+        title: z.string().min(1),
+        description: z.string().min(1),
+        ctaText: z.string().min(1),
+        ctaHref: z.string().min(1),
+        secondaryCtaText: z.string().optional(),
+        secondaryCtaHref: z.string().optional()
+    }),
+    meta: {
+        displayName: "Call to Action",
+        description: "Centered promotional section with primary and optional secondary button.",
+        category: "conversion",
+        fields: {
+            title: f.text("Headline"),
+            description: f.longtext("Description"),
+            ctaText: f.text("Button text"),
+            ctaHref: f.url("Button link"),
+            secondaryCtaText: f.text("Secondary button text"),
+            secondaryCtaHref: f.url("Secondary button link"),
+            headingLevel: f.headingLevel(),
+        }
+    }
+});
+export function ctaDefaultProps() {
+    return {
+        title: "Ready to get started?",
+        description: "Apply your next change in seconds.",
+        ctaText: "Start now",
+        ctaHref: "/"
+    };
+}

package/dist/blocks/embed.d.ts

@@ -0,0 +1 @@
+export declare function embedDefaultProps(): Record<string, unknown>;

package/dist/blocks/embed.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { registerBlock } from "./_registry.js";
+import { f } from "./_helpers.js";
+registerBlock("Embed", {
+    schema: z.object({
+        embedType: z.enum(["map", "social", "custom"]).default("map").catch("map"),
+        url: z.string().min(1),
+        title: z.string().optional(),
+        aspectRatio: z.enum(["16:9", "4:3", "1:1"]).default("16:9").catch("16:9"),
+    }),
+    meta: {
+        displayName: "Embed",
+        description: "Embed external content — Google Maps, social media posts, or a custom iframe. For video use the Video block instead.",
+        category: "media",
+        fields: {
+            embedType: { kind: "enum", label: "Embed type", options: ["map", "social", "custom"], inlineEditable: false },
+            url: f.url("URL"),
+            title: f.text("Title / caption"),
+            aspectRatio: { kind: "enum", label: "Aspect ratio", options: ["16:9", "4:3", "1:1"], inlineEditable: false },
+        },
+    }
+});
+export function embedDefaultProps() {
+    return {
+        embedType: "map",
+        url: "https://www.google.com/maps/embed?pb=!1m18!1m12!1m3!1d3153.0!2d-122.4194!3d37.7749!2m3!1f0!2f0!3f0!3m2!1i1024!2i768!4f13.1!3m3!1m2!1s0x0%3A0x0!2zMzfCsDQ2JzI5LjYiTiAxMjLCsDI1JzA5LjgiVw!5e0!3m2!1sen!2sus!4v1",
+        title: "",
+        aspectRatio: "16:9",
+    };
+}

package/dist/blocks/faq-accordion.d.ts

@@ -0,0 +1 @@
+export declare function faqAccordionDefaultProps(): Record<string, unknown>;

package/dist/blocks/faq-accordion.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { registerBlock } from "./_registry.js";
+import { f } from "./_helpers.js";
+registerBlock("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)
+    }),
+    meta: {
+        displayName: "FAQ Accordion",
+        description: "Expandable question-and-answer section.",
+        category: "content",
+        fields: { title: f.text("Section title"), headingLevel: f.headingLevel() },
+        listFields: {
+            items: {
+                label: "FAQ items",
+                itemFields: { q: f.text("Question"), a: f.richtext("Answer") }
+            }
+        }
+    }
+});
+export function faqAccordionDefaultProps() {
+    return {
+        title: "Frequently asked questions",
+        items: [
+            { q: "How fast can we publish?", a: "Most teams ship updates in minutes." },
+            { q: "Can we revise later?", a: "Yes, every block can be updated anytime." }
+        ]
+    };
+}

package/dist/blocks/feature-grid.d.ts

@@ -0,0 +1 @@
+export declare function featureGridDefaultProps(): Record<string, unknown>;

package/dist/blocks/feature-grid.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { registerBlock } from "./_registry.js";
+import { f } from "./_helpers.js";
+registerBlock("FeatureGrid", {
+    schema: z.object({
+        title: z.string().min(1),
+        columns: z.enum(["2", "3", "4"]).default("3").catch("3"),
+        features: z.array(z.object({
+            id: z.string().optional(),
+            icon: z.string().optional(),
+            title: z.string().min(1),
+            description: z.string().min(1)
+        })).min(1)
+    }),
+    meta: {
+        displayName: "Feature Grid",
+        description: "Grid of feature cards with optional icon, title, and description.",
+        category: "content",
+        fields: {
+            title: f.text("Section title"),
+            columns: { kind: "enum", label: "Columns", options: ["2", "3", "4"], inlineEditable: false },
+            headingLevel: f.headingLevel(),
+        },
+        listFields: {
+            features: {
+                label: "Features",
+                itemFields: {
+                    icon: f.text("Icon (single emoji)"),
+                    title: f.text("Feature title"),
+                    description: f.longtext("Feature description"),
+                }
+            }
+        }
+    }
+});
+export function featureGridDefaultProps() {
+    return {
+        title: "Key features",
+        columns: "3",
+        features: [
+            { icon: "\u26A1", title: "Fast setup", description: "Launch quickly with guided defaults." },
+            { icon: "\uD83D\uDEE1\uFE0F", title: "Safe edits", description: "Structured operations keep content valid." },
+            { icon: "\uD83D\uDD04", title: "Live updates", description: "Preview changes immediately." }
+        ]
+    };
+}

package/dist/blocks/footer.d.ts

@@ -0,0 +1 @@
+export declare function footerDefaultProps(): Record<string, unknown>;