@terreno/blocks 57.10.1

package/src/asks/files.test.ts

@@ -0,0 +1,294 @@
+import {describe, expect, it} from "bun:test";
+import {
+  checkAskFileBytes,
+  fileNotOwnedError,
+  isTextFileMimeType,
+  parseAskDataUrl,
+  sniffFileBytes,
+} from "./files";
+import type {FilesAskInput} from "./schema";
+import {validateAskResponse} from "./validateResponse";
+
+const RECEIPT_INPUT: FilesAskInput = {
+  accept: ["image", "pdf"],
+  maxFiles: 3,
+  prompt: "Upload a photo of the receipt.",
+};
+
+const MB = 1024 * 1024;
+
+const bytesOf = (...values: (number | string)[]): Uint8Array =>
+  new Uint8Array(
+    values.flatMap((value) =>
+      typeof value === "string" ? [...Buffer.from(value, "utf8")] : [value]
+    )
+  );
+
+const PNG = bytesOf(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0, 0, 0, 13, "IHDR");
+const JPEG = bytesOf(0xff, 0xd8, 0xff, 0xe0, 0, 16, "JFIF");
+const GIF = bytesOf("GIF89a", 1, 0, 1, 0);
+const WEBP = bytesOf("RIFF", 36, 0, 0, 0, "WEBPVP8 ");
+const PDF = bytesOf("%PDF-1.7\n%âãÏÓ\n");
+
+const dataUrl = (mimeType: string, bytes: Uint8Array): string =>
+  `data:${mimeType};base64,${Buffer.from(bytes).toString("base64")}`;
+
+const check = (files: unknown[], input: FilesAskInput = RECEIPT_INPUT, maxFileSizeBytes?: number) =>
+  validateAskResponse({
+    input,
+    kind: "files",
+    maxFileSizeBytes,
+    response: {action: "accept", content: {files}},
+  }).map(({code, path}) => ({code, path}));
+
+const uploaded = {
+  fileId: "6710c2a4f1",
+  filename: "receipt.jpg",
+  mimeType: "image/jpeg",
+  size: 482113,
+};
+
+describe("validateAskResponse for files", () => {
+  it("accepts uploaded files and data URLs within the count, types, and cap", () => {
+    expect(check([uploaded])).toEqual([]);
+    expect(
+      check([
+        uploaded,
+        {
+          filename: "scan.pdf",
+          mimeType: "application/pdf",
+          size: PDF.length,
+          url: dataUrl("application/pdf", PDF),
+        },
+      ])
+    ).toEqual([]);
+  });
+
+  it("accepts decline by default and rejects it when allowDecline is false", () => {
+    expect(
+      validateAskResponse({input: RECEIPT_INPUT, kind: "files", response: {action: "decline"}})
+    ).toEqual([]);
+    expect(
+      validateAskResponse({
+        input: {...RECEIPT_INPUT, allowDecline: false},
+        kind: "files",
+        response: {action: "decline"},
+      }).map((error) => error.code)
+    ).toEqual(["DECLINE_NOT_ALLOWED"]);
+  });
+
+  it("FILE_COUNT for fewer than minFiles or more than maxFiles", () => {
+    expect(check([])).toEqual([{code: "FILE_COUNT", path: "content.files"}]);
+    expect(check([uploaded, uploaded, uploaded, uploaded])).toEqual([
+      {code: "FILE_COUNT", path: "content.files"},
+    ]);
+    expect(
+      validateAskResponse({
+        input: {...RECEIPT_INPUT, maxFiles: 2, minFiles: 2},
+        kind: "files",
+        response: {action: "accept", content: {files: [uploaded]}},
+      })
+    ).toEqual([
+      {
+        code: "FILE_COUNT",
+        fix: "Send exactly 2 files in content.files.",
+        message: "This ask takes exactly 2 files; the answer has 1.",
+        path: "content.files",
+      },
+    ]);
+  });
+
+  it("FILE_TYPE_NOT_ACCEPTED for a declared type the accept list does not allow", () => {
+    expect(
+      validateAskResponse({
+        input: RECEIPT_INPUT,
+        kind: "files",
+        response: {
+          action: "accept",
+          content: {files: [{...uploaded, filename: "notes.txt", mimeType: "text/plain"}]},
+        },
+      })
+    ).toEqual([
+      {
+        code: "FILE_TYPE_NOT_ACCEPTED",
+        fix: "Send a file of type image/jpeg, image/png, image/gif, image/webp, application/pdf.",
+        message: '"notes.txt" is text/plain, which this ask does not accept.',
+        path: "content.files[0].mimeType",
+      },
+    ]);
+  });
+
+  it("FILE_TOO_LARGE above the 10 MB default or the host's cap", () => {
+    expect(check([{...uploaded, size: 10 * MB}])).toEqual([]);
+    expect(
+      validateAskResponse({
+        input: RECEIPT_INPUT,
+        kind: "files",
+        response: {action: "accept", content: {files: [{...uploaded, size: 10.5 * MB}]}},
+      })
+    ).toEqual([
+      {
+        code: "FILE_TOO_LARGE",
+        fix: "Send a file of 10 MB or less.",
+        message: "The file is 10.5 MB, but the limit is 10 MB.",
+        path: "content.files[0].size",
+      },
+    ]);
+    expect(check([{...uploaded, size: 10 * MB + 1}])).toEqual([
+      {code: "FILE_TOO_LARGE", path: "content.files[0].size"},
+    ]);
+    expect(check([{...uploaded, size: 2 * MB}], RECEIPT_INPUT, MB)).toEqual([
+      {code: "FILE_TOO_LARGE", path: "content.files[0].size"},
+    ]);
+  });
+
+  it("measures a data URL by its bytes, not its declared size", () => {
+    const url = dataUrl("image/png", new Uint8Array(2048));
+    expect(
+      check([{filename: "a.png", mimeType: "image/png", size: 1, url}], RECEIPT_INPUT, 1024)
+    ).toEqual([{code: "FILE_TOO_LARGE", path: "content.files[0].size"}]);
+  });
+
+  it("MIME_MISMATCH when the data URL's media type is not the declared type", () => {
+    expect(
+      check([
+        {
+          filename: "a.png",
+          mimeType: "image/png",
+          size: PNG.length,
+          url: dataUrl("image/gif", PNG),
+        },
+      ])
+    ).toEqual([{code: "MIME_MISMATCH", path: "content.files[0].url"}]);
+  });
+
+  it("needs exactly one of fileId and a base64 data URL", () => {
+    const {fileId: _fileId, ...withoutId} = uploaded;
+    expect(check([withoutId])).toEqual([{code: "MISSING_REQUIRED", path: "content.files[0]"}]);
+    expect(check([{...uploaded, url: dataUrl("image/jpeg", JPEG)}])).toEqual([
+      {code: "INVALID_FORMAT", path: "content.files[0].url"},
+    ]);
+    for (const url of [
+      "https://example.com/a.jpg",
+      "data:image/jpeg,raw",
+      "data:image/jpeg;base64,@@@",
+    ]) {
+      expect(check([{...withoutId, url}])).toEqual([
+        {code: "INVALID_FORMAT", path: "content.files[0].url"},
+      ]);
+    }
+  });
+
+  it("rejects unknown keys, blank filenames, and negative sizes", () => {
+    expect(check([{...uploaded, filename: " ", path: "/tmp/a", size: -1}])).toEqual([
+      {code: "TOO_SHORT", path: "content.files[0].filename"},
+      {code: "UNKNOWN_KEY", path: "content.files[0].path"},
+      {code: "RANGE_INVALID", path: "content.files[0].size"},
+    ]);
+  });
+});
+
+describe("parseAskDataUrl", () => {
+  it("returns the lowercase media type without parameters, and the payload", () => {
+    expect(parseAskDataUrl("data:Text/Plain;charset=utf-8;base64,aGk=")).toEqual({
+      base64: "aGk=",
+      mediaType: "text/plain",
+    });
+  });
+
+  it("rejects remote URLs, URL-encoded data, and bad base64", () => {
+    expect(parseAskDataUrl("https://example.com/a.png")).toBeUndefined();
+    expect(parseAskDataUrl("data:text/plain,hi")).toBeUndefined();
+    expect(parseAskDataUrl("data:;base64,aGk=")).toBeUndefined();
+    expect(parseAskDataUrl("data:text/plain;base64,aGk")).toBeUndefined();
+    expect(parseAskDataUrl("data:text/plain;base64")).toBeUndefined();
+  });
+});
+
+describe("sniffFileBytes", () => {
+  it("reads images and PDFs from their signatures", () => {
+    expect(sniffFileBytes(PNG)).toBe("image/png");
+    expect(sniffFileBytes(JPEG)).toBe("image/jpeg");
+    expect(sniffFileBytes(GIF)).toBe("image/gif");
+    expect(sniffFileBytes(bytesOf("GIF87a"))).toBe("image/gif");
+    expect(sniffFileBytes(WEBP)).toBe("image/webp");
+    expect(sniffFileBytes(PDF)).toBe("application/pdf");
+  });
+
+  it("reads UTF-8 without NUL as text, with or without a byte order mark", () => {
+    expect(sniffFileBytes(bytesOf("date,amount\n2026-09-28,12.50\n"))).toBe("text");
+    expect(sniffFileBytes(bytesOf(0xef, 0xbb, 0xbf, "Grüße ✓"))).toBe("text");
+    expect(sniffFileBytes(new Uint8Array())).toBe("text");
+  });
+
+  it("reads anything else as unknown", () => {
+    expect(sniffFileBytes(bytesOf(0xc3, 0x28))).toBe("unknown");
+    expect(sniffFileBytes(bytesOf("a", 0, "b"))).toBe("unknown");
+    expect(sniffFileBytes(bytesOf("RIFF", 0, 0, 0, 0, "WAVE"))).toBe("unknown");
+  });
+});
+
+describe("checkAskFileBytes", () => {
+  const checkBytes = (bytes: Uint8Array, mimeType: string, maxFileSizeBytes = MB) =>
+    checkAskFileBytes({bytes, index: 1, maxFileSizeBytes, mimeType});
+
+  it("accepts bytes that match the declared type", () => {
+    expect(checkBytes(PNG, "image/png")).toEqual([]);
+    expect(checkBytes(PDF, "application/pdf")).toEqual([]);
+    expect(checkBytes(bytesOf("hello"), "text/plain")).toEqual([]);
+    expect(checkBytes(bytesOf("a,b\n1,2"), "text/csv")).toEqual([]);
+    expect(checkBytes(bytesOf('{"total": 12.5}'), "application/json")).toEqual([]);
+  });
+
+  it("MIME_MISMATCH when the bytes are another type", () => {
+    expect(checkBytes(PNG, "image/jpeg")).toEqual([
+      {
+        code: "MIME_MISMATCH",
+        fix: "Send the file with its real type, or a file that is image/jpeg.",
+        message: "The file is declared as image/jpeg, but its bytes are image/png.",
+        path: "content.files[1].mimeType",
+      },
+    ]);
+    expect(checkBytes(bytesOf("not an image"), "image/png")[0]?.message).toBe(
+      "The file is declared as image/png, but its bytes are text."
+    );
+    expect(checkBytes(PNG, "text/plain")[0]?.code).toBe("MIME_MISMATCH");
+    expect(checkBytes(bytesOf(0xc3, 0x28), "text/csv")[0]?.message).toBe(
+      "The file is declared as text/csv, but its bytes are no accepted type."
+    );
+  });
+
+  it("MIME_MISMATCH when a JSON file does not parse", () => {
+    expect(checkBytes(bytesOf("{total: 12}"), "application/json")[0]?.code).toBe("MIME_MISMATCH");
+  });
+
+  it("FILE_TOO_LARGE when the bytes are over the cap, whatever size was declared", () => {
+    expect(checkBytes(new Uint8Array(2048), "text/plain", 1024)).toEqual([
+      {
+        code: "FILE_TOO_LARGE",
+        fix: "Send a file of 1 KB or less.",
+        message: "The file is 2 KB, but the limit is 1 KB.",
+        path: "content.files[1].size",
+      },
+    ]);
+  });
+});
+
+describe("fileNotOwnedError", () => {
+  it("points at the fileId of the file", () => {
+    expect(fileNotOwnedError({index: 2})).toEqual({
+      code: "FILE_NOT_OWNED",
+      fix: "Upload the file with POST /files/upload and send the id it returns, or send a data: URL.",
+      message: "The file id does not name one of your uploads.",
+      path: "content.files[2].fileId",
+    });
+  });
+});
+
+describe("isTextFileMimeType", () => {
+  it("is true for the types that reach the model as text", () => {
+    expect(["text/plain", "text/csv", "application/json"].every(isTextFileMimeType)).toBe(true);
+    expect(isTextFileMimeType("image/png")).toBe(false);
+    expect(isTextFileMimeType("application/pdf")).toBe(false);
+  });
+});

package/src/asks/files.ts

@@ -0,0 +1,216 @@
+import {
+  type AskErrorDraft,
+  type AskValidationError,
+  finalizeAskErrors,
+  formatAskPath,
+} from "./errors";
+
+/** What a `files` ask may accept, and the MIME types each value allows. */
+export const ASK_FILE_ACCEPT_MIME_TYPES = {
+  csv: ["text/csv"],
+  image: ["image/jpeg", "image/png", "image/gif", "image/webp"],
+  json: ["application/json"],
+  pdf: ["application/pdf"],
+  text: ["text/plain"],
+} as const;
+
+/** The values of a `files` ask's `accept` list, in the order the docs and prompt list them. */
+export const ASK_FILE_ACCEPT = ["image", "pdf", "text", "csv", "json"] as const;
+
+export type AskFileAccept = (typeof ASK_FILE_ACCEPT)[number];
+
+export type AskFileMimeType = (typeof ASK_FILE_ACCEPT_MIME_TYPES)[AskFileAccept][number];
+
+/** The MIME types an `accept` list allows, each listed once, in `accept` order. */
+export const acceptedFileMimeTypes = (accept: readonly AskFileAccept[]): AskFileMimeType[] => [
+  ...new Set(accept.flatMap((value) => ASK_FILE_ACCEPT_MIME_TYPES[value])),
+];
+
+const TEXT_MIME_TYPES: readonly string[] = ["text/plain", "text/csv", "application/json"];
+
+/** Whether a file of this type reaches the model as text rather than as bytes. */
+export const isTextFileMimeType = (mimeType: string): boolean => TEXT_MIME_TYPES.includes(mimeType);
+
+const BASE64_PATTERN = /^[A-Za-z0-9+/]*={0,2}$/;
+
+/**
+ * Splits a base64 `data:` URL into its media type (lowercase, without parameters) and payload.
+ * Returns undefined for anything else, including URL-encoded data URLs and remote URLs.
+ */
+export const parseAskDataUrl = (url: string): {base64: string; mediaType: string} | undefined => {
+  if (!url.startsWith("data:")) {
+    return undefined;
+  }
+  const comma = url.indexOf(",");
+  if (comma === -1) {
+    return undefined;
+  }
+  const params = url.slice("data:".length, comma).split(";");
+  if (params.length < 2 || params.at(-1)?.toLowerCase() !== "base64") {
+    return undefined;
+  }
+  const mediaType = params[0].trim().toLowerCase();
+  const base64 = url.slice(comma + 1);
+  if (mediaType === "" || base64.length % 4 !== 0 || !BASE64_PATTERN.test(base64)) {
+    return undefined;
+  }
+  return {base64, mediaType};
+};
+
+/** The number of bytes a base64 payload decodes to. */
+export const base64ByteLength = (base64: string): number => {
+  const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+  return (base64.length / 4) * 3 - padding;
+};
+
+const startsWith = (bytes: Uint8Array, signature: readonly number[], offset = 0): boolean =>
+  bytes.length >= offset + signature.length &&
+  signature.every((byte, index) => bytes[offset + index] === byte);
+
+const ascii = (text: string): number[] => [...text].map((character) => character.charCodeAt(0));
+
+/** What the bytes of a file are: one of the accepted binary types, UTF-8 text, or unknown. */
+export type SniffedFileType =
+  | "application/pdf"
+  | "image/gif"
+  | "image/jpeg"
+  | "image/png"
+  | "image/webp"
+  | "text"
+  | "unknown";
+
+const decodeUtf8 = (bytes: Uint8Array): string | undefined => {
+  try {
+    return new TextDecoder("utf-8", {fatal: true}).decode(bytes);
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * Reads a file's type from its first bytes. Images and PDFs are matched by their signatures;
+ * anything else that is valid UTF-8 with no NUL character is text.
+ */
+export const sniffFileBytes = (bytes: Uint8Array): SniffedFileType => {
+  if (startsWith(bytes, [0xff, 0xd8, 0xff])) {
+    return "image/jpeg";
+  }
+  if (startsWith(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) {
+    return "image/png";
+  }
+  if (startsWith(bytes, ascii("GIF87a")) || startsWith(bytes, ascii("GIF89a"))) {
+    return "image/gif";
+  }
+  if (startsWith(bytes, ascii("RIFF")) && startsWith(bytes, ascii("WEBP"), 8)) {
+    return "image/webp";
+  }
+  if (startsWith(bytes, ascii("%PDF-"))) {
+    return "application/pdf";
+  }
+  const text = decodeUtf8(bytes);
+  if (text === undefined || text.includes("\u0000")) {
+    return "unknown";
+  }
+  return "text";
+};
+
+const isJson = (bytes: Uint8Array): boolean => {
+  try {
+    JSON.parse(decodeUtf8(bytes) ?? "");
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const bytesMatchType = (bytes: Uint8Array, mimeType: string): boolean => {
+  const sniffed = sniffFileBytes(bytes);
+  if (!isTextFileMimeType(mimeType)) {
+    return sniffed === mimeType;
+  }
+  if (sniffed !== "text") {
+    return false;
+  }
+  return mimeType !== "application/json" || isJson(bytes);
+};
+
+const describeSniffed = (bytes: Uint8Array): string => {
+  const sniffed = sniffFileBytes(bytes);
+  if (sniffed === "text") {
+    return "text";
+  }
+  if (sniffed === "unknown") {
+    return "no accepted type";
+  }
+  return sniffed;
+};
+
+const oneDecimal = (value: number): number => Math.round(value * 10) / 10;
+
+/** "512 bytes", "4.5 KB", or "10 MB". */
+const formatBytes = (bytes: number): string => {
+  if (bytes < 1024) {
+    return bytes === 1 ? "1 byte" : `${bytes} bytes`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${oneDecimal(bytes / 1024)} KB`;
+  }
+  return `${oneDecimal(bytes / 1024 / 1024)} MB`;
+};
+
+export const fileTooLargeDraft = ({
+  maxFileSizeBytes,
+  segments,
+  size,
+}: {
+  maxFileSizeBytes: number;
+  segments: readonly PropertyKey[];
+  size: number;
+}): AskErrorDraft => ({
+  code: "FILE_TOO_LARGE",
+  fix: `Send a file of ${formatBytes(maxFileSizeBytes)} or less.`,
+  message: `The file is ${formatBytes(size)}, but the limit is ${formatBytes(maxFileSizeBytes)}.`,
+  segments,
+});
+
+/**
+ * Checks the bytes of the file at `content.files[index]` on the server: they must fit the per-file
+ * cap and match the declared MIME type (a JSON file must also parse).
+ */
+export const checkAskFileBytes = ({
+  bytes,
+  index,
+  maxFileSizeBytes,
+  mimeType,
+}: {
+  bytes: Uint8Array;
+  index: number;
+  maxFileSizeBytes: number;
+  mimeType: string;
+}): AskValidationError[] => {
+  const segments = ["content", "files", index];
+  if (bytes.length > maxFileSizeBytes) {
+    return finalizeAskErrors([
+      fileTooLargeDraft({maxFileSizeBytes, segments: [...segments, "size"], size: bytes.length}),
+    ]);
+  }
+  if (bytesMatchType(bytes, mimeType)) {
+    return [];
+  }
+  return finalizeAskErrors([
+    {
+      code: "MIME_MISMATCH",
+      fix: `Send the file with its real type, or a file that is ${mimeType}.`,
+      message: `The file is declared as ${mimeType}, but its bytes are ${describeSniffed(bytes)}.`,
+      segments: [...segments, "mimeType"],
+    },
+  ]);
+};
+
+/** The error for a `fileId` that the caller did not upload, or that the host cannot load. */
+export const fileNotOwnedError = ({index}: {index: number}): AskValidationError => ({
+  code: "FILE_NOT_OWNED",
+  fix: "Upload the file with POST /files/upload and send the id it returns, or send a data: URL.",
+  message: "The file id does not name one of your uploads.",
+  path: formatAskPath(["content", "files", index, "fileId"]),
+});

package/src/asks/fixtures/invalid/choice-blank-text.json

@@ -0,0 +1,20 @@
+{
+  "kind": "choice",
+  "input": {
+    "title": "  ",
+    "prompt": " \n\t ",
+    "select": "one",
+    "options": [
+      {"id": "yes", "label": "   "},
+      {"id": "no", "label": "No", "description": " "}
+    ],
+    "submitLabel": "\t"
+  },
+  "errors": [
+    {"path": "options[0].label", "code": "TOO_SHORT"},
+    {"path": "options[1].description", "code": "TOO_SHORT"},
+    {"path": "prompt", "code": "TOO_SHORT"},
+    {"path": "submitLabel", "code": "TOO_SHORT"},
+    {"path": "title", "code": "TOO_SHORT"}
+  ]
+}

package/src/asks/fixtures/invalid/choice-default-not-in-options.json

@@ -0,0 +1,13 @@
+{
+  "kind": "choice",
+  "input": {
+    "prompt": "Which plan?",
+    "select": "one",
+    "options": [
+      {"id": "team", "label": "Team"},
+      {"id": "solo", "label": "Solo"}
+    ],
+    "default": ["gold"]
+  },
+  "errors": [{"path": "default[0]", "code": "DEFAULT_NOT_IN_OPTIONS"}]
+}

package/src/asks/fixtures/invalid/choice-default-selects-two.json

@@ -0,0 +1,16 @@
+{
+  "kind": "choice",
+  "input": {
+    "prompt": "Which plan?",
+    "select": "one",
+    "options": [
+      {"id": "team", "label": "Team"},
+      {"id": "solo", "label": "Solo"}
+    ],
+    "default": ["team", "gold"]
+  },
+  "errors": [
+    {"path": "default", "code": "SELECTION_COUNT"},
+    {"path": "default[1]", "code": "DEFAULT_NOT_IN_OPTIONS"}
+  ]
+}

package/src/asks/fixtures/invalid/choice-description-too-long.json

@@ -0,0 +1,24 @@
+{
+  "kind": "choice",
+  "input": {
+    "prompt": "Pick one.",
+    "select": "one",
+    "options": [
+      {
+        "id": "a",
+        "label": "A"
+      },
+      {
+        "id": "b",
+        "label": "B",
+        "description": "ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+      }
+    ]
+  },
+  "errors": [
+    {
+      "path": "options[1].description",
+      "code": "TOO_LONG"
+    }
+  ]
+}

package/src/asks/fixtures/invalid/choice-duplicate-ids.json

@@ -0,0 +1,17 @@
+{
+  "kind": "choice",
+  "input": {
+    "prompt": "Which plan?",
+    "select": "one",
+    "options": [
+      {"id": "team", "label": "Team"},
+      {"id": "solo", "label": "Solo"},
+      {"id": "team", "label": "Team (annual)"},
+      {"id": "solo", "label": "Solo (annual)"}
+    ]
+  },
+  "errors": [
+    {"path": "options[2].id", "code": "DUPLICATE_ID"},
+    {"path": "options[3].id", "code": "DUPLICATE_ID"}
+  ]
+}

package/src/asks/fixtures/invalid/choice-label-too-long.json

@@ -0,0 +1,23 @@
+{
+  "kind": "choice",
+  "input": {
+    "prompt": "Pick one.",
+    "select": "one",
+    "options": [
+      {
+        "id": "a",
+        "label": "lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll"
+      },
+      {
+        "id": "b",
+        "label": "B"
+      }
+    ]
+  },
+  "errors": [
+    {
+      "path": "options[0].label",
+      "code": "TOO_LONG"
+    }
+  ]
+}

package/src/asks/fixtures/invalid/choice-many-bounds-not-whole.json

@@ -0,0 +1,17 @@
+{
+  "kind": "choice",
+  "input": {
+    "prompt": "Which toppings?",
+    "select": "many",
+    "options": [
+      {"id": "cheese", "label": "Cheese"},
+      {"id": "olives", "label": "Olives"}
+    ],
+    "minSelected": 1.5,
+    "maxSelected": "2"
+  },
+  "errors": [
+    {"path": "maxSelected", "code": "INVALID_TYPE"},
+    {"path": "minSelected", "code": "INVALID_TYPE"}
+  ]
+}

package/src/asks/fixtures/invalid/choice-many-bounds-out-of-range.json

@@ -0,0 +1,17 @@
+{
+  "kind": "choice",
+  "input": {
+    "prompt": "Which toppings?",
+    "select": "many",
+    "options": [
+      {"id": "cheese", "label": "Cheese"},
+      {"id": "olives", "label": "Olives"}
+    ],
+    "minSelected": -1,
+    "maxSelected": 0
+  },
+  "errors": [
+    {"path": "maxSelected", "code": "RANGE_INVALID"},
+    {"path": "minSelected", "code": "RANGE_INVALID"}
+  ]
+}

package/src/asks/fixtures/invalid/choice-many-default-duplicate.json

@@ -0,0 +1,17 @@
+{
+  "kind": "choice",
+  "input": {
+    "prompt": "Which toppings?",
+    "select": "many",
+    "options": [
+      {"id": "cheese", "label": "Cheese"},
+      {"id": "olives", "label": "Olives"}
+    ],
+    "default": ["cheese", "cheese", "ham"]
+  },
+  "errors": [
+    {"path": "default", "code": "SELECTION_COUNT"},
+    {"path": "default[1]", "code": "DUPLICATE_ID"},
+    {"path": "default[2]", "code": "DEFAULT_NOT_IN_OPTIONS"}
+  ]
+}