logisheets-logician 1.12.0 → 1.13.0

package/dist/index.node.js

@@ -807,6 +807,22 @@ function ensureOk(effect, label) {
     throw transactionFailure(label, effect);
   }
 }
+function cellDisplay(c) {
+  const v = c?.value;
+  if (v === void 0 || v === "empty") return "";
+  if (typeof v === "object" && "value" in v) {
+    return String(v.value);
+  }
+  return "";
+}
+function cellTextOnly(c) {
+  const v = c?.value;
+  if (v === void 0 || v === "empty") return "";
+  if (typeof v === "object" && "type" in v && v.type === "str") {
+    return String(v.value);
+  }
+  return "";
+}
 function stringifyForBlockInput(v) {
   if (v === null || v === void 0) return "";
   if (typeof v === "string") return v;
@@ -2412,7 +2428,9 @@ var convertToBlock = {
     "",
     "This is how you adopt a workbook someone hands you. `create_block` is for new tables and refuses to write over existing data; this one takes the data as it stands and gives it a name, fields and row keys, so you can address it as (block, row_key, field) and reference it from formulas by name instead of by coordinate.",
     "",
-    "Give `position` and the counts for the DATA only, leaving out any header row, then either `header_row` to read the field names from the titles or `fields` to state them. The first field is the row-key column, so put the column that identifies each record first.",
+    "Give `position` and the counts for the DATA only, leaving out any header row. Field names come from the header row \u2014 pass `header_row`, or leave it out and the row directly above the data is used when it looks like titles. `fields` states them outright instead.",
+    "",
+    "The row key is inferred: the first column whose values are all present and all different. Pass `key_field` to choose. Whatever is inferred is reported back, so check it \u2014 the key is how formulas and later edits name a row.",
     "",
     "Converting is a one-time cost: the block and its schema survive saving and reloading, and afterwards the region behaves exactly like one created as a block."
   ].join("\n"),
@@ -2439,7 +2457,11 @@ var convertToBlock = {
       header_row: {
         type: "integer",
         minimum: 0,
-        description: "Row holding the column titles; field names are read from it. Usually one row above `position`."
+        description: "Row holding the column titles; field names are read from it. Omit it and the row directly above `position` is used when it looks like a header \u2014 all text, over data that is not."
+      },
+      key_field: {
+        type: "string",
+        description: "Which field identifies a row. Omit and the first column whose values are all present and all different is used."
       },
       fields: {
         type: "array",
@@ -2482,29 +2504,77 @@ var convertToBlock = {
         );
       }
     }
+    const width = input.col_count;
+    const dataRes = await client.getCells({
+      sheetIdx,
+      startRow: row,
+      startCol: col,
+      endRow,
+      endCol
+    });
+    if (isErrorMessage(dataRes)) {
+      throw new Error(`reading the table failed: ${dataRes.msg}`);
+    }
+    const data = dataRes;
+    const at = (r, c) => data[r * width + c];
+    const anyData = data.some((c) => cellDisplay(c) !== "" || c.formula);
+    if (!anyData) {
+      throw new Error(
+        `there is nothing in the region at row ${row}, col ${col} (${input.row_count}x${input.col_count}) \u2014 this adopts a table that already exists; use create_block for a new one`
+      );
+    }
+    let headerRow = input.header_row;
+    let headerSource = "stated";
+    let headerDeclined = "there is no row above the data";
+    if (headerRow === void 0 && input.fields === void 0 && row > 0) {
+      const above = await client.getCells({
+        sheetIdx,
+        startRow: row - 1,
+        startCol: col,
+        endRow: row - 1,
+        endCol
+      });
+      if (!isErrorMessage(above)) {
+        const titles = above;
+        const allText = titles.length === width && titles.every((c) => cellTextOnly(c).trim() !== "");
+        const dataAllText = Array.from(
+          { length: width },
+          (_, i) => cellTextOnly(at(0, i))
+        ).every((t) => t.trim() !== "");
+        if (allText && !dataAllText) {
+          headerRow = row - 1;
+          headerSource = "inferred from the row above the data";
+        } else if (allText && dataAllText) {
+          headerDeclined = `the row above is all text but so is the first data row, so which one is titles cannot be told apart \u2014 pass \`header_row\` (probably ${row - 1}) or \`fields\``;
+        } else {
+          headerDeclined = "the row above the data is not all text";
+        }
+      }
+    }
     let fields;
+    let fieldSource;
     if (input.fields !== void 0) {
       fields = [...input.fields];
-    } else if (input.header_row !== void 0) {
+      fieldSource = "stated";
+    } else if (headerRow !== void 0) {
       const cells = await client.getCells({
         sheetIdx,
-        startRow: input.header_row,
+        startRow: headerRow,
         startCol: col,
-        endRow: input.header_row,
+        endRow: headerRow,
         endCol
       });
       if (isErrorMessage(cells)) {
         throw new Error(`reading the header row failed: ${cells.msg}`);
       }
       fields = cells.map((c, i) => {
-        const v = c.value;
-        const text = v === "empty" || v === void 0 ? "" : typeof v === "object" && "value" in v ? String(v.value) : "";
-        return text.trim() === "" ? `field_${i + 1}` : text.trim();
+        const text = cellDisplay(c).trim();
+        return text === "" ? `field_${i + 1}` : text;
       });
+      fieldSource = `read from row ${headerRow} (${headerSource})`;
     } else {
-      throw new Error(
-        "give either `header_row` to read the field names from, or `fields` to state them"
-      );
+      fields = Array.from({ length: width }, (_, i) => `field_${i + 1}`);
+      fieldSource = `generated, because ${headerDeclined}`;
     }
     if (fields.length !== input.col_count) {
       throw new Error(
@@ -2517,6 +2587,32 @@ var convertToBlock = {
         `duplicate field name(s) ${[...new Set(dup)].map((d) => `"${d}"`).join(", ")} \u2014 fields address cells, so they must be unique. Pass \`fields\` explicitly to disambiguate.`
       );
     }
+    const columnCanKey = (c) => {
+      const seen = /* @__PURE__ */ new Set();
+      for (let r = 0; r < input.row_count; r++) {
+        const text = cellDisplay(at(r, c)).trim();
+        if (text === "" || seen.has(text)) return false;
+        seen.add(text);
+      }
+      return true;
+    };
+    let keyIdx;
+    let keySource;
+    if (input.key_field !== void 0) {
+      keyIdx = fields.indexOf(input.key_field);
+      if (keyIdx < 0) {
+        throw new Error(
+          `key_field "${input.key_field}" is not one of the fields ${fields.map((f) => `"${f}"`).join(", ")}`
+        );
+      }
+      keySource = "stated";
+    } else {
+      const found = Array.from({ length: width }, (_, i) => i).find(
+        columnCanKey
+      );
+      keyIdx = found ?? 0;
+      keySource = found === void 0 ? "fell back to the first column \u2014 no column has a value in every row that is also unique" : "inferred: its values are all present and all different";
+    }
     const idRes = await client.getAvailableBlockId({ sheetIdx });
     if (isErrorMessage(idRes)) {
       throw new Error(`getAvailableBlockId failed: ${idRes.msg}`);
@@ -2531,14 +2627,21 @@ var convertToBlock = {
         },
         {
           type: "bindFormSchema",
-          value: new BindFormSchemaBuilder().refName(input.name).sheetIdx(sheetIdx).blockId(blockId).fieldFrom(0).keyIdx(0).fields(fields).renderIds(fields.map((_, i) => `${input.name}__f${i}`)).fieldFormulas([]).validationFormulas([]).editabilityFormulas([]).row(true).build()
+          value: new BindFormSchemaBuilder().refName(input.name).sheetIdx(sheetIdx).blockId(blockId).fieldFrom(0).keyIdx(keyIdx).fields(fields).renderIds(fields.map((_, i) => `${input.name}__f${i}`)).fieldFormulas([]).validationFormulas([]).editabilityFormulas([]).row(true).build()
         }
       ],
       `convert_to_block("${input.name}")`
     );
     return {
-      data: { block_id: blockId, fields },
-      display: `Converted the table at row ${row}, col ${col} into block "${input.name}" (${input.row_count} row(s), fields ${fields.map((f) => `"${f}"`).join(", ")}). Values untouched.`
+      data: {
+        block_id: blockId,
+        fields,
+        key_field: fields[keyIdx],
+        header_row: headerRow ?? null
+      },
+      display: `Converted the table at row ${row}, col ${col} into block "${input.name}" (${input.row_count} row(s)). Values untouched.
+Fields: ${fields.map((f) => `"${f}"`).join(", ")} \u2014 ${fieldSource}.
+Row key: "${fields[keyIdx]}" \u2014 ${keySource}.`
     };
   }
 };
@@ -2897,7 +3000,7 @@ var previewChanges = {
           throw transactionFailure(`preview_changes (${where})`, result);
         }
         if (watchCoords.length > 0) {
-          const watched = [];
+          const values = [];
           for (const w of watchCoords) {
             const cells = await client.getCells({
               sheetIdx: w.sheetIdx,
@@ -2910,12 +3013,11 @@ var previewChanges = {
               throw new Error(`getCells failed: ${cells.msg}`);
             }
             const info = cells[0];
-            watched.push({
-              target: w.target,
-              value: info === void 0 ? null : flattenValue2(info.value)
-            });
+            values.push(
+              info === void 0 ? null : flattenValue2(info.value)
+            );
           }
-          results.push({ label: scenario.label, watched });
+          results.push({ label: scenario.label, values });
         } else {
           const diffRes = await client.getTempStatusChanges();
           if (isErrorMessage(diffRes)) {
@@ -2965,7 +3067,10 @@ var previewChanges = {
       return `${results.length} scenarios previewed.`;
     };
     return {
-      data: single !== void 0 ? { scenarios: results, diff: single } : { scenarios: results },
+      data: single !== void 0 ? { scenarios: results, diff: single } : watchCoords.length > 0 ? {
+        watching: watchCoords.map((w) => w.target),
+        scenarios: results
+      } : { scenarios: results },
       display: describe()
     };
   }
@@ -2980,7 +3085,7 @@ function flattenValue2(v) {
     case "bool":
       return v.value;
     case "error":
-      return `#ERR:${v.value}`;
+      return v.value;
   }
 }
 function locateInBlock(sheetIdx, row, col, blocks) {
@@ -3948,7 +4053,7 @@ function valueToScalar(v) {
     case "bool":
       return v.value;
     case "error":
-      return `#${v.value}`;
+      return v.value;
     default:
       return null;
   }

package/dist/tools/builder.d.ts

@@ -275,10 +275,19 @@ interface ConvertToBlockInput {
     header_row?: number;
     /** Field names, when there is no header row to read them from. */
     fields?: string[];
+    /**
+     * Which field identifies a row. Omit and it is inferred: the first column
+     * whose values are all present and all different. The key is how every
+     * formula and every later edit names a row, so getting it from the data
+     * beats defaulting to whatever column happens to be first.
+     */
+    key_field?: string;
 }
 export declare const convertToBlock: Tool<ConvertToBlockInput, {
     block_id: number;
     fields: string[];
+    key_field: string;
+    header_row: number | null;
 }>;
 export declare const BUILDER_TOOLS: Tool[];
 export {};

package/dist/tools/builder.js

@@ -26,6 +26,31 @@ function ensureOk(effect, label) {
         throw transactionFailure(label, effect);
     }
 }
+/** A cell's value as a string — number, boolean or text alike. What a row key
+ *  is compared on, since a key column of years or ids is perfectly ordinary. */
+function cellDisplay(c) {
+    const v = c === null || c === void 0 ? void 0 : c.value;
+    if (v === undefined || v === 'empty')
+        return '';
+    if (typeof v === 'object' && 'value' in v) {
+        return String(v.value);
+    }
+    return '';
+}
+/** A cell's value only when it is TEXT, else ''. Distinct from
+ *  {@link cellDisplay} because deciding whether a row is a header turns on
+ *  exactly that difference: titles are words, the data under them usually is
+ *  not. Treating a number as text made every numeric first row look like a
+ *  second header, and the header above it went unread. */
+function cellTextOnly(c) {
+    const v = c === null || c === void 0 ? void 0 : c.value;
+    if (v === undefined || v === 'empty')
+        return '';
+    if (typeof v === 'object' && 'type' in v && v.type === 'str') {
+        return String(v.value);
+    }
+    return '';
+}
 /** Coerce arbitrary JSON values into the string form BlockInput expects.
  *  Numbers / booleans / null are stringified; strings pass through. */
 function stringifyForBlockInput(v) {
@@ -2010,7 +2035,9 @@ export const convertToBlock = {
         '',
         "This is how you adopt a workbook someone hands you. `create_block` is for new tables and refuses to write over existing data; this one takes the data as it stands and gives it a name, fields and row keys, so you can address it as (block, row_key, field) and reference it from formulas by name instead of by coordinate.",
         '',
-        'Give `position` and the counts for the DATA only, leaving out any header row, then either `header_row` to read the field names from the titles or `fields` to state them. The first field is the row-key column, so put the column that identifies each record first.',
+        'Give `position` and the counts for the DATA only, leaving out any header row. Field names come from the header row — pass `header_row`, or leave it out and the row directly above the data is used when it looks like titles. `fields` states them outright instead.',
+        '',
+        'The row key is inferred: the first column whose values are all present and all different. Pass `key_field` to choose. Whatever is inferred is reported back, so check it — the key is how formulas and later edits name a row.',
         '',
         'Converting is a one-time cost: the block and its schema survive saving and reloading, and afterwards the region behaves exactly like one created as a block.',
     ].join('\n'),
@@ -2037,7 +2064,11 @@ export const convertToBlock = {
             header_row: {
                 type: 'integer',
                 minimum: 0,
-                description: 'Row holding the column titles; field names are read from it. Usually one row above `position`.',
+                description: 'Row holding the column titles; field names are read from it. Omit it and the row directly above `position` is used when it looks like a header — all text, over data that is not.',
+            },
+            key_field: {
+                type: 'string',
+                description: 'Which field identifies a row. Omit and the first column whose values are all present and all different is used.',
             },
             fields: {
                 type: 'array',
@@ -2081,34 +2112,100 @@ export const convertToBlock = {
                 throw new Error(`that region overlaps the existing block "${(_b = (_a = b.schema) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : `block#${b.blockId}`}" at row ${b.rowStart}, col ${b.colStart}`);
             }
         }
-        // Field names: from the header row if given, else stated outright.
+        // The data itself, read once: the key has to be inferred from it, and
+        // the header check wants to know whether the first data row is text.
+        // `getCells` returns the rectangle row-major.
+        const width = input.col_count;
+        const dataRes = await client.getCells({
+            sheetIdx,
+            startRow: row,
+            startCol: col,
+            endRow,
+            endCol,
+        });
+        if (isErrorMessage(dataRes)) {
+            throw new Error(`reading the table failed: ${dataRes.msg}`);
+        }
+        const data = dataRes;
+        const at = (r, c) => data[r * width + c];
+        // Adopting a region with nothing in it is a mistake worth refusing.
+        // This tool exists to take data that is already there and name it; an
+        // empty rectangle would become a block of `field_1..n` with no rows,
+        // which is what `create_block` is for.
+        const anyData = data.some((c) => cellDisplay(c) !== '' || c.formula);
+        if (!anyData) {
+            throw new Error(`there is nothing in the region at row ${row}, col ${col} ` +
+                `(${input.row_count}x${input.col_count}) — this adopts a table that ` +
+                'already exists; use create_block for a new one');
+        }
+        // Which row holds the titles. Stated, or the row directly above the
+        // data when it looks like titles: text all the way across, over a first
+        // data row that is not all text. Guessing wrong here is cheap to spot —
+        // the field names come back in the result — and the fallback is
+        // `field_1..n`, which is obviously not a header.
+        let headerRow = input.header_row;
+        let headerSource = 'stated';
+        // Why the guess was declined, when it was, so the caller knows what to
+        // pass instead.
+        let headerDeclined = 'there is no row above the data';
+        if (headerRow === undefined && input.fields === undefined && row > 0) {
+            const above = await client.getCells({
+                sheetIdx,
+                startRow: row - 1,
+                startCol: col,
+                endRow: row - 1,
+                endCol,
+            });
+            if (!isErrorMessage(above)) {
+                const titles = above;
+                const allText = titles.length === width &&
+                    titles.every((c) => cellTextOnly(c).trim() !== '');
+                const dataAllText = Array.from({ length: width }, (_, i) => cellTextOnly(at(0, i))).every((t) => t.trim() !== '');
+                if (allText && !dataAllText) {
+                    headerRow = row - 1;
+                    headerSource = 'inferred from the row above the data';
+                }
+                else if (allText && dataAllText) {
+                    // Both are words, so there is nothing to tell them apart.
+                    // Guessing here is the one guess that could name the fields
+                    // after a row of data.
+                    headerDeclined =
+                        `the row above is all text but so is the first data row, ` +
+                            `so which one is titles cannot be told apart — pass ` +
+                            `\`header_row\` (probably ${row - 1}) or \`fields\``;
+                }
+                else {
+                    headerDeclined = 'the row above the data is not all text';
+                }
+            }
+        }
+        // Field names: stated, read from the header row, or generated.
         let fields;
+        let fieldSource;
         if (input.fields !== undefined) {
             fields = [...input.fields];
+            fieldSource = 'stated';
         }
-        else if (input.header_row !== undefined) {
+        else if (headerRow !== undefined) {
             const cells = await client.getCells({
                 sheetIdx,
-                startRow: input.header_row,
+                startRow: headerRow,
                 startCol: col,
-                endRow: input.header_row,
+                endRow: headerRow,
                 endCol,
             });
             if (isErrorMessage(cells)) {
                 throw new Error(`reading the header row failed: ${cells.msg}`);
             }
             fields = cells.map((c, i) => {
-                const v = c.value;
-                const text = v === 'empty' || v === undefined
-                    ? ''
-                    : typeof v === 'object' && 'value' in v
-                        ? String(v.value)
-                        : '';
-                return text.trim() === '' ? `field_${i + 1}` : text.trim();
+                const text = cellDisplay(c).trim();
+                return text === '' ? `field_${i + 1}` : text;
             });
+            fieldSource = `read from row ${headerRow} (${headerSource})`;
         }
         else {
-            throw new Error('give either `header_row` to read the field names from, or `fields` to state them');
+            fields = Array.from({ length: width }, (_, i) => `field_${i + 1}`);
+            fieldSource = `generated, because ${headerDeclined}`;
         }
         if (fields.length !== input.col_count) {
             throw new Error(`got ${fields.length} field name(s) for ${input.col_count} column(s)`);
@@ -2120,6 +2217,40 @@ export const convertToBlock = {
                 .join(', ')} — fields address cells, so they must be unique. ` +
                 'Pass `fields` explicitly to disambiguate.');
         }
+        // Which column identifies a row. The key is how BLOCKREF names a row and
+        // how every later edit addresses one, so it is worth deriving from the
+        // data rather than assuming the leftmost column: the first column whose
+        // values are all present and all different. A column with a gap cannot
+        // address every row, and a repeat is worse than a gap — BLOCKREF would
+        // resolve both rows to the first match.
+        const columnCanKey = (c) => {
+            const seen = new Set();
+            for (let r = 0; r < input.row_count; r++) {
+                const text = cellDisplay(at(r, c)).trim();
+                if (text === '' || seen.has(text))
+                    return false;
+                seen.add(text);
+            }
+            return true;
+        };
+        let keyIdx;
+        let keySource;
+        if (input.key_field !== undefined) {
+            keyIdx = fields.indexOf(input.key_field);
+            if (keyIdx < 0) {
+                throw new Error(`key_field "${input.key_field}" is not one of the fields ` +
+                    `${fields.map((f) => `"${f}"`).join(', ')}`);
+            }
+            keySource = 'stated';
+        }
+        else {
+            const found = Array.from({ length: width }, (_, i) => i).find(columnCanKey);
+            keyIdx = found !== null && found !== void 0 ? found : 0;
+            keySource =
+                found === undefined
+                    ? 'fell back to the first column — no column has a value in every row that is also unique'
+                    : 'inferred: its values are all present and all different';
+        }
         const idRes = await client.getAvailableBlockId({ sheetIdx });
         if (isErrorMessage(idRes)) {
             throw new Error(`getAvailableBlockId failed: ${idRes.msg}`);
@@ -2146,7 +2277,7 @@ export const convertToBlock = {
                     .sheetIdx(sheetIdx)
                     .blockId(blockId)
                     .fieldFrom(0)
-                    .keyIdx(0)
+                    .keyIdx(keyIdx)
                     .fields(fields)
                     .renderIds(fields.map((_, i) => `${input.name}__f${i}`))
                     .fieldFormulas([])
@@ -2157,10 +2288,16 @@ export const convertToBlock = {
             },
         ], `convert_to_block("${input.name}")`);
         return {
-            data: { block_id: blockId, fields },
+            data: {
+                block_id: blockId,
+                fields,
+                key_field: fields[keyIdx],
+                header_row: headerRow !== null && headerRow !== void 0 ? headerRow : null,
+            },
             display: `Converted the table at row ${row}, col ${col} into block "${input.name}" ` +
-                `(${input.row_count} row(s), fields ${fields.map((f) => `"${f}"`).join(', ')}). ` +
-                'Values untouched.',
+                `(${input.row_count} row(s)). Values untouched.\n` +
+                `Fields: ${fields.map((f) => `"${f}"`).join(', ')} — ${fieldSource}.\n` +
+                `Row key: "${fields[keyIdx]}" — ${keySource}.`,
         };
     },
 };

package/dist/tools/cells.js

@@ -29,7 +29,10 @@ function valueToScalar(v) {
         case 'bool':
             return v.value;
         case 'error':
-            return `#${v.value}`;
+            // The engine's error value already carries its `#` — `#DIV/0!`,
+            // not `DIV/0!`. Prefixing another one produced `##DIV/0!`, which
+            // matches nothing an agent or a test would look for.
+            return v.value;
         default:
             return null;
     }

package/dist/tools/edit.d.ts

@@ -76,13 +76,16 @@ interface PreviewScenarioResult {
     label?: string;
     /** Every cell whose value changes. Present unless `watch` was given. */
     diff?: PreviewDiffEntry[];
-    /** The watched cells' values under this scenario, in the order asked. */
-    watched?: Array<{
-        target: WatchTarget;
-        value: CellValue;
-    }>;
+    /** The watched cells' values, in the same order as `watching` on the
+     *  result. Bare values: repeating the target on every scenario cost more
+     *  bytes than all the answers put together on a 16-cell grid, and the
+     *  caller named those targets in the first place. */
+    values?: CellValue[];
 }
 interface PreviewChangesOutput {
+    /** The watched targets, once, in the order their values appear on each
+     *  scenario. Present only when `watch` was given. */
+    watching?: WatchTarget[];
     /** One entry per scenario, in the order given. */
     scenarios: PreviewScenarioResult[];
     /** The single scenario's diff, when called with `changes` and no `watch` —

package/dist/tools/edit.js

@@ -374,7 +374,7 @@ export const previewChanges = {
                     // Read the watched cells inside the branch, so a cell the
                     // change did not move still reports its (unchanged) value
                     // rather than going missing from a diff.
-                    const watched = [];
+                    const values = [];
                     for (const w of watchCoords) {
                         const cells = await client.getCells({
                             sheetIdx: w.sheetIdx,
@@ -387,14 +387,9 @@ export const previewChanges = {
                             throw new Error(`getCells failed: ${cells.msg}`);
                         }
                         const info = cells[0];
-                        watched.push({
-                            target: w.target,
-                            value: info === undefined
-                                ? null
-                                : flattenValue(info.value),
-                        });
+                        values.push(info === undefined ? null : flattenValue(info.value));
                     }
-                    results.push({ label: scenario.label, watched });
+                    results.push({ label: scenario.label, values });
                 }
                 else {
                     const diffRes = await client.getTempStatusChanges();
@@ -452,7 +447,14 @@ export const previewChanges = {
             return `${results.length} scenarios previewed.`;
         };
         return {
-            data: single !== undefined ? { scenarios: results, diff: single } : { scenarios: results },
+            data: single !== undefined
+                ? { scenarios: results, diff: single }
+                : watchCoords.length > 0
+                    ? {
+                        watching: watchCoords.map((w) => w.target),
+                        scenarios: results,
+                    }
+                    : { scenarios: results },
             display: describe(),
         };
     },
@@ -468,7 +470,10 @@ function flattenValue(v) {
         case 'bool':
             return v.value;
         case 'error':
-            return `#ERR:${v.value}`;
+            // The engine's error value is already spelled the way a
+            // spreadsheet spells it — `#DIV/0!`. Decorating it produced
+            // `#ERR:#DIV/0!`, which matches nothing anyone would look for.
+            return v.value;
     }
 }
 /** Which (block, row_key, field) a coordinate names, if any. Shared with the

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "logisheets-logician",
-    "version": "1.12.0",
+    "version": "1.13.0",
     "description": "AI agent tools for LogiSheets — platform-agnostic LLM tool definitions, prompts, and skills for operating a real spreadsheet engine. Powers Watson (the in-app assistant) and logisheets-mcp; reusable in any agent host.",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -20,8 +20,8 @@
         "prepack": "yarn build"
     },
     "dependencies": {
-        "logisheets-core": "^1.12.0",
-        "logisheets-web": "^1.12.0"
+        "logisheets-core": "^1.13.0",
+        "logisheets-web": "^1.13.0"
     },
     "devDependencies": {
         "esbuild": "^0.21.0",