@terreno/blocks 57.10.1

package/dist/asks/validateResponse.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAskResponse = void 0;
+const errors_1 = require("./errors");
+const files_1 = require("./files");
+const formValues_1 = require("./formValues");
+const limits_1 = require("./limits");
+const schema_1 = require("./schema");
+const countText = (count) => (count === 1 ? "1 option" : `${count} options`);
+/** "exactly 2 options", "1 to 3 options", or "at most 3 options". */
+const boundsText = ({ max, min }) => {
+    if (min === max) {
+        return `exactly ${countText(min)}`;
+    }
+    if (min === 0) {
+        return `at most ${countText(max)}`;
+    }
+    return `${min} to ${countText(max)}`;
+};
+const selectionCountDraft = ({ count, hasOther, input, }) => {
+    const bounds = (0, schema_1.choiceSelectionBounds)(input);
+    if (input.select === "one") {
+        return {
+            code: "SELECTION_COUNT",
+            fix: "Send exactly one option id in content.selected.",
+            message: `Choose exactly one option; the answer selects ${count}.`,
+            segments: ["content", "selected"],
+        };
+    }
+    const otherNote = input.allowOther === true ? " Other counts as one choice." : "";
+    return {
+        code: "SELECTION_COUNT",
+        fix: `Send ${boundsText(bounds)} in content.selected.${otherNote}`,
+        message: `Choose ${boundsText(bounds)}; the answer selects ${count}${hasOther ? ", counting Other" : ""}.`,
+        segments: ["content", "selected"],
+    };
+};
+const validateChoiceAnswer = (input, content) => {
+    const parsed = schema_1.choiceAnswerSchema.safeParse(content);
+    if (!parsed.success) {
+        return (0, errors_1.issuesToAskErrors)({ issues: parsed.error.issues, prefix: ["content"], root: content });
+    }
+    const { other, selected } = parsed.data;
+    const drafts = [];
+    const isOtherAllowed = input.allowOther === true;
+    if (other !== undefined && !isOtherAllowed) {
+        drafts.push({
+            code: "OTHER_NOT_ALLOWED",
+            fix: "Remove content.other and pick from the options.",
+            message: "This ask does not accept an Other answer.",
+            segments: ["content", "other"],
+        });
+    }
+    const hasOther = other !== undefined && isOtherAllowed;
+    const count = selected.length + (hasOther ? 1 : 0);
+    const { max, min } = (0, schema_1.choiceSelectionBounds)(input);
+    if (count < min || count > max) {
+        drafts.push(selectionCountDraft({ count, hasOther, input }));
+    }
+    const offeredIds = new Set(input.options.map((option) => option.id));
+    const firstIndexById = new Map();
+    selected.forEach((id, index) => {
+        const firstIndex = firstIndexById.get(id);
+        if (firstIndex !== undefined) {
+            drafts.push({
+                code: "DUPLICATE_ID",
+                fix: "List each option id in content.selected once.",
+                message: `${(0, errors_1.quoteValue)(id)} is already selected at ${(0, errors_1.formatAskPath)(["content", "selected", firstIndex])}.`,
+                segments: ["content", "selected", index],
+            });
+            return;
+        }
+        firstIndexById.set(id, index);
+        if (offeredIds.has(id)) {
+            return;
+        }
+        drafts.push({
+            code: "OPTION_NOT_OFFERED",
+            fix: "Use the id of one of the ask's options.",
+            message: `${(0, errors_1.quoteValue)(id)} is not one of the offered options.`,
+            segments: ["content", "selected", index],
+        });
+    });
+    return drafts;
+};
+const validateConfirmAnswer = (content) => {
+    const parsed = schema_1.confirmAnswerSchema.safeParse(content);
+    if (parsed.success) {
+        return [];
+    }
+    return (0, errors_1.issuesToAskErrors)({ issues: parsed.error.issues, prefix: ["content"], root: content });
+};
+const characters = (count) => (count === 1 ? "1 character" : `${count} characters`);
+/**
+ * The text must fit the ask's bounds, and `changed` must say truthfully whether it differs from
+ * the draft, so the agent can trust `changed: false` to mean the user approved the draft as is.
+ */
+const markdownTooLong = (length, max) => ({
+    code: "TOO_LONG",
+    fix: `Shorten content.markdown to ${characters(max)} or fewer.`,
+    message: `The text is ${characters(length)}, but this ask allows at most ${max}.`,
+    segments: ["content", "markdown"],
+});
+const isMarkdownTooLong = ({ code, segments }) => code === "TOO_LONG" &&
+    segments.length === 2 &&
+    segments[0] === "content" &&
+    segments[1] === "markdown";
+const validateMarkdownAnswer = (input, content) => {
+    const { max, min } = (0, schema_1.markdownLengthBounds)(input);
+    const parsed = schema_1.markdownAnswerSchema.safeParse(content);
+    if (!parsed.success) {
+        const sent = typeof content === "object" && content !== null
+            ? content.markdown
+            : undefined;
+        const length = typeof sent === "string" ? sent.length : 0;
+        // The schema's 20,000 cap fires before the ask's own maxLength, so the fix names the tighter one.
+        return (0, errors_1.issuesToAskErrors)({ issues: parsed.error.issues, prefix: ["content"], root: content }).map((draft) => (isMarkdownTooLong(draft) ? markdownTooLong(length, max) : draft));
+    }
+    const { changed, markdown } = parsed.data;
+    const drafts = [];
+    if (markdown.length > max) {
+        drafts.push(markdownTooLong(markdown.length, max));
+    }
+    const visibleLength = markdown.trim().length;
+    if (visibleLength < min) {
+        drafts.push({
+            code: "TOO_SHORT",
+            fix: `Write at least ${characters(min)} in content.markdown.`,
+            message: `The text is ${characters(visibleLength)}, but this ask needs at least ${min}.`,
+            segments: ["content", "markdown"],
+        });
+    }
+    const isChanged = markdown !== (input.initial ?? "");
+    if (changed !== isChanged) {
+        drafts.push({
+            code: "CHANGED_MISMATCH",
+            fix: `Set content.changed to ${String(isChanged)}.`,
+            message: isChanged
+                ? "The text differs from the draft, but changed is false."
+                : "The text is the same as the draft, but changed is true.",
+            segments: ["content", "changed"],
+        });
+    }
+    return drafts;
+};
+/**
+ * Every value must belong to a field, every required field needs a non-blank value, and every
+ * value must be one its field accepts. A blank value on an optional field counts as unanswered.
+ */
+const validateFormAnswer = (input, content) => {
+    const parsed = schema_1.formAnswerEnvelopeSchema.safeParse(content);
+    if (!parsed.success) {
+        return (0, errors_1.issuesToAskErrors)({ issues: parsed.error.issues, prefix: ["content"], root: content });
+    }
+    const { values } = parsed.data;
+    const fieldIds = new Set(input.fields.map((field) => field.id));
+    const drafts = Object.keys(values)
+        .filter((id) => !fieldIds.has(id))
+        .map((id) => ({
+        code: "UNKNOWN_KEY",
+        fix: `Remove ${(0, errors_1.quoteValue)(id)} from content.values.`,
+        message: `${(0, errors_1.quoteValue)(id)} is not the id of any field in this form.`,
+        segments: ["content", "values", id],
+    }));
+    for (const field of input.fields) {
+        const segments = ["content", "values", field.id];
+        const value = Object.hasOwn(values, field.id) ? values[field.id] : undefined;
+        if (value === undefined || (0, formValues_1.isBlankFormValue)(value)) {
+            if (field.required === true) {
+                drafts.push({
+                    code: "REQUIRED_FIELD",
+                    fix: `Fill in ${(0, errors_1.quoteValue)(field.label)} (content.values.${field.id}).`,
+                    message: `${(0, errors_1.quoteValue)(field.label)} is required.`,
+                    segments,
+                });
+            }
+            continue;
+        }
+        drafts.push(...(0, formValues_1.checkFormValue)({ field, isDefault: false, segments, value }));
+    }
+    return drafts;
+};
+const fileCountText = (count) => (count === 1 ? "1 file" : `${count} files`);
+const fileBoundsText = ({ max, min }) => min === max ? `exactly ${fileCountText(min)}` : `${min} to ${fileCountText(max)}`;
+/**
+ * The count must fit the ask, each declared type must be one `accept` allows, each file must fit
+ * the per-file cap, and a data URL's media type must be the declared type. The server then checks
+ * the bytes themselves with `checkAskFileBytes`.
+ */
+const validateFilesAnswer = (input, content, maxFileSizeBytes) => {
+    const parsed = schema_1.filesAnswerSchema.safeParse(content);
+    if (!parsed.success) {
+        return (0, errors_1.issuesToAskErrors)({ issues: parsed.error.issues, prefix: ["content"], root: content });
+    }
+    const { files } = parsed.data;
+    const drafts = [];
+    const bounds = (0, schema_1.filesCountBounds)(input);
+    if (files.length < bounds.min || files.length > bounds.max) {
+        drafts.push({
+            code: "FILE_COUNT",
+            fix: `Send ${fileBoundsText(bounds)} in content.files.`,
+            message: `This ask takes ${fileBoundsText(bounds)}; the answer has ${files.length}.`,
+            segments: ["content", "files"],
+        });
+    }
+    const accepted = (0, files_1.acceptedFileMimeTypes)(input.accept);
+    files.forEach((file, index) => {
+        const segments = ["content", "files", index];
+        if (!accepted.includes(file.mimeType)) {
+            drafts.push({
+                code: "FILE_TYPE_NOT_ACCEPTED",
+                fix: `Send a file of type ${accepted.join(", ")}.`,
+                message: `${(0, errors_1.quoteValue)(file.filename)} is ${file.mimeType}, which this ask does not accept.`,
+                segments: [...segments, "mimeType"],
+            });
+        }
+        const dataUrl = file.url === undefined ? undefined : (0, files_1.parseAskDataUrl)(file.url);
+        const size = dataUrl === undefined ? file.size : (0, files_1.base64ByteLength)(dataUrl.base64);
+        if (Math.max(size, file.size) > maxFileSizeBytes) {
+            drafts.push((0, files_1.fileTooLargeDraft)({
+                maxFileSizeBytes,
+                segments: [...segments, "size"],
+                size: Math.max(size, file.size),
+            }));
+        }
+        if (dataUrl !== undefined && dataUrl.mediaType !== file.mimeType) {
+            drafts.push({
+                code: "MIME_MISMATCH",
+                fix: `Make the data URL's media type ${file.mimeType}, or declare ${dataUrl.mediaType}.`,
+                message: `The data URL holds ${dataUrl.mediaType}, but the file is declared as ${file.mimeType}.`,
+                segments: [...segments, "url"],
+            });
+        }
+    });
+    return drafts;
+};
+/**
+ * Checks a user's answer against the ask it answers. The client runs it before enabling Submit and
+ * the server runs it before resuming the turn. Returns no errors when the answer is valid.
+ * `maxFileSizeBytes` is the host's per-file cap for `files` answers (10 MB by default).
+ */
+const validateAskResponse = ({ input, kind, maxFileSizeBytes = limits_1.ASK_LIMITS.files.defaultMaxFileSizeBytes, response, }) => {
+    const ask = { input, kind };
+    const envelope = schema_1.askResponseSchema.safeParse(response);
+    if (!envelope.success) {
+        return (0, errors_1.finalizeAskErrors)((0, errors_1.issuesToAskErrors)({ issues: envelope.error.issues, root: response }));
+    }
+    const answer = envelope.data;
+    if (answer.action === "cancel") {
+        return [];
+    }
+    if (answer.action === "decline") {
+        if ((0, schema_1.askAllowsDecline)(ask)) {
+            return [];
+        }
+        return [
+            {
+                code: "DECLINE_NOT_ALLOWED",
+                fix: 'Answer with action "accept".',
+                message: "This ask cannot be skipped.",
+                path: "action",
+            },
+        ];
+    }
+    switch (ask.kind) {
+        case "choice":
+            return (0, errors_1.finalizeAskErrors)(validateChoiceAnswer(ask.input, answer.content));
+        case "confirm":
+            return (0, errors_1.finalizeAskErrors)(validateConfirmAnswer(answer.content));
+        case "markdown":
+            return (0, errors_1.finalizeAskErrors)(validateMarkdownAnswer(ask.input, answer.content));
+        case "form":
+            return (0, errors_1.finalizeAskErrors)(validateFormAnswer(ask.input, answer.content));
+        case "files":
+            return (0, errors_1.finalizeAskErrors)(validateFilesAnswer(ask.input, answer.content, maxFileSizeBytes));
+    }
+};
+exports.validateAskResponse = validateAskResponse;

package/dist/cli.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env bun
+export declare const runBlocksCli: (argv: readonly string[], input: {
+    readFile: (path: string) => string;
+    readStdin: () => string;
+}) => {
+    code: number;
+    stderr: string;
+    stdout: string;
+};
+/** Runs validate when the process was started as the `terreno-blocks` bin. */
+export declare const launchBlocksCli: (argv1: string | undefined) => void;

package/dist/cli.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env bun
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchBlocksCli = exports.runBlocksCli = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const parse_1 = require("./parse");
+const validate_1 = require("./validate");
+const usage = "Usage: terreno-blocks validate <file | ->\n";
+const formatError = (error) => `${error.path}  ${error.code}  ${error.message} — ${error.fix}`;
+const runBlocksCli = (argv, input) => {
+    const [command, target, extra] = argv;
+    if (command !== "validate" || target === undefined || extra !== undefined) {
+        return { code: 1, stderr: usage, stdout: "" };
+    }
+    let text;
+    try {
+        text = target === "-" ? input.readStdin() : input.readFile(target);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Could not read the file.";
+        return { code: 1, stderr: `${message}\n`, stdout: "" };
+    }
+    const parsed = (0, parse_1.parseBlocks)(text);
+    if (!parsed.ok) {
+        return { code: 1, stderr: "", stdout: `${parsed.errors.map(formatError).join("\n")}\n` };
+    }
+    const validated = (0, validate_1.validateBlocks)(parsed.value);
+    if (!validated.ok) {
+        return { code: 1, stderr: "", stdout: `${validated.errors.map(formatError).join("\n")}\n` };
+    }
+    const warnings = validated.warnings.length === 0 ? "" : `${validated.warnings.map(formatError).join("\n")}\n`;
+    return { code: 0, stderr: "", stdout: warnings };
+};
+exports.runBlocksCli = runBlocksCli;
+const main = () => {
+    const result = (0, exports.runBlocksCli)(process.argv.slice(2), {
+        readFile: (path) => (0, node_fs_1.readFileSync)(path, "utf8"),
+        readStdin: () => (0, node_fs_1.readFileSync)(0, "utf8"),
+    });
+    if (result.stdout !== "") {
+        process.stdout.write(result.stdout);
+    }
+    if (result.stderr !== "") {
+        process.stderr.write(result.stderr);
+    }
+    process.exit(result.code);
+};
+/** Runs validate when the process was started as the `terreno-blocks` bin. */
+const launchBlocksCli = (argv1) => {
+    const entry = (0, node_path_1.basename)(argv1 ?? "");
+    // npm links the bin as `terreno-blocks`, so argv[1] is that name rather than cli.js.
+    if (entry === "cli.ts" || entry === "cli.js" || entry === "terreno-blocks") {
+        main();
+    }
+};
+exports.launchBlocksCli = launchBlocksCli;
+(0, exports.launchBlocksCli)(process.argv[1]);

package/dist/errors.d.ts

@@ -0,0 +1,51 @@
+/** Error codes for whole-reply documents. Warnings never block rendering. */
+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 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.";
+    readonly DUPLICATE_ID: "An id or a column name is used more than once.";
+    readonly HTML_DISABLED: "An html block is present and this host has not turned HTML on.";
+    readonly HTML_TOO_LARGE: "An html block is larger than 100,000 bytes.";
+    readonly IMAGE_HOST_NOT_ALLOWED: "An image URL is not a data:image URL, a file: ref, or an https URL on an allowed host.";
+    readonly INVALID_ENUM: "A value is not one of the allowed values.";
+    readonly INVALID_FORMAT: "A string does not match its required format.";
+    readonly INVALID_TYPE: "A value has the wrong type.";
+    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 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.";
+    readonly TOO_FEW: "A list has fewer items than allowed.";
+    readonly TOO_LONG: "A string is longer than allowed.";
+    readonly TOO_MANY: "A list has more items than allowed.";
+    readonly TOO_MANY_BLOCKS: "The document has more than the maximum number of blocks.";
+    readonly TOO_MANY_POINTS: "A ref dataset asks for more rendered rows than allowed.";
+    readonly TOO_SHORT: "A string is empty or only whitespace.";
+    readonly UNKNOWN_HOST_ACTION: "A callback names a host action that is not registered.";
+    readonly UNKNOWN_KEY: "An object has a field that its schema does not define.";
+    readonly UNSUPPORTED_VERSION: "The document version is not 1.";
+    readonly YAML_FEATURE_DISALLOWED: "The document uses a YAML anchor, alias, or custom tag.";
+};
+/** Chart heuristics. They ride along on a valid document and do not block rendering. */
+export declare const BLOCK_WARNING_CODES: {
+    readonly BAR_TOO_MANY_CATEGORIES: "A bar chart has more categories than fit comfortably.";
+    readonly DONUT_TOO_MANY_SLICES: "A donut chart has more slices than fit comfortably.";
+    readonly LINE_SINGLE_POINT: "A line chart has only one point.";
+};
+export type BlockWarningCode = keyof typeof BLOCK_WARNING_CODES;
+export type BlockErrorCode = keyof typeof BLOCK_ERROR_CODES;
+export interface BlockError {
+    /** A key of `BLOCK_ERROR_CODES` or `BLOCK_WARNING_CODES`. */
+    code: BlockErrorCode | BlockWarningCode;
+    /** One instruction that fixes the error. */
+    fix: string;
+    /** What is wrong, in one sentence. */
+    message: string;
+    /** Where the error is, such as `blocks[0].text`. The root is an empty string. */
+    path: string;
+}
+export declare const formatBlockPath: (segments: readonly PropertyKey[]) => string;
+export declare const sortBlockErrors: (errors: readonly BlockError[]) => BlockError[];

package/dist/errors.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortBlockErrors = exports.formatBlockPath = exports.BLOCK_WARNING_CODES = exports.BLOCK_ERROR_CODES = void 0;
+/** Error codes for whole-reply documents. Warnings never block rendering. */
+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.",
+    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.",
+    DUPLICATE_ID: "An id or a column name is used more than once.",
+    HTML_DISABLED: "An html block is present and this host has not turned HTML on.",
+    HTML_TOO_LARGE: "An html block is larger than 100,000 bytes.",
+    IMAGE_HOST_NOT_ALLOWED: "An image URL is not a data:image URL, a file: ref, or an https URL on an allowed host.",
+    INVALID_ENUM: "A value is not one of the allowed values.",
+    INVALID_FORMAT: "A string does not match its required format.",
+    INVALID_TYPE: "A value has the wrong type.",
+    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.",
+    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.",
+    TOO_FEW: "A list has fewer items than allowed.",
+    TOO_LONG: "A string is longer than allowed.",
+    TOO_MANY: "A list has more items than allowed.",
+    TOO_MANY_BLOCKS: "The document has more than the maximum number of blocks.",
+    TOO_MANY_POINTS: "A ref dataset asks for more rendered rows than allowed.",
+    TOO_SHORT: "A string is empty or only whitespace.",
+    UNKNOWN_HOST_ACTION: "A callback names a host action that is not registered.",
+    UNKNOWN_KEY: "An object has a field that its schema does not define.",
+    UNSUPPORTED_VERSION: "The document version is not 1.",
+    YAML_FEATURE_DISALLOWED: "The document uses a YAML anchor, alias, or custom tag.",
+};
+/** Chart heuristics. They ride along on a valid document and do not block rendering. */
+exports.BLOCK_WARNING_CODES = {
+    BAR_TOO_MANY_CATEGORIES: "A bar chart has more categories than fit comfortably.",
+    DONUT_TOO_MANY_SLICES: "A donut chart has more slices than fit comfortably.",
+    LINE_SINGLE_POINT: "A line chart has only one point.",
+};
+const formatBlockPath = (segments) => segments.reduce((path, segment) => {
+    if (typeof segment === "number") {
+        return `${path}[${segment}]`;
+    }
+    const key = String(segment);
+    if (path === "") {
+        return key;
+    }
+    return `${path}.${key}`;
+}, "");
+exports.formatBlockPath = formatBlockPath;
+const pathIndex = (segment) => {
+    const index = Number(segment);
+    if (segment !== "" && String(index) === segment) {
+        return index;
+    }
+    return segment;
+};
+/** Splits `blocks[0].text` into comparable pieces so indexes sort numerically. */
+const blockPathSegments = (path) => {
+    const parts = [];
+    const pattern = /([^[\].]+)|\[(\d+)\]/g;
+    for (const match of path.matchAll(pattern)) {
+        const index = match[2];
+        if (index !== undefined) {
+            parts.push(pathIndex(index));
+            continue;
+        }
+        const key = match[1];
+        if (key !== undefined) {
+            parts.push(key);
+        }
+    }
+    return parts;
+};
+const compareBlockPaths = (left, right) => {
+    const leftParts = blockPathSegments(left);
+    const rightParts = blockPathSegments(right);
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = leftParts[index];
+        const rightPart = rightParts[index];
+        if (leftPart === undefined) {
+            return -1;
+        }
+        if (rightPart === undefined) {
+            return 1;
+        }
+        if (leftPart === rightPart) {
+            continue;
+        }
+        if (typeof leftPart === "number" && typeof rightPart === "number") {
+            return leftPart - rightPart;
+        }
+        return String(leftPart) < String(rightPart) ? -1 : 1;
+    }
+    return 0;
+};
+const sortBlockErrors = (errors) => [...errors].sort((left, right) => {
+    const byPath = compareBlockPaths(left.path, right.path);
+    if (byPath !== 0) {
+        return byPath;
+    }
+    return left.code < right.code ? -1 : 1;
+});
+exports.sortBlockErrors = sortBlockErrors;

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export type { AskErrorCode, AskValidationError } from "./asks/errors";
+export { ASK_ERROR_CODES } from "./asks/errors";
+export type { AskFileAccept, AskFileMimeType, SniffedFileType } from "./asks/files";
+export { ASK_FILE_ACCEPT, ASK_FILE_ACCEPT_MIME_TYPES, acceptedFileMimeTypes, checkAskFileBytes, fileNotOwnedError, isTextFileMimeType, parseAskDataUrl, sniffFileBytes, } from "./asks/files";
+export type { FormValue } from "./asks/formValues";
+export { formDefaultValues, formTextMaxLength } from "./asks/formValues";
+export type { AskResponseWithToolCallId, PendingAskListItem, PendingAskSummary, TurnRequest, TurnResult, } from "./asks/headless";
+export { askResponseWithToolCallIdSchema, askSurfaceSchema, pendingAskListItemSchema, pendingAskListSchema, pendingAskSummarySchema, turnRequestSchema, turnResultSchema, } from "./asks/headless";
+export { askJsonSchemas } from "./asks/jsonSchema";
+export { ASK_LIMITS } from "./asks/limits";
+export { askPromptSection } from "./asks/prompt";
+export type { Ask, AskFileRef, AskKind, AskResponse, AskSurface, ChoiceAnswer, ChoiceAsk, ChoiceAskInput, ChoiceAskResponse, ChoiceOption, ChoiceSelectMode, CompactAskKind, ConfirmAnswer, ConfirmAsk, ConfirmAskInput, ConfirmAskResponse, FilesAnswer, FilesAsk, FilesAskInput, FilesAskResponse, FormAnswer, FormAsk, FormAskInput, FormAskResponse, FormField, FormFieldType, MarkdownAnswer, MarkdownAsk, MarkdownAskInput, MarkdownAskResponse, } from "./asks/schema";
+export { ASK_CANCEL_REASONS, ASK_KINDS, ASK_SURFACES, askAcceptResponseSchema, askAllowsDecline, askCancelResponseSchema, askDeclineResponseSchema, askFileRefSchema, askInputSchemaFor, askInputSchemas, askKindsForSurface, askOutputSchemas, askResponseSchema, CHOICE_SELECT_MODES, COMPACT_ASK_KINDS, choiceAnswerSchema, choiceAskInputSchema, choiceAskResponseSchema, choiceOptionSchema, choiceSelectionBounds, compactAskInputSchemas, compactChoiceAskInputSchema, confirmAnswerSchema, confirmAskInputSchema, confirmAskResponseSchema, confirmButtonLabels, FORM_FIELD_TYPES, filesAnswerSchema, filesAskInputSchema, filesAskResponseSchema, filesCountBounds, formAnswerSchema, formAskInputSchema, formAskResponseSchema, formFieldSchema, isCompactAskKind, markdownAnswerSchema, markdownAskInputSchema, markdownAskResponseSchema, markdownLengthBounds, } from "./asks/schema";
+export type { SimpleCard, SimpleCardButton } from "./asks/simpleCard";
+export { resolveButtonAnswer, SIMPLE_CARD_BUTTON_STYLES, simpleCardButtonSchema, simpleCardSchema, toSimpleCard, } from "./asks/simpleCard";
+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 { blocksJsonSchema } from "./jsonSchema";
+export { BLOCK_LIMITS } from "./limits";
+export type { KnownDataset, LintBlocksOptions } from "./lint";
+export type { ParseBlocksResult } from "./parse";
+export { parseBlocks } from "./parse";
+export type { ParseBlocksPartialResult } from "./parsePartial";
+export { parseBlocksPartial } from "./parsePartial";
+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 { ValidateBlocksResult } from "./validate";
+export { validateBlocks } from "./validate";