@lotics/cli 0.64.0 → 0.66.0

package/dist/src/cli.js

@@ -3387,7 +3387,7 @@ var require_jstat = __commonJS({
       }
     })(exports2, function() {
       var jStat = (function(Math2, undefined2) {
-        var concat = Array.prototype.concat;
+        var concat2 = Array.prototype.concat;
         var slice = Array.prototype.slice;
         var toString = Object.prototype.toString;
         function calcRdx(n, m) {
@@ -3407,7 +3407,7 @@ var require_jstat = __commonJS({
           return typeof num === "number" ? num - num === 0 : false;
         }
         function toVector(arr) {
-          return concat.apply([], arr);
+          return concat2.apply([], arr);
         }
         function jStat2() {
           return new jStat2._init(arguments);
@@ -20136,7 +20136,7 @@ var require_BufferList = __commonJS({
         }
         return ret;
       };
-      BufferList.prototype.concat = function concat(n) {
+      BufferList.prototype.concat = function concat2(n) {
         if (this.length === 0) return Buffer2.alloc(0);
         var ret = Buffer2.allocUnsafe(n >>> 0);
         var p = this.head;
@@ -23322,7 +23322,7 @@ var require_StreamHelper = __commonJS({
           return utils.transformTo(type, content);
       }
     }
-    function concat(type, dataArray) {
+    function concat2(type, dataArray) {
       var i2, index = 0, res = null, totalLength = 0;
       for (i2 = 0; i2 < dataArray.length; i2++) {
         totalLength += dataArray[i2].length;
@@ -23359,7 +23359,7 @@ var require_StreamHelper = __commonJS({
           reject2(err2);
         }).on("end", function() {
           try {
-            var result = transformZipOutput(resultType, concat(chunkType, dataArray), mimeType);
+            var result = transformZipOutput(resultType, concat2(chunkType, dataArray), mimeType);
             resolve(result);
           } catch (e) {
             reject2(e);
@@ -29881,6 +29881,17 @@ var LoticsClient = class {
       ...body.description ? { description: body.description } : {}
     });
   }
+  /**
+   * Bind (create or replace) an app query by alias via the `set_app_query` tool
+   * — the deploy-free authoring path for `apps.queries`, parallel to
+   * `setAppWorkflow`. `declaration` is the `{ ast, params? }` from
+   * `package.json#lotics.queries.<alias>`. The server validates it exactly as a
+   * deploy validates the manifest. Note: `apps.queries` is manifest-authoritative,
+   * so the next `lotics app deploy` overwrites this from the manifest.
+   */
+  async setAppQuery(app_id, alias, declaration) {
+    return this.execute("set_app_query", { app_id, alias, declaration });
+  }
   /**
    * Fetch one app workflow's faithful source + bound input/output schemas via
    * `get_app_workflow`. `source` is the JS-subset body re-rendered from the
@@ -30004,6 +30015,7 @@ var LoticsClient = class {
     if (args.capabilities !== void 0) {
       formData.append("capabilities", JSON.stringify(args.capabilities));
     }
+    formData.append("workflow_aliases", JSON.stringify(args.workflow_aliases ?? []));
     const url = `${this.baseUrl}/v1/apps/${encodeURIComponent(args.app_id)}/versions`;
     const response = await fetch(url, {
       method: "POST",
@@ -31803,7 +31815,7 @@ function inputDeclToTsType(decl) {
     case "date_range":
       return "{ start: string; end: string }";
     case "file":
-      return "string";
+      return decl.multi === true ? "ReadonlyArray<string>" : "string";
     case "object": {
       const fields = decl.fields !== null && typeof decl.fields === "object" ? decl.fields : {};
       return inputsToType(fields);
@@ -32219,6 +32231,8 @@ async function fetchLatestNpmVersion(packageName) {
 var WORKFLOWS_DIR = path5.join("src", "workflows");
 var WORKFLOW_GLOBALS_DIR = path5.join(".lotics", "workflows");
 var WORKFLOW_TSCONFIG_EXCLUDES = ["src/workflows", ".lotics/workflows"];
+var LOTICS_INCLUDE_GLOB = ".lotics/**/*";
+var STALE_LOTICS_INCLUDES = /* @__PURE__ */ new Set([".lotics", "./.lotics", ".lotics/"]);
 var FALLBACK_ENVELOPE_PREFIX = "async function __workflow(): Promise<__WorkflowReturn | void> {\n";
 var FALLBACK_ENVELOPE_SUFFIX = "\n}";
 function workflowFileHeader(alias) {
@@ -32362,11 +32376,11 @@ function writeAppMeta(projectDir, meta) {
   pkg2.lotics = meta;
   fs4.writeFileSync(pkgPath2, JSON.stringify(pkg2, null, 2) + "\n");
 }
-function ensureWorkflowTsconfigExcludes(projectDir) {
+function ensureAppTsconfig(projectDir) {
   const tsconfigPath = path5.join(projectDir, "tsconfig.json");
   if (!fs4.existsSync(tsconfigPath)) {
     console.error(
-      `\u26A0 No tsconfig.json at ${projectDir} \u2014 could not ensure ${WORKFLOW_TSCONFIG_EXCLUDES.join(", ")} are excluded. Add them to your tsconfig's "exclude" so npm run typecheck skips the workflow bodies.`
+      `\u26A0 No tsconfig.json at ${projectDir} \u2014 could not ensure "include" has "${LOTICS_INCLUDE_GLOB}" (a bare .lotics loads none of the generated types) or "exclude" has ${WORKFLOW_TSCONFIG_EXCLUDES.join(", ")}.`
     );
     return;
   }
@@ -32375,20 +32389,29 @@ function ensureWorkflowTsconfigExcludes(projectDir) {
     parsed = JSON.parse(fs4.readFileSync(tsconfigPath, "utf-8"));
   } catch (err2) {
     console.error(
-      `\u26A0 Could not parse tsconfig.json (${err2 instanceof Error ? err2.message : String(err2)}) \u2014 add ${WORKFLOW_TSCONFIG_EXCLUDES.join(", ")} to its "exclude" manually so npm run typecheck skips the workflow bodies.`
+      `\u26A0 Could not parse tsconfig.json (${err2 instanceof Error ? err2.message : String(err2)}) \u2014 ensure "include" has "${LOTICS_INCLUDE_GLOB}" and "exclude" has ${WORKFLOW_TSCONFIG_EXCLUDES.join(", ")} manually.`
     );
     return;
   }
   if (!parsed || typeof parsed !== "object") return;
-  const current = Array.isArray(parsed.exclude) ? parsed.exclude : [];
-  const currentStrings = current.filter((e) => typeof e === "string");
-  const toAdd = WORKFLOW_TSCONFIG_EXCLUDES.filter((g) => !currentStrings.includes(g));
-  if (toAdd.length === 0) return;
-  parsed.exclude = [...currentStrings, ...toAdd];
+  const changes = [];
+  if (Array.isArray(parsed.include)) {
+    const inc = parsed.include.filter((e) => typeof e === "string");
+    if (inc.some((e) => STALE_LOTICS_INCLUDES.has(e))) {
+      const healed = inc.map((e) => STALE_LOTICS_INCLUDES.has(e) ? LOTICS_INCLUDE_GLOB : e);
+      parsed.include = healed.filter((e, i2) => healed.indexOf(e) === i2);
+      changes.push(`rewrote a bare ".lotics" to "${LOTICS_INCLUDE_GLOB}" in "include" (a dot-dir loads zero generated types)`);
+    }
+  }
+  const currentEx = Array.isArray(parsed.exclude) ? parsed.exclude.filter((e) => typeof e === "string") : [];
+  const toAdd = WORKFLOW_TSCONFIG_EXCLUDES.filter((g) => !currentEx.includes(g));
+  if (toAdd.length > 0) {
+    parsed.exclude = [...currentEx, ...toAdd];
+    changes.push(`added ${toAdd.join(", ")} to "exclude"`);
+  }
+  if (changes.length === 0) return;
   fs4.writeFileSync(tsconfigPath, JSON.stringify(parsed, null, 2) + "\n");
-  console.error(
-    `Patched tsconfig.json: added ${toAdd.join(", ")} to "exclude" so npm run typecheck skips the workflow bodies (check them with: lotics app workflow check).`
-  );
+  console.error(`Patched tsconfig.json: ${changes.join("; ")}.`);
 }
 function writeAppDts(projectDir, manifest) {
   const dotLotics = path5.join(projectDir, ".lotics");
@@ -32399,6 +32422,7 @@ function writeAppDts(projectDir, manifest) {
     [path5.join(dotLotics, "app_agents.d.ts"), generateAppAgentsDts(manifest.agents)]
   ];
   for (const [file, content] of written) fs4.writeFileSync(file, content);
+  ensureAppTsconfig(projectDir);
   return written.map(([file]) => file);
 }
 function readCodegenTablesAllowlist(projectDir) {
@@ -32447,7 +32471,6 @@ async function appCodegen(args) {
     );
   }
   await refreshWorkflowGlobals(args.client, projectDir, meta.app_id, Object.keys(meta.workflows ?? {}));
-  if (Object.keys(meta.workflows ?? {}).length > 0) ensureWorkflowTsconfigExcludes(projectDir);
 }
 async function refreshWorkflowGlobals(client, projectDir, app_id, aliases) {
   for (const alias of aliases) {
@@ -32630,7 +32653,6 @@ async function appPull(client, args) {
         `Wrote ${written.length} workflow ${written.length === 1 ? "body" : "bodies"} to ${WORKFLOWS_DIR}/ (${written.join(", ")})`
       );
     }
-    ensureWorkflowTsconfigExcludes(targetPath);
   }
   console.error(`Installing npm dependencies...`);
   await runNpm(["install"], targetPath);
@@ -32720,10 +32742,14 @@ async function appDeploy(client, args) {
         // defaulting to `{}` when the manifest declares none — so deleting the
         // `capabilities` block turns every capability OFF on the next deploy
         // (fail-safe; the declaration is the grant).
-        capabilities: meta.capabilities ?? {}
-        // Workflow bindings are NOT a deploy concern — set_app_workflow /
-        // remove_app_workflow own apps.workflows. The manifest's `workflows`
-        // map is a pulled reflection used only for the .d.ts codegen above.
+        capabilities: meta.capabilities ?? {},
+        // Workflow BINDINGS are NOT a deploy concern — set_app_workflow /
+        // remove_app_workflow own apps.workflows. But the alias KEYS of the
+        // manifest's `workflows` map ARE sent (never the bindings): they record
+        // which aliases this bundle declares, so remove_app_workflow can refuse
+        // to unbind an alias the served version still calls. Drop an alias from
+        // the manifest + redeploy to lift that guard before removing its binding.
+        workflow_aliases: Object.keys(meta.workflows ?? {})
       });
       writeAppMeta(projectDir, {
         ...meta,
@@ -32932,6 +32958,25 @@ async function appWorkflowSet(client, args) {
     console.error(`  result.data schema: ${JSON.stringify(result.outputs)}`);
   }
 }
+async function appQuerySet(client, args) {
+  const projectDir = process.cwd();
+  const meta = readAppMeta(projectDir);
+  const declaration = meta.queries?.[args.alias];
+  if (!declaration) {
+    console.error(
+      `No query "${args.alias}" in package.json#lotics.queries. Declare it there (alias \u2192 { ast, params? }) first.`
+    );
+    process.exit(1);
+  }
+  const res = await client.setAppQuery(meta.app_id, args.alias, declaration);
+  if (res.error) {
+    console.error(`Failed to set query "${args.alias}": ${res.error}`);
+    process.exit(1);
+  }
+  console.error(
+    `Set query "${args.alias}" on ${meta.app_id}. (apps.queries is manifest-authoritative \u2014 the next 'lotics app deploy' re-syncs it.)`
+  );
+}
 async function appWorkflowPull(client) {
   const projectDir = process.cwd();
   const meta = readAppMeta(projectDir);
@@ -32945,7 +32990,7 @@ async function appWorkflowPull(client) {
   console.error(
     `Wrote ${written.length} workflow ${written.length === 1 ? "body" : "bodies"} to ${WORKFLOWS_DIR}/` + (written.length > 0 ? ` (${written.join(", ")})` : "")
   );
-  ensureWorkflowTsconfigExcludes(projectDir);
+  ensureAppTsconfig(projectDir);
 }
 async function appWorkflowCheck(args) {
   const projectDir = process.cwd();
@@ -33040,10 +33085,11 @@ function appUiLink(args) {
       `No vite.config.ts at ${projectDir}. Run inside a 'lotics app' project directory.`
     );
   }
-  const uiSrc = findUiSrcDir(projectDir);
-  if (!uiSrc) {
+  const explicit = args.uiSrc ?? process.env.LOTICS_UI_SRC;
+  const uiSrc = explicit ? path5.resolve(explicit) : findUiSrcDir(projectDir);
+  if (!uiSrc || !fs4.existsSync(uiSrc) || !fs4.statSync(uiSrc).isDirectory()) {
     throw new Error(
-      "Cannot find packages/ui/src by walking up from this directory \u2014 `lotics ui link` requires a monorepo checkout. External apps consume @lotics/ui from npm; bump the package version and widen the app's dependency range instead."
+      explicit ? `--ui-src / LOTICS_UI_SRC points at '${explicit}', which is not a directory. Pass the absolute path to the monorepo's packages/ui/src.` : "Cannot find packages/ui/src by walking up from this directory. For an EXTERNAL app (consuming @lotics/ui from npm), pass --ui-src=<abs path to packages/ui/src> or set LOTICS_UI_SRC; inside a monorepo checkout it is found automatically."
     );
   }
   const hasComponent = fs4.existsSync(path5.join(uiSrc, `${args.component}.tsx`)) || fs4.existsSync(path5.join(uiSrc, `${args.component}.ts`)) || fs4.existsSync(path5.join(uiSrc, args.component));
@@ -33098,6 +33144,7 @@ function parseArgs(argv) {
     apiKey: void 0,
     workspace: void 0,
     viewAs: void 0,
+    uiSrc: void 0,
     name: void 0,
     timezone: void 0,
     message: void 0,
@@ -33139,6 +33186,9 @@ function parseArgs(argv) {
       case "--view-as":
         flags.viewAs = argv[++i2];
         break;
+      case "--ui-src":
+        flags.uiSrc = argv[++i2];
+        break;
       case "--name":
         flags.name = argv[++i2];
         break;
@@ -42644,8 +42694,426 @@ function ensureVmlArray(val) {
   return Array.isArray(val) ? val : [val];
 }
 
+// ../xlsx/src/biff8_reader.ts
+var OLE2_MAGIC2 = [208, 207, 17, 224, 161, 177, 26, 225];
+var ENDOFCHAIN = 4294967294;
+var FREESECT = 4294967295;
+var DEFAULT_MAX_ROWS = 1e4;
+function isOle2(bytes) {
+  return bytes.length >= 8 && OLE2_MAGIC2.every((b, i2) => bytes[i2] === b);
+}
+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);
+  if (sectorSize < 512 || sectorSize > 1 << 20) {
+    throw new Error("Unsupported .xls: invalid OLE2 sector size");
+  }
+  const sectorOffset = (n) => sectorSize * (n + 1);
+  const difat = [];
+  for (let i2 = 0; i2 < 109; i2++) {
+    const v = u32(76 + i2 * 4);
+    if (v !== FREESECT) difat.push(v);
+  }
+  let ds = firstDifatSector;
+  const entriesPerSector = sectorSize / 4;
+  for (let guard = 0; ds !== ENDOFCHAIN && ds !== FREESECT && guard < 1 << 20; guard++) {
+    const base = sectorOffset(ds);
+    for (let i2 = 0; i2 < entriesPerSector - 1; i2++) {
+      const v = u32(base + i2 * 4);
+      if (v !== FREESECT) difat.push(v);
+    }
+    ds = u32(base + (entriesPerSector - 1) * 4);
+  }
+  const fat = [];
+  for (const fatSector of difat) {
+    const base = sectorOffset(fatSector);
+    for (let i2 = 0; i2 < entriesPerSector; i2++) fat.push(u32(base + i2 * 4));
+  }
+  const readChain = (src, start, size, ss, offOf, chain) => {
+    const maxSectors = Math.floor(src.length / ss) + 2;
+    const parts = [];
+    let s = start;
+    for (let guard = 0; s !== ENDOFCHAIN && s !== FREESECT && s < chain.length && guard < maxSectors; guard++) {
+      const o = offOf(s);
+      parts.push(src.subarray(o, o + ss));
+      s = chain[s];
+    }
+    const merged = concat(parts);
+    return size != null ? merged.subarray(0, size) : merged;
+  };
+  const readBig = (start, size) => readChain(bytes, start, size, sectorSize, sectorOffset, fat);
+  const dirBytes = readBig(firstDirSector, null);
+  const ddv = new DataView(dirBytes.buffer, dirBytes.byteOffset, dirBytes.byteLength);
+  const dir = [];
+  for (let off = 0; off + 128 <= dirBytes.length; off += 128) {
+    const nameLen = ddv.getUint16(off + 64, true);
+    const type = ddv.getUint8(off + 66);
+    if (nameLen < 2 || type === 0) continue;
+    const name = utf16le(dirBytes.subarray(off, off + nameLen - 2));
+    dir.push({ name, type, start: ddv.getUint32(off + 116, true), size: Number(ddv.getBigUint64(off + 120, true)) });
+  }
+  const root = dir.find((e) => e.type === 5);
+  const miniStream = root ? readBig(root.start, root.size) : new Uint8Array(0);
+  const miniFatBytes = readBig(firstMiniFatSector, null);
+  const miniFat = [];
+  for (let i2 = 0; i2 + 4 <= miniFatBytes.length; i2 += 4) miniFat.push(miniFatBytes[i2] | miniFatBytes[i2 + 1] << 8 | miniFatBytes[i2 + 2] << 16 | miniFatBytes[i2 + 3] << 24);
+  const readMini = (start, size) => readChain(miniStream, start, size, miniSectorSize, (n) => n * miniSectorSize, miniFat);
+  const readStream = (e) => e.size >= miniCutoff ? readBig(e.start, e.size) : readMini(e.start, e.size);
+  return dir.filter((e) => e.type === 2).map((e) => ({ name: e.name, bytes: readStream(e) }));
+}
+var REC = {
+  FORMULA: 6,
+  EOF: 10,
+  CONTINUE: 60,
+  DATEMODE: 34,
+  FILEPASS: 47,
+  BLANK: 513,
+  NUMBER: 515,
+  LABEL: 516,
+  STRING: 519,
+  BOOLERR: 517,
+  BOUNDSHEET: 133,
+  FORMAT: 1054,
+  XF: 224,
+  RK: 638,
+  MULRK: 189,
+  MULBLANK: 190,
+  LABELSST: 253,
+  SST: 252,
+  BOF: 2057
+};
+function* iterRecords(stream, from, to) {
+  const dv = new DataView(stream.buffer, stream.byteOffset, stream.byteLength);
+  let p = from;
+  while (p + 4 <= to) {
+    const type = dv.getUint16(p, true);
+    const len = dv.getUint16(p + 2, true);
+    const bodyStart = p + 4;
+    if (bodyStart + len > stream.length) break;
+    yield { type, body: stream.subarray(bodyStart, bodyStart + len), offset: p };
+    p = bodyStart + len;
+  }
+}
+function parseGlobals(stream) {
+  const sstChunks = [];
+  const formats = /* @__PURE__ */ new Map();
+  const xfFormatIds = [];
+  const boundsheets = [];
+  let date1904 = false;
+  let sawSst = false;
+  let sstUnique = 0;
+  let end = stream.length;
+  let started = false;
+  const dv = new DataView(stream.buffer, stream.byteOffset, stream.byteLength);
+  for (const r of iterRecords(stream, 0, stream.length)) {
+    if (r.type === REC.BOF) {
+      if (started) {
+        end = r.offset;
+        break;
+      }
+      started = true;
+      continue;
+    }
+    if (r.type === REC.EOF) {
+      end = r.offset;
+      break;
+    }
+  }
+  for (const r of iterRecords(stream, 0, end)) {
+    switch (r.type) {
+      case REC.FILEPASS:
+        throw new PasswordProtectedError();
+      case REC.DATEMODE:
+        date1904 = readU16(r.body, 0) === 1;
+        break;
+      case REC.SST:
+        sawSst = true;
+        sstUnique = readU32(r.body, 4);
+        sstChunks.push(r.body.subarray(8));
+        break;
+      case REC.CONTINUE:
+        if (sawSst) sstChunks.push(r.body);
+        break;
+      case REC.FORMAT: {
+        const id = readU16(r.body, 0);
+        formats.set(id, readUnicodeShort(r.body, 2, 2));
+        break;
+      }
+      case REC.XF: {
+        xfFormatIds.push(readU16(r.body, 2));
+        break;
+      }
+      case REC.BOUNDSHEET: {
+        const pos = dv.getUint32(r.offset + 4, true);
+        boundsheets.push({ name: readUnicodeShort(r.body, 6, 1), pos });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  const sst = parseSst(sstChunks, sstUnique);
+  const xfFormats = xfFormatIds.map((id) => formats.get(id) ?? builtinFormat(id));
+  return { sst, date1904, xfFormats, boundsheets };
+}
+function parseSst(chunks, count) {
+  const out = [];
+  if (chunks.length === 0) return out;
+  let ci = 0;
+  let off = 0;
+  const atEnd = () => ci >= chunks.length;
+  const cur = () => chunks[ci];
+  const advanceChunk = () => {
+    ci++;
+    off = 0;
+  };
+  const rawU8 = () => {
+    while (!atEnd() && off >= cur().length) advanceChunk();
+    if (atEnd()) return 0;
+    return cur()[off++];
+  };
+  const rawU16 = () => rawU8() | rawU8() << 8;
+  const rawU32 = () => rawU8() | rawU8() << 8 | rawU8() << 16 | rawU8() << 24;
+  const skip = (n) => {
+    for (let i2 = 0; i2 < n; i2++) rawU8();
+  };
+  for (let s = 0; s < count && !atEnd(); s++) {
+    const cch = rawU16();
+    const grbit = rawU8();
+    let high = (grbit & 1) !== 0;
+    const rich = (grbit & 8) !== 0 ? rawU16() : 0;
+    const ext = (grbit & 4) !== 0 ? rawU32() : 0;
+    let str = "";
+    let read = 0;
+    while (read < cch) {
+      if (off >= cur().length) {
+        advanceChunk();
+        if (atEnd()) break;
+        high = (cur()[off++] & 1) !== 0;
+      }
+      if (high) {
+        const code = cur()[off] | cur()[off + 1] << 8;
+        off += 2;
+        str += String.fromCharCode(code);
+      } else {
+        str += String.fromCharCode(cur()[off++]);
+      }
+      read++;
+    }
+    skip(rich * 4 + ext);
+    out.push(str);
+  }
+  return out;
+}
+function parseSheet2(stream, start, name, g, maxRows) {
+  const sheet = emptySheet(name);
+  const grid = /* @__PURE__ */ new Map();
+  let maxRow = -1;
+  let truncated = false;
+  const put = (row, col, cell) => {
+    if (row >= maxRows) {
+      truncated = true;
+      return;
+    }
+    let r = grid.get(row);
+    if (!r) {
+      r = /* @__PURE__ */ new Map();
+      grid.set(row, r);
+    }
+    r.set(col, cell);
+    if (row > maxRow) maxRow = row;
+  };
+  let end = stream.length;
+  let seenBof = false;
+  for (const r of iterRecords(stream, start, stream.length)) {
+    if (r.type === REC.BOF) {
+      if (seenBof) {
+        end = r.offset;
+        break;
+      }
+      seenBof = true;
+      continue;
+    }
+    if (r.type === REC.EOF) {
+      end = r.offset;
+      break;
+    }
+  }
+  for (const r of iterRecords(stream, start, end)) {
+    switch (r.type) {
+      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] ?? ""));
+        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)));
+        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]));
+        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]));
+        break;
+      }
+      case REC.MULRK: {
+        const row = readU16(r.body, 0), first2 = readU16(r.body, 2);
+        const n = (r.body.length - 6) / 6;
+        for (let i2 = 0; i2 < n; i2++) {
+          const xf = readU16(r.body, 4 + i2 * 6);
+          const rk = readU32(r.body, 6 + i2 * 6);
+          put(row, first2 + i2, numberCell(first2 + i2, decodeRk(rk), g.xfFormats[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]);
+        if (cell) put(row, col, cell);
+        break;
+      }
+      // BLANK / MULBLANK / BOOLERR carry no data value we surface — skipped.
+      default:
+        break;
+    }
+  }
+  const rows = [];
+  for (let ri = 0; ri <= maxRow; ri++) {
+    const r = grid.get(ri);
+    if (!r) continue;
+    const cells = [...r.values()].sort((a, b) => a.column - b.column);
+    rows.push({ index: ri, height: sheet.defaultRowHeight, cells, hidden: false });
+  }
+  sheet.rows = rows;
+  sheet.totalRowCount = maxRow + 1;
+  sheet.truncated = truncated;
+  return sheet;
+}
+function textCell(column, text) {
+  return { column, value: text, typedValue: text, content: { type: "plain", text }, style: {} };
+}
+function numberCell(column, num, numFmt) {
+  const value = Number.isFinite(num) ? String(num) : "";
+  return {
+    column,
+    value,
+    rawValue: num,
+    typedValue: num,
+    numFmtCode: numFmt && numFmt !== "General" ? numFmt : void 0,
+    content: { type: "plain", text: value },
+    style: {}
+  };
+}
+function formulaCell(column, body, numFmt) {
+  if (readU16(body, 12) === 65535) {
+    const kind = body[6];
+    if (kind === 1) {
+      const b = body[8] !== 0;
+      return { column, value: b ? "TRUE" : "FALSE", typedValue: b, content: { type: "plain", text: b ? "TRUE" : "FALSE" }, style: {} };
+    }
+    return null;
+  }
+  return numberCell(column, readF64(body, 6), numFmt);
+}
+function decodeRk(rk) {
+  const div100 = (rk & 1) !== 0;
+  const isInt = (rk & 2) !== 0;
+  let n;
+  if (isInt) {
+    n = rk >> 2;
+  } else {
+    const buf = new ArrayBuffer(8);
+    new DataView(buf).setUint32(4, rk & 4294967292, true);
+    n = new DataView(buf).getFloat64(0, true);
+  }
+  return div100 ? n / 100 : n;
+}
+function readU16(b, o) {
+  return b[o] | b[o + 1] << 8;
+}
+function readU32(b, o) {
+  return (b[o] | b[o + 1] << 8 | b[o + 2] << 16 | b[o + 3] << 24) >>> 0;
+}
+function readF64(b, o) {
+  return new DataView(b.buffer, b.byteOffset + o, 8).getFloat64(0, true);
+}
+function readUnicodeShort(b, offset, lenBytes) {
+  const cch = lenBytes === 1 ? b[offset] : readU16(b, offset);
+  const grbit = b[offset + lenBytes];
+  const high = (grbit & 1) !== 0;
+  let p = offset + lenBytes + 1;
+  let s = "";
+  for (let i2 = 0; i2 < cch; i2++) {
+    if (high) {
+      s += String.fromCharCode(b[p] | b[p + 1] << 8);
+      p += 2;
+    } else {
+      s += String.fromCharCode(b[p]);
+      p += 1;
+    }
+  }
+  return s;
+}
+function utf16le(b) {
+  let s = "";
+  for (let i2 = 0; i2 + 1 < b.length; i2 += 2) s += String.fromCharCode(b[i2] | b[i2 + 1] << 8);
+  return s;
+}
+function concat(parts) {
+  let total = 0;
+  for (const p of parts) total += p.length;
+  const out = new Uint8Array(total);
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+}
+function builtinFormat(id) {
+  const DATES = {
+    14: "m/d/yyyy",
+    15: "d-mmm-yy",
+    16: "d-mmm",
+    17: "mmm-yy",
+    18: "h:mm AM/PM",
+    19: "h:mm:ss AM/PM",
+    20: "h:mm",
+    21: "h:mm:ss",
+    22: "m/d/yyyy h:mm",
+    45: "mm:ss",
+    46: "[h]:mm:ss",
+    47: "mm:ss.0"
+  };
+  return DATES[id] ?? "General";
+}
+function parseBiff8(bytes, options) {
+  const streams = readCfbStreams(bytes);
+  if (streams.some((s) => /^EncryptedPackage$/i.test(s.name))) throw new PasswordProtectedError();
+  const wb = streams.find((s) => /^workbook$/i.test(s.name)) ?? streams.find((s) => /^book$/i.test(s.name));
+  if (!wb) throw new Error("Not a valid .xls: no Workbook stream in the OLE2 container");
+  const g = parseGlobals(wb.bytes);
+  const maxRows = options?.maxRowsPerSheet ?? DEFAULT_MAX_ROWS;
+  const sheets = g.boundsheets.length > 0 ? g.boundsheets.map((bs) => parseSheet2(wb.bytes, bs.pos, bs.name, g, maxRows)) : [emptySheet("Sheet1")];
+  return { sheets, activeSheetIndex: 0 };
+}
+
 // ../xlsx/src/excel_parser.ts
 function parseExcelBuffer(arrayBuffer, options) {
+  const bytes = new Uint8Array(arrayBuffer);
+  if (isOle2(bytes)) return parseBiff8(bytes, options);
   const zip = unzipXlsx(arrayBuffer);
   return parseExcelFromZip(zip, options);
 }
@@ -49222,11 +49690,16 @@ COMMANDS
   lotics app workflow pull             Rewrite src/workflows/*.ts from the server
   lotics app workflow check [alias]    Typecheck src/workflows bodies locally (one
                                        isolated program per alias; the app's own tsc)
+  lotics app query set <alias>         Push package.json#lotics.queries.<alias> to
+                                       apps.queries via set_app_query (no deploy;
+                                       re-synced by the next deploy from the manifest)
   lotics app subdomain <new-subdomain> Rename the app's public <slug>.lotics.app address
   lotics app rename "<new name>"       Rename the app's display name (launcher title)
   lotics app dev [path]                Run the app locally with HMR (RPC forwarded to prod)
-  lotics ui link <component> [--remove] Dev-link @lotics/ui to the monorepo's
-                                       packages/ui/src for live HMR (monorepo only)
+  lotics ui link <component> [--ui-src <path>] [--remove]
+                                       Dev-link @lotics/ui to packages/ui/src (Vite alias
+                                       + tsc paths) for live HMR + typecheck. Monorepo apps
+                                       auto-find it; external apps pass --ui-src / LOTICS_UI_SRC
   lotics xlsx <subcommand> ...         Read/write/edit .xlsx files on your local filesystem
                                        (uses the bundled Lotics xlsx engine; prefer over
                                        npm xlsx/exceljs for round-trip fidelity)
@@ -49590,15 +50063,16 @@ async function main() {
     if (subcommand === "link") {
       const component = toolArgs;
       if (!component) {
-        console.error("Usage: lotics ui link <component> [--remove]");
-        console.error("Dev-links @lotics/ui to the monorepo's packages/ui/src for live HMR.");
+        console.error("Usage: lotics ui link <component> [--ui-src <abs path>] [--remove]");
+        console.error("Dev-links @lotics/ui to packages/ui/src (Vite + tsc) for live HMR + typecheck.");
+        console.error("Monorepo apps find packages/ui/src automatically; external apps pass --ui-src / LOTICS_UI_SRC.");
         process.exit(1);
       }
-      appUiLink({ component, remove: restArgs.includes("--remove") });
+      appUiLink({ component, uiSrc: flags.uiSrc, remove: restArgs.includes("--remove") });
       return;
     }
     console.error(`Unknown ui subcommand: ${subcommand ?? "(none)"}`);
-    console.error("Usage: lotics ui link <component> [--remove]");
+    console.error("Usage: lotics ui link <component> [--ui-src <abs path>] [--remove]");
     process.exit(1);
   }
   if (command === "app" && subcommand === "workflow" && toolArgs === "check") {
@@ -49691,6 +50165,7 @@ async function main() {
     console.error("  lotics app workflow set <alias>           Push the edited src/workflows/<alias>.ts body");
     console.error("  lotics app workflow pull                  Rewrite src/workflows/*.ts from the server");
     console.error("  lotics app workflow check [alias]         Typecheck src/workflows bodies locally");
+    console.error("  lotics app query set <alias>              Push lotics.queries.<alias> to apps.queries (no deploy)");
     console.error("  lotics app subdomain <new-subdomain> Rename the app's public <slug>.lotics.app address");
     console.error(`  lotics app rename "<new name>"        Rename the app's display name (launcher title)`);
     console.error("  lotics app dev [path]                Run the app locally with HMR + RPC forwarding");
@@ -49896,6 +50371,26 @@ Available workspaces:`);
       }
       workflowUsage();
     }
+    if (subcommand === "query") {
+      const action = toolArgs;
+      if (action === "set") {
+        const alias = restArgs[0];
+        if (!alias) {
+          console.error("Usage: lotics app query set <alias>");
+          console.error(
+            "Pushes package.json#lotics.queries.<alias> to apps.queries via set_app_query (no deploy)."
+          );
+          process.exit(1);
+        }
+        await appQuerySet(client, { alias });
+        return;
+      }
+      console.error("Usage:");
+      console.error(
+        "  lotics app query set <alias>   Push package.json#lotics.queries.<alias> to apps.queries (no deploy)"
+      );
+      process.exit(1);
+    }
     if (subcommand === "dev") {
       const projectDir = toolArgs;
       let port;