@sixb/core 0.1.21 → 0.1.22

package/src/artifacts/publish/references.ts

@@ -17,8 +17,8 @@ export type FoundReference = Omit<ArtifactReference, "resolvedVersion">
 interface ReferenceContext {
   readonly projectId: string
   readonly storage: ArtifactStorage
-  /** Who publishes: an address resolves only to artifacts they can read. */
-  readonly author: Principal
+  /** Whether an address may name this artifact: one whoever publishes can read. */
+  readonly readable: (artifact: ArtifactRecord) => Promise<boolean>
   /** The artifact being published, which an address may not name. */
   readonly artifactId?: string
 }
@@ -59,7 +59,7 @@ export async function resolveReferences(
     if (!artifact) {
       artifact = context.storage
         .get({ projectId: context.projectId, id: address.artifactId })
-        .then((record) => (record && readable(context.author, record) ? record : null))
+        .then(async (record) => (record && (await context.readable(record)) ? record : null))
       artifacts.set(address.artifactId, artifact)
     }
     const record = await artifact
@@ -90,7 +90,8 @@ export async function resolveReferences(
 
 /**
  * The artifacts a new version breaks: each one whose latest version follows this artifact's latest
- * and names something this version no longer has. Only artifacts the author can read are named.
+ * and names something this version no longer has. Only artifacts the author can read are named,
+ * and only those the version breaks are checked: most dependents cost no read.
  */
 export async function brokenDependents(
   context: ReferenceContext,
@@ -104,27 +105,31 @@ export async function brokenDependents(
   const warnings: ArtifactWarning[] = []
   for (const dependent of dependents) {
     if (dependent.artifactId === artifact.id) continue
-    const owner = await context.storage.get({
-      projectId: context.projectId,
-      id: dependent.artifactId,
-    })
-    if (!owner || !readable(context.author, owner)) continue
+
+    const broken: ArtifactWarning[] = []
     for (const reference of dependent.references) {
       const address = parseArtifactAddress(reference.address)
       // A pinned address keeps showing the version it names.
       if (address?.artifactId !== artifact.id || address.version !== undefined) continue
       const result = resolveArtifactAddress(address, { kind: artifact.kind, ...version })
       if (!("problem" in result)) continue
-      warnings.push({
+      broken.push({
         code: "reference_broken",
         message: `“${dependent.title}” (${dependent.artifactId}) ${reference.as === "embed" ? "shows" : "links to"} ${reference.address}, but version ${version.version} ${result.problem}. Publish its next version with an address that resolves, or restore what it names.`,
       })
     }
+    if (broken.length === 0) continue
+
+    const owner = await context.storage.get({
+      projectId: context.projectId,
+      id: dependent.artifactId,
+    })
+    if (owner && (await context.readable(owner))) warnings.push(...broken)
   }
   return warnings
 }
 
-/** Owner-only, as reading is: system code reads every artifact in the project. */
-function readable(reader: Principal, artifact: ArtifactRecord): boolean {
-  return reader.type === "system" || principalsEqual(reader, artifact.owner)
+/** What its author reads when nothing else is said: their own artifacts, or all for system code. */
+export function ownArtifacts(author: Principal): (artifact: ArtifactRecord) => Promise<boolean> {
+  return async (artifact) => author.type === "system" || principalsEqual(author, artifact.owner)
 }

package/src/artifacts/publish/validate/canvas.ts

@@ -0,0 +1,118 @@
+import { posix } from "node:path"
+import type { ArtifactFile } from "../../../storage/artifacts/types"
+import { CANVAS_FILE, type Canvas, parseCanvas } from "../../canvas"
+import { ARTIFACT_LIMITS } from "../../limits"
+import type { CanvasOutline, CanvasOutlineItem } from "../../outline"
+import type { ArtifactWarning } from "../../warnings"
+import { type ArtifactBlobStorage, invalidArtifact, readArtifactText } from "../files"
+import type { FoundReference } from "../references"
+import { readHtmlReferences, refuseFrameAssetPaths } from "./html"
+
+/**
+ * Reads a canvas: `canvas.json`, then each board's HTML, which must be one of the version's files.
+ * The addresses its embeds show and its boards use are returned to resolve, each at its item's id.
+ * Boards that overlap, and notes or text drawn over a board, are warnings: the reader sees a page
+ * covered.
+ */
+export async function validateCanvas(
+  blobStorage: ArtifactBlobStorage,
+  files: readonly ArtifactFile[]
+): Promise<{
+  readonly entry: string
+  readonly outline: CanvasOutline
+  readonly references: readonly FoundReference[]
+  readonly warnings: readonly ArtifactWarning[]
+}> {
+  const byPath = new Map(files.map((file) => [file.path, file]))
+  const canvasFile = byPath.get(CANVAS_FILE)
+  if (!canvasFile) {
+    throw invalidArtifact(
+      `A canvas is '${CANVAS_FILE}', listing its items, with the HTML files its boards show beside it.`
+    )
+  }
+  refuseFrameAssetPaths(files, "the canvas")
+  const parsed = parseCanvas(
+    await readArtifactText(blobStorage, canvasFile, ARTIFACT_LIMITS.maxCanvasBytes)
+  )
+  if ("error" in parsed) throw invalidArtifact(parsed.error)
+  const { canvas } = parsed
+
+  const references: FoundReference[] = []
+  for (const item of canvas.items) {
+    if (item.type === "embed") references.push({ address: item.src, as: "embed", at: item.id })
+    if (item.type !== "board") continue
+    const file = byPath.get(posix.normalize(item.file))
+    if (!file) {
+      throw invalidArtifact(
+        `${CANVAS_FILE} board '${item.id}' shows '${item.file}', which is not one of the canvas's files.`
+      )
+    }
+    const rewriter = new HTMLRewriter()
+    const { references: found, refusal } = readHtmlReferences(rewriter, () => item.id, item.file)
+    rewriter.transform(await readArtifactText(blobStorage, file, ARTIFACT_LIMITS.maxBoardBytes))
+    const refused = refusal()
+    if (refused) throw invalidArtifact(`Board '${item.id}': ${refused}`)
+    references.push(...found)
+  }
+
+  return {
+    entry: CANVAS_FILE,
+    outline: {
+      kind: "canvas",
+      items: canvas.items.flatMap((item): CanvasOutlineItem[] => {
+        const title = item.type === "board" || item.type === "section" ? item.title : undefined
+        const named = { id: item.id, ...(title ? { title } : {}) }
+        if (item.type === "board") {
+          return [
+            { ...named, type: "board", file: posix.normalize(item.file), w: item.w, h: item.h },
+          ]
+        }
+        return item.type === "section" ? [{ ...named, type: "section" }] : []
+      }),
+    },
+    references,
+    warnings: layoutWarnings(canvas),
+  }
+}
+
+interface Box {
+  readonly x: number
+  readonly y: number
+  readonly w: number
+  readonly h: number
+}
+
+const overlaps = (a: Box, b: Box) =>
+  a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h
+
+/**
+ * What covers a board on the canvas: another board over it, or a note or a text whose top left
+ * corner lands on it. A note's height follows its text, so only its corner is sure; a section
+ * holds boards on purpose.
+ */
+function layoutWarnings(canvas: Canvas): ArtifactWarning[] {
+  const boards = canvas.items.flatMap((item) => (item.type === "board" ? [item] : []))
+  const warnings: ArtifactWarning[] = []
+  boards.forEach((board, index) => {
+    for (const other of boards.slice(index + 1)) {
+      if (!overlaps(board, other)) continue
+      warnings.push({
+        code: "canvas_overlap",
+        part: board.id,
+        message: `Boards '${board.id}' and '${other.id}' overlap, so one covers the other's page: leave 80 pixels between boards in a row and 160 between rows.`,
+      })
+    }
+  })
+  for (const item of canvas.items) {
+    if (item.type !== "note" && item.type !== "text") continue
+    const corner = { x: item.x, y: item.y, w: 1, h: 1 }
+    const board = boards.find((candidate) => overlaps(candidate, corner))
+    if (!board) continue
+    warnings.push({
+      code: "canvas_covers_board",
+      part: item.id,
+      message: `${item.type === "note" ? "Note" : "Text"} '${item.id}' sits on board '${board.id}' and covers its page: put it beside the board, and an arrow to it when it is about the board.`,
+    })
+  }
+  return warnings
+}

package/src/artifacts/publish/validate/html.ts

@@ -0,0 +1,78 @@
+import type { ArtifactFile } from "../../../storage/artifacts/types"
+import { isArtifactAddress, parseArtifactAddress } from "../../address"
+import { decodeHtmlEntities } from "../../html"
+import { invalidArtifact } from "../files"
+import type { FoundReference } from "../references"
+
+/** The file a web artifact, a deck or a page, renders from. */
+export const HTML_ENTRY = "index.html"
+
+/** Where the frame serves the kit and the runtime, beside a web artifact's own files. */
+export const FRAME_ASSET_PREFIX = "__sixb/"
+
+/** Refuses a file under `__sixb/`, where the frame serves its own: it would never be served. */
+export function refuseFrameAssetPaths(files: readonly ArtifactFile[], what: string): void {
+  const reserved = files.find((file) => file.path.startsWith(FRAME_ASSET_PREFIX))
+  if (reserved) {
+    throw invalidArtifact(
+      `'${reserved.path}' is under ${FRAME_ASSET_PREFIX}, where Sixb serves ${what}'s kit and runtime: move it.`
+    )
+  }
+}
+
+/**
+ * Reads the `artifact:` addresses a web artifact's HTML uses, to resolve: links (`<a href>`),
+ * files it shows from other artifacts (`<img src>`), and anything else it shows (`<sixb-embed
+ * src>`), a chart, a range, a section, or a slide, which the app draws over the frame. `at` names
+ * where each sits, such as a deck's slide, and `file` the HTML file it reads. The first thing that
+ * would not render is the refusal.
+ */
+export function readHtmlReferences(
+  rewriter: HTMLRewriter,
+  at: () => string,
+  file: string = HTML_ENTRY
+): { readonly references: FoundReference[]; readonly refusal: () => string | undefined } {
+  const references: FoundReference[] = []
+  let refused: string | undefined
+  rewriter
+    .on("a[href]", {
+      element(element) {
+        const href = decodeHtmlEntities(element.getAttribute("href") ?? "")
+        if (isArtifactAddress(href)) {
+          references.push({ address: href.trim(), as: "link", at: at() })
+        }
+      },
+    })
+    .on("img[src]", {
+      element(element) {
+        const source = decodeHtmlEntities(element.getAttribute("src") ?? "").trim()
+        if (!isArtifactAddress(source)) return
+        if (!parseArtifactAddress(source)?.path) {
+          refused ??= `An <img> shows a file from another artifact, and '${source}' names none: show a chart, a range, a section, or a slide with <sixb-embed src="${source}"></sixb-embed>.`
+          return
+        }
+        references.push({ address: source, as: "embed", at: at() })
+      },
+    })
+    .on("sixb-embed", {
+      element(element) {
+        const source = decodeHtmlEntities(element.getAttribute("src") ?? "").trim()
+        if (!isArtifactAddress(source)) {
+          refused ??= `<sixb-embed> shows another artifact: give it src="artifact:…", such as artifact:art_k3m9q2x7tp#chart=revenue.`
+          return
+        }
+        references.push({ address: source, as: "embed", at: at() })
+      },
+    })
+    .on("iframe[src], object[data], embed[src]", {
+      element(element) {
+        const source = decodeHtmlEntities(
+          element.getAttribute("src") ?? element.getAttribute("data") ?? ""
+        ).trim()
+        if (isArtifactAddress(source)) {
+          refused ??= `${file} frames '${source}': show another artifact with <sixb-embed src="${source}"></sixb-embed>, or a file of one with <img>.`
+        }
+      },
+    })
+  return { references, refusal: () => refused }
+}

package/src/artifacts/publish/validate/page.ts

@@ -0,0 +1,65 @@
+import type { ArtifactFile } from "../../../storage/artifacts/types"
+import { decodeHtmlEntities } from "../../html"
+import { ARTIFACT_LIMITS } from "../../limits"
+import type { PageOutline } from "../../outline"
+import { type ArtifactBlobStorage, invalidArtifact, readArtifactText } from "../files"
+import type { FoundReference } from "../references"
+import { HTML_ENTRY, readHtmlReferences, refuseFrameAssetPaths } from "./html"
+
+/**
+ * Reads a page: `index.html` and the files it loads beside it, its scripts, styles, images, and
+ * data. Its `<title>`, else its first `<h1>`, becomes its title in the outline. The `artifact:`
+ * addresses it uses are returned to resolve, as a deck's are.
+ */
+export async function validatePage(
+  blobStorage: ArtifactBlobStorage,
+  files: readonly ArtifactFile[]
+): Promise<{
+  readonly entry: string
+  readonly outline: PageOutline
+  readonly references: readonly FoundReference[]
+}> {
+  const entry = files.find((file) => file.path === HTML_ENTRY)
+  if (!entry) {
+    throw invalidArtifact(
+      `A page needs '${HTML_ENTRY}', the page itself; put its scripts, styles, and data beside it.`
+    )
+  }
+  refuseFrameAssetPaths(files, "the page")
+  const html = await readArtifactText(blobStorage, entry, ARTIFACT_LIMITS.maxPageBytes)
+
+  let title = ""
+  let heading = ""
+  let readingHeading = false
+  const rewriter = new HTMLRewriter()
+    .on("title", {
+      text(chunk) {
+        title += chunk.text
+      },
+    })
+    .on("h1", {
+      element(element) {
+        if (heading || readingHeading) return
+        readingHeading = true
+        element.onEndTag(() => {
+          readingHeading = false
+          heading ||= " "
+        })
+      },
+      text(chunk) {
+        if (readingHeading) heading += chunk.text
+      },
+    })
+  const { references, refusal } = readHtmlReferences(rewriter, () => "")
+  rewriter.transform(html)
+
+  const refused = refusal()
+  if (refused) throw invalidArtifact(refused)
+  const plain = (text: string) => decodeHtmlEntities(text).replace(/\s+/g, " ").trim()
+  const named = plain(title) || plain(heading)
+  return {
+    entry: HTML_ENTRY,
+    outline: { kind: "page", ...(named ? { title: named.slice(0, 200) } : {}) },
+    references,
+  }
+}

package/src/artifacts/publish/validate/sheet.ts

@@ -2,10 +2,14 @@ import { posix } from "node:path"
 import type { ArtifactFile } from "../../../storage/artifacts/types"
 import { isArtifactAddress } from "../../address"
 import { CsvParseError, type CsvTable, parseCsv } from "../../csv"
+import { evaluateComputedColumns } from "../../formula"
 import { ARTIFACT_LIMITS } from "../../limits"
+import { liveSheetColumns } from "../../live-sheet"
 import type { SheetOutline } from "../../outline"
+import { artifactQueryPath, type CheckedArtifactQuery } from "../../queries"
+import { sheetChartsProblem, sheetColumnsProblem, sheetFormulasProblem } from "../../sheet-rules"
+import type { ArtifactWarning } from "../../warnings"
 import {
-  NUMERIC_COLUMN_TYPES,
   parseSheetDate,
   parseSheetNumber,
   parseWorkbook,
@@ -20,16 +24,23 @@ import type { FoundReference } from "../references"
 
 /**
  * Reads a sheet: `workbook.json`, then each sheet's CSV against it. Every cell of a typed column
- * must read as its type and every chart must name columns its sheet has, so the grid formats and
- * the charts draw the same wherever the sheet is opened.
+ * must read as its type, every formula must compute its column, and every chart must name columns
+ * its sheet has, so the grid formats and the charts draw the same wherever the sheet is opened.
+ * Rows a formula computes to an error are warnings: the version publishes, and the grid shows them.
+ *
+ * A live sheet is checked against `queries`, what checking the version's queries as its author
+ * learned: its query returns rows, and its columns show properties those rows hold, so its rules
+ * hold as a CSV sheet's do. Its rows are each reader's, so no cell is checked.
  */
 export async function validateSheet(
   blobStorage: ArtifactBlobStorage,
-  files: readonly ArtifactFile[]
+  files: readonly ArtifactFile[],
+  queries: ReadonlyMap<string, CheckedArtifactQuery>
 ): Promise<{
   readonly entry: string
   readonly outline: SheetOutline
   readonly references: readonly FoundReference[]
+  readonly warnings: readonly ArtifactWarning[]
 }> {
   const byPath = new Map(files.map((file) => [file.path, file]))
   const workbookFile = byPath.get(WORKBOOK_FILE)
@@ -54,10 +65,26 @@ export async function validateSheet(
 
   const tables = new Map<string, CsvTable>()
   const references: FoundReference[] = []
+  const warnings: ArtifactWarning[] = []
+  const sheets: WorkbookSheet[] = []
   for (const sheet of workbook.sheets) {
-    tables.set(sheet.name, await readSheet(blobStorage, byPath, sheet, references))
+    if (sheet.live) {
+      const live = liveSheet(byPath, sheet, queries.get(sheet.live.query))
+      sheets.push(live.sheet)
+      tables.set(sheet.name, live.table)
+      continue
+    }
+
+    const table = await readSheet(blobStorage, byPath, sheet, references)
+    sheets.push(sheet)
+    tables.set(sheet.name, table)
+    warnings.push(...computeSheet(sheet, table))
   }
-  checkCharts(workbook, tables)
+
+  // A live sheet's charts plot the columns it lays out, typed as its query's rows are.
+  const laidOut: Workbook = { ...workbook, sheets }
+  const charts = sheetChartsProblem(laidOut, tables)
+  if (charts) throw invalidArtifact(charts)
 
   return {
     entry: WORKBOOK_FILE,
@@ -69,12 +96,53 @@ export async function validateSheet(
           name: sheet.name,
           rows: table?.rows.length ?? 0,
           columns: [...(table?.header ?? [])],
+          ...(sheet.live ? { query: sheet.live.query } : {}),
         }
       }),
       charts: workbook.charts.map((chart) => chart.name),
     },
     references,
+    warnings,
+  }
+}
+
+/**
+ * A live sheet laid out against its query as the author reads it, and its header as the table a
+ * CSV would hold, with no rows: the rules a CSV sheet keeps are checked on it.
+ */
+function liveSheet(
+  byPath: ReadonlyMap<string, ArtifactFile>,
+  sheet: WorkbookSheet,
+  checked: CheckedArtifactQuery | undefined
+): { readonly sheet: WorkbookSheet; readonly table: CsvTable } {
+  const query = sheet.live?.query
+  const csv = sheetFilePath(sheet.name)
+  if (byPath.has(csv)) {
+    throw invalidArtifact(
+      `Sheet '${sheet.name}' reads its rows from query '${query}', so it has no '${csv}': remove the CSV, or "query" to show it.`
+    )
+  }
+
+  if (!checked || query === undefined) {
+    throw invalidArtifact(
+      `Sheet '${sheet.name}' reads query '${query}', which the version does not have: add '${artifactQueryPath(query ?? "")}'.`
+    )
   }
+  if (checked.kind === "facets") {
+    throw invalidArtifact(
+      `Sheet '${sheet.name}' reads query '${query}', which counts facets: a sheet shows rows. A page shows facets; give the sheet a query of rows.`
+    )
+  }
+
+  const layout = liveSheetColumns(sheet, checked.schema)
+  if (layout.problem) throw invalidArtifact(layout.problem)
+
+  const table = { header: layout.columns.map((column) => column.name), rows: [] }
+  const problem =
+    sheetColumnsProblem(layout.sheet, table) ?? sheetFormulasProblem(layout.sheet, table)
+  if (problem) throw invalidArtifact(problem)
+
+  return { sheet: layout.sheet, table }
 }
 
 async function readSheet(
@@ -100,42 +168,10 @@ async function readSheet(
     throw error
   }
 
-  const { header, rows } = table
-  if (header.length === 0)
-    throw invalidArtifact(`'${path}' is empty: its first line names the columns.`)
-  if (header.length > ARTIFACT_LIMITS.maxSheetColumns) {
-    throw invalidArtifact(
-      `'${path}' has ${header.length} columns; a sheet holds at most ${ARTIFACT_LIMITS.maxSheetColumns}.`
-    )
-  }
-  const seen = new Set<string>()
-  for (const [index, name] of header.entries()) {
-    if (!name.trim()) {
-      throw invalidArtifact(`'${path}' column ${index + 1} has no name in the header row.`)
-    }
-    if (seen.has(name)) throw invalidArtifact(`'${path}' has two columns named '${name}'.`)
-    seen.add(name)
-  }
-  if (rows.length > ARTIFACT_LIMITS.maxSheetRows) {
-    throw invalidArtifact(
-      `'${path}' has ${rows.length} rows; a sheet holds at most ${ARTIFACT_LIMITS.maxSheetRows}.`
-    )
-  }
-  for (const [index, row] of rows.entries()) {
-    if (row.length > header.length) {
-      throw invalidArtifact(
-        `'${path}' row ${index + 2} has ${row.length} fields; the header names ${header.length} columns.`
-      )
-    }
-  }
+  const columns = sheetColumnsProblem(sheet, table)
+  if (columns) throw invalidArtifact(columns)
 
-  for (const column of [...Object.keys(sheet.columns), ...Object.keys(sheet.widths)]) {
-    if (!seen.has(column)) {
-      throw invalidArtifact(
-        `${WORKBOOK_FILE} sheet '${sheet.name}' names column '${column}', which '${path}' does not have.`
-      )
-    }
-  }
+  const { header } = table
   for (const [column, format] of Object.entries(sheet.columns)) {
     const index = header.indexOf(column)
     if (format.type === "link" || format.type === "image") {
@@ -150,11 +186,44 @@ async function readSheet(
         })
       }
     }
+    if (format.formula) {
+      checkComputedValues(path, table, index, column)
+      continue
+    }
     checkColumn(path, table, index, column, format, byPath)
   }
   return table
 }
 
+/** A computed column's values come from its formula: the CSV leaves them empty. */
+function checkComputedValues(path: string, table: CsvTable, index: number, column: string): void {
+  for (const [rowIndex, row] of table.rows.entries()) {
+    const value = row[index] ?? ""
+    if (value.trim()) {
+      throw invalidArtifact(
+        `'${path}' row ${rowIndex + 2}, column '${column}': ${JSON.stringify(value)} is in a computed column; leave its values empty, and its formula fills them.`
+      )
+    }
+  }
+}
+
+/**
+ * Checks each computed column's formula against the sheet's columns and computes them all, so a
+ * formula that can't compute refuses the version and one that computes to an error in some rows
+ * warns.
+ */
+function computeSheet(sheet: WorkbookSheet, table: CsvTable): ArtifactWarning[] {
+  const formulas = sheetFormulasProblem(sheet, table)
+  if (formulas) throw invalidArtifact(formulas)
+
+  const computed = evaluateComputedColumns(sheet, table)
+  return [...computed.errors].map(([column, errors]) => ({
+    code: "sheet_formula_error",
+    part: sheet.name,
+    message: `Sheet '${sheet.name}' column '${column}' computes to ${errors.code} in ${errors.count === 1 ? "1 row" : `${errors.count} rows`}, the first row ${errors.firstRow + 2}. IFERROR gives those rows a value.`,
+  }))
+}
+
 function checkColumn(
   path: string,
   table: CsvTable,
@@ -204,39 +273,16 @@ function cellProblem(
         ? undefined
         : "is not one of the artifact's files: add the image to the artifact and give its relative path, or give another artifact's address."
     }
+    case "boolean":
+      return /^(true|false)$/i.test(value.trim())
+        ? undefined
+        : "is not true or false: write true or false, or leave the cell empty."
     case "text":
+    case "tag":
       return undefined
   }
 }
 
-function checkCharts(workbook: Workbook, tables: ReadonlyMap<string, CsvTable>): void {
-  for (const chart of workbook.charts) {
-    const sheet = workbook.sheets.find((candidate) => candidate.name === chart.sheet)
-    const table = tables.get(chart.sheet)
-    if (!sheet || !table) continue
-    for (const column of [chart.x, ...chart.y]) {
-      if (!table.header.includes(column)) {
-        throw invalidArtifact(
-          `${WORKBOOK_FILE} chart '${chart.name}' plots column '${column}', which sheet '${chart.sheet}' does not have.`
-        )
-      }
-    }
-    for (const column of chart.y) {
-      const type = sheet.columns[column]?.type ?? "text"
-      if (!NUMERIC_COLUMN_TYPES.includes(type)) {
-        throw invalidArtifact(
-          `${WORKBOOK_FILE} chart '${chart.name}' plots column '${column}', which is ${type}; give it a number, currency, or percent type in "columns".`
-        )
-      }
-    }
-    if (chart.type === "pie" && table.rows.length > ARTIFACT_LIMITS.maxPieSlices) {
-      throw invalidArtifact(
-        `${WORKBOOK_FILE} chart '${chart.name}' is a pie with ${table.rows.length} slices; a pie reads well with at most ${ARTIFACT_LIMITS.maxPieSlices}. Use a bar chart instead.`
-      )
-    }
-  }
-}
-
 /** A column's letter as a spreadsheet shows it: A, Z, AA. */
 function columnLetter(index: number): string {
   let letters = ""