@lotics/cli 0.60.1 → 0.62.1

package/dist/src/cli.js

@@ -12243,12 +12243,12 @@ var require_tokens = __commonJS({
       });
     }
     exports2.assignCategoriesMapProp = assignCategoriesMapProp;
-    function singleAssignCategoriesToksMap(path7, nextNode) {
-      utils_1.forEach(path7, function(pathNode) {
+    function singleAssignCategoriesToksMap(path8, nextNode) {
+      utils_1.forEach(path8, function(pathNode) {
         nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;
       });
       utils_1.forEach(nextNode.CATEGORIES, function(nextCategory) {
-        var newPath = path7.concat(nextNode);
+        var newPath = path8.concat(nextNode);
         if (!utils_1.contains(newPath, nextCategory)) {
           singleAssignCategoriesToksMap(newPath, nextCategory);
         }
@@ -14011,10 +14011,10 @@ var require_interpreter = __commonJS({
       /** @class */
       (function(_super) {
         __extends(AbstractNextPossibleTokensWalker2, _super);
-        function AbstractNextPossibleTokensWalker2(topProd, path7) {
+        function AbstractNextPossibleTokensWalker2(topProd, path8) {
           var _this = _super.call(this) || this;
           _this.topProd = topProd;
-          _this.path = path7;
+          _this.path = path8;
           _this.possibleTokTypes = [];
           _this.nextProductionName = "";
           _this.nextProductionOccurrence = 0;
@@ -14068,9 +14068,9 @@ var require_interpreter = __commonJS({
       /** @class */
       (function(_super) {
         __extends(NextAfterTokenWalker2, _super);
-        function NextAfterTokenWalker2(topProd, path7) {
-          var _this = _super.call(this, topProd, path7) || this;
-          _this.path = path7;
+        function NextAfterTokenWalker2(topProd, path8) {
+          var _this = _super.call(this, topProd, path8) || this;
+          _this.path = path8;
           _this.nextTerminalName = "";
           _this.nextTerminalOccurrence = 0;
           _this.nextTerminalName = _this.path.lastTok.name;
@@ -14767,10 +14767,10 @@ var require_lookahead = __commonJS({
       }
       return result;
     }
-    function pathToHashKeys(path7) {
+    function pathToHashKeys(path8) {
       var keys2 = [""];
-      for (var i2 = 0; i2 < path7.length; i2++) {
-        var tokType = path7[i2];
+      for (var i2 = 0; i2 < path8.length; i2++) {
+        var tokType = path8[i2];
         var longerKeys = [];
         for (var j = 0; j < keys2.length; j++) {
           var currShorterKey = keys2[j];
@@ -15082,9 +15082,9 @@ var require_checks = __commonJS({
       return errors;
     }
     exports2.validateRuleIsOverridden = validateRuleIsOverridden;
-    function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path7) {
-      if (path7 === void 0) {
-        path7 = [];
+    function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path8) {
+      if (path8 === void 0) {
+        path8 = [];
       }
       var errors = [];
       var nextNonTerminals = getFirstNoneTerminal(currRule.definition);
@@ -15097,15 +15097,15 @@ var require_checks = __commonJS({
           errors.push({
             message: errMsgProvider.buildLeftRecursionError({
               topLevelRule: topRule,
-              leftRecursionPath: path7
+              leftRecursionPath: path8
             }),
             type: parser_1.ParserDefinitionErrorType.LEFT_RECURSION,
             ruleName
           });
         }
-        var validNextSteps = utils.difference(nextNonTerminals, path7.concat([topRule]));
+        var validNextSteps = utils.difference(nextNonTerminals, path8.concat([topRule]));
         var errorsFromNextSteps = utils.map(validNextSteps, function(currRefRule) {
-          var newPath = utils.cloneArr(path7);
+          var newPath = utils.cloneArr(path8);
           newPath.push(currRefRule);
           return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);
         });
@@ -22714,8 +22714,8 @@ var require_utils4 = __commonJS({
       var result = transform[inputType][outputType](input);
       return result;
     };
-    exports2.resolve = function(path7) {
-      var parts = path7.split("/");
+    exports2.resolve = function(path8) {
+      var parts = path8.split("/");
       var result = [];
       for (var index = 0; index < parts.length; index++) {
         var part = parts[index];
@@ -28568,18 +28568,18 @@ var require_object = __commonJS({
       var object = new ZipObject(name, zipObjectContent, o);
       this.files[name] = object;
     };
-    var parentFolder = function(path7) {
-      if (path7.slice(-1) === "/") {
-        path7 = path7.substring(0, path7.length - 1);
+    var parentFolder = function(path8) {
+      if (path8.slice(-1) === "/") {
+        path8 = path8.substring(0, path8.length - 1);
       }
-      var lastSlash = path7.lastIndexOf("/");
-      return lastSlash > 0 ? path7.substring(0, lastSlash) : "";
+      var lastSlash = path8.lastIndexOf("/");
+      return lastSlash > 0 ? path8.substring(0, lastSlash) : "";
     };
-    var forceTrailingSlash = function(path7) {
-      if (path7.slice(-1) !== "/") {
-        path7 += "/";
+    var forceTrailingSlash = function(path8) {
+      if (path8.slice(-1) !== "/") {
+        path8 += "/";
       }
-      return path7;
+      return path8;
     };
     var folderAdd = function(name, createFolders) {
       createFolders = typeof createFolders !== "undefined" ? createFolders : defaults2.createFolders;
@@ -29581,8 +29581,8 @@ var require_lib3 = __commonJS({
 // src/cli.ts
 import dns from "node:dns";
 import net2 from "node:net";
-import fs7 from "node:fs";
-import path6 from "node:path";
+import fs8 from "node:fs";
+import path7 from "node:path";
 import readline from "node:readline";
 
 // src/client.ts
@@ -29680,8 +29680,8 @@ var LoticsClient = class {
     }
     return headers;
   }
-  async request(method, path7, body) {
-    const url = `${this.baseUrl}${path7}`;
+  async request(method, path8, body) {
+    const url = `${this.baseUrl}${path8}`;
     const headers = this.buildHeaders();
     const init = { method, headers };
     if (body !== void 0) {
@@ -30342,8 +30342,8 @@ var pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
 var VERSION = pkg.version;
 
 // src/app_commands.ts
-import fs3 from "node:fs";
-import path4 from "node:path";
+import fs4 from "node:fs";
+import path5 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 import { tmpdir } from "node:os";
 
@@ -30403,7 +30403,9 @@ function buildStarterTemplate(args) {
             "@vitejs/plugin-react": "^4.3.0",
             jsdom: "^25.0.0",
             oxlint: "^0.13.0",
-            typescript: "^5.6.0",
+            // Track the platform's TS major so `lotics app workflow check` (which runs
+            // the app's OWN typescript) gives the same verdict the server does at set-time.
+            typescript: "~6.0.3",
             vite: "^5.4.0",
             vitest: "^2.1.0"
           },
@@ -30447,45 +30449,17 @@ function buildStarterTemplate(args) {
           // base, which IS read. (GAP-38.)
           include: ["src", ".lotics/**/*"],
           // src/workflows/<alias>.ts bodies run on the server (workflow globals:
-          // trigger / runtime / tool calls). They ARE locally typecheckable —
-          // each is wrapped in the server's `__workflow` envelope and references
-          // its per-alias `.lotics/workflows/<alias>.globals.d.ts` — but under a
-          // DEDICATED config that mirrors the server's compile options (es2022
-          // lib, NO DOM). The main `npm run typecheck` excludes them so it stays
-          // green and DOM-lib-free for bodies; check a body with
-          // `tsc -p tsconfig.workflows.json`. The server is the single verifier
-          // on `lotics app workflow set`.
-          exclude: ["node_modules", "src/workflows"]
-        },
-        null,
-        2
-      ) + "\n"
-    },
-    {
-      // Dedicated config for the editable workflow bodies (GAP-59). Mirrors the
-      // SERVER's set-time typecheck options (strict, lib es2022 with NO DOM,
-      // target ES2022, skipLibCheck) so a local `tsc -p tsconfig.workflows.json`
-      // gives the same verdict the server would on `lotics app workflow set`.
-      // Each body file is a module (the CLI writes a bookkeeping `export {};`),
-      // so the per-file `__workflow` wrapper doesn't collide across bodies.
-      path: "tsconfig.workflows.json",
-      content: JSON.stringify(
-        {
-          compilerOptions: {
-            target: "ES2022",
-            lib: ["ES2022"],
-            module: "ESNext",
-            moduleResolution: "Bundler",
-            strict: true,
-            skipLibCheck: true,
-            noEmit: true,
-            types: []
-          },
-          // The bodies + their per-alias ambient globals. `.lotics/workflows`
-          // uses the explicit `**/*` glob for the same dot-dir walk reason the
-          // main config does (TS's include walk skips bare dot-dirs).
-          include: ["src/workflows", ".lotics/workflows/**/*"],
-          exclude: ["node_modules"]
+          // trigger / runtime / tool calls), and each pulls its own per-alias
+          // ambient globals under `.lotics/workflows/`. BOTH are excluded from
+          // the main typecheck: the bodies would apply the app's DOM lib (the
+          // server doesn't), and the per-alias `.globals.d.ts` files each declare
+          // their OWN ambient `trigger` — loading several into one program
+          // collides those declarations and reports false errors. Type-check the
+          // bodies with `lotics app workflow check` instead — it builds ONE
+          // isolated program per alias (mirroring the server's set-time verify),
+          // so the ambient `trigger` is unambiguous. The server stays the single
+          // verifier on `lotics app workflow set`.
+          exclude: ["node_modules", "src/workflows", ".lotics/workflows"]
         },
         null,
         2
@@ -30846,6 +30820,7 @@ Editable JS-subset bodies of this app's workflows live here, one file per alias:
 \`\`\`bash
 lotics app workflow pull          # write/refresh every src/workflows/<alias>.ts from the server
 # edit src/workflows/<alias>.ts
+lotics app workflow check <alias> # typecheck the body locally (same verdict as \`set\`)
 lotics app workflow set <alias>   # push it back through set_app_workflow (the server verifies)
 \`\`\`
 
@@ -30857,15 +30832,17 @@ A workflow body is a **JS-subset expression** that runs server-side using workfl
 globals (\`trigger\`, \`runtime\`, tool calls) and ends with \`return({ data })\`. Each
 pulled file wraps the body in the server's \`__workflow\` envelope and references its
 per-alias ambient globals at \`.lotics/workflows/<alias>.globals.d.ts\`, so it **is**
-locally typecheckable \u2014 under the dedicated config that mirrors the server's compile
-options:
+locally typecheckable:
 
 \`\`\`bash
-tsc -p tsconfig.workflows.json   # same verdict the server gives on \`set\`
+lotics app workflow check        # check every body; [alias] to check one
 \`\`\`
 
-The main \`npm run typecheck\` excludes \`src/workflows\` (it would apply the app's
-DOM lib, which the server doesn't), so the bodies have their own config. The
+\`check\` builds ONE isolated program per alias (the app's own \`typescript\`, the
+server's compile options \u2014 strict, lib es2022 with no DOM), so each body's ambient
+\`trigger\` is unambiguous and the verdict mirrors set-time verify. The main
+\`npm run typecheck\` excludes \`src/workflows\` + \`.lotics/workflows\` (the bodies would
+apply the app's DOM lib, and the per-alias globals collide on \`trigger\`). The
 verification that matters still runs on the **server** when you \`set\` \u2014 the same
 guarantee as authoring via \`set_app_workflow\` directly. Edit only the body BETWEEN
 the wrapper lines; the wrapper, the \`/// <reference>\`, and the \`export {};\` marker
@@ -30905,6 +30882,9 @@ declare module "lucide-react-native/dist/esm/icons/*" {
   const classes: { [key: string]: string };
   export default classes;
 }
+
+// Plain side-effect CSS imports (@lotics/ui ships .tsx with import "./x.css").
+declare module "*.css";
 `
     },
     {
@@ -32119,6 +32099,98 @@ export type AppOptions = typeof OPT;
 `;
 }
 
+// src/app_workflow_check.ts
+import fs3 from "node:fs";
+import path4 from "node:path";
+import { createRequire } from "node:module";
+function workflowCheckCompilerOptions(tsApi) {
+  return {
+    target: tsApi.ScriptTarget.ES2022,
+    module: tsApi.ModuleKind.ESNext,
+    lib: ["lib.es2022.d.ts"],
+    strict: true,
+    noImplicitAny: true,
+    strictNullChecks: true,
+    noImplicitReturns: false,
+    noEmit: true,
+    allowJs: false,
+    isolatedModules: false,
+    skipLibCheck: true,
+    moduleResolution: tsApi.ModuleResolutionKind.NodeNext,
+    types: [],
+    declaration: false
+  };
+}
+function bodyLineOffset(wrappedSource) {
+  const lines = wrappedSource.split("\n");
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    if (/^\s*async\s+function\s+__workflow\s*\(/.test(lines[i2])) return i2 + 1;
+  }
+  return 0;
+}
+async function loadProjectTypescript(projectDir) {
+  const requireFromProject = createRequire(path4.join(projectDir, "package.json"));
+  let resolved;
+  try {
+    resolved = requireFromProject.resolve("typescript");
+  } catch {
+    throw new Error(
+      `Could not resolve 'typescript' from ${projectDir}. 'lotics app workflow check' type-checks bodies with the app's own compiler \u2014 run 'npm install' (the scaffold ships typescript as a devDependency).`
+    );
+  }
+  const mod = await import(pathToImportUrl(resolved));
+  return mod.default ?? mod;
+}
+function pathToImportUrl(p) {
+  const resolved = path4.resolve(p);
+  const prefixed = resolved.startsWith("/") ? resolved : `/${resolved}`;
+  return `file://${prefixed.split(path4.sep).join("/")}`;
+}
+function checkOneWorkflowBody(tsApi, input) {
+  const wrapped = fs3.readFileSync(input.bodyPath, "utf-8");
+  const offset = bodyLineOffset(wrapped);
+  const program = tsApi.createProgram({
+    rootNames: [input.globalsPath, input.bodyPath],
+    options: workflowCheckCompilerOptions(tsApi)
+  });
+  const bodyFile = program.getSourceFile(input.bodyPath);
+  if (!bodyFile) {
+    return [
+      {
+        line: 1,
+        col: 1,
+        code: "INTERNAL",
+        message: `workflow check: body file was not loaded (${input.bodyPath})`
+      }
+    ];
+  }
+  const issues = [];
+  for (const d of tsApi.getPreEmitDiagnostics(program)) {
+    if (d.file !== bodyFile) continue;
+    let line = 1;
+    let col = 1;
+    if (typeof d.start === "number") {
+      const lc2 = bodyFile.getLineAndCharacterOfPosition(d.start);
+      line = Math.max(1, lc2.line + 1 - offset);
+      col = lc2.character + 1;
+    }
+    issues.push({
+      line,
+      col,
+      code: `TS${d.code}`,
+      message: tsApi.flattenDiagnosticMessageText(d.messageText, "\n")
+    });
+  }
+  return issues;
+}
+function checkWorkflowBodies(tsApi, aliases) {
+  return aliases.map(({ alias, input }) => ({
+    alias,
+    bodyPath: input.bodyPath,
+    issues: checkOneWorkflowBody(tsApi, input)
+  }));
+}
+
 // src/app_commands.ts
 async function fetchLatestNpmVersion(packageName) {
   try {
@@ -32136,15 +32208,17 @@ async function fetchLatestNpmVersion(packageName) {
     return null;
   }
 }
-var WORKFLOWS_DIR = path4.join("src", "workflows");
-var WORKFLOW_GLOBALS_DIR = path4.join(".lotics", "workflows");
+var WORKFLOWS_DIR = path5.join("src", "workflows");
+var WORKFLOW_GLOBALS_DIR = path5.join(".lotics", "workflows");
+var WORKFLOW_TSCONFIG_EXCLUDES = ["src/workflows", ".lotics/workflows"];
 var FALLBACK_ENVELOPE_PREFIX = "async function __workflow(): Promise<__WorkflowReturn | void> {\n";
 var FALLBACK_ENVELOPE_SUFFIX = "\n}";
 function workflowFileHeader(alias) {
-  const refPath = path4.join("..", "..", WORKFLOW_GLOBALS_DIR, `${alias}.globals.d.ts`).split(path4.sep).join("/");
+  const refPath = path5.join("..", "..", WORKFLOW_GLOBALS_DIR, `${alias}.globals.d.ts`).split(path5.sep).join("/");
   return `/// <reference path="${refPath}" />
 // Auto-pulled workflow body for "${alias}". Edit the BODY between the wrapper
-// lines below, then push with:
+// lines below, then check + push with:
+//   lotics app workflow check ${alias}
 //   lotics app workflow set ${alias}
 // The push goes through set_app_workflow, where the SERVER verifies the body.
 // The __workflow wrapper + the reference above are CLI bookkeeping (stripped on
@@ -32154,25 +32228,25 @@ export {};
 `;
 }
 function workflowFilePath(projectDir, alias) {
-  return path4.join(projectDir, WORKFLOWS_DIR, `${alias}.ts`);
+  return path5.join(projectDir, WORKFLOWS_DIR, `${alias}.ts`);
 }
 function workflowGlobalsPath(projectDir, alias) {
-  return path4.join(projectDir, WORKFLOW_GLOBALS_DIR, `${alias}.globals.d.ts`);
+  return path5.join(projectDir, WORKFLOW_GLOBALS_DIR, `${alias}.globals.d.ts`);
 }
 function writeWorkflowGlobals(projectDir, alias, dts) {
-  const dir = path4.join(projectDir, WORKFLOW_GLOBALS_DIR);
-  fs3.mkdirSync(dir, { recursive: true });
+  const dir = path5.join(projectDir, WORKFLOW_GLOBALS_DIR);
+  fs4.mkdirSync(dir, { recursive: true });
   const file = workflowGlobalsPath(projectDir, alias);
-  fs3.writeFileSync(file, `${dts.replace(/\s+$/, "")}
+  fs4.writeFileSync(file, `${dts.replace(/\s+$/, "")}
 `);
   return file;
 }
 function writeWorkflowFile(projectDir, alias, source, envelope = { prefix: FALLBACK_ENVELOPE_PREFIX, suffix: FALLBACK_ENVELOPE_SUFFIX }) {
-  const dir = path4.join(projectDir, WORKFLOWS_DIR);
-  fs3.mkdirSync(dir, { recursive: true });
+  const dir = path5.join(projectDir, WORKFLOWS_DIR);
+  fs4.mkdirSync(dir, { recursive: true });
   const file = workflowFilePath(projectDir, alias);
   const body = source.replace(/\s+$/, "");
-  fs3.writeFileSync(file, `${workflowFileHeader(alias)}
+  fs4.writeFileSync(file, `${workflowFileHeader(alias)}
 ${envelope.prefix}${body}${envelope.suffix}
 `);
   return file;
@@ -32253,11 +32327,11 @@ function runNpm(args, cwd) {
   });
 }
 function readAppMeta(projectDir) {
-  const pkgPath2 = path4.join(projectDir, "package.json");
-  if (!fs3.existsSync(pkgPath2)) {
+  const pkgPath2 = path5.join(projectDir, "package.json");
+  if (!fs4.existsSync(pkgPath2)) {
     throw new Error(`No package.json found at ${projectDir}. Run 'lotics app create' first.`);
   }
-  const pkg2 = JSON.parse(fs3.readFileSync(pkgPath2, "utf-8"));
+  const pkg2 = JSON.parse(fs4.readFileSync(pkgPath2, "utf-8"));
   if (!pkg2.lotics?.app_id || !pkg2.lotics.workspace_id) {
     throw new Error(
       `package.json is missing the 'lotics' field with app_id and workspace_id. Was this folder created with 'lotics app create'?`
@@ -32275,24 +32349,52 @@ function readAppMeta(projectDir) {
   };
 }
 function writeAppMeta(projectDir, meta) {
-  const pkgPath2 = path4.join(projectDir, "package.json");
-  const pkg2 = JSON.parse(fs3.readFileSync(pkgPath2, "utf-8"));
+  const pkgPath2 = path5.join(projectDir, "package.json");
+  const pkg2 = JSON.parse(fs4.readFileSync(pkgPath2, "utf-8"));
   pkg2.lotics = meta;
-  fs3.writeFileSync(pkgPath2, JSON.stringify(pkg2, null, 2) + "\n");
+  fs4.writeFileSync(pkgPath2, JSON.stringify(pkg2, null, 2) + "\n");
+}
+function ensureWorkflowTsconfigExcludes(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.`
+    );
+    return;
+  }
+  let parsed;
+  try {
+    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.`
+    );
+    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];
+  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).`
+  );
 }
 function writeAppDts(projectDir, manifest) {
-  const dotLotics = path4.join(projectDir, ".lotics");
-  fs3.mkdirSync(dotLotics, { recursive: true });
+  const dotLotics = path5.join(projectDir, ".lotics");
+  fs4.mkdirSync(dotLotics, { recursive: true });
   const written = [
-    [path4.join(dotLotics, "app_workflows.d.ts"), generateAppWorkflowsDts(manifest.workflows)],
-    [path4.join(dotLotics, "app_queries.d.ts"), generateAppQueriesDts(manifest.queries)],
-    [path4.join(dotLotics, "app_agents.d.ts"), generateAppAgentsDts(manifest.agents)]
+    [path5.join(dotLotics, "app_workflows.d.ts"), generateAppWorkflowsDts(manifest.workflows)],
+    [path5.join(dotLotics, "app_queries.d.ts"), generateAppQueriesDts(manifest.queries)],
+    [path5.join(dotLotics, "app_agents.d.ts"), generateAppAgentsDts(manifest.agents)]
   ];
-  for (const [file, content] of written) fs3.writeFileSync(file, content);
+  for (const [file, content] of written) fs4.writeFileSync(file, content);
   return written.map(([file]) => file);
 }
 function readCodegenTablesAllowlist(projectDir) {
-  const pkg2 = JSON.parse(fs3.readFileSync(path4.join(projectDir, "package.json"), "utf-8"));
+  const pkg2 = JSON.parse(fs4.readFileSync(path5.join(projectDir, "package.json"), "utf-8"));
   const tables = pkg2.lotics?.codegen?.tables;
   return Array.isArray(tables) ? tables.filter((t) => typeof t === "string") : [];
 }
@@ -32305,14 +32407,14 @@ function resolveCodegenTableIds(projectDir, queries) {
   return [...ids];
 }
 function writeAppFields(projectDir, tables) {
-  const dotLotics = path4.join(projectDir, ".lotics");
-  fs3.mkdirSync(dotLotics, { recursive: true });
-  const file = path4.join(dotLotics, "app_fields.ts");
-  fs3.writeFileSync(file, generateAppFields(tables));
+  const dotLotics = path5.join(projectDir, ".lotics");
+  fs4.mkdirSync(dotLotics, { recursive: true });
+  const file = path5.join(dotLotics, "app_fields.ts");
+  fs4.writeFileSync(file, generateAppFields(tables));
   return file;
 }
 async function appCodegen(args) {
-  const projectDir = path4.resolve(args.projectDir ?? process.cwd());
+  const projectDir = path5.resolve(args.projectDir ?? process.cwd());
   const meta = readAppMeta(projectDir);
   const dtsPaths = writeAppDts(projectDir, {
     workflows: meta.workflows,
@@ -32337,16 +32439,17 @@ 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) {
     const file = workflowFilePath(projectDir, alias);
-    if (!fs3.existsSync(file)) continue;
-    const body = stripWorkflowHeader(fs3.readFileSync(file, "utf-8"));
+    if (!fs4.existsSync(file)) continue;
+    const body = stripWorkflowHeader(fs4.readFileSync(file, "utf-8"));
     if (body.trim() === "") continue;
     const envelope = await fetchWorkflowGlobals(client, projectDir, app_id, alias);
     writeWorkflowFile(projectDir, alias, body, envelope);
-    console.error(`Refreshed ${path4.relative(projectDir, file)} + its workflow types`);
+    console.error(`Refreshed ${path5.relative(projectDir, file)} + its workflow types`);
   }
 }
 function stampPulledManifest(projectDir, args) {
@@ -32367,21 +32470,21 @@ async function downloadToFile(url, destPath) {
     throw new Error(`Failed to download ${url}: ${response.status}`);
   }
   const buffer = Buffer.from(await response.arrayBuffer());
-  fs3.writeFileSync(destPath, buffer);
+  fs4.writeFileSync(destPath, buffer);
 }
 function appDirName(name) {
   const cleaned = name.replace(/[/\\]+/g, "-").replace(/[<>:"|?*]/g, "").replace(/\s+/g, " ").trim().replace(/^[.\s-]+|[.\s-]+$/g, "");
   return cleaned || "app";
 }
 async function appCreate(client, args) {
-  const targetPath = path4.resolve(args.targetPath ?? appDirName(args.name));
-  if (fs3.existsSync(targetPath)) {
-    const entries = fs3.readdirSync(targetPath);
+  const targetPath = path5.resolve(args.targetPath ?? appDirName(args.name));
+  if (fs4.existsSync(targetPath)) {
+    const entries = fs4.readdirSync(targetPath);
     if (entries.length > 0) {
       throw new Error(`Target directory ${targetPath} is not empty.`);
     }
   }
-  fs3.mkdirSync(targetPath, { recursive: true });
+  fs4.mkdirSync(targetPath, { recursive: true });
   const app = await client.createApp({ name: args.name });
   console.error(`Created app: ${app.name} (${app.id})`);
   const [uiLatest, sdkLatest] = await Promise.all([
@@ -32396,9 +32499,9 @@ async function appCreate(client, args) {
     sdk_version: sdkLatest ? `^${sdkLatest}` : void 0
   });
   for (const file of files) {
-    const fullPath = path4.join(targetPath, file.path);
-    fs3.mkdirSync(path4.dirname(fullPath), { recursive: true });
-    fs3.writeFileSync(fullPath, file.content);
+    const fullPath = path5.join(targetPath, file.path);
+    fs4.mkdirSync(path5.dirname(fullPath), { recursive: true });
+    fs4.writeFileSync(fullPath, file.content);
   }
   console.error(`Scaffolded ${files.length} files into ${targetPath}`);
   writeAppDts(targetPath, {});
@@ -32411,7 +32514,7 @@ async function appCreate(client, args) {
   });
   console.error(`
 Ready. Next steps:`);
-  console.error(`  cd ${path4.relative(process.cwd(), targetPath) || "."}`);
+  console.error(`  cd ${path5.relative(process.cwd(), targetPath) || "."}`);
   console.error(`  # edit src/App.tsx, then:`);
   console.error(`  lotics app deploy`);
 }
@@ -32426,6 +32529,21 @@ async function appRename(client, args) {
   if (res.error) throw new Error(res.error);
   console.error(`App renamed: "${args.name}" (${meta.app_id})`);
 }
+function defaultPullTarget(appId, appName) {
+  const cwdPkgPath = path5.join(process.cwd(), "package.json");
+  if (fs4.existsSync(cwdPkgPath)) {
+    let pkg2 = null;
+    try {
+      pkg2 = JSON.parse(fs4.readFileSync(cwdPkgPath, "utf-8"));
+    } catch (err2) {
+      console.error(
+        `\u26A0 Could not parse ${cwdPkgPath} (${err2 instanceof Error ? err2.message : String(err2)}) \u2014 pulling into a fresh ${appDirName(appName)}/ subdir.`
+      );
+    }
+    if (pkg2?.lotics?.app_id === appId) return process.cwd();
+  }
+  return appDirName(appName);
+}
 async function appPull(client, args) {
   const app = await client.getApp(args.app_id);
   if (!app.current_version_id) {
@@ -32435,16 +32553,16 @@ async function appPull(client, args) {
   }
   const version = await client.getAppVersion(app.id, app.current_version_id);
   const sourceUrl = await client.getAppVersionSourceUrl(app.id, version.id);
-  const targetPath = path4.resolve(args.targetPath ?? appDirName(app.name));
-  fs3.mkdirSync(targetPath, { recursive: true });
-  const tmpFile = path4.join(tmpdir(), `lotics-app-${app.id}-${Date.now()}.tar.gz`);
+  const targetPath = path5.resolve(args.targetPath ?? defaultPullTarget(app.id, app.name));
+  fs4.mkdirSync(targetPath, { recursive: true });
+  const tmpFile = path5.join(tmpdir(), `lotics-app-${app.id}-${Date.now()}.tar.gz`);
   console.error(`Downloading source archive...`);
   await downloadToFile(sourceUrl, tmpFile);
   try {
     console.error(`Extracting to ${targetPath}...`);
     await runTar(["-xzf", tmpFile, "-C", targetPath], targetPath);
   } finally {
-    if (fs3.existsSync(tmpFile)) fs3.unlinkSync(tmpFile);
+    if (fs4.existsSync(tmpFile)) fs4.unlinkSync(tmpFile);
   }
   stampPulledManifest(targetPath, {
     app_id: app.id,
@@ -32463,12 +32581,13 @@ 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);
   console.error(`
 Ready. Next steps:`);
-  console.error(`  cd ${path4.relative(process.cwd(), targetPath) || "."}`);
+  console.error(`  cd ${path5.relative(process.cwd(), targetPath) || "."}`);
   console.error(`  # edit src/App.tsx`);
   console.error(`  lotics app deploy`);
 }
@@ -32484,21 +32603,21 @@ function undeclaredCapabilities(sourceText, declared) {
   return used;
 }
 function readAppSourceText(projectDir) {
-  const srcDir = path4.join(projectDir, "src");
-  if (!fs3.existsSync(srcDir)) return "";
+  const srcDir = path5.join(projectDir, "src");
+  if (!fs4.existsSync(srcDir)) return "";
   const parts = [];
   const walk2 = (dir) => {
-    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-      const full = path4.join(dir, entry.name);
+    for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+      const full = path5.join(dir, entry.name);
       if (entry.isDirectory()) walk2(full);
-      else if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) parts.push(fs3.readFileSync(full, "utf8"));
+      else if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) parts.push(fs4.readFileSync(full, "utf8"));
     }
   };
   walk2(srcDir);
   return parts.join("\n");
 }
 async function appDeploy(client, args) {
-  const projectDir = path4.resolve(args.projectDir ?? process.cwd());
+  const projectDir = path5.resolve(args.projectDir ?? process.cwd());
   const meta = readAppMeta(projectDir);
   const undeclared = undeclaredCapabilities(readAppSourceText(projectDir), meta.capabilities);
   if (undeclared.length > 0) {
@@ -32512,14 +32631,14 @@ async function appDeploy(client, args) {
   writeAppDts(projectDir, { workflows: meta.workflows, queries: meta.queries, agents: meta.agents });
   console.error("Building...");
   await runNpm(["run", "build"], projectDir);
-  const distDir = path4.join(projectDir, "dist");
-  if (!fs3.existsSync(distDir)) {
+  const distDir = path5.join(projectDir, "dist");
+  if (!fs4.existsSync(distDir)) {
     throw new Error(
       `Build did not produce a dist/ directory in ${projectDir}. Check that 'npm run build' is configured correctly (Vite/etc. defaults to dist/).`
     );
   }
-  const tmpSource = path4.join(tmpdir(), `lotics-source-${Date.now()}.tar.gz`);
-  const tmpDist = path4.join(tmpdir(), `lotics-dist-${Date.now()}.tar.gz`);
+  const tmpSource = path5.join(tmpdir(), `lotics-source-${Date.now()}.tar.gz`);
+  const tmpDist = path5.join(tmpdir(), `lotics-dist-${Date.now()}.tar.gz`);
   try {
     console.error("Packaging source...");
     await runTar(
@@ -32541,8 +32660,8 @@ async function appDeploy(client, args) {
     try {
       const result = await client.deployAppVersion({
         app_id: meta.app_id,
-        source_archive: fs3.readFileSync(tmpSource),
-        dist_archive: fs3.readFileSync(tmpDist),
+        source_archive: fs4.readFileSync(tmpSource),
+        dist_archive: fs4.readFileSync(tmpDist),
         prev_version_id: meta.current_version_id,
         message: args.message,
         // Sync apps.queries from the manifest. Server validates each query
@@ -32576,8 +32695,8 @@ async function appDeploy(client, args) {
       throw err2;
     }
   } finally {
-    if (fs3.existsSync(tmpSource)) fs3.unlinkSync(tmpSource);
-    if (fs3.existsSync(tmpDist)) fs3.unlinkSync(tmpDist);
+    if (fs4.existsSync(tmpSource)) fs4.unlinkSync(tmpSource);
+    if (fs4.existsSync(tmpDist)) fs4.unlinkSync(tmpDist);
   }
 }
 async function warnIfUnbranded(client, appId) {
@@ -32598,7 +32717,7 @@ async function warnIfUnbranded(client, appId) {
   }
 }
 async function appDev(client, args) {
-  const projectDir = path4.resolve(args.projectDir ?? process.cwd());
+  const projectDir = path5.resolve(args.projectDir ?? process.cwd());
   const meta = readAppMeta(projectDir);
   writeAppDts(projectDir, { workflows: meta.workflows, queries: meta.queries, agents: meta.agents });
   const app = await client.getApp(meta.app_id);
@@ -32737,15 +32856,15 @@ async function appWorkflowSet(client, args) {
     process.exit(1);
   }
   const file = workflowFilePath(projectDir, args.alias);
-  if (!fs3.existsSync(file)) {
+  if (!fs4.existsSync(file)) {
     console.error(
-      `No workflow body at ${path4.relative(projectDir, file)}. Run 'lotics app pull ${meta.app_id}' to write src/workflows/${args.alias}.ts, then edit it.`
+      `No workflow body at ${path5.relative(projectDir, file)}. Run 'lotics app pull ${meta.app_id}' to write src/workflows/${args.alias}.ts, then edit it.`
     );
     process.exit(1);
   }
-  const source = stripWorkflowHeader(fs3.readFileSync(file, "utf-8"));
+  const source = stripWorkflowHeader(fs4.readFileSync(file, "utf-8"));
   if (source.trim() === "") {
-    console.error(`Workflow body ${path4.relative(projectDir, file)} is empty after stripping the header.`);
+    console.error(`Workflow body ${path5.relative(projectDir, file)} is empty after stripping the header.`);
     process.exit(1);
   }
   const res = await client.setAppWorkflow(meta.app_id, args.alias, {
@@ -32777,22 +32896,97 @@ 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);
+}
+async function appWorkflowCheck(args) {
+  const projectDir = process.cwd();
+  const meta = readAppMeta(projectDir);
+  const bound = Object.keys(meta.workflows ?? {});
+  let aliases;
+  if (args.alias) {
+    if (!bound.includes(args.alias)) {
+      console.error(
+        `No workflow "${args.alias}" in package.json#lotics.workflows. Bound aliases: ${bound.length > 0 ? bound.join(", ") : "(none)"}.`
+      );
+      process.exit(1);
+    }
+    aliases = [args.alias];
+  } else {
+    aliases = bound;
+  }
+  if (aliases.length === 0) {
+    console.error(`App ${meta.app_id} has no bound workflows to check.`);
+    return;
+  }
+  const toCheck = [];
+  for (const alias of aliases) {
+    const bodyPath = workflowFilePath(projectDir, alias);
+    const globalsPath = workflowGlobalsPath(projectDir, alias);
+    if (!fs4.existsSync(bodyPath)) {
+      console.error(
+        `\u26A0 Skipped "${alias}" \u2014 no body at ${path5.relative(projectDir, bodyPath)}. Run 'lotics app workflow pull' to write it.`
+      );
+      continue;
+    }
+    if (!fs4.existsSync(globalsPath)) {
+      console.error(
+        `Cannot check "${alias}" \u2014 missing types at ${path5.relative(projectDir, globalsPath)}. Run 'lotics app workflow pull' (or 'lotics app codegen') to fetch them.`
+      );
+      process.exit(1);
+    }
+    toCheck.push({ alias, input: { bodyPath, globalsPath } });
+  }
+  if (toCheck.length === 0) {
+    console.error("No workflow bodies to check (every bound alias was skipped).");
+    return;
+  }
+  const tsApi = await loadProjectTypescript(projectDir);
+  const results = checkWorkflowBodies(tsApi, toCheck);
+  printWorkflowCheckResults(projectDir, results);
+  const failed = results.filter((r) => r.issues.length > 0);
+  if (failed.length > 0) process.exit(1);
+}
+function printWorkflowCheckResults(projectDir, results) {
+  let totalErrors = 0;
+  for (const r of results) {
+    const rel = path5.relative(projectDir, r.bodyPath);
+    if (r.issues.length === 0) {
+      console.error(`\u2713 ${r.alias} (${rel}) \u2014 no type errors`);
+      continue;
+    }
+    totalErrors += r.issues.length;
+    console.error(
+      `\u2717 ${r.alias} (${rel}) \u2014 ${r.issues.length} error${r.issues.length === 1 ? "" : "s"}:`
+    );
+    for (const issue of r.issues) {
+      const [first2, ...rest] = issue.message.split("\n");
+      console.error(`    ${rel}:${issue.line}:${issue.col} - ${issue.code}: ${first2}`);
+      for (const line of rest) console.error(`      ${line}`);
+    }
+  }
+  const passed = results.length - results.filter((r) => r.issues.length > 0).length;
+  console.error(
+    totalErrors === 0 ? results.length === 1 ? `
+The workflow body type-checks clean.` : `
+All ${results.length} workflow bodies type-check clean.` : `
+${totalErrors} error${totalErrors === 1 ? "" : "s"} across ${results.length - passed} of ${results.length} ${results.length === 1 ? "body" : "bodies"}.`
+  );
 }
 function findUiSrcDir(start) {
-  let dir = path4.resolve(start);
+  let dir = path5.resolve(start);
   for (; ; ) {
-    const candidate = path4.join(dir, "packages", "ui", "src");
-    if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) return candidate;
-    const parent = path4.dirname(dir);
+    const candidate = path5.join(dir, "packages", "ui", "src");
+    if (fs4.existsSync(candidate) && fs4.statSync(candidate).isDirectory()) return candidate;
+    const parent = path5.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 var UI_ALIAS_FIND_SOURCE = String.raw`/^@lotics\/ui\/(.+)$/`;
 function appUiLink(args) {
-  const projectDir = path4.resolve(args.projectDir ?? process.cwd());
-  const viteConfigPath = path4.join(projectDir, "vite.config.ts");
-  if (!fs3.existsSync(viteConfigPath)) {
+  const projectDir = path5.resolve(args.projectDir ?? process.cwd());
+  const viteConfigPath = path5.join(projectDir, "vite.config.ts");
+  if (!fs4.existsSync(viteConfigPath)) {
     throw new Error(
       `No vite.config.ts at ${projectDir}. Run inside a 'lotics app' project directory.`
     );
@@ -32803,13 +32997,13 @@ function appUiLink(args) {
       "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."
     );
   }
-  const hasComponent = fs3.existsSync(path4.join(uiSrc, `${args.component}.tsx`)) || fs3.existsSync(path4.join(uiSrc, `${args.component}.ts`)) || fs3.existsSync(path4.join(uiSrc, args.component));
+  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));
   if (!hasComponent) {
     throw new Error(
       `No '@lotics/ui/${args.component}' under ${uiSrc} (expected ${args.component}.tsx/.ts). Check the component name.`
     );
   }
-  const source = fs3.readFileSync(viteConfigPath, "utf-8");
+  const source = fs4.readFileSync(viteConfigPath, "utf-8");
   const aliasEntry = `{ find: ${UI_ALIAS_FIND_SOURCE}, replacement: ${JSON.stringify(`${uiSrc}/$1`)} },`;
   const alreadyLinked = source.includes(UI_ALIAS_FIND_SOURCE);
   if (args.remove) {
@@ -32818,7 +33012,7 @@ function appUiLink(args) {
       return;
     }
     const stripped = source.replace(new RegExp(`^\\s*\\{ find: ${escapeRegExp(UI_ALIAS_FIND_SOURCE)}.*$\\n?`, "m"), "");
-    fs3.writeFileSync(viteConfigPath, stripped);
+    fs4.writeFileSync(viteConfigPath, stripped);
     console.error(`Removed the @lotics/ui dev-link alias from ${viteConfigPath}.`);
     console.error("Restart `lotics app dev` and rm -rf node_modules/.vite to clear cached modules.");
     return;
@@ -32836,7 +33030,7 @@ function appUiLink(args) {
   const insertAt = aliasMatch.index + aliasMatch[0].length;
   const updated = `${source.slice(0, insertAt)}
       ${aliasEntry}${source.slice(insertAt)}`;
-  fs3.writeFileSync(viteConfigPath, updated);
+  fs4.writeFileSync(viteConfigPath, updated);
   console.error(`Dev-linked @lotics/ui \u2192 ${uiSrc} in ${viteConfigPath}.`);
   console.error("Restart `lotics app dev` and rm -rf node_modules/.vite to clear cached modules.");
   console.error("Finalize: PR the packages/ui change \u2192 publish \u2192 `lotics ui link <component> --remove` + bump the app's dep.");
@@ -32973,11 +33167,11 @@ async function ingestJsonArgs(opts) {
 }
 
 // src/xlsx.ts
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 
 // src/file_command_io.ts
-import fs4 from "node:fs";
-import path5 from "node:path";
+import fs5 from "node:fs";
+import path6 from "node:path";
 var CliError = class extends Error {
   constructor(message) {
     super(message);
@@ -32988,14 +33182,14 @@ function fail(message) {
   throw new CliError(message);
 }
 function writeFileAtomic(filePath, bytes) {
-  const dir = path5.dirname(path5.resolve(filePath));
-  const tmp = path5.join(dir, `.${path5.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
-  fs4.writeFileSync(tmp, bytes);
+  const dir = path6.dirname(path6.resolve(filePath));
+  const tmp = path6.join(dir, `.${path6.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+  fs5.writeFileSync(tmp, bytes);
   try {
-    fs4.renameSync(tmp, filePath);
+    fs5.renameSync(tmp, filePath);
   } catch (error) {
     try {
-      fs4.unlinkSync(tmp);
+      fs5.unlinkSync(tmp);
     } catch {
     }
     throw error;
@@ -35778,16 +35972,16 @@ var MatcherView = class {
    * @returns {string|undefined}
    */
   getCurrentTag() {
-    const path7 = this._matcher.path;
-    return path7.length > 0 ? path7[path7.length - 1].tag : void 0;
+    const path8 = this._matcher.path;
+    return path8.length > 0 ? path8[path8.length - 1].tag : void 0;
   }
   /**
    * Get current namespace.
    * @returns {string|undefined}
    */
   getCurrentNamespace() {
-    const path7 = this._matcher.path;
-    return path7.length > 0 ? path7[path7.length - 1].namespace : void 0;
+    const path8 = this._matcher.path;
+    return path8.length > 0 ? path8[path8.length - 1].namespace : void 0;
   }
   /**
    * Get current node's attribute value.
@@ -35795,9 +35989,9 @@ var MatcherView = class {
    * @returns {*}
    */
   getAttrValue(attrName) {
-    const path7 = this._matcher.path;
-    if (path7.length === 0) return void 0;
-    return path7[path7.length - 1].values?.[attrName];
+    const path8 = this._matcher.path;
+    if (path8.length === 0) return void 0;
+    return path8[path8.length - 1].values?.[attrName];
   }
   /**
    * Check if current node has an attribute.
@@ -35805,9 +35999,9 @@ var MatcherView = class {
    * @returns {boolean}
    */
   hasAttr(attrName) {
-    const path7 = this._matcher.path;
-    if (path7.length === 0) return false;
-    const current = path7[path7.length - 1];
+    const path8 = this._matcher.path;
+    if (path8.length === 0) return false;
+    const current = path8[path8.length - 1];
     return current.values !== void 0 && attrName in current.values;
   }
   /**
@@ -35815,18 +36009,18 @@ var MatcherView = class {
    * @returns {number}
    */
   getPosition() {
-    const path7 = this._matcher.path;
-    if (path7.length === 0) return -1;
-    return path7[path7.length - 1].position ?? 0;
+    const path8 = this._matcher.path;
+    if (path8.length === 0) return -1;
+    return path8[path8.length - 1].position ?? 0;
   }
   /**
    * Get current node's repeat counter (occurrence count of this tag name).
    * @returns {number}
    */
   getCounter() {
-    const path7 = this._matcher.path;
-    if (path7.length === 0) return -1;
-    return path7[path7.length - 1].counter ?? 0;
+    const path8 = this._matcher.path;
+    if (path8.length === 0) return -1;
+    return path8[path8.length - 1].counter ?? 0;
   }
   /**
    * Get current node's sibling index (alias for getPosition).
@@ -37681,8 +37875,8 @@ function isAttribute(name) {
 }
 
 // ../../node_modules/fflate/esm/index.mjs
-import { createRequire } from "module";
-var require2 = createRequire("/");
+import { createRequire as createRequire2 } from "module";
+var require2 = createRequire2("/");
 var Worker;
 try {
   Worker = require2("worker_threads").Worker;
@@ -41282,10 +41476,10 @@ function resolveRelativePath(basePath, relativePath) {
   }
   return resolved.join("/");
 }
-function findZipEntry(zipEntries, path7) {
-  if (zipEntries[path7]) return zipEntries[path7];
-  if (zipEntries[`xl/${path7}`]) return zipEntries[`xl/${path7}`];
-  const noSlash = path7.replace(/^\//, "");
+function findZipEntry(zipEntries, path8) {
+  if (zipEntries[path8]) return zipEntries[path8];
+  if (zipEntries[`xl/${path8}`]) return zipEntries[`xl/${path8}`];
+  const noSlash = path8.replace(/^\//, "");
   if (zipEntries[noSlash]) return zipEntries[noSlash];
   return void 0;
 }
@@ -42583,9 +42777,9 @@ function parseExcelFromZip(zip, options) {
   }
   return result;
 }
-function findEntry(zip, path7) {
-  if (zip[path7]) return zip[path7];
-  const lower = path7.toLowerCase();
+function findEntry(zip, path8) {
+  if (zip[path8]) return zip[path8];
+  const lower = path8.toLowerCase();
   for (const key of Object.keys(zip)) {
     if (key.toLowerCase() === lower) return zip[key];
   }
@@ -43196,12 +43390,12 @@ function extractPivotRoundTripInfo(originalZip) {
     if (paths.length > 0) pivotTablesBySheetIndex.set(i2, paths);
   }
   const pivotXmlPaths = [];
-  for (const path7 of Object.keys(originalZip)) {
-    if (path7.startsWith("xl/pivotTables/") && path7.endsWith(".xml")) {
-      pivotXmlPaths.push(path7);
+  for (const path8 of Object.keys(originalZip)) {
+    if (path8.startsWith("xl/pivotTables/") && path8.endsWith(".xml")) {
+      pivotXmlPaths.push(path8);
     }
-    if (path7.startsWith("xl/pivotCache/") && path7.endsWith(".xml")) {
-      pivotXmlPaths.push(path7);
+    if (path8.startsWith("xl/pivotCache/") && path8.endsWith(".xml")) {
+      pivotXmlPaths.push(path8);
     }
   }
   return { cachesByWorkbook, pivotTablesBySheetIndex, pivotXmlPaths };
@@ -43209,15 +43403,15 @@ function extractPivotRoundTripInfo(originalZip) {
 function decode(bytes) {
   return new TextDecoder().decode(bytes);
 }
-function pivotContentTypeFor(path7) {
-  if (path7.startsWith("xl/pivotTables/") && path7.endsWith(".xml")) {
-    return `<Override PartName="/${path7}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"/>`;
+function pivotContentTypeFor(path8) {
+  if (path8.startsWith("xl/pivotTables/") && path8.endsWith(".xml")) {
+    return `<Override PartName="/${path8}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"/>`;
   }
-  if (path7.includes("/pivotCacheDefinition") && path7.endsWith(".xml")) {
-    return `<Override PartName="/${path7}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"/>`;
+  if (path8.includes("/pivotCacheDefinition") && path8.endsWith(".xml")) {
+    return `<Override PartName="/${path8}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"/>`;
   }
-  if (path7.includes("/pivotCacheRecords") && path7.endsWith(".xml")) {
-    return `<Override PartName="/${path7}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"/>`;
+  if (path8.includes("/pivotCacheRecords") && path8.endsWith(".xml")) {
+    return `<Override PartName="/${path8}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"/>`;
   }
   return void 0;
 }
@@ -43289,13 +43483,13 @@ function exportWorkbook(workbook, originalZip) {
       regeneratedPaths.add(`xl/worksheets/sheet${i2 + 1}.xml`);
       regeneratedPaths.add(`xl/worksheets/_rels/sheet${i2 + 1}.xml.rels`);
     }
-    for (const path7 of Object.keys(originalZip)) {
-      if (path7.startsWith("xl/drawings/") || path7.startsWith("xl/charts/") || path7.startsWith("xl/tables/") || path7.startsWith("xl/media/")) {
-        regeneratedPaths.add(path7);
+    for (const path8 of Object.keys(originalZip)) {
+      if (path8.startsWith("xl/drawings/") || path8.startsWith("xl/charts/") || path8.startsWith("xl/tables/") || path8.startsWith("xl/media/")) {
+        regeneratedPaths.add(path8);
       }
     }
-    for (const [path7, data] of Object.entries(originalZip)) {
-      if (!regeneratedPaths.has(path7)) entries[path7] = data;
+    for (const [path8, data] of Object.entries(originalZip)) {
+      if (!regeneratedPaths.has(path8)) entries[path8] = data;
     }
   }
   const sharedStrings = buildSharedStrings(workbook);
@@ -43310,8 +43504,8 @@ function exportWorkbook(workbook, originalZip) {
     buildWorkbookRels(workbook, pivotInfo)
   );
   const extraContentTypes = [];
-  for (const path7 of pivotInfo.pivotXmlPaths) {
-    const ct = pivotContentTypeFor(path7);
+  for (const path8 of pivotInfo.pivotXmlPaths) {
+    const ct = pivotContentTypeFor(path8);
     if (ct) extraContentTypes.push(ct);
   }
   let globalChartIndex = 1;
@@ -45072,14 +45266,14 @@ var DependencyGraph = class {
       stack.push({ cell: p, path: [cell, p] });
     }
     while (stack.length > 0) {
-      const { cell: current, path: path7 } = stack.pop();
-      if (current === cell) return path7;
+      const { cell: current, path: path8 } = stack.pop();
+      if (current === cell) return path8;
       if (visited.has(current)) continue;
       visited.add(current);
       const nextPrec = this.precedents.get(current);
       if (!nextPrec) continue;
       for (const p of nextPrec) {
-        stack.push({ cell: p, path: [...path7, p] });
+        stack.push({ cell: p, path: [...path8, p] });
       }
     }
     return null;
@@ -46070,8 +46264,8 @@ function adjustMergedCellsForColDelete(sheet, atCol, count) {
 
 // src/xlsx.ts
 function loadFile(filePath) {
-  if (!fs5.existsSync(filePath)) fail(`File not found: ${filePath}`);
-  const buffer = fs5.readFileSync(filePath);
+  if (!fs6.existsSync(filePath)) fail(`File not found: ${filePath}`);
+  const buffer = fs6.readFileSync(filePath);
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
   const originalZip = unzipXlsx(arrayBuffer);
   const parsed = parseExcelBuffer(arrayBuffer);
@@ -46121,7 +46315,7 @@ function lazyEngine(workbook) {
   };
 }
 function readToJson(filePath) {
-  const buffer = fs5.readFileSync(filePath);
+  const buffer = fs6.readFileSync(filePath);
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
   const parsed = parseExcelBuffer(arrayBuffer);
   return {
@@ -46511,7 +46705,7 @@ async function runXlsxCommand(subcommand, toolArgs, restArgs) {
 }
 
 // src/docx.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 
 // ../docx/src/parse/parser.ts
 var import_jszip = __toESM(require_lib3(), 1);
@@ -48282,11 +48476,11 @@ async function parseDocx(buffer) {
   const zip = await import_jszip.default.loadAsync(buffer);
   const parts = /* @__PURE__ */ new Map();
   const filePromises = [];
-  zip.forEach((path7, file) => {
+  zip.forEach((path8, file) => {
     if (file.dir) return;
     filePromises.push(
       file.async("uint8array").then((bytes) => {
-        parts.set(path7, bytes);
+        parts.set(path8, bytes);
       })
     );
   });
@@ -48515,9 +48709,9 @@ var DEFAULT_PARTS = [
   ["word/theme/theme1.xml", () => encoder.encode(THEME_XML)]
 ];
 function fillDefaultParts(parts) {
-  for (const [path7, makeBytes] of DEFAULT_PARTS) {
-    if (!parts.has(path7)) {
-      parts.set(path7, makeBytes());
+  for (const [path8, makeBytes] of DEFAULT_PARTS) {
+    if (!parts.has(path8)) {
+      parts.set(path8, makeBytes());
     }
   }
   return parts;
@@ -48527,9 +48721,9 @@ function fillDefaultParts(parts) {
 async function serializeDocx(doc) {
   const zip = new import_jszip2.default();
   const parts = fillDefaultParts(new Map(doc.parts));
-  for (const [path7, bytes] of parts) {
-    if (path7 === "word/document.xml") continue;
-    zip.file(path7, bytes);
+  for (const [path8, bytes] of parts) {
+    if (path8 === "word/document.xml") continue;
+    zip.file(path8, bytes);
   }
   const documentXml = serializeDocumentXml(doc);
   zip.file("word/document.xml", documentXml);
@@ -48615,8 +48809,8 @@ var DEFAULT_DOC_ATTRS = {
   "@_xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
 };
 async function loadFile2(filePath) {
-  if (!fs6.existsSync(filePath)) fail(`File not found: ${filePath}`);
-  const bytes = fs6.readFileSync(filePath);
+  if (!fs7.existsSync(filePath)) fail(`File not found: ${filePath}`);
+  const bytes = fs7.readFileSync(filePath);
   return parseDocx(new Uint8Array(bytes));
 }
 async function writeDoc(filePath, doc) {
@@ -48973,6 +49167,8 @@ COMMANDS
   lotics app workflow set <alias>      Push the edited src/workflows/<alias>.ts body
                                        through set_app_workflow (server verifies)
   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 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)
@@ -49080,8 +49276,8 @@ function prompt(question) {
     });
   });
 }
-async function publicPost(path7, body) {
-  const response = await fetch(`${API_BASE_URL}${path7}`, {
+async function publicPost(path8, body) {
+  const response = await fetch(`${API_BASE_URL}${path8}`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(body)
@@ -49227,13 +49423,13 @@ async function resolveWorkspace(client, ctx) {
 function resolveUploadPaths(rawPaths) {
   const result = [];
   for (const p of rawPaths) {
-    const resolved = path6.resolve(p);
-    const stat = fs7.statSync(resolved);
+    const resolved = path7.resolve(p);
+    const stat = fs8.statSync(resolved);
     if (stat.isDirectory()) {
-      const entries = fs7.readdirSync(resolved, { withFileTypes: true });
+      const entries = fs8.readdirSync(resolved, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile()) {
-          result.push(path6.join(resolved, entry.name));
+          result.push(path7.join(resolved, entry.name));
         }
       }
     } else {
@@ -49352,6 +49548,10 @@ async function main() {
     console.error("Usage: lotics ui link <component> [--remove]");
     process.exit(1);
   }
+  if (command === "app" && subcommand === "workflow" && toolArgs === "check") {
+    await appWorkflowCheck({ alias: restArgs[0] });
+    return;
+  }
   if (command === "app" && subcommand === "codegen") {
     const projectDir = toolArgs;
     const ctx2 = resolveContext(flags);
@@ -49436,6 +49636,7 @@ async function main() {
     console.error("  lotics app workflow run <alias> '<json>'  Execute a bound app workflow end-to-end");
     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 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");
@@ -49584,6 +49785,7 @@ Available workspaces:`);
         console.error("  lotics app workflow run <alias> '<json>'   Execute a bound app workflow");
         console.error("  lotics app workflow set <alias>            Push src/workflows/<alias>.ts");
         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");
         process.exit(1);
       };
       if (action === "run") {
@@ -49599,7 +49801,7 @@ Available workspaces:`);
         const ingested = await ingestJsonArgs({
           rawArg: restArgs[1],
           stdinIsTTY: process.stdin.isTTY ?? false,
-          readFile: (p) => fs7.readFileSync(p, "utf-8"),
+          readFile: (p) => fs8.readFileSync(p, "utf-8"),
           readStdin
         });
         if (ingested.kind === "error") {
@@ -49731,7 +49933,7 @@ ${JSON.stringify(info.input_schema, null, 2)}`);
     const ingested = await ingestJsonArgs({
       rawArg: toolArgs,
       stdinIsTTY: process.stdin.isTTY ?? false,
-      readFile: (p) => fs7.readFileSync(p, "utf-8"),
+      readFile: (p) => fs8.readFileSync(p, "utf-8"),
       readStdin
     });
     if (ingested.kind === "error") {