@terreno/blocks 57.10.1

package/dist/index.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filesAskInputSchema = exports.filesAnswerSchema = exports.FORM_FIELD_TYPES = exports.confirmButtonLabels = exports.confirmAskResponseSchema = exports.confirmAskInputSchema = exports.confirmAnswerSchema = exports.compactChoiceAskInputSchema = exports.compactAskInputSchemas = exports.choiceSelectionBounds = exports.choiceOptionSchema = exports.choiceAskResponseSchema = exports.choiceAskInputSchema = exports.choiceAnswerSchema = exports.COMPACT_ASK_KINDS = exports.CHOICE_SELECT_MODES = exports.askResponseSchema = exports.askOutputSchemas = exports.askKindsForSurface = exports.askInputSchemas = exports.askInputSchemaFor = exports.askFileRefSchema = exports.askDeclineResponseSchema = exports.askCancelResponseSchema = exports.askAllowsDecline = exports.askAcceptResponseSchema = exports.ASK_SURFACES = exports.ASK_KINDS = exports.ASK_CANCEL_REASONS = exports.askPromptSection = exports.ASK_LIMITS = exports.askJsonSchemas = exports.turnResultSchema = exports.turnRequestSchema = exports.pendingAskSummarySchema = exports.pendingAskListSchema = exports.pendingAskListItemSchema = exports.askSurfaceSchema = exports.askResponseWithToolCallIdSchema = exports.formTextMaxLength = exports.formDefaultValues = exports.sniffFileBytes = exports.parseAskDataUrl = exports.isTextFileMimeType = exports.fileNotOwnedError = exports.checkAskFileBytes = exports.acceptedFileMimeTypes = exports.ASK_FILE_ACCEPT_MIME_TYPES = exports.ASK_FILE_ACCEPT = exports.ASK_ERROR_CODES = void 0;
+exports.validateBlocks = exports.wrapAsTextDocument = exports.METRIC_TRENDS = exports.HTML_HEIGHTS = exports.HEADING_SIZES = exports.DATASET_GRAINS = exports.DATASET_COLUMN_TYPES = exports.CHART_KINDS = exports.CHART_HEIGHTS = exports.CALLOUT_STATUSES = exports.blocksSchema = exports.BUTTON_VARIANTS = exports.BADGE_STATUSES = exports.blocksPromptSection = exports.parseBlocksPartial = exports.parseBlocks = exports.BLOCK_LIMITS = exports.blocksJsonSchema = exports.BLOCK_WARNING_CODES = exports.BLOCK_ERROR_CODES = exports.validateAskResponse = exports.validateAskInput = exports.toSimpleCard = exports.simpleCardSchema = exports.simpleCardButtonSchema = exports.SIMPLE_CARD_BUTTON_STYLES = exports.resolveButtonAnswer = exports.markdownLengthBounds = exports.markdownAskResponseSchema = exports.markdownAskInputSchema = exports.markdownAnswerSchema = exports.isCompactAskKind = exports.formFieldSchema = exports.formAskResponseSchema = exports.formAskInputSchema = exports.formAnswerSchema = exports.filesCountBounds = exports.filesAskResponseSchema = void 0;
+var errors_1 = require("./asks/errors");
+Object.defineProperty(exports, "ASK_ERROR_CODES", { enumerable: true, get: function () { return errors_1.ASK_ERROR_CODES; } });
+var files_1 = require("./asks/files");
+Object.defineProperty(exports, "ASK_FILE_ACCEPT", { enumerable: true, get: function () { return files_1.ASK_FILE_ACCEPT; } });
+Object.defineProperty(exports, "ASK_FILE_ACCEPT_MIME_TYPES", { enumerable: true, get: function () { return files_1.ASK_FILE_ACCEPT_MIME_TYPES; } });
+Object.defineProperty(exports, "acceptedFileMimeTypes", { enumerable: true, get: function () { return files_1.acceptedFileMimeTypes; } });
+Object.defineProperty(exports, "checkAskFileBytes", { enumerable: true, get: function () { return files_1.checkAskFileBytes; } });
+Object.defineProperty(exports, "fileNotOwnedError", { enumerable: true, get: function () { return files_1.fileNotOwnedError; } });
+Object.defineProperty(exports, "isTextFileMimeType", { enumerable: true, get: function () { return files_1.isTextFileMimeType; } });
+Object.defineProperty(exports, "parseAskDataUrl", { enumerable: true, get: function () { return files_1.parseAskDataUrl; } });
+Object.defineProperty(exports, "sniffFileBytes", { enumerable: true, get: function () { return files_1.sniffFileBytes; } });
+var formValues_1 = require("./asks/formValues");
+Object.defineProperty(exports, "formDefaultValues", { enumerable: true, get: function () { return formValues_1.formDefaultValues; } });
+Object.defineProperty(exports, "formTextMaxLength", { enumerable: true, get: function () { return formValues_1.formTextMaxLength; } });
+var headless_1 = require("./asks/headless");
+Object.defineProperty(exports, "askResponseWithToolCallIdSchema", { enumerable: true, get: function () { return headless_1.askResponseWithToolCallIdSchema; } });
+Object.defineProperty(exports, "askSurfaceSchema", { enumerable: true, get: function () { return headless_1.askSurfaceSchema; } });
+Object.defineProperty(exports, "pendingAskListItemSchema", { enumerable: true, get: function () { return headless_1.pendingAskListItemSchema; } });
+Object.defineProperty(exports, "pendingAskListSchema", { enumerable: true, get: function () { return headless_1.pendingAskListSchema; } });
+Object.defineProperty(exports, "pendingAskSummarySchema", { enumerable: true, get: function () { return headless_1.pendingAskSummarySchema; } });
+Object.defineProperty(exports, "turnRequestSchema", { enumerable: true, get: function () { return headless_1.turnRequestSchema; } });
+Object.defineProperty(exports, "turnResultSchema", { enumerable: true, get: function () { return headless_1.turnResultSchema; } });
+var jsonSchema_1 = require("./asks/jsonSchema");
+Object.defineProperty(exports, "askJsonSchemas", { enumerable: true, get: function () { return jsonSchema_1.askJsonSchemas; } });
+var limits_1 = require("./asks/limits");
+Object.defineProperty(exports, "ASK_LIMITS", { enumerable: true, get: function () { return limits_1.ASK_LIMITS; } });
+var prompt_1 = require("./asks/prompt");
+Object.defineProperty(exports, "askPromptSection", { enumerable: true, get: function () { return prompt_1.askPromptSection; } });
+var schema_1 = require("./asks/schema");
+Object.defineProperty(exports, "ASK_CANCEL_REASONS", { enumerable: true, get: function () { return schema_1.ASK_CANCEL_REASONS; } });
+Object.defineProperty(exports, "ASK_KINDS", { enumerable: true, get: function () { return schema_1.ASK_KINDS; } });
+Object.defineProperty(exports, "ASK_SURFACES", { enumerable: true, get: function () { return schema_1.ASK_SURFACES; } });
+Object.defineProperty(exports, "askAcceptResponseSchema", { enumerable: true, get: function () { return schema_1.askAcceptResponseSchema; } });
+Object.defineProperty(exports, "askAllowsDecline", { enumerable: true, get: function () { return schema_1.askAllowsDecline; } });
+Object.defineProperty(exports, "askCancelResponseSchema", { enumerable: true, get: function () { return schema_1.askCancelResponseSchema; } });
+Object.defineProperty(exports, "askDeclineResponseSchema", { enumerable: true, get: function () { return schema_1.askDeclineResponseSchema; } });
+Object.defineProperty(exports, "askFileRefSchema", { enumerable: true, get: function () { return schema_1.askFileRefSchema; } });
+Object.defineProperty(exports, "askInputSchemaFor", { enumerable: true, get: function () { return schema_1.askInputSchemaFor; } });
+Object.defineProperty(exports, "askInputSchemas", { enumerable: true, get: function () { return schema_1.askInputSchemas; } });
+Object.defineProperty(exports, "askKindsForSurface", { enumerable: true, get: function () { return schema_1.askKindsForSurface; } });
+Object.defineProperty(exports, "askOutputSchemas", { enumerable: true, get: function () { return schema_1.askOutputSchemas; } });
+Object.defineProperty(exports, "askResponseSchema", { enumerable: true, get: function () { return schema_1.askResponseSchema; } });
+Object.defineProperty(exports, "CHOICE_SELECT_MODES", { enumerable: true, get: function () { return schema_1.CHOICE_SELECT_MODES; } });
+Object.defineProperty(exports, "COMPACT_ASK_KINDS", { enumerable: true, get: function () { return schema_1.COMPACT_ASK_KINDS; } });
+Object.defineProperty(exports, "choiceAnswerSchema", { enumerable: true, get: function () { return schema_1.choiceAnswerSchema; } });
+Object.defineProperty(exports, "choiceAskInputSchema", { enumerable: true, get: function () { return schema_1.choiceAskInputSchema; } });
+Object.defineProperty(exports, "choiceAskResponseSchema", { enumerable: true, get: function () { return schema_1.choiceAskResponseSchema; } });
+Object.defineProperty(exports, "choiceOptionSchema", { enumerable: true, get: function () { return schema_1.choiceOptionSchema; } });
+Object.defineProperty(exports, "choiceSelectionBounds", { enumerable: true, get: function () { return schema_1.choiceSelectionBounds; } });
+Object.defineProperty(exports, "compactAskInputSchemas", { enumerable: true, get: function () { return schema_1.compactAskInputSchemas; } });
+Object.defineProperty(exports, "compactChoiceAskInputSchema", { enumerable: true, get: function () { return schema_1.compactChoiceAskInputSchema; } });
+Object.defineProperty(exports, "confirmAnswerSchema", { enumerable: true, get: function () { return schema_1.confirmAnswerSchema; } });
+Object.defineProperty(exports, "confirmAskInputSchema", { enumerable: true, get: function () { return schema_1.confirmAskInputSchema; } });
+Object.defineProperty(exports, "confirmAskResponseSchema", { enumerable: true, get: function () { return schema_1.confirmAskResponseSchema; } });
+Object.defineProperty(exports, "confirmButtonLabels", { enumerable: true, get: function () { return schema_1.confirmButtonLabels; } });
+Object.defineProperty(exports, "FORM_FIELD_TYPES", { enumerable: true, get: function () { return schema_1.FORM_FIELD_TYPES; } });
+Object.defineProperty(exports, "filesAnswerSchema", { enumerable: true, get: function () { return schema_1.filesAnswerSchema; } });
+Object.defineProperty(exports, "filesAskInputSchema", { enumerable: true, get: function () { return schema_1.filesAskInputSchema; } });
+Object.defineProperty(exports, "filesAskResponseSchema", { enumerable: true, get: function () { return schema_1.filesAskResponseSchema; } });
+Object.defineProperty(exports, "filesCountBounds", { enumerable: true, get: function () { return schema_1.filesCountBounds; } });
+Object.defineProperty(exports, "formAnswerSchema", { enumerable: true, get: function () { return schema_1.formAnswerSchema; } });
+Object.defineProperty(exports, "formAskInputSchema", { enumerable: true, get: function () { return schema_1.formAskInputSchema; } });
+Object.defineProperty(exports, "formAskResponseSchema", { enumerable: true, get: function () { return schema_1.formAskResponseSchema; } });
+Object.defineProperty(exports, "formFieldSchema", { enumerable: true, get: function () { return schema_1.formFieldSchema; } });
+Object.defineProperty(exports, "isCompactAskKind", { enumerable: true, get: function () { return schema_1.isCompactAskKind; } });
+Object.defineProperty(exports, "markdownAnswerSchema", { enumerable: true, get: function () { return schema_1.markdownAnswerSchema; } });
+Object.defineProperty(exports, "markdownAskInputSchema", { enumerable: true, get: function () { return schema_1.markdownAskInputSchema; } });
+Object.defineProperty(exports, "markdownAskResponseSchema", { enumerable: true, get: function () { return schema_1.markdownAskResponseSchema; } });
+Object.defineProperty(exports, "markdownLengthBounds", { enumerable: true, get: function () { return schema_1.markdownLengthBounds; } });
+var simpleCard_1 = require("./asks/simpleCard");
+Object.defineProperty(exports, "resolveButtonAnswer", { enumerable: true, get: function () { return simpleCard_1.resolveButtonAnswer; } });
+Object.defineProperty(exports, "SIMPLE_CARD_BUTTON_STYLES", { enumerable: true, get: function () { return simpleCard_1.SIMPLE_CARD_BUTTON_STYLES; } });
+Object.defineProperty(exports, "simpleCardButtonSchema", { enumerable: true, get: function () { return simpleCard_1.simpleCardButtonSchema; } });
+Object.defineProperty(exports, "simpleCardSchema", { enumerable: true, get: function () { return simpleCard_1.simpleCardSchema; } });
+Object.defineProperty(exports, "toSimpleCard", { enumerable: true, get: function () { return simpleCard_1.toSimpleCard; } });
+var validateInput_1 = require("./asks/validateInput");
+Object.defineProperty(exports, "validateAskInput", { enumerable: true, get: function () { return validateInput_1.validateAskInput; } });
+var validateResponse_1 = require("./asks/validateResponse");
+Object.defineProperty(exports, "validateAskResponse", { enumerable: true, get: function () { return validateResponse_1.validateAskResponse; } });
+var errors_2 = require("./errors");
+Object.defineProperty(exports, "BLOCK_ERROR_CODES", { enumerable: true, get: function () { return errors_2.BLOCK_ERROR_CODES; } });
+Object.defineProperty(exports, "BLOCK_WARNING_CODES", { enumerable: true, get: function () { return errors_2.BLOCK_WARNING_CODES; } });
+var jsonSchema_2 = require("./jsonSchema");
+Object.defineProperty(exports, "blocksJsonSchema", { enumerable: true, get: function () { return jsonSchema_2.blocksJsonSchema; } });
+var limits_2 = require("./limits");
+Object.defineProperty(exports, "BLOCK_LIMITS", { enumerable: true, get: function () { return limits_2.BLOCK_LIMITS; } });
+var parse_1 = require("./parse");
+Object.defineProperty(exports, "parseBlocks", { enumerable: true, get: function () { return parse_1.parseBlocks; } });
+var parsePartial_1 = require("./parsePartial");
+Object.defineProperty(exports, "parseBlocksPartial", { enumerable: true, get: function () { return parsePartial_1.parseBlocksPartial; } });
+var prompt_2 = require("./prompt");
+Object.defineProperty(exports, "blocksPromptSection", { enumerable: true, get: function () { return prompt_2.blocksPromptSection; } });
+var schema_2 = require("./schema");
+Object.defineProperty(exports, "BADGE_STATUSES", { enumerable: true, get: function () { return schema_2.BADGE_STATUSES; } });
+Object.defineProperty(exports, "BUTTON_VARIANTS", { enumerable: true, get: function () { return schema_2.BUTTON_VARIANTS; } });
+Object.defineProperty(exports, "blocksSchema", { enumerable: true, get: function () { return schema_2.blocksSchema; } });
+Object.defineProperty(exports, "CALLOUT_STATUSES", { enumerable: true, get: function () { return schema_2.CALLOUT_STATUSES; } });
+Object.defineProperty(exports, "CHART_HEIGHTS", { enumerable: true, get: function () { return schema_2.CHART_HEIGHTS; } });
+Object.defineProperty(exports, "CHART_KINDS", { enumerable: true, get: function () { return schema_2.CHART_KINDS; } });
+Object.defineProperty(exports, "DATASET_COLUMN_TYPES", { enumerable: true, get: function () { return schema_2.DATASET_COLUMN_TYPES; } });
+Object.defineProperty(exports, "DATASET_GRAINS", { enumerable: true, get: function () { return schema_2.DATASET_GRAINS; } });
+Object.defineProperty(exports, "HEADING_SIZES", { enumerable: true, get: function () { return schema_2.HEADING_SIZES; } });
+Object.defineProperty(exports, "HTML_HEIGHTS", { enumerable: true, get: function () { return schema_2.HTML_HEIGHTS; } });
+Object.defineProperty(exports, "METRIC_TRENDS", { enumerable: true, get: function () { return schema_2.METRIC_TRENDS; } });
+Object.defineProperty(exports, "wrapAsTextDocument", { enumerable: true, get: function () { return schema_2.wrapAsTextDocument; } });
+var validate_1 = require("./validate");
+Object.defineProperty(exports, "validateBlocks", { enumerable: true, get: function () { return validate_1.validateBlocks; } });

package/dist/jsonSchema.d.ts

@@ -0,0 +1,5 @@
+/**
+ * JSON Schema for the same document `blocksSchema` checks.
+ * Semantic lint (dataset columns, select targets, host callbacks) is not expressible here.
+ */
+export declare const blocksJsonSchema: Record<string, unknown>;

package/dist/jsonSchema.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blocksJsonSchema = void 0;
+const zod_1 = require("zod");
+const schema_1 = require("./schema");
+/**
+ * JSON Schema for the same document `blocksSchema` checks.
+ * Semantic lint (dataset columns, select targets, host callbacks) is not expressible here.
+ */
+exports.blocksJsonSchema = zod_1.z.toJSONSchema(schema_1.blocksSchema, {
+    target: "draft-07",
+});

package/dist/limits.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Caps shared by the schema, the prompt, and the reference page.
+ */
+export declare const BLOCK_LIMITS: {
+    readonly actionElementsMax: 25;
+    readonly badgeTextMaxLength: 80;
+    readonly barCategoryWarning: 60;
+    readonly blockTextMaxLength: 4000;
+    readonly cardTitleMaxLength: 120;
+    readonly columnsMax: 4;
+    readonly columnsMin: 2;
+    readonly contextTextMaxLength: 280;
+    readonly datasetColumnMax: 12;
+    readonly datasetRowMax: 500;
+    readonly documentTextMaxLength: 20000;
+    readonly donutSliceWarning: 8;
+    readonly headingTextMaxLength: 200;
+    readonly htmlMaxBytes: 100000;
+    readonly maxBlocks: 50;
+    readonly maxDatasets: 8;
+    readonly maxDepth: 2;
+    readonly metricDeltaMaxLength: 40;
+    readonly metricHelperMaxLength: 120;
+    readonly metricLabelMaxLength: 80;
+    readonly metricValueMaxLength: 80;
+    readonly refLimitMax: 1000;
+};

package/dist/limits.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLOCK_LIMITS = void 0;
+/**
+ * Caps shared by the schema, the prompt, and the reference page.
+ */
+exports.BLOCK_LIMITS = {
+    actionElementsMax: 25,
+    badgeTextMaxLength: 80,
+    barCategoryWarning: 60,
+    blockTextMaxLength: 4_000,
+    cardTitleMaxLength: 120,
+    columnsMax: 4,
+    columnsMin: 2,
+    contextTextMaxLength: 280,
+    datasetColumnMax: 12,
+    datasetRowMax: 500,
+    documentTextMaxLength: 20_000,
+    donutSliceWarning: 8,
+    headingTextMaxLength: 200,
+    htmlMaxBytes: 100_000,
+    maxBlocks: 50,
+    maxDatasets: 8,
+    maxDepth: 2,
+    metricDeltaMaxLength: 40,
+    metricHelperMaxLength: 120,
+    metricLabelMaxLength: 80,
+    metricValueMaxLength: 80,
+    refLimitMax: 1_000,
+};

package/dist/lint.d.ts

@@ -0,0 +1,21 @@
+import { type BlockError } from "./errors";
+import type { BlocksDocument, DatasetColumn } from "./schema";
+export interface KnownDataset {
+    columns: DatasetColumn[];
+}
+export interface LintBlocksOptions {
+    /** When false or omitted, an `html` block fails with `HTML_DISABLED`. */
+    allowHtml?: boolean;
+    hostActions?: readonly string[];
+    /** Hostnames allowed on `https` image `src` values. Empty means no https images. */
+    imageHosts?: readonly string[];
+    knownDatasets?: Record<string, KnownDataset>;
+}
+/**
+ * Semantic checks for datasets, charts, and tables.
+ * Structural schema errors are handled before this runs.
+ */
+export declare const lintDocument: (doc: BlocksDocument, options?: LintBlocksOptions) => {
+    errors: BlockError[];
+    warnings: BlockError[];
+};

package/dist/lint.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintDocument = void 0;
+const errors_1 = require("./errors");
+const limits_1 = require("./limits");
+const issue = ({ code, fix, message, path }) => ({ code, fix, message, path });
+const imageSourceIssue = (src, hosts, path) => {
+    if (src.startsWith("file:") && src.slice("file:".length).trim().length > 0) {
+        return undefined;
+    }
+    if (/^data:image\//i.test(src)) {
+        return undefined;
+    }
+    let hostname = "";
+    try {
+        const url = new URL(src);
+        if (url.protocol === "https:") {
+            hostname = url.hostname.toLowerCase();
+        }
+    }
+    catch {
+        hostname = "";
+    }
+    const allowed = (hosts ?? []).some((host) => host.toLowerCase() === hostname);
+    if (hostname !== "" && allowed) {
+        return undefined;
+    }
+    return issue({
+        code: "IMAGE_HOST_NOT_ALLOWED",
+        fix: "Use a data:image URL, a file: ref, or an https URL whose host is in uiBlocks.imageHosts.",
+        message: errors_1.BLOCK_ERROR_CODES.IMAGE_HOST_NOT_ALLOWED,
+        path: `${path}.src`,
+    });
+};
+const isInline = (dataset) => dataset.source !== "ref";
+const columnsFor = (dataset, options) => {
+    if (isInline(dataset)) {
+        return dataset.columns;
+    }
+    return options?.knownDatasets?.[dataset.id]?.columns;
+};
+const cellMatches = (type, value) => {
+    if (type === "number") {
+        return typeof value === "number" && Number.isFinite(value);
+    }
+    return typeof value === "string" && value.trim().length > 0;
+};
+const walk = (blocks, prefix) => {
+    const found = [];
+    blocks.forEach((block, index) => {
+        const path = `${prefix}[${index}]`;
+        found.push({ block, path });
+        if (block.type === "columns" || block.type === "card") {
+            found.push(...walk(block.children, `${path}.children`));
+        }
+    });
+    return found;
+};
+const renderedCount = (dataset, points) => {
+    if (points !== undefined) {
+        return points;
+    }
+    if (dataset === undefined) {
+        return undefined;
+    }
+    if (isInline(dataset)) {
+        return dataset.rows.length;
+    }
+    return dataset.limit;
+};
+/**
+ * Semantic checks for datasets, charts, and tables.
+ * Structural schema errors are handled before this runs.
+ */
+const lintDocument = (doc, options) => {
+    const errors = [];
+    const warnings = [];
+    const datasets = doc.datasets ?? {};
+    const names = Object.keys(datasets);
+    if (names.length > limits_1.BLOCK_LIMITS.maxDatasets) {
+        errors.push(issue({
+            code: "TOO_MANY",
+            fix: `Keep ${limits_1.BLOCK_LIMITS.maxDatasets} datasets or fewer.`,
+            message: `The document has more than ${limits_1.BLOCK_LIMITS.maxDatasets} datasets.`,
+            path: "datasets",
+        }));
+    }
+    for (const name of names) {
+        const dataset = datasets[name];
+        if (dataset === undefined || !isInline(dataset)) {
+            if (dataset?.source === "ref" &&
+                dataset.limit !== undefined &&
+                dataset.limit > limits_1.BLOCK_LIMITS.refLimitMax) {
+                errors.push(issue({
+                    code: "TOO_MANY_POINTS",
+                    fix: `Set grain to a coarser bucket, or set limit to ${limits_1.BLOCK_LIMITS.refLimitMax} or less.`,
+                    message: errors_1.BLOCK_ERROR_CODES.TOO_MANY_POINTS,
+                    path: `datasets.${name}.limit`,
+                }));
+            }
+            continue;
+        }
+        if (dataset.columns.length > limits_1.BLOCK_LIMITS.datasetColumnMax) {
+            errors.push(issue({
+                code: "DATASET_TOO_LARGE",
+                fix: `Use ${limits_1.BLOCK_LIMITS.datasetColumnMax} columns or fewer.`,
+                message: errors_1.BLOCK_ERROR_CODES.DATASET_TOO_LARGE,
+                path: `datasets.${name}.columns`,
+            }));
+        }
+        if (dataset.rows.length > limits_1.BLOCK_LIMITS.datasetRowMax) {
+            errors.push(issue({
+                code: "DATASET_TOO_LARGE",
+                fix: `Use ${limits_1.BLOCK_LIMITS.datasetRowMax} rows or fewer, or return a ref dataset from a tool.`,
+                message: errors_1.BLOCK_ERROR_CODES.DATASET_TOO_LARGE,
+                path: `datasets.${name}.rows`,
+            }));
+        }
+        const seenColumns = new Set();
+        dataset.columns.forEach((column, index) => {
+            if (seenColumns.has(column.name)) {
+                errors.push(issue({
+                    code: "DUPLICATE_ID",
+                    fix: `Rename the duplicate column "${column.name}".`,
+                    message: errors_1.BLOCK_ERROR_CODES.DUPLICATE_ID,
+                    path: `datasets.${name}.columns[${index}].name`,
+                }));
+            }
+            seenColumns.add(column.name);
+        });
+        dataset.rows.forEach((row, rowIndex) => {
+            if (row.length !== dataset.columns.length) {
+                errors.push(issue({
+                    code: "ROW_ARITY_MISMATCH",
+                    fix: `Give the row ${dataset.columns.length} values, one per column.`,
+                    message: errors_1.BLOCK_ERROR_CODES.ROW_ARITY_MISMATCH,
+                    path: `datasets.${name}.rows[${rowIndex}]`,
+                }));
+                return;
+            }
+            row.forEach((value, columnIndex) => {
+                const column = dataset.columns[columnIndex];
+                if (column === undefined || cellMatches(column.type, value)) {
+                    return;
+                }
+                errors.push(issue({
+                    code: "COLUMN_TYPE_MISMATCH",
+                    fix: `Make datasets.${name}.rows[${rowIndex}][${columnIndex}] a ${column.type}.`,
+                    message: errors_1.BLOCK_ERROR_CODES.COLUMN_TYPE_MISMATCH,
+                    path: `datasets.${name}.rows[${rowIndex}][${columnIndex}]`,
+                }));
+            });
+        });
+    }
+    const seenIds = new Set();
+    const selectableIds = new Set();
+    const walked = walk(doc.blocks, "blocks");
+    for (const { block } of walked) {
+        if ((block.type === "chart" || block.type === "table") && block.id !== undefined) {
+            selectableIds.add(block.id);
+        }
+    }
+    for (const { block, path } of walked) {
+        if (block.type === "html") {
+            if (options?.allowHtml !== true) {
+                errors.push(issue({
+                    code: "HTML_DISABLED",
+                    fix: "Turn on uiBlocks.html before sending an html block, or use a text block.",
+                    message: errors_1.BLOCK_ERROR_CODES.HTML_DISABLED,
+                    path,
+                }));
+            }
+            const bytes = new TextEncoder().encode(block.html).length;
+            if (bytes > limits_1.BLOCK_LIMITS.htmlMaxBytes) {
+                errors.push(issue({
+                    code: "HTML_TOO_LARGE",
+                    fix: `Keep the html field at or under ${limits_1.BLOCK_LIMITS.htmlMaxBytes} bytes.`,
+                    message: errors_1.BLOCK_ERROR_CODES.HTML_TOO_LARGE,
+                    path: `${path}.html`,
+                }));
+            }
+        }
+        if (block.type === "image") {
+            const imageIssue = imageSourceIssue(block.src, options?.imageHosts, path);
+            if (imageIssue) {
+                errors.push(imageIssue);
+            }
+        }
+        if (block.id !== undefined) {
+            if (seenIds.has(block.id)) {
+                errors.push(issue({
+                    code: "DUPLICATE_ID",
+                    fix: `Give ${path} a unique id.`,
+                    message: errors_1.BLOCK_ERROR_CODES.DUPLICATE_ID,
+                    path: `${path}.id`,
+                }));
+            }
+            seenIds.add(block.id);
+        }
+        if (block.type === "chart") {
+            const hasPoints = block.points !== undefined;
+            const hasData = block.data !== undefined || block.x !== undefined || block.y !== undefined;
+            if (hasPoints && hasData) {
+                errors.push(issue({
+                    code: "INVALID_TYPE",
+                    fix: "Use data, x, and y, or use points. Do not set both.",
+                    message: "A chart binds to a dataset or lists points.",
+                    path: `${path}.points`,
+                }));
+            }
+            else if (!hasPoints &&
+                (block.data === undefined || block.x === undefined || block.y === undefined)) {
+                errors.push(issue({
+                    code: "MISSING_REQUIRED",
+                    fix: "Set data, x, and y, or set points.",
+                    message: errors_1.BLOCK_ERROR_CODES.MISSING_REQUIRED,
+                    path: `${path}.data`,
+                }));
+            }
+            const dataset = block.data === undefined ? undefined : datasets[block.data];
+            if (block.data !== undefined && dataset === undefined) {
+                errors.push(issue({
+                    code: "DATASET_NOT_FOUND",
+                    fix: `Define datasets.${block.data}, or use a dataset name that exists.`,
+                    message: errors_1.BLOCK_ERROR_CODES.DATASET_NOT_FOUND,
+                    path: `${path}.data`,
+                }));
+            }
+            const columns = dataset === undefined ? undefined : columnsFor(dataset, options);
+            if (dataset !== undefined &&
+                columns !== undefined &&
+                block.x !== undefined &&
+                block.y !== undefined) {
+                const xColumn = columns.find((column) => column.name === block.x);
+                const yColumn = columns.find((column) => column.name === block.y);
+                if (xColumn === undefined) {
+                    errors.push(issue({
+                        code: "COLUMN_NOT_FOUND",
+                        fix: `Set x to a column of ${block.data}.`,
+                        message: errors_1.BLOCK_ERROR_CODES.COLUMN_NOT_FOUND,
+                        path: `${path}.x`,
+                    }));
+                }
+                else if (xColumn.type === "number") {
+                    errors.push(issue({
+                        code: "COLUMN_TYPE_MISMATCH",
+                        fix: "Use a string or date column for x.",
+                        message: errors_1.BLOCK_ERROR_CODES.COLUMN_TYPE_MISMATCH,
+                        path: `${path}.x`,
+                    }));
+                }
+                if (yColumn === undefined) {
+                    errors.push(issue({
+                        code: "COLUMN_NOT_FOUND",
+                        fix: `Set y to a column of ${block.data}.`,
+                        message: errors_1.BLOCK_ERROR_CODES.COLUMN_NOT_FOUND,
+                        path: `${path}.y`,
+                    }));
+                }
+                else if (yColumn.type !== "number") {
+                    errors.push(issue({
+                        code: "COLUMN_TYPE_MISMATCH",
+                        fix: "Use a number column for y.",
+                        message: errors_1.BLOCK_ERROR_CODES.COLUMN_TYPE_MISMATCH,
+                        path: `${path}.y`,
+                    }));
+                }
+            }
+            const count = renderedCount(dataset, block.points?.length);
+            if (block.kind === "bar" && count !== undefined && count > limits_1.BLOCK_LIMITS.barCategoryWarning) {
+                warnings.push(issue({
+                    code: "BAR_TOO_MANY_CATEGORIES",
+                    fix: "Group the categories, or use a line chart.",
+                    message: errors_1.BLOCK_WARNING_CODES.BAR_TOO_MANY_CATEGORIES,
+                    path,
+                }));
+            }
+            if (block.kind === "donut" && count !== undefined && count > limits_1.BLOCK_LIMITS.donutSliceWarning) {
+                warnings.push(issue({
+                    code: "DONUT_TOO_MANY_SLICES",
+                    fix: "Keep 8 slices or fewer.",
+                    message: errors_1.BLOCK_WARNING_CODES.DONUT_TOO_MANY_SLICES,
+                    path,
+                }));
+            }
+            if (block.kind === "line" && count === 1) {
+                warnings.push(issue({
+                    code: "LINE_SINGLE_POINT",
+                    fix: "Add another point, or use a metric block.",
+                    message: errors_1.BLOCK_WARNING_CODES.LINE_SINGLE_POINT,
+                    path,
+                }));
+            }
+        }
+        if (block.type === "actions") {
+            block.elements.forEach((element, index) => {
+                const elementPath = `${path}.elements[${index}]`;
+                if (seenIds.has(element.id)) {
+                    errors.push(issue({
+                        code: "DUPLICATE_ID",
+                        fix: `Give ${elementPath} a unique id.`,
+                        message: errors_1.BLOCK_ERROR_CODES.DUPLICATE_ID,
+                        path: `${elementPath}.id`,
+                    }));
+                }
+                seenIds.add(element.id);
+                if (element.type === "segmented" && !selectableIds.has(element.target)) {
+                    errors.push(issue({
+                        code: "SELECT_TARGET_INVALID",
+                        fix: "Set target to the id of a chart or table in this document.",
+                        message: errors_1.BLOCK_ERROR_CODES.SELECT_TARGET_INVALID,
+                        path: `${elementPath}.target`,
+                    }));
+                }
+                if (element.type === "button" &&
+                    element.action.kind === "select" &&
+                    !selectableIds.has(element.action.target)) {
+                    errors.push(issue({
+                        code: "SELECT_TARGET_INVALID",
+                        fix: "Set target to the id of a chart or table in this document.",
+                        message: errors_1.BLOCK_ERROR_CODES.SELECT_TARGET_INVALID,
+                        path: `${elementPath}.action.target`,
+                    }));
+                }
+                if (element.type === "button" &&
+                    element.action.kind === "callback" &&
+                    options?.hostActions !== undefined &&
+                    !options.hostActions.includes(element.action.name)) {
+                    errors.push(issue({
+                        code: "UNKNOWN_HOST_ACTION",
+                        fix: `Use one of: ${options.hostActions.join(", ") || "(none registered)"}.`,
+                        message: errors_1.BLOCK_ERROR_CODES.UNKNOWN_HOST_ACTION,
+                        path: `${elementPath}.action.name`,
+                    }));
+                }
+                if (element.type === "button" && element.action.kind === "open") {
+                    const hasRoute = element.action.route !== undefined;
+                    const hasUrl = element.action.url !== undefined;
+                    if (hasRoute === hasUrl) {
+                        errors.push(issue({
+                            code: "MISSING_REQUIRED",
+                            fix: "Set either url or route on an open action.",
+                            message: errors_1.BLOCK_ERROR_CODES.MISSING_REQUIRED,
+                            path: `${elementPath}.action`,
+                        }));
+                    }
+                }
+            });
+        }
+        if (block.type === "table") {
+            const dataset = datasets[block.data];
+            if (dataset === undefined) {
+                errors.push(issue({
+                    code: "DATASET_NOT_FOUND",
+                    fix: `Define datasets.${block.data}.`,
+                    message: errors_1.BLOCK_ERROR_CODES.DATASET_NOT_FOUND,
+                    path: `${path}.data`,
+                }));
+                continue;
+            }
+            const columns = columnsFor(dataset, options);
+            const listed = block.columns ?? columns?.map((column) => column.name);
+            if (listed !== undefined && listed.length > limits_1.BLOCK_LIMITS.datasetColumnMax) {
+                errors.push(issue({
+                    code: "TABLE_TOO_WIDE",
+                    fix: `List ${limits_1.BLOCK_LIMITS.datasetColumnMax} columns or fewer.`,
+                    message: errors_1.BLOCK_ERROR_CODES.TABLE_TOO_WIDE,
+                    path: `${path}.columns`,
+                }));
+            }
+            if (columns === undefined || block.columns === undefined) {
+                continue;
+            }
+            for (const [index, columnName] of block.columns.entries()) {
+                if (!columns.some((column) => column.name === columnName)) {
+                    errors.push(issue({
+                        code: "COLUMN_NOT_FOUND",
+                        fix: `Remove "${columnName}" or add it to the dataset.`,
+                        message: errors_1.BLOCK_ERROR_CODES.COLUMN_NOT_FOUND,
+                        path: `${path}.columns[${index}]`,
+                    }));
+                }
+            }
+        }
+    }
+    return { errors, warnings };
+};
+exports.lintDocument = lintDocument;

package/dist/parse.d.ts

@@ -0,0 +1,16 @@
+import { type BlockError } from "./errors";
+/** Drops one surrounding markdown fence so a model that adds one still parses. */
+export declare const stripBlocksFence: (text: string) => string;
+export type ParseBlocksResult = {
+    errors: BlockError[];
+    ok: false;
+} | {
+    ok: true;
+    value: unknown;
+};
+/**
+ * Parses one assistant reply into a plain value.
+ * A surrounding markdown fence is ignored. Anchors, aliases, and custom tags are rejected.
+ * Anything that is not a mapping with `v` is `NOT_A_DOCUMENT`.
+ */
+export declare const parseBlocks: (text: string) => ParseBlocksResult;