@lotics/cli 0.196.0 → 0.197.0

package/README.md

@@ -248,7 +248,11 @@ Workspaces live inside the active org. If the org has more than one, select befo
 ```bash
 lotics workspace                    # list workspaces in the active org (marks current)
 lotics workspace select wks_...     # set the workspace for the active scope (pin or profile)
-lotics workspace create "Sales"     # create a new workspace (admin only)
+lotics workspace create "Sales" --timezone America/New_York --currency USD
+                                    # create a new workspace (admin only); without the flags it
+                                    # takes the org's oldest workspace's zone and currency
+lotics workspace settings --currency USD --timezone America/New_York
+                                    # change the current workspace's name/currency/zone
 lotics workspace delete wks_... --yes  # delete a workspace (admin only; soft delete, recoverable)
 ```
 
@@ -268,8 +272,8 @@ lotics run query_records '{"table_id":"tbl_...","field_keys":["name"]}'
 # Large args (a knowledge-doc `content`, a bulk update) exceed the OS arg limit —
 # read them from a file or stdin instead of an inline arg:
 lotics run create_knowledge @args.json
-cat args.json | lotics run create_knowledge
-echo '{"table_id":"tbl_..."}' | lotics run query_records
+cat args.json | lotics run create_knowledge -          # the trailing - reads stdin
+echo '{"table_id":"tbl_..."}' | lotics run query_records -
 
 # Upload files (multiple files and directories supported)
 lotics upload ./report.pdf ./data.csv ./documents/
@@ -278,6 +282,10 @@ lotics upload ./report.pdf ./data.csv ./documents/
 lotics run generate_excel_from_template '{"..."}'
 lotics download <file_id> -o ./reports/
 
+# What is in the store, newest first — one page, with the command for the next one
+lotics file list --limit 50
+lotics file delete <file_id>          # refused while anything still references it
+
 # CI / non-interactive (key inline)
 LOTICS_API_KEY=ltk_... lotics run query_tables '{}'
 
@@ -348,7 +356,7 @@ lotics app check
 # Running an app's alias is a TOOL call, like every other tool. Exits non-zero
 # when the RUN failed, not only when the call did.
 lotics run run_app_workflow '{"app_id":"app_...","alias":"issueInvoice","inputs":{"record_id":"rec_..."}}'
-cat args.json | lotics run run_app_workflow    # bulk inputs bypass ARG_MAX
+cat args.json | lotics run run_app_workflow -  # bulk inputs bypass ARG_MAX
 # Honest post-run harvest: created records + a paste-ready cleanup plan + the
 # caveat (external/notification calls can't be auto-undone; sub-workflows may run).
 lotics run run_app_workflow '{...}' --print-created
@@ -361,7 +369,8 @@ lotics run run_app_workflow '{...}' --cleanup   # also deletes created records (
 # JS-subset parser + type-check locally, so a body that passes is one `set` will accept
 # (`set` still adds name resolution + lint + structural checks, which need the workspace):
 lotics app workflow pull                    # rewrite src/workflows/*.ts + globals from the server
-lotics app workflow check                   # parse + typecheck every body locally ([alias] for one)
+lotics app workflow check                   # parse + typecheck every body locally ([alias...] for some)
+lotics app workflow diff issueInvoice       # how the local body differs from the one the server runs
 lotics app workflow set issueInvoice        # push the edited src/workflows/issueInvoice.ts
 
 # Iterate on a named query WITHOUT a deploy: push package.json#lotics.queries.<alias>
@@ -373,7 +382,7 @@ lotics app query set openInvoices           # push package.json#lotics.queries.o
 # + member auth). Streams progress to stderr; reports the SETTLED run (structured
 # output / final text) to stdout; exits 0 only when the run completed.
 lotics run run_app_agent '{"app_id":"app_abc","alias":"recognize","input":{"image_file_id":"fil_..."}}'
-cat input.json | lotics run run_app_agent            # inputs via stdin/@file
+cat input.json | lotics run run_app_agent -          # inputs via stdin/@file
 lotics run run_app_agent '{...}' --json              # full run summary to stdout
 # A run that outlives the call's bounded wait keeps going server-side; read it with
 lotics run get_app_agent_run '{"app_id":"app_abc","run_id":"run_..."}'

package/dist/render_page.js

@@ -52856,6 +52856,7 @@ ${e.toString()}`);
   // ../xlsx/src/ooxml_sheet.ts
   var MAX_ROWS_PER_SHEET = 1e4;
   var MAX_IMAGES = 50;
+  var LAST_COLUMN = 16384;
   function extractElementText(node) {
     if (node === void 0 || node === null) return void 0;
     if (typeof node === "object") {
@@ -52897,8 +52898,12 @@ ${e.toString()}`);
     const defaultRowHeight = sheetFormatPr?.["@_defaultRowHeight"] ? parseFloat(sheetFormatPr["@_defaultRowHeight"]) : 15;
     const defaultColWidth = sheetFormatPr?.["@_defaultColWidth"] ? parseFloat(sheetFormatPr["@_defaultColWidth"]) : 8;
     const { freezePane, showGridLines } = parseSheetViews(worksheet);
-    const { columns: parsedCols, colHidden, colOutlineLevels } = parseCols(worksheet, defaultColWidth);
+    const parsedCols = parseCols(worksheet, defaultColWidth);
+    const backdrop = parsedCols.filter((c) => c.max >= LAST_COLUMN).pop();
+    const sheetColWidth = backdrop?.width ?? defaultColWidth;
     const hyperlinkMap = parseHyperlinks(worksheet, rels);
+    const styleRuns = parsedCols.filter((c) => c.styleIndex !== void 0);
+    const colStyleIndex = (col) => styleRuns.find((r) => col >= r.min && col <= r.max)?.styleIndex ?? 0;
     const {
       rows,
       totalRowCount,
@@ -52906,9 +52911,20 @@ ${e.toString()}`);
       maxCol,
       maxContentWidth,
       rowOutlineLevels
-    } = parseSheetData(worksheet, styles, sharedStrings, hyperlinkMap, defaultRowHeight, date1904, maxRows);
-    const colCount = Math.max(parsedCols.length > 0 ? parsedCols[parsedCols.length - 1].max : 0, maxCol);
-    const columns = buildColumns(parsedCols, colHidden, maxContentWidth, colCount, defaultColWidth);
+    } = parseSheetData(
+      worksheet,
+      styles,
+      sharedStrings,
+      hyperlinkMap,
+      defaultRowHeight,
+      date1904,
+      maxRows,
+      colStyleIndex
+    );
+    const declaredMax = parsedCols.reduce((m, c) => c.max >= LAST_COLUMN ? m : Math.max(m, c.max), 0);
+    const colCount = Math.max(declaredMax, maxCol);
+    const { colHidden, colOutlineLevels } = expandColRuns(parsedCols, colCount);
+    const columns = buildColumns(parsedCols, colHidden, maxContentWidth, colCount, styles);
     const mergedCells = parseMergedCells(worksheet);
     const conditionalFormats = parseConditionalFormats(worksheet, theme, indexedColors, styles.dxfs);
     const images = parseImages(rels, zipEntries);
@@ -52923,7 +52939,7 @@ ${e.toString()}`);
       totalRowCount,
       truncated,
       defaultRowHeight,
-      defaultColWidth,
+      defaultColWidth: sheetColWidth,
       showGridLines,
       freezePane,
       conditionalFormats,
@@ -53046,11 +53062,9 @@ ${e.toString()}`);
   }
   function parseCols(worksheet, defaultColWidth) {
     const colsEl = worksheet["cols"];
-    const colHidden = /* @__PURE__ */ new Set();
-    const colOutlineLevels = /* @__PURE__ */ new Map();
-    if (!colsEl) return { columns: [], colHidden, colOutlineLevels };
+    if (!colsEl) return [];
     const colArr = colsEl["col"];
-    if (!colArr) return { columns: [], colHidden, colOutlineLevels };
+    if (!colArr) return [];
     const columns = [];
     for (const col of colArr) {
       const min = parseInt(col["@_min"] ?? "1", 10);
@@ -53059,21 +53073,32 @@ ${e.toString()}`);
       const hidden = col["@_hidden"] === "1" || col["@_hidden"] === "true";
       const customWidth = col["@_customWidth"] === "1" || col["@_customWidth"] === "true";
       const outlineLevel = parseInt(col["@_outlineLevel"] ?? "0", 10);
-      columns.push({ min, max: max2, width, hidden, customWidth, outlineLevel });
-      for (let c = min; c <= max2; c++) {
-        if (hidden) colHidden.add(c);
-        if (outlineLevel > 0) colOutlineLevels.set(c, outlineLevel);
+      const styleIndex = col["@_style"] !== void 0 ? parseInt(col["@_style"], 10) : void 0;
+      columns.push({ min, max: max2, width, hidden, customWidth, outlineLevel, styleIndex });
+    }
+    return columns;
+  }
+  function expandColRuns(colDefs, colCount) {
+    const colHidden = /* @__PURE__ */ new Set();
+    const colOutlineLevels = /* @__PURE__ */ new Map();
+    for (const def of colDefs) {
+      if (!def.hidden && def.outlineLevel <= 0) continue;
+      for (let c = def.min; c <= Math.min(def.max, colCount); c++) {
+        if (def.hidden) colHidden.add(c);
+        if (def.outlineLevel > 0) colOutlineLevels.set(c, def.outlineLevel);
       }
     }
-    return { columns, colHidden, colOutlineLevels };
+    return { colHidden, colOutlineLevels };
   }
-  function buildColumns(colDefs, colHidden, maxContentWidth, colCount, _defaultColWidth) {
+  function buildColumns(colDefs, colHidden, maxContentWidth, colCount, styles) {
     const explicitWidth = /* @__PURE__ */ new Map();
     const pinned = /* @__PURE__ */ new Set();
+    const styleIndexes = /* @__PURE__ */ new Map();
     for (const def of colDefs) {
-      for (let c = def.min; c <= def.max; c++) {
+      for (let c = def.min; c <= Math.min(def.max, colCount); c++) {
         explicitWidth.set(c, def.width);
         if (def.customWidth) pinned.add(c);
+        if (def.styleIndex !== void 0) styleIndexes.set(c, def.styleIndex);
       }
     }
     const columns = [];
@@ -53087,11 +53112,28 @@ ${e.toString()}`);
       } else {
         width = Math.max(8, Math.min(contentChars + 2, 40));
       }
-      columns.push({ index: c, width, hidden, ...pinned.has(c) ? { customWidth: true } : {} });
+      columns.push({
+        index: c,
+        width,
+        hidden,
+        ...pinned.has(c) ? { customWidth: true } : {},
+        ...resolveAxisFormat(styles, styleIndexes.get(c))
+      });
     }
     return columns;
   }
-  function parseSheetData(worksheet, styles, sharedStrings, hyperlinkMap, defaultRowHeight, date1904, maxRows) {
+  function resolveAxisFormat(styles, xfIndex) {
+    if (xfIndex === void 0 || xfIndex === 0) return {};
+    const numFmt = styles.getNumFmt(xfIndex);
+    return {
+      style: styles.resolveStyle(xfIndex),
+      ...numFmt !== "General" ? { numFmtCode: numFmt } : {},
+      // An index naming no `cellXfs` entry expresses nothing to preserve, and
+      // recording it would let the writer re-emit an index the file cannot resolve.
+      ...styles.hasXf(xfIndex) ? { originalXfIndex: xfIndex } : {}
+    };
+  }
+  function parseSheetData(worksheet, styles, sharedStrings, hyperlinkMap, defaultRowHeight, date1904, maxRows, colStyleIndex) {
     const sheetData = worksheet["sheetData"];
     if (!sheetData) {
       return {
@@ -53132,11 +53174,15 @@ ${e.toString()}`);
       if (rowCount > maxRows) continue;
       const height = rowEl["@_ht"] ? parseFloat(rowEl["@_ht"]) : defaultRowHeight;
       const customHeight = rowEl["@_customHeight"] === "1" || rowEl["@_customHeight"] === "true";
+      const customFormat = rowEl["@_customFormat"] === "1" || rowEl["@_customFormat"] === "true";
+      const rowXfIndex = customFormat ? parseInt(rowEl["@_s"] ?? "0", 10) : 0;
+      const rowFormat = resolveAxisFormat(styles, rowXfIndex);
+      const inheritedXfIndex = (col) => rowXfIndex > 0 ? rowXfIndex : colStyleIndex(col);
       const cellArr = rowEl["c"];
       const cells = [];
       if (cellArr) {
         for (const cellEl of cellArr) {
-          const parsed = parseCell(cellEl, styles, sharedStrings, hyperlinkMap, date1904);
+          const parsed = parseCell(cellEl, styles, sharedStrings, hyperlinkMap, date1904, inheritedXfIndex);
           if (parsed) {
             cells.push(parsed);
             if (parsed.column > maxCol) maxCol = parsed.column;
@@ -53154,7 +53200,8 @@ ${e.toString()}`);
         height,
         cells,
         hidden: rowHidden,
-        ...customHeight ? { customHeight: true } : {}
+        ...customHeight ? { customHeight: true } : {},
+        ...rowFormat
       });
     }
     return {
@@ -53171,13 +53218,14 @@ ${e.toString()}`);
     if (!match) return void 0;
     return { col: colLettersToNum(match[1]), row: parseInt(match[2], 10) };
   }
-  function parseCell(cellEl, styles, sharedStrings, hyperlinkMap, date1904) {
+  function parseCell(cellEl, styles, sharedStrings, hyperlinkMap, date1904, inheritedXfIndex) {
     const ref2 = cellEl["@_r"];
     if (!ref2) return void 0;
     const cellRef = parseCellRef(ref2);
     if (!cellRef) return void 0;
     const type = cellEl["@_t"] ?? "";
-    const styleIndex = parseInt(cellEl["@_s"] ?? "0", 10);
+    const declaredStyle = cellEl["@_s"];
+    const styleIndex = declaredStyle !== void 0 ? parseInt(declaredStyle, 10) : inheritedXfIndex(cellRef.col);
     const rawValue = extractElementText(cellEl["v"]);
     let inlineStr;
     if (type === "inlineStr") {
@@ -54238,18 +54286,18 @@ ${e.toString()}`);
       return original !== void 0 && original.styleIndex === styleIndex && original.numFmtCode === (numFmtCode === "" ? "General" : numFmtCode);
     }
     /**
-     * True when the xf index the writer emits for `cell` in styles-passthrough
-     * mode still expresses the cell's style. A cell CARRYING an index always
-     * does — every write path drops that index the moment the style or number
-     * format moves off it. The question left is the one no cell states: a cell
-     * the file never carried emits no `s=` and so inherits the file's xf 0,
+     * True when the xf index the writer emits for `format` in styles-passthrough
+     * mode still expresses its style. A cell, column or row CARRYING an index
+     * always does — every write path drops that index the moment the style or
+     * number format moves off it. The question left is the one nothing states: a
+     * cell the file never carried emits no `s=` and so inherits the file's xf 0,
      * which is right only when that entry expresses the style the model gives
      * it. Neither half reads cell protection or `quotePrefix`, which this model
      * does not carry, so an xf differing only there compares equal.
      */
-    keepsOriginalXf(cell) {
-      if (cell.originalXfIndex !== void 0) return true;
-      return this.originalXfExpresses(0, cell.styleIndex, cell.numFmtCode);
+    keepsOriginalXf(format) {
+      if (format.originalXfIndex !== void 0) return true;
+      return this.originalXfExpresses(0, format.styleIndex, format.numFmtCode);
     }
     /**
      * Reset the `dirty` flag and snapshot the current numFmt set as the
@@ -54303,6 +54351,12 @@ ${e.toString()}`);
       this.hiddenCols = /* @__PURE__ */ new Set();
       this.rowOutlineLevels = /* @__PURE__ */ new Map();
       this.colOutlineLevels = /* @__PURE__ */ new Map();
+      /** A whole column's / whole row's default format, keyed by 1-based index.
+       *  The cheapest way a template says "this column is money", and the writer
+       *  must restate it or the regenerated sheet says less than the one it
+       *  replaces. */
+      this.colFormats = /* @__PURE__ */ new Map();
+      this.rowFormats = /* @__PURE__ */ new Map();
       this.conditionalFormats = [];
       this.images = [];
       this.charts = [];
@@ -54385,17 +54439,31 @@ ${e.toString()}`);
     getCellAt(row, col) {
       return this.cells.getAt(row, col);
     }
+    /**
+     * The format the cell at (row, col) HAS: its own when the grid holds one,
+     * else the default its row declares, else its column's, else the sheet's.
+     * This is what `<col style>` and `<row s customFormat>` mean — an EMPTY cell
+     * in a money column is still a money cell, and a value written into one
+     * arrives as money rather than at the sheet default.
+     */
+    effectiveFormat(row, col) {
+      return this.cells.getAt(row, col) ?? this.rowFormats.get(row) ?? this.colFormats.get(col) ?? { styleIndex: 0, numFmtCode: "General" };
+    }
     /**
      * Set cell value with optional inline style. Interns style via the
-     * StyleRegistry when available. When `style` is supplied and matches the
-     * existing cell's style (or is identical to a previously interned style),
-     * the cell's `originalXfIndex` is preserved so that the writer can use
-     * styles-passthrough mode if no other mutation has dirtied the registry.
+     * StyleRegistry when available. What the caller leaves unstated is what the
+     * cell already HAS — its own format, or the one its row or column declares —
+     * so a number written into a money column arrives as money. When the result
+     * still expresses that format, its `originalXfIndex` is carried, so the
+     * writer can use styles-passthrough mode if no other mutation has dirtied the
+     * registry.
      */
     set(ref2, value2, style, numFmt, formula) {
       const existing = this.cells.get(ref2);
-      const styleIndex = style && this.styles ? this.styles.intern(style) : existing?.styleIndex ?? 0;
-      const numFmtCode = numFmt ?? existing?.numFmtCode ?? "General";
+      const rc = existing ? void 0 : refToRowCol(ref2);
+      const inherited = existing ?? (rc ? this.effectiveFormat(rc.row, rc.col) : { styleIndex: 0, numFmtCode: "General" });
+      const styleIndex = style && this.styles ? this.styles.intern(style) : inherited.styleIndex;
+      const numFmtCode = numFmt ?? inherited.numFmtCode;
       if (this.styles) this.styles.registerNumFmt(numFmtCode);
       const displayValue = computeDisplayValue(value2, numFmtCode);
       const content = buildContentFromValue(displayValue, this.hyperlinks.get(ref2));
@@ -54407,8 +54475,8 @@ ${e.toString()}`);
         numFmtCode,
         content
       };
-      if (existing && existing.styleIndex === styleIndex && existing.numFmtCode === numFmtCode && existing.originalXfIndex !== void 0) {
-        cell.originalXfIndex = existing.originalXfIndex;
+      if (inherited.originalXfIndex !== void 0 && inherited.styleIndex === styleIndex && inherited.numFmtCode === numFmtCode) {
+        cell.originalXfIndex = inherited.originalXfIndex;
       }
       this.cells.set(ref2, cell);
       return cell;
@@ -54553,6 +54621,12 @@ ${e.toString()}`);
         for (const cell of sheet.cells.values()) {
           if (!this.styles.keepsOriginalXf(cell)) return false;
         }
+        for (const format of sheet.colFormats.values()) {
+          if (!this.styles.keepsOriginalXf(format)) return false;
+        }
+        for (const format of sheet.rowFormats.values()) {
+          if (!this.styles.keepsOriginalXf(format)) return false;
+        }
         for (const cf of sheet.conditionalFormats) {
           for (const rule of cf.rules) {
             if (rule.ruleType !== "style") continue;
@@ -54570,6 +54644,13 @@ ${e.toString()}`);
       };
     }
   };
+  function snapshotAxisFormat(format, styles) {
+    if (!format) return {};
+    return {
+      style: styles.get(format.styleIndex),
+      ...format.numFmtCode !== "General" ? { numFmtCode: format.numFmtCode } : {}
+    };
+  }
   function sheetToSnapshot(sheet, styles) {
     const { maxRow, maxCol } = sheet.getUsedRange();
     const rowMap = /* @__PURE__ */ new Map();
@@ -54597,6 +54678,9 @@ ${e.toString()}`);
       if (cell.arrayRange) parsedCell.arrayRange = cell.arrayRange;
       arr.push(parsedCell);
     }
+    for (const rowNum of sheet.rowHeights.keys()) if (!rowMap.has(rowNum)) rowMap.set(rowNum, []);
+    for (const rowNum of sheet.hiddenRows) if (!rowMap.has(rowNum)) rowMap.set(rowNum, []);
+    for (const rowNum of sheet.rowFormats.keys()) if (!rowMap.has(rowNum)) rowMap.set(rowNum, []);
     const rows = [];
     const sortedRowNums = Array.from(rowMap.keys()).sort((a, b) => a - b);
     for (const rowNum of sortedRowNums) {
@@ -54606,15 +54690,21 @@ ${e.toString()}`);
         index: rowNum,
         height: sheet.rowHeights.get(rowNum) ?? sheet.defaultRowHeight,
         cells,
-        hidden: sheet.hiddenRows.has(rowNum)
+        hidden: sheet.hiddenRows.has(rowNum),
+        ...snapshotAxisFormat(sheet.rowFormats.get(rowNum), styles)
       });
     }
     const columns = [];
-    for (let c = 1; c <= maxCol; c++) {
+    let colBound = maxCol;
+    for (const c of sheet.colWidths.keys()) if (c > colBound) colBound = c;
+    for (const c of sheet.hiddenCols) if (c > colBound) colBound = c;
+    for (const c of sheet.colFormats.keys()) if (c > colBound) colBound = c;
+    for (let c = 1; c <= colBound; c++) {
       columns.push({
         index: c,
         width: sheet.colWidths.get(c) ?? sheet.defaultColWidth,
-        hidden: sheet.hiddenCols.has(c)
+        hidden: sheet.hiddenCols.has(c),
+        ...snapshotAxisFormat(sheet.colFormats.get(c), styles)
       });
     }
     const mergedCells = sheet.mergedCells.map((ref2) => {
@@ -54725,6 +54815,8 @@ ${e.toString()}`);
       if (col.hidden) {
         sheet.hiddenCols.add(col.index);
       }
+      const format = loadAxisFormat(col, styles, hasCellXfs, `${ps.name} column ${col.index}`);
+      if (format) sheet.colFormats.set(col.index, format);
     }
     sheet.mergedCells = ps.mergedCells.map((mc) => {
       const startRef = rowColToRef(mc.startRow, mc.startCol);
@@ -54738,6 +54830,8 @@ ${e.toString()}`);
       if (row.hidden) {
         sheet.hiddenRows.add(row.index);
       }
+      const rowFormat = loadAxisFormat(row, styles, hasCellXfs, `${ps.name} row ${row.index}`);
+      if (rowFormat) sheet.rowFormats.set(row.index, rowFormat);
       for (const cell of row.cells) {
         const ref2 = rowColToRef(row.index, cell.column);
         const styleIndex = styles.intern(cell.style);
@@ -54777,6 +54871,23 @@ ${e.toString()}`);
     }
     return sheet;
   }
+  function loadAxisFormat(source, styles, hasCellXfs, label) {
+    if (!source.style) return void 0;
+    styles.registerNumFmt(source.numFmtCode);
+    const format = {
+      styleIndex: styles.intern(source.style),
+      numFmtCode: source.numFmtCode ?? "General"
+    };
+    if (source.originalXfIndex !== void 0) {
+      if (!hasCellXfs) {
+        throw new InvalidModelError(
+          `${label} carries originalXfIndex ${source.originalXfIndex} but the snapshot has no cellXfs table`
+        );
+      }
+      format.originalXfIndex = source.originalXfIndex;
+    }
+    return format;
+  }
   function applyAutoFilterHiddenRows(sheet) {
     const af = sheet.autoFilter;
     if (!af) return;