windmill-cli 1.685.0 → 1.687.0

package/esm/main.js

@@ -11812,7 +11812,7 @@ var init_OpenAPI = __esm(() => {
     PASSWORD: undefined,
     TOKEN: getEnv2("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: "1.685.0",
+    VERSION: "1.687.0",
     WITH_CREDENTIALS: true,
     interceptors: {
       request: new Interceptors,
@@ -12335,6 +12335,7 @@ __export(exports_services_gen, {
   listGoogleDriveFiles: () => listGoogleDriveFiles,
   listGoogleCalendars: () => listGoogleCalendars,
   listGlobalSettings: () => listGlobalSettings,
+  listGithubRepos: () => listGithubRepos,
   listGitRepoFiles: () => listGitRepoFiles,
   listGcpTriggers: () => listGcpTriggers,
   listFolders: () => listFolders,
@@ -12379,6 +12380,7 @@ __export(exports_services_gen, {
   leaveInstance: () => leaveInstance,
   isValidPostgresConfiguration: () => isValidPostgresConfiguration,
   isSmtpConfigured: () => isSmtpConfigured,
+  isPasswordLoginDisabled: () => isPasswordLoginDisabled,
   isOwnerOfPath: () => isOwnerOfPath,
   isDomainAllowed: () => isDomainAllowed,
   isDefaultTagsPerWorkspace: () => isDefaultTagsPerWorkspace,
@@ -12867,6 +12869,11 @@ var backendVersion = () => {
     method: "GET",
     url: "/auth/is_smtp_configured"
   });
+}, isPasswordLoginDisabled = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/auth/is_password_login_disabled"
+  });
 }, requestPasswordReset = (data2) => {
   return request(OpenAPI, {
     method: "POST",
@@ -18125,6 +18132,14 @@ var backendVersion = () => {
       workspace: data2.workspace
     }
   });
+}, listGithubRepos = (data2) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/w/{workspace}/native_triggers/github/repos",
+    path: {
+      workspace: data2.workspace
+    }
+  });
 }, nativeTriggerWebhook = (data2) => {
   return request(OpenAPI, {
     method: "POST",
@@ -26760,6 +26775,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 +26881,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 +26969,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 +27004,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 +27019,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 +27042,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 +27154,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 +27196,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 +27213,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 +27366,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 +27553,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 +27995,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 +32822,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 +32851,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 +32892,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 +32913,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 +32926,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 +32973,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 +34695,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 +34753,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 +37486,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 +42937,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 +49450,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 +49641,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 +53075,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 +56385,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 +56405,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 +56415,7 @@ var require_buildJsonPath = __commonJS((exports) => {
       prevNode = node;
       node = node.parent;
     }
-    return path6;
+    return path7;
   }
   exports.buildJsonPath = buildJsonPath;
 });
@@ -56393,10 +56474,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 +56598,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 +56650,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 +60592,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 +60718,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 +60801,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 +60946,7 @@ function getWorkspaceSpecificPath(basePath, specificItems, workspaceNameOverride
   }
   return;
 }
-function isCurrentWorkspaceFile(path6, workspaceNameOverride) {
+function isCurrentWorkspaceFile(path7, workspaceNameOverride) {
   let currentWorkspace = null;
   if (workspaceNameOverride) {
     currentWorkspace = workspaceNameOverride;
@@ -60882,11 +60963,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 +61041,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 +61090,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 +61112,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 +61171,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 +61194,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 +61208,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 +61231,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 +61322,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 +61332,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 +61457,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 +61514,7 @@ async function resolve6(input) {
     throw e;
   }
 }
-async function run2(opts, path7) {
+async function run2(opts, path8) {
   if (opts.silent) {
     setSilent(true);
   }
@@ -61444,7 +61525,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 +61538,7 @@ async function run2(opts, path7) {
   try {
     id = await runScriptByPath({
       workspace: workspace.workspaceId,
-      path: path7,
+      path: path8,
       requestBody: input
     });
   } catch (e) {
@@ -61465,10 +61546,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 +61558,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 +61674,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 +61687,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 +61744,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 +61827,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 +61837,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 +62085,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 +62145,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 +62235,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 +62253,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 +62300,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 +62319,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 +62344,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 +62365,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 +62389,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 +62414,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 +62439,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 +62456,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 +62468,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 +62575,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 +62588,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 +62900,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 +62924,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 +63090,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 +63180,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 +63379,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))) {
@@ -63342,7 +63423,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);
@@ -63377,29 +63458,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);
@@ -63435,8 +63516,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`));
@@ -63444,7 +63525,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) => {
@@ -63560,7 +63641,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);
@@ -63618,8 +63699,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) {
@@ -63635,7 +63716,7 @@ function findCodebase(path10, codebases) {
       if (included) {
         break;
       }
-      if (minimatch(path10, r)) {
+      if (minimatch(path11, r)) {
         included = true;
       }
     }
@@ -63643,7 +63724,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;
       }
     }
@@ -63652,13 +63733,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 {
@@ -63672,9 +63753,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") {
@@ -63686,7 +63767,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`);
       }
     }
   }
@@ -63703,7 +63784,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}`);
@@ -63874,7 +63955,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);
@@ -63982,9 +64063,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;
         }
       }
@@ -64020,7 +64101,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;
@@ -64033,7 +64114,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);
@@ -64057,7 +64138,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;
@@ -64070,7 +64151,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);
@@ -64125,7 +64206,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") {
@@ -64142,7 +64223,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;
@@ -64178,7 +64259,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);
@@ -64192,7 +64273,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);
@@ -64200,7 +64281,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);
@@ -64303,12 +64384,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;
@@ -64323,7 +64404,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;
@@ -64333,7 +64414,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;
@@ -64370,7 +64451,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;
@@ -64406,7 +64487,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);
@@ -64475,15 +64556,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",
@@ -64505,39 +64586,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")
@@ -64551,27 +64632,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;
           }
         }
@@ -64579,12 +64660,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;
       }
@@ -64593,14 +64674,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) {
@@ -64980,7 +65061,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);
@@ -65005,7 +65086,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) {
@@ -65049,8 +65130,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 {
@@ -65083,13 +65164,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");
@@ -65294,7 +65375,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);
@@ -65408,7 +65489,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) {
@@ -65530,7 +65611,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;
       }
@@ -65581,7 +65662,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;
@@ -65606,7 +65687,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)) {
@@ -65663,7 +65744,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);
@@ -66256,8 +66337,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);
@@ -66299,8 +66380,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 {
@@ -66354,8 +66435,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 = {};
@@ -66411,7 +66492,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 = "";
@@ -66442,10 +66523,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 {
@@ -66475,8 +66556,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;
@@ -66630,7 +66711,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);
@@ -66654,12 +66735,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);
             }
@@ -66671,7 +66752,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");
@@ -66774,7 +66855,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,
@@ -66946,15 +67027,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();
   }
@@ -66963,10 +67044,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;
   }
@@ -66979,7 +67060,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()) {
@@ -66999,14 +67080,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) {
@@ -67019,24 +67100,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");
@@ -67086,7 +67167,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) {
@@ -67099,7 +67180,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;
@@ -67136,7 +67217,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);
@@ -67144,7 +67225,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,
@@ -67175,7 +67256,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",
@@ -67203,7 +67284,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) {
@@ -67254,7 +67335,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) {
@@ -67330,13 +67411,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;
   }
 }
@@ -67373,11 +67454,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);
@@ -67412,7 +67493,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, "/");
@@ -67424,7 +67505,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;
@@ -67490,7 +67571,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) {
@@ -67563,7 +67644,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 {}
@@ -67588,7 +67669,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)) {
@@ -67606,8 +67687,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);
@@ -67655,8 +67736,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);
@@ -67727,7 +67808,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;
   }
@@ -67736,13 +67817,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`));
@@ -67759,7 +67840,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");
@@ -67869,8 +67950,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;
@@ -67969,7 +68050,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}`));
@@ -67996,11 +68077,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;
@@ -68018,24 +68099,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);
@@ -68062,40 +68143,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";
@@ -68105,18 +68186,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);
   }
@@ -68179,7 +68260,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}
@@ -68191,8 +68272,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;
@@ -68205,7 +68286,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)}`));
@@ -68243,7 +68324,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));
@@ -68254,7 +68335,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));
@@ -68265,7 +68346,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));
@@ -68276,7 +68357,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));
@@ -68290,12 +68371,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;
@@ -68332,12 +68413,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()) {
@@ -68359,9 +68440,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;
@@ -68373,7 +68454,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,
@@ -68387,7 +68468,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();
       }
@@ -68514,7 +68595,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}`));
@@ -68566,7 +68647,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();
@@ -68584,11 +68665,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]);
       }
@@ -68613,7 +68694,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) {
@@ -68627,7 +68708,7 @@ data: reload
       }
     }
   });
-  process15.on("SIGINT", async () => {
+  process16.on("SIGINT", async () => {
     info(colors.yellow(`
 
 \uD83D\uDED1 Shutting down...`));
@@ -68640,17 +68721,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 = {};
@@ -68666,7 +68747,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}`));
   }
@@ -68683,11 +68764,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);
@@ -69168,8 +69249,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 = [];
@@ -69183,7 +69264,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;
@@ -69206,7 +69287,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,
@@ -69221,12 +69302,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 };
@@ -69265,7 +69346,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}
 `));
@@ -69286,7 +69367,7 @@ async function lint2(opts, appFolder) {
     info(colors.red(`
 ❌ Lint failed
 `));
-    process16.exit(1);
+    process17.exit(1);
   }
   info(colors.green(`
 ✅ All checks passed
@@ -69310,7 +69391,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 {
@@ -69515,7 +69596,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({
@@ -69528,17 +69609,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");
   }
@@ -69548,21 +69629,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.
 
@@ -69590,7 +69671,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}/`));
@@ -69891,8 +69972,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 = {};
@@ -69934,13 +70015,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;
   }
 }
@@ -69969,12 +70050,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));
@@ -70312,11 +70393,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);
@@ -70336,14 +70417,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));
@@ -70472,11 +70553,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);
@@ -70500,14 +70581,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));
@@ -70520,14 +70601,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 = {};
@@ -70536,31 +70617,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
           }
@@ -70571,12 +70652,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
         }
@@ -70587,27 +70668,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);
@@ -70711,7 +70792,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 ?? "" };
@@ -71020,7 +71101,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) {
@@ -71194,7 +71275,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();
@@ -71386,7 +71467,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
           });
         }
@@ -71420,10 +71501,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,
@@ -71458,7 +71539,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
           });
         }
@@ -71547,12 +71628,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,
@@ -71815,8 +71896,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}`);
@@ -71879,8 +71960,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({
@@ -72131,10 +72212,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`;
@@ -72185,7 +72266,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,
@@ -72198,10 +72279,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,
@@ -72214,9 +72295,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,
@@ -72229,16 +72310,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 = {};
@@ -72247,33 +72328,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);
@@ -72358,8 +72439,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) {
@@ -72369,7 +72450,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);
@@ -72405,7 +72486,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);
@@ -72414,7 +72495,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 {
@@ -72425,12 +72506,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];
@@ -72441,7 +72522,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);
   }
@@ -72658,7 +72739,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) {
@@ -72703,8 +72784,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(`
@@ -72808,7 +72889,7 @@ function getTypeStrFromPath(p) {
   if (isFileResource(p) || isFilesetResource(p)) {
     return "resource";
   }
-  const parsed = path18.parse(p);
+  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";
   }
@@ -72832,7 +72913,7 @@ function getTypeStrFromPath(p) {
   }
 }
 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);
   }
@@ -72842,7 +72923,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) {
@@ -72856,8 +72937,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 "";
   }
@@ -73029,7 +73110,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;
 }
@@ -73071,12 +73152,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.
@@ -73101,7 +73182,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) {
@@ -73193,14 +73274,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));
@@ -73238,7 +73319,7 @@ async function get9(opts, path19) {
     }
   }
 }
-async function run3(opts, path19) {
+async function run3(opts, path20) {
   if (opts.silent) {
     setSilent(true);
   }
@@ -73249,7 +73330,7 @@ async function run3(opts, path19) {
     try {
       const flow = await getFlowByPath({
         workspace: workspace.workspaceId,
-        path: path19
+        path: path20
       });
       validateRequiredArgs(flow.schema);
     } catch (e) {
@@ -73260,7 +73341,7 @@ async function run3(opts, path19) {
   }
   const id = await runFlowByPath({
     workspace: workspace.workspaceId,
-    path: path19,
+    path: path20,
     requestBody: input
   });
   const stepLabels = new Map;
@@ -73406,7 +73487,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);
@@ -73521,7 +73602,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)
@@ -73754,7 +73835,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;
@@ -73764,7 +73845,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(`
@@ -73870,7 +73951,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 () => {
@@ -73914,8 +73995,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) {
@@ -74326,14 +74407,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;
   }
@@ -74343,7 +74424,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;
@@ -74459,7 +74540,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
@@ -74570,22 +74651,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)
@@ -74597,19 +74678,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);
     }
   }
 }
@@ -74620,12 +74701,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",
@@ -74638,7 +74719,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;
@@ -74685,59 +74766,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";
       }
     }
@@ -74789,20 +74870,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;
@@ -74817,11 +74898,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);
       }
     }
   }
@@ -76270,7 +76351,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;
     }
@@ -76282,7 +76363,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,
@@ -85224,8 +85305,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 {
@@ -85379,7 +85460,7 @@ var config_default = command35;
 
 // src/main.ts
 await init_context();
-var VERSION = "1.685.0";
+var VERSION = "1.687.0";
 async function checkVersionSafe(cmd) {
   const mainCommand = cmd.getMainCommand();
   const upgradeCommand = mainCommand.getCommand("upgrade");