@terreno/blocks 57.10.1

package/dist/schema.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapAsTextDocument = exports.blocksSchema = exports.BUTTON_VARIANTS = exports.DATASET_GRAINS = exports.DATASET_COLUMN_TYPES = exports.CHART_HEIGHTS = exports.CHART_KINDS = exports.LAYOUT_BLOCK_TYPES = exports.METRIC_TRENDS = exports.BADGE_STATUSES = exports.CALLOUT_STATUSES = exports.HTML_HEIGHTS = exports.HEADING_SIZES = void 0;
+const zod_1 = require("zod");
+const limits_1 = require("./limits");
+exports.HEADING_SIZES = ["sm", "md", "lg", "xl", "2xl"];
+exports.HTML_HEIGHTS = ["sm", "md", "lg"];
+exports.CALLOUT_STATUSES = ["info", "warning", "alert"];
+exports.BADGE_STATUSES = ["info", "error", "warning", "success", "neutral", "active"];
+exports.METRIC_TRENDS = ["up", "down", "flat"];
+exports.LAYOUT_BLOCK_TYPES = ["columns", "card"];
+const visibleText = (maxLength) => zod_1.z
+    .string()
+    .min(1)
+    .max(maxLength)
+    .refine((value) => value.trim().length > 0, {
+    message: "Must contain visible text, not only whitespace.",
+    params: { blockCode: "TOO_SHORT" },
+});
+const blockIdSchema = zod_1.z
+    .string()
+    .regex(/^[a-z][a-z0-9_]{0,63}$/)
+    .describe("Optional id. Lowercase letters, digits, and underscores, starting with a letter.");
+const sharedBlockFields = {
+    id: blockIdSchema.optional(),
+};
+exports.CHART_KINDS = ["line", "bar", "area", "donut"];
+exports.CHART_HEIGHTS = ["sm", "md", "lg"];
+exports.DATASET_COLUMN_TYPES = ["string", "number", "date"];
+exports.DATASET_GRAINS = ["hour", "day", "week", "month"];
+exports.BUTTON_VARIANTS = ["primary", "secondary", "outline", "ghost", "destructive"];
+const headingSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    size: zod_1.z.enum(exports.HEADING_SIZES).optional(),
+    text: visibleText(limits_1.BLOCK_LIMITS.headingTextMaxLength),
+    type: zod_1.z.literal("heading"),
+})
+    .strict();
+const textSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    markdown: visibleText(limits_1.BLOCK_LIMITS.blockTextMaxLength),
+    type: zod_1.z.literal("text"),
+})
+    .strict();
+const metricSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    delta: visibleText(limits_1.BLOCK_LIMITS.metricDeltaMaxLength).optional(),
+    helper: visibleText(limits_1.BLOCK_LIMITS.metricHelperMaxLength).optional(),
+    label: visibleText(limits_1.BLOCK_LIMITS.metricLabelMaxLength),
+    trend: zod_1.z.enum(exports.METRIC_TRENDS).optional(),
+    type: zod_1.z.literal("metric"),
+    value: visibleText(limits_1.BLOCK_LIMITS.metricValueMaxLength),
+})
+    .strict();
+const badgeSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    status: zod_1.z.enum(exports.BADGE_STATUSES).optional(),
+    text: visibleText(limits_1.BLOCK_LIMITS.badgeTextMaxLength),
+    type: zod_1.z.literal("badge"),
+})
+    .strict();
+const dividerSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    type: zod_1.z.literal("divider"),
+})
+    .strict();
+const contextSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    text: visibleText(limits_1.BLOCK_LIMITS.contextTextMaxLength),
+    type: zod_1.z.literal("context"),
+})
+    .strict();
+const chartSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    data: zod_1.z.string().min(1).max(64).optional(),
+    emptyText: visibleText(limits_1.BLOCK_LIMITS.contextTextMaxLength).optional(),
+    height: zod_1.z.enum(exports.CHART_HEIGHTS).optional(),
+    kind: zod_1.z.enum(exports.CHART_KINDS),
+    legend: zod_1.z.boolean().optional(),
+    points: zod_1.z
+        .array(zod_1.z
+        .object({
+        label: visibleText(limits_1.BLOCK_LIMITS.metricLabelMaxLength),
+        value: zod_1.z.number().finite(),
+    })
+        .strict())
+        .max(limits_1.BLOCK_LIMITS.datasetRowMax)
+        .optional(),
+    title: visibleText(limits_1.BLOCK_LIMITS.cardTitleMaxLength).optional(),
+    type: zod_1.z.literal("chart"),
+    x: zod_1.z.string().min(1).max(64).optional(),
+    y: zod_1.z.string().min(1).max(64).optional(),
+})
+    .strict();
+const tableSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    columns: zod_1.z.array(zod_1.z.string().min(1).max(64)).min(1).optional(),
+    data: zod_1.z.string().min(1).max(64),
+    title: visibleText(limits_1.BLOCK_LIMITS.cardTitleMaxLength).optional(),
+    type: zod_1.z.literal("table"),
+})
+    .strict();
+const replyActionSchema = zod_1.z
+    .object({
+    kind: zod_1.z.literal("reply"),
+    text: visibleText(limits_1.BLOCK_LIMITS.blockTextMaxLength),
+})
+    .strict();
+const openActionSchema = zod_1.z
+    .object({
+    kind: zod_1.z.literal("open"),
+    route: zod_1.z.string().min(1).max(200).optional(),
+    url: zod_1.z.string().min(1).max(2_000).optional(),
+})
+    .strict();
+const selectActionSchema = zod_1.z
+    .object({
+    data: zod_1.z.string().min(1).max(64),
+    kind: zod_1.z.literal("select"),
+    target: zod_1.z.string().min(1).max(64),
+})
+    .strict();
+const callbackActionSchema = zod_1.z
+    .object({
+    kind: zod_1.z.literal("callback"),
+    name: zod_1.z.string().regex(/^[a-z][A-Za-z0-9_]{0,63}$/),
+    payload: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+})
+    .strict();
+const actionSchema = zod_1.z.discriminatedUnion("kind", [
+    replyActionSchema,
+    openActionSchema,
+    selectActionSchema,
+    callbackActionSchema,
+]);
+const buttonElementSchema = zod_1.z
+    .object({
+    action: actionSchema,
+    iconName: zod_1.z.string().min(1).max(40).optional(),
+    id: blockIdSchema,
+    text: visibleText(80),
+    type: zod_1.z.literal("button"),
+    variant: zod_1.z.enum(exports.BUTTON_VARIANTS).optional(),
+})
+    .strict();
+const segmentedElementSchema = zod_1.z
+    .object({
+    id: blockIdSchema,
+    options: zod_1.z
+        .array(zod_1.z
+        .object({
+        data: zod_1.z.string().min(1).max(64),
+        label: visibleText(40),
+    })
+        .strict())
+        .min(2)
+        .max(8),
+    target: zod_1.z.string().min(1).max(64),
+    type: zod_1.z.literal("segmented"),
+})
+    .strict();
+const htmlSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    height: zod_1.z.enum(exports.HTML_HEIGHTS).optional(),
+    html: zod_1.z.string().min(1),
+    title: visibleText(limits_1.BLOCK_LIMITS.headingTextMaxLength).optional(),
+    type: zod_1.z.literal("html"),
+})
+    .strict();
+const calloutSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    status: zod_1.z.enum(exports.CALLOUT_STATUSES).optional(),
+    text: visibleText(limits_1.BLOCK_LIMITS.blockTextMaxLength),
+    type: zod_1.z.literal("callout"),
+})
+    .strict();
+const imageSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    alt: visibleText(limits_1.BLOCK_LIMITS.headingTextMaxLength),
+    src: zod_1.z.string().min(1).max(limits_1.BLOCK_LIMITS.htmlMaxBytes),
+    type: zod_1.z.literal("image"),
+})
+    .strict();
+const detailsSchema = zod_1.z
+    .object({
+    ...sharedBlockFields,
+    text: visibleText(limits_1.BLOCK_LIMITS.blockTextMaxLength),
+    title: visibleText(limits_1.BLOCK_LIMITS.headingTextMaxLength),
+    type: zod_1.z.literal("details"),
+})
+    .strict();
+const actionsSchema = zod_1.z
+    .object({
+    elements: zod_1.z
+        .array(zod_1.z.discriminatedUnion("type", [buttonElementSchema, segmentedElementSchema]))
+        .min(1)
+        .max(limits_1.BLOCK_LIMITS.actionElementsMax),
+    id: blockIdSchema,
+    type: zod_1.z.literal("actions"),
+})
+    .strict();
+const blockSchema = zod_1.z.lazy(() => zod_1.z.discriminatedUnion("type", [
+    headingSchema,
+    textSchema,
+    metricSchema,
+    badgeSchema,
+    dividerSchema,
+    contextSchema,
+    chartSchema,
+    tableSchema,
+    actionsSchema,
+    htmlSchema,
+    calloutSchema,
+    imageSchema,
+    detailsSchema,
+    zod_1.z
+        .object({
+        ...sharedBlockFields,
+        children: zod_1.z.array(blockSchema).min(limits_1.BLOCK_LIMITS.columnsMin).max(limits_1.BLOCK_LIMITS.columnsMax),
+        type: zod_1.z.literal("columns"),
+    })
+        .strict(),
+    zod_1.z
+        .object({
+        ...sharedBlockFields,
+        children: zod_1.z.array(blockSchema).min(1).max(limits_1.BLOCK_LIMITS.maxBlocks),
+        title: visibleText(limits_1.BLOCK_LIMITS.cardTitleMaxLength).optional(),
+        type: zod_1.z.literal("card"),
+    })
+        .strict(),
+]));
+const datasetColumnSchema = zod_1.z
+    .object({
+    name: zod_1.z.string().regex(/^[a-z][a-z0-9_]{0,63}$/),
+    type: zod_1.z.enum(exports.DATASET_COLUMN_TYPES),
+})
+    .strict();
+const inlineDatasetSchema = zod_1.z
+    .object({
+    columns: zod_1.z.array(datasetColumnSchema).min(1),
+    rows: zod_1.z.array(zod_1.z.array(zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.null()]))),
+    source: zod_1.z.literal("inline").optional(),
+})
+    .strict();
+const refDatasetSchema = zod_1.z
+    .object({
+    grain: zod_1.z.enum(exports.DATASET_GRAINS).optional(),
+    id: zod_1.z.string().regex(/^[A-Za-z0-9_-]{1,80}$/),
+    limit: zod_1.z.number().int().positive().optional(),
+    source: zod_1.z.literal("ref"),
+})
+    .strict();
+const datasetSchema = zod_1.z.union([refDatasetSchema, inlineDatasetSchema]);
+/** Document schema. Semantic dataset and chart checks run in `lintDocument`. */
+exports.blocksSchema = zod_1.z
+    .object({
+    blocks: zod_1.z.array(blockSchema).min(1).max(limits_1.BLOCK_LIMITS.maxBlocks),
+    datasets: zod_1.z.record(zod_1.z.string().regex(/^[a-z][a-z0-9_]{0,63}$/), datasetSchema).optional(),
+    v: zod_1.z.literal(1),
+})
+    .strict();
+const wrapAsTextDocument = (text) => ({
+    blocks: [{ markdown: text, type: "text" }],
+    v: 1,
+});
+exports.wrapAsTextDocument = wrapAsTextDocument;

package/dist/validate.d.ts

@@ -0,0 +1,17 @@
+import { type BlockError } from "./errors";
+import { type LintBlocksOptions } from "./lint";
+import { type BlocksDocument } from "./schema";
+export type ValidateBlocksResult = {
+    doc: BlocksDocument;
+    ok: true;
+    warnings: BlockError[];
+} | {
+    errors: BlockError[];
+    ok: false;
+    warnings: BlockError[];
+};
+/**
+ * Checks structure, then dataset, chart, and table lint.
+ * Returns every error at once. Warnings do not block a valid document.
+ */
+export declare const validateBlocks: (doc: unknown, options?: LintBlocksOptions) => ValidateBlocksResult;

package/dist/validate.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBlocks = void 0;
+const errors_1 = require("./errors");
+const limits_1 = require("./limits");
+const lint_1 = require("./lint");
+const schema_1 = require("./schema");
+const TOP_LEVEL_ORDER = ["v", "datasets", "blocks"];
+const layoutTypes = new Set(schema_1.LAYOUT_BLOCK_TYPES);
+const error = ({ code, fix, message, path, }) => ({ code, fix, message, path });
+const isPlainMapping = (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    return Object.getPrototypeOf(value) === Object.prototype;
+};
+const keyOrderError = (value) => {
+    const present = Object.keys(value).filter((key) => TOP_LEVEL_ORDER.some((ordered) => ordered === key));
+    const expected = TOP_LEVEL_ORDER.filter((key) => present.includes(key));
+    for (let index = 0; index < present.length; index += 1) {
+        if (present[index] !== expected[index]) {
+            return error({
+                code: "KEY_ORDER",
+                fix: "Put the keys in this order: v, datasets, blocks.",
+                message: errors_1.BLOCK_ERROR_CODES.KEY_ORDER,
+                path: present[index] ?? "",
+            });
+        }
+    }
+    return undefined;
+};
+const versionError = (value) => {
+    if (!Object.hasOwn(value, "v")) {
+        return undefined;
+    }
+    if (value.v === 1) {
+        return undefined;
+    }
+    return error({
+        code: "UNSUPPORTED_VERSION",
+        fix: "Set v to 1.",
+        message: errors_1.BLOCK_ERROR_CODES.UNSUPPORTED_VERSION,
+        path: "v",
+    });
+};
+const countBlocks = (value) => {
+    if (!isPlainMapping(value) || typeof value.type !== "string") {
+        return 0;
+    }
+    let count = 1;
+    if (Array.isArray(value.children)) {
+        for (const child of value.children) {
+            count += countBlocks(child);
+        }
+    }
+    return count;
+};
+const blockCountError = (value) => {
+    if (!Array.isArray(value.blocks)) {
+        return undefined;
+    }
+    let count = 0;
+    for (const block of value.blocks) {
+        count += countBlocks(block);
+    }
+    if (count <= limits_1.BLOCK_LIMITS.maxBlocks) {
+        return undefined;
+    }
+    return error({
+        code: "TOO_MANY_BLOCKS",
+        fix: `Use ${limits_1.BLOCK_LIMITS.maxBlocks} blocks or fewer.`,
+        message: errors_1.BLOCK_ERROR_CODES.TOO_MANY_BLOCKS,
+        path: "blocks",
+    });
+};
+const depthPath = (value, depth, path) => {
+    if (!isPlainMapping(value)) {
+        return undefined;
+    }
+    const type = value.type;
+    const isLayout = typeof type === "string" && layoutTypes.has(type);
+    if (isLayout && depth >= limits_1.BLOCK_LIMITS.maxDepth) {
+        return path;
+    }
+    if (!Array.isArray(value.children)) {
+        return undefined;
+    }
+    const childDepth = isLayout ? depth + 1 : depth;
+    for (let index = 0; index < value.children.length; index += 1) {
+        const found = depthPath(value.children[index], childDepth, `${path}.children[${index}]`);
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return undefined;
+};
+const depthError = (value) => {
+    if (!Array.isArray(value.blocks)) {
+        return undefined;
+    }
+    for (let index = 0; index < value.blocks.length; index += 1) {
+        const path = depthPath(value.blocks[index], 1, `blocks[${index}]`);
+        if (path === undefined) {
+            continue;
+        }
+        return error({
+            code: "DEPTH_EXCEEDED",
+            fix: "Keep columns and card at the top level. Their children must be leaf blocks.",
+            message: errors_1.BLOCK_ERROR_CODES.DEPTH_EXCEEDED,
+            path,
+        });
+    }
+    return undefined;
+};
+const lookup = (root, path) => {
+    let current = root;
+    for (const segment of path) {
+        if (Array.isArray(current) && typeof segment === "number") {
+            current = current[segment];
+            continue;
+        }
+        if (isPlainMapping(current) && (typeof segment === "string" || typeof segment === "number")) {
+            current = current[String(segment)];
+            continue;
+        }
+        return undefined;
+    }
+    return current;
+};
+const subject = (path) => (path === "" ? "The value" : path);
+const mapIssue = (issue, root) => {
+    const path = (0, errors_1.formatBlockPath)(issue.path);
+    if (issue.code === "unrecognized_keys") {
+        return issue.keys.map((key) => error({
+            code: "UNKNOWN_KEY",
+            fix: `Remove "${key}".`,
+            message: `"${key}" is not a field of ${path === "" ? "this object" : path}.`,
+            path: path === "" ? key : `${path}.${key}`,
+        }));
+    }
+    if (issue.code === "invalid_value") {
+        const received = lookup(root, issue.path);
+        return [
+            error({
+                code: "INVALID_ENUM",
+                fix: `Use one of: ${issue.values.map((value) => JSON.stringify(value)).join(", ")}.`,
+                message: `${subject(path)} must be one of the allowed values, not ${JSON.stringify(received)}.`,
+                path,
+            }),
+        ];
+    }
+    if (issue.code === "invalid_type") {
+        const received = lookup(root, issue.path);
+        if (received === undefined) {
+            return [
+                error({
+                    code: "MISSING_REQUIRED",
+                    fix: `Add ${path === "" ? "the missing field" : path}.`,
+                    message: errors_1.BLOCK_ERROR_CODES.MISSING_REQUIRED,
+                    path,
+                }),
+            ];
+        }
+        return [
+            error({
+                code: "INVALID_TYPE",
+                fix: `Make ${subject(path)} a ${issue.expected}.`,
+                message: `${subject(path)} has the wrong type.`,
+                path,
+            }),
+        ];
+    }
+    if (issue.code === "too_big") {
+        const maximum = String(issue.maximum);
+        if (issue.origin === "array" && path === "blocks") {
+            return [
+                error({
+                    code: "TOO_MANY_BLOCKS",
+                    fix: `Use ${maximum} blocks or fewer.`,
+                    message: errors_1.BLOCK_ERROR_CODES.TOO_MANY_BLOCKS,
+                    path,
+                }),
+            ];
+        }
+        if (issue.origin === "array") {
+            return [
+                error({
+                    code: "TOO_MANY",
+                    fix: `Remove items from ${subject(path)} until it has ${maximum} or fewer.`,
+                    message: `${subject(path)} has more than ${maximum} items.`,
+                    path,
+                }),
+            ];
+        }
+        return [
+            error({
+                code: "TOO_LONG",
+                fix: `Shorten ${subject(path)} to ${maximum} characters or fewer.`,
+                message: `${subject(path)} is longer than ${maximum} characters.`,
+                path,
+            }),
+        ];
+    }
+    if (issue.code === "too_small") {
+        if (issue.origin === "number" || issue.origin === "int") {
+            return [
+                error({
+                    code: "INVALID_TYPE",
+                    fix: `Set ${subject(path)} to an integer of at least ${String(issue.minimum)}.`,
+                    message: `${subject(path)} must be an integer of at least ${String(issue.minimum)}.`,
+                    path,
+                }),
+            ];
+        }
+        if (issue.origin === "array") {
+            return [
+                error({
+                    code: "TOO_FEW",
+                    fix: `Add items to ${subject(path)} until it has at least ${String(issue.minimum)}.`,
+                    message: `${subject(path)} has fewer items than allowed.`,
+                    path,
+                }),
+            ];
+        }
+        return [
+            error({
+                code: "TOO_SHORT",
+                fix: `Write visible text for ${subject(path)}.`,
+                message: errors_1.BLOCK_ERROR_CODES.TOO_SHORT,
+                path,
+            }),
+        ];
+    }
+    if (issue.code === "invalid_format") {
+        const isRefId = /^datasets\.[^.]+\.id$/.test(path);
+        return [
+            error({
+                code: "INVALID_FORMAT",
+                fix: isRefId
+                    ? "Use 1 to 80 letters, digits, underscores, or hyphens."
+                    : "Use a lowercase id starting with a letter, then letters, digits, or underscores.",
+                message: `${subject(path)} does not match the required format.`,
+                path,
+            }),
+        ];
+    }
+    if (issue.code === "custom" && issue.params?.blockCode === "TOO_SHORT") {
+        return [
+            error({
+                code: "TOO_SHORT",
+                fix: `Write visible text for ${subject(path)}.`,
+                message: errors_1.BLOCK_ERROR_CODES.TOO_SHORT,
+                path,
+            }),
+        ];
+    }
+    if (issue.code === "invalid_union") {
+        const nested = "errors" in issue && Array.isArray(issue.errors) ? issue.errors.flat() : [];
+        if (nested.length > 0) {
+            return nested.flatMap((nestedIssue) => mapIssue(nestedIssue, root));
+        }
+        return [
+            error({
+                code: "INVALID_ENUM",
+                fix: "Set type to heading, text, metric, badge, divider, context, chart, table, actions, columns, card, callout, image, details, or html.",
+                message: `${subject(path)} is not a supported block.`,
+                path: path === "" ? "type" : `${path}.type`,
+            }),
+        ];
+    }
+    return [
+        error({
+            code: "INVALID_TYPE",
+            fix: `Check ${subject(path)}.`,
+            message: issue.message,
+            path,
+        }),
+    ];
+};
+const dropVersionIssues = (issues) => issues.filter((issue) => !(issue.path.length === 1 && issue.path[0] === "v"));
+/**
+ * Checks structure, then dataset, chart, and table lint.
+ * Returns every error at once. Warnings do not block a valid document.
+ */
+const validateBlocks = (doc, options) => {
+    const structural = [];
+    if (isPlainMapping(doc)) {
+        const order = keyOrderError(doc);
+        if (order) {
+            structural.push(order);
+        }
+        const version = versionError(doc);
+        if (version) {
+            structural.push(version);
+        }
+        const depth = depthError(doc);
+        if (depth) {
+            structural.push(depth);
+        }
+        const count = blockCountError(doc);
+        if (count) {
+            structural.push(count);
+        }
+    }
+    const parsed = schema_1.blocksSchema.safeParse(doc);
+    if (!parsed.success) {
+        const issues = structural.some((item) => item.code === "UNSUPPORTED_VERSION")
+            ? dropVersionIssues(parsed.error.issues)
+            : parsed.error.issues;
+        const skipBlockCount = structural.some((item) => item.code === "TOO_MANY_BLOCKS");
+        for (const issue of issues) {
+            if (skipBlockCount && issue.code === "too_big" && (0, errors_1.formatBlockPath)(issue.path) === "blocks") {
+                continue;
+            }
+            structural.push(...mapIssue(issue, doc));
+        }
+    }
+    if (structural.length > 0 || !parsed.success) {
+        return { errors: (0, errors_1.sortBlockErrors)(structural), ok: false, warnings: [] };
+    }
+    const linted = (0, lint_1.lintDocument)(parsed.data, options);
+    if (linted.errors.length > 0) {
+        return {
+            errors: (0, errors_1.sortBlockErrors)(linted.errors),
+            ok: false,
+            warnings: (0, errors_1.sortBlockErrors)(linted.warnings),
+        };
+    }
+    return { doc: parsed.data, ok: true, warnings: (0, errors_1.sortBlockErrors)(linted.warnings) };
+};
+exports.validateBlocks = validateBlocks;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "author": "Josh Gachnang",
+  "bin": {
+    "terreno-blocks": "./dist/cli.js"
+  },
+  "bugs": {
+    "url": "https://github.com/TerrenoLabs/terreno/issues"
+  },
+  "dependencies": {
+    "yaml": "^2.4.0",
+    "zod": "^4.4.3"
+  },
+  "description": "Shared contracts for agent-driven UI: ask schemas, simple cards, and whole-reply block documents — part of Terreno, the batteries-included TypeScript framework for universal apps.",
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.6",
+    "@types/bun": "^1.4.0",
+    "ajv": "8.20.0",
+    "typescript": "~6.0.3"
+  },
+  "exports": {
+    ".": {
+      "default": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./fixtures/*": "./src/asks/fixtures/*",
+    "./schemas/*": "./schemas/*"
+  },
+  "homepage": "https://github.com/TerrenoLabs/terreno#readme",
+  "keywords": [
+    "ai",
+    "agents",
+    "generative-ui",
+    "zod",
+    "terreno"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "name": "@terreno/blocks",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/TerrenoLabs/terreno.git"
+  },
+  "scripts": {
+    "compile": "bun tsc",
+    "compile:watch": "bun tsc -w",
+    "dev": "bun tsc -w",
+    "lint": "biome check ./src ./scripts",
+    "lint:fix": "biome check --write ./src ./scripts",
+    "schemas": "bun scripts/writeJsonSchemas.ts",
+    "test": "bun test",
+    "test:agent": "AGENT=1 bun test --only-failures",
+    "test:ci": "bun test",
+    "test:coverage": "bun run ../scripts/check-coverage.ts"
+  },
+  "types": "dist/index.d.ts",
+  "version": "57.10.1"
+}