windmill-cli 1.684.1 → 1.686.0

package/esm/main.js

@@ -11812,7 +11812,7 @@ var init_OpenAPI = __esm(() => {
     PASSWORD: undefined,
     TOKEN: getEnv2("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: "1.684.1",
+    VERSION: "1.686.0",
     WITH_CREDENTIALS: true,
     interceptors: {
       request: new Interceptors,
@@ -26760,6 +26760,70 @@ var init_conf = __esm(async () => {
   RESERVED_WORKSPACE_KEYS = new Set(["commonSpecificItems"]);
 });
 
+// src/commands/resource-type/tsconfig.ts
+import { execSync as execSync3 } from "node:child_process";
+import { existsSync as existsSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import path3 from "node:path";
+import process10 from "node:process";
+async function generateTsconfigForIde() {
+  const tsconfigPath = path3.join(process10.cwd(), "tsconfig.json");
+  if (existsSync3(tsconfigPath)) {
+    info(colors.gray("tsconfig.json already exists, skipping"));
+    return;
+  }
+  let defaultTs = "bun";
+  try {
+    const conf = await readConfigFile({ warnIfMissing: false });
+    if (conf?.defaultTs === "deno") {
+      defaultTs = "deno";
+    }
+  } catch {}
+  const bunTypesAvailable = defaultTs === "bun" ? ensureBunTypesAvailable() : false;
+  const tsconfig = {
+    compilerOptions: {
+      target: "ESNext",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      noEmit: true,
+      strict: false
+    },
+    include: ["**/*.ts", "rt.d.ts"]
+  };
+  if (bunTypesAvailable) {
+    tsconfig.compilerOptions.types = ["bun-types"];
+  }
+  writeFileSync2(tsconfigPath, JSON.stringify(tsconfig, null, 2) + `
+`);
+  info(colors.green("Created tsconfig.json for IDE type support."));
+}
+function ensureBunTypesAvailable() {
+  const cwd = process10.cwd();
+  if (existsSync3(path3.join(cwd, "node_modules", "bun-types"))) {
+    return true;
+  }
+  try {
+    execSync3("bun --version", { stdio: "ignore" });
+  } catch {
+    info(`Install bun (https://bun.sh) then run 'bun add -d bun-types' and add "types": ["bun-types"] to tsconfig.json for Bun API autocompletion.`);
+    return false;
+  }
+  try {
+    info(colors.yellow("Installing bun-types with 'bun add -d bun-types'..."));
+    execSync3("bun add -d bun-types", { stdio: "inherit" });
+    info(colors.green("Installed bun-types."));
+    return true;
+  } catch (e) {
+    warn(`Failed to install bun-types automatically: ${e instanceof Error ? e.message : e}`);
+    info(`Run 'bun add -d bun-types' manually and add "types": ["bun-types"] to tsconfig.json for Bun API autocompletion.`);
+    return false;
+  }
+}
+var init_tsconfig = __esm(async () => {
+  init_colors2();
+  init_log();
+  await init_conf();
+});
+
 // src/utils/resource_types.ts
 function compileResourceTypeToTsType(schema) {
   function rec(x, root = false) {
@@ -26802,10 +26866,10 @@ __export(exports_resource_type, {
   generateRTNamespace: () => generateRTNamespace,
   default: () => resource_type_default
 });
-import { writeFileSync as writeFileSync2 } from "node:fs";
+import { writeFileSync as writeFileSync3 } from "node:fs";
 import { stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
-import path3 from "node:path";
-import process10 from "node:process";
+import path4 from "node:path";
+import process11 from "node:process";
 async function pushResourceType(workspace, remotePath, resource, localResource) {
   remotePath = removeType(remotePath, "resource-type");
   try {
@@ -26890,12 +26954,12 @@ async function newResourceType(opts, name) {
   });
   info(colors.green(`Created ${filePath}`));
 }
-async function get(opts, path4) {
+async function get(opts, path5) {
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   const rt = await getResourceType({
     workspace: workspace.workspaceId,
-    path: path4
+    path: path5
   });
   if (opts.json) {
     console.log(JSON.stringify(rt));
@@ -26925,8 +26989,9 @@ async function generateRTNamespace(opts) {
 `);
   namespaceContent += `
 }`;
-  writeFileSync2(path3.join(process10.cwd(), "rt.d.ts"), namespaceContent);
+  writeFileSync3(path4.join(process11.cwd(), "rt.d.ts"), namespaceContent);
   info(colors.green("Created rt.d.ts with resource types namespace (RT) for TypeScript."));
+  await generateTsconfigForIde();
 }
 var import_yaml5, command, resource_type_default;
 var init_resource_type = __esm(async () => {
@@ -26939,6 +27004,7 @@ var init_resource_type = __esm(async () => {
     init_types(),
     init_auth(),
     init_context(),
+    init_tsconfig(),
     init_utils()
   ]);
   import_yaml5 = __toESM(require_dist(), 1);
@@ -26961,7 +27027,7 @@ __export(exports_workspace, {
   add: () => add
 });
 import { readFile as readFile3, writeFile as writeFile3, open as fsOpen } from "node:fs/promises";
-import process11 from "node:process";
+import process12 from "node:process";
 async function allWorkspaces(configDirOverride) {
   try {
     const file = await getWorkspaceConfigFilePath(configDirOverride);
@@ -27073,7 +27139,7 @@ async function add(opts, workspaceName, workspaceId, remote) {
   }
   remote = new URL(remote).toString();
   let token = await tryGetLoginInfo(opts);
-  if (!token && !(process11.stdin.isTTY ?? false)) {
+  if (!token && !(process12.stdin.isTTY ?? false)) {
     info("Not a TTY, can't login interactively. Pass the token in --token");
     return;
   }
@@ -27115,7 +27181,7 @@ async function add(opts, workspaceName, workspaceId, remote) {
         info(`- ${workspace.id} (name: ${workspace.name})`);
       }
     }
-    process11.exit(1);
+    process12.exit(1);
   }
   const added = await addWorkspace({
     name: workspaceName,
@@ -27132,7 +27198,7 @@ async function add(opts, workspaceName, workspaceId, remote) {
 async function addWorkspace(workspace, opts) {
   workspace.remote = new URL(workspace.remote).toString();
   const existingWorkspaces = await allWorkspaces(opts.configDir);
-  const isInteractive = (process11.stdin.isTTY ?? false) && (process11.stdout.isTTY ?? false) && !opts.force;
+  const isInteractive = (process12.stdin.isTTY ?? false) && (process12.stdout.isTTY ?? false) && !opts.force;
   const nameConflict = existingWorkspaces.find((w) => w.name === workspace.name);
   if (nameConflict) {
     if (nameConflict.remote === workspace.remote && nameConflict.workspaceId === workspace.workspaceId) {
@@ -27285,7 +27351,7 @@ async function bind(opts, doBind) {
   if (!config.workspaces) {
     config.workspaces = {};
   }
-  const isInteractive = !!process11.stdin.isTTY;
+  const isInteractive = !!process12.stdin.isTTY;
   const inGitRepo = isGitRepository2();
   const currentBranch = inGitRepo ? getCurrentGitBranch2() : null;
   if (doBind) {
@@ -27472,16 +27538,16 @@ async function getBranchProfilesPath(configDirOverride) {
 }
 async function loadBranchProfiles(configDirOverride) {
   try {
-    const path4 = await getBranchProfilesPath(configDirOverride);
-    const content = await readFile4(path4, "utf-8");
+    const path5 = await getBranchProfilesPath(configDirOverride);
+    const content = await readFile4(path5, "utf-8");
     return JSON.parse(content);
   } catch {
     return { lastUsed: {} };
   }
 }
 async function saveBranchProfiles(mapping, configDirOverride) {
-  const path4 = await getBranchProfilesPath(configDirOverride);
-  await writeFile4(path4, JSON.stringify(mapping, null, 2), "utf-8");
+  const path5 = await getBranchProfilesPath(configDirOverride);
+  await writeFile4(path5, JSON.stringify(mapping, null, 2), "utf-8");
 }
 function getBranchProfileKey(branch, baseUrl2, workspaceId) {
   let normalizedUrl;
@@ -27914,8 +27980,8 @@ async function tryResolveVersion(opts) {
     return;
   }
 }
-function validatePath(path4) {
-  if (!(path4.startsWith("g") || path4.startsWith("u") || path4.startsWith("f"))) {
+function validatePath(path5) {
+  if (!(path5.startsWith("g") || path5.startsWith("u") || path5.startsWith("f"))) {
     info(colors.red("Given remote path looks invalid. Remote paths are typically of the form <u|g|f>/<username|group|folder>/..."));
     return false;
   }
@@ -32741,11 +32807,11 @@ var init_wrapper = __esm(() => {
 
 // src/commands/app/bundle.ts
 import * as fs7 from "node:fs";
-import * as path4 from "node:path";
-import process12 from "node:process";
+import * as path5 from "node:path";
+import process13 from "node:process";
 import { spawn } from "node:child_process";
 function detectFrameworks(appDir) {
-  const packageJsonPath = path4.join(appDir, "package.json");
+  const packageJsonPath = path5.join(appDir, "package.json");
   if (!fs7.existsSync(packageJsonPath)) {
     return { svelte: false, vue: false };
   }
@@ -32770,7 +32836,7 @@ function createSveltePlugin(appDir) {
       build.onLoad({ filter: /\.svelte$/ }, async (args) => {
         const svelte = await import("svelte/compiler");
         const source = await fs7.promises.readFile(args.path, "utf8");
-        const filename = path4.relative(process12.cwd(), args.path);
+        const filename = path5.relative(process13.cwd(), args.path);
         const convertMessage = ({ message, start, end }) => {
           let location;
           if (start && end) {
@@ -32811,8 +32877,8 @@ async function createFrameworkPlugins(appDir) {
   return plugins;
 }
 async function ensureNodeModules(appDir) {
-  const targetDir = appDir ?? process12.cwd();
-  const nodeModulesPath = path4.join(targetDir, "node_modules");
+  const targetDir = appDir ?? process13.cwd();
+  const nodeModulesPath = path5.join(targetDir, "node_modules");
   if (!fs7.existsSync(nodeModulesPath)) {
     info(colors.yellow("\uD83D\uDCE6 node_modules not found, running npm install..."));
     const code2 = await new Promise((resolve6, reject) => {
@@ -32832,7 +32898,7 @@ async function ensureNodeModules(appDir) {
 }
 async function createBundle(options = {}) {
   const esbuild = await import("esbuild");
-  const appDir = options.entryPoint ? path4.dirname(options.entryPoint) : process12.cwd();
+  const appDir = options.entryPoint ? path5.dirname(options.entryPoint) : process13.cwd();
   const frameworks = detectFrameworks(appDir);
   const defaultEntry = frameworks.svelte || frameworks.vue ? "index.ts" : "index.tsx";
   const entryPoint = options.entryPoint ?? defaultEntry;
@@ -32845,11 +32911,11 @@ async function createBundle(options = {}) {
   }
   await ensureNodeModules(appDir);
   const frameworkPlugins = await createFrameworkPlugins(appDir);
-  const distDir = path4.join(process12.cwd(), outDir);
+  const distDir = path5.join(process13.cwd(), outDir);
   if (!fs7.existsSync(distDir)) {
     fs7.mkdirSync(distDir, { recursive: true });
   }
-  const outfile = path4.join(outDir, "bundle.js");
+  const outfile = path5.join(outDir, "bundle.js");
   const wmillTs = rawAppWmillTs_exports.default ?? rawAppWmillTs_exports;
   const wmillPlugin = {
     name: "wmill-virtual",
@@ -32892,8 +32958,8 @@ async function createBundle(options = {}) {
       throw new Error("Build failed with errors");
     }
     info(colors.green("✅ Bundle created successfully"));
-    const jsPath = path4.join(process12.cwd(), outfile);
-    const cssPath = path4.join(process12.cwd(), outDir, "bundle.css");
+    const jsPath = path5.join(process13.cwd(), outfile);
+    const cssPath = path5.join(process13.cwd(), outDir, "bundle.css");
     if (!fs7.existsSync(jsPath)) {
       throw new Error(`Expected JS bundle at ${jsPath} but file not found`);
     }
@@ -34614,7 +34680,7 @@ var minimatch = (p, pattern, options = {}) => {
 }, qmarksTestNoExtDot = ([$0]) => {
   const len = $0.length;
   return (f) => f.length === len && f !== "." && f !== "..";
-}, defaultPlatform, path5, sep2, GLOBSTAR, qmark2 = "[^/]", star3, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
+}, defaultPlatform, path6, sep2, GLOBSTAR, qmark2 = "[^/]", star3, twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?", filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options), ext = (a, b = {}) => Object.assign({}, a, b), defaults = (def) => {
   if (!def || typeof def !== "object" || !Object.keys(def).length) {
     return minimatch;
   }
@@ -34672,11 +34738,11 @@ var init_esm2 = __esm(() => {
   starRE = /^\*+$/;
   qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
   defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-  path5 = {
+  path6 = {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  sep2 = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
+  sep2 = defaultPlatform === "win32" ? path6.win32.sep : path6.posix.sep;
   minimatch.sep = sep2;
   GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
@@ -37405,8 +37471,8 @@ var require_utils = __commonJS((exports) => {
     var result = transform[inputType][outputType](input);
     return result;
   };
-  exports.resolve = function(path6) {
-    var parts = path6.split("/");
+  exports.resolve = function(path7) {
+    var parts = path7.split("/");
     var result = [];
     for (var index = 0;index < parts.length; index++) {
       var part = parts[index];
@@ -42856,18 +42922,18 @@ var require_object = __commonJS((exports, module) => {
     var object = new ZipObject(name, zipObjectContent, o);
     this.files[name] = object;
   };
-  var parentFolder = function(path6) {
-    if (path6.slice(-1) === "/") {
-      path6 = path6.substring(0, path6.length - 1);
+  var parentFolder = function(path7) {
+    if (path7.slice(-1) === "/") {
+      path7 = path7.substring(0, path7.length - 1);
     }
-    var lastSlash = path6.lastIndexOf("/");
-    return lastSlash > 0 ? path6.substring(0, lastSlash) : "";
+    var lastSlash = path7.lastIndexOf("/");
+    return lastSlash > 0 ? path7.substring(0, lastSlash) : "";
   };
-  var forceTrailingSlash = function(path6) {
-    if (path6.slice(-1) !== "/") {
-      path6 += "/";
+  var forceTrailingSlash = function(path7) {
+    if (path7.slice(-1) !== "/") {
+      path7 += "/";
     }
-    return path6;
+    return path7;
   };
   var folderAdd = function(name, createFolders) {
     createFolders = typeof createFolders !== "undefined" ? createFolders : defaults2.createFolders;
@@ -49369,8 +49435,8 @@ var require_utils2 = __commonJS((exports, module) => {
     }
     return ind;
   }
-  function removeDotSegments(path6) {
-    let input = path6;
+  function removeDotSegments(path7) {
+    let input = path7;
     const output = [];
     let nextSlash = -1;
     let len = 0;
@@ -49560,8 +49626,8 @@ var require_schemes = __commonJS((exports, module) => {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path6, query] = wsComponent.resourceName.split("?");
-      wsComponent.path = path6 && path6 !== "/" ? path6 : undefined;
+      const [path7, query] = wsComponent.resourceName.split("?");
+      wsComponent.path = path7 && path7 !== "/" ? path7 : undefined;
       wsComponent.query = query;
       wsComponent.resourceName = undefined;
     }
@@ -52994,13 +53060,13 @@ var require_tslib = __commonJS((exports, module) => {
       }
       return next();
     };
-    __rewriteRelativeImportExtension = function(path6, preserveJsx) {
-      if (typeof path6 === "string" && /^\.\.?\//.test(path6)) {
-        return path6.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext2, cm) {
+    __rewriteRelativeImportExtension = function(path7, preserveJsx) {
+      if (typeof path7 === "string" && /^\.\.?\//.test(path7)) {
+        return path7.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext2, cm) {
           return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext2 || !cm) ? m : d + ext2 + "." + cm.toLowerCase() + "js";
         });
       }
-      return path6;
+      return path7;
     };
     exporter("__extends", __extends2);
     exporter("__assign", __assign2);
@@ -56304,19 +56370,19 @@ var require_buildJsonPath = __commonJS((exports) => {
   var types_1 = require_types2();
   var utils_1 = require_utils3();
   function buildJsonPath(node) {
-    const path6 = [];
+    const path7 = [];
     let prevNode = node;
     while (node) {
       switch (node.kind) {
         case types_1.Kind.SCALAR:
-          path6.unshift(node.value);
+          path7.unshift(node.value);
           break;
         case types_1.Kind.MAPPING:
           if (prevNode !== node.key) {
-            if (path6.length > 0 && utils_1.isObject(node.value) && node.value.value === path6[0]) {
-              path6[0] = node.key.value;
+            if (path7.length > 0 && utils_1.isObject(node.value) && node.value.value === path7[0]) {
+              path7[0] = node.key.value;
             } else {
-              path6.unshift(node.key.value);
+              path7.unshift(node.key.value);
             }
           }
           break;
@@ -56324,9 +56390,9 @@ var require_buildJsonPath = __commonJS((exports) => {
           if (prevNode) {
             const index = node.items.indexOf(prevNode);
             if (prevNode.kind === types_1.Kind.SCALAR) {
-              path6[0] = index;
+              path7[0] = index;
             } else if (index !== -1) {
-              path6.unshift(index);
+              path7.unshift(index);
             }
           }
           break;
@@ -56334,7 +56400,7 @@ var require_buildJsonPath = __commonJS((exports) => {
       prevNode = node;
       node = node.parent;
     }
-    return path6;
+    return path7;
   }
   exports.buildJsonPath = buildJsonPath;
 });
@@ -56393,10 +56459,10 @@ var require_getJsonPathForPosition = __commonJS((exports) => {
     const node = findClosestScalar(ast, Math.min(lineMap[line] - 1, startOffset + character), line, lineMap);
     if (!utils_1.isObject(node))
       return;
-    const path6 = buildJsonPath_1.buildJsonPath(node);
-    if (path6.length === 0)
+    const path7 = buildJsonPath_1.buildJsonPath(node);
+    if (path7.length === 0)
       return;
-    return path6;
+    return path7;
   };
   function* walk(node) {
     switch (node.kind) {
@@ -56517,8 +56583,8 @@ var require_getLocationForJsonPath = __commonJS((exports) => {
   var lineForPosition_1 = require_lineForPosition();
   var types_1 = require_types2();
   var utils_1 = require_utils3();
-  exports.getLocationForJsonPath = ({ ast, lineMap, metadata }, path6, closest = false) => {
-    const node = findNodeAtPath(ast, path6, { closest, mergeKeys: metadata !== undefined && metadata.mergeKeys === true });
+  exports.getLocationForJsonPath = ({ ast, lineMap, metadata }, path7, closest = false) => {
+    const node = findNodeAtPath(ast, path7, { closest, mergeKeys: metadata !== undefined && metadata.mergeKeys === true });
     if (node === undefined)
       return;
     return getLoc(lineMap, {
@@ -56569,9 +56635,9 @@ var require_getLocationForJsonPath = __commonJS((exports) => {
     }
     return node.endPosition;
   }
-  function findNodeAtPath(node, path6, { closest, mergeKeys }) {
+  function findNodeAtPath(node, path7, { closest, mergeKeys }) {
     pathLoop:
-      for (const segment of path6) {
+      for (const segment of path7) {
         if (!utils_1.isObject(node)) {
           return closest ? node : undefined;
         }
@@ -60511,14 +60577,14 @@ var require_yaml_validator = __commonJS((exports) => {
     email: email_json_1.default
   };
   function getValidationTargetFromFilename(filePath) {
-    const path6 = filePath.toLowerCase();
-    if (/[/\\]flow\.ya?ml$/.test(path6) || /^flow\.ya?ml$/.test(path6)) {
+    const path7 = filePath.toLowerCase();
+    if (/[/\\]flow\.ya?ml$/.test(path7) || /^flow\.ya?ml$/.test(path7)) {
       return { type: "flow" };
     }
-    if (/\.schedule\.ya?ml$/.test(path6)) {
+    if (/\.schedule\.ya?ml$/.test(path7)) {
       return { type: "schedule" };
     }
-    const triggerMatch = path6.match(/\.(http|websocket|kafka|nats|postgres|mqtt|sqs|gcp|email)_trigger\.ya?ml$/);
+    const triggerMatch = path7.match(/\.(http|websocket|kafka|nats|postgres|mqtt|sqs|gcp|email)_trigger\.ya?ml$/);
     if (triggerMatch) {
       return {
         type: "trigger",
@@ -60637,19 +60703,19 @@ function getWorkspaceSpecificTypes() {
     ...Object.fromEntries(TRIGGER_TYPES.map((t) => [`${t}_trigger`, `.${t}_trigger.yaml`]))
   };
 }
-function isTriggerFile(path6) {
-  return TRIGGER_TYPES.some((type) => path6.endsWith(`.${type}_trigger.yaml`));
+function isTriggerFile(path7) {
+  return TRIGGER_TYPES.some((type) => path7.endsWith(`.${type}_trigger.yaml`));
 }
-function isScheduleFile(path6) {
-  return path6.endsWith(".schedule.yaml");
+function isScheduleFile(path7) {
+  return path7.endsWith(".schedule.yaml");
 }
-function getFileTypeSuffix(path6) {
+function getFileTypeSuffix(path7) {
   for (const [_, suffix] of Object.entries(getWorkspaceSpecificTypes())) {
-    if (path6.endsWith(suffix)) {
+    if (path7.endsWith(suffix)) {
       return suffix;
     }
   }
-  const resourceFileMatch = path6.match(/(\\.resource\\.file\\..+)$/);
+  const resourceFileMatch = path7.match(/(\\.resource\\.file\\..+)$/);
   if (resourceFileMatch) {
     return resourceFileMatch[1];
   }
@@ -60720,71 +60786,71 @@ function getSpecificItemsForCurrentBranch(config, workspaceNameOverride) {
   }
   return merged;
 }
-function matchesPatterns(path6, patterns) {
-  return patterns.some((pattern) => minimatch(path6, pattern));
+function matchesPatterns(path7, patterns) {
+  return patterns.some((pattern) => minimatch(path7, pattern));
 }
-function isItemTypeConfigured(path6, specificItems) {
+function isItemTypeConfigured(path7, specificItems) {
   if (!specificItems) {
     return false;
   }
-  if (path6.endsWith(".variable.yaml")) {
+  if (path7.endsWith(".variable.yaml")) {
     return specificItems.variables !== undefined;
   }
-  if (path6.endsWith(".resource.yaml")) {
+  if (path7.endsWith(".resource.yaml")) {
     return specificItems.resources !== undefined;
   }
-  if (isTriggerFile(path6)) {
+  if (isTriggerFile(path7)) {
     return specificItems.triggers !== undefined;
   }
-  if (isScheduleFile(path6)) {
+  if (isScheduleFile(path7)) {
     return specificItems.schedules !== undefined;
   }
-  if (path6.endsWith("/folder.meta.yaml")) {
+  if (path7.endsWith("/folder.meta.yaml")) {
     return specificItems.folders !== undefined;
   }
-  if (path6 === "settings.yaml") {
+  if (path7 === "settings.yaml") {
     return specificItems.settings !== undefined;
   }
-  if (isFileResource(path6) || isFilesetResource(path6)) {
+  if (isFileResource(path7) || isFilesetResource(path7)) {
     return specificItems.resources !== undefined;
   }
   return false;
 }
-function isSpecificItem(path6, specificItems) {
+function isSpecificItem(path7, specificItems) {
   if (!specificItems) {
     return false;
   }
-  if (path6.endsWith(".variable.yaml")) {
-    return specificItems.variables ? matchesPatterns(path6, specificItems.variables) : false;
+  if (path7.endsWith(".variable.yaml")) {
+    return specificItems.variables ? matchesPatterns(path7, specificItems.variables) : false;
   }
-  if (path6.endsWith(".resource.yaml")) {
-    return specificItems.resources ? matchesPatterns(path6, specificItems.resources) : false;
+  if (path7.endsWith(".resource.yaml")) {
+    return specificItems.resources ? matchesPatterns(path7, specificItems.resources) : false;
   }
-  if (isTriggerFile(path6)) {
-    return specificItems.triggers ? matchesPatterns(path6, specificItems.triggers) : false;
+  if (isTriggerFile(path7)) {
+    return specificItems.triggers ? matchesPatterns(path7, specificItems.triggers) : false;
   }
-  if (isScheduleFile(path6)) {
-    return specificItems.schedules ? matchesPatterns(path6, specificItems.schedules) : false;
+  if (isScheduleFile(path7)) {
+    return specificItems.schedules ? matchesPatterns(path7, specificItems.schedules) : false;
   }
-  if (path6.endsWith("/folder.meta.yaml")) {
+  if (path7.endsWith("/folder.meta.yaml")) {
     if (specificItems.folders) {
-      const folderPath = path6.slice(0, -"/folder.meta.yaml".length);
+      const folderPath = path7.slice(0, -"/folder.meta.yaml".length);
       return matchesPatterns(folderPath, specificItems.folders);
     }
     return false;
   }
-  if (path6 === "settings.yaml") {
+  if (path7 === "settings.yaml") {
     return specificItems.settings === true;
   }
-  if (isFileResource(path6)) {
-    const basePathMatch = path6.match(/^(.+?)\.resource\.file\./);
+  if (isFileResource(path7)) {
+    const basePathMatch = path7.match(/^(.+?)\.resource\.file\./);
     if (basePathMatch && specificItems.resources) {
       const basePath = basePathMatch[1] + ".resource.yaml";
       return matchesPatterns(basePath, specificItems.resources);
     }
   }
-  if (isFilesetResource(path6)) {
-    const basePathMatch = path6.match(/^(.+?)\.fileset[/\\]/);
+  if (isFilesetResource(path7)) {
+    const basePathMatch = path7.match(/^(.+?)\.fileset[/\\]/);
     if (basePathMatch && specificItems.resources) {
       const basePath = basePathMatch[1] + ".resource.yaml";
       return matchesPatterns(basePath, specificItems.resources);
@@ -60865,7 +60931,7 @@ function getWorkspaceSpecificPath(basePath, specificItems, workspaceNameOverride
   }
   return;
 }
-function isCurrentWorkspaceFile(path6, workspaceNameOverride) {
+function isCurrentWorkspaceFile(path7, workspaceNameOverride) {
   let currentWorkspace = null;
   if (workspaceNameOverride) {
     currentWorkspace = workspaceNameOverride;
@@ -60882,11 +60948,11 @@ function isCurrentWorkspaceFile(path6, workspaceNameOverride) {
     pattern = new RegExp(`\\.${escapedName}\\.${buildYamlTypePattern()}\\.yaml$|` + `\\.${escapedName}\\.resource\\.file\\..+$|` + `/folder\\.${escapedName}\\.meta\\.yaml$|` + `^settings\\.${escapedName}\\.yaml$`);
     workspacePatternCache.set(currentWorkspace, pattern);
   }
-  return pattern.test(path6);
+  return pattern.test(path7);
 }
-function isWorkspaceSpecificFile(path6) {
+function isWorkspaceSpecificFile(path7) {
   const yamlTypePattern = buildYamlTypePattern();
-  return new RegExp(`\\.[^.]+\\.${yamlTypePattern}\\.yaml$|` + `\\.[^.]+\\.resource\\.file\\..+$|` + `/folder\\.[^.]+\\.meta\\.yaml$|` + `^settings\\.[^.]+\\.yaml$`).test(path6);
+  return new RegExp(`\\.[^.]+\\.${yamlTypePattern}\\.yaml$|` + `\\.[^.]+\\.resource\\.file\\..+$|` + `/folder\\.[^.]+\\.meta\\.yaml$|` + `^settings\\.[^.]+\\.yaml$`).test(path7);
 }
 var workspacePatternCache;
 var init_specific_items = __esm(async () => {
@@ -60960,9 +61026,9 @@ var init_tar = __esm(() => {
 import { readFile as readFile5, writeFile as writeFile5, stat as stat4, mkdir as mkdir3 } from "node:fs/promises";
 import { Buffer as Buffer4 } from "node:buffer";
 import { sep as SEP4 } from "node:path";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import fs8 from "node:fs";
-import { execSync as execSync3 } from "node:child_process";
+import { execSync as execSync4 } from "node:child_process";
 function isRawAppBackendPath2(filePath) {
   return isRawAppBackendPath(filePath);
 }
@@ -61009,8 +61075,8 @@ async function push2(opts, filePath) {
   await handleFile(filePath, workspace, [], opts.message, opts, await getRawWorkspaceDependencies(true), codebases);
   info(colors.bold.underline.green(`Script ${filePath} pushed`));
 }
-async function findResourceFile(path7) {
-  const splitPath = path7.split(".");
+async function findResourceFile(path8) {
+  const splitPath = path8.split(".");
   let contentBasePathJSON = splitPath[0] + "." + splitPath[1] + ".json";
   let contentBasePathYAML = splitPath[0] + "." + splitPath[1] + ".yaml";
   const currentBranch = getCurrentGitBranch();
@@ -61031,48 +61097,48 @@ async function findResourceFile(path7) {
     throw new Error("Found two resource files for the same resource" + validCandidates.join(", "));
   }
   if (validCandidates.length < 1) {
-    throw new Error(`No resource matching file resource: ${path7}.`);
+    throw new Error(`No resource matching file resource: ${path8}.`);
   }
   return validCandidates[0];
 }
-async function handleScriptMetadata(path7, workspace, alreadySynced, message, rawWorkspaceDependencies, codebases, opts, permissionedAsContext) {
-  const isFlatMeta = path7.endsWith(".script.json") || path7.endsWith(".script.yaml") || path7.endsWith(".script.lock");
-  const isFolderMeta = !isFlatMeta && isScriptModulePath(path7) && (path7.endsWith("/script.yaml") || path7.endsWith("/script.json") || path7.endsWith("/script.lock"));
+async function handleScriptMetadata(path8, workspace, alreadySynced, message, rawWorkspaceDependencies, codebases, opts, permissionedAsContext) {
+  const isFlatMeta = path8.endsWith(".script.json") || path8.endsWith(".script.yaml") || path8.endsWith(".script.lock");
+  const isFolderMeta = !isFlatMeta && isScriptModulePath(path8) && (path8.endsWith("/script.yaml") || path8.endsWith("/script.json") || path8.endsWith("/script.lock"));
   if (isFlatMeta || isFolderMeta) {
-    const contentPath = await findContentFile(path7);
+    const contentPath = await findContentFile(path8);
     return handleFile(contentPath, workspace, alreadySynced, message, opts, rawWorkspaceDependencies, codebases, permissionedAsContext);
   } else {
     return false;
   }
 }
-async function handleFile(path7, workspace, alreadySynced, message, opts, rawWorkspaceDependencies, codebases, permissionedAsContext) {
-  const moduleEntryPoint = isModuleEntryPoint(path7);
-  if (!isAppInlineScriptPath2(path7) && !isFlowInlineScriptPath2(path7) && !isRawAppBackendPath2(path7) && (!isScriptModulePath(path7) || moduleEntryPoint) && exts.some((exts) => path7.endsWith(exts))) {
-    if (alreadySynced.includes(path7)) {
+async function handleFile(path8, workspace, alreadySynced, message, opts, rawWorkspaceDependencies, codebases, permissionedAsContext) {
+  const moduleEntryPoint = isModuleEntryPoint(path8);
+  if (!isAppInlineScriptPath2(path8) && !isFlowInlineScriptPath2(path8) && !isRawAppBackendPath2(path8) && (!isScriptModulePath(path8) || moduleEntryPoint) && exts.some((exts) => path8.endsWith(exts))) {
+    if (alreadySynced.includes(path8)) {
       return true;
     }
-    debug(`Processing local script ${path7}`);
-    alreadySynced.push(path7);
-    const remotePath = moduleEntryPoint ? getScriptBasePathFromModulePath(path7).replaceAll(SEP4, "/") : path7.substring(0, path7.indexOf(".")).replaceAll(SEP4, "/");
-    const language = inferContentTypeFromFilePath(path7, opts?.defaultTs);
-    const codebase = language == "bun" ? findCodebase(path7, codebases) : undefined;
+    debug(`Processing local script ${path8}`);
+    alreadySynced.push(path8);
+    const remotePath = moduleEntryPoint ? getScriptBasePathFromModulePath(path8).replaceAll(SEP4, "/") : path8.substring(0, path8.indexOf(".")).replaceAll(SEP4, "/");
+    const language = inferContentTypeFromFilePath(path8, opts?.defaultTs);
+    const codebase = language == "bun" ? findCodebase(path8, codebases) : undefined;
     let bundleContent = undefined;
     let forceTar = false;
     if (codebase) {
       let outputFiles = [];
       if (codebase.customBundler) {
-        info(`Using custom bundler ${codebase.customBundler} for ${path7}`);
-        bundleContent = execSync3(codebase.customBundler + " " + path7, {
+        info(`Using custom bundler ${codebase.customBundler} for ${path8}`);
+        bundleContent = execSync4(codebase.customBundler + " " + path8, {
           maxBuffer: 1024 * 1024 * 50
         }).toString();
-        info("Custom bundler executed for " + path7);
+        info("Custom bundler executed for " + path8);
       } else {
         const esbuild = await import("esbuild");
-        info(`Started bundling ${path7} ...`);
+        info(`Started bundling ${path8} ...`);
         const startTime = performance.now();
         const format6 = codebase.format ?? "cjs";
         const out = await esbuild.build({
-          entryPoints: [path7],
+          entryPoints: [path8],
           format: format6,
           bundle: true,
           write: false,
@@ -61090,15 +61156,15 @@ async function handleFile(path7, workspace, alreadySynced, message, opts, rawWor
         bundleContent = out.outputFiles[0].text;
         outputFiles = out.outputFiles ?? [];
         if (outputFiles.length == 0) {
-          throw new Error(`No output files found for ${path7}`);
+          throw new Error(`No output files found for ${path8}`);
         }
-        info(`Finished bundling ${path7}: ${(bundleContent.length / 1024).toFixed(0)}kB (${(endTime - startTime).toFixed(0)}ms)`);
+        info(`Finished bundling ${path8}: ${(bundleContent.length / 1024).toFixed(0)}kB (${(endTime - startTime).toFixed(0)}ms)`);
       }
       if (outputFiles.length > 1) {
-        info(`Found multiple output files for ${path7}, creating a tarball... ${outputFiles.map((file) => file.path).join(", ")}`);
+        info(`Found multiple output files for ${path8}, creating a tarball... ${outputFiles.map((file) => file.path).join(", ")}`);
         forceTar = true;
         const startTime = performance.now();
-        const mainPath = path7.split(SEP4).pop()?.split(".")[0] + ".js";
+        const mainPath = path8.split(SEP4).pop()?.split(".")[0] + ".js";
         const mainContent = outputFiles.find((file) => file.path == "/" + mainPath)?.text ?? "";
         info(`Main content: ${mainContent.length}chars`);
         const entries = [
@@ -61113,10 +61179,10 @@ async function handleFile(path7, workspace, alreadySynced, message, opts, rawWor
         }
         bundleContent = await createTarBlob(entries);
         const endTime = performance.now();
-        info(`Finished creating tarball for ${path7}: ${(bundleContent.size / 1024).toFixed(0)}kB (${(endTime - startTime).toFixed(0)}ms)`);
+        info(`Finished creating tarball for ${path8}: ${(bundleContent.size / 1024).toFixed(0)}kB (${(endTime - startTime).toFixed(0)}ms)`);
       } else {
         if (Array.isArray(codebase.assets) && codebase.assets.length > 0) {
-          info(`Using the following asset configuration for ${path7}: ${JSON.stringify(codebase.assets)}`);
+          info(`Using the following asset configuration for ${path8}: ${JSON.stringify(codebase.assets)}`);
           const startTime = performance.now();
           const entries = [
             { name: "main.js", content: bundleContent }
@@ -61127,13 +61193,13 @@ async function handleFile(path7, workspace, alreadySynced, message, opts, rawWor
           }
           bundleContent = await createTarBlob(entries);
           const endTime = performance.now();
-          info(`Finished creating tarball for ${path7}: ${(bundleContent.size / 1024).toFixed(0)}kB (${(endTime - startTime).toFixed(0)}ms)`);
+          info(`Finished creating tarball for ${path8}: ${(bundleContent.size / 1024).toFixed(0)}kB (${(endTime - startTime).toFixed(0)}ms)`);
         }
       }
     }
     let typed = opts?.skipScriptsMetadata ? undefined : (await parseMetadataFile(remotePath, opts ? {
       ...opts,
-      path: path7,
+      path: path8,
       workspaceRemote: workspace,
       schemaOnly: codebase ? true : undefined,
       rawWorkspaceDependencies,
@@ -61150,14 +61216,14 @@ async function handleFile(path7, workspace, alreadySynced, message, opts, rawWor
     } catch {
       debug(`Script ${remotePath} does not exist on remote`);
     }
-    const content = await readFile5(path7, "utf-8");
+    const content = await readFile5(path8, "utf-8");
     if (opts?.skipScriptsMetadata) {
       typed = structuredClone(remote);
     }
     if (typed && codebase) {
       typed.codebase = await codebase.getDigest(forceTar);
     }
-    const scriptBasePath = moduleEntryPoint ? getScriptBasePathFromModulePath(path7) : path7.substring(0, path7.indexOf("."));
+    const scriptBasePath = moduleEntryPoint ? getScriptBasePathFromModulePath(path8) : path8.substring(0, path8.indexOf("."));
     const moduleFolderPath = scriptBasePath + getModuleFolderSuffix();
     const modules = await readModulesFromDisk(moduleFolderPath, opts?.defaultTs, moduleEntryPoint);
     const requestBodyCommon = {
@@ -61241,7 +61307,7 @@ async function readModulesFromDisk(moduleFolderPath, defaultTs, folderLayout = f
   function readDir2(dirPath, relPrefix) {
     const entries = fs8.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path6.join(dirPath, entry.name);
+      const fullPath = path7.join(dirPath, entry.name);
       const relPath = relPrefix ? relPrefix + "/" + entry.name : entry.name;
       const isTopLevel = relPrefix === "";
       if (entry.isDirectory()) {
@@ -61251,7 +61317,7 @@ async function readModulesFromDisk(moduleFolderPath, defaultTs, folderLayout = f
           const content = fs8.readFileSync(fullPath, "utf-8");
           const language = inferContentTypeFromFilePath(entry.name, defaultTs);
           const baseName = entry.name.replace(/\.[^.]+$/, "");
-          const lockPath = path6.join(dirPath, baseName + ".lock");
+          const lockPath = path7.join(dirPath, baseName + ".lock");
           let lock;
           if (fs8.existsSync(lockPath)) {
             lock = fs8.readFileSync(lockPath, "utf-8");
@@ -61376,13 +61442,13 @@ function filePathExtensionFromContentType(language, defaultTs) {
     throw new Error("Invalid language: " + language);
   }
 }
-function removeExtensionToPath(path7) {
+function removeExtensionToPath(path8) {
   for (const ext2 of exts) {
-    if (path7.endsWith(ext2)) {
-      return path7.substring(0, path7.length - ext2.length);
+    if (path8.endsWith(ext2)) {
+      return path8.substring(0, path8.length - ext2.length);
     }
   }
-  throw new Error("Invalid extension: " + path7);
+  throw new Error("Invalid extension: " + path8);
 }
 async function list4(opts) {
   if (opts.json)
@@ -61433,7 +61499,7 @@ async function resolve6(input) {
     throw e;
   }
 }
-async function run2(opts, path7) {
+async function run2(opts, path8) {
   if (opts.silent) {
     setSilent(true);
   }
@@ -61444,7 +61510,7 @@ async function run2(opts, path7) {
     try {
       const script = await getScriptByPath({
         workspace: workspace.workspaceId,
-        path: path7
+        path: path8
       });
       validateRequiredArgs(script.schema);
     } catch (e) {
@@ -61457,7 +61523,7 @@ async function run2(opts, path7) {
   try {
     id = await runScriptByPath({
       workspace: workspace.workspaceId,
-      path: path7,
+      path: path8,
       requestBody: input
     });
   } catch (e) {
@@ -61465,10 +61531,10 @@ async function run2(opts, path7) {
       try {
         const script = await getScriptByPath({
           workspace: workspace.workspaceId,
-          path: path7
+          path: path8
         });
         if (script.lock_error_logs) {
-          throw new Error(`Script '${path7}' has a deployment error and cannot be run:
+          throw new Error(`Script '${path8}' has a deployment error and cannot be run:
 ${script.lock_error_logs}`);
         }
       } catch (lookupErr) {
@@ -61477,7 +61543,7 @@ ${script.lock_error_logs}`);
         if (lookupErr?.status && lookupErr.status !== 404)
           throw lookupErr;
       }
-      throw new Error(`Script '${path7}' not found. Run 'wmill script list' to see available scripts.`);
+      throw new Error(`Script '${path8}' not found. Run 'wmill script list' to see available scripts.`);
     }
     throw e;
   }
@@ -61593,12 +61659,12 @@ async function pollForJobResult(workspace, jobId) {
     await new Promise((resolve7) => setTimeout(resolve7, POLL_INTERVAL_MS));
   }
 }
-async function show(opts, path7) {
+async function show(opts, path8) {
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   const s = await getScriptByPath({
     workspace: workspace.workspaceId,
-    path: path7
+    path: path8
   });
   info(colors.underline(s.path));
   if (s.description)
@@ -61606,14 +61672,14 @@ async function show(opts, path7) {
   info("");
   info(s.content);
 }
-async function get2(opts, path7) {
+async function get2(opts, path8) {
   if (opts.json)
     setSilent(true);
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   const s = await getScriptByPath({
     workspace: workspace.workspaceId,
-    path: path7
+    path: path8
   });
   if (opts.json) {
     console.log(JSON.stringify(s));
@@ -61663,7 +61729,7 @@ async function bootstrap(opts, scriptPath, language) {
     scriptMetadata.description = opts.description;
   }
   const scriptInitialMetadataYaml = import_yaml6.stringify(scriptMetadata, yamlOptions);
-  const parentDir = path6.dirname(scriptCodeFileFullPath);
+  const parentDir = path7.dirname(scriptCodeFileFullPath);
   await mkdir3(parentDir, { recursive: true });
   await writeFile5(scriptCodeFileFullPath, scriptInitialCode, {
     flag: "wx",
@@ -61746,7 +61812,7 @@ async function preview(opts, filePath) {
   const content = await readFile5(filePath, "utf-8");
   const input = opts.data ? await resolve6(opts.data) : {};
   const isFolderLayout = isModuleEntryPoint(filePath);
-  const moduleFolderPath = isFolderLayout ? path6.dirname(filePath) : filePath.substring(0, filePath.indexOf(".")) + getModuleFolderSuffix();
+  const moduleFolderPath = isFolderLayout ? path7.dirname(filePath) : filePath.substring(0, filePath.indexOf(".")) + getModuleFolderSuffix();
   const modules = await readModulesFromDisk(moduleFolderPath, opts?.defaultTs, isFolderLayout);
   const codebase = language == "bun" ? findCodebase(filePath, codebases) : undefined;
   let bundledContent = undefined;
@@ -61756,7 +61822,7 @@ async function preview(opts, filePath) {
       if (!opts.silent) {
         info(`Using custom bundler ${codebase.customBundler} for preview`);
       }
-      bundledContent = execSync3(codebase.customBundler + " " + filePath, {
+      bundledContent = execSync4(codebase.customBundler + " " + filePath, {
         maxBuffer: 52428800
       }).toString();
     } else {
@@ -62004,8 +62070,8 @@ var init_script = __esm(async () => {
 
 // src/commands/lint/lint.ts
 import { stat as stat5, readdir as readdir2 } from "node:fs/promises";
-import process13 from "node:process";
-import * as path7 from "node:path";
+import process14 from "node:process";
+import * as path8 from "node:path";
 import { sep as SEP5 } from "node:path";
 function normalizePath(p) {
   return p.replaceAll(SEP5, "/");
@@ -62064,7 +62130,7 @@ async function isLockResolved(lockValue, baseDir) {
   return true;
 }
 async function checkInlineFile(relativePath, baseDir) {
-  const fullPath = path7.join(baseDir, relativePath.trim());
+  const fullPath = path8.join(baseDir, relativePath.trim());
   try {
     const s = await stat5(fullPath);
     return s.size > 0;
@@ -62154,7 +62220,7 @@ async function checkRawAppRunnables(backendDir, rawAppYamlPath, defaultTs) {
       continue;
     const runnableId = fileName.replace(".yaml", "");
     processedIds.add(runnableId);
-    const filePath = path7.join(backendDir, fileName);
+    const filePath = path8.join(backendDir, fileName);
     let runnable;
     try {
       runnable = await yamlParseFile(filePath);
@@ -62172,7 +62238,7 @@ async function checkRawAppRunnables(backendDir, rawAppYamlPath, defaultTs) {
     }
     if (!language || !languageNeedsLock(language))
       continue;
-    const lockFile = path7.join(backendDir, `${runnableId}.lock`);
+    const lockFile = path8.join(backendDir, `${runnableId}.lock`);
     let hasLock = false;
     try {
       const s = await stat5(lockFile);
@@ -62219,7 +62285,7 @@ async function checkRawAppRunnables(backendDir, rawAppYamlPath, defaultTs) {
     }
     if (!languageNeedsLock(language))
       continue;
-    const lockFile = path7.join(backendDir, `${runnableId}.lock`);
+    const lockFile = path8.join(backendDir, `${runnableId}.lock`);
     let hasLock = false;
     try {
       const s = await stat5(lockFile);
@@ -62238,8 +62304,8 @@ async function checkRawAppRunnables(backendDir, rawAppYamlPath, defaultTs) {
   return issues;
 }
 async function checkMissingLocks(opts, directory) {
-  const initialCwd = process13.cwd();
-  const targetDirectory = directory ? path7.resolve(initialCwd, directory) : process13.cwd();
+  const initialCwd = process14.cwd();
+  const targetDirectory = directory ? path8.resolve(initialCwd, directory) : process14.cwd();
   const { ...syncOpts } = opts;
   const mergedOpts = await mergeConfigWithConfigFile(syncOpts);
   const ignore = await ignoreF(mergedOpts);
@@ -62263,19 +62329,19 @@ async function checkMissingLocks(opts, directory) {
     if (normalizedPath.endsWith("/flow.yaml") && normalizedPath.includes(flowSuffix + "/")) {
       flowYamls.push({
         normalizedPath,
-        fullPath: path7.join(targetDirectory, entry.path)
+        fullPath: path8.join(targetDirectory, entry.path)
       });
     }
     if (normalizedPath.endsWith("/app.yaml") && normalizedPath.includes(appSuffix + "/")) {
       appYamls.push({
         normalizedPath,
-        fullPath: path7.join(targetDirectory, entry.path)
+        fullPath: path8.join(targetDirectory, entry.path)
       });
     }
     if (normalizedPath.endsWith("/raw_app.yaml") && normalizedPath.includes(rawAppSuffix + "/")) {
       rawAppYamls.push({
         normalizedPath,
-        fullPath: path7.join(targetDirectory, entry.path)
+        fullPath: path8.join(targetDirectory, entry.path)
       });
     }
   }
@@ -62284,14 +62350,14 @@ async function checkMissingLocks(opts, directory) {
     let language = null;
     for (const ext2 of exts) {
       try {
-        await stat5(path7.join(targetDirectory, basePath + ext2));
+        await stat5(path8.join(targetDirectory, basePath + ext2));
         language = inferContentTypeFromFilePath(basePath + ext2, defaultTs);
         break;
       } catch {}
     }
     if (language && languageNeedsLock(language)) {
       try {
-        const metadata = await yamlParseFile(path7.join(targetDirectory, yamlPath));
+        const metadata = await yamlParseFile(path8.join(targetDirectory, yamlPath));
         const lockResolved = await isLockResolved(metadata?.lock, targetDirectory);
         if (!lockResolved) {
           issues.push({
@@ -62308,7 +62374,7 @@ async function checkMissingLocks(opts, directory) {
     }
   }
   for (const { normalizedPath: flowYamlPath, fullPath } of flowYamls) {
-    const flowDir = path7.dirname(fullPath);
+    const flowDir = path8.dirname(fullPath);
     try {
       const flowFile = await yamlParseFile(fullPath);
       if (!flowFile?.value?.modules)
@@ -62333,7 +62399,7 @@ async function checkMissingLocks(opts, directory) {
     }
   }
   for (const { normalizedPath: appYamlPath, fullPath } of appYamls) {
-    const appDir = path7.dirname(fullPath);
+    const appDir = path8.dirname(fullPath);
     try {
       const appFile = await yamlParseFile(fullPath);
       if (!appFile?.value)
@@ -62358,8 +62424,8 @@ async function checkMissingLocks(opts, directory) {
     }
   }
   for (const { normalizedPath: rawAppYamlPath, fullPath } of rawAppYamls) {
-    const rawAppDir = path7.dirname(fullPath);
-    const backendDir = path7.join(rawAppDir, "backend");
+    const rawAppDir = path8.dirname(fullPath);
+    const backendDir = path8.join(rawAppDir, "backend");
     try {
       await stat5(backendDir);
     } catch {
@@ -62375,11 +62441,11 @@ async function checkMissingLocks(opts, directory) {
   return issues;
 }
 async function runLint(opts, directory) {
-  const initialCwd = process13.cwd();
-  const explicitTargetDirectory = directory ? path7.resolve(initialCwd, directory) : undefined;
+  const initialCwd = process14.cwd();
+  const explicitTargetDirectory = directory ? path8.resolve(initialCwd, directory) : undefined;
   const { json: _json, ...syncOpts } = opts;
   const mergedOpts = await mergeConfigWithConfigFile(syncOpts);
-  const targetDirectory = explicitTargetDirectory ?? process13.cwd();
+  const targetDirectory = explicitTargetDirectory ?? process14.cwd();
   const stats = await stat5(targetDirectory).catch(() => null);
   if (!stats) {
     throw new Error(`Directory not found: ${targetDirectory}`);
@@ -62387,7 +62453,7 @@ async function runLint(opts, directory) {
   if (!stats.isDirectory()) {
     throw new Error(`Path is not a directory: ${targetDirectory}`);
   }
-  const isSubdirectory = explicitTargetDirectory && !await stat5(path7.join(targetDirectory, "wmill.yaml")).catch(() => null);
+  const isSubdirectory = explicitTargetDirectory && !await stat5(path8.join(targetDirectory, "wmill.yaml")).catch(() => null);
   const ignore = isSubdirectory ? (_p, _isDir) => false : await ignoreF(mergedOpts);
   const root = await FSFSElement(targetDirectory, [], false);
   const validator = new import_windmill_yaml_validator.WindmillYamlValidator;
@@ -62494,7 +62560,7 @@ async function lint(opts, directory) {
     const report = await runLint(opts, directory);
     printReport(report, !!opts.json);
     if (report.exitCode !== 0) {
-      process13.exit(report.exitCode);
+      process14.exit(report.exitCode);
     }
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : String(error2);
@@ -62507,17 +62573,17 @@ async function lint(opts, directory) {
     } else {
       error(colors.red(`❌ ${message}`));
     }
-    process13.exit(1);
+    process14.exit(1);
   }
 }
 async function lintWatch(opts, directory) {
   const { watch } = await import("node:fs");
-  const targetDir = directory ? path7.resolve(process13.cwd(), directory) : process13.cwd();
+  const targetDir = directory ? path8.resolve(process14.cwd(), directory) : process14.cwd();
   info(colors.blue(`Watching ${targetDir} for changes... (Ctrl+C to stop)`));
   async function runAndReport() {
     try {
       const report = await runLint(opts, directory);
-      process13.stdout.write("\x1Bc");
+      process14.stdout.write("\x1Bc");
       info(colors.gray(`[${new Date().toLocaleTimeString()}] Lint results:
 `));
       printReport(report, false);
@@ -62819,11 +62885,11 @@ async function list5(opts) {
     new Table2().header(["Path", "Resource Type"]).padding(2).border(true).body(total.map((x) => [x.path, x.resource_type])).render();
   }
 }
-async function newResource(opts, path8) {
-  if (!validatePath(path8)) {
+async function newResource(opts, path9) {
+  if (!validatePath(path9)) {
     return;
   }
-  const filePath = path8 + ".resource.yaml";
+  const filePath = path9 + ".resource.yaml";
   try {
     await stat6(filePath);
     throw new Error("File already exists: " + filePath);
@@ -62843,14 +62909,14 @@ async function newResource(opts, path8) {
   });
   info(colors.green(`Created ${filePath}`));
 }
-async function get3(opts, path8) {
+async function get3(opts, path9) {
   if (opts.json)
     setSilent(true);
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   const r = await getResource({
     workspace: workspace.workspaceId,
-    path: path8
+    path: path9
   });
   if (opts.json) {
     console.log(JSON.stringify(r));
@@ -63009,11 +63075,11 @@ var init_path_assigner = __esm(() => {
 function extractRawscriptInline(id, summary, rawscript, mapping, separator, assigner) {
   const [basePath, ext2] = assigner.assignPath(summary ?? id, rawscript.language);
   const mappedPath = mapping[id];
-  const path8 = mappedPath ?? basePath + ext2;
+  const path9 = mappedPath ?? basePath + ext2;
   const language = rawscript.language;
   const content = rawscript.content;
-  const r = [{ path: path8, content, language, is_lock: false }];
-  rawscript.content = "!inline " + path8.replaceAll(separator, "/");
+  const r = [{ path: path9, content, language, is_lock: false }];
+  rawscript.content = "!inline " + path9.replaceAll(separator, "/");
   const lock = rawscript.lock;
   if (lock && lock != "") {
     const dotIdx = mappedPath ? mappedPath.lastIndexOf(".") : -1;
@@ -63099,23 +63165,23 @@ async function replaceRawscriptInline(id, rawscript, fileReader, logger, separat
   if (!rawscript.content || !rawscript.content.startsWith("!inline")) {
     return;
   }
-  const path8 = rawscript.content.split(" ")[1];
-  const pathSuffix = path8.split(".").slice(1).join(".");
+  const path9 = rawscript.content.split(" ")[1];
+  const pathSuffix = path9.split(".").slice(1).join(".");
   const newPath = id + "." + pathSuffix;
   try {
-    rawscript.content = await fileReader(path8);
+    rawscript.content = await fileReader(path9);
   } catch {
-    logger.error(`Script file ${path8} not found`);
+    logger.error(`Script file ${path9} not found`);
     try {
       rawscript.content = await fileReader(newPath);
     } catch {
       logger.error(`Script file ${newPath} not found`);
       if (missingFiles)
-        missingFiles.push(path8);
+        missingFiles.push(path9);
     }
   }
   const lock = rawscript.lock;
-  if (removeLocks && removeLocks.includes(path8)) {
+  if (removeLocks && removeLocks.includes(path9)) {
     rawscript.lock = undefined;
   } else if (lock && typeof lock === "string" && lock.trimStart().startsWith("!inline ")) {
     const lockPath = lock.split(" ")[1];
@@ -63298,11 +63364,11 @@ var init_relative_imports = __esm(async () => {
 });
 
 // src/commands/flow/flow_metadata.ts
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 import { sep as SEP7 } from "node:path";
 import { readFile as readFile7 } from "node:fs/promises";
 async function generateFlowHash(rawWorkspaceDependencies, folder, defaultTs) {
-  const elems = await FSFSElement(path8.join(process.cwd(), folder), [], true);
+  const elems = await FSFSElement(path9.join(process.cwd(), folder), [], true);
   const hashes = {};
   for await (const f of elems.getChildren()) {
     if (exts.some((e) => f.path.endsWith(e))) {
@@ -63310,7 +63376,11 @@ async function generateFlowHash(rawWorkspaceDependencies, folder, defaultTs) {
       hashes[normalizedPath] = await generateHash(await f.getContentText() + JSON.stringify(rawWorkspaceDependencies));
     }
   }
-  return { ...hashes, [TOP_HASH]: await generateHash(JSON.stringify(hashes)) };
+  const sortedHashes = {};
+  for (const k of Object.keys(hashes).sort()) {
+    sortedHashes[k] = hashes[k];
+  }
+  return { ...sortedHashes, [TOP_HASH]: await generateHash(JSON.stringify(sortedHashes)) };
 }
 async function generateFlowLockInternal(folder, dryRun, workspace, opts, justUpdateMetadataLock, noStaleMessage, tree) {
   if (folder.endsWith(SEP7)) {
@@ -63338,7 +63408,7 @@ async function generateFlowLockInternal(folder, dryRun, workspace, opts, justUpd
             continue;
           }
         }
-        const treePath = folderNormalized + "/" + path8.basename(script.path, path8.extname(script.path));
+        const treePath = folderNormalized + "/" + path9.basename(script.path, path9.extname(script.path));
         const language = script.language;
         const imports = await extractRelativeImports(content, treePath, language);
         await tree.addNode(treePath, content, language, "", imports, "inline_script", folderNormalized, folder, false);
@@ -63373,29 +63443,29 @@ async function generateFlowLockInternal(folder, dryRun, workspace, opts, justUpd
     const c = script.content;
     if (c.startsWith("!inline ")) {
       const fileName = c.replace("!inline ", "");
-      const treePath = folderNormalized + "/" + path8.basename(script.path, path8.extname(script.path));
+      const treePath = folderNormalized + "/" + path9.basename(script.path, path9.extname(script.path));
       fileToTreePath.set(fileName, treePath);
     }
   }
   if (!justUpdateMetadataLock) {
     const hashes = await generateFlowHash(filteredDeps, folder, opts.defaultTs);
-    for (const [path9, hash2] of Object.entries(hashes)) {
-      if (path9 == TOP_HASH) {
+    for (const [path10, hash2] of Object.entries(hashes)) {
+      if (path10 == TOP_HASH) {
         continue;
       }
-      if (!await checkifMetadataUptodate(folder, hash2, conf, path9)) {
-        changedScripts.push(path9);
+      if (!await checkifMetadataUptodate(folder, hash2, conf, path10)) {
+        changedScripts.push(path10);
       }
     }
     if (!noStaleMessage) {
       info(`Recomputing locks of ${changedScripts.join(", ")} in ${folder}`);
     }
-    const fileReader = async (path9) => await readFile7(folder + SEP7 + path9, "utf-8");
+    const fileReader = async (path10) => await readFile7(folder + SEP7 + path10, "utf-8");
     const currentMapping = extractCurrentMapping(flowValue.value.modules, {}, flowValue.value.failure_module, flowValue.value.preprocessor_module);
     const locksToRemove = tree ? Object.keys(hashes).filter((k) => {
       if (k === TOP_HASH)
         return false;
-      const treePath = fileToTreePath.get(k) ?? folderNormalized + "/" + path8.basename(k, path8.extname(k));
+      const treePath = fileToTreePath.get(k) ?? folderNormalized + "/" + path9.basename(k, path9.extname(k));
       return tree.isStale(treePath);
     }) : changedScripts;
     await replaceInlineScripts(flowValue.value.modules, fileReader, exports_log, folder + SEP7, SEP7, locksToRemove);
@@ -63431,8 +63501,8 @@ async function generateFlowLockInternal(folder, dryRun, workspace, opts, justUpd
   const depsForHash = tree ? {} : filteredDeps;
   const finalHashes = await generateFlowHash(depsForHash, folder, opts.defaultTs);
   await clearGlobalLock(folder);
-  for (const [path9, hash2] of Object.entries(finalHashes)) {
-    await updateMetadataGlobalLock(folder, hash2, path9);
+  for (const [path10, hash2] of Object.entries(finalHashes)) {
+    await updateMetadataGlobalLock(folder, hash2, path10);
   }
   if (!noStaleMessage) {
     info(colors.green(`Flow ${remote_path} lockfiles updated`));
@@ -63440,7 +63510,7 @@ async function generateFlowLockInternal(folder, dryRun, workspace, opts, justUpd
   const relocked = tree ? Object.keys(finalHashes).filter((k) => {
     if (k === TOP_HASH)
       return false;
-    const treePath = fileToTreePath.get(k) ?? folderNormalized + "/" + path8.basename(k, path8.extname(k));
+    const treePath = fileToTreePath.get(k) ?? folderNormalized + "/" + path9.basename(k, path9.extname(k));
     return tree.isStale(treePath);
   }) : changedScripts;
   const updatedScripts = relocked.map((p) => {
@@ -63556,7 +63626,7 @@ __export(exports_sync, {
   FSFSElement: () => FSFSElement
 });
 import { readFile as readFile8, writeFile as writeFile7, readdir as readdir4, stat as stat7, rm, copyFile, mkdir as mkdir5 } from "node:fs/promises";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 import { sep as SEP8 } from "node:path";
 function resolveWsNameFromBranch(opts, branchName) {
   const match2 = findWorkspaceByGitBranch(opts.workspaces, branchName);
@@ -63614,8 +63684,8 @@ function mergeCliWithEffectiveOptions(cliOpts, effectiveOpts) {
 async function resolveEffectiveSyncOptions(workspace, localConfig, promotion, workspaceNameOverride) {
   return await getEffectiveSettings(localConfig, promotion, false, false, workspaceNameOverride);
 }
-function findCodebase(path10, codebases) {
-  if (!path10.endsWith(".ts")) {
+function findCodebase(path11, codebases) {
+  if (!path11.endsWith(".ts")) {
     return;
   }
   for (const c of codebases) {
@@ -63631,7 +63701,7 @@ function findCodebase(path10, codebases) {
       if (included) {
         break;
       }
-      if (minimatch(path10, r)) {
+      if (minimatch(path11, r)) {
         included = true;
       }
     }
@@ -63639,7 +63709,7 @@ function findCodebase(path10, codebases) {
       c.excludes = [c.excludes];
     }
     for (const r of c.excludes ?? []) {
-      if (minimatch(path10, r)) {
+      if (minimatch(path11, r)) {
         excluded = true;
       }
     }
@@ -63648,13 +63718,13 @@ function findCodebase(path10, codebases) {
     }
   }
 }
-async function addCodebaseDigestIfRelevant(path10, content, codebases, ignoreCodebaseChanges) {
-  const isScript = path10.endsWith(".script.yaml");
+async function addCodebaseDigestIfRelevant(path11, content, codebases, ignoreCodebaseChanges) {
+  const isScript = path11.endsWith(".script.yaml");
   if (!isScript) {
     return content;
   }
   let isTs = true;
-  const replacedPath = path10.replace(".script.yaml", ".ts");
+  const replacedPath = path11.replace(".script.yaml", ".ts");
   try {
     await stat7(replacedPath);
   } catch {
@@ -63668,9 +63738,9 @@ async function addCodebaseDigestIfRelevant(path10, content, codebases, ignoreCod
     if (c) {
       let parsed;
       try {
-        parsed = yamlParseContent(path10, content);
+        parsed = yamlParseContent(path11, content);
       } catch (error2) {
-        error(`Failed to parse YAML content for codebase digest at path: ${path10}`);
+        error(`Failed to parse YAML content for codebase digest at path: ${path11}`);
         throw error2;
       }
       if (parsed && typeof parsed == "object") {
@@ -63682,7 +63752,7 @@ async function addCodebaseDigestIfRelevant(path10, content, codebases, ignoreCod
         parsed["lock"] = "";
         return import_yaml11.stringify(parsed, yamlOptions);
       } else {
-        throw Error(`Expected local yaml ${path10} to be an object, found: ${content} instead`);
+        throw Error(`Expected local yaml ${path11} to be an object, found: ${content} instead`);
       }
     }
   }
@@ -63699,7 +63769,7 @@ async function FSFSElement(p, codebases, ignoreCodebaseChanges) {
         try {
           const entries = await readdir4(localP, { withFileTypes: true });
           for (const e of entries) {
-            yield _internal_element(path9.join(localP, e.name), e.isDirectory(), codebases2);
+            yield _internal_element(path10.join(localP, e.name), e.isDirectory(), codebases2);
           }
         } catch (e) {
           warn(`Error reading dir: ${localP}, ${e}`);
@@ -63870,7 +63940,7 @@ function extractInlineScriptsForApps(key, rec, pathAssigner, toId, removeSchema)
   }
   if (typeof rec == "object") {
     return Object.entries(rec).flatMap(([k, v]) => {
-      if (k == "inlineScript" && typeof v == "object") {
+      if (k == "inlineScript" && v != null && typeof v == "object") {
         rec["type"] = undefined;
         const o = v;
         const name = toId(key ?? "", rec);
@@ -63978,9 +64048,9 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
       for (const basePath of moduleScripts) {
         if (normalizedP.startsWith(basePath + ".")) {
           const ext2 = normalizedP.slice(basePath.length);
-          const dir = path9.dirname(finalPath);
-          const base = path9.basename(basePath);
-          finalPath = path9.join(dir, base + getModuleFolderSuffix(), "script" + ext2);
+          const dir = path10.dirname(finalPath);
+          const base = path10.basename(basePath);
+          finalPath = path10.join(dir, base + getModuleFolderSuffix(), "script" + ext2);
           break;
         }
       }
@@ -64016,7 +64086,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
             for (const s of inlineScripts) {
               yield {
                 isDirectory: false,
-                path: path9.join(finalPath, s.path),
+                path: path10.join(finalPath, s.path),
                 async* getChildren() {},
                 async getContentText() {
                   return s.content;
@@ -64029,7 +64099,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
             }
             yield {
               isDirectory: false,
-              path: path9.join(finalPath, "flow.yaml"),
+              path: path10.join(finalPath, "flow.yaml"),
               async* getChildren() {},
               async getContentText() {
                 return import_yaml11.stringify(flow, yamlOptions);
@@ -64053,7 +64123,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
             for (const s of inlineScripts) {
               yield {
                 isDirectory: false,
-                path: path9.join(finalPath, s.path),
+                path: path10.join(finalPath, s.path),
                 async* getChildren() {},
                 async getContentText() {
                   return s.content;
@@ -64066,7 +64136,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
             app.policy = undefined;
             yield {
               isDirectory: false,
-              path: path9.join(finalPath, "app.yaml"),
+              path: path10.join(finalPath, "app.yaml"),
               async* getChildren() {},
               async getContentText() {
                 return import_yaml11.stringify(app, yamlOptions);
@@ -64121,7 +64191,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
                 }
                 yield {
                   isDirectory: false,
-                  path: path9.join(finalPath, filePath.substring(1)),
+                  path: path10.join(finalPath, filePath.substring(1)),
                   async* getChildren() {},
                   async getContentText() {
                     if (typeof content !== "string") {
@@ -64138,7 +64208,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
             for (const s of inlineScripts) {
               yield {
                 isDirectory: false,
-                path: path9.join(finalPath, APP_BACKEND_FOLDER, s.path),
+                path: path10.join(finalPath, APP_BACKEND_FOLDER, s.path),
                 async* getChildren() {},
                 async getContentText() {
                   return s.content;
@@ -64174,7 +64244,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
               }
               yield {
                 isDirectory: false,
-                path: path9.join(finalPath, APP_BACKEND_FOLDER, `${runnableId}.yaml`),
+                path: path10.join(finalPath, APP_BACKEND_FOLDER, `${runnableId}.yaml`),
                 async* getChildren() {},
                 async getContentText() {
                   return import_yaml11.stringify(simplifiedRunnable, yamlOptions);
@@ -64188,7 +64258,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
             delete rawApp?.["value"];
             yield {
               isDirectory: false,
-              path: path9.join(finalPath, "raw_app.yaml"),
+              path: path10.join(finalPath, "raw_app.yaml"),
               async* getChildren() {},
               async getContentText() {
                 return import_yaml11.stringify(rawApp, yamlOptions);
@@ -64196,7 +64266,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
             };
             yield {
               isDirectory: false,
-              path: path9.join(finalPath, "DATATABLES.md"),
+              path: path10.join(finalPath, "DATATABLES.md"),
               async* getChildren() {},
               async getContentText() {
                 return generateDatatablesDocumentation(data3);
@@ -64299,12 +64369,12 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
       const scriptBasePath = removeSuffix(removeSuffix(finalPath, metaExt), ".script");
       const moduleFolderPath = scriptBasePath + getModuleFolderSuffix();
       if (hasModules) {
-        r[0].path = path9.join(moduleFolderPath, "script" + metaExt);
+        r[0].path = path10.join(moduleFolderPath, "script" + metaExt);
       }
       if (lock && lock != "") {
         r.push({
           isDirectory: false,
-          path: hasModules ? path9.join(moduleFolderPath, "script.lock") : removeSuffix(finalPath, metaExt) + ".lock",
+          path: hasModules ? path10.join(moduleFolderPath, "script.lock") : removeSuffix(finalPath, metaExt) + ".lock",
           async* getChildren() {},
           async getContentText() {
             return lock;
@@ -64319,7 +64389,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
             for (const [relPath, mod] of Object.entries(scriptModules)) {
               yield {
                 isDirectory: false,
-                path: path9.join(moduleFolderPath, relPath),
+                path: path10.join(moduleFolderPath, relPath),
                 async* getChildren() {},
                 async getContentText() {
                   return mod.content;
@@ -64329,7 +64399,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
                 const baseName = relPath.replace(/\.[^.]+$/, "");
                 yield {
                   isDirectory: false,
-                  path: path9.join(moduleFolderPath, baseName + ".lock"),
+                  path: path10.join(moduleFolderPath, baseName + ".lock"),
                   async* getChildren() {},
                   async getContentText() {
                     return mod.lock;
@@ -64366,7 +64436,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
               if (typeof fileContent === "string") {
                 yield {
                   isDirectory: false,
-                  path: path9.join(filesetBasePath, relPath),
+                  path: path10.join(filesetBasePath, relPath),
                   async* getChildren() {},
                   async getContentText() {
                     return fileContent;
@@ -64402,7 +64472,7 @@ function ZipFSElement(zip, useYaml, defaultTs, resourceTypeToFormatExtension, re
       async* getChildren() {
         for (const filename in zip2.files) {
           const file = zip2.files[filename];
-          const totalPath = path9.join(p, filename);
+          const totalPath = path10.join(p, filename);
           if (file.dir) {
             const e = zip2.folder(file.name);
             yield _internal_folder(totalPath, e);
@@ -64471,15 +64541,15 @@ async function elementsToMap(els, ignore, json, skips, specificItems, branchOver
     if (entry.ignored) {
       continue;
     }
-    const path10 = entry.path;
-    if (isScriptModulePath(path10)) {
-      map[path10] = await entry.getContentText();
+    const path11 = entry.path;
+    if (isScriptModulePath(path11)) {
+      map[path11] = await entry.getContentText();
       continue;
     }
-    if (!isFileResource(path10) && !isFilesetResource(path10) && !isRawAppFile(path10) && !isWorkspaceDependencies(path10)) {
-      if (json && path10.endsWith(".yaml"))
+    if (!isFileResource(path11) && !isFilesetResource(path11) && !isRawAppFile(path11) && !isWorkspaceDependencies(path11)) {
+      if (json && path11.endsWith(".yaml"))
         continue;
-      if (!json && path10.endsWith(".json"))
+      if (!json && path11.endsWith(".json"))
         continue;
       if (![
         "json",
@@ -64501,39 +64571,39 @@ async function elementsToMap(els, ignore, json, skips, specificItems, branchOver
         "java",
         "rb",
         "r"
-      ].includes(path10.split(".").pop() ?? "")) {
+      ].includes(path11.split(".").pop() ?? "")) {
         continue;
       }
     }
-    if (isRawAppFile(path10)) {
-      const suffix = path10.split(getFolderSuffix("raw_app") + SEP8).pop();
+    if (isRawAppFile(path11)) {
+      const suffix = path11.split(getFolderSuffix("raw_app") + SEP8).pop();
       if (suffix?.startsWith("dist/") || suffix == "wmill.d.ts" || suffix == "package-lock.json" || suffix == "DATATABLES.md") {
         continue;
       }
     }
-    if (skips.skipResources && (isFileResource(path10) || isFilesetResource(path10)))
+    if (skips.skipResources && (isFileResource(path11) || isFilesetResource(path11)))
       continue;
     const ext2 = json ? ".json" : ".yaml";
-    if (!skips.includeSchedules && path10.endsWith(".schedule" + ext2))
+    if (!skips.includeSchedules && path11.endsWith(".schedule" + ext2))
       continue;
-    if (!skips.includeTriggers && (path10.endsWith(".http_trigger" + ext2) || path10.endsWith(".websocket_trigger" + ext2) || path10.endsWith(".kafka_trigger" + ext2) || path10.endsWith(".nats_trigger" + ext2) || path10.endsWith(".postgres_trigger" + ext2) || path10.endsWith(".mqtt_trigger" + ext2) || path10.endsWith(".sqs_trigger" + ext2) || path10.endsWith(".gcp_trigger" + ext2) || path10.endsWith(".email_trigger" + ext2) || path10.endsWith("_native_trigger" + ext2))) {
+    if (!skips.includeTriggers && (path11.endsWith(".http_trigger" + ext2) || path11.endsWith(".websocket_trigger" + ext2) || path11.endsWith(".kafka_trigger" + ext2) || path11.endsWith(".nats_trigger" + ext2) || path11.endsWith(".postgres_trigger" + ext2) || path11.endsWith(".mqtt_trigger" + ext2) || path11.endsWith(".sqs_trigger" + ext2) || path11.endsWith(".gcp_trigger" + ext2) || path11.endsWith(".email_trigger" + ext2) || path11.endsWith("_native_trigger" + ext2))) {
       continue;
     }
-    if (!skips.includeUsers && path10.endsWith(".user" + ext2))
+    if (!skips.includeUsers && path11.endsWith(".user" + ext2))
       continue;
-    if (!skips.includeGroups && path10.endsWith(".group" + ext2))
+    if (!skips.includeGroups && path11.endsWith(".group" + ext2))
       continue;
-    if (!skips.includeSettings && path10 === "settings" + ext2)
+    if (!skips.includeSettings && path11 === "settings" + ext2)
       continue;
-    if (!skips.includeKey && path10 === "encryption_key")
+    if (!skips.includeKey && path11 === "encryption_key")
       continue;
-    if (skips.skipResources && path10.endsWith(".resource" + ext2))
+    if (skips.skipResources && path11.endsWith(".resource" + ext2))
       continue;
-    if (skips.skipResourceTypes && path10.endsWith(".resource-type" + ext2)) {
+    if (skips.skipResourceTypes && path11.endsWith(".resource-type" + ext2)) {
       continue;
     }
     try {
-      const fileType = getTypeStrFromPath(path10);
+      const fileType = getTypeStrFromPath(path11);
       if (skips.skipVariables && fileType === "variable")
         continue;
       if (skips.skipScripts && fileType === "script")
@@ -64547,27 +64617,27 @@ async function elementsToMap(els, ignore, json, skips, specificItems, branchOver
       if (skips.skipWorkspaceDependencies && fileType === "workspace_dependencies")
         continue;
     } catch {}
-    if (specificItems && isWorkspaceSpecificFile(path10)) {
-      if (!isCurrentWorkspaceFile(path10, cachedWsName)) {
+    if (specificItems && isWorkspaceSpecificFile(path11)) {
+      if (!isCurrentWorkspaceFile(path11, cachedWsName)) {
         continue;
       }
     }
     const content = await entry.getContentText();
-    if (skips.skipSecrets && path10.endsWith(".variable" + ext2)) {
+    if (skips.skipSecrets && path11.endsWith(".variable" + ext2)) {
       try {
         let o;
         if (json) {
           try {
             o = JSON.parse(content);
           } catch (error2) {
-            error(`Failed to parse JSON variable content at path: ${path10}`);
+            error(`Failed to parse JSON variable content at path: ${path11}`);
             throw error2;
           }
         } else {
           try {
-            o = yamlParseContent(path10, content);
+            o = yamlParseContent(path11, content);
           } catch (error2) {
-            error(`Failed to parse YAML variable content at path: ${path10}`);
+            error(`Failed to parse YAML variable content at path: ${path11}`);
             throw error2;
           }
         }
@@ -64575,12 +64645,12 @@ async function elementsToMap(els, ignore, json, skips, specificItems, branchOver
           continue;
         }
       } catch (e) {
-        warn(`Error reading variable ${path10} to check for secrets`);
+        warn(`Error reading variable ${path11} to check for secrets`);
       }
     }
-    if (cachedWsName && isCurrentWorkspaceFile(path10, cachedWsName)) {
+    if (cachedWsName && isCurrentWorkspaceFile(path11, cachedWsName)) {
       const currentBranch = cachedWsName;
-      const basePath = fromWorkspaceSpecificPath(path10, currentBranch);
+      const basePath = fromWorkspaceSpecificPath(path11, currentBranch);
       if (!isItemTypeConfigured(basePath, specificItems)) {
         continue;
       }
@@ -64589,14 +64659,14 @@ async function elementsToMap(els, ignore, json, skips, specificItems, branchOver
       }
       map[basePath] = content;
       processedBasePaths.add(basePath);
-    } else if (!isWorkspaceSpecificFile(path10)) {
-      if (processedBasePaths.has(path10)) {
+    } else if (!isWorkspaceSpecificFile(path11)) {
+      if (processedBasePaths.has(path11)) {
         continue;
       }
-      if (!isRemote && isSpecificItem(path10, specificItems)) {
+      if (!isRemote && isSpecificItem(path11, specificItems)) {
         continue;
       }
-      map[path10] = content;
+      map[path11] = content;
     }
   }
   if (wrongFormatPaths.length > 0) {
@@ -64851,7 +64921,7 @@ async function ignoreF(wmillconf) {
   };
 }
 async function addToChangedIfNotExists(p, tracker) {
-  const isScript = exts.some((e) => p.endsWith(e));
+  const isScript = exts.some((e) => p.endsWith(e)) && !isFileResource(p) && !isFilesetResource(p);
   if (isScript) {
     if (isFlowPath(p)) {
       const folder = extractFolderPath(p, "flow");
@@ -64976,7 +65046,7 @@ async function pull(opts) {
     throw error2;
   }
   if (opts.stateful) {
-    await mkdir5(path9.join(process.cwd(), ".wmill"), { recursive: true });
+    await mkdir5(path10.join(process.cwd(), ".wmill"), { recursive: true });
   }
   const workspace = await resolveWorkspace(opts, wsNameForConfig);
   await requireLogin(opts);
@@ -65001,7 +65071,7 @@ async function pull(opts) {
   } catch {}
   const zipFile = await downloadZip(workspace, opts.plainSecrets, opts.skipVariables, opts.skipResources, opts.skipResourceTypes, opts.skipSecrets, opts.includeSchedules, opts.includeTriggers, opts.includeUsers, opts.includeGroups, opts.includeSettings, opts.includeKey, opts.skipWorkspaceDependencies, opts.defaultTs);
   const remote = ZipFSElement(zipFile, !opts.json, opts.defaultTs ?? "bun", resourceTypeToFormatExtension, resourceTypeToIsFileset, true, parseSyncBehavior(opts.syncBehavior) >= 1);
-  const local = !opts.stateful ? await FSFSElement(process.cwd(), codebases, true) : await FSFSElement(path9.join(process.cwd(), ".wmill"), [], true);
+  const local = !opts.stateful ? await FSFSElement(process.cwd(), codebases, true) : await FSFSElement(path10.join(process.cwd(), ".wmill"), [], true);
   const changes = await compareDynFSElement(remote, local, await ignoreF(opts), opts.json ?? false, opts, false, codebases, true, specificItems, wsNameForFiles, true);
   info(`remote (${workspace.name}) -> local: ${changes.length} changes to apply`);
   if (opts.dryRun && opts.jsonOutput) {
@@ -65045,8 +65115,8 @@ async function pull(opts) {
           targetPath = workspaceSpecificPath;
         }
       }
-      const target = path9.join(process.cwd(), targetPath);
-      const stateTarget = path9.join(process.cwd(), ".wmill", targetPath);
+      const target = path10.join(process.cwd(), targetPath);
+      const stateTarget = path10.join(process.cwd(), ".wmill", targetPath);
       if (change.name === "edited") {
         if (opts.stateful) {
           try {
@@ -65079,13 +65149,13 @@ Both local and remote have been modified.`));
         }
         await writeFile7(target, change.after, "utf-8");
         if (opts.stateful) {
-          await mkdir5(path9.dirname(stateTarget), { recursive: true });
+          await mkdir5(path10.dirname(stateTarget), { recursive: true });
           await copyFile(target, stateTarget);
         }
       } else if (change.name === "added") {
-        await mkdir5(path9.dirname(target), { recursive: true });
+        await mkdir5(path10.dirname(target), { recursive: true });
         if (opts.stateful) {
-          await mkdir5(path9.dirname(stateTarget), { recursive: true });
+          await mkdir5(path10.dirname(stateTarget), { recursive: true });
           info(`Adding ${getTypeStrFromPath(change.path)} ${targetPath}${targetPath !== change.path ? colors.gray(` (workspace-specific override for ${change.path})`) : ""}`);
         }
         await writeFile7(target, change.content, "utf-8");
@@ -65290,7 +65360,7 @@ Push aborted: ${lockIssues.length} script(s) missing locks.`));
     resourceTypeToIsFileset = parsed.filesetMap;
   } catch {}
   const remote = ZipFSElement(await downloadZip(workspace, opts.plainSecrets, opts.skipVariables, opts.skipResources, opts.skipResourceTypes, opts.skipSecrets, opts.includeSchedules, opts.includeTriggers, opts.includeUsers, opts.includeGroups, opts.includeSettings, opts.includeKey, opts.skipWorkspaceDependencies, opts.defaultTs), !opts.json, opts.defaultTs ?? "bun", resourceTypeToFormatExtension, resourceTypeToIsFileset, false, parseSyncBehavior(opts.syncBehavior) >= 1);
-  const local = await FSFSElement(path9.join(process.cwd(), ""), codebases, false);
+  const local = await FSFSElement(path10.join(process.cwd(), ""), codebases, false);
   const changes = await compareDynFSElement(local, remote, await ignoreF(opts), opts.json ?? false, opts, true, codebases, false, specificItems, wsNameForFiles, false);
   const rawWorkspaceDependencies = await getRawWorkspaceDependencies(true);
   const tracker = await buildTracker(changes);
@@ -65404,7 +65474,7 @@ Push aborted: ${lockIssues.length} script(s) missing locks.`));
       }
     }
     for (const folderName2 of folderNames) {
-      const basePath = path9.join("f", folderName2, "folder.meta.yaml");
+      const basePath = path10.join("f", folderName2, "folder.meta.yaml");
       const branchPath = getWorkspaceSpecificPath(`f/${folderName2}/folder.meta.yaml`, specificItems, wsNameForFiles);
       let found = false;
       if (branchPath) {
@@ -65526,7 +65596,7 @@ ${folderList}
     let stateful = opts.stateful;
     if (stateful) {
       try {
-        await stat7(path9.join(process.cwd(), ".wmill"));
+        await stat7(path10.join(process.cwd(), ".wmill"));
       } catch {
         stateful = false;
       }
@@ -65577,7 +65647,7 @@ ${folderList}
             let stateTarget = undefined;
             if (stateful) {
               try {
-                stateTarget = path9.join(process.cwd(), ".wmill", change.path);
+                stateTarget = path10.join(process.cwd(), ".wmill", change.path);
                 await stat7(stateTarget);
               } catch {
                 stateTarget = undefined;
@@ -65602,7 +65672,7 @@ ${folderList}
                 continue;
               }
               if (stateTarget) {
-                await mkdir5(path9.dirname(stateTarget), { recursive: true });
+                await mkdir5(path10.dirname(stateTarget), { recursive: true });
                 info(`Editing ${getTypeStrFromPath(change.path)} ${change.path}`);
               }
               if (isFileResource(change.path)) {
@@ -65659,7 +65729,7 @@ ${folderList}
                 continue;
               }
               if (stateTarget) {
-                await mkdir5(path9.dirname(stateTarget), { recursive: true });
+                await mkdir5(path10.dirname(stateTarget), { recursive: true });
                 info(`Adding ${getTypeStrFromPath(change.path)} ${change.path}`);
               }
               const obj = parseFromPath(change.path, change.content);
@@ -66252,8 +66322,8 @@ var init_parse_schema = __esm(() => {
 // src/utils/metadata.ts
 import { sep as SEP9 } from "node:path";
 import { readFile as readFile9, writeFile as writeFile8, stat as stat8, rm as rm2, readdir as readdir5 } from "node:fs/promises";
-import { readFileSync as readFileSync3, existsSync as existsSync4, readdirSync, statSync, writeFileSync as writeFileSync3 } from "node:fs";
-import * as path10 from "node:path";
+import { readFileSync as readFileSync3, existsSync as existsSync5, readdirSync, statSync, writeFileSync as writeFileSync4 } from "node:fs";
+import * as path11 from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 function loadParser(pkgName) {
   let p = _parserCache.get(pkgName);
@@ -66295,8 +66365,8 @@ async function getRawWorkspaceDependencies(legacyBehaviour) {
   } catch {}
   return rawWorkspaceDeps;
 }
-function workspaceDependenciesPathToLanguageAndFilename(path11) {
-  const relativePath = path11.replace("dependencies/", "");
+function workspaceDependenciesPathToLanguageAndFilename(path12) {
+  const relativePath = path12.replace("dependencies/", "");
   for (const { filename, language } of workspaceDependenciesLanguages) {
     if (relativePath.endsWith(filename)) {
       return {
@@ -66350,8 +66420,8 @@ async function generateScriptMetadataInternal(scriptPath, workspace, opts, dryRu
   const scriptContent = await readFile9(scriptPath, "utf-8");
   const metadataContent = await readFile9(metadataWithType.path, "utf-8");
   const filteredRawWorkspaceDependencies = filterWorkspaceDependencies(rawWorkspaceDependencies, scriptContent, language);
-  const moduleFolderPath = isFolderLayout ? path10.dirname(scriptPath) : scriptPath.substring(0, scriptPath.indexOf(".")) + getModuleFolderSuffix();
-  const hasModules = existsSync4(moduleFolderPath) && statSync(moduleFolderPath).isDirectory();
+  const moduleFolderPath = isFolderLayout ? path11.dirname(scriptPath) : scriptPath.substring(0, scriptPath.indexOf(".")) + getModuleFolderSuffix();
+  const hasModules = existsSync5(moduleFolderPath) && statSync(moduleFolderPath).isDirectory();
   const depsForHash = tree ? {} : filteredRawWorkspaceDependencies;
   let hash2 = await generateScriptHash(depsForHash, scriptContent, metadataContent);
   let moduleHashes = {};
@@ -66407,7 +66477,7 @@ async function generateScriptMetadataInternal(scriptPath, workspace, opts, dryRu
     const hasCodebase = findCodebase(scriptPath, codebases) != null;
     if (!hasCodebase) {
       const tempScriptRefs = tree?.getTempScriptRefs(remotePath);
-      const lockPathOverride = isFolderLayout ? path10.dirname(scriptPath) + "/script.lock" : undefined;
+      const lockPathOverride = isFolderLayout ? path11.dirname(scriptPath) + "/script.lock" : undefined;
       await updateScriptLock(workspace, scriptContent, language, remotePath, metadataParsedContent, filteredRawWorkspaceDependencies, tempScriptRefs, lockPathOverride);
     } else {
       metadataParsedContent.lock = "";
@@ -66438,10 +66508,10 @@ async function generateScriptMetadataInternal(scriptPath, workspace, opts, dryRu
   let newMetadataContent;
   if (isFolderLayout) {
     if (metadataWithType.isJson) {
-      metaPath = path10.dirname(scriptPath) + "/script.json";
+      metaPath = path11.dirname(scriptPath) + "/script.json";
       newMetadataContent = JSON.stringify(metadataParsedContent);
     } else {
-      metaPath = path10.dirname(scriptPath) + "/script.yaml";
+      metaPath = path11.dirname(scriptPath) + "/script.yaml";
       newMetadataContent = import_yaml13.stringify(metadataParsedContent, yamlOptions);
     }
   } else {
@@ -66453,7 +66523,7 @@ async function generateScriptMetadataInternal(scriptPath, workspace, opts, dryRu
       newMetadataContent = import_yaml13.stringify(metadataParsedContent, yamlOptions);
     }
   }
-  const metadataContentUsedForHash = newMetadataContent;
+  const metadataContentUsedForHash = justUpdateMetadataLock ? metadataContent : newMetadataContent;
   hash2 = await generateScriptHash(depsForHash, scriptContent, metadataContentUsedForHash);
   if (hasModuleHashes) {
     const sortedEntries = Object.entries(moduleHashes).sort(([a], [b]) => a.localeCompare(b));
@@ -66471,8 +66541,8 @@ async function generateScriptMetadataInternal(scriptPath, workspace, opts, dryRu
   }
   return `${remotePath} (${language})`;
 }
-async function updateScriptSchema(scriptContent, language, metadataContent, path11) {
-  const result = await inferSchema(language, scriptContent, metadataContent.schema, path11);
+async function updateScriptSchema(scriptContent, language, metadataContent, path12) {
+  const result = await inferSchema(language, scriptContent, metadataContent.schema, path12);
   metadataContent.schema = result.schema;
   if (result.has_preprocessor) {
     metadataContent.has_preprocessor = result.has_preprocessor;
@@ -66626,7 +66696,7 @@ async function updateScriptLock(workspace, scriptContent, language, remotePath,
 async function updateModuleLocks(workspace, dirPath, relPrefix, scriptRemotePath, rawWorkspaceDependencies, defaultTs, changedModules) {
   const entries = readdirSync(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path10.join(dirPath, entry.name);
+    const fullPath = path11.join(dirPath, entry.name);
     const relPath = relPrefix ? relPrefix + "/" + entry.name : entry.name;
     if (entry.isDirectory()) {
       await updateModuleLocks(workspace, fullPath, relPath, scriptRemotePath, rawWorkspaceDependencies, defaultTs, changedModules);
@@ -66650,12 +66720,12 @@ async function updateModuleLocks(workspace, dirPath, relPrefix, scriptRemotePath
       try {
         const lock = await fetchScriptLock(workspace, moduleContent, modLanguage, moduleRemotePath, rawWorkspaceDependencies);
         const baseName = entry.name.replace(/\.[^.]+$/, "");
-        const lockPath = path10.join(dirPath, baseName + ".lock");
+        const lockPath = path11.join(dirPath, baseName + ".lock");
         if (lock != "") {
-          writeFileSync3(lockPath, lock, "utf-8");
+          writeFileSync4(lockPath, lock, "utf-8");
         } else {
           try {
-            if (existsSync4(lockPath)) {
+            if (existsSync5(lockPath)) {
               const { rm: rmAsync } = await import("node:fs/promises");
               await rmAsync(lockPath);
             }
@@ -66667,7 +66737,7 @@ async function updateModuleLocks(workspace, dirPath, relPrefix, scriptRemotePath
     }
   }
 }
-async function inferSchema(language, content, currentSchema, path11) {
+async function inferSchema(language, content, currentSchema, path12) {
   let inferedSchema;
   if (language === "python3") {
     const { parse_python } = await loadParser("windmill-parser-wasm-py");
@@ -66770,7 +66840,7 @@ async function inferSchema(language, content, currentSchema, path11) {
     throw new Error("Invalid language: " + language);
   }
   if (inferedSchema.type == "Invalid") {
-    info(colors.yellow(`Script ${path11} invalid, it cannot be parsed to infer schema.`));
+    info(colors.yellow(`Script ${path12} invalid, it cannot be parsed to infer schema.`));
     return {
       schema: defaultScriptMetadata().schema,
       has_preprocessor: false,
@@ -66942,15 +67012,15 @@ async function readLockfile() {
     return lock;
   }
 }
-function v2LockPath(path11, subpath) {
-  const normalizedPath = normalizeLockPath(path11);
+function v2LockPath(path12, subpath) {
+  const normalizedPath = normalizeLockPath(path12);
   if (subpath) {
     return `${normalizedPath}+${normalizeLockPath(subpath)}`;
   } else {
     return normalizedPath;
   }
 }
-async function checkifMetadataUptodate(path11, hash2, conf, subpath) {
+async function checkifMetadataUptodate(path12, hash2, conf, subpath) {
   if (!conf) {
     conf = await readLockfile();
   }
@@ -66959,10 +67029,10 @@ async function checkifMetadataUptodate(path11, hash2, conf, subpath) {
   }
   const isV2 = conf?.version == "v2";
   if (isV2) {
-    const current = conf.locks?.[v2LockPath(path11, subpath)];
+    const current = conf.locks?.[v2LockPath(path12, subpath)];
     return current == hash2;
   } else {
-    const obj = conf.locks?.[path11];
+    const obj = conf.locks?.[path12];
     const current = subpath && typeof obj == "object" ? obj?.[subpath] : obj;
     return current == hash2;
   }
@@ -66975,7 +67045,7 @@ async function computeModuleHashes(moduleFolderPath, defaultTs, rawWorkspaceDepe
   async function readDir2(dirPath, relPrefix) {
     const entries = readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path10.join(dirPath, entry.name);
+      const fullPath = path11.join(dirPath, entry.name);
       const relPath = relPrefix ? relPrefix + "/" + entry.name : entry.name;
       const isTopLevel = relPrefix === "";
       if (entry.isDirectory()) {
@@ -66995,14 +67065,14 @@ async function computeModuleHashes(moduleFolderPath, defaultTs, rawWorkspaceDepe
   await readDir2(moduleFolderPath, "");
   return hashes;
 }
-async function clearGlobalLock(path11) {
+async function clearGlobalLock(path12) {
   const conf = await readLockfile();
   if (!conf?.locks) {
     conf.locks = {};
   }
   const isV2 = conf?.version == "v2";
   if (isV2) {
-    const key = v2LockPath(path11);
+    const key = v2LockPath(path12);
     if (conf.locks) {
       Object.keys(conf.locks).forEach((k) => {
         if (conf.locks) {
@@ -67015,24 +67085,24 @@ async function clearGlobalLock(path11) {
     await writeFile8(WMILL_LOCKFILE, import_yaml13.stringify(conf, yamlOptions), "utf-8");
   }
 }
-async function updateMetadataGlobalLock(path11, hash2, subpath) {
+async function updateMetadataGlobalLock(path12, hash2, subpath) {
   const conf = await readLockfile();
   if (!conf?.locks) {
     conf.locks = {};
   }
   const isV2 = conf?.version == "v2";
   if (isV2) {
-    conf.locks[v2LockPath(path11, subpath)] = hash2;
+    conf.locks[v2LockPath(path12, subpath)] = hash2;
   } else {
     if (subpath) {
-      let prev = conf.locks[path11];
+      let prev = conf.locks[path12];
       if (!prev || typeof prev != "object") {
         prev = {};
-        conf.locks[path11] = prev;
+        conf.locks[path12] = prev;
       }
       prev[subpath] = hash2;
     } else {
-      conf.locks[path11] = hash2;
+      conf.locks[path12] = hash2;
     }
   }
   await writeFile8(WMILL_LOCKFILE, import_yaml13.stringify(conf, yamlOptions), "utf-8");
@@ -67082,7 +67152,7 @@ __export(exports_raw_apps, {
   generatingPolicy: () => generatingPolicy
 });
 import { sep as SEP10 } from "node:path";
-import path11 from "node:path";
+import path12 from "node:path";
 import { readFile as readFile10, readdir as readdir6 } from "node:fs/promises";
 async function findRunnableContentFile(backendPath, runnableId, allFiles) {
   for (const fileName of allFiles) {
@@ -67095,7 +67165,7 @@ async function findRunnableContentFile(backendPath, runnableId, allFiles) {
     const ext2 = fileName.substring(runnableId.length + 1);
     if (EXTENSION_TO_LANGUAGE[ext2]) {
       try {
-        const content = await readFile10(path11.join(backendPath, fileName), "utf-8");
+        const content = await readFile10(path12.join(backendPath, fileName), "utf-8");
         return { ext: ext2, content };
       } catch {
         continue;
@@ -67132,7 +67202,7 @@ async function loadRunnablesFromBackend(backendPath, defaultTs = "bun") {
       }
       const runnableId = fileName.replace(".yaml", "");
       processedIds.add(runnableId);
-      const filePath = path11.join(backendPath, fileName);
+      const filePath = path12.join(backendPath, fileName);
       const runnable = await yamlParseFile(filePath);
       if (runnable?.type === "inline") {
         const contentFile = await findRunnableContentFile(backendPath, runnableId, allFiles);
@@ -67140,7 +67210,7 @@ async function loadRunnablesFromBackend(backendPath, defaultTs = "bun") {
           const language = getLanguageFromExtension(contentFile.ext, defaultTs);
           let lock;
           try {
-            lock = await readFile10(path11.join(backendPath, `${runnableId}.lock`), "utf-8");
+            lock = await readFile10(path12.join(backendPath, `${runnableId}.lock`), "utf-8");
           } catch {}
           runnable.inlineScript = {
             content: contentFile.content,
@@ -67171,7 +67241,7 @@ async function loadRunnablesFromBackend(backendPath, defaultTs = "bun") {
         const language = getLanguageFromExtension(contentFile.ext, defaultTs);
         let lock;
         try {
-          lock = await readFile10(path11.join(backendPath, `${runnableId}.lock`), "utf-8");
+          lock = await readFile10(path12.join(backendPath, `${runnableId}.lock`), "utf-8");
         } catch {}
         runnables[runnableId] = {
           type: "inline",
@@ -67199,7 +67269,7 @@ function writeRunnableToBackend(backendPath, runnableId, runnable) {
       ...rest
     };
   }
-  const filePath = path11.join(backendPath, `${runnableId}.yaml`);
+  const filePath = path12.join(backendPath, `${runnableId}.yaml`);
   writeIfChanged(filePath, import_yaml16.stringify(runnableToWrite, yamlOptions));
 }
 async function collectAppFiles(localPath) {
@@ -67250,7 +67320,7 @@ async function pushRawApp(workspace, remotePath, localPath, message) {
   }
   const appFilePath = localPath + "raw_app.yaml";
   const localApp = await yamlParseFile(appFilePath);
-  const backendPath = path11.join(localPath, APP_BACKEND_FOLDER);
+  const backendPath = path12.join(localPath, APP_BACKEND_FOLDER);
   const runnablesFromBackend = await loadRunnablesFromBackend(backendPath);
   let runnables;
   if (Object.keys(runnablesFromBackend).length > 0) {
@@ -67326,13 +67396,13 @@ async function pushRawApp(workspace, remotePath, localPath, message) {
     });
   }
 }
-async function generatingPolicy(app, path12, publicApp) {
-  info(colors.gray(`Generating fresh policy for app ${path12}...`));
+async function generatingPolicy(app, path13, publicApp) {
+  info(colors.gray(`Generating fresh policy for app ${path13}...`));
   try {
     app.policy = await updateRawAppPolicy(app.runnables, app.policy);
     app.policy.execution_mode = publicApp ? "anonymous" : "publisher";
   } catch (e) {
-    error(colors.red(`Error generating policy for app ${path12}: ${e}`));
+    error(colors.red(`Error generating policy for app ${path13}: ${e}`));
     throw e;
   }
 }
@@ -67369,11 +67439,11 @@ __export(exports_app_metadata, {
   filterWorkspaceDependenciesForApp: () => filterWorkspaceDependenciesForApp,
   APP_BACKEND_FOLDER: () => APP_BACKEND_FOLDER
 });
-import path12 from "node:path";
+import path13 from "node:path";
 import { readFile as readFile11, mkdir as mkdir6 } from "node:fs/promises";
 import { sep as SEP11 } from "node:path";
 async function generateAppHash(rawReqs, folder, rawApp, defaultTs) {
-  const runnablesFolder = rawApp ? path12.join(folder, APP_BACKEND_FOLDER) : folder;
+  const runnablesFolder = rawApp ? path13.join(folder, APP_BACKEND_FOLDER) : folder;
   const hashes = {};
   try {
     const elems = await FSFSElement(runnablesFolder, [], true);
@@ -67394,7 +67464,11 @@ async function generateAppHash(rawReqs, folder, rawApp, defaultTs) {
       throw error2;
     }
   }
-  return { ...hashes, [TOP_HASH2]: await generateHash(JSON.stringify(hashes)) };
+  const sortedHashes = {};
+  for (const k of Object.keys(hashes).sort()) {
+    sortedHashes[k] = hashes[k];
+  }
+  return { ...sortedHashes, [TOP_HASH2]: await generateHash(JSON.stringify(sortedHashes)) };
 }
 async function generateAppLocksInternal(appFolder, rawApp, dryRun, workspace, opts, justUpdateMetadataLock, noStaleMessage, tree) {
   if (appFolder.endsWith(SEP11)) {
@@ -67404,7 +67478,7 @@ async function generateAppLocksInternal(appFolder, rawApp, dryRun, workspace, op
   if (!justUpdateMetadataLock && !noStaleMessage) {
     info(`Generating locks for app ${appFolder} at ${remote_path}`);
   }
-  const appFilePath = path12.join(appFolder, rawApp ? "raw_app.yaml" : "app.yaml");
+  const appFilePath = path13.join(appFolder, rawApp ? "raw_app.yaml" : "app.yaml");
   const appFile = await yamlParseFile(appFilePath);
   const appValue = rawApp ? appFile.runnables : appFile.value;
   const folderNormalized = appFolder.replaceAll(SEP11, "/");
@@ -67416,7 +67490,7 @@ async function generateAppLocksInternal(appFolder, rawApp, dryRun, workspace, op
       const isDirectlyStale = !await checkifMetadataUptodate(appFolder, hashes[TOP_HASH2], conf, TOP_HASH2);
       let treeAppValue = structuredClone(appValue);
       if (rawApp) {
-        const runnablesPath = path12.join(appFolder, APP_BACKEND_FOLDER);
+        const runnablesPath = path13.join(appFolder, APP_BACKEND_FOLDER);
         const runnablesFromFiles = await loadRunnablesFromBackend(runnablesPath);
         if (Object.keys(runnablesFromFiles).length > 0) {
           treeAppValue = runnablesFromFiles;
@@ -67482,7 +67556,7 @@ async function generateAppLocksInternal(appFolder, rawApp, dryRun, workspace, op
         info(`Recomputing locks of ${changedScripts.join(", ")} in ${appFolder}`);
       }
       if (rawApp) {
-        const runnablesPath = path12.join(appFolder, APP_BACKEND_FOLDER);
+        const runnablesPath = path13.join(appFolder, APP_BACKEND_FOLDER);
         const rawAppFile = appFile;
         let runnables = await loadRunnablesFromBackend(runnablesPath);
         if (Object.keys(runnables).length === 0 && rawAppFile.runnables) {
@@ -67555,7 +67629,7 @@ async function traverseAndProcessInlineScripts(obj, processor, currentPath = [])
 }
 async function updateRawAppRunnables(workspace, runnables, remotePath, appFolder, rawDeps, defaultTs = "bun", noStaleMessage, tempScriptRefs) {
   const updatedRunnables = [];
-  const runnablesFolder = path12.join(appFolder, APP_BACKEND_FOLDER);
+  const runnablesFolder = path13.join(appFolder, APP_BACKEND_FOLDER);
   try {
     await mkdir6(runnablesFolder, { recursive: true });
   } catch {}
@@ -67580,7 +67654,7 @@ async function updateRawAppRunnables(workspace, runnables, remotePath, appFolder
     if (language === "frontend") {
       const [basePathO, ext2] = pathAssigner.assignPath(runnableId, language);
       const basePath = basePathO.replaceAll(SEP11, "/");
-      const contentPath = path12.join(runnablesFolder, `${basePath}${ext2}`);
+      const contentPath = path13.join(runnablesFolder, `${basePath}${ext2}`);
       writeIfChanged(contentPath, content);
       const simplifiedRunnable = { type: "inline" };
       for (const [key, value] of Object.entries(runnable)) {
@@ -67598,8 +67672,8 @@ async function updateRawAppRunnables(workspace, runnables, remotePath, appFolder
       const lock = await generateInlineScriptLock(workspace, content, language, `${remotePath}/${runnableId}`, rawDeps, tempScriptRefs);
       const [basePathO, ext2] = pathAssigner.assignPath(runnableId, language);
       const basePath = basePathO.replaceAll(SEP11, "/");
-      const contentPath = path12.join(runnablesFolder, `${basePath}${ext2}`);
-      const lockPath = path12.join(runnablesFolder, `${basePath}lock`);
+      const contentPath = path13.join(runnablesFolder, `${basePath}${ext2}`);
+      const lockPath = path13.join(runnablesFolder, `${basePath}lock`);
       writeIfChanged(contentPath, content);
       if (lock && lock !== "") {
         writeIfChanged(lockPath, lock);
@@ -67647,8 +67721,8 @@ async function updateAppInlineScripts(workspace, appValue, remotePath, appFolder
       }
       const [basePathO, ext2] = pathAssigner.assignPath(scriptName, language);
       const basePath = basePathO.replaceAll(SEP11, "/");
-      const contentPath = path12.join(appFolder, `${basePath}${ext2}`);
-      const lockPath = path12.join(appFolder, `${basePath}lock`);
+      const contentPath = path13.join(appFolder, `${basePath}${ext2}`);
+      const lockPath = path13.join(appFolder, `${basePath}lock`);
       writeIfChanged(contentPath, content);
       if (lock && lock !== "") {
         writeIfChanged(lockPath, lock);
@@ -67719,7 +67793,7 @@ ${text}`);
   }
 }
 async function inferRunnableSchemaFromFile(appFolder, runnableFilePath) {
-  const fileName = path12.basename(runnableFilePath);
+  const fileName = path13.basename(runnableFilePath);
   if (fileName.endsWith(".lock") || fileName.endsWith(".yaml")) {
     return;
   }
@@ -67728,13 +67802,13 @@ async function inferRunnableSchemaFromFile(appFolder, runnableFilePath) {
     return;
   }
   const runnableId = match2[1];
-  const runnableFilePath2 = path12.join(appFolder, APP_BACKEND_FOLDER, `${runnableId}.yaml`);
+  const runnableFilePath2 = path13.join(appFolder, APP_BACKEND_FOLDER, `${runnableId}.yaml`);
   let runnable;
   try {
     runnable = await yamlParseFile(runnableFilePath2);
   } catch {
     try {
-      const appFilePath = path12.join(appFolder, "raw_app.yaml");
+      const appFilePath = path13.join(appFolder, "raw_app.yaml");
       const appFile = await yamlParseFile(appFilePath);
       if (!appFile.runnables?.[runnableId]) {
         warn(colors.yellow(`Runnable ${runnableId} not found in backend folder or raw_app.yaml`));
@@ -67751,7 +67825,7 @@ async function inferRunnableSchemaFromFile(appFolder, runnableFilePath) {
   }
   const inlineScript = runnable.inlineScript;
   const language = inlineScript.language;
-  const fullFilePath = path12.join(appFolder, APP_BACKEND_FOLDER, runnableFilePath);
+  const fullFilePath = path13.join(appFolder, APP_BACKEND_FOLDER, runnableFilePath);
   let content;
   try {
     content = await readFile11(fullFilePath, "utf-8");
@@ -67861,8 +67935,8 @@ var init_app_metadata = __esm(async () => {
 // src/commands/app/generate_agents.ts
 import * as fs9 from "node:fs";
 import { writeFile as writeFile9 } from "node:fs/promises";
-import path13 from "node:path";
-import process14 from "node:process";
+import path14 from "node:path";
+import process15 from "node:process";
 function generateDatatablesMarkdown(schemas, localData) {
   const defaultDatatable = localData?.datatable;
   const defaultSchema = localData?.schema;
@@ -67961,7 +68035,7 @@ Configure datatables in Workspace Settings > Windmill Data Tables.
   return content;
 }
 async function regenerateAgentDocs(workspaceId, targetDir, silent = false) {
-  const rawAppPath = path13.join(targetDir, "raw_app.yaml");
+  const rawAppPath = path14.join(targetDir, "raw_app.yaml");
   if (!fs9.existsSync(rawAppPath)) {
     if (!silent) {
       error(colors.red(`Error: raw_app.yaml not found in ${targetDir}`));
@@ -67988,11 +68062,11 @@ async function regenerateAgentDocs(workspaceId, targetDir, silent = false) {
     }
   } catch {}
   const agentsContent = generateAgentsDocumentation(localData);
-  await writeFile9(path13.join(targetDir, "AGENTS.md"), agentsContent, "utf-8");
-  await writeFile9(path13.join(targetDir, "CLAUDE.md"), `Instructions are in @AGENTS.md
+  await writeFile9(path14.join(targetDir, "AGENTS.md"), agentsContent, "utf-8");
+  await writeFile9(path14.join(targetDir, "CLAUDE.md"), `Instructions are in @AGENTS.md
 `, "utf-8");
   const datatablesContent = generateDatatablesMarkdown(schemas, localData);
-  await writeFile9(path13.join(targetDir, "DATATABLES.md"), datatablesContent, "utf-8");
+  await writeFile9(path14.join(targetDir, "DATATABLES.md"), datatablesContent, "utf-8");
   if (!silent) {
     info(colors.green(`✓ Generated AGENTS.md, CLAUDE.md, and DATATABLES.md`));
     const datatableCount = schemas.length;
@@ -68010,24 +68084,24 @@ async function regenerateAgentDocs(workspaceId, targetDir, silent = false) {
   }
 }
 async function generateAgents(opts, appFolder) {
-  const cwd = process14.cwd();
+  const cwd = process15.cwd();
   let targetDir = cwd;
   if (appFolder) {
-    targetDir = path13.isAbsolute(appFolder) ? appFolder : path13.join(cwd, appFolder);
+    targetDir = path14.isAbsolute(appFolder) ? appFolder : path14.join(cwd, appFolder);
   }
   await loadNonDottedPathsSetting();
-  const dirName = path13.basename(targetDir);
+  const dirName = path14.basename(targetDir);
   if (!hasFolderSuffix(dirName, "raw_app")) {
-    if (!hasFolderSuffix(path13.basename(cwd), "raw_app") && !appFolder) {
+    if (!hasFolderSuffix(path14.basename(cwd), "raw_app") && !appFolder) {
       error(colors.red(`Error: Must be run inside a ${getFolderSuffix("raw_app")} folder or specify one as argument.`));
       info(colors.gray("Usage: wmill app generate-agents [app_folder]"));
-      process14.exit(1);
+      process15.exit(1);
     }
   }
-  const rawAppPath = path13.join(targetDir, "raw_app.yaml");
+  const rawAppPath = path14.join(targetDir, "raw_app.yaml");
   if (!fs9.existsSync(rawAppPath)) {
     error(colors.red(`Error: raw_app.yaml not found in ${targetDir}`));
-    process14.exit(1);
+    process15.exit(1);
   }
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
@@ -68054,40 +68128,40 @@ var init_generate_agents = __esm(async () => {
 import { sep as SEP12 } from "node:path";
 import * as http2 from "node:http";
 import * as fs10 from "node:fs";
-import * as path14 from "node:path";
-import process15 from "node:process";
-import { writeFileSync as writeFileSync4 } from "node:fs";
+import * as path15 from "node:path";
+import process16 from "node:process";
+import { writeFileSync as writeFileSync5 } from "node:fs";
 import { readFile as readFile12 } from "node:fs/promises";
 async function dev(opts, appFolder) {
   GLOBAL_CONFIG_OPT.noCdToRoot = true;
   await loadNonDottedPathsSetting();
-  const originalCwd = process15.cwd();
+  const originalCwd = process16.cwd();
   let targetDir = originalCwd;
   if (appFolder) {
-    targetDir = path14.isAbsolute(appFolder) ? appFolder : path14.join(originalCwd, appFolder);
+    targetDir = path15.isAbsolute(appFolder) ? appFolder : path15.join(originalCwd, appFolder);
     if (!fs10.existsSync(targetDir)) {
       error(colors.red(`Error: Directory not found: ${targetDir}`));
-      process15.exit(1);
+      process16.exit(1);
     }
   }
-  const targetDirName = path14.basename(targetDir);
+  const targetDirName = path15.basename(targetDir);
   if (!hasFolderSuffix(targetDirName, "raw_app")) {
     error(colors.red(`Error: The dev command must be run inside a ${getFolderSuffix("raw_app")} folder.
 ` + `Target directory: ${targetDirName}
 ` + `Please navigate to a folder ending with '${getFolderSuffix("raw_app")}' or specify one as argument.`));
-    process15.exit(1);
+    process16.exit(1);
   }
-  const rawAppPath = path14.join(targetDir, "raw_app.yaml");
+  const rawAppPath = path15.join(targetDir, "raw_app.yaml");
   if (!fs10.existsSync(rawAppPath)) {
     error(colors.red(`Error: raw_app.yaml not found in ${targetDir}.
 ` + `The dev command requires a ${getFolderSuffix("raw_app")} folder containing a raw_app.yaml file.`));
-    process15.exit(1);
+    process16.exit(1);
   }
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   const workspaceId = workspace.workspaceId;
   if (appFolder) {
-    process15.chdir(targetDir);
+    process16.chdir(targetDir);
   }
   const rawApp = await yamlParseFile(rawAppPath);
   const appPath = rawApp?.custom_path ?? "u/unknown/newapp";
@@ -68097,18 +68171,18 @@ async function dev(opts, appFolder) {
   });
   const host = opts.host ?? DEFAULT_HOST;
   const shouldOpen = opts.open ?? true;
-  const frameworks = detectFrameworks(process15.cwd());
+  const frameworks = detectFrameworks(process16.cwd());
   const defaultEntry = frameworks.svelte || frameworks.vue ? "index.ts" : "index.tsx";
   const entryPoint = opts.entry ?? defaultEntry;
   if (!fs10.existsSync(entryPoint)) {
     error(colors.red(`Entry point "${entryPoint}" not found. Please specify a valid entry point with --entry.`));
-    process15.exit(1);
+    process16.exit(1);
   }
-  const appDir = path14.dirname(entryPoint) || process15.cwd();
+  const appDir = path15.dirname(entryPoint) || process16.cwd();
   await ensureNodeModules(appDir);
   const inferredSchemas = {};
   genRunnablesTs(inferredSchemas);
-  const distDir = path14.join(process15.cwd(), "dist");
+  const distDir = path15.join(process16.cwd(), "dist");
   if (!fs10.existsSync(distDir)) {
     fs10.mkdirSync(distDir);
   }
@@ -68171,7 +68245,7 @@ data: reload
   info(colors.blue(`\uD83D\uDC40 Watching for file changes...
 `));
   await ctx.rebuild();
-  const runnablesPath = path14.join(process15.cwd(), APP_BACKEND_FOLDER);
+  const runnablesPath = path15.join(process16.cwd(), APP_BACKEND_FOLDER);
   let runnablesWatcher;
   if (fs10.existsSync(runnablesPath)) {
     info(colors.blue(`\uD83D\uDC41️  Watching runnables folder at: ${runnablesPath}
@@ -68183,8 +68257,8 @@ data: reload
       if (!filename)
         return;
       const fileStr = typeof filename === "string" ? filename : filename.toString();
-      const changedPath = path14.join(runnablesPath, fileStr);
-      const relativePath = path14.relative(process15.cwd(), changedPath);
+      const changedPath = path15.join(runnablesPath, fileStr);
+      const relativePath = path15.relative(process16.cwd(), changedPath);
       const relativeToRunnables = fileStr;
       if (changedPath.endsWith(".lock")) {
         return;
@@ -68197,7 +68271,7 @@ data: reload
         delete schemaInferenceTimeouts[changedPath];
         try {
           info(colors.cyan(`\uD83D\uDCDD Inferring schema for: ${relativeToRunnables}`));
-          const result = await inferRunnableSchemaFromFile(process15.cwd(), relativeToRunnables);
+          const result = await inferRunnableSchemaFromFile(process16.cwd(), relativeToRunnables);
           if (result) {
             inferredSchemas[result.runnableId] = result.schema;
             info(colors.green(`  Inferred Schemas: ${JSON.stringify(inferredSchemas, null, 2)}`));
@@ -68235,7 +68309,7 @@ data: reload
       return;
     }
     if (url === "/dist/bundle.js" || url === "/bundle.js") {
-      const jsPath = path14.join(process15.cwd(), "dist/bundle.js");
+      const jsPath = path15.join(process16.cwd(), "dist/bundle.js");
       if (fs10.existsSync(jsPath)) {
         res.writeHead(200, { "Content-Type": "application/javascript" });
         res.end(fs10.readFileSync(jsPath));
@@ -68246,7 +68320,7 @@ data: reload
       return;
     }
     if (url === "/dist/bundle.css" || url === "/bundle.css") {
-      const cssPath = path14.join(process15.cwd(), "dist/bundle.css");
+      const cssPath = path15.join(process16.cwd(), "dist/bundle.css");
       if (fs10.existsSync(cssPath)) {
         res.writeHead(200, { "Content-Type": "text/css" });
         res.end(fs10.readFileSync(cssPath));
@@ -68257,7 +68331,7 @@ data: reload
       return;
     }
     if (url === "/dist/bundle.js.map" || url === "/bundle.js.map") {
-      const mapPath = path14.join(process15.cwd(), "dist/bundle.js.map");
+      const mapPath = path15.join(process16.cwd(), "dist/bundle.js.map");
       if (fs10.existsSync(mapPath)) {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(fs10.readFileSync(mapPath));
@@ -68268,7 +68342,7 @@ data: reload
       return;
     }
     if (url === "/dist/bundle.css.map" || url === "/bundle.css.map") {
-      const mapPath = path14.join(process15.cwd(), "dist/bundle.css.map");
+      const mapPath = path15.join(process16.cwd(), "dist/bundle.css.map");
       if (fs10.existsSync(mapPath)) {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(fs10.readFileSync(mapPath));
@@ -68282,12 +68356,12 @@ data: reload
     res.end(createHTML("/dist/bundle.js", "/dist/bundle.css"));
   });
   const wss = new import_websocket_server.default({ server });
-  const sqlToApplyPath = path14.join(process15.cwd(), "sql_to_apply");
+  const sqlToApplyPath = path15.join(process16.cwd(), "sql_to_apply");
   const sqlFileQueue = [];
   let currentSqlFile = null;
   async function getDatatableConfig() {
     try {
-      const rawApp2 = await yamlParseFile(path14.join(process15.cwd(), "raw_app.yaml"));
+      const rawApp2 = await yamlParseFile(path15.join(process16.cwd(), "raw_app.yaml"));
       return rawApp2?.data?.datatable;
     } catch {
       return;
@@ -68324,12 +68398,12 @@ data: reload
     }
     const filePath = sqlFileQueue.shift();
     if (!fs10.existsSync(filePath)) {
-      info(colors.gray(`File no longer exists: ${path14.basename(filePath)}`));
+      info(colors.gray(`File no longer exists: ${path15.basename(filePath)}`));
       await processNextSqlFile();
       return;
     }
     currentSqlFile = filePath;
-    const fileName = path14.basename(filePath);
+    const fileName = path15.basename(filePath);
     try {
       const sqlContent = await readFile12(filePath, "utf-8");
       if (!sqlContent.trim()) {
@@ -68351,9 +68425,9 @@ data: reload
     if (deleteFile && fs10.existsSync(filePath)) {
       try {
         fs10.unlinkSync(filePath);
-        info(colors.green(`✓ Deleted: ${path14.basename(filePath)}`));
+        info(colors.green(`✓ Deleted: ${path15.basename(filePath)}`));
       } catch (error2) {
-        error(colors.red(`Failed to delete ${path14.basename(filePath)}: ${error2.message}`));
+        error(colors.red(`Failed to delete ${path15.basename(filePath)}: ${error2.message}`));
       }
     }
     currentSqlFile = null;
@@ -68365,7 +68439,7 @@ data: reload
       try {
         const sqlContent = await readFile12(currentSqlFile, "utf-8");
         const datatable = await getDatatableConfig();
-        const fileName = path14.basename(currentSqlFile);
+        const fileName = path15.basename(currentSqlFile);
         ws.send(JSON.stringify({
           type: "sqlMigration",
           fileName,
@@ -68379,7 +68453,7 @@ data: reload
       const sqlFiles = entries.filter((entry) => entry.endsWith(".sql"));
       if (sqlFiles.length > 0 && sqlFileQueue.length === 0) {
         for (const sqlFile of sqlFiles.sort()) {
-          queueSqlFile(path14.join(sqlToApplyPath, sqlFile));
+          queueSqlFile(path15.join(sqlToApplyPath, sqlFile));
         }
         await processNextSqlFile();
       }
@@ -68506,7 +68580,7 @@ data: reload
                 await onSqlFileCompleted(currentSqlFile, true);
               }
               try {
-                await regenerateAgentDocs(workspaceId, process15.cwd(), true);
+                await regenerateAgentDocs(workspaceId, process16.cwd(), true);
                 info(colors.gray(`[SQL Migration] Refreshed AGENTS.md and DATATABLES.md`));
               } catch (regenError) {
                 warn(colors.yellow(`[SQL Migration] Could not refresh docs: ${regenError.message}`));
@@ -68558,7 +68632,7 @@ data: reload
       }
       info(colors.blue(`\uD83D\uDD0D Found ${sqlFiles.length} SQL file(s) in sql_to_apply/`));
       for (const sqlFile of sqlFiles) {
-        const filePath = path14.join(sqlToApplyPath, sqlFile);
+        const filePath = path15.join(sqlToApplyPath, sqlFile);
         queueSqlFile(filePath);
       }
       await processNextSqlFile();
@@ -68576,11 +68650,11 @@ data: reload
       if (!filename)
         return;
       const fileStr = typeof filename === "string" ? filename : filename.toString();
-      const changedPath = path14.join(sqlToApplyPath, fileStr);
+      const changedPath = path15.join(sqlToApplyPath, fileStr);
       if (!changedPath.endsWith(".sql")) {
         return;
       }
-      const fileName = path14.basename(changedPath);
+      const fileName = path15.basename(changedPath);
       if (sqlDebounceTimeouts[changedPath]) {
         clearTimeout(sqlDebounceTimeouts[changedPath]);
       }
@@ -68605,7 +68679,7 @@ data: reload
     const url = `http://${host}:${port}`;
     info(colors.bold.green(`\uD83D\uDE80 Dev server running at ${url}`));
     info(colors.cyan(`\uD83D\uDD0C WebSocket server running at ws://${host}:${port}`));
-    info(colors.gray(`\uD83D\uDCE6 Serving files from: ${process15.cwd()}`));
+    info(colors.gray(`\uD83D\uDCE6 Serving files from: ${process16.cwd()}`));
     info(colors.gray(`\uD83D\uDD04 Live reload enabled
 `));
     if (shouldOpen) {
@@ -68619,7 +68693,7 @@ data: reload
       }
     }
   });
-  process15.on("SIGINT", async () => {
+  process16.on("SIGINT", async () => {
     info(colors.yellow(`
 
 \uD83D\uDED1 Shutting down...`));
@@ -68632,17 +68706,17 @@ data: reload
       sqlWatcher.close();
     }
     await ctx.dispose();
-    process15.exit(0);
+    process16.exit(0);
   });
 }
 async function genRunnablesTs(schemaOverrides = {}) {
   info(colors.blue("\uD83D\uDD04 Generating wmill.d.ts..."));
-  const localPath = process15.cwd();
-  const backendPath = path14.join(localPath, APP_BACKEND_FOLDER);
+  const localPath = process16.cwd();
+  const backendPath = path15.join(localPath, APP_BACKEND_FOLDER);
   let runnables = await loadRunnablesFromBackend(backendPath);
   if (Object.keys(runnables).length === 0) {
     try {
-      const rawApp = await yamlParseFile(path14.join(localPath, "raw_app.yaml"));
+      const rawApp = await yamlParseFile(path15.join(localPath, "raw_app.yaml"));
       runnables = rawApp?.["runnables"] ?? {};
     } catch {
       runnables = {};
@@ -68658,7 +68732,7 @@ async function genRunnablesTs(schemaOverrides = {}) {
   }
   try {
     const newWmillTs = genWmillTs(runnables);
-    writeFileSync4(path14.join(process15.cwd(), "wmill.d.ts"), newWmillTs);
+    writeFileSync5(path15.join(process16.cwd(), "wmill.d.ts"), newWmillTs);
   } catch (error2) {
     error(colors.red(`Failed to generate wmill.d.ts: ${error2.message}`));
   }
@@ -68675,11 +68749,11 @@ function convertRunnablesToApiFormat(runnables) {
 }
 async function loadRunnables() {
   try {
-    const localPath = process15.cwd();
-    const backendPath = path14.join(localPath, APP_BACKEND_FOLDER);
+    const localPath = process16.cwd();
+    const backendPath = path15.join(localPath, APP_BACKEND_FOLDER);
     let runnables = await loadRunnablesFromBackend(backendPath);
     if (Object.keys(runnables).length === 0) {
-      const rawApp = await yamlParseFile(path14.join(localPath, "raw_app.yaml"));
+      const rawApp = await yamlParseFile(path15.join(localPath, "raw_app.yaml"));
       runnables = rawApp?.runnables ?? {};
     }
     convertRunnablesToApiFormat(runnables);
@@ -69160,8 +69234,8 @@ var init_dev = __esm(async () => {
 
 // src/commands/app/lint.ts
 import * as fs11 from "node:fs";
-import * as path15 from "node:path";
-import process16 from "node:process";
+import * as path16 from "node:path";
+import process17 from "node:process";
 function validateRawAppYaml(appData) {
   const errors = [];
   const warnings = [];
@@ -69175,7 +69249,7 @@ function validateRawAppYaml(appData) {
 async function validateRunnables(appDir, appData) {
   const errors = [];
   const warnings = [];
-  const backendPath = path15.join(appDir, APP_BACKEND_FOLDER);
+  const backendPath = path16.join(appDir, APP_BACKEND_FOLDER);
   const runnablesFromBackend = await loadRunnablesFromBackend(backendPath);
   const hasBackendRunnables = Object.keys(runnablesFromBackend).length > 0;
   const hasYamlRunnables = appData.runnables && typeof appData.runnables === "object" && !Array.isArray(appData.runnables) && Object.keys(appData.runnables).length > 0;
@@ -69198,7 +69272,7 @@ async function validateBuild(appDir) {
     info(colors.blue("\uD83D\uDD28 Testing build..."));
     const frameworks = detectFrameworks(appDir);
     const entryFile = frameworks.svelte || frameworks.vue ? "index.ts" : "index.tsx";
-    const entryPoint = path15.join(appDir, entryFile);
+    const entryPoint = path16.join(appDir, entryFile);
     await createBundle({
       entryPoint,
       production: true,
@@ -69213,12 +69287,12 @@ async function validateBuild(appDir) {
 async function lintRawApp(appDir, opts) {
   const errors = [];
   const warnings = [];
-  const currentDirName = path15.basename(appDir);
+  const currentDirName = path16.basename(appDir);
   if (!hasFolderSuffix(currentDirName, "raw_app")) {
     errors.push(`Not a raw app folder: '${currentDirName}' does not end with '${getFolderSuffix("raw_app")}'`);
     return { valid: false, errors, warnings };
   }
-  const rawAppPath = path15.join(appDir, "raw_app.yaml");
+  const rawAppPath = path16.join(appDir, "raw_app.yaml");
   if (!fs11.existsSync(rawAppPath)) {
     errors.push("Missing raw_app.yaml file");
     return { valid: false, errors, warnings };
@@ -69257,7 +69331,7 @@ async function lintRawApp(appDir, opts) {
 }
 async function lint2(opts, appFolder) {
   await loadNonDottedPathsSetting();
-  const targetDir = appFolder ?? process16.cwd();
+  const targetDir = appFolder ?? process17.cwd();
   info(colors.bold.blue(`
 \uD83D\uDD0D Linting raw app: ${targetDir}
 `));
@@ -69278,7 +69352,7 @@ async function lint2(opts, appFolder) {
     info(colors.red(`
 ❌ Lint failed
 `));
-    process16.exit(1);
+    process17.exit(1);
   }
   info(colors.green(`
 ✅ All checks passed
@@ -69302,7 +69376,7 @@ var init_lint2 = __esm(async () => {
 
 // src/commands/app/new.ts
 import { stat as stat9, writeFile as writeFile10, mkdir as mkdir7 } from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 function validateAppPath(appPath) {
   if (!appPath.startsWith("u/") && !appPath.startsWith("f/")) {
     return {
@@ -69507,7 +69581,7 @@ CREATE SCHEMA IF NOT EXISTS ${schemaName};
   }
   await loadNonDottedPathsSetting();
   const folderName2 = buildFolderPath(appPath, "raw_app");
-  const appDir = path16.join(process.cwd(), folderName2);
+  const appDir = path17.join(process.cwd(), folderName2);
   try {
     await stat9(appDir);
     const overwrite = await Confirm.prompt({
@@ -69520,17 +69594,17 @@ CREATE SCHEMA IF NOT EXISTS ${schemaName};
     }
   } catch {}
   await mkdir7(appDir, { recursive: true });
-  await mkdir7(path16.join(appDir, "backend"), { recursive: true });
-  await mkdir7(path16.join(appDir, "sql_to_apply"), { recursive: true });
+  await mkdir7(path17.join(appDir, "backend"), { recursive: true });
+  await mkdir7(path17.join(appDir, "sql_to_apply"), { recursive: true });
   const rawAppConfig = {
     summary
   };
   if (dataConfig.datatable) {
     rawAppConfig.data = dataConfig;
   }
-  await writeFile10(path16.join(appDir, "raw_app.yaml"), import_yaml22.stringify(rawAppConfig, yamlOptions), "utf-8");
+  await writeFile10(path17.join(appDir, "raw_app.yaml"), import_yaml22.stringify(rawAppConfig, yamlOptions), "utf-8");
   for (const [filePath, content] of Object.entries(template.files)) {
-    const fullPath = path16.join(appDir, filePath.slice(1));
+    const fullPath = path17.join(appDir, filePath.slice(1));
     await writeFile10(fullPath, content.trim() + `
 `, "utf-8");
   }
@@ -69540,21 +69614,21 @@ CREATE SCHEMA IF NOT EXISTS ${schemaName};
     schema: dataConfig.schema
   } : undefined;
   const agentsContent = generateAgentsDocumentation(dataForDocs);
-  await writeFile10(path16.join(appDir, "AGENTS.md"), agentsContent, "utf-8");
-  await writeFile10(path16.join(appDir, "CLAUDE.md"), `Instructions are in @AGENTS.md
+  await writeFile10(path17.join(appDir, "AGENTS.md"), agentsContent, "utf-8");
+  await writeFile10(path17.join(appDir, "CLAUDE.md"), `Instructions are in @AGENTS.md
 `, "utf-8");
   const datatablesContent = generateDatatablesDocumentation(dataForDocs);
-  await writeFile10(path16.join(appDir, "DATATABLES.md"), datatablesContent, "utf-8");
+  await writeFile10(path17.join(appDir, "DATATABLES.md"), datatablesContent, "utf-8");
   const exampleRunnable = {
     type: "inline",
     path: undefined
   };
-  await writeFile10(path16.join(appDir, "backend", "a.yaml"), import_yaml22.stringify(exampleRunnable, yamlOptions), "utf-8");
-  await writeFile10(path16.join(appDir, "backend", "a.ts"), `export async function main(x: number): Promise<string> {
+  await writeFile10(path17.join(appDir, "backend", "a.yaml"), import_yaml22.stringify(exampleRunnable, yamlOptions), "utf-8");
+  await writeFile10(path17.join(appDir, "backend", "a.ts"), `export async function main(x: number): Promise<string> {
   return \`Hello from backend! x = \${x}\`;
 }
 `, "utf-8");
-  await writeFile10(path16.join(appDir, "sql_to_apply", "README.md"), `# SQL Migrations Folder
+  await writeFile10(path17.join(appDir, "sql_to_apply", "README.md"), `# SQL Migrations Folder
 
 This folder is for SQL migration files that will be applied to datatables during development.
 
@@ -69582,7 +69656,7 @@ This folder is for SQL migration files that will be applied to datatables during
 - Use idempotent SQL (\`CREATE TABLE IF NOT EXISTS\`, etc.)
 `);
   if (createSchemaSQL && schemaName) {
-    await writeFile10(path16.join(appDir, "sql_to_apply", `000_create_schema_${schemaName}.sql`), createSchemaSQL, "utf-8");
+    await writeFile10(path17.join(appDir, "sql_to_apply", `000_create_schema_${schemaName}.sql`), createSchemaSQL, "utf-8");
   }
   info("");
   info(colors.bold.green(`App created successfully at ${folderName2}/`));
@@ -69883,8 +69957,8 @@ async function pushApp(workspace, remotePath, localPath, message, permissionedAs
   if (!localPath.endsWith(SEP13)) {
     localPath += SEP13;
   }
-  const path17 = localPath + "app.yaml";
-  const localApp = await yamlParseFile(path17);
+  const path18 = localPath + "app.yaml";
+  const localApp = await yamlParseFile(path18);
   replaceInlineScripts2(localApp.value, localPath, true);
   await generatingPolicy2(localApp, remotePath, localApp?.["public"] ?? localApp?.["policy"]?.["execution_mode"] == "anonymous");
   const preserveFields = {};
@@ -69926,13 +70000,13 @@ async function pushApp(workspace, remotePath, localPath, message, permissionedAs
     });
   }
 }
-async function generatingPolicy2(app, path17, publicApp) {
-  info(colors.gray(`Generating fresh policy for app ${path17}...`));
+async function generatingPolicy2(app, path18, publicApp) {
+  info(colors.gray(`Generating fresh policy for app ${path18}...`));
   try {
     app.policy = await updatePolicy(app.value, undefined);
     app.policy.execution_mode = publicApp ? "anonymous" : "publisher";
   } catch (e) {
-    error(colors.red(`Error generating policy for app ${path17}: ${e}`));
+    error(colors.red(`Error generating policy for app ${path18}: ${e}`));
     throw e;
   }
 }
@@ -69961,12 +70035,12 @@ async function list6(opts) {
     new Table2().header(["path", "summary"]).padding(2).border(true).body(total.map((x) => [x.path, x.summary])).render();
   }
 }
-async function get4(opts, path17) {
+async function get4(opts, path18) {
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   const a = await getAppByPath({
     workspace: workspace.workspaceId,
-    path: path17
+    path: path18
   });
   if (opts.json) {
     console.log(JSON.stringify(a));
@@ -70304,11 +70378,11 @@ async function list8(opts) {
     ])).render();
   }
 }
-async function newVariable(opts, path17) {
-  if (!validatePath(path17)) {
+async function newVariable(opts, path18) {
+  if (!validatePath(path18)) {
     return;
   }
-  const filePath = path17 + ".variable.yaml";
+  const filePath = path18 + ".variable.yaml";
   try {
     await stat12(filePath);
     throw new Error("File already exists: " + filePath);
@@ -70328,14 +70402,14 @@ async function newVariable(opts, path17) {
   });
   info(colors.green(`Created ${filePath}`));
 }
-async function get6(opts, path17) {
+async function get6(opts, path18) {
   if (opts.json)
     setSilent(true);
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   const v = await getVariable({
     workspace: workspace.workspaceId,
-    path: path17
+    path: path18
   });
   if (opts.json) {
     console.log(JSON.stringify(v));
@@ -70464,11 +70538,11 @@ async function list9(opts) {
     new Table2().header(["Path", "Schedule"]).padding(2).border(true).body(schedules.map((x) => [x.path, x.schedule])).render();
   }
 }
-async function newSchedule(opts, path17) {
-  if (!validatePath(path17)) {
+async function newSchedule(opts, path18) {
+  if (!validatePath(path18)) {
     return;
   }
-  const filePath = path17 + ".schedule.yaml";
+  const filePath = path18 + ".schedule.yaml";
   try {
     await stat13(filePath);
     throw new Error("File already exists: " + filePath);
@@ -70492,14 +70566,14 @@ async function newSchedule(opts, path17) {
   });
   info(colors.green(`Created ${filePath}`));
 }
-async function get7(opts, path17) {
+async function get7(opts, path18) {
   if (opts.json)
     setSilent(true);
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   const s = await getSchedule({
     workspace: workspace.workspaceId,
-    path: path17
+    path: path18
   });
   if (opts.json) {
     console.log(JSON.stringify(s));
@@ -70512,14 +70586,14 @@ async function get7(opts, path17) {
     console.log(colors.bold("Enabled:") + " " + (s.enabled ? "true" : "false"));
   }
 }
-async function pushSchedule(workspace, path17, schedule, localSchedule, permissionedAsContext) {
-  path17 = removeType(path17, "schedule").replaceAll(SEP16, "/");
-  debug(`Processing local schedule ${path17}`);
+async function pushSchedule(workspace, path18, schedule, localSchedule, permissionedAsContext) {
+  path18 = removeType(path18, "schedule").replaceAll(SEP16, "/");
+  debug(`Processing local schedule ${path18}`);
   try {
-    schedule = await getSchedule({ workspace, path: path17 });
-    debug(`Schedule ${path17} exists on remote`);
+    schedule = await getSchedule({ workspace, path: path18 });
+    debug(`Schedule ${path18} exists on remote`);
   } catch {
-    debug(`Schedule ${path17} does not exist on remote`);
+    debug(`Schedule ${path18} does not exist on remote`);
   }
   delete localSchedule.has_permissioned_as;
   const preserveFields = {};
@@ -70528,31 +70602,31 @@ async function pushSchedule(workspace, path17, schedule, localSchedule, permissi
       preserveFields.preserve_permissioned_as = true;
       if (schedule.permissioned_as) {
         preserveFields.permissioned_as = schedule.permissioned_as;
-        info(`Preserving ${schedule.permissioned_as} as permissioned_as for schedule ${path17}`);
+        info(`Preserving ${schedule.permissioned_as} as permissioned_as for schedule ${path18}`);
       }
     }
   }
   if (schedule) {
     if (isSuperset(localSchedule, schedule)) {
-      debug(`Schedule ${path17} is up to date`);
+      debug(`Schedule ${path18} is up to date`);
       return;
     }
-    debug(`Updating schedule ${path17}`);
+    debug(`Updating schedule ${path18}`);
     try {
-      info(colors.bold.yellow(`Updating schedule ${path17}`));
+      info(colors.bold.yellow(`Updating schedule ${path18}`));
       await updateSchedule({
         workspace,
-        path: path17,
+        path: path18,
         requestBody: {
           ...localSchedule,
           ...preserveFields
         }
       });
       if (localSchedule.enabled != schedule.enabled) {
-        info(colors.bold.yellow(`Schedule ${path17} is ${localSchedule.enabled ? "enabled" : "disabled"} locally but not on remote, updating remote`));
+        info(colors.bold.yellow(`Schedule ${path18} is ${localSchedule.enabled ? "enabled" : "disabled"} locally but not on remote, updating remote`));
         await setScheduleEnabled({
           workspace,
-          path: path17,
+          path: path18,
           requestBody: {
             enabled: localSchedule.enabled
           }
@@ -70563,12 +70637,12 @@ async function pushSchedule(workspace, path17, schedule, localSchedule, permissi
       throw e;
     }
   } else {
-    console.log(colors.bold.yellow("Creating new schedule " + path17));
+    console.log(colors.bold.yellow("Creating new schedule " + path18));
     try {
       await createSchedule({
         workspace,
         requestBody: {
-          path: path17,
+          path: path18,
           ...localSchedule,
           ...preserveFields
         }
@@ -70579,27 +70653,27 @@ async function pushSchedule(workspace, path17, schedule, localSchedule, permissi
     }
   }
 }
-async function enable(opts, path17) {
+async function enable(opts, path18) {
   opts = await mergeConfigWithConfigFile(opts);
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   await setScheduleEnabled({
     workspace: workspace.workspaceId,
-    path: path17,
+    path: path18,
     requestBody: { enabled: true }
   });
-  info(colors.green(`Schedule ${path17} enabled.`));
+  info(colors.green(`Schedule ${path18} enabled.`));
 }
-async function disable(opts, path17) {
+async function disable(opts, path18) {
   opts = await mergeConfigWithConfigFile(opts);
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   await setScheduleEnabled({
     workspace: workspace.workspaceId,
-    path: path17,
+    path: path18,
     requestBody: { enabled: false }
   });
-  info(colors.yellow(`Schedule ${path17} disabled.`));
+  info(colors.yellow(`Schedule ${path18} disabled.`));
 }
 async function push8(opts, filePath, remotePath) {
   const workspace = await resolveWorkspace(opts);
@@ -70703,7 +70777,7 @@ async function decrypt(combinedCiphertext, keyString) {
 var init_local_encryption = () => {};
 
 // src/core/settings.ts
-import process17 from "node:process";
+import process18 from "node:process";
 import { writeFile as writeFile14 } from "node:fs/promises";
 function migrateToGroupedFormat(settings) {
   const result = { name: settings.name ?? "" };
@@ -71012,7 +71086,7 @@ async function readInstanceSettings(opts) {
   return localSettings;
 }
 async function processInstanceSettings(settings, mode) {
-  const encKey = process17.env.WMILL_INSTANCE_LOCAL_ENCRYPTION_KEY;
+  const encKey = process18.env.WMILL_INSTANCE_LOCAL_ENCRYPTION_KEY;
   if (encKey) {
     const res = [];
     for (const s of settings) {
@@ -71186,7 +71260,7 @@ var init_settings = __esm(async () => {
 // src/commands/instance/instance.ts
 import { readFile as readFile13, writeFile as writeFile15, readdir as readdir8, mkdir as mkdir11, rm as rm3, stat as stat14 } from "node:fs/promises";
 import { appendFile } from "node:fs/promises";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 async function allInstances() {
   try {
     const file = await getInstancesConfigFilePath();
@@ -71378,7 +71452,7 @@ async function instancePull(opts) {
     if (confirm) {
       if (uChanges > 0) {
         if (opts.folderPerInstance && opts.prefixSettings) {
-          await mkdir11(path17.join(rootDir, opts.prefix), {
+          await mkdir11(path18.join(rootDir, opts.prefix), {
             recursive: true
           });
         }
@@ -71412,10 +71486,10 @@ Pulling all workspaces`);
       info(`
 Pulling workspace ` + remoteWorkspace.id);
       const workspaceName = opts?.folderPerInstance ? instance.prefix + "/" + remoteWorkspace.id : instance.prefix + "_" + remoteWorkspace.id;
-      await mkdir11(path17.join(rootDir, workspaceName), {
+      await mkdir11(path18.join(rootDir, workspaceName), {
         recursive: true
       });
-      process.chdir(path17.join(rootDir, workspaceName));
+      process.chdir(path18.join(rootDir, workspaceName));
       await addWorkspace({
         remote: instance.remote,
         name: workspaceName,
@@ -71450,7 +71524,7 @@ Pulling workspace ` + remoteWorkspace.id);
       if (confirmDelete) {
         for (const workspace of localWorkspacesToDelete) {
           await removeWorkspace(workspace.id, false, {});
-          await rm3(path17.join(rootDir, workspace.dir), {
+          await rm3(path18.join(rootDir, workspace.dir), {
             recursive: true
           });
         }
@@ -71539,12 +71613,12 @@ Pushing all workspaces: ${localWorkspaces.map((x) => x.id).join(", ")}`);
       info(`
 Pushing workspace ` + localWorkspace.id);
       try {
-        process.chdir(path17.join(rootDir, localWorkspace.dir));
+        process.chdir(path18.join(rootDir, localWorkspace.dir));
       } catch (_) {
         throw new Error("Workspace folder not found, are you in the right directory?");
       }
       try {
-        const workspaceSettings = await yamlParseFile(path17.join(process.cwd(), "settings.yaml"));
+        const workspaceSettings = await yamlParseFile(path18.join(process.cwd(), "settings.yaml"));
         await add({
           token: instance.token,
           workspace: undefined,
@@ -71807,8 +71881,8 @@ async function createToken2(opts) {
   }
   info("Token: " + await createToken({ requestBody: {} }));
 }
-async function pushWorkspaceUser(workspace, path18, user, localUser) {
-  const email = removePathPrefix(removeType(path18, "user"), "users");
+async function pushWorkspaceUser(workspace, path19, user, localUser) {
+  const email = removePathPrefix(removeType(path19, "user"), "users");
   debug(`Processing local user ${email}`);
   if (!["operator", "developer", "admin"].includes(localUser.role)) {
     throw new Error(`Invalid role for user ${email}: ${localUser.role}`);
@@ -71871,8 +71945,8 @@ async function pushWorkspaceUser(workspace, path18, user, localUser) {
     }
   }
 }
-async function pushGroup(workspace, path18, group, localGroup) {
-  const name = removePathPrefix(removeType(path18, "group"), "groups");
+async function pushGroup(workspace, path19, group, localGroup) {
+  const name = removePathPrefix(removeType(path19, "group"), "groups");
   debug(`Processing local group ${name}`);
   try {
     const remoteGroup = await getGroup({
@@ -72123,10 +72197,10 @@ async function push9(opts, filePath) {
   const content = fs12.readFileSync(filePath, "utf8");
   await pushWorkspaceDependencies(workspace.workspaceId, filePath, null, content);
 }
-async function pushWorkspaceDependencies(workspace, path18, _befObj, newDependenciesContent) {
-  const res = workspaceDependenciesPathToLanguageAndFilename(path18);
+async function pushWorkspaceDependencies(workspace, path19, _befObj, newDependenciesContent) {
+  const res = workspaceDependenciesPathToLanguageAndFilename(path19);
   if (!res) {
-    throw new Error(`Unknown workspace dependencies file format: ${path18}. ` + `Valid files: package.json, requirements.in, composer.json, go.mod, modules.json`);
+    throw new Error(`Unknown workspace dependencies file format: ${path19}. ` + `Valid files: package.json, requirements.in, composer.json, go.mod, modules.json`);
   }
   const { language, name } = res;
   const displayName = name ? `named dependencies "${name}"` : `workspace default dependencies`;
@@ -72177,7 +72251,7 @@ var init_dependencies = __esm(async () => {
 import { mkdir as mkdir12, stat as stat15, writeFile as writeFile17 } from "node:fs/promises";
 import { dirname as dirname15 } from "node:path";
 import { sep as SEP17 } from "node:path";
-async function getTrigger(triggerType, workspace, path18) {
+async function getTrigger(triggerType, workspace, path19) {
   const triggerFunctions = {
     http: getHttpTrigger,
     websocket: getWebsocketTrigger,
@@ -72190,10 +72264,10 @@ async function getTrigger(triggerType, workspace, path18) {
     email: getEmailTrigger
   };
   const triggerFunction = triggerFunctions[triggerType];
-  const trigger = await triggerFunction({ workspace, path: path18 });
+  const trigger = await triggerFunction({ workspace, path: path19 });
   return trigger;
 }
-async function updateTrigger(triggerType, workspace, path18, trigger) {
+async function updateTrigger(triggerType, workspace, path19, trigger) {
   const triggerFunctions = {
     http: updateHttpTrigger,
     websocket: updateWebsocketTrigger,
@@ -72206,9 +72280,9 @@ async function updateTrigger(triggerType, workspace, path18, trigger) {
     email: updateEmailTrigger
   };
   const triggerFunction = triggerFunctions[triggerType];
-  await triggerFunction({ workspace, path: path18, requestBody: trigger });
+  await triggerFunction({ workspace, path: path19, requestBody: trigger });
 }
-async function createTrigger(triggerType, workspace, path18, trigger) {
+async function createTrigger(triggerType, workspace, path19, trigger) {
   const triggerFunctions = {
     http: createHttpTrigger,
     websocket: createWebsocketTrigger,
@@ -72221,16 +72295,16 @@ async function createTrigger(triggerType, workspace, path18, trigger) {
     email: createEmailTrigger
   };
   const triggerFunction = triggerFunctions[triggerType];
-  await triggerFunction({ workspace, path: path18, requestBody: trigger });
+  await triggerFunction({ workspace, path: path19, requestBody: trigger });
 }
-async function pushTrigger(triggerType, workspace, path18, trigger, localTrigger, permissionedAsContext) {
-  path18 = removeType(path18, triggerType + "_trigger").replaceAll(SEP17, "/");
-  debug(`Processing local ${triggerType} trigger ${path18}`);
+async function pushTrigger(triggerType, workspace, path19, trigger, localTrigger, permissionedAsContext) {
+  path19 = removeType(path19, triggerType + "_trigger").replaceAll(SEP17, "/");
+  debug(`Processing local ${triggerType} trigger ${path19}`);
   try {
-    trigger = await getTrigger(triggerType, workspace, path18);
-    debug(`${triggerType} trigger ${path18} exists on remote`);
+    trigger = await getTrigger(triggerType, workspace, path19);
+    debug(`${triggerType} trigger ${path19} exists on remote`);
   } catch {
-    debug(`${triggerType} trigger ${path18} does not exist on remote`);
+    debug(`${triggerType} trigger ${path19} does not exist on remote`);
   }
   delete localTrigger.has_permissioned_as;
   const preserveFields = {};
@@ -72239,33 +72313,33 @@ async function pushTrigger(triggerType, workspace, path18, trigger, localTrigger
       preserveFields.preserve_permissioned_as = true;
       if (trigger.permissioned_as) {
         preserveFields.permissioned_as = trigger.permissioned_as;
-        info(`Preserving ${trigger.permissioned_as} as permissioned_as for trigger ${path18}`);
+        info(`Preserving ${trigger.permissioned_as} as permissioned_as for trigger ${path19}`);
       }
     }
   }
   if (trigger) {
     if (isSuperset(localTrigger, trigger)) {
-      debug(`${triggerType} trigger ${path18} is up to date`);
+      debug(`${triggerType} trigger ${path19} is up to date`);
       return;
     }
-    debug(`${triggerType} trigger ${path18} is not up-to-date, updating...`);
+    debug(`${triggerType} trigger ${path19} is not up-to-date, updating...`);
     try {
-      await updateTrigger(triggerType, workspace, path18, {
+      await updateTrigger(triggerType, workspace, path19, {
         ...localTrigger,
         ...preserveFields,
-        path: path18
+        path: path19
       });
     } catch (e) {
       console.error(e.body);
       throw e;
     }
   } else {
-    console.log(colors.bold.yellow(`Creating new ${triggerType} trigger: ${path18}`));
+    console.log(colors.bold.yellow(`Creating new ${triggerType} trigger: ${path19}`));
     try {
-      await createTrigger(triggerType, workspace, path18, {
+      await createTrigger(triggerType, workspace, path19, {
         ...localTrigger,
         ...preserveFields,
-        path: path18
+        path: path19
       });
     } catch (e) {
       console.error(e.body);
@@ -72350,8 +72424,8 @@ async function pushNativeTrigger(workspace, filePath, _remoteTrigger, localTrigg
     }
   }
 }
-async function newTrigger(opts, path18) {
-  if (!validatePath(path18)) {
+async function newTrigger(opts, path19) {
+  if (!validatePath(path19)) {
     return;
   }
   if (!opts.kind) {
@@ -72361,7 +72435,7 @@ async function newTrigger(opts, path18) {
     throw new Error("Invalid trigger kind: " + opts.kind + ". Valid kinds: " + TRIGGER_TYPES.join(", "));
   }
   const kind = opts.kind;
-  const filePath = `${path18}.${kind}_trigger.yaml`;
+  const filePath = `${path19}.${kind}_trigger.yaml`;
   try {
     await stat15(filePath);
     throw new Error("File already exists: " + filePath);
@@ -72397,7 +72471,7 @@ function printTriggerDetails(trigger, kind) {
     console.log(colors.bold(label + ":") + " " + display);
   }
 }
-async function get8(opts, path18) {
+async function get8(opts, path19) {
   if (opts.json)
     setSilent(true);
   const workspace = await resolveWorkspace(opts);
@@ -72406,7 +72480,7 @@ async function get8(opts, path18) {
     if (!checkIfValidTrigger(opts.kind)) {
       throw new Error("Invalid trigger kind: " + opts.kind + ". Valid kinds: " + TRIGGER_TYPES.join(", "));
     }
-    const trigger = await getTrigger(opts.kind, workspace.workspaceId, path18);
+    const trigger = await getTrigger(opts.kind, workspace.workspaceId, path19);
     if (opts.json) {
       console.log(JSON.stringify(trigger));
     } else {
@@ -72417,12 +72491,12 @@ async function get8(opts, path18) {
   const matches = [];
   for (const kind of TRIGGER_TYPES) {
     try {
-      const trigger = await getTrigger(kind, workspace.workspaceId, path18);
+      const trigger = await getTrigger(kind, workspace.workspaceId, path19);
       matches.push({ kind, trigger });
     } catch {}
   }
   if (matches.length === 0) {
-    throw new Error("No trigger found at path: " + path18);
+    throw new Error("No trigger found at path: " + path19);
   }
   if (matches.length === 1) {
     const { kind, trigger } = matches[0];
@@ -72433,7 +72507,7 @@ async function get8(opts, path18) {
     }
     return;
   }
-  console.log("Multiple triggers found at path " + path18 + ":");
+  console.log("Multiple triggers found at path " + path19 + ":");
   for (const m of matches) {
     console.log("  - " + m.kind);
   }
@@ -72650,7 +72724,7 @@ var init_trigger = __esm(async () => {
 });
 
 // src/types.ts
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 import { sep as SEP18 } from "node:path";
 import { readFileSync as readFileSync5 } from "node:fs";
 function isSuperset(subset, superset) {
@@ -72695,8 +72769,8 @@ function showDiff(local, remote) {
   }
   info(finalString);
 }
-function showConflict(path19, local, remote) {
-  info(colors.yellow(`- ${path19}`));
+function showConflict(path20, local, remote) {
+  info(colors.yellow(`- ${path20}`));
   showDiff(local, remote);
   info("\x1B[31mlocal\x1B[31m - \x1B[32mremote\x1B[32m");
   info(`
@@ -72797,7 +72871,10 @@ function getTypeStrFromPath(p) {
   if (p.startsWith("dependencies" + SEP18)) {
     return "workspace_dependencies";
   }
-  const parsed = path18.parse(p);
+  if (isFileResource(p) || isFilesetResource(p)) {
+    return "resource";
+  }
+  const parsed = path19.parse(p);
   if (parsed.ext == ".go" || parsed.ext == ".ts" || parsed.ext == ".sh" || parsed.ext == ".py" || parsed.ext == ".sql" || parsed.ext == ".gql" || parsed.ext == ".ps1" || parsed.ext == ".js" || parsed.ext == ".php" || parsed.ext == ".rs" || parsed.ext == ".cs" || parsed.ext == ".nu" || parsed.ext == ".java" || parsed.ext == ".rb" || parsed.ext == ".r" || parsed.ext == ".yml" && parsed.name.split(".").pop() == "playbook") {
     return "script";
   }
@@ -72817,14 +72894,11 @@ function getTypeStrFromPath(p) {
   if (typeEnding === "script" || typeEnding === "variable" || typeEnding === "resource" || typeEnding === "resource-type" || typeEnding === "app" || typeEnding === "schedule" || typeEnding === "http_trigger" || typeEnding === "websocket_trigger" || typeEnding === "kafka_trigger" || typeEnding === "nats_trigger" || typeEnding === "postgres_trigger" || typeEnding === "mqtt_trigger" || typeEnding === "sqs_trigger" || typeEnding === "gcp_trigger" || typeEnding === "email_trigger" || typeEnding === "user" || typeEnding === "group" || typeEnding === "settings" || typeEnding === "encryption_key") {
     return typeEnding;
   } else {
-    if (isFileResource(p) || isFilesetResource(p)) {
-      return "resource";
-    }
     throw new Error("Could not infer type of path " + JSON.stringify(parsed));
   }
 }
 function removeType(str, type) {
-  const normalizedStr = path18.normalize(str).replaceAll(SEP18, "/");
+  const normalizedStr = path19.normalize(str).replaceAll(SEP18, "/");
   if (normalizedStr.endsWith("." + type + ".yaml") || normalizedStr.endsWith("." + type + ".json")) {
     return normalizedStr.slice(0, normalizedStr.length - type.length - 6);
   }
@@ -72834,7 +72908,7 @@ function removeType(str, type) {
   return normalizedStr;
 }
 function extractNativeTriggerInfo(p) {
-  const normalizedPath = path18.normalize(p).replaceAll(SEP18, "/");
+  const normalizedPath = path19.normalize(p).replaceAll(SEP18, "/");
   const withoutExt = normalizedPath.replace(/\.(json|yaml)$/, "");
   const match2 = withoutExt.match(/^(.+)\.(flow|script)\.([^.]+)\.(\w+)_native_trigger$/);
   if (!match2) {
@@ -72848,8 +72922,8 @@ function extractNativeTriggerInfo(p) {
   };
 }
 function removePathPrefix(str, prefix) {
-  const normalizedStr = path18.normalize(str).replaceAll(SEP18, "/");
-  const normalizedPrefix = path18.normalize(prefix).replaceAll(SEP18, "/");
+  const normalizedStr = path19.normalize(str).replaceAll(SEP18, "/");
+  const normalizedPrefix = path19.normalize(prefix).replaceAll(SEP18, "/");
   if (normalizedStr === normalizedPrefix) {
     return "";
   }
@@ -73021,7 +73095,7 @@ var init_local_path_scripts = __esm(async () => {
 // src/commands/flow/flow.ts
 import { sep as SEP19 } from "node:path";
 import { readFile as readFile15 } from "node:fs/promises";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "node:fs";
 function normalizeOptionalString(value) {
   return typeof value === "string" && value.trim() === "" ? undefined : value ?? undefined;
 }
@@ -73063,12 +73137,12 @@ function warnAboutLocalPathScriptDivergence(divergence) {
   const details = [];
   if (divergence.changed.length > 0) {
     details.push(`These workspace scripts differ from the deployed version:
-${divergence.changed.map((path19) => `- ${path19}`).join(`
+${divergence.changed.map((path20) => `- ${path20}`).join(`
 `)}`);
   }
   if (divergence.missing.length > 0) {
     details.push(`These scripts do not exist in the workspace yet:
-${divergence.missing.map((path19) => `- ${path19}`).join(`
+${divergence.missing.map((path20) => `- ${path20}`).join(`
 `)}`);
   }
   warn(`Using local PathScript files for flow preview.
@@ -73093,7 +73167,7 @@ async function pushFlow(workspace, remotePath, localPath, message, permissionedA
     localPath += SEP19;
   }
   const localFlow = await yamlParseFile(localPath + "flow.yaml");
-  const fileReader = async (path19) => await readFile15(localPath + path19, "utf-8");
+  const fileReader = async (path20) => await readFile15(localPath + path20, "utf-8");
   const missingFiles = [];
   await replaceInlineScripts(localFlow.value.modules, fileReader, exports_log, localPath, SEP19, undefined, missingFiles);
   if (localFlow.value.failure_module) {
@@ -73185,14 +73259,14 @@ async function list12(opts) {
     new Table2().header(["path", "summary", "edited by"]).padding(2).border(true).body(total.map((x) => [x.path, x.summary, x.edited_by])).render();
   }
 }
-async function get9(opts, path19) {
+async function get9(opts, path20) {
   if (opts.json)
     setSilent(true);
   const workspace = await resolveWorkspace(opts);
   await requireLogin(opts);
   const f = await getFlowByPath({
     workspace: workspace.workspaceId,
-    path: path19
+    path: path20
   });
   if (opts.json) {
     console.log(JSON.stringify(f));
@@ -73230,7 +73304,7 @@ async function get9(opts, path19) {
     }
   }
 }
-async function run3(opts, path19) {
+async function run3(opts, path20) {
   if (opts.silent) {
     setSilent(true);
   }
@@ -73241,7 +73315,7 @@ async function run3(opts, path19) {
     try {
       const flow = await getFlowByPath({
         workspace: workspace.workspaceId,
-        path: path19
+        path: path20
       });
       validateRequiredArgs(flow.schema);
     } catch (e) {
@@ -73252,7 +73326,7 @@ async function run3(opts, path19) {
   }
   const id = await runFlowByPath({
     workspace: workspace.workspaceId,
-    path: path19,
+    path: path20,
     requestBody: input
   });
   const stepLabels = new Map;
@@ -73398,7 +73472,7 @@ async function preview2(opts, flowPath) {
     flowPath += SEP19;
   }
   const localFlow = await yamlParseFile(flowPath + "flow.yaml");
-  const fileReader = async (path19) => await readFile15(flowPath + path19, "utf-8");
+  const fileReader = async (path20) => await readFile15(flowPath + path20, "utf-8");
   await replaceInlineScripts(localFlow.value.modules, fileReader, exports_log, flowPath, SEP19);
   if (localFlow.value.failure_module) {
     await replaceInlineScripts([localFlow.value.failure_module], fileReader, exports_log, flowPath, SEP19);
@@ -73513,7 +73587,7 @@ async function bootstrap2(opts, flowPath) {
   const newFlowDefinitionYaml = import_yaml36.stringify(newFlowDefinition);
   const metadataFile = getMetadataFileName("flow", "yaml");
   const flowYamlPath = `${flowDirFullPath}/${metadataFile}`;
-  writeFileSync5(flowYamlPath, newFlowDefinitionYaml, { flag: "wx", encoding: "utf-8" });
+  writeFileSync6(flowYamlPath, newFlowDefinitionYaml, { flag: "wx", encoding: "utf-8" });
 }
 async function history2(opts, flowPath) {
   if (opts.json)
@@ -73746,7 +73820,7 @@ class GitSyncSettingsConverter {
 }
 
 // src/commands/gitsync-settings/legacySettings.ts
-import process18 from "node:process";
+import process19 from "node:process";
 async function handleLegacyRepositoryMigration(selectedRepo, gitSyncSettings, workspace, opts, operationName = "operation") {
   if (selectedRepo.settings) {
     return selectedRepo;
@@ -73756,7 +73830,7 @@ async function handleLegacyRepositoryMigration(selectedRepo, gitSyncSettings, wo
   }
   const workspaceIncludePath = gitSyncSettings.include_path;
   const workspaceIncludeType = gitSyncSettings.include_type;
-  if (!!process18.stdout.isTTY && !opts.yes) {
+  if (!!process19.stdout.isTTY && !opts.yes) {
     console.log(colors.yellow(`
 ⚠️  Legacy git-sync settings detected!`));
     console.log(`
@@ -73862,7 +73936,7 @@ Repository "${selectedRepo.git_repo_resource_path}" has legacy settings format.`
       console.error(`   wmill gitsync-settings push
 `);
     }
-    process18.exit(1);
+    process19.exit(1);
   }
 }
 var init_legacySettings = __esm(async () => {
@@ -73906,8 +73980,8 @@ function outputResult(opts, result) {
     error(colors.red(result.error));
   }
 }
-function normalizeRepoPath(path19) {
-  return path19.replace(/^\$res:/, "");
+function normalizeRepoPath(path20) {
+  return path20.replace(/^\$res:/, "");
 }
 function getOrCreateBranchConfig(config, branchName) {
   if (!config.workspaces) {
@@ -74318,14 +74392,14 @@ var init_pull2 = __esm(async () => {
 });
 
 // src/commands/gitsync-settings/push.ts
-import process19 from "node:process";
+import process20 from "node:process";
 async function pushGitSyncSettings(opts) {
   try {
     await validateBranchConfiguration({ yes: opts.yes });
   } catch (error2) {
     if (error2 instanceof Error && error2.message.includes("overrides")) {
       error(error2.message);
-      process19.exit(1);
+      process20.exit(1);
     }
     throw error2;
   }
@@ -74335,7 +74409,7 @@ async function pushGitSyncSettings(opts) {
     const wmillYamlPath = getWmillYamlPath();
     if (!wmillYamlPath) {
       error(colors.red("No wmill.yaml file found. Please run 'wmill init' first to create the configuration file."));
-      process19.exit(1);
+      process20.exit(1);
     }
     const localConfig = await readConfigFile();
     let settings;
@@ -74451,7 +74525,7 @@ async function pushGitSyncSettings(opts) {
           displayChanges(changes);
         }
       }
-      if (!opts.yes && !!process19.stdin.isTTY) {
+      if (!opts.yes && !!process20.stdin.isTTY) {
         const confirmed = await Confirm.prompt({
           message: `Do you want to apply these changes to the remote?`,
           default: true
@@ -74562,22 +74636,22 @@ var init_gitsync_settings = __esm(async () => {
 async function uploadScripts(tree, workspace) {
   const scriptHashes = {};
   const workspaceDeps = [];
-  for (const path19 of tree.allPaths()) {
-    const content = tree.getContent(path19);
-    const itemType = tree.getItemType(path19);
+  for (const path20 of tree.allPaths()) {
+    const content = tree.getContent(path20);
+    const itemType = tree.getItemType(path20);
     if (itemType === "dependencies") {
       if (content === undefined)
         continue;
-      const info2 = workspaceDependenciesPathToLanguageAndFilename(path19);
+      const info2 = workspaceDependenciesPathToLanguageAndFilename(path20);
       if (info2) {
         const hash2 = await generateHash(content);
-        workspaceDeps.push({ path: path19, language: info2.language, name: info2.name, hash: hash2 });
+        workspaceDeps.push({ path: path20, language: info2.language, name: info2.name, hash: hash2 });
       }
     } else if (itemType === "script") {
       if (!content)
         continue;
       const hash2 = await generateHash(content);
-      scriptHashes[path19] = hash2;
+      scriptHashes[path20] = hash2;
     }
   }
   if (Object.keys(scriptHashes).length === 0 && workspaceDeps.length === 0)
@@ -74589,19 +74663,19 @@ async function uploadScripts(tree, workspace) {
       workspace_deps: workspaceDeps
     }
   });
-  for (const path19 of mismatched) {
-    const content = tree.getContent(path19);
-    const itemType = tree.getItemType(path19);
+  for (const path20 of mismatched) {
+    const content = tree.getContent(path20);
+    const itemType = tree.getItemType(path20);
     if (itemType === "dependencies") {
       if (content !== undefined) {
-        tree.setContentHash(path19, "mismatched");
+        tree.setContentHash(path20, "mismatched");
       }
     } else if (content) {
       const hash2 = await storeRawScriptTemp({
         workspace: workspace.workspaceId,
         requestBody: content
       });
-      tree.setContentHash(path19, hash2);
+      tree.setContentHash(path20, hash2);
     }
   }
 }
@@ -74612,12 +74686,12 @@ class DoubleLinkedDependencyTree {
   setWorkspaceDeps(deps) {
     this.workspaceDeps = deps;
   }
-  async addNode(path19, content, language, metadata, imports, itemType, folder, originalPath, isDirectlyStale, isRawApp) {
+  async addNode(path20, content, language, metadata, imports, itemType, folder, originalPath, isDirectlyStale, isRawApp) {
     const hasWorkspaceDeps = itemType === "script" || itemType === "inline_script";
     const filteredDeps = hasWorkspaceDeps ? filterWorkspaceDependencies(this.workspaceDeps, content, language) : {};
     const stalenessHash = await generateScriptHash({}, content, metadata);
-    if (!this.nodes.has(path19)) {
-      this.nodes.set(path19, {
+    if (!this.nodes.has(path20)) {
+      this.nodes.set(path20, {
         content: "",
         stalenessHash: "",
         language: "deno",
@@ -74630,7 +74704,7 @@ class DoubleLinkedDependencyTree {
         isDirectlyStale: false
       });
     }
-    const node = this.nodes.get(path19);
+    const node = this.nodes.get(path20);
     node.content = content;
     node.stalenessHash = stalenessHash;
     node.language = language;
@@ -74677,59 +74751,59 @@ class DoubleLinkedDependencyTree {
           isDirectlyStale: false
         });
       }
-      this.nodes.get(importPath).importedBy.add(path19);
+      this.nodes.get(importPath).importedBy.add(path20);
     }
   }
-  getContent(path19) {
-    return this.nodes.get(path19)?.content;
+  getContent(path20) {
+    return this.nodes.get(path20)?.content;
   }
-  getStalenessHash(path19) {
-    return this.nodes.get(path19)?.stalenessHash;
+  getStalenessHash(path20) {
+    return this.nodes.get(path20)?.stalenessHash;
   }
-  getContentHash(path19) {
-    return this.nodes.get(path19)?.contentHash;
+  getContentHash(path20) {
+    return this.nodes.get(path20)?.contentHash;
   }
-  setContentHash(path19, hash2) {
-    const node = this.nodes.get(path19);
+  setContentHash(path20, hash2) {
+    const node = this.nodes.get(path20);
     if (node) {
       node.contentHash = hash2;
     }
   }
-  getLanguage(path19) {
-    return this.nodes.get(path19)?.language;
+  getLanguage(path20) {
+    return this.nodes.get(path20)?.language;
   }
-  getMetadata(path19) {
-    return this.nodes.get(path19)?.metadata;
+  getMetadata(path20) {
+    return this.nodes.get(path20)?.metadata;
   }
-  getStaleReason(path19) {
-    return this.nodes.get(path19)?.staleReason;
+  getStaleReason(path20) {
+    return this.nodes.get(path20)?.staleReason;
   }
-  getItemType(path19) {
-    return this.nodes.get(path19)?.itemType;
+  getItemType(path20) {
+    return this.nodes.get(path20)?.itemType;
   }
-  getFolder(path19) {
-    return this.nodes.get(path19)?.folder;
+  getFolder(path20) {
+    return this.nodes.get(path20)?.folder;
   }
-  getIsRawApp(path19) {
-    return this.nodes.get(path19)?.isRawApp;
+  getIsRawApp(path20) {
+    return this.nodes.get(path20)?.isRawApp;
   }
-  getIsDirectlyStale(path19) {
-    return this.nodes.get(path19)?.isDirectlyStale ?? false;
+  getIsDirectlyStale(path20) {
+    return this.nodes.get(path20)?.isDirectlyStale ?? false;
   }
-  getOriginalPath(path19) {
-    return this.nodes.get(path19)?.originalPath;
+  getOriginalPath(path20) {
+    return this.nodes.get(path20)?.originalPath;
   }
-  getImports(path19) {
-    return this.nodes.get(path19)?.imports;
+  getImports(path20) {
+    return this.nodes.get(path20)?.imports;
   }
-  isStale(path19) {
-    return this.nodes.get(path19)?.staleReason !== undefined;
+  isStale(path20) {
+    return this.nodes.get(path20)?.staleReason !== undefined;
   }
   propagateStaleness() {
     const directlyStale = new Set;
-    for (const [path19, node] of this.nodes.entries()) {
+    for (const [path20, node] of this.nodes.entries()) {
       if (node.isDirectlyStale) {
-        directlyStale.add(path19);
+        directlyStale.add(path20);
         node.staleReason = "content changed";
       }
     }
@@ -74781,20 +74855,20 @@ class DoubleLinkedDependencyTree {
     return this.nodes.keys();
   }
   *stalePaths() {
-    for (const [path19, node] of this.nodes.entries()) {
+    for (const [path20, node] of this.nodes.entries()) {
       if (node.staleReason) {
-        yield path19;
+        yield path20;
       }
     }
   }
-  has(path19) {
-    return this.nodes.has(path19);
+  has(path20) {
+    return this.nodes.has(path20);
   }
   getMismatchedWorkspaceDeps() {
     const result2 = {};
-    for (const [path19, node] of this.nodes.entries()) {
+    for (const [path20, node] of this.nodes.entries()) {
       if (node.itemType === "dependencies" && node.contentHash && node.content !== undefined) {
-        result2[path19] = node.content;
+        result2[path20] = node.content;
       }
     }
     return result2;
@@ -74809,11 +74883,11 @@ class DoubleLinkedDependencyTree {
     return result2;
   }
   async persistDepsHashes(depsPaths) {
-    for (const path19 of depsPaths) {
-      const node = this.nodes.get(path19);
+    for (const path20 of depsPaths) {
+      const node = this.nodes.get(path20);
       if (node?.itemType === "dependencies" && node.content !== undefined) {
-        const hash2 = await generateHash(node.content + path19);
-        await updateMetadataGlobalLock(path19, hash2);
+        const hash2 = await generateHash(node.content + path20);
+        await updateMetadataGlobalLock(path20, hash2);
       }
     }
   }
@@ -76262,7 +76336,7 @@ async function dev2(opts) {
   const flowFolderSuffix = getFolderSuffixWithSep("flow");
   const flowMetadataFile = getMetadataFileName("flow", "yaml");
   async function loadPaths(pathsToLoad) {
-    const paths = pathsToLoad.filter((path19) => exts.some((ext2) => path19.endsWith(ext2) || path19.endsWith(flowFolderSuffix + flowMetadataFile)));
+    const paths = pathsToLoad.filter((path20) => exts.some((ext2) => path20.endsWith(ext2) || path20.endsWith(flowFolderSuffix + flowMetadataFile)));
     if (paths.length == 0) {
       return;
     }
@@ -76274,7 +76348,7 @@ async function dev2(opts) {
       if (typ == "flow") {
         const localPath = extractFolderPath(cpath, "flow");
         const localFlow = await yamlParseFile(localPath + "flow.yaml");
-        await replaceInlineScripts(localFlow.value.modules, async (path19) => await readFile16(localPath + path19, "utf-8"), exports_log, localPath, SEP20, undefined);
+        await replaceInlineScripts(localFlow.value.modules, async (path20) => await readFile16(localPath + path20, "utf-8"), exports_log, localPath, SEP20, undefined);
         const localScriptReader = createPreviewLocalScriptReader({
           exts,
           defaultTs: opts.defaultTs,
@@ -81026,6 +81100,53 @@ The OpenFlow schema (openflow.openapi.yaml) is the source of truth for flow stru
 - \`preprocessor\` - Reserved for preprocessor module
 - \`Input\` - Reserved for flow input reference
 
+## Hard Structural Rules
+
+These are strict Windmill schema rules. Follow them exactly.
+
+- \`value.modules\` is only for normal sequential steps
+- \`value.preprocessor_module\` and \`value.failure_module\` are special top-level fields inside \`value\`, not entries in \`value.modules\`
+- If a flow needs a preprocessor, create \`value.preprocessor_module\` with \`id: preprocessor\`
+- If a flow needs a failure handler, create \`value.failure_module\` with \`id: failure\`
+- Do NOT create regular modules inside \`value.modules\` named \`preprocessor\` or \`failure\`
+- \`preprocessor_module\` and \`failure_module\` only support \`script\` or \`rawscript\`
+- \`preprocessor_module\` runs before normal modules and cannot reference \`results.*\`
+- \`failure_module\` can use the \`error\` object with \`error.message\`, \`error.step_id\`, \`error.name\`, and \`error.stack\`
+
+Correct shape:
+
+\`\`\`yaml
+value:
+  preprocessor_module:
+    id: preprocessor
+    value:
+      type: rawscript
+      ...
+  failure_module:
+    id: failure
+    value:
+      type: rawscript
+      ...
+  modules:
+    - id: process_event
+      value:
+        type: rawscript
+        ...
+\`\`\`
+
+Incorrect shape:
+
+\`\`\`yaml
+value:
+  modules:
+    - id: preprocessor
+      ...
+    - id: process_event
+      ...
+    - id: failure
+      ...
+\`\`\`
+
 ## Module ID Rules
 
 - Must be unique across the entire flow
@@ -81041,10 +81162,148 @@ The OpenFlow schema (openflow.openapi.yaml) is the source of truth for flow stru
 ## Data Flow Between Steps
 
 - \`flow_input.property\` - Access flow input parameters
-- \`results.step_id\` - Access output from a previous step
-- \`results.step_id.property\` - Access specific property from previous step output
-- \`flow_input.iter.value\` - Current item when inside a for-loop
-- \`flow_input.iter.index\` - Current index when inside a for-loop
+- \`results.step_id\` - Access output from a previous step only when that step result is in scope
+- \`results.step_id.property\` - Access specific property from a previous step output only when that step result is in scope
+- \`flow_input.iter.value\` - Current iteration value when inside a loop (\`forloopflow\` or \`whileloopflow\`)
+- \`flow_input.iter.index\` - Current loop index when inside a loop (\`forloopflow\` or \`whileloopflow\`)
+
+## Loop Structure Rules
+
+- For \`whileloopflow\`, use module-level \`stop_after_if\` on the loop module itself when the loop should stop after an iteration result
+- Do NOT put \`stop_after_if\` inside \`value\` of a \`whileloopflow\`
+- \`stop_after_all_iters_if\` is for checks after the whole loop finishes, not the normal per-iteration break condition
+- When a \`whileloopflow\` carries state forward between iterations, use \`flow_input.iter.value\` as the current loop value and provide an explicit first-iteration fallback when needed
+- Use \`flow_input.iter.index\` only when the loop logic is truly based on the iteration index, not as a replacement for the current loop value
+- If the user asks for a final scalar/object after a loop, add a normal step after the loop that extracts the final value from the loop result instead of returning the whole loop result array
+
+Correct \`whileloopflow\` shape:
+
+\`\`\`yaml
+- id: loop_until_done
+  stop_after_if:
+    expr: result.done === true
+    skip_if_stopped: false
+  value:
+    type: whileloopflow
+    skip_failures: false
+    modules:
+      - id: advance_state
+        value:
+          type: rawscript
+          input_transforms:
+            state:
+              type: javascript
+              expr: flow_input.iter && flow_input.iter.value !== undefined ? flow_input.iter.value : flow_input.initial_state
+- id: return_final_state
+  value:
+    type: rawscript
+    input_transforms:
+      final_state:
+        type: javascript
+        expr: results.loop_until_done[results.loop_until_done.length - 1]
+\`\`\`
+
+Incorrect \`whileloopflow\` patterns:
+
+\`\`\`yaml
+- id: loop_until_done
+  value:
+    type: whileloopflow
+    stop_after_if:
+      expr: result.done === true
+\`\`\`
+
+\`\`\`yaml
+input_transforms:
+  state:
+    type: javascript
+    expr: flow_input.iter.index
+\`\`\`
+
+\`\`\`yaml
+input_transforms:
+  final_state:
+    type: javascript
+    expr: results.loop_until_done
+\`\`\`
+
+## Approval / Suspend Structure
+
+- \`suspend\` belongs on the flow module object itself, as a sibling of \`id\` and \`value\`
+- Never put \`suspend\` inside \`value\`
+
+Correct shape:
+
+\`\`\`yaml
+- id: request_approval
+  suspend:
+    required_events: 1
+    resume_form:
+      schema:
+        type: object
+        properties:
+          comment:
+            type: string
+        required: [comment]
+  value:
+    type: identity
+\`\`\`
+
+Incorrect shape:
+
+\`\`\`yaml
+- id: request_approval
+  value:
+    type: rawscript
+    suspend:
+      required_events: 1
+\`\`\`
+
+## Branch Result Scope Rules
+
+- Inside a branch, you may reference earlier outer steps and earlier steps in the same branch
+- Outside a \`branchone\`, do NOT reference ids of steps that only exist inside its branches or default branch. Use \`results.<branchone_module_id>\` instead
+- Outside a \`branchall\`, do NOT reference ids of steps inside its branches. Use \`results.<branchall_module_id>\` instead
+- If downstream steps need a stable shape after a branch, make each branch return the same fields
+- When needed, add a normalization step immediately after the branch and consume \`results.<branch_module_id>\` there
+
+Correct after \`branchone\`:
+
+\`\`\`yaml
+- id: route_order
+  value:
+    type: branchone
+    ...
+- id: send_confirmation
+  value:
+    input_transforms:
+      routed:
+        type: javascript
+        expr: results.route_order
+\`\`\`
+
+Incorrect after \`branchone\`:
+
+\`\`\`yaml
+expr: results.create_shipment
+expr: results.create_backorder
+\`\`\`
+
+Correct after \`branchall\`:
+
+\`\`\`yaml
+- id: enrich_parallel
+  value:
+    type: branchall
+    parallel: true
+    ...
+- id: combine_data
+  value:
+    input_transforms:
+      enrichments:
+        type: javascript
+        expr: results.enrich_parallel
+\`\`\`
 
 ## Input Transforms
 
@@ -81061,14 +81320,14 @@ JavaScript transform (dynamic expression):
 - For flow inputs: Use type \`"object"\` with format \`"resource-{type}"\` (e.g., \`"resource-postgresql"\`)
 - For step inputs: Use static value \`"$res:path/to/resource"\`
 
-## Failure Handler
+## Final Structural Self-Check
 
-Executes when any step fails. Has access to error details:
+Before finalizing a flow, verify:
 
-- \`error.message\` - Error message
-- \`error.step_id\` - ID of failed step
-- \`error.name\` - Error name
-- \`error.stack\` - Stack trace
+- any preprocessor is in \`value.preprocessor_module\`
+- any failure handler is in \`value.failure_module\`
+- any approval step has module-level \`suspend\`
+- no downstream step references inner branch step ids from outside the branch
 
 ## S3 Object Operations
 
@@ -85031,8 +85290,8 @@ async function generateMetadata2(opts, folder) {
   info("");
   if (errors.length > 0) {
     info(`Done. Updated ${colors.bold(String(succeeded))}/${total} item(s). ${colors.red(String(errors.length) + " failed")}:`);
-    for (const { path: path19, error: error2 } of errors) {
-      error(`  ${path19}: ${error2}`);
+    for (const { path: path20, error: error2 } of errors) {
+      error(`  ${path20}: ${error2}`);
     }
     process.exitCode = 1;
   } else {
@@ -85186,7 +85445,7 @@ var config_default = command35;
 
 // src/main.ts
 await init_context();
-var VERSION = "1.684.1";
+var VERSION = "1.686.0";
 async function checkVersionSafe(cmd) {
   const mainCommand = cmd.getMainCommand();
   const upgradeCommand = mainCommand.getCommand("upgrade");