@avocadostudio-ai/shared 0.1.0 → 0.2.0

package/dist/block-manifest.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { catalogueBlockTypes, getBlockJsonSchema, getBlockMeta } from "./blocks/_registry.js";
+import { declaredDefaultPropsForType } from "./blocks/index.js";
 export const jsonSchemaLikeSchema = z.lazy(() => z.object({
     type: z.string().optional(),
     properties: z.record(z.string(), jsonSchemaLikeSchema).optional(),
@@ -11,12 +13,68 @@ export const jsonSchemaLikeSchema = z.lazy(() => z.object({
     additionalProperties: z.union([z.boolean(), jsonSchemaLikeSchema]).optional(),
     description: z.string().optional()
 }).catchall(z.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 const fieldMetaSchema = z.object({
+    kind: z.enum(["text", "richtext", "url", "image", "imageAlt", "enum", "color", "number", "boolean", "headingLevel"]),
+    label: z.string().optional(),
+    inlineEditable: z.boolean().optional(),
+    options: z.array(z.string()).optional(),
+    imageSpec: z
+        .object({
+        aspectRatio: z.enum(["landscape", "square", "portrait"]),
+        width: z.number(),
+        height: z.number(),
+        format: z.enum(["png", "webp", "jpeg"]).optional()
+    })
+        .optional(),
+    multiline: z.boolean().optional(),
+    inline: z.boolean().optional(),
+    decorators: z
+        .array(z.object({ name: z.string().min(1), title: z.string().optional() }))
+        .optional(),
+    required: z.boolean().optional()
+});
+export const listFieldMetaSchema = z.object({
+    label: z.string().optional(),
+    itemFields: z.record(z.string(), fieldMetaSchema).optional(),
+    discriminator: z.string().optional(),
+    itemFieldsByType: z.record(z.string(), z.record(z.string(), fieldMetaSchema)).optional()
+});
 export const blockDefinitionSchema = z.object({
     type: z.string().min(1),
     displayName: z.string().min(1).optional(),
     editablePaths: z.array(z.string().min(1)).optional(),
     propsSchema: jsonSchemaLikeSchema,
-    defaultProps: z.record(z.string(), z.unknown()).optional()
+    defaultProps: z.record(z.string(), z.unknown()).optional(),
+    /**
+     * Optional editing metadata, merged over what the schema implies.
+     *
+     * `propsSchema` stays the source of truth for *which* props exist; this only
+     * refines how the ones already there are presented.
+     */
+    fields: z.record(z.string(), fieldMetaSchema).optional(),
+    listFields: z.record(z.string(), listFieldMetaSchema).optional(),
+    /**
+     * How the block presents itself in a catalogue, and whether it can be placed
+     * at all. None of the three is derivable from `propsSchema`.
+     *
+     * `chrome` is the one that changes what a caller may do: a chrome block is
+     * structurally pinned — always present, never added, moved or removed. An
+     * agent reading this manifest to decide what to insert needs to be told
+     * that, or it plans an `add_block` the ops engine will refuse.
+     */
+    category: z.string().min(1).optional(),
+    description: z.string().min(1).optional(),
+    chrome: z.boolean().optional()
 });
 export const blockManifestSchema = z.object({
     version: z.number().int().positive(),
@@ -25,42 +83,99 @@ export const blockManifestSchema = z.object({
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-export function validateByJsonSchemaLike(schema, value) {
+/** Name a runtime value the way an error message should: array, not object. */
+function describeValue(value) {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+/**
+ * Validate, and say what went wrong.
+ *
+ * The boolean form below could only report "does not match block manifest
+ * schema" — which is what an integrator saw when a plan wrote one prop of the
+ * wrong type, on a block with a dozen of them. The same failing patch reported
+ * through the registered-schema path said "bullets: expected string, received
+ * array". Two validators, one useless message, and the useful one was the path
+ * NOT taken when a manifest was supplied — so custom blocks, the case that
+ * needs the detail most, got the least.
+ *
+ * Returns the first issue found, or null when the value matches. It reports on
+ * exactly the constraints the boolean form enforced, with one deliberate
+ * loosening since — a key holding `undefined` counts as absent, see below.
+ * Note that `enum` and `const` are among the constraints it does not enforce —
+ * a value outside a declared enum still passes here.
+ */
+export function findManifestSchemaIssue(schema, value, path = "") {
     const type = typeof schema.type === "string" ? schema.type : undefined;
+    const here = path || "(root)";
+    const child = (key) => (path ? `${path}.${key}` : key);
     if (type === "object") {
         if (!isObject(value))
-            return false;
+            return { path: here, message: `expected object, received ${describeValue(value)}` };
         const props = isObject(schema.properties) ? schema.properties : {};
-        const required = Array.isArray(schema.required) ? schema.required.filter((item) => typeof item === "string") : [];
+        const required = Array.isArray(schema.required)
+            ? schema.required.filter((item) => typeof item === "string")
+            : [];
+        /*
+         * A key holding `undefined` is absent.
+         *
+         * `JSON.stringify` drops such a key, so over HTTP this distinction cannot
+         * reach us at all — every request arrives with the key simply missing. In
+         * library mode the orchestrator runs in the consumer's own process and the
+         * props object is passed by reference, so `{ imageRatio: undefined }`
+         * survives and used to be rejected as "expected string, received
+         * undefined" — for an *optional* field, on a value the same code accepts
+         * over the wire. Zod agrees with the wire: `z.enum(...).optional()` takes
+         * `undefined`. Treating it as absent is what makes the two transports and
+         * the two validators say the same thing.
+         */
         for (const key of required) {
-            if (!(key in value))
-                return false;
+            if (!(key in value) || value[key] === undefined) {
+                return { path: child(key), message: "required, but missing" };
+            }
         }
         for (const [key, propSchema] of Object.entries(props)) {
-            if (!(key in value))
+            if (!(key in value) || value[key] === undefined)
                 continue;
             if (!isObject(propSchema))
                 continue;
-            if (!validateByJsonSchemaLike(propSchema, value[key]))
-                return false;
+            const issue = findManifestSchemaIssue(propSchema, value[key], child(key));
+            if (issue)
+                return issue;
         }
-        return true;
+        return null;
     }
     if (type === "array") {
         if (!Array.isArray(value))
-            return false;
+            return { path: here, message: `expected array, received ${describeValue(value)}` };
         const items = schema.items;
-        if (isObject(items))
-            return value.every((item) => validateByJsonSchemaLike(items, item));
-        return true;
+        if (isObject(items)) {
+            for (let i = 0; i < value.length; i++) {
+                const issue = findManifestSchemaIssue(items, value[i], `${path}[${i}]`);
+                if (issue)
+                    return issue;
+            }
+        }
+        return null;
     }
-    if (type === "string")
-        return typeof value === "string";
-    if (type === "number" || type === "integer")
-        return typeof value === "number" && Number.isFinite(value);
-    if (type === "boolean")
-        return typeof value === "boolean";
-    return true;
+    if (type === "string" && typeof value !== "string") {
+        return { path: here, message: `expected string, received ${describeValue(value)}` };
+    }
+    if ((type === "number" || type === "integer") && !(typeof value === "number" && Number.isFinite(value))) {
+        return { path: here, message: `expected ${type}, received ${describeValue(value)}` };
+    }
+    if (type === "boolean" && typeof value !== "boolean") {
+        return { path: here, message: `expected boolean, received ${describeValue(value)}` };
+    }
+    return null;
+}
+export function validateByJsonSchemaLike(schema, value) {
+    return findManifestSchemaIssue(schema, value) === null;
 }
 // ---------------------------------------------------------------------------
 // Derive FieldMeta from JSON Schema — fallback for custom blocks not in the
@@ -86,6 +201,17 @@ function inferFieldKind(key, schema) {
     const type = typeof schema.type === "string" ? schema.type : undefined;
     if (isProseMirrorDocSchema(schema))
         return "richtext";
+    /*
+     * A markdown string, declared the way JSON Schema already provides for.
+     *
+     * Without this an integrator has no way to say "this string is prose": every
+     * plain string infers as `text`, so an external block's body field got a bare
+     * textarea and none of the rich-text handling, whatever it actually held.
+     * `contentMediaType` is standard vocabulary — no proprietary annotation, and
+     * a validator that does not know about it simply ignores it.
+     */
+    if (type === "string" && schema.contentMediaType === "text/markdown")
+        return "richtext";
     if (type === "boolean")
         return "boolean";
     if (type !== "string" && type !== "number" && type !== "integer")
@@ -127,7 +253,7 @@ function deriveItemFields(itemSchema) {
  * field gets the richtext editor — and the underlying document is edited as-is,
  * not flattened to a string.
  */
-function isProseMirrorDocSchema(schema) {
+export function isProseMirrorDocSchema(schema) {
     if (!isObject(schema) || schema.type !== "object" || !isObject(schema.properties))
         return false;
     return constValue(schema.properties.type) === "doc";
@@ -245,3 +371,161 @@ export function validateManifestDefaultProps(blocks) {
     }
     return null;
 }
+/**
+ * The field metadata a manifest block should actually be edited with.
+ *
+ * Derived from the JSON schema, then refined by whatever the definition
+ * declared. Every surface that renders a manifest block — the property panel,
+ * the Puck adapter, the planner's block contracts, an integration's own
+ * boundary code — has to agree on this, so it lives here rather than being
+ * re-derived four times with four sets of assumptions.
+ *
+ * Two rules:
+ *
+ * - `propsSchema` decides *which* props exist. A declared entry for a key the
+ *   schema does not expose is ignored, not added — otherwise a stale manifest
+ *   would put a control on a prop the block cannot store.
+ * - A declared entry is merged *over* the derived one, key by key, so a site
+ *   can supply just `multiline` and keep the label and options that were
+ *   inferred for it.
+ */
+export function resolveManifestFieldMeta(definition) {
+    const { fields, listFields } = deriveFieldMetaFromSchema(definition.propsSchema);
+    const declaredFields = isObject(definition.fields) ? definition.fields : {};
+    const resolvedFields = {};
+    for (const [key, derived] of Object.entries(fields)) {
+        const declared = declaredFields[key];
+        resolvedFields[key] = isObject(declared) ? { ...derived, ...declared } : derived;
+    }
+    const declaredLists = isObject(definition.listFields) ? definition.listFields : {};
+    const resolvedListFields = {};
+    for (const [key, derived] of Object.entries(listFields)) {
+        const declared = declaredLists[key];
+        if (!isObject(declared)) {
+            resolvedListFields[key] = derived;
+            continue;
+        }
+        const declaredItems = isObject(declared.itemFields) ? declared.itemFields : {};
+        const itemFields = {};
+        for (const [itemKey, derivedItem] of Object.entries(derived.itemFields)) {
+            const declaredItem = declaredItems[itemKey];
+            itemFields[itemKey] = isObject(declaredItem)
+                ? { ...derivedItem, ...declaredItem }
+                : derivedItem;
+        }
+        resolvedListFields[key] = { ...derived, ...declared, itemFields };
+    }
+    return { fields: resolvedFields, listFields: resolvedListFields };
+}
+// ---------------------------------------------------------------------------
+// Manifest construction
+// ---------------------------------------------------------------------------
+/**
+ * Build a manifest describing every block type registered in THIS process.
+ *
+ * Built fresh on every call rather than memoised, because the registry is not
+ * fixed at module load: a site's custom blocks call `registerBlock()` from its
+ * own `blocks/register.ts`, which may run after this module was first imported.
+ * A cached manifest is a manifest missing exactly the blocks the caller most
+ * needs to know about.
+ *
+ * This lives in `shared`, not in the SDK, because two very different consumers
+ * need the same answer. The editor asks the *site* for it over
+ * `/api/editor/blocks`; an MCP agent asks the *orchestrator*, which in library
+ * mode is mounted in that same site process and so shares its registry. Keeping
+ * one builder is what makes those two answers the same answer.
+ */
+export function buildBlockManifest() {
+    /*
+     * The site's catalogue, not the registry.
+     *
+     * These are the same list until a site declares otherwise — and a Tier B site
+     * has to, because importing anything from this package registers Avocado's 18
+     * built-ins whether or not the site has a renderer for one. PBA's manifest
+     * offered 32 types for 14 renderers; an agent that took the list at its word
+     * could add a `Hero` that applied cleanly and drew nothing.
+     */
+    const blocks = catalogueBlockTypes()
+        .map((type) => {
+        const meta = getBlockMeta(type);
+        const propsSchema = getBlockJsonSchema(type);
+        if (!propsSchema)
+            return null; // skip blocks without schema (shouldn't happen but be safe)
+        const finalSchema = applyMetaEnumsToSchema(propsSchema, meta);
+        /*
+         * Only blocks that declare defaults get a `defaultProps`.
+         *
+         * This used to attach `defaultPropsForType(type)` whenever it validated
+         * against the schema, which sounds like the same rule and is not: the
+         * generic CTA-shaped fallback that function hands to every *custom* block
+         * validates against any schema permissive enough to allow unknown keys —
+         * and a site's own blocks are usually registered with a catchall so chat
+         * edits don't strip props the site cares about. So `get-block-schema
+         * pba_heroImage` answered with a `title`/`description`/`ctaText`/`ctaHref`
+         * shape that appears nowhere in that block's own schema, and an agent
+         * following it would have built a broken block.
+         *
+         * The validation guard stays underneath: a declared default that violates
+         * its own schema is still dropped rather than allowed to fail
+         * `validateManifestDefaultProps` and poison the whole manifest, which
+         * would make every block read as "unknown" in the editor.
+         */
+        const candidateDefaults = declaredDefaultPropsForType(type);
+        const defaultProps = candidateDefaults && validateByJsonSchemaLike(finalSchema, candidateDefaults)
+            ? candidateDefaults
+            : undefined;
+        return {
+            type,
+            displayName: meta?.displayName ?? type,
+            propsSchema: finalSchema,
+            defaultProps,
+            /*
+             * Carry the block's own field metadata, not just its schema.
+             *
+             * `kind` and `multiline` have no JSON Schema spelling, so a manifest
+             * built from the schema alone hands every string the same one-line
+             * input — a site that declared `richtext` for a body paragraph got the
+             * control it would have got for a one-word headline. The consumer
+             * merges this over what it derives; the schema still decides which
+             * props exist.
+             */
+            ...(meta?.fields ? { fields: meta.fields } : {}),
+            ...(meta?.listFields ? { listFields: meta.listFields } : {}),
+            ...(meta?.category ? { category: meta.category } : {}),
+            ...(meta?.description ? { description: meta.description } : {}),
+            ...(meta?.chrome === true ? { chrome: true } : {})
+        };
+    })
+        .filter((b) => b !== null);
+    return { version: 1, blocks };
+}
+/**
+ * Fold enum options declared in the block's registry `meta.fields` into the
+ * derived JSON schema. A site can declare `f.enum("Gap", ["sm","md","lg"])` in
+ * its block meta while the Zod prop stays a plain `z.string()` (so any value
+ * still validates). Without this, manifest-driven custom blocks lose the enum
+ * and the editor renders a free-text input instead of a dropdown. We only add
+ * `enum` (the editor reads it to pick a select control); validation is type-only
+ * (see validateByJsonSchemaLike), so widening here never rejects stored content.
+ */
+function applyMetaEnumsToSchema(schema, meta) {
+    if (!meta?.fields)
+        return schema;
+    const properties = schema.properties;
+    if (!properties || typeof properties !== "object")
+        return schema;
+    let next;
+    for (const [key, fieldMeta] of Object.entries(meta.fields)) {
+        if (fieldMeta.kind !== "enum" || !fieldMeta.options?.length)
+            continue;
+        const prop = properties[key];
+        if (!prop || typeof prop !== "object" || Array.isArray(prop))
+            continue;
+        const propObj = prop;
+        if (Array.isArray(propObj.enum))
+            continue; // schema already carries an enum
+        next ??= { ...schema, properties: { ...properties } };
+        next.properties[key] = { ...propObj, type: "string", enum: [...fieldMeta.options] };
+    }
+    return next ?? schema;
+}

package/dist/blocks/_registry.d.ts

@@ -23,6 +23,40 @@ export type FieldMeta = {
     imageSpec?: ImageSpec;
     /** Render as a textarea in the PropertyPanel instead of a single-line input. */
     multiline?: boolean;
+    /**
+     * This rich-text value is one line: marks, no block structure.
+     *
+     * A headline is not a document. It carries character styles — a brand
+     * highlight, a bold phrase — but a paragraph break, a bullet list or an H2
+     * inside it is meaningless, and offering those controls invites an editor to
+     * break the design. Declaring `inline` gives the field the document editor
+     * with only the mark controls, and a schema whose top node holds a single
+     * paragraph.
+     *
+     * Only meaningful with `kind: "richtext"` on a document-valued prop. The
+     * value must genuinely be one paragraph: ProseMirror drops what its schema
+     * cannot hold, so declaring this on a multi-block value would discard every
+     * block after the first.
+     */
+    inline?: boolean;
+    /**
+     * Character styles this rich-text field permits beyond the built-in set.
+     *
+     * A *decorator* in the rich-text sense: a boolean toggle over a range that
+     * carries no data, the same kind of thing bold and italic are. Every CMS has
+     * a name for them — Portable Text calls them `decorators`, ProseMirror calls
+     * them marks with no attributes — and every CMS lets a project declare its
+     * own. Avocado's built-in five cannot cover a site's brand highlight, so a
+     * block declares the extra names here and the document editor accepts them
+     * instead of deleting them on load.
+     *
+     * Marks that carry *data* (a link's href, a reference to another document)
+     * are a different thing and are not declared this way.
+     */
+    decorators?: {
+        name: string;
+        title?: string;
+    }[];
     /** Whether the field is required. Auto-derived from Zod schema at registration. */
     required?: boolean;
 };
@@ -90,6 +124,30 @@ export declare function getImageSpec(blockType: string, fieldPath: string): Imag
  */
 export declare const blockSchemas: Record<string, z.ZodObject<any, z.core.$strip>>;
 export declare const allowedBlockTypes: string[];
+/**
+ * Declare the block types this site renders. Pass `null` to lift a declaration.
+ *
+ * Call it once, from wherever the site registers its blocks. Order does not
+ * matter: this records names, and the manifest is rebuilt per request.
+ *
+ * A declared type that is never registered is not an error here — it simply has
+ * no schema to describe, so it does not reach the manifest. `undeclaredBlockTypes()`
+ * exists so a caller that wants to complain about that can.
+ */
+export declare function declareBlockCatalogue(types: readonly string[] | null): void;
+/** The declared catalogue, or null when the site has not declared one. */
+export declare function getBlockCatalogue(): ReadonlySet<string> | null;
+/**
+ * Whether a type belongs to this site's catalogue.
+ *
+ * True for everything when no catalogue is declared — the guard has to be
+ * invisible to the sites that never opted in.
+ */
+export declare function isInBlockCatalogue(type: string): boolean;
+/** Registered, non-chrome types this site renders — `allowedBlockTypes` through the catalogue. */
+export declare function catalogueBlockTypes(): string[];
+/** Declared types with no registration behind them — a typo, or a missing import. */
+export declare function undeclaredBlockTypes(): 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

@@ -173,6 +173,72 @@ export function getImageSpec(blockType, fieldPath) {
  */
 export const blockSchemas = _blockSchemas;
 export const allowedBlockTypes = G.__ase_allowedBlockTypes ?? (G.__ase_allowedBlockTypes = []);
+// ---------------------------------------------------------------------------
+// The catalogue a site actually renders
+// ---------------------------------------------------------------------------
+/*
+ * `allowedBlockTypes` answers "what is registered", which is not the same
+ * question as "what can this site draw".
+ *
+ * Importing anything at all from this package registers Avocado's built-ins,
+ * transitively and unavoidably — so a site that brought its own fourteen block
+ * types advertised thirty-two, and an agent reading that list could add a `Hero`
+ * that applied cleanly and rendered nothing. The registry was not lying: the
+ * built-ins really are registered. They are simply registered in a process that
+ * has no renderer for them.
+ *
+ * A site declares its catalogue and the two questions come apart. Declaring
+ * nothing keeps the old behaviour exactly, which is what every Tier A site and
+ * every example wants: there, registered and renderable are the same set.
+ *
+ * Stored on `globalThis` for the same reason the registries above are — Next
+ * duplicates this module across the RSC / SSR / route-handler layers, and a
+ * declaration made in one copy has to be visible to the manifest built in
+ * another.
+ */
+function catalogueSlot() {
+    return G.__ase_blockCatalogue ??
+        (G.__ase_blockCatalogue = { types: null });
+}
+/**
+ * Declare the block types this site renders. Pass `null` to lift a declaration.
+ *
+ * Call it once, from wherever the site registers its blocks. Order does not
+ * matter: this records names, and the manifest is rebuilt per request.
+ *
+ * A declared type that is never registered is not an error here — it simply has
+ * no schema to describe, so it does not reach the manifest. `undeclaredBlockTypes()`
+ * exists so a caller that wants to complain about that can.
+ */
+export function declareBlockCatalogue(types) {
+    catalogueSlot().types = types === null ? null : new Set(types);
+}
+/** The declared catalogue, or null when the site has not declared one. */
+export function getBlockCatalogue() {
+    return catalogueSlot().types;
+}
+/**
+ * Whether a type belongs to this site's catalogue.
+ *
+ * True for everything when no catalogue is declared — the guard has to be
+ * invisible to the sites that never opted in.
+ */
+export function isInBlockCatalogue(type) {
+    const declared = catalogueSlot().types;
+    return declared === null || declared.has(type);
+}
+/** Registered, non-chrome types this site renders — `allowedBlockTypes` through the catalogue. */
+export function catalogueBlockTypes() {
+    const declared = catalogueSlot().types;
+    return declared === null ? allowedBlockTypes : allowedBlockTypes.filter((t) => declared.has(t));
+}
+/** Declared types with no registration behind them — a typo, or a missing import. */
+export function undeclaredBlockTypes() {
+    const declared = catalogueSlot().types;
+    if (declared === null)
+        return [];
+    return [...declared].filter((t) => !(t in _blockSchemas));
+}
 export function getPropDisplayName(blockType, propKey) {
     if (!blockType)
         return propKey;

package/dist/blocks/footer.js

@@ -15,7 +15,26 @@ registerBlock("Footer", {
         listFields: {
             columns: {
                 label: "Footer columns",
-                itemFields: { title: f.text("Column title"), links: f.richtext("Links (one label|url per line)") }
+                itemFields: {
+                    title: f.text("Column title"),
+                    /*
+                     * A newline-delimited list of `label|url` pairs — NOT prose.
+                     *
+                     * This was `f.richtext`, which put a markdown editor on it. Markdown
+                     * has no bare newline: Tiptap parsed the lines as one paragraph with
+                     * a soft break and serialised it back with a space, so a single
+                     * keystroke turned "Features|/features\nPricing|/pricing" into
+                     * "Features|/features Pricing|/pricing" — one link, with the rest of
+                     * the column swallowed into its href. Footer is a chrome block, so
+                     * that was live on every page of every site.
+                     *
+                     * A plain textarea preserves the separator. The real fix is a field
+                     * kind for a list of scalars, which needs a schema change and a
+                     * migration of stored footers; until then, do not put a prose editor
+                     * on a delimited value.
+                     */
+                    links: f.longtext("Links (one label|url per line)")
+                }
             }
         }
     }

package/dist/blocks/index.d.ts

@@ -1,3 +1,19 @@
 import type { BlockType } from "./_registry.ts";
 export declare function defaultPropsForType(type: BlockType): Record<string, unknown>;
+/**
+ * The defaults a block type *actually declares*, or null when it declares none.
+ *
+ * `defaultPropsForType` never answers "I don't know" — an unregistered type gets
+ * the CTA-shaped `fallback` above, which is a reasonable last resort when
+ * something must be rendered and a bad answer when the question was "what are
+ * this block's defaults?". A site's own block is exactly that case: it is
+ * registered, it has a real schema, and it has no declared defaults, so the
+ * fallback describes it as having a `title`, a `description` and a CTA it has
+ * never heard of.
+ *
+ * Callers that report on a block, or that build one from a caller's own props,
+ * want the honest null. Callers that must produce *something* renderable keep
+ * using `defaultPropsForType`.
+ */
+export declare function declaredDefaultPropsForType(type: BlockType): Record<string, unknown> | null;
 export { DEFAULT_HEADING_LEVELS, resolveHeadingTag, resolveItemHeadingTag } from "./_helpers.ts";

package/dist/blocks/index.js

@@ -50,4 +50,22 @@ const fallback = {
 export function defaultPropsForType(type) {
     return defaults[type]?.() ?? { ...fallback };
 }
+/**
+ * The defaults a block type *actually declares*, or null when it declares none.
+ *
+ * `defaultPropsForType` never answers "I don't know" — an unregistered type gets
+ * the CTA-shaped `fallback` above, which is a reasonable last resort when
+ * something must be rendered and a bad answer when the question was "what are
+ * this block's defaults?". A site's own block is exactly that case: it is
+ * registered, it has a real schema, and it has no declared defaults, so the
+ * fallback describes it as having a `title`, a `description` and a CTA it has
+ * never heard of.
+ *
+ * Callers that report on a block, or that build one from a caller's own props,
+ * want the honest null. Callers that must produce *something* renderable keep
+ * using `defaultPropsForType`.
+ */
+export function declaredDefaultPropsForType(type) {
+    return defaults[type]?.() ?? null;
+}
 export { DEFAULT_HEADING_LEVELS, resolveHeadingTag, resolveItemHeadingTag } from "./_helpers.js";

package/dist/blocks/quote.js

@@ -27,6 +27,6 @@ export function quoteDefaultProps() {
         quote: "The best way to predict the future is to create it.",
         author: "Peter Drucker",
         role: "Management Consultant",
-        imageUrl: "https://placehold.co/300x300/e2e8f0/475569?text=PD",
+        imageUrl: "https://placehold.co/300x300/e2e8f0/475569.png?text=PD",
     };
 }

package/dist/chat-events.d.ts

@@ -133,7 +133,7 @@ export declare const chatStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             title: z.ZodOptional<z.ZodString>;
             description: z.ZodOptional<z.ZodString>;
             ogImage: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
+        }, z.core.$strict>;
     }, z.core.$strip>, z.ZodObject<{
         op: z.ZodLiteral<"update_site_config">;
         patch: z.ZodObject<{
@@ -262,7 +262,7 @@ export declare const chatStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             title: z.ZodOptional<z.ZodString>;
             description: z.ZodOptional<z.ZodString>;
             ogImage: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
+        }, z.core.$strict>;
     }, z.core.$strip>, z.ZodObject<{
         op: z.ZodLiteral<"update_site_config">;
         patch: z.ZodObject<{
@@ -397,7 +397,7 @@ export declare const chatStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             title: z.ZodOptional<z.ZodString>;
             description: z.ZodOptional<z.ZodString>;
             ogImage: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
+        }, z.core.$strict>;
     }, z.core.$strip>, z.ZodObject<{
         op: z.ZodLiteral<"update_site_config">;
         patch: z.ZodObject<{

package/dist/index.d.ts

@@ -2,9 +2,10 @@ 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, setPropAtPath } from "./editable-path.ts";
-export { blockDefinitionSchema, blockManifestSchema, jsonSchemaLikeSchema, validateByJsonSchemaLike, validateManifestDefaultProps, deriveFieldMetaFromSchema, type BlockDefinition, type BlockManifest } from "./block-manifest.ts";
-export { type FieldKind, type ImageSpec, type FieldMeta, type ListFieldMeta, type BlockMeta, type BlockType, type BlockInstance, type BlockRegistration, IMAGE_PLACEHOLDER, isImagePlaceholder, registerBlock, getBlockMeta, getAllBlockMeta, getImageFields, getListImageFields, isFieldInlineEditable, getImageSpec, isChrome, getChromeTypes, blockSchemas, allowedBlockTypes, getPropDisplayName, defaultListItemForBlock, blockInstanceSchema, blockInstanceSchemaLenient, validateBlockProps, getBlockJsonSchema, } from "./blocks/_registry.ts";
-export { defaultPropsForType, resolveHeadingTag, resolveItemHeadingTag, DEFAULT_HEADING_LEVELS, } from "./blocks/index.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 { type FieldKind, type ImageSpec, type FieldMeta, type ListFieldMeta, type BlockMeta, type BlockType, type BlockInstance, type BlockRegistration, IMAGE_PLACEHOLDER, isImagePlaceholder, registerBlock, getBlockMeta, getAllBlockMeta, getImageFields, getListImageFields, 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";
 export { THEME_TOKEN_TO_CSS_VARS, themeTokenKeys, semanticThemeTokensSchema, mapSemanticThemeTokens, type ThemeTokenKey, type SemanticThemeTokens, } from "./ops/theme-tokens.ts";