@particle-academy/holy-sheet 2.4.1 → 2.4.3

package/dist/index.cjs

@@ -177,7 +177,7 @@ var CsvBuilder = {
     return ArrayBuilder.build(dataRows, headers, sheetName2, options);
   }
 };
-function parseRows(csv, delimiter, quote) {
+function parseRows(csv, delimiter, quote2) {
   const rows = [];
   let field = "";
   let row = [];
@@ -197,9 +197,9 @@ function parseRows(csv, delimiter, quote) {
   for (let i = 0; i < csv.length; i++) {
     const ch = csv[i];
     if (inQuotes) {
-      if (ch === quote) {
-        if (csv[i + 1] === quote) {
-          field += quote;
+      if (ch === quote2) {
+        if (csv[i + 1] === quote2) {
+          field += quote2;
           i++;
         } else {
           inQuotes = false;
@@ -209,7 +209,7 @@ function parseRows(csv, delimiter, quote) {
       }
       continue;
     }
-    if (ch === quote) {
+    if (ch === quote2) {
       inQuotes = true;
       started = true;
       continue;
@@ -287,6 +287,39 @@ var Cell = class {
   }
 };
 
+// src/schema/column-widths.ts
+var ColumnWidths = {
+  MAX_INDEX: 16383,
+  index(key) {
+    if (typeof key === "number") {
+      return Number.isInteger(key) && key >= 0 && key <= ColumnWidths.MAX_INDEX ? key : null;
+    }
+    if (typeof key === "string" && /^[0-9]{1,5}$/.test(key)) {
+      const index = parseInt(key, 10);
+      return index <= ColumnWidths.MAX_INDEX ? index : null;
+    }
+    return null;
+  },
+  width(px) {
+    if (typeof px === "number") {
+      return Number.isFinite(px) && px >= 0 ? px : null;
+    }
+    if (typeof px === "string" && /^[0-9]+(\.[0-9]+)?$/.test(px)) {
+      return Number(px);
+    }
+    return null;
+  },
+  /**
+   * A column letter key (`"B"`, `"aa"`) as an index, for repair only. One or two
+   * letters (A to ZZ): a longer run like `"abc"` is more likely a mistake than
+   * column ABC, and a repair must not guess.
+   */
+  fromLetters(key) {
+    if (typeof key !== "string" || !/^[A-Za-z]{1,2}$/.test(key.trim())) return null;
+    return CellAddress.index(key.trim());
+  }
+};
+
 // src/workbook/cell-comment.ts
 var CellComment = class {
   constructor(text, author = null, color2 = null) {
@@ -631,7 +664,10 @@ var Normalizer = class {
   normalizeColumnWidths(widths) {
     const out = /* @__PURE__ */ new Map();
     for (const [key, px] of Object.entries(widths)) {
-      out.set(parseInt(key, 10), Number(px));
+      const index = ColumnWidths.index(key);
+      const width = ColumnWidths.width(px);
+      if (index === null || width === null) continue;
+      out.set(index, width);
     }
     return out;
   }
@@ -1329,6 +1365,30 @@ var Repairer = class {
       sheet.theme = "default";
       this.repairs.push(`changed '${path}.theme' from '${original}' to 'default' (unknown theme)`);
     }
+    if (sheet.columnWidths != null && (isPlainObject(sheet.columnWidths) || Array.isArray(sheet.columnWidths))) {
+      const widths = {};
+      let changed = false;
+      for (const [key, px] of Object.entries(sheet.columnWidths)) {
+        let index = ColumnWidths.index(key);
+        if (index === null) {
+          const letters = ColumnWidths.fromLetters(key);
+          if (letters !== null) {
+            index = letters;
+            this.repairs.push(`converted '${path}.columnWidths.${key}' to column index ${index}`);
+            changed = true;
+          }
+        }
+        if (index === null || ColumnWidths.width(px) === null) {
+          this.repairs.push(`dropped '${path}.columnWidths.${key}' (not a column index and a width)`);
+          changed = true;
+          continue;
+        }
+        widths[String(index)] = px;
+      }
+      if (changed) {
+        sheet.columnWidths = widths;
+      }
+    }
     if (sheet.cells != null && isPlainObject(sheet.cells)) {
       const cleaned = {};
       let changed = false;
@@ -1534,6 +1594,43 @@ var Validator = class {
         )
       );
     }
+    if (sheet.columnWidths != null) {
+      if (!isPlainObject(sheet.columnWidths) && !Array.isArray(sheet.columnWidths)) {
+        errors.push(
+          error(
+            `${path}.columnWidths`,
+            "object keyed by 0-based column index",
+            typeOf(sheet.columnWidths),
+            sheet.columnWidths,
+            'Column widths map a 0-based column index to pixels: {"0": 120, "1": 80}.'
+          )
+        );
+      } else {
+        for (const [key, px] of Object.entries(sheet.columnWidths)) {
+          if (ColumnWidths.index(key) === null) {
+            errors.push(
+              error(
+                `${path}.columnWidths.${key}`,
+                `a 0-based column index from 0 to ${ColumnWidths.MAX_INDEX}`,
+                typeOf(key),
+                key,
+                'Keys are 0-based column indexes: "0" is column A, "1" is column B. Use the index, not the letter.'
+              )
+            );
+          } else if (ColumnWidths.width(px) === null) {
+            errors.push(
+              error(
+                `${path}.columnWidths.${key}`,
+                "a non-negative number of pixels",
+                typeOf(px),
+                px,
+                "A width is a number of pixels, like 120."
+              )
+            );
+          }
+        }
+      }
+    }
     return errors;
   }
   validateColumn(col, path) {
@@ -2682,13 +2779,13 @@ function unescapeXml(s) {
   });
 }
 function findTagEnd(src, from) {
-  let quote = "";
+  let quote2 = "";
   for (let i = from; i < src.length; i++) {
     const ch = src[i];
-    if (quote) {
-      if (ch === quote) quote = "";
+    if (quote2) {
+      if (ch === quote2) quote2 = "";
     } else if (ch === '"' || ch === "'") {
-      quote = ch;
+      quote2 = ch;
     } else if (ch === ">") {
       return i;
     }
@@ -3836,16 +3933,132 @@ function phpString(value) {
   if (isArr(value)) return "Array";
   return String(value);
 }
+function phpTrim2(value) {
+  return value.replace(/^[ \t\n\r\x00\x0B]+|[ \t\n\r\x00\x0B]+$/g, "");
+}
+function phpInteger(value) {
+  if (typeof value === "number") {
+    return Number.isInteger(value) && Math.abs(value) <= 2 ** 63 ? value || 0 : null;
+  }
+  return typeof value === "string" && /^[0-9]+$/.test(value) ? phpInt2(value) : null;
+}
+function isIndexKey(key) {
+  return /^[0-9]+$/.test(key) || /^-[1-9][0-9]*$/.test(key) && BigInt(key) >= -(2n ** 63n);
+}
 function asciiUpper(value) {
   return value.replace(/[a-z]+/g, (s) => s.toUpperCase());
 }
 function parseAddress(address) {
-  const m = /^([A-Z]+)(\d+)$/.exec(asciiUpper(address.replace(/^[ \t\n\r\v\0]+|[ \t\n\r\v\0]+$/g, "")));
+  const m = /^([A-Z]+)(\d+)$/.exec(asciiUpper(phpTrim2(address)));
   if (!m) return null;
   return [CellAddress.index(m[1]), parseInt(m[2], 10)];
 }
 var letter = CellAddress.letter;
 
+// src/ops/sheet-op-schema.ts
+var SheetOpSchema = {
+  /** Every op type, in the order the variants are listed. */
+  TYPES: [
+    "set_cell",
+    "set_range",
+    "set_workbook",
+    "clear_cell",
+    "insert_rows",
+    "delete_rows",
+    "insert_columns",
+    "delete_columns",
+    "add_sheet",
+    "remove_sheet",
+    "rename_sheet",
+    "move_sheet",
+    "replace_sheet",
+    "set_merged_regions",
+    "set_column_widths",
+    "set_frozen",
+    "set_meta"
+  ],
+  /** A fresh object on every call, so a caller editing it changes nothing here. */
+  jsonSchema() {
+    const address = () => ({ type: "string", pattern: "^[A-Za-z]+[0-9]+$" });
+    const sheet = () => ({ type: "string", minLength: 1 });
+    const count = () => ({ type: "integer", minimum: 1 });
+    const position2 = () => ({ type: "integer", minimum: 1 });
+    const object = () => ({ type: "object" });
+    const nullableObject = () => ({ type: ["object", "null"] });
+    const value = () => ({ type: ["string", "number", "boolean", "null"] });
+    const variants = [
+      variant(
+        "set_cell",
+        { sheet: sheet(), address: address(), value: value(), formula: { type: "string" }, computedValue: value(), format: nullableObject(), comment: nullableObject() },
+        ["sheet", "address"],
+        "Write one cell. Omitting formula or computedValue clears it; omitting format or comment keeps it; null clears it."
+      ),
+      variant(
+        "set_range",
+        { sheet: sheet(), start: address(), end: address(), values: { type: "array", items: { type: "array", items: value() } } },
+        ["sheet", "start", "values"],
+        "Write a block of values row-major from start, each as a set_cell with no formula."
+      ),
+      variant("set_workbook", { data: object() }, ["data"], "Replace the whole workbook schema."),
+      variant("clear_cell", { sheet: sheet(), address: address() }, ["sheet", "address"], "Remove one cell."),
+      variant("insert_rows", { sheet: sheet(), at: position2(), count: count() }, ["sheet", "at", "count"], "Insert rows before 1-based row `at`; cells, merges below move down."),
+      variant("delete_rows", { sheet: sheet(), at: position2(), count: count() }, ["sheet", "at", "count"], "Delete rows starting at 1-based row `at`; cells, merges below move up."),
+      variant("insert_columns", { sheet: sheet(), at: position2(), count: count() }, ["sheet", "at", "count"], "Insert columns before 1-based column `at` (A = 1); cells, merges and widths move right."),
+      variant("delete_columns", { sheet: sheet(), at: position2(), count: count() }, ["sheet", "at", "count"], "Delete columns starting at 1-based column `at`; cells, merges and widths move left."),
+      variant("add_sheet", { index: { type: "integer", minimum: 0 }, sheet: object() }, ["index", "sheet"], "Insert a sheet at a 0-based position."),
+      variant("remove_sheet", { sheet: sheet() }, ["sheet"], "Remove a sheet by name."),
+      variant("rename_sheet", { sheet: sheet(), name: sheet() }, ["sheet", "name"], "Rename a sheet."),
+      variant("move_sheet", { sheet: sheet(), toIndex: { type: "integer", minimum: 0 } }, ["sheet", "toIndex"], "Move a sheet to a 0-based position."),
+      variant("replace_sheet", { sheet: sheet(), data: object() }, ["sheet", "data"], "Replace one sheet whole."),
+      variant(
+        "set_merged_regions",
+        { sheet: sheet(), mergedRegions: { type: "array", items: { type: "object", required: ["start", "end"], properties: { start: address(), end: address() } } } },
+        ["sheet", "mergedRegions"],
+        "Set every merged region of a sheet."
+      ),
+      // A LIST too, as PHP 2.3.2 declares. PHP encodes a map whose keys run
+      // 0..n-1 as a JSON list, so widths for columns A, B and C arrive as
+      // `[120, 80, 140]` and no widths as `[]`; this port passes such a list
+      // through a diff unchanged. A list's position is the column index.
+      variant(
+        "set_column_widths",
+        {
+          sheet: sheet(),
+          columnWidths: {
+            type: ["object", "array"],
+            items: { type: "number", minimum: 0 },
+            additionalProperties: { type: "number", minimum: 0 }
+          }
+        },
+        ["sheet", "columnWidths"],
+        "Set every column width of a sheet (0-based column index to pixels; a list is indexed by position); empty removes them."
+      ),
+      variant(
+        "set_frozen",
+        { sheet: sheet(), rows: { type: "integer", minimum: 0 }, cols: { type: "integer", minimum: 0 } },
+        ["sheet", "rows", "cols"],
+        "Set frozen rows and columns."
+      ),
+      variant("set_meta", { meta: nullableObject() }, ["meta"], "Replace the workbook meta, or remove it with null.")
+    ];
+    return {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      title: "Holy Sheet op",
+      description: "One op from Agent::diff, applied by Agent::reduce.",
+      oneOf: variants
+    };
+  }
+};
+function variant(type, properties, required, description) {
+  return {
+    type: "object",
+    description,
+    required: ["type", ...required],
+    additionalProperties: false,
+    properties: { type: { const: type }, ...properties }
+  };
+}
+
 // src/ops/sheet-reducer.ts
 var SheetReducer = {
   /** Sheet keys the granular ops address. A sheet with any other key is authored form. */
@@ -3858,6 +4071,9 @@ var SheetReducer = {
   },
   apply(schema, op) {
     const type = get(op, "type");
+    if (typeof type !== "string" || !SheetOpSchema.TYPES.includes(type)) {
+      return schema;
+    }
     if (type === "set_workbook") {
       return isArr(get(op, "data")) ? op.data : schema;
     }
@@ -3875,14 +4091,22 @@ var SheetReducer = {
       if (!isArr(get(op, "sheet"))) {
         return schema;
       }
-      const index = Math.max(0, Math.min(sheets.length, phpInt2(get(op, "index") ?? sheets.length)));
-      sheets.splice(index, 0, op.sheet);
+      const index = has(op, "index") ? phpInteger(op.index) : sheets.length;
+      if (index === null) {
+        return schema;
+      }
+      sheets.splice(Math.max(0, Math.min(sheets.length, index)), 0, op.sheet);
       return { ...schema, sheets };
     }
     const at2 = find(sheets, phpString(get(op, "sheet") ?? ""));
     if (at2 === null) {
       return schema;
     }
+    for (const field of POSITION_FIELDS) {
+      if (has(op, field) && phpInteger(op[field]) === null) {
+        return schema;
+      }
+    }
     switch (type) {
       case "remove_sheet":
         sheets.splice(at2, 1);
@@ -3892,7 +4116,7 @@ var SheetReducer = {
         break;
       case "move_sheet": {
         const [moved] = sheets.splice(at2, 1);
-        const to = Math.max(0, Math.min(sheets.length, phpInt2(get(op, "toIndex") ?? at2)));
+        const to = Math.max(0, Math.min(sheets.length, phpInteger(get(op, "toIndex") ?? at2) ?? at2));
         sheets.splice(to, 0, moved);
         break;
       }
@@ -3908,8 +4132,8 @@ var SheetReducer = {
         sheets[at2] = setOrUnset(sheets[at2], "columnWidths", get(op, "columnWidths") ?? [], EMPTY);
         break;
       case "set_frozen":
-        sheets[at2] = setOrUnset(sheets[at2], "frozenRows", phpInt2(get(op, "rows") ?? 0), 0);
-        sheets[at2] = setOrUnset(sheets[at2], "frozenCols", phpInt2(get(op, "cols") ?? 0), 0);
+        sheets[at2] = setOrUnset(sheets[at2], "frozenRows", phpInteger(get(op, "rows") ?? 0) ?? 0, 0);
+        sheets[at2] = setOrUnset(sheets[at2], "frozenCols", phpInteger(get(op, "cols") ?? 0) ?? 0, 0);
         break;
       case "set_cell":
         sheets[at2] = setCell(sheets[at2], op);
@@ -3918,7 +4142,7 @@ var SheetReducer = {
         sheets[at2] = setRange(sheets[at2], op);
         break;
       case "clear_cell": {
-        const address = asciiUpper(phpString(get(op, "address") ?? ""));
+        const address = asciiUpper(phpTrim2(phpString(get(op, "address") ?? "")));
         const cells = sheets[at2].cells;
         if (isArr(cells) && !Array.isArray(cells) && has(cells, address)) {
           const copy = { ...cells };
@@ -3928,16 +4152,16 @@ var SheetReducer = {
         break;
       }
       case "insert_rows":
-        sheets[at2] = shiftRows(sheets[at2], phpInt2(get(op, "at") ?? 0), Math.max(0, phpInt2(get(op, "count") ?? 0)));
+        sheets[at2] = shiftRows(sheets[at2], position(op, "at"), Math.max(0, position(op, "count")));
         break;
       case "delete_rows":
-        sheets[at2] = shiftRows(sheets[at2], phpInt2(get(op, "at") ?? 0), -Math.max(0, phpInt2(get(op, "count") ?? 0)));
+        sheets[at2] = shiftRows(sheets[at2], position(op, "at"), -Math.max(0, position(op, "count")));
         break;
       case "insert_columns":
-        sheets[at2] = shiftColumns(sheets[at2], phpInt2(get(op, "at") ?? 0), Math.max(0, phpInt2(get(op, "count") ?? 0)));
+        sheets[at2] = shiftColumns(sheets[at2], position(op, "at"), Math.max(0, position(op, "count")));
         break;
       case "delete_columns":
-        sheets[at2] = shiftColumns(sheets[at2], phpInt2(get(op, "at") ?? 0), -Math.max(0, phpInt2(get(op, "count") ?? 0)));
+        sheets[at2] = shiftColumns(sheets[at2], position(op, "at"), -Math.max(0, position(op, "count")));
         break;
       default:
         return schema;
@@ -3945,6 +4169,10 @@ var SheetReducer = {
     return { ...schema, sheets };
   }
 };
+var POSITION_FIELDS = ["index", "toIndex", "rows", "cols", "at", "count"];
+function position(op, key) {
+  return phpInteger(get(op, key) ?? 0) ?? 0;
+}
 var EMPTY = /* @__PURE__ */ Symbol("empty");
 function find(sheets, name) {
   for (let i = 0; i < sheets.length; i++) {
@@ -3964,7 +4192,7 @@ function setOrUnset(sheet, key, value, empty) {
   return out;
 }
 function setCell(sheet, op) {
-  const address = asciiUpper(phpString(get(op, "address") ?? ""));
+  const address = asciiUpper(phpTrim2(phpString(get(op, "address") ?? "")));
   if (parseAddress(address) === null) {
     return sheet;
   }
@@ -4044,6 +4272,9 @@ function shiftColumns(sheet, at2, delta) {
   if (isArr(get(sheet, "columnWidths"))) {
     const widths = /* @__PURE__ */ new Map();
     for (const [index, width] of entriesOf(sheet.columnWidths)) {
+      if (!isIndexKey(index)) {
+        continue;
+      }
       const i = phpInt2(index);
       const number = i + 1;
       if (number < at2) {
@@ -4170,6 +4401,21 @@ var SheetDiff = {
    *   example `columnWidths` decoded from `{"1":140,"0":120}`) as a map, not a
    *   list, and so as different from the same widths in order. A JS object has
    *   no such order to compare.
+   *
+   * Throws a `TypeError` on a value JSON cannot hold, as PHP 2.3.2 throws
+   * `JsonException`, rather than calling two such values the same:
+   *
+   * - a non-finite number (PHP: NAN, INF);
+   * - a lone UTF-16 surrogate in a string or a key, which is this runtime's
+   *   invalid UTF-8 (a JS string cannot hold invalid UTF-8, and PHP's own
+   *   `json_decode` refuses a lone surrogate);
+   * - a function or a symbol, which `JSON.stringify` would silently drop
+   *   (a bigint already throws there);
+   * - nesting deeper than PHP's `json_encode` depth of 4096, where every object
+   *   and array is a level, an empty one included. The walk is iterative, so
+   *   this is PHP's limit and not the call stack's.
+   *
+   * `undefined` stays what JSON makes it: an absent key, and `null` in a list.
    */
   same(a, b) {
     return canon(a) === canon(b);
@@ -4421,19 +4667,19 @@ function lines(sheet, axis) {
     }
     const [col, row] = parsed;
     const line = axis === "row" ? row : col + 1;
-    const position = axis === "row" ? col : row;
+    const position2 = axis === "row" ? col : row;
     let group = grouped.get(line);
     if (group === void 0) {
       group = /* @__PURE__ */ new Map();
       grouped.set(line, group);
     }
-    group.set(position, cell);
+    group.set(position2, cell);
     max = Math.max(max, line);
   }
   const out = [];
   for (let i = 1; i <= max; i++) {
     const positions = [...(grouped.get(i) ?? /* @__PURE__ */ new Map()).entries()].sort((x, y) => x[0] - y[0]);
-    out.push(canonEntries(positions.map(([position, cell]) => [String(position), cell])));
+    out.push(canonEntries(positions.map(([position2, cell]) => [String(position2), cell])));
   }
   return out;
 }
@@ -4460,116 +4706,72 @@ function rowMajor(addresses) {
   return parsed.map(([, , address]) => address);
 }
 function canon(value) {
-  if (Array.isArray(value)) {
-    return "[" + value.map(canon).join(",") + "]";
+  return isArr(value) ? canonEntries(entriesFor(value)) : scalar(value);
+}
+var JSON_DEPTH = 4096;
+function canonEntries(root) {
+  const stack = [];
+  const open = (key, entries) => {
+    if (stack.length === JSON_DEPTH) {
+      throw unencodable("Maximum stack depth exceeded");
+    }
+    const list = entries.every(([k], i) => k === String(i));
+    if (!list) {
+      entries = entries.slice().sort((x, y) => x[0] < y[0] ? -1 : x[0] > y[0] ? 1 : 0);
+    }
+    stack.push({ key, entries, list, next: 0, parts: [] });
+  };
+  open("", root);
+  for (; ; ) {
+    const top = stack[stack.length - 1];
+    if (top.next < top.entries.length) {
+      const [key, item] = top.entries[top.next++];
+      if (isArr(item)) {
+        open(key, entriesFor(item));
+      } else {
+        top.parts.push(member(top, key, scalar(item)));
+      }
+      continue;
+    }
+    stack.pop();
+    const text = top.list ? "[" + top.parts.join(",") + "]" : "{" + top.parts.join(",") + "}";
+    const parent = stack[stack.length - 1];
+    if (parent === void 0) {
+      return text;
+    }
+    parent.parts.push(member(parent, top.key, text));
   }
-  if (isArr(value)) {
-    return canonEntries(entriesOf(value));
+}
+function entriesFor(value) {
+  return Array.isArray(value) ? Array.from(value, (item, i) => [String(i), item]) : entriesOf(value);
+}
+function member(frame, key, text) {
+  return frame.list ? text : quote(key) + ":" + text;
+}
+function scalar(value) {
+  switch (typeof value) {
+    case "number":
+      if (!Number.isFinite(value)) {
+        throw unencodable("Inf and NaN cannot be JSON encoded");
+      }
+      break;
+    case "string":
+      return quote(value);
+    case "function":
+    case "symbol":
+      throw unencodable(`a ${typeof value} cannot be JSON encoded`);
   }
   return JSON.stringify(value) ?? "null";
 }
-function canonEntries(entries) {
-  if (entries.every(([key], i) => key === String(i))) {
-    return "[" + entries.map(([, item]) => canon(item)).join(",") + "]";
+var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+function quote(text) {
+  if (LONE_SURROGATE.test(text)) {
+    throw unencodable("Single unpaired UTF-16 surrogate");
   }
-  const sorted = entries.slice().sort((x, y) => x[0] < y[0] ? -1 : x[0] > y[0] ? 1 : 0);
-  return "{" + sorted.map(([key, item]) => JSON.stringify(key) + ":" + canon(item)).join(",") + "}";
+  return JSON.stringify(text);
 }
-
-// src/ops/sheet-op-schema.ts
-var SheetOpSchema = {
-  /** Every op type, in the order the variants are listed. */
-  TYPES: [
-    "set_cell",
-    "set_range",
-    "set_workbook",
-    "clear_cell",
-    "insert_rows",
-    "delete_rows",
-    "insert_columns",
-    "delete_columns",
-    "add_sheet",
-    "remove_sheet",
-    "rename_sheet",
-    "move_sheet",
-    "replace_sheet",
-    "set_merged_regions",
-    "set_column_widths",
-    "set_frozen",
-    "set_meta"
-  ],
-  /** A fresh object on every call, so a caller editing it changes nothing here. */
-  jsonSchema() {
-    const address = () => ({ type: "string", pattern: "^[A-Za-z]+[0-9]+$" });
-    const sheet = () => ({ type: "string", minLength: 1 });
-    const count = () => ({ type: "integer", minimum: 1 });
-    const position = () => ({ type: "integer", minimum: 1 });
-    const object = () => ({ type: "object" });
-    const nullableObject = () => ({ type: ["object", "null"] });
-    const value = () => ({ type: ["string", "number", "boolean", "null"] });
-    const variants = [
-      variant(
-        "set_cell",
-        { sheet: sheet(), address: address(), value: value(), formula: { type: "string" }, computedValue: value(), format: nullableObject(), comment: nullableObject() },
-        ["sheet", "address"],
-        "Write one cell. Omitting formula or computedValue clears it; omitting format or comment keeps it; null clears it."
-      ),
-      variant(
-        "set_range",
-        { sheet: sheet(), start: address(), end: address(), values: { type: "array", items: { type: "array", items: value() } } },
-        ["sheet", "start", "values"],
-        "Write a block of values row-major from start, each as a set_cell with no formula."
-      ),
-      variant("set_workbook", { data: object() }, ["data"], "Replace the whole workbook schema."),
-      variant("clear_cell", { sheet: sheet(), address: address() }, ["sheet", "address"], "Remove one cell."),
-      variant("insert_rows", { sheet: sheet(), at: position(), count: count() }, ["sheet", "at", "count"], "Insert rows before 1-based row `at`; cells, merges below move down."),
-      variant("delete_rows", { sheet: sheet(), at: position(), count: count() }, ["sheet", "at", "count"], "Delete rows starting at 1-based row `at`; cells, merges below move up."),
-      variant("insert_columns", { sheet: sheet(), at: position(), count: count() }, ["sheet", "at", "count"], "Insert columns before 1-based column `at` (A = 1); cells, merges and widths move right."),
-      variant("delete_columns", { sheet: sheet(), at: position(), count: count() }, ["sheet", "at", "count"], "Delete columns starting at 1-based column `at`; cells, merges and widths move left."),
-      variant("add_sheet", { index: { type: "integer", minimum: 0 }, sheet: object() }, ["index", "sheet"], "Insert a sheet at a 0-based position."),
-      variant("remove_sheet", { sheet: sheet() }, ["sheet"], "Remove a sheet by name."),
-      variant("rename_sheet", { sheet: sheet(), name: sheet() }, ["sheet", "name"], "Rename a sheet."),
-      variant("move_sheet", { sheet: sheet(), toIndex: { type: "integer", minimum: 0 } }, ["sheet", "toIndex"], "Move a sheet to a 0-based position."),
-      variant("replace_sheet", { sheet: sheet(), data: object() }, ["sheet", "data"], "Replace one sheet whole."),
-      variant(
-        "set_merged_regions",
-        { sheet: sheet(), mergedRegions: { type: "array", items: { type: "object", required: ["start", "end"], properties: { start: address(), end: address() } } } },
-        ["sheet", "mergedRegions"],
-        "Set every merged region of a sheet."
-      ),
-      // An EMPTY array too, as PHP 2.3.1 declares: PHP encodes an empty map as
-      // `[]`, which its diff emits when every width is removed. This port emits
-      // `{}`. Both mean no widths.
-      variant(
-        "set_column_widths",
-        { sheet: sheet(), columnWidths: { type: ["object", "array"], maxItems: 0 } },
-        ["sheet", "columnWidths"],
-        "Set every column width of a sheet (0-based column index to pixels); empty removes them."
-      ),
-      variant(
-        "set_frozen",
-        { sheet: sheet(), rows: { type: "integer", minimum: 0 }, cols: { type: "integer", minimum: 0 } },
-        ["sheet", "rows", "cols"],
-        "Set frozen rows and columns."
-      ),
-      variant("set_meta", { meta: nullableObject() }, ["meta"], "Replace the workbook meta, or remove it with null.")
-    ];
-    return {
-      $schema: "http://json-schema.org/draft-07/schema#",
-      title: "Holy Sheet op",
-      description: "One op from Agent::diff, applied by Agent::reduce.",
-      oneOf: variants
-    };
-  }
-};
-function variant(type, properties, required, description) {
-  return {
-    type: "object",
-    description,
-    required: ["type", ...required],
-    additionalProperties: false,
-    properties: { type: { const: type }, ...properties }
-  };
+function unencodable(reason) {
+  return new TypeError(`[holy-sheet] cannot compare a value JSON cannot hold: ${reason}`);
 }
 
 // src/holy-sheet.schema.json
@@ -4936,7 +5138,7 @@ var holy_sheet_schema_default = {
 };
 
 // src/agent.ts
-var VERSION = "2.4.1";
+var VERSION = "2.4.3";
 function toU8(input) {
   return input instanceof Uint8Array ? input : new Uint8Array(input);
 }