@lotics/cli 0.156.6 → 0.162.0

package/AGENTS.md

@@ -79,13 +79,13 @@ whether something exists, read `lotics --help` § COMMANDS — the whole section
   `set_app_*` tools. A manifest alias with no server binding only fails at the app's first call, so
   deploy warns about the mismatch.
 
-  **The five `lotics.*` keys look alike and point in three different directions.** Before editing one,
+  **The four `lotics.*` keys look alike and point in three different directions.** Before editing one,
   know which you are touching — this is the single most expensive thing to get wrong in a manifest:
 
   | `lotics.<key>` | Owned by | Your edit reaches the app via |
   |---|---|---|
   | `queries`, `capabilities` | the manifest | `app deploy` — re-synced on every one (an absent `capabilities` block turns them all OFF) |
-  | `knowledge`, `config` | the manifest | `opctl app publish` / `app release` — package authoring only |
+  | `knowledge` | the manifest | nothing, until the app is published as a starter — it declares which docs ship with it |
   | `workflows` | the workflow row's verified contract | `app workflow set`, which type-checks the BODY against your declaration and refuses a schema the body cannot satisfy |
   | `agents` | the app row | **nothing.** It is a mirror: `app codegen` re-silvers it from the app, and an agent is changed with `set_app_agent` |
 

package/dist/render_page.js

@@ -52728,14 +52728,14 @@ ${e.toString()}`);
   }
   function readCfbStreams(bytes) {
     const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const u162 = (o) => dv.getUint16(o, true);
-    const u32 = (o) => dv.getUint32(o, true);
-    const sectorSize = 1 << u162(30);
-    const miniSectorSize = 1 << u162(32);
-    const firstDirSector = u32(48);
-    const miniCutoff = u32(56);
-    const firstMiniFatSector = u32(60);
-    const firstDifatSector = u32(68);
+    const u163 = (o) => dv.getUint16(o, true);
+    const u322 = (o) => dv.getUint32(o, true);
+    const sectorSize = 1 << u163(30);
+    const miniSectorSize = 1 << u163(32);
+    const firstDirSector = u322(48);
+    const miniCutoff = u322(56);
+    const firstMiniFatSector = u322(60);
+    const firstDifatSector = u322(68);
     if (sectorSize < 512 || sectorSize > 1 << 20) {
       throw new Error("Unsupported OLE2 file: invalid sector size");
     }
@@ -52743,7 +52743,7 @@ ${e.toString()}`);
     const maxSectors = Math.ceil(bytes.length / sectorSize) + 1;
     const difat = [];
     for (let i3 = 0; i3 < 109; i3++) {
-      const v = u32(76 + i3 * 4);
+      const v = u322(76 + i3 * 4);
       if (v !== FREESECT) difat.push(v);
     }
     let ds = firstDifatSector;
@@ -52753,10 +52753,10 @@ ${e.toString()}`);
       seenDifat.add(ds);
       const base2 = sectorOffset(ds);
       for (let i3 = 0; i3 < entriesPerSector - 1; i3++) {
-        const v = u32(base2 + i3 * 4);
+        const v = u322(base2 + i3 * 4);
         if (v !== FREESECT) difat.push(v);
       }
-      ds = u32(base2 + (entriesPerSector - 1) * 4);
+      ds = u322(base2 + (entriesPerSector - 1) * 4);
     }
     const fat = [];
     for (const fatSector of difat) {
@@ -52764,7 +52764,7 @@ ${e.toString()}`);
       if (fatSector >= maxSectors) continue;
       const base2 = sectorOffset(fatSector);
       for (let i3 = 0; i3 < entriesPerSector && fat.length < maxSectors; i3++) {
-        fat.push(u32(base2 + i3 * 4));
+        fat.push(u322(base2 + i3 * 4));
       }
     }
     const readChain = (src, start, size, ss, offOf, chain) => {
@@ -66301,6 +66301,221 @@ ${e.toString()}`);
     return val && typeof val === "object" ? val : {};
   }
 
+  // ../xlsx/src/biff8_styles.ts
+  var DEFAULT_PALETTE = [
+    "#000000",
+    "#FFFFFF",
+    "#FF0000",
+    "#00FF00",
+    "#0000FF",
+    "#FFFF00",
+    "#FF00FF",
+    "#00FFFF",
+    "#000000",
+    "#FFFFFF",
+    "#FF0000",
+    "#00FF00",
+    "#0000FF",
+    "#FFFF00",
+    "#FF00FF",
+    "#00FFFF",
+    "#800000",
+    "#008000",
+    "#000080",
+    "#808000",
+    "#800080",
+    "#008080",
+    "#C0C0C0",
+    "#808080",
+    "#9999FF",
+    "#993366",
+    "#FFFFCC",
+    "#CCFFFF",
+    "#660066",
+    "#FF8080",
+    "#0066CC",
+    "#CCCCFF",
+    "#000080",
+    "#FF00FF",
+    "#FFFF00",
+    "#00FFFF",
+    "#800080",
+    "#800000",
+    "#008080",
+    "#0000FF",
+    "#00CCFF",
+    "#CCFFFF",
+    "#CCFFCC",
+    "#FFFF99",
+    "#99CCFF",
+    "#FF99CC",
+    "#CC99FF",
+    "#FFCC99",
+    "#3366FF",
+    "#33CCCC",
+    "#99CC00",
+    "#FFCC00",
+    "#FF9900",
+    "#FF6600",
+    "#666699",
+    "#969696",
+    "#003366",
+    "#339966",
+    "#003300",
+    "#333300",
+    "#993300",
+    "#993366",
+    "#333399",
+    "#333333"
+  ];
+  var AUTOMATIC = /* @__PURE__ */ new Set([64, 65, 32767]);
+  var u162 = (b, o) => b[o] | b[o + 1] << 8;
+  var u32 = (b, o) => (u162(b, o) | u162(b, o + 2) << 16) >>> 0;
+  function parsePalette(body) {
+    const palette = [...DEFAULT_PALETTE];
+    const count = u162(body, 0);
+    for (let i3 = 0; i3 < count && 2 + i3 * 4 + 3 < body.length; i3++) {
+      const o = 2 + i3 * 4;
+      const hex = (n) => n.toString(16).padStart(2, "0").toUpperCase();
+      palette[8 + i3] = `#${hex(body[o])}${hex(body[o + 1])}${hex(body[o + 2])}`;
+    }
+    return palette;
+  }
+  function defaultPalette() {
+    return [...DEFAULT_PALETTE];
+  }
+  function parseFont2(body) {
+    const grbit = u162(body, 2);
+    const uls = body[10];
+    const sss = u162(body, 8);
+    let name2 = "";
+    if (body.length > 15) {
+      const cch = body[14];
+      const high = (body[15] & 1) !== 0;
+      for (let i3 = 0; i3 < cch; i3++) {
+        const o = 16 + (high ? i3 * 2 : i3);
+        if (o >= body.length) break;
+        name2 += String.fromCharCode(high ? body[o] | body[o + 1] << 8 : body[o]);
+      }
+    }
+    return {
+      size: u162(body, 0) / 20,
+      bold: u162(body, 6) >= 600,
+      italic: (grbit & 2) !== 0,
+      strike: (grbit & 8) !== 0,
+      underline: uls === 1 || uls === 33 ? "single" : uls === 2 || uls === 34 ? "double" : void 0,
+      vertAlign: sss === 1 ? "superscript" : sss === 2 ? "subscript" : void 0,
+      colorIndex: u162(body, 4),
+      name: name2
+    };
+  }
+  function parseXf2(body) {
+    const alignByte = body[6] ?? 0;
+    const indentByte = body[8] ?? 0;
+    const b1 = u32(body, 10);
+    const b22 = u32(body, 14);
+    const fill = u162(body, 18);
+    const HORIZ = [
+      void 0,
+      "left",
+      "center",
+      "right",
+      void 0,
+      void 0,
+      "center"
+    ];
+    const VERT = ["top", "middle", "bottom", "middle", "middle"];
+    const rot = body[7] ?? 0;
+    return {
+      fontIndex: u162(body, 0),
+      horizontal: HORIZ[alignByte & 7],
+      vertical: VERT[alignByte >> 4 & 7],
+      wrap: (alignByte & 8) !== 0,
+      shrink: (indentByte & 16) !== 0,
+      indent: indentByte & 15,
+      // 0–90 means degrees; 91–180 means −1…−90; 255 is stacked/vertical text.
+      rotation: rot === 255 ? 255 : rot <= 90 ? rot : -(rot - 90),
+      borders: {
+        left: b1 & 15,
+        right: b1 >> 4 & 15,
+        top: b1 >> 8 & 15,
+        bottom: b1 >> 12 & 15,
+        leftColor: b1 >> 16 & 127,
+        rightColor: b1 >> 23 & 127,
+        topColor: b22 & 127,
+        bottomColor: b22 >> 7 & 127
+      },
+      fillPattern: b22 >>> 26 & 63,
+      fillFore: fill & 127,
+      fillBack: fill >> 7 & 127
+    };
+  }
+  var BORDER_STYLES = [
+    "none",
+    "thin",
+    "medium",
+    "dashed",
+    "dotted",
+    "thick",
+    "double",
+    "hair",
+    "mediumDashed",
+    "dashDot",
+    "mediumDashDot",
+    "dashDotDot",
+    "mediumDashDotDot",
+    "slantDashDot"
+  ];
+  var BORDER_WIDTH = { thick: 3, medium: 2, mediumDashed: 2, mediumDashDot: 2, mediumDashDotDot: 2, double: 3, hair: 1 };
+  function colorOf(index, palette) {
+    if (AUTOMATIC.has(index)) return void 0;
+    return palette[index];
+  }
+  function borderOf(style, colorIndex, palette) {
+    if (style === 0) return void 0;
+    const name2 = BORDER_STYLES[style] ?? "thin";
+    return { width: BORDER_WIDTH[name2] ?? 1, style: name2, color: colorOf(colorIndex, palette) ?? "#000000" };
+  }
+  function toCellStyle(xf, fonts, palette) {
+    const style = {};
+    const font = fonts[xf.fontIndex];
+    if (font) {
+      if (font.bold) style.fontBold = true;
+      if (font.italic) style.fontItalic = true;
+      if (font.strike) style.fontStrike = true;
+      if (font.underline) style.fontUnderline = font.underline;
+      if (font.vertAlign) style.fontVertAlign = font.vertAlign;
+      if (font.size > 0) style.fontSize = font.size;
+      if (font.name) style.fontName = font.name;
+      const color = colorOf(font.colorIndex, palette);
+      if (color) style.fontColor = color;
+    }
+    if (xf.horizontal) style.horizontalAlign = xf.horizontal;
+    if (xf.vertical) style.verticalAlign = xf.vertical;
+    if (xf.wrap) style.wrapText = true;
+    if (xf.shrink) style.shrinkToFit = true;
+    if (xf.indent > 0) style.indent = xf.indent;
+    if (xf.rotation === 255) style.textRotation = "vertical";
+    else if (xf.rotation !== 0) style.textRotation = xf.rotation;
+    const left = borderOf(xf.borders.left, xf.borders.leftColor, palette);
+    const right = borderOf(xf.borders.right, xf.borders.rightColor, palette);
+    const top = borderOf(xf.borders.top, xf.borders.topColor, palette);
+    const bottom = borderOf(xf.borders.bottom, xf.borders.bottomColor, palette);
+    if (left) style.borderLeft = left;
+    if (right) style.borderRight = right;
+    if (top) style.borderTop = top;
+    if (bottom) style.borderBottom = bottom;
+    if (xf.fillPattern === 1) {
+      const bg = colorOf(xf.fillFore, palette);
+      if (bg) style.backgroundColor = bg;
+    } else if (xf.fillPattern > 1) {
+      const bg = colorOf(xf.fillBack, palette);
+      if (bg) style.backgroundColor = bg;
+      style.patternType = "gray125";
+    }
+    return style;
+  }
+
   // ../xlsx/src/biff8_reader.ts
   var DEFAULT_MAX_ROWS = 1e4;
   var REC = {
@@ -66322,7 +66537,12 @@ ${e.toString()}`);
     MULBLANK: 190,
     LABELSST: 253,
     SST: 252,
-    BOF: 2057
+    BOF: 2057,
+    DEFCOLWIDTH: 85,
+    COLINFO: 125,
+    FONT: 49,
+    PALETTE: 146,
+    ROW: 520
   };
   function* iterRecords(stream, from2, to) {
     const dv = new DataView(stream.buffer, stream.byteOffset, stream.byteLength);
@@ -66340,6 +66560,9 @@ ${e.toString()}`);
     const sstChunks = [];
     const formats = /* @__PURE__ */ new Map();
     const xfFormatIds = [];
+    const xfRecords = [];
+    const fonts = [];
+    let palette = null;
     const boundsheets = [];
     let date1904 = false;
     let sawSst = false;
@@ -66383,8 +66606,17 @@ ${e.toString()}`);
         }
         case REC.XF: {
           xfFormatIds.push(readU16(r.body, 2));
+          xfRecords.push(r.body.slice());
+          break;
+        }
+        case REC.FONT: {
+          fonts.push(parseFont2(r.body));
+          if (fonts.length === 4) fonts.push(fonts[3]);
           break;
         }
+        case REC.PALETTE:
+          palette = parsePalette(r.body);
+          break;
         case REC.BOUNDSHEET: {
           const pos = dv.getUint32(r.offset + 4, true);
           boundsheets.push({ name: readUnicodeShort(r.body, 6, 1), pos });
@@ -66396,7 +66628,9 @@ ${e.toString()}`);
     }
     const sst = parseSst(sstChunks, sstUnique);
     const xfFormats = xfFormatIds.map((id) => formats.get(id) ?? builtinFormat(id));
-    return { sst, date1904, xfFormats, boundsheets };
+    const pal = palette ?? defaultPalette();
+    const xfStyles = xfRecords.map((body) => toCellStyle(parseXf2(body), fonts, pal));
+    return { sst, date1904, xfFormats, xfStyles, boundsheets };
   }
   function parseSst(chunks, count) {
     const out = [];
@@ -66481,26 +66715,55 @@ ${e.toString()}`);
         break;
       }
     }
+    const colDefs = /* @__PURE__ */ new Map();
+    const rowHeights = /* @__PURE__ */ new Map();
+    const hiddenRows = /* @__PURE__ */ new Set();
     for (const r of iterRecords(stream, start, end)) {
       switch (r.type) {
+        case REC.DEFCOLWIDTH: {
+          sheet.defaultColWidth = readU16(r.body, 0);
+          break;
+        }
+        case REC.COLINFO: {
+          const first2 = readU16(r.body, 0), last2 = readU16(r.body, 2);
+          const width = readU16(r.body, 4) / 256;
+          const grbit = readU16(r.body, 8);
+          const hidden = (grbit & 1) !== 0;
+          const outline = grbit >> 8 & 7;
+          for (let c = first2; c <= last2 && c <= 255; c++) {
+            colDefs.set(c, { index: c + 1, width, hidden, customWidth: true });
+            if (outline > 0) sheet.colOutlineLevels.set(c + 1, outline);
+          }
+          break;
+        }
+        case REC.ROW: {
+          const row = readU16(r.body, 0);
+          const grbit = readU16(r.body, 12);
+          const height = (readU16(r.body, 6) & 32767) / 20;
+          if (height > 0) rowHeights.set(row, height);
+          if ((grbit & 32) !== 0) hiddenRows.add(row);
+          const outline = grbit & 7;
+          if (outline > 0) sheet.rowOutlineLevels.set(row + 1, outline);
+          break;
+        }
         case REC.LABELSST: {
-          const row = readU16(r.body, 0), col = readU16(r.body, 2), isst = readU32(r.body, 6);
-          put(row, col, textCell(col, g.sst[isst] ?? ""));
+          const row = readU16(r.body, 0), col = readU16(r.body, 2), xf = readU16(r.body, 4), isst = readU32(r.body, 6);
+          put(row, col, textCell(col, g.sst[isst] ?? "", g.xfStyles[xf]));
           break;
         }
         case REC.LABEL: {
-          const row = readU16(r.body, 0), col = readU16(r.body, 2);
-          put(row, col, textCell(col, readUnicodeShort(r.body, 6, 2)));
+          const row = readU16(r.body, 0), col = readU16(r.body, 2), xf = readU16(r.body, 4);
+          put(row, col, textCell(col, readUnicodeShort(r.body, 6, 2), g.xfStyles[xf]));
           break;
         }
         case REC.NUMBER: {
           const row = readU16(r.body, 0), col = readU16(r.body, 2), xf = readU16(r.body, 4);
-          put(row, col, numberCell(col, readF64(r.body, 6), g.xfFormats[xf]));
+          put(row, col, numberCell(col, readF64(r.body, 6), g.xfFormats[xf], g.xfStyles[xf]));
           break;
         }
         case REC.RK: {
           const row = readU16(r.body, 0), col = readU16(r.body, 2), xf = readU16(r.body, 4);
-          put(row, col, numberCell(col, decodeRk(readU32(r.body, 6)), g.xfFormats[xf]));
+          put(row, col, numberCell(col, decodeRk(readU32(r.body, 6)), g.xfFormats[xf], g.xfStyles[xf]));
           break;
         }
         case REC.MULRK: {
@@ -66509,13 +66772,13 @@ ${e.toString()}`);
           for (let i3 = 0; i3 < n; i3++) {
             const xf = readU16(r.body, 4 + i3 * 6);
             const rk = readU32(r.body, 6 + i3 * 6);
-            put(row, first2 + i3, numberCell(first2 + i3, decodeRk(rk), g.xfFormats[xf]));
+            put(row, first2 + i3, numberCell(first2 + i3, decodeRk(rk), g.xfFormats[xf], g.xfStyles[xf]));
           }
           break;
         }
         case REC.FORMULA: {
           const row = readU16(r.body, 0), col = readU16(r.body, 2), xf = readU16(r.body, 4);
-          const cell = formulaCell(col, r.body, g.xfFormats[xf]);
+          const cell = formulaCell(col, r.body, g.xfFormats[xf], g.xfStyles[xf]);
           if (cell) put(row, col, cell);
           break;
         }
@@ -66529,17 +66792,23 @@ ${e.toString()}`);
       const r = grid.get(ri);
       if (!r) continue;
       const cells = [...r.values()].sort((a, b) => a.column - b.column);
-      rows.push({ index: ri + 1, height: sheet.defaultRowHeight, cells, hidden: false });
+      rows.push({
+        index: ri + 1,
+        height: rowHeights.get(ri) ?? sheet.defaultRowHeight,
+        cells,
+        hidden: hiddenRows.has(ri)
+      });
     }
     sheet.rows = rows;
+    sheet.columns = [...colDefs.values()].sort((a, b) => a.index - b.index);
     sheet.totalRowCount = maxRow + 1;
     sheet.truncated = truncated;
     return sheet;
   }
-  function textCell(column, text) {
-    return { column: column + 1, value: text, typedValue: text, content: { type: "plain", text }, style: {} };
+  function textCell(column, text, style = {}) {
+    return { column: column + 1, value: text, typedValue: text, content: { type: "plain", text }, style };
   }
-  function numberCell(column, num3, numFmt) {
+  function numberCell(column, num3, numFmt, style = {}) {
     const value2 = Number.isFinite(num3) ? String(num3) : "";
     return {
       column: column + 1,
@@ -66548,19 +66817,19 @@ ${e.toString()}`);
       typedValue: num3,
       numFmtCode: numFmt && numFmt !== "General" ? numFmt : void 0,
       content: { type: "plain", text: value2 },
-      style: {}
+      style
     };
   }
-  function formulaCell(column, body, numFmt) {
+  function formulaCell(column, body, numFmt, style = {}) {
     if (readU16(body, 12) === 65535) {
       const kind = body[6];
       if (kind === 1) {
         const b = body[8] !== 0;
-        return { column: column + 1, value: b ? "TRUE" : "FALSE", typedValue: b, content: { type: "plain", text: b ? "TRUE" : "FALSE" }, style: {} };
+        return { column: column + 1, value: b ? "TRUE" : "FALSE", typedValue: b, content: { type: "plain", text: b ? "TRUE" : "FALSE" }, style };
       }
       return null;
     }
-    return numberCell(column, readF64(body, 6), numFmt);
+    return numberCell(column, readF64(body, 6), numFmt, style);
   }
   function decodeRk(rk) {
     const div100 = (rk & 1) !== 0;