mulmoclaude 2.7.0 → 2.8.1

package/src/plugins/spreadsheet/engine/index.ts

@@ -1,34 +0,0 @@
-/**
- * Spreadsheet Engine
- *
- * Framework-agnostic spreadsheet calculation engine
- */
-
-// Export types
-export * from "./types";
-
-// Export utilities
-export * from "./parser";
-export * from "./condition";
-export * from "./date-locale";
-export * from "./cellEmpty";
-export * from "./datedif";
-export * from "./formatter";
-export * from "./translateFormula";
-export * from "./formulaError";
-export * from "./spreadsheet-errors";
-export * from "./evaluator";
-export * from "./calculator";
-export * from "./formulaRefs";
-export * from "./cellBuilder";
-export * from "./responseDecoder";
-export * from "./jsonCellLocator";
-
-// Export function registry
-export * from "./registry";
-
-// Load all built-in functions
-import "./functions";
-
-// Export main SpreadsheetEngine class
-export { SpreadsheetEngine } from "./engine";

package/src/plugins/spreadsheet/engine/jsonCellLocator.ts

@@ -1,111 +0,0 @@
-/**
- * Locate the start offset of a specific cell value inside a
- * pretty-printed JSON spreadsheet document. Extracted from
- * `handleTableClick` in `src/plugins/spreadsheet/View.vue` where the
- * inline scanner pushed cognitive complexity to 163.
- *
- * The scanner walks the raw editor text character-by-character,
- * tracking string boundaries, bracket depth, and object depth to
- * find the n-th cell of the m-th row within a named sheet's `data`
- * array. We deliberately do NOT parse the JSON — we need the
- * character offset inside the user's text buffer (which may not be
- * valid JSON mid-edit), so a positional scan is required.
- *
- * Pure — no refs, no DOM. Returns -1 if the cell can't be located.
- * Tested in `test/plugins/spreadsheet/engine/test_jsonCellLocator.ts`.
- */
-
-// Advance `pos` through `text` until we reach the `rowIndex`-th
-// opening `[` after `startPos` (counting from -1 so the first `[`
-// encountered is index 0). Returns the position just after that
-// opening bracket, or -1 if we ran off the end.
-function findRowOpenBracket(text: string, startPos: number, rowIndex: number): number {
-  let currentRow = -1;
-  let inString = false;
-  for (let i = startPos; i < text.length; i++) {
-    const c = text[i];
-    const prevChar = i > 0 ? text[i - 1] : "";
-    // Track string literal boundaries so that a `[` inside a cell
-    // value like `"has [bracket]"` doesn't get mistaken for a row
-    // opener and throw off the row offset.
-    if (c === '"' && prevChar !== "\\") {
-      inString = !inString;
-      continue;
-    }
-    if (!inString && c === "[") {
-      currentRow++;
-      if (currentRow === rowIndex) return i + 1;
-    }
-  }
-  return -1;
-}
-
-// Starting just inside the row's `[`, scan for the start offset of
-// the `colIndex`-th cell. Tracks string/object/bracket state so
-// commas inside cell objects don't miscounted as cell separators.
-// Returns -1 if the row ends before we reach colIndex.
-function findCellStartWithinRow(text: string, rowStart: number, colIndex: number): number {
-  let currentCol = 0;
-  let inString = false;
-  let inObject = 0;
-  let bracketDepth = 1; // we already stepped past one `[`
-
-  for (let i = rowStart; i < text.length; i++) {
-    const c = text[i];
-    const prevChar = i > 0 ? text[i - 1] : "";
-
-    if (c === '"' && prevChar !== "\\") {
-      inString = !inString;
-    }
-
-    if (!inString) {
-      if (c === "[") bracketDepth++;
-      if (c === "]") {
-        bracketDepth--;
-        if (bracketDepth === 0) return -1; // row ended before colIndex
-      }
-      if (c === "{") inObject++;
-      if (c === "}") inObject--;
-      if (c === "," && inObject === 0 && bracketDepth === 1) {
-        currentCol++;
-      }
-    }
-
-    // Once currentCol matches, skip any structural whitespace /
-    // opening bracket / comma and return the first content char.
-    if (currentCol === colIndex) {
-      if (c !== " " && c !== "\n" && c !== "\t" && c !== "[" && c !== ",") {
-        return i;
-      }
-    }
-  }
-  return -1;
-}
-
-/**
- * Given the pretty-printed JSON editor text, a sheet name, and
- * (rowIndex, colIndex), return the character offset of that cell's
- * JSON token. The returned offset can be fed into
- * `textarea.setSelectionRange(offset, offset + cellJsonLength)` to
- * highlight the cell.
- *
- * Returns -1 if the sheet isn't found or the (row, col) is out of
- * range. Never throws.
- */
-export function findCellJsonPosition(editorText: string, sheetName: string, rowIndex: number, colIndex: number): number {
-  // JSON.stringify escapes embedded quotes/backslashes so the marker
-  // matches the way the sheet name actually appears in editorText.
-  const sheetStartMarker = `"name": ${JSON.stringify(sheetName)}`;
-  const dataStartMarker = `"data": [`;
-
-  const sheetPos = editorText.indexOf(sheetStartMarker);
-  if (sheetPos === -1) return -1;
-
-  const dataPos = editorText.indexOf(dataStartMarker, sheetPos);
-  if (dataPos === -1) return -1;
-
-  const rowStart = findRowOpenBracket(editorText, dataPos + dataStartMarker.length, rowIndex);
-  if (rowStart === -1) return -1;
-
-  return findCellStartWithinRow(editorText, rowStart, colIndex);
-}

package/src/plugins/spreadsheet/engine/math-ops.ts

@@ -1,98 +0,0 @@
-/**
- * Rounding, modulo and significance math for the mathematical functions.
- *
- * Pure number-in / (number | formula-error-value)-out helpers. The rounding
- * direction and the domain rules are exactly where the engine diverged from
- * Excel (rounding toward +∞ instead of away from zero, modulo taking the
- * dividend's sign, negative bases and domains slipping through as NaN/∞), so
- * they are worth testing apart from the argument-reading handlers.
- */
-
-import { DIV_ZERO_ERROR, NUM_ERROR, isSpreadsheetErrorValue, type SpreadsheetError } from "./spreadsheet-errors";
-
-const DECIMAL_BASE = 10;
-
-const scale = (digits: number): number => Math.pow(DECIMAL_BASE, digits);
-
-/** Excel ROUND: half away from zero (JS `Math.round` breaks half toward +∞, so
- *  `ROUND(-2.5, 0)` came back -2 instead of -3). */
-export function roundTo(value: number, digits: number): number {
-  const factor = scale(digits);
-  return (Math.sign(value) * Math.round(Math.abs(value) * factor)) / factor;
-}
-
-/** Excel ROUNDUP: away from zero. */
-export function roundUpTo(value: number, digits: number): number {
-  const factor = scale(digits);
-  return (Math.sign(value) * Math.ceil(Math.abs(value) * factor)) / factor;
-}
-
-/** Excel ROUNDDOWN: toward zero. */
-export function roundDownTo(value: number, digits: number): number {
-  const factor = scale(digits);
-  return (Math.sign(value) * Math.floor(Math.abs(value) * factor)) / factor;
-}
-
-/** Whether `value` and `significance` point the same way; opposite signs are the
- *  #NUM! case for FLOOR / CEILING. A zero value is always in range. */
-const sameSign = (value: number, significance: number): boolean => value === 0 || Math.sign(value) === Math.sign(significance);
-
-/** Excel FLOOR: nearest multiple of `significance` toward zero; opposite signs
- *  are #NUM!, and a zero significance is #DIV/0! — the division by the
- *  significance is what FLOOR reports, so it wins over the sign check. */
-export function floorToSignificance(value: number, significance: number): number | SpreadsheetError {
-  if (significance === 0) return DIV_ZERO_ERROR;
-  if (!sameSign(value, significance)) return NUM_ERROR;
-  return Math.floor(value / significance) * significance;
-}
-
-/** Excel CEILING: nearest multiple of `significance` away from zero; opposite
- *  signs are #NUM!, and a zero significance is 0 — deliberately NOT FLOOR's
- *  #DIV/0!, an asymmetry Excel keeps and this engine has to match. */
-export function ceilingToSignificance(value: number, significance: number): number | SpreadsheetError {
-  if (significance === 0) return 0;
-  if (!sameSign(value, significance)) return NUM_ERROR;
-  return Math.ceil(value / significance) * significance;
-}
-
-/** Excel MOD: result takes the divisor's sign (`MOD(-3, 2) === 1`); dividing by
- *  zero is #DIV/0!, not a silent 0. */
-export function modulo(value: number, divisor: number): number | SpreadsheetError {
-  if (divisor === 0) return DIV_ZERO_ERROR;
-  return value - divisor * Math.floor(value / divisor);
-}
-
-/** Excel POWER: a negative base with a non-integer exponent has no real root, so
- *  it is #NUM! rather than JS's NaN. */
-export function power(base: number, exponent: number): number | SpreadsheetError {
-  if (base < 0 && !Number.isInteger(exponent)) return NUM_ERROR;
-  return Math.pow(base, exponent);
-}
-
-/** Natural log guarded to its domain: `LN(x)` for `x <= 0` is #NUM!, not
- *  -∞ / NaN. Reused by LN and LOG. */
-export function safeLog(value: number): number | SpreadsheetError {
-  if (value <= 0) return NUM_ERROR;
-  return Math.log(value);
-}
-
-/** Excel LOG(value, base): the base must also be positive and not 1, or the
- *  result is #NUM! rather than the ∞ / NaN a bare division would give. */
-export function logWithBase(value: number, base: number): number | SpreadsheetError {
-  const lnValue = safeLog(value);
-  if (isSpreadsheetErrorValue(lnValue)) return lnValue;
-  if (base <= 0 || base === 1) return NUM_ERROR;
-  return lnValue / Math.log(base);
-}
-
-/** Base-10 log guarded to its domain (`LOG10(x)` for `x <= 0` is #NUM!). */
-export function safeLog10(value: number): number | SpreadsheetError {
-  if (value <= 0) return NUM_ERROR;
-  return Math.log10(value);
-}
-
-/** Square root guarded to its domain (`SQRT(x)` for `x < 0` is #NUM!, not NaN). */
-export function safeSqrt(value: number): number | SpreadsheetError {
-  if (value < 0) return NUM_ERROR;
-  return Math.sqrt(value);
-}

package/src/plugins/spreadsheet/engine/numericCoercion.ts

@@ -1,61 +0,0 @@
-/**
- * Numeric coercion helpers for the spreadsheet engine.
- *
- * Two intentionally different reads share one string parser (`parseNumericString`):
- *  - `registry.toNumber` — lenient, for range aggregation (SUM / AVERAGE / …):
- *    anything unreadable becomes 0. PINNED (booleans are 0, not Excel's 1/0).
- *  - `toScalarNumber` — strict, for single-value math functions (ABS / SIGN):
- *    booleans are 1/0 and non-numeric text is `#VALUE!`, matching Excel.
- *
- * `holdsNumber` asks the question neither read can answer once it has coerced:
- * was there a number here at all, or is this 0 the reading of something else.
- */
-
-import type { CellValue } from "./types";
-import { VALUE_ERROR, type SpreadsheetError } from "./spreadsheet-errors";
-
-const numberOrNull = (num: number): number | null => (isNaN(num) ? null : num);
-
-/**
- * Parse a spreadsheet string as a number, or `null` when it holds no number.
- *
- * Mirrors the engine's long-standing lenient read: a percentage, a currency
- * amount, or a thousands-separated value, else a bare `parseFloat` (which reads a
- * leading number out of "12abc"). The branch order is load-bearing — each strips
- * only its own characters, so a string mixing "%" and "$" fails in the first.
- */
-export function parseNumericString(value: string): number | null {
-  if (value.includes("%")) {
-    const num = numberOrNull(parseFloat(value.replace("%", "").trim()));
-    return num === null ? null : num / 100;
-  }
-  if (value.includes("$")) return numberOrNull(parseFloat(value.replace(/[$,]/g, "").trim()));
-  if (value.includes(",")) return numberOrNull(parseFloat(value.replace(/,/g, "").trim()));
-  return numberOrNull(parseFloat(value));
-}
-
-/**
- * Whether a value holds a number at all, under the same reading `toNumber` uses.
- *
- * `toNumber` answers 0 for text, for a boolean and for a genuine 0 alike, so a
- * caller that must tell "no number here" from "the number zero" — COUNT — cannot
- * ask it. Booleans are not numbers here, matching `toNumber`'s PINNED behaviour.
- */
-export function holdsNumber(value: CellValue): boolean {
-  if (typeof value === "number") return !isNaN(value);
-  if (typeof value !== "string") return false;
-  return parseNumericString(value) !== null;
-}
-
-/**
- * Strict scalar coercion for single-value math functions (ABS, SIGN). Follows
- * Excel's scalar rules: a boolean is 1 / 0 and genuinely non-numeric text is
- * `#VALUE!` rather than a silent 0. A partly-numeric string still yields its
- * leading number, matching the engine's other numeric reads.
- */
-export function toScalarNumber(value: CellValue): number | SpreadsheetError {
-  if (typeof value === "number") return value;
-  if (typeof value === "boolean") return value ? 1 : 0;
-  if (typeof value !== "string") return value;
-  return parseNumericString(value) ?? VALUE_ERROR;
-}

package/src/plugins/spreadsheet/engine/parser.ts

@@ -1,40 +0,0 @@
-/**
- * Cell and Range Reference Parsing
- *
- * Handles Excel A1 notation parsing and conversion
- */
-
-import type { CellRef, RangeRef } from "./types";
-
-/**
- * Convert Excel column letters to 0-based index
- * A=0, B=1, ..., Z=25, AA=26, etc.
- *
- * @param col - Column letters (e.g., "A", "Z", "AA")
- * @returns 0-based column index
- */
-export function columnToIndex(col: string): number {
-  let result = 0;
-  for (let i = 0; i < col.length; i++) {
-    result = result * 26 + (col.charCodeAt(i) - 64); // A=1, B=2, etc.
-  }
-  return result - 1; // Convert to 0-based
-}
-
-/**
- * Convert 0-based index to Excel column letters
- * 0=A, 1=B, ..., 25=Z, 26=AA, etc.
- *
- * @param index - 0-based column index
- * @returns Column letters (e.g., "A", "Z", "AA")
- */
-export function indexToColumn(index: number): string {
-  let col = "";
-  let num = index + 1; // Convert to 1-based
-  while (num > 0) {
-    const remainder = (num - 1) % 26;
-    col = String.fromCharCode(65 + remainder) + col;
-    num = Math.floor((num - 1) / 26);
-  }
-  return col;
-}

package/src/plugins/spreadsheet/engine/registry.ts

@@ -1,201 +0,0 @@
-/**
- * Spreadsheet Function Registry
- *
- * This module provides a registry system for spreadsheet functions,
- * allowing modular organization and easy extension of formula capabilities.
- */
-
-import type { CellValue } from "./types";
-import { parseNumericString } from "./numericCoercion";
-export type { CellValue };
-export type CellGetter = (ref: string) => CellValue;
-export type RangeGetter = (range: string) => CellValue[];
-export type RawRangeGetter = (range: string) => CellValue[];
-
-export interface FunctionContext {
-  /** The registry name the formula invoked, so a handler can report a failure
-   *  the way the evaluator names it. */
-  functionName: string;
-  getCellValue: CellGetter;
-  getRangeValues: RangeGetter;
-  getRangeValuesRaw?: RawRangeGetter | undefined;
-  evaluateFormula: (formula: string) => CellValue;
-}
-
-/** The too-few-arguments error, raised by the evaluator from the registry's
- *  `minArgs` before any handler runs — and by `requiredArg` for the argument a
- *  handler actually reads, so both report one wording. */
-export const tooFewArgumentsError = (funcName: string, minArgs: number): Error =>
-  new Error(`${funcName} requires at least ${minArgs} argument${minArgs !== 1 ? "s" : ""}`);
-
-/** The argument at `index`, which the caller has already established is there —
- *  the registry's `minArgs` for a mandatory argument, an `args.length` branch for
- *  an optional one. An absent one means that guarantee is wrong, so it raises the
- *  arity error the guarantee should have raised. Never a default value: a
- *  substituted 0 or "" computes a plausible wrong answer, which is worse than
- *  the error the formula deserves. */
-export const requiredArg = (context: FunctionContext, args: string[], index: number): string => {
-  const arg = args[index];
-  if (arg === undefined) throw tooFewArgumentsError(context.functionName, index + 1);
-  return arg;
-};
-
-/** The range reader that keeps every cell, for functions whose answer depends on
- *  a range's POSITIONS rather than its numbers.
- *
- *  `getRangeValues` drops non-numeric cells, which silently renumbers the rows
- *  underneath: a criteria/value pair read that way falls out of alignment and
- *  aggregates a different row, and an index returned from it points at the wrong
- *  one. SUMIF/AVERAGEIF were moved here in #2358; MATCH/XLOOKUP in #2765.
- *
- *  Falls back to the numeric reader because `getRangeValuesRaw` is optional on
- *  `FunctionContext` — a host that predates it keeps its old behaviour rather
- *  than throwing. */
-export const rawRangeReader = (context: FunctionContext): RangeGetter => context.getRangeValuesRaw ?? context.getRangeValues;
-
-export type FunctionHandler = (args: string[], context: FunctionContext) => CellValue;
-
-export interface FunctionDefinition {
-  name: string;
-  handler: FunctionHandler;
-  minArgs?: number;
-  maxArgs?: number;
-  description?: string;
-  examples?: string[];
-  category?: string;
-}
-
-class FunctionRegistry {
-  private functions = new Map<string, FunctionDefinition>();
-
-  register(def: FunctionDefinition): void {
-    this.functions.set(def.name.toUpperCase(), def);
-  }
-
-  get(name: string): FunctionDefinition | undefined {
-    return this.functions.get(name.toUpperCase());
-  }
-
-  hasFunction(name: string): boolean {
-    return this.functions.has(name.toUpperCase());
-  }
-
-  getAllFunctions(): FunctionDefinition[] {
-    return Array.from(this.functions.values());
-  }
-
-  getFunctionsByCategory(): Map<string, FunctionDefinition[]> {
-    const categories = new Map<string, FunctionDefinition[]>();
-
-    for (const func of Array.from(this.functions.values())) {
-      const category = func.category || "Other";
-      if (!categories.has(category)) {
-        categories.set(category, []);
-      }
-      categories.get(category)!.push(func);
-    }
-
-    return categories;
-  }
-}
-
-export const functionRegistry = new FunctionRegistry();
-
-/** Whether `name` written before "(" is a function call. A letters-only name is,
- *  registered or not (an unknown one reports #NAME?). A name with digits is only
- *  when registered: LOG10 is also shaped like a cell reference, so `A1(2)` is not. */
-export const isCallableName = (name: string): boolean => /^[A-Z]+$/i.test(name) || functionRegistry.hasFunction(name);
-
-/**
- * Lenient numeric coercion for range aggregation: anything unreadable is 0.
- * PINNED behaviour (booleans are 0, not Excel's 1/0) — the string parsing lives
- * in numericCoercion.parseNumericString, shared with the strict scalar read.
- */
-export function toNumber(value: CellValue): number {
-  if (typeof value === "number") return value;
-  return parseNumericString(String(value)) ?? 0;
-}
-
-/**
- * Helper function to convert a value to a string
- */
-export function toString(value: CellValue): string {
-  return String(value);
-}
-
-const REGEXP_METACHARACTERS = /[.*+?^${}()|[\]\\]/;
-
-const escapeRegExpChar = (char: string): string => (REGEXP_METACHARACTERS.test(char) ? `\\${char}` : char);
-
-// One criteria token: `~x` (an escaped character) or any single character. The
-// escape branch needs a following character, so a TRAILING `~` falls through to
-// the single-character branch and stands for itself.
-const CRITERIA_TOKEN = /~([\s\S])|[\s\S]/g;
-
-const criteriaRegexSource = (pattern: string): string =>
-  pattern.replace(CRITERIA_TOKEN, (token, escaped: string | undefined) => {
-    if (escaped !== undefined) return escapeRegExpChar(escaped);
-    if (token === "*") return ".*";
-    if (token === "?") return ".";
-    return escapeRegExpChar(token);
-  });
-
-/**
- * Match text the way a spreadsheet criteria does: case-insensitively, with `*`
- * standing for any run of characters, `?` for exactly one, and `~` escaping the
- * next character. A plain `String(v) === criteria` missed both — `COUNTIF(range,
- * "yes")` skipped a cell holding `Yes`, and `"A*"` was compared literally.
- */
-function textMatcher(pattern: string): (text: string) => boolean {
-  const regex = new RegExp(`^${criteriaRegexSource(pattern)}$`, "iu");
-  return (text) => regex.test(text);
-}
-
-/**
- * Helper to parse criteria for conditional functions like COUNTIF, SUMIF
- * Returns a comparison function that tests if a value matches the criteria
- */
-export function parseCriteria(criteria: string): (value: CellValue) => boolean {
-  // eslint-disable -- sonarjs/anchor-precedence
-  const trimmedCriteria = criteria.trim().replace(/^["']|["']$/g, "");
-
-  // Check for comparison operators
-  // eslint-disable -- sonarjs/slow-regex
-  const [, op, value] = trimmedCriteria.match(/^([><=!]+)(.+)$/) ?? [];
-  if (op !== undefined && value !== undefined) {
-    const numValue = parseFloat(value);
-
-    // `=` / `<>` compare like the bare criteria does — case-insensitive text
-    // with wildcards, or the number. `<>` is exactly its negation.
-    const equals = matchesTextOrNumber(value);
-    switch (op) {
-      case ">":
-        return (v) => toNumber(v) > numValue;
-      case ">=":
-        return (v) => toNumber(v) >= numValue;
-      case "<":
-        return (v) => toNumber(v) < numValue;
-      case "<=":
-        return (v) => toNumber(v) <= numValue;
-      case "=":
-      case "==":
-        return equals;
-      case "!=":
-      case "<>":
-        return (v) => !equals(v);
-      default:
-        return () => false;
-    }
-  }
-
-  return matchesTextOrNumber(trimmedCriteria);
-}
-
-/** A value matches when its text matches the criteria (case-insensitively, with
- *  wildcards) or, for a numeric criteria, when its number is equal. */
-function matchesTextOrNumber(criteria: string): (value: CellValue) => boolean {
-  const matchesText = textMatcher(criteria);
-  const numCriteria = parseFloat(criteria);
-  const hasNumber = !isNaN(numCriteria);
-  return (value) => matchesText(String(value)) || (hasNumber && toNumber(value) === numCriteria);
-}

package/src/plugins/spreadsheet/engine/responseDecoder.ts

@@ -1,68 +0,0 @@
-/**
- * Decode the `/api/files/content` response for a spreadsheet file
- * into an "ok with sheets" / "error with message" discriminated
- * union. Extracted from `fetchSheets` in
- * `src/plugins/spreadsheet/View.vue` where the decision tree was
- * inlined as several nested try/catch + if branches.
- *
- * Pure — no fetch, no refs. Takes the parsed JSON body and returns
- * a result the caller can pattern-match on. Tested in
- * `test/plugins/spreadsheet/engine/test_responseDecoder.ts`.
- */
-
-import type { SheetData } from "./types.js";
-import { errorMessage } from "../../../utils/errors";
-
-/** Shape of the `/api/files/content` response we care about. The
- *  server returns more fields (kind, size, modifiedMs, …) but this
- *  decoder only depends on the three that drive branching. */
-export interface FilesContentResponseLike {
-  kind?: string;
-  content?: string;
-  message?: string;
-}
-
-export type DecodeResult = { kind: "ok"; sheets: SheetData[] } | { kind: "error"; message: string };
-
-/**
- * Turn a parsed `/files/content` body into an OK/error decision:
- *
- * - `kind` present and not "text" → error with the server's message
- *   (e.g. "too-large", "binary"). Spreadsheets only live in text
- *   JSON files.
- * - Missing or non-string `content` → error.
- * - `content` is not valid JSON → error.
- * - Parsed `content` is not an array → error (server should never
- *   return a non-array but the guard protects downstream render).
- * - Otherwise → ok with the sheets array.
- */
-export function decodeSpreadsheetResponse(body: FilesContentResponseLike): DecodeResult {
-  if (body.kind && body.kind !== "text") {
-    return {
-      kind: "error",
-      message: body.message ?? `Cannot load spreadsheet: ${body.kind}`,
-    };
-  }
-  if (typeof body.content !== "string") {
-    return { kind: "error", message: "Spreadsheet file has no content" };
-  }
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(body.content);
-  } catch (err) {
-    return {
-      kind: "error",
-      message: `Spreadsheet JSON is malformed: ${errorMessage(err, "parse error")}`,
-    };
-  }
-  if (!Array.isArray(parsed)) {
-    return {
-      kind: "error",
-      message: "Spreadsheet content is not an array of sheets",
-    };
-  }
-  // Array.isArray narrows to unknown[]; we trust the server contract
-  // and type the local explicitly rather than using an inline `as`.
-  const sheets: SheetData[] = parsed;
-  return { kind: "ok", sheets };
-}