@terreno/blocks 57.12.0 → 57.14.0

package/dist/errors.d.ts

@@ -2,6 +2,7 @@
 export declare const BLOCK_ERROR_CODES: {
     readonly COLUMN_NOT_FOUND: "A chart or table names a column the dataset does not have.";
     readonly COLUMN_TYPE_MISMATCH: "A column value does not match the column type.";
+    readonly COPY_TARGET_INVALID: "A copy action names a block that is not a stepper, checklist, list, table, or text block.";
     readonly DATASET_NOT_FOUND: "A chart or table names a dataset the document does not define.";
     readonly DATASET_TOO_LARGE: "A dataset has more rows or columns than allowed.";
     readonly DEPTH_EXCEEDED: "A columns or card block is nested inside another columns or card block.";
@@ -15,6 +16,7 @@ export declare const BLOCK_ERROR_CODES: {
     readonly KEY_ORDER: "Top-level keys are not in the order v, datasets, blocks.";
     readonly MISSING_REQUIRED: "A required field is missing.";
     readonly NOT_A_DOCUMENT: "The reply is not one YAML or JSON mapping with a v field.";
+    readonly OUT_OF_RANGE: "A number is outside its allowed range, such as a stepper value outside min and max.";
     readonly ROW_ARITY_MISMATCH: "A dataset row does not have one value per column.";
     readonly SELECT_TARGET_INVALID: "A select action names a block that is not a chart or table.";
     readonly TABLE_TOO_WIDE: "A table lists more columns than allowed.";

package/dist/errors.js

@@ -5,6 +5,7 @@ exports.sortBlockErrors = exports.formatBlockPath = exports.BLOCK_WARNING_CODES
 exports.BLOCK_ERROR_CODES = {
     COLUMN_NOT_FOUND: "A chart or table names a column the dataset does not have.",
     COLUMN_TYPE_MISMATCH: "A column value does not match the column type.",
+    COPY_TARGET_INVALID: "A copy action names a block that is not a stepper, checklist, list, table, or text block.",
     DATASET_NOT_FOUND: "A chart or table names a dataset the document does not define.",
     DATASET_TOO_LARGE: "A dataset has more rows or columns than allowed.",
     DEPTH_EXCEEDED: "A columns or card block is nested inside another columns or card block.",
@@ -18,6 +19,7 @@ exports.BLOCK_ERROR_CODES = {
     KEY_ORDER: "Top-level keys are not in the order v, datasets, blocks.",
     MISSING_REQUIRED: "A required field is missing.",
     NOT_A_DOCUMENT: "The reply is not one YAML or JSON mapping with a v field.",
+    OUT_OF_RANGE: "A number is outside its allowed range, such as a stepper value outside min and max.",
     ROW_ARITY_MISMATCH: "A dataset row does not have one value per column.",
     SELECT_TARGET_INVALID: "A select action names a block that is not a chart or table.",
     TABLE_TOO_WIDE: "A table lists more columns than allowed.",

package/dist/index.d.ts

@@ -17,15 +17,20 @@ export { validateAskInput } from "./asks/validateInput";
 export { validateAskResponse } from "./asks/validateResponse";
 export type { BlockError, BlockErrorCode, BlockWarningCode } from "./errors";
 export { BLOCK_ERROR_CODES, BLOCK_WARNING_CODES } from "./errors";
+export type { ChecklistTick } from "./interactive";
+export { applyChecklistState, isStepperValueAllowed, scaleStepperBlock, unknownChecklistItemIds, } from "./interactive";
 export { blocksJsonSchema } from "./jsonSchema";
 export { BLOCK_LIMITS } from "./limits";
 export type { KnownDataset, LintBlocksOptions } from "./lint";
+export { checklistElementId, stepperElementIds } from "./lint";
 export type { ParseBlocksResult } from "./parse";
 export { parseBlocks } from "./parse";
 export type { ParseBlocksPartialResult } from "./parsePartial";
 export { parseBlocksPartial } from "./parsePartial";
+export type { BlockPlainTextOptions } from "./plainText";
+export { blockPlainText } from "./plainText";
 export { blocksPromptSection } from "./prompt";
-export type { ActionsBlock, BadgeBlock, Block, BlockAction, BlocksDocument, ButtonElement, CallbackAction, CalloutBlock, CardBlock, ChartBlock, ColumnsBlock, ContextBlock, Dataset, DatasetColumn, DetailsBlock, DividerBlock, HeadingBlock, HtmlBlock, ImageBlock, InlineDataset, LeafBlock, MetricBlock, OpenAction, RefDataset, ReplyAction, SegmentedElement, SelectAction, TableBlock, TextBlock, } from "./schema";
-export { BADGE_STATUSES, BUTTON_VARIANTS, blocksSchema, CALLOUT_STATUSES, CHART_HEIGHTS, CHART_KINDS, DATASET_COLUMN_TYPES, DATASET_GRAINS, HEADING_SIZES, HTML_HEIGHTS, METRIC_TRENDS, wrapAsTextDocument, } from "./schema";
+export type { ActionsBlock, BadgeBlock, Block, BlockAction, BlocksDocument, ButtonElement, CallbackAction, CalloutBlock, CardBlock, ChartBlock, ChecklistBlock, ChecklistCallback, ChecklistItem, ColumnsBlock, ContextBlock, CopyAction, Dataset, DatasetColumn, DetailsBlock, DividerBlock, GalleryBlock, GalleryImage, HeadingBlock, HtmlBlock, ImageBlock, InlineDataset, LeafBlock, ListBlock, ListItem, ListItemImage, MetricBlock, OpenAction, RefDataset, ReplyAction, SegmentedElement, SelectAction, StepperBlock, StepperCallback, StepperItem, TableBlock, TextBlock, } from "./schema";
+export { BADGE_STATUSES, BUTTON_VARIANTS, blocksSchema, CALLOUT_STATUSES, CHART_HEIGHTS, CHART_KINDS, COPY_TARGET_TYPES, DATASET_COLUMN_TYPES, DATASET_GRAINS, HEADING_SIZES, HTML_HEIGHTS, METRIC_TRENDS, STEPPER_ROUNDING, wrapAsTextDocument, } from "./schema";
 export type { ValidateBlocksResult } from "./validate";
 export { validateBlocks } from "./validate";

package/dist/index.js

@@ -1,7 +1,7 @@
 "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;
+exports.validateBlocks = exports.wrapAsTextDocument = exports.STEPPER_ROUNDING = exports.METRIC_TRENDS = exports.HTML_HEIGHTS = exports.HEADING_SIZES = exports.DATASET_GRAINS = exports.DATASET_COLUMN_TYPES = exports.COPY_TARGET_TYPES = exports.CHART_KINDS = exports.CHART_HEIGHTS = exports.CALLOUT_STATUSES = exports.blocksSchema = exports.BUTTON_VARIANTS = exports.BADGE_STATUSES = exports.blocksPromptSection = exports.blockPlainText = exports.parseBlocksPartial = exports.parseBlocks = exports.stepperElementIds = exports.checklistElementId = exports.BLOCK_LIMITS = exports.blocksJsonSchema = exports.unknownChecklistItemIds = exports.scaleStepperBlock = exports.isStepperValueAllowed = exports.applyChecklistState = 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");
@@ -84,14 +84,24 @@ Object.defineProperty(exports, "validateAskResponse", { enumerable: true, get: f
 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 interactive_1 = require("./interactive");
+Object.defineProperty(exports, "applyChecklistState", { enumerable: true, get: function () { return interactive_1.applyChecklistState; } });
+Object.defineProperty(exports, "isStepperValueAllowed", { enumerable: true, get: function () { return interactive_1.isStepperValueAllowed; } });
+Object.defineProperty(exports, "scaleStepperBlock", { enumerable: true, get: function () { return interactive_1.scaleStepperBlock; } });
+Object.defineProperty(exports, "unknownChecklistItemIds", { enumerable: true, get: function () { return interactive_1.unknownChecklistItemIds; } });
 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 lint_1 = require("./lint");
+Object.defineProperty(exports, "checklistElementId", { enumerable: true, get: function () { return lint_1.checklistElementId; } });
+Object.defineProperty(exports, "stepperElementIds", { enumerable: true, get: function () { return lint_1.stepperElementIds; } });
 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 plainText_1 = require("./plainText");
+Object.defineProperty(exports, "blockPlainText", { enumerable: true, get: function () { return plainText_1.blockPlainText; } });
 var prompt_2 = require("./prompt");
 Object.defineProperty(exports, "blocksPromptSection", { enumerable: true, get: function () { return prompt_2.blocksPromptSection; } });
 var schema_2 = require("./schema");
@@ -101,11 +111,13 @@ Object.defineProperty(exports, "blocksSchema", { enumerable: true, get: function
 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, "COPY_TARGET_TYPES", { enumerable: true, get: function () { return schema_2.COPY_TARGET_TYPES; } });
 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, "STEPPER_ROUNDING", { enumerable: true, get: function () { return schema_2.STEPPER_ROUNDING; } });
 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/interactive.d.ts

@@ -0,0 +1,26 @@
+import type { ChecklistBlock, StepperBlock } from "./schema";
+/** A checklist tick as the renderer sends it: the ticked item and every item's state. */
+export interface ChecklistTick {
+    checked: boolean;
+    itemId: string;
+    state: Record<string, boolean>;
+}
+/**
+ * True when `value` is finite, within `min`..`max`, and a whole number of `step`s from the
+ * stepper's own `value`.
+ */
+export declare const isStepperValueAllowed: (stepper: StepperBlock, value: number) => boolean;
+/**
+ * Returns `original` at `value` with every item scaled linearly from `original`, rounded by its
+ * `decimals` and `round`. Always scale from the block the agent wrote, not the last result, so
+ * rounding never drifts tap after tap. An original `value` of 0 keeps the amounts as written.
+ * Check the value with `isStepperValueAllowed` first.
+ */
+export declare const scaleStepperBlock: (original: StepperBlock, value: number) => StepperBlock;
+/** The ids in a tick (its `itemId` and `state` keys) that `checklist` has no item for, once each. */
+export declare const unknownChecklistItemIds: (checklist: ChecklistBlock, tick: ChecklistTick) => string[];
+/**
+ * Returns `checklist` with every item's `checked` taken from `tick.state`. An item missing from
+ * `state` is unchecked, and the ticked item always takes `tick.checked`.
+ */
+export declare const applyChecklistState: (checklist: ChecklistBlock, tick: ChecklistTick) => ChecklistBlock;

package/dist/interactive.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyChecklistState = exports.unknownChecklistItemIds = exports.scaleStepperBlock = exports.isStepperValueAllowed = void 0;
+/** Tolerance for float noise when checking the step grid and rounding up. */
+const EPSILON = 1e-9;
+const roundAmount = (amount, item) => {
+    const factor = 10 ** (item.decimals ?? 0);
+    const scaled = amount * factor;
+    const rounded = item.round === "up" ? Math.ceil(scaled - EPSILON) : Math.round(scaled);
+    return Number((rounded / factor).toFixed(item.decimals ?? 0));
+};
+/**
+ * True when `value` is finite, within `min`..`max`, and a whole number of `step`s from the
+ * stepper's own `value`.
+ */
+const isStepperValueAllowed = (stepper, value) => {
+    if (!Number.isFinite(value) || value < stepper.min || value > stepper.max) {
+        return false;
+    }
+    const steps = (value - stepper.value) / (stepper.step ?? 1);
+    return Math.abs(steps - Math.round(steps)) < EPSILON;
+};
+exports.isStepperValueAllowed = isStepperValueAllowed;
+/**
+ * Returns `original` at `value` with every item scaled linearly from `original`, rounded by its
+ * `decimals` and `round`. Always scale from the block the agent wrote, not the last result, so
+ * rounding never drifts tap after tap. An original `value` of 0 keeps the amounts as written.
+ * Check the value with `isStepperValueAllowed` first.
+ */
+const scaleStepperBlock = (original, value) => {
+    if (original.items === undefined) {
+        return { ...original, value };
+    }
+    const ratio = original.value === 0 ? 1 : value / original.value;
+    return {
+        ...original,
+        items: original.items.map((item) => ({
+            ...item,
+            amount: roundAmount(item.amount * ratio, item),
+        })),
+        value,
+    };
+};
+exports.scaleStepperBlock = scaleStepperBlock;
+/** The ids in a tick (its `itemId` and `state` keys) that `checklist` has no item for, once each. */
+const unknownChecklistItemIds = (checklist, tick) => {
+    const itemIds = new Set(checklist.items.map((item) => item.id));
+    return [...new Set([tick.itemId, ...Object.keys(tick.state)])].filter((id) => !itemIds.has(id));
+};
+exports.unknownChecklistItemIds = unknownChecklistItemIds;
+/**
+ * Returns `checklist` with every item's `checked` taken from `tick.state`. An item missing from
+ * `state` is unchecked, and the ticked item always takes `tick.checked`.
+ */
+const applyChecklistState = (checklist, tick) => ({
+    ...checklist,
+    items: checklist.items.map((item) => ({
+        ...item,
+        checked: item.id === tick.itemId ? tick.checked : tick.state[item.id] === true,
+    })),
+});
+exports.applyChecklistState = applyChecklistState;

package/dist/limits.d.ts

@@ -6,16 +6,35 @@ export declare const BLOCK_LIMITS: {
     readonly badgeTextMaxLength: 80;
     readonly barCategoryWarning: 60;
     readonly blockTextMaxLength: 4000;
+    readonly cardEyebrowMaxLength: 60;
     readonly cardTitleMaxLength: 120;
+    readonly checklistIdMaxLength: 31;
+    readonly checklistItemDetailMaxLength: 280;
+    readonly checklistItemIdMaxLength: 32;
+    readonly checklistItemMetaMaxLength: 40;
+    readonly checklistItemsMax: 30;
+    readonly checklistItemsMin: 1;
+    readonly checklistItemTextMaxLength: 120;
+    readonly checklistTitleMaxLength: 120;
     readonly columnsMax: 4;
     readonly columnsMin: 2;
     readonly contextTextMaxLength: 280;
+    readonly copyTextMaxLength: 4000;
     readonly datasetColumnMax: 12;
     readonly datasetRowMax: 500;
     readonly documentTextMaxLength: 20000;
     readonly donutSliceWarning: 8;
+    readonly galleryAltMaxLength: 200;
+    readonly galleryCaptionMaxLength: 120;
+    readonly galleryImagesMax: 6;
+    readonly galleryImagesMin: 2;
     readonly headingTextMaxLength: 200;
     readonly htmlMaxBytes: 100000;
+    readonly listItemMetaMaxLength: 40;
+    readonly listItemsMax: 12;
+    readonly listItemsMin: 1;
+    readonly listItemTextMaxLength: 500;
+    readonly listItemTitleMaxLength: 120;
     readonly maxBlocks: 50;
     readonly maxDatasets: 8;
     readonly maxDepth: 2;
@@ -24,4 +43,11 @@ export declare const BLOCK_LIMITS: {
     readonly metricLabelMaxLength: 80;
     readonly metricValueMaxLength: 80;
     readonly refLimitMax: 1000;
+    readonly stepperDecimalsMax: 3;
+    readonly stepperIdMaxLength: 54;
+    readonly stepperItemsMax: 12;
+    readonly stepperItemUnitMaxLength: 20;
+    readonly stepperLabelMaxLength: 80;
+    readonly stepperNoteMaxLength: 280;
+    readonly stepperUnitMaxLength: 40;
 };

package/dist/limits.js

@@ -9,16 +9,35 @@ exports.BLOCK_LIMITS = {
     badgeTextMaxLength: 80,
     barCategoryWarning: 60,
     blockTextMaxLength: 4_000,
+    cardEyebrowMaxLength: 60,
     cardTitleMaxLength: 120,
+    checklistIdMaxLength: 31,
+    checklistItemDetailMaxLength: 280,
+    checklistItemIdMaxLength: 32,
+    checklistItemMetaMaxLength: 40,
+    checklistItemsMax: 30,
+    checklistItemsMin: 1,
+    checklistItemTextMaxLength: 120,
+    checklistTitleMaxLength: 120,
     columnsMax: 4,
     columnsMin: 2,
     contextTextMaxLength: 280,
+    copyTextMaxLength: 4_000,
     datasetColumnMax: 12,
     datasetRowMax: 500,
     documentTextMaxLength: 20_000,
     donutSliceWarning: 8,
+    galleryAltMaxLength: 200,
+    galleryCaptionMaxLength: 120,
+    galleryImagesMax: 6,
+    galleryImagesMin: 2,
     headingTextMaxLength: 200,
     htmlMaxBytes: 100_000,
+    listItemMetaMaxLength: 40,
+    listItemsMax: 12,
+    listItemsMin: 1,
+    listItemTextMaxLength: 500,
+    listItemTitleMaxLength: 120,
     maxBlocks: 50,
     maxDatasets: 8,
     maxDepth: 2,
@@ -27,4 +46,11 @@ exports.BLOCK_LIMITS = {
     metricLabelMaxLength: 80,
     metricValueMaxLength: 80,
     refLimitMax: 1_000,
+    stepperDecimalsMax: 3,
+    stepperIdMaxLength: 54,
+    stepperItemsMax: 12,
+    stepperItemUnitMaxLength: 20,
+    stepperLabelMaxLength: 80,
+    stepperNoteMaxLength: 280,
+    stepperUnitMaxLength: 40,
 };

package/dist/lint.d.ts

@@ -1,16 +1,33 @@
 import { type BlockError } from "./errors";
-import type { BlocksDocument, DatasetColumn } from "./schema";
+import { type BlocksDocument, type DatasetColumn } from "./schema";
 export interface KnownDataset {
     columns: DatasetColumn[];
 }
 export interface LintBlocksOptions {
     /** When false or omitted, an `html` block fails with `HTML_DISABLED`. */
     allowHtml?: boolean;
+    /**
+     * Host actions that handle a checklist. When set, a checklist `callback.name` outside it fails
+     * with `UNKNOWN_HOST_ACTION`.
+     */
+    checklistActions?: readonly string[];
     hostActions?: readonly string[];
     /** Hostnames allowed on `https` image `src` values. Empty means no https images. */
     imageHosts?: readonly string[];
     knownDatasets?: Record<string, KnownDataset>;
+    /**
+     * Host actions that handle a stepper. When set, a stepper `callback.name` outside it fails with
+     * `UNKNOWN_HOST_ACTION`, even when the name is in `hostActions`. Omitted, `hostActions` applies.
+     */
+    stepperActions?: readonly string[];
 }
+/** The element ids a stepper's − and + buttons use in callback events. */
+export declare const stepperElementIds: (stepperId: string) => {
+    decrease: string;
+    increase: string;
+};
+/** The element id a checklist item's tick uses in callback events. */
+export declare const checklistElementId: (checklistId: string, itemId: string) => string;
 /**
  * Semantic checks for datasets, charts, and tables.
  * Structural schema errors are handled before this runs.

package/dist/lint.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lintDocument = void 0;
+exports.lintDocument = exports.checklistElementId = exports.stepperElementIds = void 0;
 const errors_1 = require("./errors");
 const limits_1 = require("./limits");
+const schema_1 = require("./schema");
 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) {
@@ -32,6 +33,85 @@ const imageSourceIssue = (src, hosts, path) => {
         path: `${path}.src`,
     });
 };
+/** The element ids a stepper's − and + buttons use in callback events. */
+const stepperElementIds = (stepperId) => ({
+    decrease: `${stepperId}_decrease`,
+    increase: `${stepperId}_increase`,
+});
+exports.stepperElementIds = stepperElementIds;
+/** The element id a checklist item's tick uses in callback events. */
+const checklistElementId = (checklistId, itemId) => `${checklistId}_${itemId}`;
+exports.checklistElementId = checklistElementId;
+const unknownHostActionIssue = (name, hostActions, path) => {
+    if (hostActions === undefined || hostActions.includes(name)) {
+        return undefined;
+    }
+    return issue({
+        code: "UNKNOWN_HOST_ACTION",
+        fix: `Use one of: ${hostActions.join(", ") || "(none registered)"}.`,
+        message: errors_1.BLOCK_ERROR_CODES.UNKNOWN_HOST_ACTION,
+        path,
+    });
+};
+const stepperIssues = (block, path, options) => {
+    const found = [];
+    if (block.min >= block.max) {
+        found.push(issue({
+            code: "OUT_OF_RANGE",
+            fix: "Set max above min.",
+            message: errors_1.BLOCK_ERROR_CODES.OUT_OF_RANGE,
+            path: `${path}.max`,
+        }));
+    }
+    else if (block.value < block.min || block.value > block.max) {
+        found.push(issue({
+            code: "OUT_OF_RANGE",
+            fix: `Set value between ${block.min} and ${block.max}.`,
+            message: errors_1.BLOCK_ERROR_CODES.OUT_OF_RANGE,
+            path: `${path}.value`,
+        }));
+    }
+    if (block.step !== undefined && block.step <= 0) {
+        found.push(issue({
+            code: "OUT_OF_RANGE",
+            fix: "Set step above 0, or leave it out for 1.",
+            message: errors_1.BLOCK_ERROR_CODES.OUT_OF_RANGE,
+            path: `${path}.step`,
+        }));
+    }
+    const unknown = unknownHostActionIssue(block.callback.name, options?.stepperActions ?? options?.hostActions, `${path}.callback.name`);
+    if (unknown) {
+        found.push(unknown);
+    }
+    return found;
+};
+const checklistIssues = (block, path, options) => {
+    const found = [];
+    const seenItemIds = new Set();
+    block.items.forEach((item, index) => {
+        if (seenItemIds.has(item.id)) {
+            found.push(issue({
+                code: "DUPLICATE_ID",
+                fix: `Give ${path}.items[${index}] an id no other item in this checklist uses.`,
+                message: errors_1.BLOCK_ERROR_CODES.DUPLICATE_ID,
+                path: `${path}.items[${index}].id`,
+            }));
+        }
+        seenItemIds.add(item.id);
+    });
+    if (block.callback === undefined) {
+        return found;
+    }
+    const unknown = unknownHostActionIssue(block.callback.name, options?.checklistActions ?? options?.hostActions, `${path}.callback.name`);
+    if (unknown) {
+        found.push(unknown);
+    }
+    return found;
+};
+const STEPPER_RESERVED_FIX = "A stepper uses <id>_decrease and <id>_increase for its buttons.";
+const CHECKLIST_RESERVED_FIX = "A checklist uses <id>_<item id> for each item's tick.";
+const copyTargetTypes = new Set(schema_1.COPY_TARGET_TYPES);
+const COPY_TARGET_FIX = `Set target to the id of a ${schema_1.COPY_TARGET_TYPES.slice(0, -1).join(", ")}, or ${schema_1.COPY_TARGET_TYPES.at(-1)} block in this document.`;
 const isInline = (dataset) => dataset.source !== "ref";
 const columnsFor = (dataset, options) => {
     if (isInline(dataset)) {
@@ -154,12 +234,61 @@ const lintDocument = (doc, options) => {
     }
     const seenIds = new Set();
     const selectableIds = new Set();
+    // Block ids a copy action may target, collected first so a target may sit before or after it.
+    const copyTargetIds = new Set();
+    // Element ids a renderer derives from a block id, mapped to the fix that explains the clash.
+    const reservedIds = new Map();
+    // Two blocks deriving the same element id would send ambiguous callback events. A clash within
+    // one block id is a repeated item or block id, which DUPLICATE_ID already reports elsewhere.
+    const reserve = ({ elementId, fix, ownerId, path, }) => {
+        const taken = reservedIds.get(elementId);
+        if (taken !== undefined && taken.ownerId !== ownerId) {
+            errors.push(issue({
+                code: "DUPLICATE_ID",
+                fix: `Rename ${path}. Its element id ${elementId} is already used. ${taken.fix}`,
+                message: errors_1.BLOCK_ERROR_CODES.DUPLICATE_ID,
+                path,
+            }));
+        }
+        reservedIds.set(elementId, { fix, ownerId });
+    };
     const walked = walk(doc.blocks, "blocks");
-    for (const { block } of walked) {
+    for (const { block, path } of walked) {
         if ((block.type === "chart" || block.type === "table") && block.id !== undefined) {
             selectableIds.add(block.id);
         }
+        if (copyTargetTypes.has(block.type) && block.id !== undefined) {
+            copyTargetIds.add(block.id);
+        }
+        if (block.type === "stepper") {
+            const { decrease, increase } = (0, exports.stepperElementIds)(block.id);
+            for (const elementId of [decrease, increase]) {
+                reserve({ elementId, fix: STEPPER_RESERVED_FIX, ownerId: block.id, path: `${path}.id` });
+            }
+        }
+        if (block.type === "checklist") {
+            block.items.forEach((item, index) => {
+                reserve({
+                    elementId: (0, exports.checklistElementId)(block.id, item.id),
+                    fix: CHECKLIST_RESERVED_FIX,
+                    ownerId: block.id,
+                    path: `${path}.items[${index}].id`,
+                });
+            });
+        }
     }
+    const idIssue = (id, path) => {
+        const reservedFix = reservedIds.get(id)?.fix;
+        if (!seenIds.has(id) && reservedFix === undefined) {
+            return undefined;
+        }
+        return issue({
+            code: "DUPLICATE_ID",
+            fix: reservedFix === undefined ? `Give ${path} a unique id.` : `Rename ${path}. ${reservedFix}`,
+            message: errors_1.BLOCK_ERROR_CODES.DUPLICATE_ID,
+            path: `${path}.id`,
+        });
+    };
     for (const { block, path } of walked) {
         if (block.type === "html") {
             if (options?.allowHtml !== true) {
@@ -186,17 +315,38 @@ const lintDocument = (doc, options) => {
                 errors.push(imageIssue);
             }
         }
+        if (block.type === "gallery") {
+            block.images.forEach((image, index) => {
+                const tileIssue = imageSourceIssue(image.src, options?.imageHosts, `${path}.images[${index}]`);
+                if (tileIssue) {
+                    errors.push(tileIssue);
+                }
+            });
+        }
+        if (block.type === "list") {
+            block.items.forEach((item, index) => {
+                if (item.image === undefined) {
+                    return;
+                }
+                const thumbnailIssue = imageSourceIssue(item.image.src, options?.imageHosts, `${path}.items[${index}].image`);
+                if (thumbnailIssue) {
+                    errors.push(thumbnailIssue);
+                }
+            });
+        }
         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`,
-                }));
+            const duplicate = idIssue(block.id, path);
+            if (duplicate) {
+                errors.push(duplicate);
             }
             seenIds.add(block.id);
         }
+        if (block.type === "stepper") {
+            errors.push(...stepperIssues(block, path, options));
+        }
+        if (block.type === "checklist") {
+            errors.push(...checklistIssues(block, path, options));
+        }
         if (block.type === "chart") {
             const hasPoints = block.points !== undefined;
             const hasData = block.data !== undefined || block.x !== undefined || block.y !== undefined;
@@ -295,13 +445,9 @@ const lintDocument = (doc, options) => {
         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`,
-                    }));
+                const duplicate = idIssue(element.id, elementPath);
+                if (duplicate) {
+                    errors.push(duplicate);
                 }
                 seenIds.add(element.id);
                 if (element.type === "segmented" && !selectableIds.has(element.target)) {
@@ -322,16 +468,11 @@ const lintDocument = (doc, options) => {
                         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 === "callback") {
+                    const unknown = unknownHostActionIssue(element.action.name, options?.hostActions, `${elementPath}.action.name`);
+                    if (unknown) {
+                        errors.push(unknown);
+                    }
                 }
                 if (element.type === "button" && element.action.kind === "open") {
                     const hasRoute = element.action.route !== undefined;
@@ -345,6 +486,25 @@ const lintDocument = (doc, options) => {
                         }));
                     }
                 }
+                if (element.type === "button" && element.action.kind === "copy") {
+                    const { target, text } = element.action;
+                    if ((target === undefined) === (text === undefined)) {
+                        errors.push(issue({
+                            code: "MISSING_REQUIRED",
+                            fix: "Set either text or target on a copy action.",
+                            message: errors_1.BLOCK_ERROR_CODES.MISSING_REQUIRED,
+                            path: `${elementPath}.action`,
+                        }));
+                    }
+                    else if (target !== undefined && !copyTargetIds.has(target)) {
+                        errors.push(issue({
+                            code: "COPY_TARGET_INVALID",
+                            fix: COPY_TARGET_FIX,
+                            message: errors_1.BLOCK_ERROR_CODES.COPY_TARGET_INVALID,
+                            path: `${elementPath}.action.target`,
+                        }));
+                    }
+                }
             });
         }
         if (block.type === "table") {

package/dist/plainText.d.ts

@@ -0,0 +1,17 @@
+import type { Block, Dataset } from "./schema";
+export interface BlockPlainTextOptions {
+    /**
+     * Current ticks by checklist item id. An entry overrides that item's `checked`; ids the
+     * checklist does not have are ignored.
+     */
+    checked?: Record<string, boolean>;
+    /** The document's datasets. A table copies only an inline dataset, so resolve refs first. */
+    datasets?: Record<string, Dataset>;
+}
+/**
+ * The text a copy action writes to the clipboard for its target block. Pass the block as it is
+ * shown now (a host override applied) and the current checklist ticks in `checked`. Blocks a
+ * copy action cannot target return an empty string, as does a table whose dataset is missing or
+ * an unresolved ref.
+ */
+export declare const blockPlainText: (block: Block, options?: BlockPlainTextOptions) => string;