@sixb/core 0.1.21 → 0.1.22

package/dist/chunk-waqk73p1.js

@@ -0,0 +1,2380 @@
+// @bun
+import {
+  isArtifactAddress2,
+  parseSheetPart2
+} from "./chunk-3fqxbn31.js";
+import {
+  ARTIFACT_LIMITS2
+} from "./chunk-hz5d43gn.js";
+
+// src/artifacts/theme.ts
+var ARTIFACT_THEME_FILE2 = "theme.json";
+var COLOR_TOKENS = [
+  "--background",
+  "--foreground",
+  "--card",
+  "--card-foreground",
+  "--muted",
+  "--muted-foreground",
+  "--primary",
+  "--primary-foreground",
+  "--accent",
+  "--accent-foreground",
+  "--border",
+  "--chart-1",
+  "--chart-2",
+  "--chart-3",
+  "--chart-4",
+  "--chart-5"
+];
+var FONT_TOKENS = ["--font-sans", "--font-serif", "--font-mono"];
+var ARTIFACT_THEME_TOKENS = [
+  ...COLOR_TOKENS,
+  ...FONT_TOKENS,
+  "--radius"
+];
+var HEX_COLOR = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var FUNCTION_COLOR = /^(?:rgba?|hsla?|oklch|oklab|lab|lch)\((?:[\d.%\s,/+-]|deg|turn|rad|none)*\)$/i;
+var FONT_FAMILY = /^\s*(?:"[\w -]+"|'[\w -]+'|[\w-]+)(?:\s*,\s*(?:"[\w -]+"|'[\w -]+'|[\w-]+))*\s*$/;
+var LENGTH = /^(?:0|\d{1,3}(?:\.\d+)?(?:px|rem|em))$/;
+function parseArtifactTheme2(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return { error: `${ARTIFACT_THEME_FILE2} is not valid JSON.` };
+  }
+  if (!isObject(value))
+    return { error: `${ARTIFACT_THEME_FILE2} must be a JSON object.` };
+  const unknownKey = Object.keys(value).find((key) => key !== "mode" && key !== "tokens");
+  if (unknownKey) {
+    return {
+      error: `${ARTIFACT_THEME_FILE2} has '${unknownKey}'; it takes only "mode" and "tokens".`
+    };
+  }
+  if (value.mode !== undefined && value.mode !== "light" && value.mode !== "dark") {
+    return { error: `${ARTIFACT_THEME_FILE2} "mode" must be "light" or "dark".` };
+  }
+  if (value.tokens !== undefined && !isObject(value.tokens)) {
+    return { error: `${ARTIFACT_THEME_FILE2} "tokens" must be an object of token names to values.` };
+  }
+  const tokens = {};
+  for (const [name, tokenValue] of Object.entries(value.tokens ?? {})) {
+    if (!ARTIFACT_THEME_TOKENS.includes(name)) {
+      return {
+        error: `${ARTIFACT_THEME_FILE2} sets '${name}'. A theme can set ${ARTIFACT_THEME_TOKENS.join(", ")}.`
+      };
+    }
+    if (typeof tokenValue !== "string" || !tokenValueFits(name, tokenValue)) {
+      return {
+        error: `${ARTIFACT_THEME_FILE2} gives '${name}' a value it cannot use: ${expected(name)}.`
+      };
+    }
+    tokens[name] = tokenValue.trim();
+  }
+  return {
+    theme: {
+      ...value.mode === undefined ? {} : { mode: value.mode },
+      ...Object.keys(tokens).length === 0 ? {} : { tokens }
+    }
+  };
+}
+function tokenValueFits(name, value) {
+  const trimmed = value.trim();
+  if (name === "--radius")
+    return LENGTH.test(trimmed);
+  if (FONT_TOKENS.includes(name)) {
+    return trimmed.length <= 200 && FONT_FAMILY.test(trimmed);
+  }
+  return HEX_COLOR.test(trimmed) || FUNCTION_COLOR.test(trimmed);
+}
+function expected(name) {
+  if (name === "--radius")
+    return "a length such as 8px or 0.5rem";
+  if (FONT_TOKENS.includes(name)) {
+    return 'a font list such as "Inter Tight", system-ui, sans-serif';
+  }
+  return "a color such as #2f7280 or oklch(0.62 0.1 210)";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/artifacts/queries.ts
+var ARTIFACT_QUERIES_DIRECTORY = "queries/";
+var ARTIFACT_QUERY_KINDS = ["sheet", "page", "slides", "canvas"];
+var QUERY_NAME = /^[a-z0-9][a-z0-9-]{0,63}$/;
+function isArtifactQueryName(name) {
+  return QUERY_NAME.test(name);
+}
+function artifactQueryPath(name) {
+  return `${ARTIFACT_QUERIES_DIRECTORY}${name}.json`;
+}
+function artifactQueryName2(path) {
+  if (!path.startsWith(ARTIFACT_QUERIES_DIRECTORY) || !path.endsWith(".json"))
+    return;
+  const name = path.slice(ARTIFACT_QUERIES_DIRECTORY.length, -".json".length);
+  return isArtifactQueryName(name) ? name : undefined;
+}
+
+class QueryShapeError extends Error {
+  path;
+  constructor(path, message) {
+    super(message);
+    this.path = path;
+  }
+}
+function parseArtifactQuery(path, text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return { error: `${path} is not valid JSON.` };
+  }
+  try {
+    return readFile(value);
+  } catch (error) {
+    if (error instanceof QueryShapeError)
+      return { error: `${path}: ${error.path}: ${error.message}` };
+    throw error;
+  }
+}
+function readFile(value) {
+  const file = record(value, "$");
+  if (Object.hasOwn(file, "kind")) {
+    return { query: { kind: "objects", query: readNode(file, "$") }, at: "$" };
+  }
+  if (!Object.hasOwn(file, "query")) {
+    throw new QueryShapeError("$", 'a query file holds a query node, with "kind", or a request, with "query".');
+  }
+  if (!Object.hasOwn(file, "facets")) {
+    only(file, "$", ["query", "includeTotal"], "a query request");
+    if (file.includeTotal !== undefined)
+      boolean(file, "includeTotal", "$");
+    return { query: { kind: "objects", query: readNode(file.query, "$.query") }, at: "$.query" };
+  }
+  only(file, "$", ["query", "facets"], "a facets request");
+  const query = readNode(file.query, "$.query");
+  const facets = list(file.facets, "$.facets").map((facet, index) => readFacet(facet, `$.facets[${index}]`));
+  if (facets.length === 0)
+    throw new QueryShapeError("$.facets", "list at least one facet.");
+  return { query: { kind: "facets", query, facets }, at: "$.query" };
+}
+function readFacet(value, path) {
+  const facet = record(value, path);
+  only(facet, path, ["propertyId", "limit"], "a facet");
+  const limit = facet.limit;
+  if (typeof limit !== "number" || !Number.isInteger(limit) || limit <= 0) {
+    throw new QueryShapeError(`${path}.limit`, "must be a positive whole number.");
+  }
+  return { propertyId: text(facet, "propertyId", path), limit };
+}
+var NODE_KEYS = {
+  start: ["objectTypeId", "includeSubtypes"],
+  refs: ["refs"],
+  filter: ["input", "predicate"],
+  text: ["input", "query", "fields"],
+  traverse: ["input", "linkId", "direction", "sourceObjectTypeId"],
+  set: ["op", "inputs"],
+  sort: ["input", "fields"],
+  limit: ["input", "limit"],
+  project: ["input", "properties"],
+  expand: ["input", "expansions", "users"]
+};
+var REFUSED_NODES = {
+  page: 'Sixb pages the result for each reader; bound the query with "limit" instead.',
+  vector: "each reader who opens the artifact would pay for an embedding call.",
+  rerank: "each reader who opens the artifact would pay for a reranking call."
+};
+function readNode(value, path) {
+  const node = record(value, path);
+  const kind = node.kind;
+  if (typeof kind === "string" && Object.hasOwn(REFUSED_NODES, kind)) {
+    throw new QueryShapeError(`${path}.kind`, `"${kind}" is not allowed in an artifact's query: ${REFUSED_NODES[kind]}`);
+  }
+  if (typeof kind !== "string" || !Object.hasOwn(NODE_KEYS, kind)) {
+    throw new QueryShapeError(`${path}.kind`, `${JSON.stringify(kind)} is not a query node; use ${Object.keys(NODE_KEYS).join(", ")}.`);
+  }
+  const known = kind;
+  only(node, path, ["kind", ...NODE_KEYS[known]], `a "${known}" node`);
+  const input = () => readNode(node.input, `${path}.input`);
+  switch (known) {
+    case "start":
+      return {
+        kind: known,
+        objectTypeId: text(node, "objectTypeId", path),
+        ...node.includeSubtypes === undefined ? {} : { includeSubtypes: boolean(node, "includeSubtypes", path) }
+      };
+    case "refs":
+      return {
+        kind: known,
+        refs: list(node.refs, `${path}.refs`).map((ref, index) => {
+          const at = `${path}.refs[${index}]`;
+          const entry = record(ref, at);
+          only(entry, at, ["objectTypeId", "primaryId"], "a ref");
+          return {
+            objectTypeId: text(entry, "objectTypeId", at),
+            primaryId: text(entry, "primaryId", at)
+          };
+        })
+      };
+    case "filter":
+      return {
+        kind: known,
+        input: input(),
+        predicate: readPredicate(node.predicate, `${path}.predicate`)
+      };
+    case "text":
+      return {
+        kind: known,
+        input: input(),
+        query: string(node, "query", path),
+        ...node.fields === undefined ? {} : { fields: texts(node.fields, `${path}.fields`) }
+      };
+    case "traverse":
+      return {
+        kind: known,
+        input: input(),
+        linkId: text(node, "linkId", path),
+        direction: direction(node, path),
+        ...node.sourceObjectTypeId === undefined ? {} : { sourceObjectTypeId: text(node, "sourceObjectTypeId", path) }
+      };
+    case "set":
+      return {
+        kind: known,
+        op: oneOf(node, "op", path, ["union", "intersect", "subtract"]),
+        inputs: list(node.inputs, `${path}.inputs`).map((each, index) => readNode(each, `${path}.inputs[${index}]`))
+      };
+    case "sort":
+      return { kind: known, input: input(), fields: sortFields(node.fields, `${path}.fields`) };
+    case "limit":
+      return { kind: known, input: input(), limit: count(node, "limit", path) };
+    case "project":
+      return {
+        kind: known,
+        input: input(),
+        ...node.properties === undefined ? {} : { properties: texts(node.properties, `${path}.properties`) }
+      };
+    case "expand":
+      return {
+        kind: known,
+        input: input(),
+        expansions: expansions(node.expansions, `${path}.expansions`),
+        ...node.users === undefined ? {} : { users: texts(node.users, `${path}.users`) }
+      };
+  }
+}
+function readPredicate(value, path) {
+  const predicate = record(value, path);
+  const op = predicate.op;
+  switch (op) {
+    case "and":
+    case "or":
+      only(predicate, path, ["op", "items"], `an "${op}" predicate`);
+      return {
+        op,
+        items: list(predicate.items, `${path}.items`).map((item, index) => readPredicate(item, `${path}.items[${index}]`))
+      };
+    case "not":
+      only(predicate, path, ["op", "item"], 'a "not" predicate');
+      return { op, item: readPredicate(predicate.item, `${path}.item`) };
+    case "eq":
+    case "neq":
+    case "lt":
+    case "lte":
+    case "gt":
+    case "gte":
+    case "contains":
+      only(predicate, path, ["op", "propertyId", "value"], `an "${op}" predicate`);
+      return {
+        op,
+        propertyId: text(predicate, "propertyId", path),
+        value: present(predicate, "value", path)
+      };
+    case "in":
+      only(predicate, path, ["op", "propertyId", "values"], 'an "in" predicate');
+      return {
+        op,
+        propertyId: text(predicate, "propertyId", path),
+        values: list(predicate.values, `${path}.values`)
+      };
+    case "exists":
+      only(predicate, path, ["op", "propertyId", "value"], 'an "exists" predicate');
+      return {
+        op,
+        propertyId: text(predicate, "propertyId", path),
+        value: boolean(predicate, "value", path)
+      };
+    default:
+      throw new QueryShapeError(`${path}.op`, `${JSON.stringify(op)} is not a predicate; use and, or, not, eq, neq, lt, lte, gt, gte, in, exists or contains.`);
+  }
+}
+function sortFields(value, path) {
+  return list(value, path).map((each, index) => {
+    const at = `${path}[${index}]`;
+    const field = record(each, at);
+    const kind = oneOf(field, "kind", at, ["property", "relevance"]);
+    if (kind === "relevance") {
+      only(field, at, ["kind", "direction"], "a relevance sort");
+      return { kind, ...sortDirection(field, at) };
+    }
+    only(field, at, ["kind", "propertyId", "direction"], "a property sort");
+    return { kind, propertyId: text(field, "propertyId", at), ...sortDirection(field, at) };
+  });
+}
+function sortDirection(field, path) {
+  return field.direction === undefined ? {} : { direction: oneOf(field, "direction", path, ["asc", "desc"]) };
+}
+function expansions(value, path) {
+  return list(value, path).map((each, index) => {
+    const at = `${path}[${index}]`;
+    const expansion = record(each, at);
+    only(expansion, at, ["linkId", "direction", "sourceObjectTypeId", "limit", "orderBy", "expand", "users"], "an expansion");
+    return {
+      linkId: text(expansion, "linkId", at),
+      direction: direction(expansion, at),
+      ...expansion.sourceObjectTypeId === undefined ? {} : { sourceObjectTypeId: text(expansion, "sourceObjectTypeId", at) },
+      ...expansion.limit === undefined ? {} : { limit: count(expansion, "limit", at) },
+      ...expansion.orderBy === undefined ? {} : { orderBy: sortFields(expansion.orderBy, `${at}.orderBy`) },
+      ...expansion.expand === undefined ? {} : { expand: expansions(expansion.expand, `${at}.expand`) },
+      ...expansion.users === undefined ? {} : { users: texts(expansion.users, `${at}.users`) }
+    };
+  });
+}
+function direction(value, path) {
+  return oneOf(value, "direction", path, ["outgoing", "incoming"]);
+}
+function record(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new QueryShapeError(path, "must be an object.");
+  }
+  return value;
+}
+function list(value, path) {
+  if (!Array.isArray(value))
+    throw new QueryShapeError(path, "must be a list.");
+  return value;
+}
+function only(value, path, keys, shape) {
+  const extra = Object.keys(value).find((key) => !keys.includes(key));
+  if (extra !== undefined) {
+    throw new QueryShapeError(`${path}.${extra}`, `is not a key of ${shape}.`);
+  }
+}
+function present(value, key, path) {
+  if (!Object.hasOwn(value, key))
+    throw new QueryShapeError(`${path}.${key}`, "is missing.");
+  return value[key];
+}
+function string(value, key, path) {
+  const found = value[key];
+  if (typeof found !== "string")
+    throw new QueryShapeError(`${path}.${key}`, "must be text.");
+  return found;
+}
+function text(value, key, path) {
+  const found = string(value, key, path);
+  if (found.length === 0)
+    throw new QueryShapeError(`${path}.${key}`, "must not be empty.");
+  return found;
+}
+function texts(value, path) {
+  return list(value, path).map((each, index) => {
+    if (typeof each !== "string" || each.length === 0) {
+      throw new QueryShapeError(`${path}[${index}]`, "must be text that is not empty.");
+    }
+    return each;
+  });
+}
+function boolean(value, key, path) {
+  const found = value[key];
+  if (typeof found !== "boolean") {
+    throw new QueryShapeError(`${path}.${key}`, "must be true or false.");
+  }
+  return found;
+}
+function count(value, key, path) {
+  const found = value[key];
+  if (typeof found !== "number" || !Number.isInteger(found) || found < 0) {
+    throw new QueryShapeError(`${path}.${key}`, "must be a whole number, 0 or more.");
+  }
+  return found;
+}
+function oneOf(value, key, path, values) {
+  const found = value[key];
+  if (typeof found !== "string" || !values.includes(found)) {
+    throw new QueryShapeError(`${path}.${key}`, `${JSON.stringify(found)} is not one of ${values.join(", ")}.`);
+  }
+  return found;
+}
+
+// src/artifacts/resolve.ts
+function resolveArtifactAddress2(address, target) {
+  if (address.path !== undefined) {
+    if (address.part !== undefined)
+      return { problem: "names both a file and a part of one" };
+    return target.files.some((file) => file.path === address.path) ? { part: { type: "file", path: address.path } } : { problem: `has no file '${address.path}'` };
+  }
+  if (address.part === undefined)
+    return { part: { type: "artifact" } };
+  const { outline } = target;
+  switch (outline.kind) {
+    case "sheet": {
+      const part = parseSheetPart2(address.part);
+      if (!part) {
+        return {
+          problem: `has no part '${address.part}': name a sheet, a range such as Summary!A1:D12, or chart=<name>`
+        };
+      }
+      if (part.type === "chart") {
+        return outline.charts.includes(part.chart) ? { part } : { problem: `has no chart '${part.chart}'${listed("its charts", outline.charts)}` };
+      }
+      const sheet = outline.sheets.find((candidate) => candidate.name === part.sheet);
+      if (!sheet) {
+        return {
+          problem: `has no sheet '${part.sheet}'${listed("its sheets", outline.sheets.map((candidate) => candidate.name))}`
+        };
+      }
+      const rows = sheet.query === undefined ? sheet.rows : Number.POSITIVE_INFINITY;
+      if (part.range && (part.range.bottom > rows || part.range.right >= sheet.columns.length)) {
+        return {
+          problem: `has no range ${address.part.slice(address.part.lastIndexOf("!") + 1)} in sheet '${sheet.name}', which has ${sheet.rows + 1} rows and ${sheet.columns.length} columns`
+        };
+      }
+      return { part };
+    }
+    case "document": {
+      const heading = outline.headings.find((candidate) => candidate.slug === address.part);
+      return heading ? { part: { type: "section", slug: heading.slug } } : {
+        problem: `has no section '${address.part}'${listed("its sections", outline.headings.map((candidate) => candidate.slug))}`
+      };
+    }
+    case "slides": {
+      const slide = /^[1-9]\d*$/.test(address.part) ? Number(address.part) : Number.NaN;
+      return slide <= outline.slides.length ? { part: { type: "slide", slide } } : { problem: `has no slide '${address.part}': it has ${outline.slides.length} slides` };
+    }
+    case "canvas": {
+      const item = outline.items.find((candidate) => candidate.id === address.part);
+      if (!item) {
+        return {
+          problem: `has no board or section '${address.part}'${listed("its boards and sections", outline.items.map((candidate) => candidate.id))}`
+        };
+      }
+      return { part: { type: item.type === "board" ? "board" : "region", id: item.id } };
+    }
+    case "page":
+    case "file":
+      return { problem: `is a ${target.kind}, which has no parts to name` };
+  }
+}
+function listed(label, names) {
+  if (names.length === 0)
+    return "";
+  const shown = names.slice(0, 8).map((name) => `'${name}'`);
+  return `; ${label} are ${shown.join(", ")}${names.length > shown.length ? ", \u2026" : ""}`;
+}
+
+// src/artifacts/tones.ts
+var ARTIFACT_TONES2 = [
+  "neutral",
+  "positive",
+  "warning",
+  "negative",
+  "chart-1",
+  "chart-2",
+  "chart-3",
+  "chart-4",
+  "chart-5"
+];
+function isArtifactTone(value) {
+  return ARTIFACT_TONES2.includes(value);
+}
+
+// src/artifacts/canvas.ts
+var CANVAS_FILE2 = "canvas.json";
+var CANVAS_ITEM_TYPES = [
+  "board",
+  "section",
+  "note",
+  "text",
+  "shape",
+  "arrow",
+  "embed"
+];
+var CANVAS_SHAPES = ["rect", "ellipse", "diamond"];
+var CANVAS_TEXT_SIZES = ["s", "m", "l", "xl"];
+
+class CanvasError extends Error {
+}
+function parseCanvas2(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return { error: `${CANVAS_FILE2} is not valid JSON.` };
+  }
+  try {
+    return { canvas: readCanvas(value) };
+  } catch (error) {
+    if (error instanceof CanvasError)
+      return { error: `${CANVAS_FILE2}: ${error.message}` };
+    throw error;
+  }
+}
+var ITEM_ID = /^[a-z0-9][a-z0-9-]{0,39}$/;
+var TEXT_MAX = ARTIFACT_LIMITS2.maxCanvasTextLength;
+var LABEL_MAX = ARTIFACT_LIMITS2.maxCanvasLabelLength;
+function readCanvas(value) {
+  const input = record2(value, "the canvas", ["items"]);
+  if (!Array.isArray(input.items) || input.items.length === 0) {
+    throw new CanvasError('"items" must list at least one item.');
+  }
+  if (input.items.length > ARTIFACT_LIMITS2.maxCanvasItems) {
+    throw new CanvasError(`a canvas holds at most ${ARTIFACT_LIMITS2.maxCanvasItems} items; this one has ${input.items.length}.`);
+  }
+  const items = input.items.map((item, index) => readItem(item, index));
+  const ids = new Set;
+  for (const item of items) {
+    if (ids.has(item.id))
+      throw new CanvasError(`two items have the id '${item.id}'.`);
+    ids.add(item.id);
+  }
+  const boards = items.filter((item) => item.type === "board").length;
+  if (boards > ARTIFACT_LIMITS2.maxCanvasBoards) {
+    throw new CanvasError(`a canvas holds at most ${ARTIFACT_LIMITS2.maxCanvasBoards} boards; this one has ${boards}.`);
+  }
+  for (const item of items) {
+    if (item.type !== "arrow")
+      continue;
+    for (const [key, end] of [
+      ["from", item.from],
+      ["to", item.to]
+    ]) {
+      if (typeof end !== "string")
+        continue;
+      const target = items.find((candidate) => candidate.id === end);
+      if (!target) {
+        throw new CanvasError(`arrow '${item.id}' "${key}" names '${end}', which the canvas does not have.`);
+      }
+      if (target.type === "arrow") {
+        throw new CanvasError(`arrow '${item.id}' "${key}" names arrow '${end}'; an arrow joins items, not arrows.`);
+      }
+    }
+    if (item.from === item.to) {
+      throw new CanvasError(`arrow '${item.id}' starts and ends at '${String(item.from)}'.`);
+    }
+  }
+  return { items };
+}
+var KEYS = {
+  board: ["file", "x", "y", "w", "h", "title"],
+  section: ["x", "y", "w", "h", "title"],
+  note: ["x", "y", "w", "h", "text", "tone"],
+  text: ["x", "y", "w", "text", "size"],
+  shape: ["shape", "x", "y", "w", "h", "text", "tone"],
+  arrow: ["from", "to", "label", "dashed"],
+  embed: ["src", "x", "y", "w", "h", "title"]
+};
+function readItem(value, index) {
+  const loose = record2(value, `item ${index + 1}`, null);
+  if (typeof loose.id !== "string" || !ITEM_ID.test(loose.id)) {
+    throw new CanvasError(`item ${index + 1} needs an "id" of lowercase letters, digits, and hyphens, such as "pricing".`);
+  }
+  const id = loose.id;
+  if (!CANVAS_ITEM_TYPES.includes(loose.type)) {
+    throw new CanvasError(`item '${id}' has type ${JSON.stringify(loose.type)}; use one of ${CANVAS_ITEM_TYPES.join(", ")}.`);
+  }
+  const type = loose.type;
+  const at = `${type} '${id}'`;
+  const input = record2(value, at, ["id", "type", ...KEYS[type]]);
+  const place = () => ({ id, x: position(input.x, at, "x"), y: position(input.y, at, "y") });
+  const size = (key) => dimension(input[key], at, key);
+  const title = () => optionalText(input.title, at, "title", LABEL_MAX);
+  const tone = () => {
+    if (input.tone === undefined)
+      return {};
+    if (!isArtifactTone(input.tone)) {
+      throw new CanvasError(`${at} has the tone ${JSON.stringify(input.tone)}; use one of ${ARTIFACT_TONES2.join(", ")}.`);
+    }
+    return { tone: input.tone };
+  };
+  switch (type) {
+    case "board": {
+      if (typeof input.file !== "string" || !/\.html?$/i.test(input.file)) {
+        throw new CanvasError(`${at} needs a "file", the HTML it shows, such as "boards/${id}.html".`);
+      }
+      return { type, ...place(), w: size("w"), h: size("h"), file: input.file, ...title() };
+    }
+    case "section":
+      return { type, ...place(), w: size("w"), h: size("h"), ...title() };
+    case "note":
+      return {
+        type,
+        ...place(),
+        w: size("w"),
+        ...input.h === undefined ? {} : { h: size("h") },
+        text: requiredText(input.text, at, "text", TEXT_MAX),
+        ...tone()
+      };
+    case "text": {
+      if (input.size !== undefined && !CANVAS_TEXT_SIZES.includes(input.size)) {
+        throw new CanvasError(`${at} "size" is ${JSON.stringify(input.size)}; use one of ${CANVAS_TEXT_SIZES.join(", ")}.`);
+      }
+      return {
+        type,
+        ...place(),
+        text: requiredText(input.text, at, "text", TEXT_MAX),
+        size: input.size ?? "m",
+        ...input.w === undefined ? {} : { w: size("w") }
+      };
+    }
+    case "shape": {
+      if (!CANVAS_SHAPES.includes(input.shape)) {
+        throw new CanvasError(`${at} "shape" is ${JSON.stringify(input.shape)}; use one of ${CANVAS_SHAPES.join(", ")}.`);
+      }
+      return {
+        type,
+        ...place(),
+        w: size("w"),
+        h: size("h"),
+        shape: input.shape,
+        ...optionalText(input.text, at, "text", LABEL_MAX, "text"),
+        ...tone()
+      };
+    }
+    case "embed": {
+      if (typeof input.src !== "string" || !isArtifactAddress2(input.src)) {
+        throw new CanvasError(`${at} needs a "src", another artifact's address, such as "artifact:art_k3m9q2x7tp#chart=revenue".`);
+      }
+      return { type, ...place(), w: size("w"), h: size("h"), src: input.src.trim(), ...title() };
+    }
+    case "arrow": {
+      if (input.dashed !== undefined && typeof input.dashed !== "boolean") {
+        throw new CanvasError(`${at} "dashed" must be true or false.`);
+      }
+      return {
+        type,
+        id,
+        from: end(input.from, at, "from"),
+        to: end(input.to, at, "to"),
+        ...optionalText(input.label, at, "label", LABEL_MAX, "label"),
+        dashed: input.dashed === true
+      };
+    }
+  }
+}
+function end(value, at, key) {
+  if (typeof value === "string" && value)
+    return value;
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const point = record2(value, `${at} "${key}"`, ["x", "y"]);
+    return { x: position(point.x, at, `${key}.x`), y: position(point.y, at, `${key}.y`) };
+  }
+  throw new CanvasError(`${at} needs "${key}": an item's id, or a point such as { "x": 0, "y": 0 }.`);
+}
+function position(value, at, key) {
+  const max = ARTIFACT_LIMITS2.maxCanvasPosition;
+  if (typeof value !== "number" || !Number.isFinite(value) || Math.abs(value) > max) {
+    throw new CanvasError(`${at} needs "${key}", a number of pixels within \xB1${max.toLocaleString("en-US")}.`);
+  }
+  return value;
+}
+function dimension(value, at, key) {
+  const { minCanvasItemSize: min, maxCanvasItemSize: max } = ARTIFACT_LIMITS2;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) {
+    throw new CanvasError(`${at} needs "${key}", a size of ${min} to ${max} pixels.`);
+  }
+  return value;
+}
+function requiredText(value, at, key, max) {
+  if (typeof value !== "string" || !value.trim())
+    throw new CanvasError(`${at} needs "${key}", its text.`);
+  if (value.length > max)
+    throw new CanvasError(`${at} "${key}" is ${value.length} characters; at most ${max}.`);
+  return value.trim();
+}
+function optionalText(value, at, key, max, as = key) {
+  if (value === undefined)
+    return {};
+  if (typeof value !== "string" || value.length > max) {
+    throw new CanvasError(`${at} "${key}" must be text of at most ${max} characters.`);
+  }
+  return value.trim() ? { [as]: value.trim() } : {};
+}
+function record2(value, at, keys) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new CanvasError(`${at} must be an object.`);
+  }
+  const input = value;
+  const unknownKey = keys && Object.keys(input).find((key) => !keys.includes(key));
+  if (unknownKey) {
+    throw new CanvasError(`${at} has '${unknownKey}'; it takes ${keys.map((key) => `"${key}"`).join(", ")}.`);
+  }
+  return input;
+}
+
+// src/artifacts/outline.ts
+function createHeadingSlugger2() {
+  const used = new Set;
+  return (text) => {
+    const base = text.trim().toLowerCase().replace(/[^\p{L}\p{N}\s_-]/gu, "").replace(/\s+/g, "-") || "section";
+    let slug = base;
+    for (let repeat = 1;used.has(slug); repeat += 1)
+      slug = `${base}-${repeat}`;
+    used.add(slug);
+    return slug;
+  };
+}
+
+// src/artifacts/csv.ts
+class CsvParseError2 extends Error {
+  line;
+  constructor(message, line) {
+    super(message);
+    this.line = line;
+    this.name = "CsvParseError";
+  }
+}
+function parseCsv2(text, options = {}) {
+  const delimiter = options.delimiter ?? ",";
+  const source = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+  const records = [];
+  let record = [];
+  let field = "";
+  let quoted = false;
+  let quotedSeen = false;
+  let line = 1;
+  let recordLine = 1;
+  let index = 0;
+  const endField = () => {
+    record.push(field);
+    field = "";
+  };
+  const endRecord = () => {
+    endField();
+    if (!(record.length === 1 && record[0] === "" && !quotedSeen))
+      records.push(record);
+    record = [];
+    quotedSeen = false;
+  };
+  while (index < source.length) {
+    const char = source[index];
+    if (quoted) {
+      if (char === '"') {
+        if (source[index + 1] === '"') {
+          field += '"';
+          index += 2;
+          continue;
+        }
+        quoted = false;
+        index += 1;
+        const next = source[index];
+        if (next !== undefined && next !== delimiter && next !== `
+` && next !== "\r") {
+          throw new CsvParseError2(`A quoted field on line ${line} goes on after its closing quote; quote the whole field and double the quotes inside it.`, recordLine);
+        }
+        continue;
+      }
+      if (char === `
+` || char === "\r" && source[index + 1] !== `
+`)
+        line += 1;
+      field += char;
+      index += 1;
+      continue;
+    }
+    if (char === '"' && field === "") {
+      quoted = true;
+      quotedSeen = true;
+      index += 1;
+      continue;
+    }
+    if (char === delimiter) {
+      endField();
+      index += 1;
+      continue;
+    }
+    if (char === "\r" || char === `
+`) {
+      endRecord();
+      index += char === "\r" && source[index + 1] === `
+` ? 2 : 1;
+      line += 1;
+      recordLine = line;
+      continue;
+    }
+    field += char;
+    index += 1;
+  }
+  if (quoted) {
+    throw new CsvParseError2(`A quoted field that starts on line ${recordLine} is never closed.`, recordLine);
+  }
+  if (field !== "" || record.length > 0 || quotedSeen)
+    endRecord();
+  const [header, ...rows] = records;
+  return { header: header ?? [], rows };
+}
+function formatCsv2(header, rows) {
+  const field = (value) => /[",\r\n]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value;
+  return [header, ...rows].map((row) => `${row.map(field).join(",")}\r
+`).join("");
+}
+
+// src/artifacts/formula/parser.ts
+class FormulaSyntaxError extends Error {
+  position;
+  constructor(message, position) {
+    super(message);
+    this.position = position;
+    this.name = "FormulaSyntaxError";
+  }
+}
+var OPERATORS = ["<>", "<=", ">=", "+", "-", "*", "/", "^", "&", "=", "<", ">", "(", ")", ","];
+function tokens(source) {
+  const list = [];
+  let index = 0;
+  const fail = (message, at = index) => {
+    throw new FormulaSyntaxError(`${message} at character ${at + 1}.`, at + 1);
+  };
+  const name = () => {
+    let value = "";
+    while (index < source.length && source[index] !== "]") {
+      if (source[index] === "[")
+        fail("A column's name holds '[': escape it as '[");
+      if (source[index] === "'")
+        index += 1;
+      value += source[index] ?? "";
+      index += 1;
+    }
+    if (source[index] !== "]")
+      fail("A column reference is never closed with ']'");
+    index += 1;
+    return value.trim();
+  };
+  while (index < source.length) {
+    const char = source[index];
+    const at = index;
+    if (/\s/.test(char)) {
+      index += 1;
+      continue;
+    }
+    if (/[0-9.]/.test(char)) {
+      const match = /^(\d+\.?\d*|\.\d+)(e[-+]?\d+)?/i.exec(source.slice(index));
+      if (!match)
+        fail("A number is not written right");
+      index += match[0].length;
+      list.push({ kind: "number", value: Number(match[0]), at });
+      continue;
+    }
+    if (char === '"') {
+      let value = "";
+      index += 1;
+      for (;; ) {
+        if (index >= source.length)
+          fail("A text in quotes is never closed", at);
+        if (source[index] === '"') {
+          if (source[index + 1] === '"') {
+            value += '"';
+            index += 2;
+            continue;
+          }
+          index += 1;
+          break;
+        }
+        value += source[index];
+        index += 1;
+      }
+      list.push({ kind: "text", value, at });
+      continue;
+    }
+    if (char === "[") {
+      index += 1;
+      const row = source[index] === "@";
+      if (row)
+        index += 1;
+      let column;
+      if (source[index] === "[") {
+        index += 1;
+        column = name();
+        if (source[index] !== "]")
+          fail("A bracketed column name needs its outer ']'");
+        index += 1;
+      } else {
+        column = name();
+      }
+      if (!column)
+        fail("A column reference names no column", at);
+      list.push({ kind: "ref", column, row, at });
+      continue;
+    }
+    if (/[A-Za-z_]/.test(char)) {
+      const match = /^[A-Za-z_][A-Za-z0-9_.]*/.exec(source.slice(index));
+      index += match[0].length;
+      list.push({ kind: "name", value: match[0].toUpperCase(), at });
+      continue;
+    }
+    const operator = OPERATORS.find((candidate) => source.startsWith(candidate, index));
+    if (!operator)
+      fail(`'${char}' is not part of a formula`);
+    index += operator.length;
+    list.push({ kind: "op", value: operator, at });
+  }
+  list.push({ kind: "end", at: source.length });
+  return list;
+}
+var BINDING = {
+  "=": 10,
+  "<>": 10,
+  "<": 10,
+  "<=": 10,
+  ">": 10,
+  ">=": 10,
+  "&": 20,
+  "+": 30,
+  "-": 30,
+  "*": 40,
+  "/": 40,
+  "^": 50
+};
+var PREFIX = 60;
+function parseFormula2(text) {
+  const source = text.trim().replace(/^=/, "");
+  const list = tokens(source);
+  let position = 0;
+  const peek = () => list[position];
+  const next = () => list[position++];
+  const fail = (message, token) => {
+    throw new FormulaSyntaxError(`${message} at character ${token.at + 1}.`, token.at + 1);
+  };
+  const expect = (value) => {
+    const token = next();
+    if (token.kind !== "op" || token.value !== value) {
+      fail(`Expected '${value}'`, token);
+    }
+  };
+  const expression = (binding) => {
+    let left = operand();
+    for (;; ) {
+      const token = peek();
+      if (token.kind !== "op")
+        break;
+      const power = BINDING[token.value];
+      if (power === undefined || power <= binding)
+        break;
+      next();
+      const right = expression(power);
+      left = { kind: "binary", op: token.value, left, right };
+    }
+    return left;
+  };
+  const operand = () => {
+    const token = next();
+    switch (token.kind) {
+      case "number":
+        return { kind: "number", value: token.value };
+      case "text":
+        return { kind: "text", value: token.value };
+      case "ref":
+        return token.row ? { kind: "ref", column: token.column } : { kind: "columnRef", column: token.column };
+      case "name": {
+        if (token.value === "TRUE" || token.value === "FALSE") {
+          return { kind: "boolean", value: token.value === "TRUE" };
+        }
+        if (peek().kind !== "op" || peek().value !== "(") {
+          return fail(`'${token.value}' is not a function call or a reference; a column is written [@Name]`, token);
+        }
+        next();
+        const args = [];
+        if (!(peek().kind === "op" && peek().value === ")")) {
+          for (;; ) {
+            args.push(expression(0));
+            const separator = peek();
+            if (separator.kind === "op" && separator.value === ",") {
+              next();
+              continue;
+            }
+            break;
+          }
+        }
+        expect(")");
+        return { kind: "call", name: token.value, args };
+      }
+      case "op":
+        if (token.value === "(") {
+          const inner = expression(0);
+          expect(")");
+          return inner;
+        }
+        if (token.value === "-" || token.value === "+") {
+          return { kind: "unary", op: token.value, operand: expression(PREFIX) };
+        }
+        return fail(`'${token.value}' can't start a value`, token);
+      case "end":
+        return fail("The formula ends where a value is expected", token);
+    }
+  };
+  const tree = expression(0);
+  const rest = peek();
+  if (rest.kind !== "end")
+    fail("The formula goes on after a complete value", rest);
+  return tree;
+}
+function formulaDependencies2(node) {
+  const columns = new Set;
+  visitReferences(node, (reference) => columns.add(reference.column));
+  return columns;
+}
+function formulaReferences2(node) {
+  const row = new Set;
+  const whole = new Set;
+  visitReferences(node, (reference) => (reference.kind === "ref" ? row : whole).add(reference.column));
+  return { row, whole };
+}
+function visitReferences(node, found) {
+  const visit = (current) => {
+    switch (current.kind) {
+      case "ref":
+      case "columnRef":
+        found(current);
+        return;
+      case "unary":
+        visit(current.operand);
+        return;
+      case "binary":
+        visit(current.left);
+        visit(current.right);
+        return;
+      case "call":
+        for (const arg of current.args)
+          visit(arg);
+        return;
+      default:
+        return;
+    }
+  };
+  visit(node);
+}
+function renameColumnReferences2(formula, from, to) {
+  let result = "";
+  let index = 0;
+  while (index < formula.length) {
+    const char = formula[index];
+    if (char === '"') {
+      let end = index + 1;
+      while (end < formula.length) {
+        if (formula[end] === '"' && formula[end + 1] === '"')
+          end += 2;
+        else if (formula[end] === '"')
+          break;
+        else
+          end += 1;
+      }
+      result += formula.slice(index, end + 1);
+      index = end + 1;
+      continue;
+    }
+    if (char !== "[") {
+      result += char;
+      index += 1;
+      continue;
+    }
+    const start = index;
+    index += 1;
+    const row = formula[index] === "@";
+    if (row)
+      index += 1;
+    const bracketed = formula[index] === "[";
+    if (bracketed)
+      index += 1;
+    let name = "";
+    while (index < formula.length && formula[index] !== "]") {
+      if (formula[index] === "'")
+        index += 1;
+      name += formula[index] ?? "";
+      index += 1;
+    }
+    index += bracketed ? 2 : 1;
+    result += name.trim() === from ? columnReference(to, row) : formula.slice(start, Math.min(index, formula.length));
+  }
+  return result;
+}
+function columnReference(name, row) {
+  const escaped = name.replace(/['[\]#@]/g, "'$&");
+  const plain = /^[A-Za-z0-9_ ]+$/.test(name) && name === name.trim();
+  const inner = plain ? escaped : `[${escaped}]`;
+  return row ? `[@${inner}]` : `[${inner}]`;
+}
+
+// src/artifacts/workbook.ts
+var WORKBOOK_FILE2 = "workbook.json";
+var SHEET_COLUMN_TYPES2 = [
+  "text",
+  "number",
+  "currency",
+  "percent",
+  "date",
+  "link",
+  "image",
+  "boolean",
+  "tag"
+];
+var NUMERIC_COLUMN_TYPES2 = ["number", "currency", "percent"];
+var SHEET_HIGHLIGHTS2 = ["bars", "scale", "diverging"];
+var SHEET_TOTALS2 = ["sum", "average", "min", "max", "count"];
+var SHEET_CHART_TYPES = ["bar", "line", "area", "pie", "scatter"];
+var SHEET_CHART_AGGREGATES = ["sum", "average", "count"];
+function sheetFilePath2(sheetName) {
+  return `sheets/${sheetName}.csv`;
+}
+function parseWorkbook2(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return { error: `${WORKBOOK_FILE2} is not valid JSON.` };
+  }
+  try {
+    return { workbook: readWorkbook(value) };
+  } catch (error) {
+    if (error instanceof WorkbookError)
+      return { error: `${WORKBOOK_FILE2}: ${error.message}` };
+    throw error;
+  }
+}
+function parseSheetNumber2(value) {
+  const trimmed = value.trim();
+  if (!/^[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?$/i.test(trimmed))
+    return;
+  const number = Number(trimmed);
+  return Number.isFinite(number) ? number : undefined;
+}
+function parseSheetDate2(value) {
+  const trimmed = value.trim();
+  if (!/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[-+]\d{2}:\d{2})?)?$/.test(trimmed)) {
+    return;
+  }
+  const date = new Date(trimmed.length === 10 ? `${trimmed}T00:00:00Z` : trimmed);
+  return Number.isNaN(date.getTime()) ? undefined : date;
+}
+
+class WorkbookError extends Error {
+}
+var SHEET_NAME_MAX = 60;
+var DESCRIPTION_MAX = 300;
+var TONES_MAX = 20;
+var TAG_MAX = 60;
+var FORMULA_MAX = 500;
+var COMPUTED_MAX = 20;
+var CHART_NAME = /^[a-z0-9][a-z0-9-]{0,39}$/;
+var CONTROL = /[\u0000-\u001f\u007f]/;
+function readWorkbook(value) {
+  const input = record3(value, "the workbook", ["sheets", "charts"]);
+  if (!Array.isArray(input.sheets) || input.sheets.length === 0) {
+    throw new WorkbookError('"sheets" must list at least one sheet.');
+  }
+  if (input.sheets.length > ARTIFACT_LIMITS2.maxSheets) {
+    throw new WorkbookError(`a workbook holds at most ${ARTIFACT_LIMITS2.maxSheets} sheets; this one has ${input.sheets.length}.`);
+  }
+  const sheets = input.sheets.map((sheet, index) => readSheet(sheet, index));
+  const names = new Set;
+  for (const sheet of sheets) {
+    const key = sheet.name.toLowerCase();
+    if (names.has(key))
+      throw new WorkbookError(`two sheets are named '${sheet.name}'.`);
+    names.add(key);
+  }
+  const chartsInput = input.charts ?? [];
+  if (!Array.isArray(chartsInput))
+    throw new WorkbookError('"charts" must be a list.');
+  if (chartsInput.length > ARTIFACT_LIMITS2.maxCharts) {
+    throw new WorkbookError(`a workbook holds at most ${ARTIFACT_LIMITS2.maxCharts} charts; this one has ${chartsInput.length}.`);
+  }
+  const charts = chartsInput.map((chart, index) => readChart(chart, index, sheets));
+  const chartNames = new Set;
+  for (const chart of charts) {
+    if (chartNames.has(chart.name))
+      throw new WorkbookError(`two charts are named '${chart.name}'.`);
+    chartNames.add(chart.name);
+  }
+  return { sheets, charts };
+}
+function readSheet(value, index) {
+  const at = `sheet ${index + 1}`;
+  const input = record3(value, at, [
+    "name",
+    "frozenRows",
+    "frozenColumns",
+    "columns",
+    "widths",
+    "descriptions",
+    "totals",
+    "query"
+  ]);
+  const name = typeof input.name === "string" ? input.name.trim() : "";
+  if (!name || name.length > SHEET_NAME_MAX || CONTROL.test(name) || /[/\\]/.test(name) || name === "." || name === "..") {
+    throw new WorkbookError(`${at} needs a "name" of at most ${SHEET_NAME_MAX} characters without / or \\; its values go in sheets/<name>.csv.`);
+  }
+  const sheetAt = `sheet '${name}'`;
+  const live = input.query === undefined ? undefined : readLiveSheet(input, sheetAt);
+  const columns = {};
+  for (const [column, format] of Object.entries(record3(input.columns ?? {}, `${sheetAt} "columns"`, null))) {
+    const at = `${sheetAt} column '${column}'`;
+    if (!live) {
+      columns[column] = readColumnFormat(format, at);
+      continue;
+    }
+    const { from: _from, ...written } = format;
+    if (written.type !== undefined || written.formula !== undefined) {
+      columns[column] = readColumnFormat(written, at);
+    }
+  }
+  const computed = Object.values(columns).filter((format) => format.formula).length;
+  if (computed > COMPUTED_MAX) {
+    throw new WorkbookError(`${sheetAt} computes ${computed} columns; a sheet computes at most ${COMPUTED_MAX}.`);
+  }
+  const widths = {};
+  for (const [column, width] of Object.entries(record3(input.widths ?? {}, `${sheetAt} "widths"`, null))) {
+    if (typeof width !== "number" || !Number.isInteger(width) || width < 40 || width > 800) {
+      throw new WorkbookError(`${sheetAt} gives column '${column}' a width of ${String(width)}; use 40 to 800 pixels.`);
+    }
+    widths[column] = width;
+  }
+  const descriptions = {};
+  for (const [column, description] of Object.entries(record3(input.descriptions ?? {}, `${sheetAt} "descriptions"`, null))) {
+    if (typeof description !== "string" || !description.trim() || description.length > DESCRIPTION_MAX) {
+      throw new WorkbookError(`${sheetAt} describes column '${column}' with ${JSON.stringify(description)}; a description is text of at most ${DESCRIPTION_MAX} characters.`);
+    }
+    descriptions[column] = description.trim();
+  }
+  const totals = {};
+  for (const [column, total] of Object.entries(record3(input.totals ?? {}, `${sheetAt} "totals"`, null))) {
+    if (!SHEET_TOTALS2.includes(total)) {
+      throw new WorkbookError(`${sheetAt} totals column '${column}' with ${JSON.stringify(total)}; use one of ${SHEET_TOTALS2.join(", ")}.`);
+    }
+    const deferred = live !== undefined && columns[column] === undefined;
+    const problem = deferred ? null : sheetTotalProblem(sheetAt, column, total, columns[column]?.type ?? "text");
+    if (problem)
+      throw new WorkbookError(problem);
+    totals[column] = total;
+  }
+  return {
+    name,
+    frozenRows: integer(input.frozenRows, 1, 0, 10, `${sheetAt} "frozenRows"`),
+    frozenColumns: integer(input.frozenColumns, 0, 0, 5, `${sheetAt} "frozenColumns"`),
+    columns,
+    widths,
+    descriptions,
+    totals,
+    ...live ? { live } : {}
+  };
+}
+function sheetTotalProblem(sheetAt, column, total, type) {
+  if (total === "count" || NUMERIC_COLUMN_TYPES2.includes(type))
+    return null;
+  return `${sheetAt} totals column '${column}' with "${total}", but it is ${type}; only a number, currency, or percent column has a ${total}. Use "count", or give it a numeric type in "columns".`;
+}
+var INDEX_NAME = /^(0|[1-9]\d{0,8})$/;
+function readLiveSheet(input, sheetAt) {
+  if (typeof input.query !== "string" || !isArtifactQueryName(input.query)) {
+    throw new WorkbookError(`${sheetAt} "query" must name one of the version's queries, as queries/<name>.json names it: lowercase letters, digits and hyphens.`);
+  }
+  const entries = Object.entries(record3(input.columns ?? {}, `${sheetAt} "columns"`, null));
+  if (entries.length === 0) {
+    throw new WorkbookError(`${sheetAt} reads query '${input.query}': list its columns in "columns", each with the property it shows in "from".`);
+  }
+  const columns = entries.map(([name, value]) => {
+    const at = `${sheetAt} column '${name}'`;
+    if (INDEX_NAME.test(name)) {
+      throw new WorkbookError(`${at}: a live sheet's columns come in the order "columns" lists them, and JSON puts a name of digits first. Name it with a letter, such as "FY${name}".`);
+    }
+    if (typeof value === "string") {
+      throw new WorkbookError(`${at} is ${JSON.stringify(value)}; a live sheet's column is an object, such as { "from": "amount", "type": "${value}" }.`);
+    }
+    const column = record3(value, at, [
+      "from",
+      "type",
+      "currency",
+      "decimals",
+      "compact",
+      "signed",
+      "tones",
+      "highlight",
+      "formula"
+    ]);
+    if (column.from === undefined && column.formula === undefined) {
+      throw new WorkbookError(`${at} shows nothing: give it "from", the property it shows, or a "formula".`);
+    }
+    if (column.from !== undefined && column.formula !== undefined) {
+      throw new WorkbookError(`${at} has both "from" and "formula": a column shows a property or computes, not both.`);
+    }
+    if (column.from === undefined)
+      return { name };
+    const from = column.from;
+    const segments = typeof from === "string" ? from.split(".") : [];
+    if (segments.length === 0 || segments.some((segment) => !segment)) {
+      throw new WorkbookError(`${at} "from" must name a property of the rows, such as "amount", or of a link the query expands, such as "customer.name".`);
+    }
+    if (segments.length > 2) {
+      throw new WorkbookError(`${at} "from" is ${JSON.stringify(from)}; a column reads a property of the rows or of one link the query expands, such as "customer.name".`);
+    }
+    const { from: _from, ...untyped } = column;
+    return { name, from, ...column.type === undefined ? { untyped } : {} };
+  });
+  return { query: input.query, columns };
+}
+function readSheetColumnFormat(value, at, type) {
+  try {
+    return { format: readColumnFormat({ type, ...value }, at) };
+  } catch (error) {
+    if (error instanceof WorkbookError)
+      return { error: `${WORKBOOK_FILE2}: ${error.message}` };
+    throw error;
+  }
+}
+function readColumnFormat(value, at) {
+  if (typeof value === "string")
+    return { type: columnType(value, at) };
+  const input = record3(value, at, [
+    "type",
+    "currency",
+    "decimals",
+    "compact",
+    "signed",
+    "tones",
+    "highlight",
+    "formula"
+  ]);
+  const type = columnType(input.type, at);
+  if (input.currency !== undefined) {
+    if (type !== "currency")
+      throw new WorkbookError(`${at} sets "currency" but is not a currency column.`);
+    if (typeof input.currency !== "string" || !/^[A-Z]{3}$/.test(input.currency)) {
+      throw new WorkbookError(`${at} "currency" must be an ISO 4217 code such as "USD".`);
+    }
+  }
+  if (input.decimals !== undefined && !["number", "currency", "percent"].includes(type)) {
+    throw new WorkbookError(`${at} sets "decimals" but is not a number, currency, or percent column.`);
+  }
+  for (const [key, types, named] of [
+    ["compact", ["number", "currency"], "number or currency"],
+    ["signed", ["number", "currency", "percent"], "number, currency, or percent"]
+  ]) {
+    if (input[key] === undefined)
+      continue;
+    if (typeof input[key] !== "boolean") {
+      throw new WorkbookError(`${at} "${key}" must be true or false.`);
+    }
+    if (!types.includes(type)) {
+      throw new WorkbookError(`${at} sets "${key}" but is not a ${named} column.`);
+    }
+  }
+  let tones;
+  if (input.tones !== undefined) {
+    if (type !== "tag")
+      throw new WorkbookError(`${at} sets "tones" but is not a tag column.`);
+    tones = {};
+    const entries = Object.entries(record3(input.tones, `${at} "tones"`, null));
+    if (entries.length > TONES_MAX) {
+      throw new WorkbookError(`${at} "tones" names ${entries.length} values; it takes at most ${TONES_MAX}.`);
+    }
+    for (const [tag, tone] of entries) {
+      if (!tag.trim() || tag.length > TAG_MAX) {
+        throw new WorkbookError(`${at} "tones" names a value of ${tag.length} characters; a tag is 1 to ${TAG_MAX}.`);
+      }
+      if (!isArtifactTone(tone)) {
+        throw new WorkbookError(`${at} gives '${tag}' the tone ${JSON.stringify(tone)}; use one of ${ARTIFACT_TONES2.join(", ")}.`);
+      }
+      tones[tag] = tone;
+    }
+  }
+  if (input.highlight !== undefined) {
+    if (!SHEET_HIGHLIGHTS2.includes(input.highlight)) {
+      throw new WorkbookError(`${at} "highlight" is ${JSON.stringify(input.highlight)}; use one of ${SHEET_HIGHLIGHTS2.join(", ")}.`);
+    }
+    if (!NUMERIC_COLUMN_TYPES2.includes(type)) {
+      throw new WorkbookError(`${at} sets "highlight" but is not a number, currency, or percent column.`);
+    }
+  }
+  let formula;
+  if (input.formula !== undefined) {
+    if (typeof input.formula !== "string" || !input.formula.trim()) {
+      throw new WorkbookError(`${at} "formula" must be text, such as "[@Revenue]-[@Cost]".`);
+    }
+    if (input.formula.length > FORMULA_MAX) {
+      throw new WorkbookError(`${at} "formula" is ${input.formula.length} characters; a formula is at most ${FORMULA_MAX}.`);
+    }
+    if (type === "link" || type === "image") {
+      throw new WorkbookError(`${at} is a ${type} column, which a formula can't compute.`);
+    }
+    formula = input.formula.trim().replace(/^=/, "");
+    try {
+      parseFormula2(formula);
+    } catch (error) {
+      if (error instanceof FormulaSyntaxError) {
+        throw new WorkbookError(`${at} "formula" does not read: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  return {
+    type,
+    ...typeof input.currency === "string" ? { currency: input.currency } : {},
+    ...formula ? { formula } : {},
+    ...input.compact === true ? { compact: true } : {},
+    ...input.signed === true ? { signed: true } : {},
+    ...tones ? { tones } : {},
+    ...input.highlight === undefined ? {} : { highlight: input.highlight },
+    ...input.decimals === undefined ? {} : { decimals: integer(input.decimals, 0, 0, 6, `${at} "decimals"`) }
+  };
+}
+function columnType(value, at) {
+  if (typeof value === "string" && SHEET_COLUMN_TYPES2.includes(value)) {
+    return value;
+  }
+  throw new WorkbookError(`${at} has type ${JSON.stringify(value)}; use one of ${SHEET_COLUMN_TYPES2.join(", ")}.`);
+}
+function readChart(value, index, sheets) {
+  const input = record3(value, `chart ${index + 1}`, [
+    "name",
+    "type",
+    "sheet",
+    "x",
+    "y",
+    "line",
+    "aggregate",
+    "title",
+    "stacked"
+  ]);
+  if (typeof input.name !== "string" || !CHART_NAME.test(input.name)) {
+    throw new WorkbookError(`chart ${index + 1} needs a "name" of lowercase letters, digits, and hyphens, such as "revenue".`);
+  }
+  const at = `chart '${input.name}'`;
+  if (!SHEET_CHART_TYPES.includes(input.type)) {
+    throw new WorkbookError(`${at} has type ${JSON.stringify(input.type)}; use one of ${SHEET_CHART_TYPES.join(", ")}.`);
+  }
+  const type = input.type;
+  if (typeof input.sheet !== "string" || !sheets.some((sheet) => sheet.name === input.sheet)) {
+    throw new WorkbookError(`${at} names sheet ${JSON.stringify(input.sheet)}, which the workbook does not have.`);
+  }
+  if (typeof input.x !== "string" || !input.x)
+    throw new WorkbookError(`${at} needs an "x" column.`);
+  if (input.aggregate !== undefined && !SHEET_CHART_AGGREGATES.includes(input.aggregate)) {
+    throw new WorkbookError(`${at} "aggregate" is ${JSON.stringify(input.aggregate)}; use one of ${SHEET_CHART_AGGREGATES.join(", ")}.`);
+  }
+  const aggregate = input.aggregate;
+  if (aggregate && type === "scatter") {
+    throw new WorkbookError(`${at} is a scatter chart, which plots every row; leave out "aggregate".`);
+  }
+  const columns = (key) => {
+    const value = input[key];
+    const list = typeof value === "string" ? [value] : value ?? [];
+    if (!Array.isArray(list) || !list.every((column) => typeof column === "string" && column)) {
+      throw new WorkbookError(`${at} "${key}" must be a column, or a list of them.`);
+    }
+    return list;
+  };
+  const y = columns("y");
+  const line = columns("line");
+  if (aggregate === "count") {
+    if (y.length > 0 || line.length > 0) {
+      throw new WorkbookError(`${at} counts rows, which needs no "y"; leave it out.`);
+    }
+  } else if (y.length === 0) {
+    throw new WorkbookError(`${at} needs a "y" column, or a list of them.`);
+  }
+  if (line.length > 0 && type !== "bar") {
+    throw new WorkbookError(`${at} is a ${type} chart; only a bar chart draws "line" columns over its bars.`);
+  }
+  if (y.length + line.length > ARTIFACT_LIMITS2.maxChartSeries) {
+    throw new WorkbookError(`${at} plots ${y.length + line.length} columns; a chart reads well with at most ${ARTIFACT_LIMITS2.maxChartSeries}. Split it, or chart the ones that matter.`);
+  }
+  if (type === "pie" && aggregate !== "count" && y.length !== 1)
+    throw new WorkbookError(`${at} is a pie: give it one "y" column.`);
+  if (input.stacked !== undefined && typeof input.stacked !== "boolean") {
+    throw new WorkbookError(`${at} "stacked" must be true or false.`);
+  }
+  if (input.stacked === true && type !== "bar" && type !== "area") {
+    throw new WorkbookError(`${at} is a ${type} chart; only bar and area charts stack.`);
+  }
+  if (input.title !== undefined && (typeof input.title !== "string" || input.title.length > 120)) {
+    throw new WorkbookError(`${at} "title" must be text of at most 120 characters.`);
+  }
+  return {
+    name: input.name,
+    type,
+    sheet: input.sheet,
+    x: input.x,
+    y,
+    line,
+    ...aggregate ? { aggregate } : {},
+    ...typeof input.title === "string" && input.title.trim() ? { title: input.title.trim() } : {},
+    stacked: input.stacked === true
+  };
+}
+function record3(value, at, keys) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new WorkbookError(`${at} must be an object.`);
+  }
+  const input = value;
+  const unknownKey = keys && Object.keys(input).find((key) => !keys.includes(key));
+  if (unknownKey) {
+    throw new WorkbookError(`${at} has '${unknownKey}'; it takes ${keys.map((key) => `"${key}"`).join(", ")}.`);
+  }
+  return input;
+}
+function integer(value, fallback, min, max, at) {
+  if (value === undefined)
+    return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max) {
+    throw new WorkbookError(`${at} must be a whole number from ${min} to ${max}.`);
+  }
+  return value;
+}
+
+// src/artifacts/formula/check.ts
+var FORMULA_FUNCTIONS = {
+  IF: { min: 2, max: 3 },
+  IFERROR: { min: 2, max: 2 },
+  AND: { min: 1, max: 30 },
+  OR: { min: 1, max: 30 },
+  NOT: { min: 1, max: 1 },
+  ISBLANK: { min: 1, max: 1 },
+  ROUND: { min: 2, max: 2 },
+  ABS: { min: 1, max: 1 },
+  MIN: { min: 1, max: 30 },
+  MAX: { min: 1, max: 30 },
+  SUM: { min: 1, max: 30 },
+  AVERAGE: { min: 1, max: 30 },
+  COUNT: { min: 1, max: 30 },
+  LEN: { min: 1, max: 1 },
+  LOWER: { min: 1, max: 1 },
+  UPPER: { min: 1, max: 1 },
+  CONCAT: { min: 1, max: 30 },
+  YEAR: { min: 1, max: 1 },
+  MONTH: { min: 1, max: 1 },
+  DAYS: { min: 2, max: 2 }
+};
+var AGGREGATE_FUNCTIONS = new Set([
+  "SUM",
+  "AVERAGE",
+  "MIN",
+  "MAX",
+  "COUNT"
+]);
+function checkFormula2(node, columns) {
+  try {
+    return { type: typeOf(node, columns, false) };
+  } catch (error) {
+    if (error instanceof FormulaCheckError)
+      return { error: error.message };
+    throw error;
+  }
+}
+
+class FormulaCheckError extends Error {
+}
+var numeric = (type) => type !== "text";
+function typeOf(node, columns, inAggregate) {
+  switch (node.kind) {
+    case "number":
+      return "number";
+    case "text":
+      return "text";
+    case "boolean":
+      return "boolean";
+    case "ref":
+    case "columnRef": {
+      const type = columns.get(node.column);
+      if (type === undefined) {
+        throw new FormulaCheckError(`it reads column '${node.column}', which the sheet does not have`);
+      }
+      if (node.kind === "columnRef" && !inAggregate) {
+        throw new FormulaCheckError(`[${node.column}] is the whole column, which only ${[...AGGREGATE_FUNCTIONS].join(", ")} take; this row's value is [@${node.column}]`);
+      }
+      return type;
+    }
+    case "unary": {
+      const type = typeOf(node.operand, columns, false);
+      if (!numeric(type))
+        throw new FormulaCheckError(`'${node.op}' needs a number, not text`);
+      return "number";
+    }
+    case "binary": {
+      const left = typeOf(node.left, columns, false);
+      const right = typeOf(node.right, columns, false);
+      switch (node.op) {
+        case "&":
+          return "text";
+        case "=":
+        case "<>":
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+          return "boolean";
+        default: {
+          if (!numeric(left) || !numeric(right)) {
+            throw new FormulaCheckError(`'${node.op}' needs numbers on both sides, not text`);
+          }
+          if (node.op === "+" && left === "date" !== (right === "date"))
+            return "date";
+          if (node.op === "-" && left === "date" && right !== "date")
+            return "date";
+          return "number";
+        }
+      }
+    }
+    case "call": {
+      const shape = FORMULA_FUNCTIONS[node.name];
+      if (!shape) {
+        throw new FormulaCheckError(`${node.name} is not a function a sheet computes; use one of ${Object.keys(FORMULA_FUNCTIONS).join(", ")}`);
+      }
+      if (node.args.length < shape.min || node.args.length > shape.max) {
+        const count = shape.min === shape.max ? `${shape.min}` : shape.max === 30 ? `at least ${shape.min}` : `${shape.min} or ${shape.max}`;
+        throw new FormulaCheckError(`${node.name} takes ${count} ${shape.max === 1 ? "argument" : "arguments"}, not ${node.args.length}`);
+      }
+      const aggregate = AGGREGATE_FUNCTIONS.has(node.name);
+      const args = node.args.map((arg) => typeOf(arg, columns, aggregate));
+      switch (node.name) {
+        case "IF": {
+          const [, then = "boolean", otherwise = "boolean"] = args;
+          return then === otherwise ? then : "any";
+        }
+        case "IFERROR": {
+          const [value = "any", fallback = "any"] = args;
+          return value === fallback ? value : "any";
+        }
+        case "AND":
+        case "OR":
+        case "NOT":
+        case "ISBLANK":
+          return "boolean";
+        case "LOWER":
+        case "UPPER":
+        case "CONCAT":
+          return "text";
+        default:
+          for (const [index, type] of args.entries()) {
+            if (node.name !== "LEN" && !aggregate && !numeric(type)) {
+              throw new FormulaCheckError(`${node.name}'s argument ${index + 1} needs a number, not text`);
+            }
+          }
+          return "number";
+      }
+    }
+  }
+}
+
+// src/artifacts/formula/evaluate.ts
+var FORMULA_ERRORS2 = ["#DIV/0!", "#VALUE!"];
+var isError = (value) => typeof value === "object" && value !== null;
+var fault = (error) => ({ error });
+function evaluateFormula(node, scope, memo = new Map) {
+  const value = (current) => {
+    switch (current.kind) {
+      case "number":
+      case "text":
+      case "boolean":
+        return current.value;
+      case "ref":
+        return scope.cell(current.column);
+      case "columnRef":
+        return fault("#VALUE!");
+      case "unary": {
+        const operand = number(value(current.operand));
+        if (isError(operand))
+          return operand;
+        return current.op === "-" ? -operand : operand;
+      }
+      case "binary":
+        return binary(current.op, value(current.left), value(current.right));
+      case "call": {
+        const constant = AGGREGATE_FUNCTIONS.has(current.name) && current.args.every(isConstant);
+        if (constant && memo.has(current))
+          return memo.get(current);
+        const result = call(current.name, current.args, value, scope);
+        if (constant)
+          memo.set(current, result);
+        return result;
+      }
+    }
+  };
+  return value(node);
+}
+function isConstant(node) {
+  return node.kind === "columnRef" || node.kind === "number" || node.kind === "text";
+}
+function number(value) {
+  if (isError(value))
+    return value;
+  if (value === null)
+    return 0;
+  if (typeof value === "boolean")
+    return value ? 1 : 0;
+  if (typeof value === "number")
+    return value;
+  const trimmed = value.trim();
+  const parsed = trimmed ? Number(trimmed) : Number.NaN;
+  return /^[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?$/i.test(trimmed) && Number.isFinite(parsed) ? parsed : fault("#VALUE!");
+}
+function formulaText(value) {
+  if (value === null)
+    return "";
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  if (typeof value === "number")
+    return String(Number(value.toPrecision(15)));
+  return value;
+}
+function truth(value) {
+  if (isError(value))
+    return value;
+  if (value === null)
+    return false;
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "number")
+    return value !== 0;
+  const word = value.trim().toUpperCase();
+  return word === "TRUE" ? true : word === "FALSE" ? false : fault("#VALUE!");
+}
+var finite = (result) => Number.isFinite(result) ? result : fault("#VALUE!");
+function binary(op, left, right) {
+  if (isError(left))
+    return left;
+  if (isError(right))
+    return right;
+  if (op === "&")
+    return formulaText(left) + formulaText(right);
+  if (op === "=" || op === "<>" || op === "<" || op === "<=" || op === ">" || op === ">=") {
+    const order = compare(left, right);
+    return {
+      "=": order === 0,
+      "<>": order !== 0,
+      "<": order < 0,
+      "<=": order <= 0,
+      ">": order > 0,
+      ">=": order >= 0
+    }[op];
+  }
+  const a = number(left);
+  const b = number(right);
+  if (isError(a))
+    return a;
+  if (isError(b))
+    return b;
+  switch (op) {
+    case "+":
+      return finite(a + b);
+    case "-":
+      return finite(a - b);
+    case "*":
+      return finite(a * b);
+    case "/":
+      return b === 0 ? fault("#DIV/0!") : finite(a / b);
+    case "^":
+      return a === 0 && b < 0 ? fault("#DIV/0!") : finite(a ** b);
+  }
+}
+function compare(left, right) {
+  const blank = (other) => typeof other === "number" ? 0 : typeof other === "boolean" ? false : "";
+  const a = left === null ? blank(right) : left;
+  const b = right === null ? blank(left) : right;
+  const rank = (value) => typeof value === "number" ? 0 : typeof value === "string" ? 1 : 2;
+  if (rank(a) !== rank(b))
+    return rank(a) - rank(b);
+  if (typeof a === "string" && typeof b === "string") {
+    const x = a.toLowerCase();
+    const y = b.toLowerCase();
+    return x < y ? -1 : x > y ? 1 : 0;
+  }
+  return Number(a) - Number(b);
+}
+var EPOCH_SERIAL = 25569;
+var DAY_MS = 86400000;
+function dateSerial(date) {
+  return date.getTime() / DAY_MS + EPOCH_SERIAL;
+}
+function serialDate(serial) {
+  const date = new Date(Math.round((serial - EPOCH_SERIAL) * DAY_MS));
+  const iso = date.toISOString();
+  return Number.isInteger(serial) ? iso.slice(0, 10) : `${iso.slice(0, 19)}Z`;
+}
+function call(name, args, value, scope) {
+  const at = (index) => value(args[index]);
+  switch (name) {
+    case "IF": {
+      const condition = truth(at(0));
+      if (isError(condition))
+        return condition;
+      if (condition)
+        return at(1);
+      return args.length > 2 ? at(2) : false;
+    }
+    case "IFERROR": {
+      const result = at(0);
+      return isError(result) ? at(1) : result;
+    }
+    case "AND":
+    case "OR": {
+      const values = args.map((_, index) => at(index)).filter((entry) => entry !== null);
+      if (values.length === 0)
+        return fault("#VALUE!");
+      let result = name === "AND";
+      for (const entry of values) {
+        const flag = truth(entry);
+        if (isError(flag))
+          return flag;
+        result = name === "AND" ? result && flag : result || flag;
+      }
+      return result;
+    }
+    case "NOT": {
+      const flag = truth(at(0));
+      return isError(flag) ? flag : !flag;
+    }
+    case "ISBLANK":
+      return at(0) === null;
+    case "ROUND": {
+      const x = number(at(0));
+      const digits = number(at(1));
+      if (isError(x))
+        return x;
+      if (isError(digits))
+        return digits;
+      const scale = 10 ** Math.trunc(digits);
+      return Math.sign(x) * Math.round(Number((Math.abs(x) * scale).toPrecision(15))) / scale;
+    }
+    case "ABS": {
+      const x = number(at(0));
+      return isError(x) ? x : Math.abs(x);
+    }
+    case "LEN":
+    case "LOWER":
+    case "UPPER": {
+      const text = at(0);
+      if (isError(text))
+        return text;
+      const written = formulaText(text);
+      return name === "LEN" ? written.length : name === "LOWER" ? written.toLowerCase() : written.toUpperCase();
+    }
+    case "CONCAT": {
+      let text = "";
+      for (const index of args.keys()) {
+        const part = at(index);
+        if (isError(part))
+          return part;
+        text += formulaText(part);
+      }
+      return text;
+    }
+    case "YEAR":
+    case "MONTH": {
+      const serial = number(at(0));
+      if (isError(serial))
+        return serial;
+      if (serial < 0)
+        return fault("#VALUE!");
+      const date = new Date((Math.floor(serial) - EPOCH_SERIAL) * DAY_MS);
+      return name === "YEAR" ? date.getUTCFullYear() : date.getUTCMonth() + 1;
+    }
+    case "DAYS": {
+      const end = number(at(0));
+      const start = number(at(1));
+      if (isError(end))
+        return end;
+      if (isError(start))
+        return start;
+      return Math.floor(end) - Math.floor(start);
+    }
+    default: {
+      const numbers = [];
+      for (const [index, arg] of args.entries()) {
+        const values = arg.kind === "columnRef" ? scope.column(arg.column) : [at(index)];
+        for (const entry of values) {
+          if (isError(entry))
+            return entry;
+          if (typeof entry === "number")
+            numbers.push(entry);
+        }
+      }
+      switch (name) {
+        case "COUNT":
+          return numbers.length;
+        case "SUM":
+          return numbers.reduce((sum, entry) => sum + entry, 0);
+        case "AVERAGE":
+          return numbers.length === 0 ? fault("#DIV/0!") : numbers.reduce((sum, entry) => sum + entry, 0) / numbers.length;
+        case "MIN":
+          return numbers.length === 0 ? 0 : numbers.reduce((min, entry) => Math.min(min, entry));
+        case "MAX":
+          return numbers.length === 0 ? 0 : numbers.reduce((max, entry) => Math.max(max, entry));
+        default:
+          return fault("#VALUE!");
+      }
+    }
+  }
+}
+
+// src/artifacts/formula/index.ts
+function columnFormulaType2(type) {
+  if (NUMERIC_COLUMN_TYPES2.includes(type))
+    return "number";
+  if (type === "date" || type === "boolean")
+    return type;
+  return "text";
+}
+function formulaFitsColumn2(result, type) {
+  if (result === "any" || type === "text" || type === "tag")
+    return true;
+  if (NUMERIC_COLUMN_TYPES2.includes(type))
+    return result === "number";
+  if (type === "date")
+    return result === "date";
+  if (type === "boolean")
+    return result === "boolean";
+  return false;
+}
+
+class FormulaCycleError2 extends Error {
+  columns;
+  constructor(columns) {
+    super(`columns ${columns.map((column) => `'${column}'`).join(" \u2192 ")} compute from each other`);
+    this.columns = columns;
+    this.name = "FormulaCycleError";
+  }
+}
+function evaluateComputedColumns2(sheet, table) {
+  const computed = table.header.filter((name) => sheet.columns[name]?.formula !== undefined);
+  if (computed.length === 0)
+    return { table, errors: new Map };
+  const formulas = new Map(computed.map((name) => [name, parseFormula2(sheet.columns[name]?.formula ?? "")]));
+  const indexOf = new Map(table.header.map((name, index) => [name, index]));
+  const typeOf = (name) => sheet.columns[name]?.type ?? "text";
+  const values = new Map;
+  const columnValues = (name) => {
+    let column = values.get(name);
+    if (!column) {
+      const index = indexOf.get(name) ?? -1;
+      const type = typeOf(name);
+      column = table.rows.map((row) => readCell(row[index] ?? "", type));
+      values.set(name, column);
+    }
+    return column;
+  };
+  const rows = table.rows.map((row) => {
+    const copy = [...row];
+    while (copy.length < table.header.length)
+      copy.push("");
+    return copy;
+  });
+  const errors = new Map;
+  for (const name of computeOrder(formulas)) {
+    const formula = formulas.get(name);
+    const index = indexOf.get(name);
+    const type = typeOf(name);
+    const results = [];
+    const memo = new Map;
+    for (const [rowIndex, row] of rows.entries()) {
+      const result = evaluateFormula(formula, {
+        cell: (column) => columnValues(column)[rowIndex] ?? null,
+        column: (column) => columnValues(column)
+      }, memo);
+      const cell = writeCell(result, type);
+      results.push(typeof cell === "object" ? cell : result);
+      row[index] = typeof cell === "object" ? cell.error : cell;
+      if (typeof cell === "object") {
+        const known = errors.get(name);
+        errors.set(name, {
+          count: (known?.count ?? 0) + 1,
+          firstRow: known?.firstRow ?? rowIndex,
+          code: known?.code ?? cell.error
+        });
+      }
+    }
+    values.set(name, results);
+  }
+  return { table: { header: table.header, rows }, errors };
+}
+function computeOrder(formulas) {
+  const order = [];
+  const state = new Map;
+  const visit = (name, path) => {
+    if (state.get(name) === "done")
+      return;
+    if (state.get(name) === "visiting") {
+      throw new FormulaCycleError2([...path.slice(path.indexOf(name)), name]);
+    }
+    state.set(name, "visiting");
+    for (const dependency of formulaDependencies2(formulas.get(name))) {
+      if (formulas.has(dependency))
+        visit(dependency, [...path, name]);
+    }
+    state.set(name, "done");
+    order.push(name);
+  };
+  for (const name of formulas.keys())
+    visit(name, []);
+  return order;
+}
+function readCell(raw, type) {
+  if (!raw.trim())
+    return null;
+  if (NUMERIC_COLUMN_TYPES2.includes(type))
+    return parseSheetNumber2(raw) ?? raw;
+  if (type === "date") {
+    const date = parseSheetDate2(raw);
+    return date ? dateSerial(date) : raw;
+  }
+  if (type === "boolean") {
+    const word = raw.trim().toLowerCase();
+    return word === "true" ? true : word === "false" ? false : raw;
+  }
+  return raw;
+}
+function writeCell(value, type) {
+  if (typeof value === "object" && value !== null)
+    return value;
+  if (value === null)
+    return "";
+  if (type === "text" || type === "tag")
+    return formulaText(value);
+  if (NUMERIC_COLUMN_TYPES2.includes(type)) {
+    return typeof value === "number" ? formulaText(value) : { error: "#VALUE!" };
+  }
+  if (type === "date") {
+    return typeof value === "number" ? serialDate(value) : { error: "#VALUE!" };
+  }
+  if (type === "boolean") {
+    return typeof value === "boolean" ? String(value) : { error: "#VALUE!" };
+  }
+  return { error: "#VALUE!" };
+}
+
+// src/artifacts/live-sheet.ts
+function sheetColumnType(property) {
+  switch (property.type) {
+    case "integer":
+    case "double":
+    case "decimal":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "timestamp":
+      return "date";
+    case "enum":
+      return property.valueType === "integer" ? "number" : "tag";
+    default:
+      return "text";
+  }
+}
+function liveSheetColumns2(sheet, schema) {
+  const live = sheet.live;
+  if (!live)
+    throw new Error(`[Sixb] Sheet '${sheet.name}' is not a live sheet.`);
+  let problem = null;
+  const formats = {};
+  const totals = { ...sheet.totals };
+  const columns = live.columns.map((source) => {
+    const columnAt = `sheet '${sheet.name}' column '${source.name}'`;
+    const at = `${WORKBOOK_FILE2} ${columnAt}`;
+    const written = sheet.columns[source.name];
+    if (source.from === undefined) {
+      if (written)
+        formats[source.name] = written;
+      return { name: source.name, missing: false };
+    }
+    const [first = "", second] = source.from.split(".");
+    const from = second === undefined ? { propertyId: first } : { linkId: first, propertyId: second };
+    const found = resolveProperty(schema, live.query, from);
+    if ("problem" in found)
+      problem ??= `${at} "from": ${found.problem}`;
+    const inferred = "property" in found ? sheetColumnType(found.property) : undefined;
+    const format = layColumn(columnAt, source.from, written, source.untyped, inferred);
+    if (format.problem)
+      problem ??= format.problem;
+    formats[source.name] = format.format;
+    const total = totals[source.name];
+    const totalProblem = total && source.untyped ? sheetTotalProblem(`${WORKBOOK_FILE2} sheet '${sheet.name}'`, source.name, total, format.format.type) : null;
+    if (totalProblem) {
+      problem ??= totalProblem;
+      delete totals[source.name];
+    }
+    return { name: source.name, from, missing: !("property" in found) };
+  });
+  return { sheet: { ...sheet, columns: formats, totals }, columns, problem };
+}
+function resolveProperty(schema, query, from) {
+  const { linkId, propertyId } = from;
+  if (linkId === undefined) {
+    const property = schema.properties[propertyId];
+    return property ? { property } : {
+      problem: `query '${query}' returns no property '${propertyId}'${known(schema.properties)}.`
+    };
+  }
+  const link = schema.links[linkId];
+  if (!link) {
+    return {
+      problem: `query '${query}' does not expand link '${linkId}': add it to the query's "expand" node, or show a property of the rows.`
+    };
+  }
+  const property = link.properties[propertyId];
+  return property ? { property } : { problem: `link '${linkId}' reaches no property '${propertyId}'${known(link.properties)}.` };
+}
+function known(properties) {
+  const ids = Object.keys(properties);
+  return ids.length > 0 ? `; it has ${ids.join(", ")}` : "";
+}
+function layColumn(columnAt, from, written, untyped, inferred) {
+  if (written) {
+    if (inferred === undefined || fits(written.type, inferred))
+      return { format: written };
+    return {
+      format: written,
+      problem: `${WORKBOOK_FILE2} ${columnAt} is ${written.type}, but '${from}' holds ${HOLDS[inferred]}: leave out "type" to show it as its property is, or show another property.`
+    };
+  }
+  const type = inferred ?? "text";
+  const read = readSheetColumnFormat(untyped ?? {}, columnAt, type);
+  return "format" in read ? read : { format: { type }, problem: read.error };
+}
+var HOLDS = {
+  text: "text",
+  tag: "text",
+  number: "numbers",
+  currency: "numbers",
+  percent: "numbers",
+  date: "dates",
+  boolean: "true or false",
+  link: "text",
+  image: "text"
+};
+function fits(type, inferred) {
+  if (NUMERIC_COLUMN_TYPES2.includes(type))
+    return inferred === "number";
+  if (type === "date" || type === "boolean")
+    return inferred === type;
+  return true;
+}
+function liveSheetTable2(layout, rows) {
+  const { columns } = layout;
+  const locked = new Map;
+  const lock = (row, column) => {
+    const cells = locked.get(row) ?? new Set;
+    cells.add(column);
+    locked.set(row, cells);
+  };
+  const tableRows = rows.map((row, rowIndex) => columns.map((column, columnIndex) => {
+    if (!column.from)
+      return "";
+    if (column.missing) {
+      lock(rowIndex, columnIndex);
+      return "";
+    }
+    const cell = readCell2(row, column.from);
+    if (cell.locked)
+      lock(rowIndex, columnIndex);
+    return cell.locked ? "" : cell.text;
+  }));
+  lockComputed(layout, rows.length, locked);
+  return { table: { header: columns.map((column) => column.name), rows: tableRows }, locked };
+}
+function readCell2(row, from) {
+  const { linkId, propertyId } = from;
+  if (linkId === undefined)
+    return propertyCell(row, propertyId);
+  const linked = row.links?.[linkId];
+  if (!linked)
+    return { text: "", locked: false };
+  if (!isRowList(linked))
+    return propertyCell(linked, propertyId);
+  const values = linked.map((each) => propertyCell(each, propertyId));
+  return {
+    text: values.map((value) => value.text).filter(Boolean).join(", "),
+    locked: values.some((value) => value.locked)
+  };
+}
+function isRowList(value) {
+  return Array.isArray(value);
+}
+function propertyCell(row, propertyId) {
+  if (row.redactions && Object.hasOwn(row.redactions, propertyId)) {
+    return { text: "", locked: true };
+  }
+  return { text: cellText(row.properties[propertyId]), locked: false };
+}
+function cellText(value) {
+  if (value === null || value === undefined)
+    return "";
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Array.isArray(value))
+    return value.map(cellText).filter(Boolean).join(", ");
+  return JSON.stringify(value);
+}
+function lockComputed(layout, rowCount, locked) {
+  const indexOf = new Map(layout.columns.map((column, index) => [column.name, index]));
+  const indexes = (names) => [...names].map((name) => indexOf.get(name)).filter((read) => read !== undefined);
+  const computed = layout.columns.flatMap((column, index) => {
+    const formula = column.from ? undefined : layout.sheet.columns[column.name]?.formula;
+    if (!formula)
+      return [];
+    const { row, whole } = formulaReferences2(parseFormula2(formula));
+    return [{ index, row: indexes(row), whole: indexes(whole) }];
+  });
+  if (computed.length === 0)
+    return;
+  for (let changed = true;changed; ) {
+    changed = false;
+    const anywhere = new Set;
+    for (const cells of locked.values())
+      for (const column of cells)
+        anywhere.add(column);
+    for (const { index, whole } of computed) {
+      if (!whole.some((read) => anywhere.has(read)))
+        continue;
+      for (let row = 0;row < rowCount; row += 1) {
+        const cells = locked.get(row) ?? new Set;
+        if (cells.has(index))
+          continue;
+        cells.add(index);
+        locked.set(row, cells);
+        changed = true;
+      }
+    }
+    for (const cells of locked.values()) {
+      for (const { index, row } of computed) {
+        if (cells.has(index) || !row.some((read) => cells.has(read)))
+          continue;
+        cells.add(index);
+        changed = true;
+      }
+    }
+  }
+}
+
+// src/artifacts/sheet-rules.ts
+function checkSheet2(workbook, tables) {
+  for (const sheet of workbook.sheets) {
+    const table = tables.get(sheet.name);
+    if (!table)
+      continue;
+    const problem = sheetColumnsProblem(sheet, table) ?? sheetFormulasProblem(sheet, table);
+    if (problem)
+      return problem;
+  }
+  return sheetChartsProblem(workbook, tables);
+}
+function sheetColumnsProblem(sheet, table) {
+  const path = sheetFilePath2(sheet.name);
+  const source = sheet.live ? `${WORKBOOK_FILE2} sheet '${sheet.name}' "columns"` : `'${path}'`;
+  const { header, rows } = table;
+  if (header.length === 0)
+    return `'${path}' is empty: its first line names the columns.`;
+  if (header.length > ARTIFACT_LIMITS2.maxSheetColumns) {
+    return `${source} has ${header.length} columns; a sheet holds at most ${ARTIFACT_LIMITS2.maxSheetColumns}.`;
+  }
+  const seen = new Set;
+  for (const [index, name] of header.entries()) {
+    if (!name.trim())
+      return `${source} column ${index + 1} has no name${sheet.live ? "" : " in the header row"}.`;
+    if (seen.has(name))
+      return `${source} has two columns named '${name}'.`;
+    seen.add(name);
+  }
+  if (rows.length > ARTIFACT_LIMITS2.maxSheetRows) {
+    return `'${path}' has ${rows.length} rows; a sheet holds at most ${ARTIFACT_LIMITS2.maxSheetRows}.`;
+  }
+  for (const [index, row] of rows.entries()) {
+    if (row.length > header.length) {
+      return `'${path}' row ${index + 2} has ${row.length} fields; the header names ${header.length} columns.`;
+    }
+  }
+  for (const column of [
+    ...Object.keys(sheet.columns),
+    ...Object.keys(sheet.widths),
+    ...Object.keys(sheet.descriptions),
+    ...Object.keys(sheet.totals)
+  ]) {
+    if (!seen.has(column)) {
+      return `${WORKBOOK_FILE2} sheet '${sheet.name}' names column '${column}', which ${sheet.live ? 'its "columns" does not list' : `'${path}' does not have`}.`;
+    }
+  }
+  return null;
+}
+function sheetFormulasProblem(sheet, table) {
+  const at = (column) => `${WORKBOOK_FILE2} sheet '${sheet.name}' column '${column}'`;
+  const types = new Map(table.header.map((name) => [name, columnFormulaType2(sheet.columns[name]?.type ?? "text")]));
+  for (const [column, format] of Object.entries(sheet.columns)) {
+    if (!format.formula)
+      continue;
+    let node;
+    try {
+      node = parseFormula2(format.formula);
+    } catch (error) {
+      if (error instanceof FormulaSyntaxError) {
+        return `${at(column)} "formula" does not read: ${error.message}`;
+      }
+      throw error;
+    }
+    const checked = checkFormula2(node, types);
+    if ("error" in checked)
+      return `${at(column)} "formula": ${checked.error}.`;
+    if (!formulaFitsColumn2(checked.type, format.type)) {
+      return `${at(column)} "formula" computes ${checked.type === "date" ? "a date" : checked.type === "boolean" ? "true or false" : checked.type === "text" ? "text" : "a number"}, which a ${format.type} column can't show: change its type, or the formula.`;
+    }
+  }
+  try {
+    evaluateComputedColumns2(sheet, { header: table.header, rows: [] });
+  } catch (error) {
+    if (error instanceof FormulaCycleError2) {
+      return `${WORKBOOK_FILE2} sheet '${sheet.name}': ${error.message}, so none can be computed first.`;
+    }
+    throw error;
+  }
+  return null;
+}
+function sheetChartsProblem(workbook, tables) {
+  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;
+    const plotted = [...chart.y, ...chart.line];
+    for (const column of [chart.x, ...plotted]) {
+      if (!table.header.includes(column)) {
+        return `${WORKBOOK_FILE2} chart '${chart.name}' plots column '${column}', which sheet '${chart.sheet}' does not have.`;
+      }
+    }
+    for (const column of chart.type === "scatter" ? [chart.x, ...plotted] : plotted) {
+      const type = sheet.columns[column]?.type ?? "text";
+      if (!NUMERIC_COLUMN_TYPES2.includes(type)) {
+        return `${WORKBOOK_FILE2} chart '${chart.name}' plots column '${column}', which is ${type}; give it a number, currency, or percent type in "columns".`;
+      }
+    }
+    const barType = sheet.columns[chart.y[0] ?? ""]?.type;
+    const rightTypes = new Set(chart.line.map((column) => sheet.columns[column]?.type).filter((type) => type !== barType));
+    if (rightTypes.size > 1) {
+      return `${WORKBOOK_FILE2} chart '${chart.name}' draws lines of ${[...rightTypes].join(" and ")} over ${barType ?? "its"} bars; the right axis reads one kind. Chart the others separately.`;
+    }
+    if (chart.type === "pie") {
+      const index = table.header.indexOf(chart.x);
+      const slices = chart.aggregate ? new Set(table.rows.map((row) => (row[index] ?? "").trim())).size : table.rows.length;
+      if (slices > ARTIFACT_LIMITS2.maxPieSlices) {
+        return `${WORKBOOK_FILE2} chart '${chart.name}' is a pie with ${slices} slices; a pie reads well with at most ${ARTIFACT_LIMITS2.maxPieSlices}. Use a bar chart instead.`;
+      }
+    }
+  }
+  return null;
+}
+
+export { ARTIFACT_THEME_FILE2, ARTIFACT_THEME_TOKENS, parseArtifactTheme2, ARTIFACT_QUERIES_DIRECTORY, ARTIFACT_QUERY_KINDS, isArtifactQueryName, artifactQueryPath, artifactQueryName2, parseArtifactQuery, resolveArtifactAddress2, ARTIFACT_TONES2, CANVAS_FILE2, parseCanvas2, createHeadingSlugger2, CsvParseError2, parseCsv2, formatCsv2, parseFormula2, formulaDependencies2, formulaReferences2, renameColumnReferences2, WORKBOOK_FILE2, SHEET_COLUMN_TYPES2, NUMERIC_COLUMN_TYPES2, SHEET_HIGHLIGHTS2, SHEET_TOTALS2, sheetFilePath2, parseWorkbook2, parseSheetNumber2, parseSheetDate2, checkFormula2, FORMULA_ERRORS2, columnFormulaType2, formulaFitsColumn2, FormulaCycleError2, evaluateComputedColumns2, liveSheetColumns2, liveSheetTable2, checkSheet2, sheetColumnsProblem, sheetFormulasProblem, sheetChartsProblem };
+
+//# debugId=B716461C2DF6F0DA64756E2164756E21