@uipath/function-tool 1.202.0-preview.156 → 1.202.0-preview.157

package/dist/{packager-tool-3hvc4zcd.js → packager-tool-sdc3wrcd.js}

@@ -1,40 +1,44 @@
 // ../../node_modules/@uipath/coded-functions-js-cli/dist/cliRunner.js
 import { createRequire } from "node:module";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as dirname5, join as join21 } from "node:path";
-import { readFileSync as readFileSync15 } from "node:fs";
+import { dirname as dirname6, join as join22 } from "node:path";
+import { readFileSync as readFileSync17 } from "node:fs";
 import { execSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join3, resolve } from "node:path";
+import { existsSync as existsSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join4, resolve } from "node:path";
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join2 } from "node:path";
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename, join as join8, resolve as resolve3 } from "node:path";
+import { copyFileSync, existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename, extname, isAbsolute, join as join3 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync8 } from "node:fs";
+import { basename as basename3, join as join9, resolve as resolve3 } from "node:path";
 import { spawn } from "node:child_process";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "node:fs";
-import { extname, join as join4 } from "node:path";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3 } from "node:fs";
+import { extname as extname2, join as join5 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { join as join6 } from "node:path";
 import ts2 from "typescript";
 import { dirname, resolve as resolve2 } from "node:path";
 import ts from "typescript";
-import { copyFileSync, existsSync as existsSync4, lstatSync, mkdirSync as mkdirSync4, readFileSync as readFileSync3, readdirSync, symlinkSync, writeFileSync as writeFileSync5, cpSync } from "node:fs";
+import { basename as basename2, dirname as dirname2 } from "node:path";
+import ts3 from "typescript";
+import { existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync4, readFileSync as readFileSync4, readdirSync, symlinkSync, writeFileSync as writeFileSync6, cpSync } from "node:fs";
+import { spawnSync as spawnSync2 } from "node:child_process";
 import { createRequire as createRequire2 } from "node:module";
-import { join as join6 } from "node:path";
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { join as join7 } from "node:path";
+import { pathToFileURL } from "node:url";
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { extname as extname2, join as join7 } from "node:path";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, readdirSync as readdirSync3, rmSync, statSync, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join12, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { extname as extname3, join as join8 } from "node:path";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync9, readdirSync as readdirSync3, rmSync, statSync, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join13, resolve as resolve5 } from "node:path";
 import { randomUUID } from "node:crypto";
 import { createRequire as createRequire3 } from "module";
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import * as fs6 from "node:fs/promises";
 import * as os2 from "node:os";
 import * as path2 from "node:path";
@@ -67,35 +71,33 @@ import { execFile as execFile4, execFileSync } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
 import { execFile as execFile5 } from "node:child_process";
 import process7 from "node:process";
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
-import { join as join11 } from "node:path";
-import ts3 from "typescript";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
+import { join as join12 } from "node:path";
 import { createRequire as createRequire4 } from "node:module";
 import { register } from "node:module";
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join10 } from "node:path";
-import { pathToFileURL } from "node:url";
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join11 } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync2 } from "node:fs";
 import { emitKeypressEvents } from "node:readline";
-import { join as join13, resolve as resolve6 } from "node:path";
-import { existsSync as existsSync13, readFileSync as readFileSync12, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join16, resolve as resolve7 } from "node:path";
+import { join as join14, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join17, resolve as resolve7 } from "node:path";
 import { createHash } from "node:crypto";
-import { existsSync as existsSync12, readFileSync as readFileSync11, readdirSync as readdirSync5, statSync as statSync3 } from "node:fs";
-import { join as join15, relative as relative2 } from "node:path";
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname3, join as join14 } from "node:path";
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, renameSync, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join18, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync12, readdirSync as readdirSync5, statSync as statSync3 } from "node:fs";
+import { join as join16, relative as relative2 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname4, join as join15 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync15, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync14 } from "node:fs";
+import { join as join19, resolve as resolve9 } from "node:path";
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync12 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join17, relative as relative3, resolve as resolve8 } from "node:path";
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join19, resolve as resolve10 } from "node:path";
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync14, writeFileSync as writeFileSync13 } from "node:fs";
+import { isAbsolute as isAbsolute3, join as join18, relative as relative3, resolve as resolve8 } from "node:path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync15 } from "node:fs";
+import { join as join20, resolve as resolve10 } from "node:path";
 import { resolve as resolve11 } from "node:path";
-import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync14, readdirSync as readdirSync6, writeFileSync as writeFileSync15 } from "node:fs";
-import { dirname as dirname4, join as join20, resolve as resolve12 } from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync10, readFileSync as readFileSync16, readdirSync as readdirSync6, writeFileSync as writeFileSync16 } from "node:fs";
+import { dirname as dirname5, join as join21, resolve as resolve12 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -1971,7 +1973,8 @@ var {
   Option,
   Help
 } = import__.default;
-var CACHE_FILE = join(homedir(), ".uipcli", "functions-cache.json");
+var CACHE_DIR = join(homedir(), ".uipath");
+var CACHE_FILE = join(CACHE_DIR, "functions-runtime-cache.json");
 function registerSetupCommand(program2) {
   program2.command("setup", { hidden: true }).description("Verify and cache Node.js (and optionally Deno) for JS Functions development.").option("--runtime <runtime>", "Runtime to set up: node, deno, or both", "node").action((opts) => {
     const runtimes = opts.runtime === "both" ? ["node", "deno"] : [opts.runtime];
@@ -2013,13 +2016,6 @@ function setupNode(cache) {
     }).trim();
     cache.node = { path: path3, version };
     console.log(`Node.js ${version} ✓`);
-    try {
-      execSync("npx --yes tsx --version", { encoding: "utf-8", stdio: "pipe" });
-      console.log("tsx ✓");
-    } catch {
-      console.log("tsx not found — installing globally...");
-      execSync("npm install -g tsx", { stdio: "inherit" });
-    }
   } catch {
     console.error("Node.js not found. Install from https://nodejs.org (v20+).");
     process.exit(1);
@@ -2050,103 +2046,25 @@ function readCache() {
   return {};
 }
 function writeCache(cache) {
-  mkdirSync(join(homedir(), ".uipcli"), { recursive: true });
+  mkdirSync(CACHE_DIR, { recursive: true });
   writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
 }
-var SERVER_RUNNER_DIR = ".uipath/server-runner";
-var DESIGN_TIME_ENV = "DESIGN_TIME";
-var SDK_VERSION = "^0.6.0";
-var RUNTIME_VERSION = "^0.8.0";
-var HONO_NODE_VERSION = "^1.0.0";
-var TSX_VERSION = "^4.0.0";
-var COREIPC_VERSION = "2.5.1-20260324-07";
-var SIGNALR_VERSION = "8.0.7";
-var TRACE_MAPPING_VERSION = "0.3.25";
-var NPM_RC = `@uipath:registry=https://npm.pkg.github.com
-//npm.pkg.github.com/:_authToken=\${GITHUB_TOKEN}`;
-function scaffoldProject(opts) {
-  const { projectDir, name, lang, functions } = opts;
-  mkdirSync2(projectDir, { recursive: true });
-  mkdirSync2(join2(projectDir, "functions"), { recursive: true });
-  writeFileSync2(join2(projectDir, "uipath.json"), JSON.stringify({
-    $schema: "https://cloud.uipath.com/draft/2024-12/uipath",
-    packOptions: {
-      fileExtensionsIncluded: [],
-      filesIncluded: [],
-      filesExcluded: [],
-      directoriesExcluded: [],
-      includeLockFile: true
-    },
-    functions
-  }, null, 2) + `
-`, "utf-8");
-  writeFileSync2(join2(projectDir, "package.json"), JSON.stringify({
-    name,
-    version: "1.0.0",
-    type: "module",
-    devDependencies: {
-      "@uipath/coded-functions-js-sdk": SDK_VERSION,
-      ...lang === "ts" ? { typescript: "^5.7.0" } : {}
-    }
-  }, null, 2) + `
-`, "utf-8");
-  if (lang === "ts") {
-    writeFileSync2(join2(projectDir, "tsconfig.json"), JSON.stringify({
-      compilerOptions: {
-        target: "ESNext",
-        module: "ESNext",
-        moduleResolution: "bundler",
-        strict: true,
-        allowImportingTsExtensions: true,
-        noEmit: true
-      },
-      include: ["**/*.ts"],
-      exclude: ["node_modules", "dist"]
-    }, null, 2) + `
-`, "utf-8");
-  }
-  writeFileSync2(join2(projectDir, ".env.example"), [
-    "UIPATH_URL=",
-    "UIPATH_ORGANIZATION_NAME=",
-    "UIPATH_TENANT_NAME=",
-    "UIPATH_ACCESS_TOKEN=",
-    "",
-    "# push: Studio Web project ID (create the project in Studio Web to get this)",
-    "UIPATH_PROJECT_ID="
-  ].join(`
-`) + `
-`, "utf-8");
-  writeFileSync2(join2(projectDir, ".gitignore"), `node_modules/
-dist/
-.env
-*.nupkg
-.uipath/
-`, "utf-8");
-}
-var bunAvailableCache;
-function hasBun() {
-  if (bunAvailableCache !== undefined)
-    return bunAvailableCache;
-  const result = spawnSync("bun", ["--version"], {
-    stdio: "ignore",
-    shell: process.platform === "win32"
-  });
-  bunAvailableCache = result.status === 0;
-  return bunAvailableCache;
-}
-function getInstallCommand(onlyProd, extraArgs = []) {
-  if (hasBun()) {
-    if (onlyProd) {
-      return { cmd: "bun", args: ["install", "--production", ...extraArgs] };
-    }
-    return { cmd: "bun", args: ["install", ...extraArgs] };
-  }
-  if (onlyProd) {
-    return { cmd: "npm", args: ["install", "--omit=dev", ...extraArgs] };
-  }
-  return { cmd: "npm", args: ["install", ...extraArgs] };
-}
-var HELLO_TS = `import { defineFunction, defineSchema } from "@uipath/coded-functions-js-sdk";
+var SDK_VERSION = "0.6.2";
+var SDK_RANGE = `^${SDK_VERSION}`;
+var SDK_PACKAGE_NAME = "@uipath/coded-functions-js-sdk";
+var TYPESCRIPT_RANGE = "^5.7.0";
+var SAMPLE_FUNCTION = {
+  name: "hello",
+  description: "Returns a greeting message.",
+  method: "POST",
+  path: "/hello",
+  entryExport: "default"
+};
+var httpSemantics = `  method: "${SAMPLE_FUNCTION.method}",
+  path: "${SAMPLE_FUNCTION.path}",
+`;
+var semanticsFor = (variant) => variant === "http" ? httpSemantics : "";
+var buildHelloTs = (variant) => `import { defineFunction, defineSchema, type FunctionContext } from "@uipath/coded-functions-js-sdk";
 
 interface HelloInput {
   /**
@@ -2160,27 +2078,28 @@ interface HelloOutput {
   message: string;
 }
 
+function main(input: HelloInput, ctx: FunctionContext): HelloOutput {
+  const output: HelloOutput = {
+    message: \`Hello, \${input.name}!\`,
+  };
+  return output;
+}
+
 export default defineFunction({
-  name: "hello",
-  description: "Returns a greeting message.",
-  method: "POST",
-  path: "/hello",
-  input: defineSchema<HelloInput>(),
+  name: "${SAMPLE_FUNCTION.name}",
+  description: "${SAMPLE_FUNCTION.description}",
+${semanticsFor(variant)}  input: defineSchema<HelloInput>(),
   output: defineSchema<HelloOutput>(),
-  handler: async (input, ctx) => ({
-    message: \`Hello, \${input.name}!\`,
-  }),
+  handler: main,
 });
 `;
-var HELLO_JS = `// @ts-check
+var buildHelloJs = (variant) => `// @ts-check
 import { defineFunction } from "@uipath/coded-functions-js-sdk";
 
 export default defineFunction({
-  name: "hello",
-  description: "Returns a greeting message.",
-  method: "POST",
-  path: "/hello",
-  input: {
+  name: "${SAMPLE_FUNCTION.name}",
+  description: "${SAMPLE_FUNCTION.description}",
+${semanticsFor(variant)}  input: {
     type: "object",
     properties: {
       name: { type: "string", default: "World" },
@@ -2200,141 +2119,682 @@ export default defineFunction({
   }),
 });
 `;
-function registerNewCommand(program2) {
-  program2.command("new [name]").description("Scaffold a new JS/TS Functions project. Includes a hello world function by default; pass --empty to skip it.").option("--name <name>", "Project name / directory (alias for positional arg)").option("-l, --language <lang>", "Language: ts (default) or js", "ts").option("--empty", "Skip the hello world function — create an empty project").action((nameArg, opts) => {
-    const projectName = opts.name ?? nameArg ?? "my-functions";
-    const lang = opts.language === "js" ? "js" : "ts";
-    const projectDir = resolve(projectName);
-    if (existsSync2(projectDir)) {
-      console.error(`Directory already exists: ${projectDir}`);
-      process.exit(1);
-    }
-    ensureSetup();
-    const withSample = !opts.empty;
-    scaffoldProject({
-      projectDir,
-      name: projectName,
-      type: "module",
-      lang,
-      functions: withSample ? { hello: `functions/hello.${lang}:default` } : {}
-    });
-    if (withSample) {
-      writeFileSync3(join3(projectDir, "functions", `hello.${lang}`), lang === "ts" ? HELLO_TS : HELLO_JS, "utf-8");
-    }
-    if (process.env["GITHUB_TOKEN"]) {
-      writeFileSync3(join3(projectDir, ".npmrc"), NPM_RC, "utf-8");
-    }
-    console.log(`
-Created ${projectName}/`);
-    console.log("Installing dependencies...");
-    const { cmd, args } = getInstallCommand(false);
-    const installResult = spawnSync2(cmd, args, {
-      cwd: projectDir,
-      stdio: "inherit",
-      shell: process.platform === "win32"
-    });
-    if (installResult.status !== 0) {
-      console.error(`${cmd} install failed in ${projectDir}.`);
-      process.exit(1);
-    }
-    console.log(`
-Ready. Next steps:`);
-    console.log(`  cd ${projectName}`);
-    if (withSample) {
-      console.log(`  uip functions serve`);
-    } else {
-      console.log(`  # Add your function entry points to ${projectName}/functions/`);
-      console.log(`  uip functions serve`);
-    }
-  });
-}
-function generateAggregator(functionsMap, cwd, variant, derivedByPath = {}) {
-  const lang = detectLanguage(functionsMap);
-  const ext = lang === "javascript" ? "js" : "ts";
-  const fileToFunctions = new Map;
-  for (const [name, entry] of Object.entries(functionsMap)) {
-    const file = entry.split(":")[0];
-    const existing = fileToFunctions.get(file);
-    if (existing) {
-      existing.push(name);
-    } else {
-      fileToFunctions.set(file, [name]);
+var HELLO_TS = buildHelloTs("http");
+var HELLO_TS_JOB = buildHelloTs("job");
+var HELLO_JS = buildHelloJs("http");
+var HELLO_JS_JOB = buildHelloJs("job");
+var sanitizeNpmPackageName = (projectName) => projectName.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-._]/g, "").replace(/^[-._]+/, "") || "function-project";
+var sampleDevDependencies = (language) => ({
+  [SDK_PACKAGE_NAME]: SDK_RANGE,
+  ...language === "ts" ? { typescript: TYPESCRIPT_RANGE } : {}
+});
+var getSamplePackageJson = (projectName, language) => JSON.stringify({
+  name: sanitizeNpmPackageName(projectName),
+  version: "1.0.0",
+  type: "module",
+  devDependencies: sampleDevDependencies(language)
+}, null, 2) + `
+`;
+var SAMPLE_TSCONFIG = JSON.stringify({
+  compilerOptions: {
+    target: "ESNext",
+    module: "ESNext",
+    moduleResolution: "bundler",
+    strict: true,
+    allowImportingTsExtensions: true,
+    noEmit: true
+  },
+  include: ["**/*.ts"],
+  exclude: ["node_modules", "dist"]
+}, null, 2) + `
+`;
+var SAMPLE_LOCK_PACKAGES = {
+  "node_modules/@babel/runtime": {
+    version: "7.29.7",
+    resolved: "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+    integrity: "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
+    dev: true,
+    license: "MIT",
+    engines: { node: ">=6.9.0" }
+  },
+  "node_modules/@standard-schema/spec": {
+    version: "1.1.0",
+    resolved: "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+    integrity: "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+    dev: true,
+    license: "MIT"
+  },
+  [`node_modules/${SDK_PACKAGE_NAME}`]: {
+    version: SDK_VERSION,
+    dev: true,
+    dependencies: {
+      "@standard-schema/spec": "^1.1.0",
+      "json-schema-to-ts": "^3.1.1"
     }
+  },
+  "node_modules/json-schema-to-ts": {
+    version: "3.1.1",
+    resolved: "https://registry.npmjs.org/json-schema-to-ts/-/json-schema-to-ts-3.1.1.tgz",
+    integrity: "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==",
+    dev: true,
+    license: "MIT",
+    dependencies: {
+      "@babel/runtime": "^7.18.3",
+      "ts-algebra": "^2.0.0"
+    },
+    engines: { node: ">=16" }
+  },
+  "node_modules/ts-algebra": {
+    version: "2.0.0",
+    resolved: "https://registry.npmjs.org/ts-algebra/-/ts-algebra-2.0.0.tgz",
+    integrity: "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==",
+    dev: true,
+    license: "MIT"
+  },
+  "node_modules/typescript": {
+    version: "5.9.3",
+    resolved: "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+    integrity: "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+    dev: true,
+    license: "Apache-2.0",
+    bin: { tsc: "bin/tsc", tsserver: "bin/tsserver" },
+    engines: { node: ">=14.17" }
   }
-  for (const [file, names] of fileToFunctions) {
-    if (names.length > 1) {
-      throw new Error(`Multiple function definitions in the same file are not allowed.
-` + `File "${file}" is used by: ${names.join(", ")}.
-` + `Each function must be defined in its own file.`);
-    }
+};
+function scaffoldProject(opts) {
+  const { projectDir, name, lang, functions } = opts;
+  mkdirSync2(projectDir, { recursive: true });
+  mkdirSync2(join2(projectDir, "functions"), { recursive: true });
+  writeFileSync2(join2(projectDir, "uipath.json"), JSON.stringify({
+    $schema: "https://cloud.uipath.com/draft/2024-12/uipath",
+    packOptions: {
+      fileExtensionsIncluded: [],
+      filesIncluded: [],
+      filesExcluded: [],
+      directoriesExcluded: []
+    },
+    functions
+  }, null, 2) + `
+`, "utf-8");
+  writeFileSync2(join2(projectDir, "package.json"), getSamplePackageJson(name, lang), "utf-8");
+  if (lang === "ts") {
+    writeFileSync2(join2(projectDir, "tsconfig.json"), SAMPLE_TSCONFIG, "utf-8");
   }
-  const files = [...fileToFunctions.keys()];
-  let outputFile;
-  let importPrefix;
-  if (variant === "serve") {
-    const dbgDir = join4(cwd, SERVER_RUNNER_DIR);
-    mkdirSync3(dbgDir, { recursive: true });
-    outputFile = join4(dbgDir, `function-main.${ext}`);
-    importPrefix = "../../";
-  } else {
-    outputFile = join4(cwd, `function-main.${ext}`);
-    importPrefix = "./";
+  writeFileSync2(join2(projectDir, ".env.example"), [
+    "UIPATH_URL=",
+    "UIPATH_ORGANIZATION_NAME=",
+    "UIPATH_TENANT_NAME=",
+    "UIPATH_ACCESS_TOKEN=",
+    "",
+    "# push: Studio Web project ID (create the project in Studio Web to get this)",
+    "UIPATH_PROJECT_ID="
+  ].join(`
+`) + `
+`, "utf-8");
+  writeFileSync2(join2(projectDir, ".gitignore"), `node_modules/
+dist/
+.env
+*.nupkg
+.uipath/
+`, "utf-8");
+}
+var npm = { name: "npm", lockFile: "package-lock.json", installHint: "npm install" };
+var bun = { name: "bun", lockFile: "bun.lock", installHint: "bun install" };
+var SUPPORTED_MANAGERS = [npm, bun];
+var RECOGNIZED_UNSUPPORTED_LOCK_FILES = ["yarn.lock", "pnpm-lock.yaml", "bun.lockb"];
+function detectPackageManager(present) {
+  const supported = SUPPORTED_MANAGERS.filter((manager) => present.has(manager.lockFile));
+  if (supported.length > 1)
+    return { kind: "ambiguous", managers: supported };
+  if (supported.length === 1)
+    return { kind: "found", manager: supported[0] };
+  const unsupported = RECOGNIZED_UNSUPPORTED_LOCK_FILES.filter((name) => present.has(name));
+  return unsupported.length > 0 ? { kind: "unsupported", fileNames: unsupported } : { kind: "none" };
+}
+var CANDIDATE_LOCK_FILES = [
+  ...SUPPORTED_MANAGERS.map((manager) => manager.lockFile),
+  ...RECOGNIZED_UNSUPPORTED_LOCK_FILES
+];
+async function probeLockFiles(reader) {
+  const present = new Set;
+  for (const fileName of CANDIDATE_LOCK_FILES) {
+    if (await reader.fileExists(fileName))
+      present.add(fileName);
   }
-  const imports = files.map((file, i) => `import f${i} from "${importPrefix}${file}";`).join(`
-`);
-  const relevantDerived = {};
-  for (const file of files) {
-    const d = derivedByPath[file];
-    if (!d)
-      continue;
-    const entry = {};
-    if (d.input !== undefined)
-      entry.input = d.input;
-    if (d.output !== undefined)
-      entry.output = d.output;
-    if (entry.input !== undefined || entry.output !== undefined)
-      relevantDerived[file] = entry;
+  return present;
+}
+function supportedLockFilesLabel() {
+  return SUPPORTED_MANAGERS.map((manager) => `${manager.lockFile} (${manager.name})`).join(" or ");
+}
+function describeDependencyProblem(detection) {
+  const defaultHint = SUPPORTED_MANAGERS[0].installHint;
+  switch (detection.kind) {
+    case "none":
+      return {
+        problem: `No dependency lock file found; expected ${supportedLockFilesLabel()}.`,
+        remedyCommand: defaultHint
+      };
+    case "unsupported": {
+      const names = detection.fileNames.join(" and ");
+      return {
+        problem: `Found ${names}, which cannot be installed from; expected ${supportedLockFilesLabel()}. ` + `Create a supported lock file, then delete ${names}.`,
+        remedyCommand: defaultHint
+      };
+    }
+    case "ambiguous":
+      return {
+        problem: `Found ${detection.managers.map((manager) => manager.lockFile).join(" and ")}. Keep exactly one: ` + `with two lock files the installer that runs on the pod picks one and the other's resolution ` + `is silently ignored.`,
+        remedyCommand: null
+      };
   }
-  const hasDerived = Object.keys(relevantDerived).length > 0;
-  const entries = files.map((file, i) => {
-    const def = hasDerived ? `__lower(f${i}, "${file}")` : `f${i}`;
-    return `{ functionDef: ${def}, functionPath: "${file}" }`;
-  }).join(", ");
-  const header = lang === "javascript" ? `// @ts-check
-` : "";
-  const loweringBlock = hasDerived ? `const __derived = ${JSON.stringify(relevantDerived, null, 2)};
-` + `function __lower(def, path) {
-` + `  const d = __derived[path];
-` + `  if (!d) return def;
-` + `  const out = { ...def };
-` + `  if (d.input !== undefined) out.input = d.input;
-` + `  if (d.output !== undefined) out.output = d.output;
-` + `  return out;
-` + `}
-
-` : "";
-  const content = `${header}` + `// Generated by uipath-functions — do not edit
-` + `import { createApp } from "@uipath/coded-functions-js-runtime";
-` + `${imports}
-
-` + `${loweringBlock}` + `export default createApp([${entries}]);
-`;
-  writeFileSync4(outputFile, content, "utf-8");
-  return outputFile;
 }
-function detectLanguage(functionsMap) {
-  const first = Object.values(functionsMap)[0]?.split(":")[0] ?? "";
-  return extname(first) === ".js" ? "javascript" : "typescript";
+var REGISTRY_CONFIG_FILE = ".npmrc";
+function isRegistryConfigFile(fileName) {
+  return fileName === REGISTRY_CONFIG_FILE;
 }
-var SegmentTier = {
-  Literal: 0,
-  RegexParam: 1,
-  RequiredParam: 2,
-  OptionalParam: 3,
-  Wildcard: 4
-};
-function trimSlashes(slug) {
-  return slug.replace(/^\/+|\/+$/g, "");
+var CREDENTIAL_KEYS = ["_authtoken", "_auth", "_password"];
+function isComment(line) {
+  return line === "" || line.startsWith("#") || line.startsWith(";");
+}
+function settingKey(line) {
+  const trimmed = line.trim();
+  if (isComment(trimmed))
+    return null;
+  return (trimmed.split("=")[0] ?? "").trim().toLowerCase();
+}
+function sanitizeRegistryConfig(content, stripScopes) {
+  const stripped = stripScopes.map((scope) => `${scope.replace(/:$/, "")}:`.toLowerCase());
+  const kept = content.split(/\r?\n/).filter((line) => {
+    const key = settingKey(line);
+    if (key === null)
+      return true;
+    if (stripped.some((scope) => key.startsWith(scope)))
+      return false;
+    return !CREDENTIAL_KEYS.some((credential) => key.endsWith(credential));
+  });
+  return kept.some((line) => !isComment(line.trim())) ? kept.join(`
+`) : null;
+}
+function ifsProjectFileReader(fs7, projectPath) {
+  return {
+    async fileExists(fileName) {
+      try {
+        return await fs7.exists(fs7.path.join(projectPath, fileName));
+      } catch {
+        return false;
+      }
+    },
+    async readFile(fileName) {
+      const content = await fs7.readFile(fs7.path.join(projectPath, fileName), "utf-8");
+      if (content === null)
+        throw new Error(`${fileName} not found in ${projectPath}.`);
+      return content;
+    }
+  };
+}
+var EXCLUDED_NAMES = new Set([
+  "node_modules",
+  ".git",
+  ".env",
+  ".deno",
+  "dist",
+  ".uipath"
+]);
+var EXCLUDED_EXTENSIONS = [".nupkg"];
+var SCOPES_NOT_PACKAGED = ["@uipath"];
+async function buildFunctionsPackage(fs7, options) {
+  const { projectPath, outputPath, projectStorageId } = options;
+  const contentPath = fs7.path.join(outputPath, "content");
+  await fs7.mkdir(outputPath);
+  await fs7.mkdir(contentPath);
+  const uipathJsonRaw = await fs7.readFile(fs7.path.join(projectPath, "uipath.json"), "utf-8");
+  if (!uipathJsonRaw) {
+    throw new Error("uipath.json not found. Run 'uipath-functions init' first.");
+  }
+  const uipathJson = JSON.parse(uipathJsonRaw);
+  const entryPointsRaw = await fs7.readFile(fs7.path.join(projectPath, "entry-points.json"), "utf-8");
+  if (!entryPointsRaw) {
+    throw new Error("entry-points.json not found. Run 'uipath-functions pack' to generate it.");
+  }
+  const entryPoints = JSON.parse(entryPointsRaw);
+  const bindingsRaw = await fs7.readFile(fs7.path.join(projectPath, "bindings_v2.json"), "utf-8");
+  if (!bindingsRaw) {
+    throw new Error("bindings_v2.json not found. Run 'uipath-functions pack' to generate it.");
+  }
+  const bindings = JSON.parse(bindingsRaw);
+  const packageJsonRaw = await fs7.readFile(fs7.path.join(projectPath, "package.json"), "utf-8");
+  const packageDependencies = packageJsonRaw ? JSON.parse(packageJsonRaw).dependencies ?? {} : {};
+  const targetRuntime = detectRuntime(uipathJson.functions);
+  const detection = detectPackageManager(await probeLockFiles(ifsProjectFileReader(fs7, projectPath)));
+  if (detection.kind !== "found") {
+    const { problem, remedyCommand } = describeDependencyProblem(detection);
+    throw new Error(remedyCommand !== null ? `${problem} Run '${remedyCommand}' in the project, then pack again.` : `${problem} Then pack again.`);
+  }
+  const lockFile = detection.manager.lockFile;
+  if (uipathJson.packOptions?.includeLockFile === false) {
+    console.warn(`uipath.json packOptions.includeLockFile is ignored: ${lockFile} is always packaged.`);
+  }
+  await copyProjectFiles(fs7, projectPath, contentPath, lockFile, uipathJson.packOptions);
+  const operateJson = {
+    $schema: "https://cloud.uipath.com/draft/2024-12/operate",
+    projectId: projectStorageId,
+    contentType: "function",
+    targetFramework: "Portable",
+    targetRuntime,
+    runtimeOptions: {
+      requiresUserInteraction: false,
+      isAttended: false
+    },
+    deploymentOptions: {
+      generateSlug: true
+    },
+    dependencies: packageDependencies
+  };
+  await fs7.writeFile(fs7.path.join(contentPath, "operate.json"), JSON.stringify(operateJson, null, 2));
+  await fs7.writeFile(fs7.path.join(contentPath, "entry-points.json"), JSON.stringify(entryPoints, null, 2));
+  await fs7.writeFile(fs7.path.join(contentPath, "bindings_v2.json"), JSON.stringify(bindings, null, 2));
+  const packageDescriptor = {
+    $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+    files: {
+      "operate.json": "content/operate.json",
+      "entry-points.json": "content/entry-points.json",
+      "bindings.json": "content/bindings_v2.json"
+    }
+  };
+  for (const ep of entryPoints.entryPoints) {
+    const fnEntry = uipathJson.functions?.[ep.filePath];
+    const filePath = fnEntry ? fnEntry.split(":")[0] ?? ep.filePath : ep.filePath;
+    packageDescriptor.files[ep.filePath] = `${filePath}`;
+  }
+  await fs7.writeFile(fs7.path.join(contentPath, "package-descriptor.json"), JSON.stringify(packageDescriptor, null, 2));
+}
+function detectRuntime(functions) {
+  if (!functions)
+    return "javascript";
+  const first = Object.values(functions)[0];
+  if (!first)
+    return "javascript";
+  const filePath = first.split(":")[0] ?? "";
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  if (ext === ".py")
+    return "python";
+  return "javascript";
+}
+async function copyProjectFiles(fs7, sourcePath, destPath, lockFile, packOptions) {
+  const extraExcludedDirs = new Set(packOptions?.directoriesExcluded ?? []);
+  const extraExcludedFiles = new Set(packOptions?.filesExcluded ?? []);
+  const otherLockFiles = new Set(CANDIDATE_LOCK_FILES.filter((name) => name !== lockFile));
+  async function walk(src, dest) {
+    await fs7.mkdir(dest);
+    const entries = await fs7.readdir(src);
+    for (const name of entries) {
+      if (EXCLUDED_NAMES.has(name))
+        continue;
+      if (extraExcludedDirs.has(name))
+        continue;
+      if (extraExcludedFiles.has(name))
+        continue;
+      if (EXCLUDED_EXTENSIONS.some((ext) => name.endsWith(ext)))
+        continue;
+      if (otherLockFiles.has(name))
+        continue;
+      const srcEntry = fs7.path.join(src, name);
+      const destEntry = fs7.path.join(dest, name);
+      const stat2 = await fs7.stat(srcEntry);
+      if (stat2?.isDirectory()) {
+        await walk(srcEntry, destEntry);
+      } else if (isRegistryConfigFile(name)) {
+        const raw = await fs7.readFile(srcEntry, "utf-8") ?? "";
+        const sanitized = sanitizeRegistryConfig(raw, SCOPES_NOT_PACKAGED);
+        if (sanitized !== null)
+          await fs7.writeFile(destEntry, sanitized);
+      } else if (stat2?.isFile()) {
+        const content = await fs7.readFile(srcEntry);
+        if (content)
+          await fs7.writeFile(destEntry, content);
+      }
+    }
+  }
+  await walk(sourcePath, destPath);
+}
+var COMMANDS = {
+  npm: {
+    bin: "npm",
+    args: ({ production, preferOffline }) => [
+      "install",
+      ...production === true ? ["--omit=dev"] : [],
+      ...preferOffline === true ? ["--prefer-offline"] : []
+    ],
+    verifyArgs: ["ci", "--dry-run", "--no-audit", "--no-fund"],
+    saysLockDiffers: (output) => output.includes("EUSAGE")
+  },
+  bun: {
+    bin: "bun",
+    args: ({ production, preferOffline }) => [
+      "install",
+      ...production === true ? ["--production"] : [],
+      ...preferOffline === true ? ["--prefer-offline"] : []
+    ],
+    verifyArgs: ["install", "--frozen-lockfile", "--dry-run"],
+    saysLockDiffers: (output) => output.includes("lockfile had changes")
+  }
+};
+var FALLBACK_ORDER = ["npm", "bun"];
+var PACKAGE_MANAGER_NAMES = Object.keys(COMMANDS);
+var RUNNER_REGISTRY_CONFIG = `@uipath:registry=https://npm.pkg.github.com
+//npm.pkg.github.com/:_authToken=\${GITHUB_TOKEN}`;
+function writeRunnerRegistryConfig(dir) {
+  if (process.env["GITHUB_TOKEN"] === undefined || process.env["GITHUB_TOKEN"] === "")
+    return;
+  writeFileSync3(join3(dir, REGISTRY_CONFIG_FILE), RUNNER_REGISTRY_CONFIG, "utf-8");
+}
+function shareRegistryConfig(fromDir, toDir) {
+  if (fromDir === toDir)
+    return;
+  const source = join3(fromDir, REGISTRY_CONFIG_FILE);
+  if (existsSync2(source))
+    copyFileSync(source, join3(toDir, REGISTRY_CONFIG_FILE));
+}
+var onPathCache = new Map;
+function isOnPath(name) {
+  const cached = onPathCache.get(name);
+  if (cached !== undefined)
+    return cached;
+  const result = spawnSync(COMMANDS[name].bin, ["--version"], {
+    stdio: "ignore",
+    shell: process.platform === "win32"
+  });
+  const available = result.status === 0;
+  onPathCache.set(name, available);
+  return available;
+}
+function detectAvailableManagers() {
+  return FALLBACK_ORDER.filter((name) => isOnPath(name));
+}
+function declaredManager(cwd) {
+  let declared;
+  try {
+    declared = JSON.parse(readFileSync2(join3(cwd, "package.json"), "utf-8")).packageManager;
+  } catch {
+    return null;
+  }
+  if (typeof declared !== "string")
+    return null;
+  const name = declared.split("@")[0];
+  return Object.keys(COMMANDS).find((known) => known === name) ?? null;
+}
+function presentLockFiles(cwd) {
+  return new Set(CANDIDATE_LOCK_FILES.filter((fileName) => existsSync2(join3(cwd, fileName))));
+}
+function lockedManager(cwd) {
+  const detection = detectPackageManager(presentLockFiles(cwd));
+  return detection.kind === "found" ? detection.manager.name : null;
+}
+function firstComplaint(output) {
+  const lines = output.split(`
+`).map((line) => line.replace(/^npm (error|warn)/, "").trim()).filter((line) => line !== "");
+  const end = lines.findIndex((line) => line.startsWith("Usage:") || line.startsWith("Options:"));
+  return (end === -1 ? lines : lines.slice(0, end)).slice(0, 3).join(" ");
+}
+function detectProjectManager(cwd) {
+  return lockedManager(cwd) ?? declaredManager(cwd);
+}
+function resolvePackageManager(cwd, required) {
+  const { name, bin, shell } = required === undefined ? chosenInvocation(cwd) : requiredInvocation(required);
+  const { args, verifyArgs, saysLockDiffers } = COMMANDS[name];
+  return {
+    name,
+    verifyLock(dir) {
+      const result = spawnSync(bin, [...verifyArgs], {
+        cwd: dir,
+        encoding: "utf-8",
+        shell
+      });
+      const output = `${result.stdout ?? ""}
+${result.stderr ?? ""}`;
+      const detail = firstComplaint(output);
+      if (result.status === 0)
+        return { verdict: "current", detail };
+      return { verdict: saysLockDiffers(output) ? "differs" : "unknown", detail };
+    },
+    runInstall(dir, options = {}) {
+      shareRegistryConfig(cwd, dir);
+      const argv = args(options);
+      console.log(`Running: ${bin} ${argv.join(" ")}`);
+      const result = spawnSync(bin, argv, {
+        cwd: dir,
+        stdio: "inherit",
+        shell
+      });
+      if (result.status !== 0) {
+        throw new Error(`'${bin} ${argv.join(" ")}' failed in ${dir}.`);
+      }
+    }
+  };
+}
+function chooseManager(cwd) {
+  const available = detectAvailableManagers();
+  const desired = detectProjectManager(cwd);
+  if (desired !== null && !available.includes(desired)) {
+    const found = available.length > 0 ? ` (found ${available.join(", ")})` : "";
+    throw new Error(`This project must be installed with ${desired}, which is not on PATH${found}.`);
+  }
+  const name = desired ?? available[0];
+  if (name === undefined) {
+    throw new Error(`No supported package manager is on PATH (looked for ${FALLBACK_ORDER.join(", ")}).`);
+  }
+  return name;
+}
+function chosenInvocation(cwd) {
+  const name = chooseManager(cwd);
+  return { name, bin: COMMANDS[name].bin, shell: process.platform === "win32" };
+}
+function requiredInvocation(required) {
+  if (isManagerName(required)) {
+    if (!isOnPath(required)) {
+      throw new Error(`Cannot install with ${required}: it is not on PATH.`);
+    }
+    return { name: required, bin: COMMANDS[required].bin, shell: process.platform === "win32" };
+  }
+  const name = basename(required, extname(required)).toLowerCase();
+  if (!isManagerName(name)) {
+    throw new Error(`Cannot tell which package manager '${required}' is. Pass ${PACKAGE_MANAGER_NAMES.join(" or ")}, ` + "or the path to a binary named after one.");
+  }
+  if (!isAbsolute(required)) {
+    throw new Error(`Cannot install with '${required}': a package manager path must be absolute.`);
+  }
+  if (!existsSync2(required)) {
+    throw new Error(`Cannot install with '${required}': there is no such file.`);
+  }
+  return { name, bin: required, shell: needsShell(required) };
+}
+function isManagerName(value) {
+  return PACKAGE_MANAGER_NAMES.includes(value);
+}
+function needsShell(managerPath) {
+  return process.platform === "win32" && extname(managerPath).toLowerCase() !== ".exe";
+}
+function checkDependenciesInstalled(cwd) {
+  if (existsSync2(join3(cwd, "node_modules")))
+    return { ready: true, problem: null, remedyCommand: null };
+  return {
+    ready: false,
+    problem: "node_modules not found.",
+    remedyCommand: describeInstallCommand(cwd)
+  };
+}
+function checkLockCurrent(cwd) {
+  const detection = detectPackageManager(presentLockFiles(cwd));
+  if (detection.kind !== "found") {
+    const { problem, remedyCommand } = describeDependencyProblem(detection);
+    return { ready: false, problem, remedyCommand };
+  }
+  const { lockFile, installHint } = detection.manager;
+  const { verdict, detail } = resolvePackageManager(cwd).verifyLock(cwd);
+  if (verdict === "current")
+    return { ready: true, problem: null, remedyCommand: null };
+  if (verdict === "unknown") {
+    return {
+      ready: false,
+      problem: `Could not check whether ${lockFile} is up to date${detail === "" ? "." : `: ${detail}`}`,
+      remedyCommand: null
+    };
+  }
+  return {
+    ready: false,
+    problem: detail === "" ? `${lockFile} is out of date.` : `${lockFile} is out of date: ${detail}`,
+    remedyCommand: installHint
+  };
+}
+function describeInstallCommand(cwd) {
+  const name = detectProjectManager(cwd) ?? FALLBACK_ORDER[0];
+  const { bin, args } = COMMANDS[name];
+  return `${bin} ${args({}).join(" ")}`;
+}
+function affectsDependencyInstall(fileName) {
+  return CANDIDATE_LOCK_FILES.includes(fileName);
+}
+function describePackagedInstallProblem(installInputs) {
+  const detection = detectPackageManager(new Set(installInputs));
+  if (detection.kind === "found")
+    return null;
+  return `cannot be installed: ${describeDependencyProblem(detection).problem}`;
+}
+function registerNewCommand(program2) {
+  program2.command("new [name]").description("Scaffold a new JS/TS Functions project. Includes a hello world function by default; pass --empty to skip it.").option("--name <name>", "Project name / directory (alias for positional arg)").option("-l, --language <lang>", "Language: ts (default) or js", "ts").option("--empty", "Skip the hello world function — create an empty project").action((nameArg, opts) => {
+    const projectName = opts.name ?? nameArg ?? "my-functions";
+    const lang = opts.language === "js" ? "js" : "ts";
+    const projectDir = resolve(projectName);
+    if (existsSync3(projectDir)) {
+      console.error(`Directory already exists: ${projectDir}`);
+      process.exit(1);
+    }
+    ensureSetup();
+    const withSample = !opts.empty;
+    const sampleFile = `functions/${SAMPLE_FUNCTION.name}.${lang}`;
+    scaffoldProject({
+      projectDir,
+      name: projectName,
+      lang,
+      functions: withSample ? { [SAMPLE_FUNCTION.name]: `${sampleFile}:${SAMPLE_FUNCTION.entryExport}` } : {}
+    });
+    if (withSample) {
+      writeFileSync4(join4(projectDir, sampleFile), lang === "ts" ? HELLO_TS : HELLO_JS, "utf-8");
+    }
+    console.log(`
+Created ${projectName}/`);
+    console.log("Installing dependencies...");
+    try {
+      resolvePackageManager(projectDir).runInstall(projectDir);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+    console.log(`
+Ready. Next steps:`);
+    console.log(`  cd ${projectName}`);
+    if (withSample) {
+      console.log(`  uip functions serve`);
+    } else {
+      console.log(`  # Add your function entry points to ${projectName}/functions/`);
+      console.log(`  uip functions serve`);
+    }
+  });
+}
+var SERVER_RUNNER_DIR = ".uipath/server-runner";
+var DESIGN_TIME_ENV = "DESIGN_TIME";
+var RUNTIME_VERSION = "^0.9.0";
+var TSX_VERSION = "^4.0.0";
+var COREIPC_VERSION = "2.5.3";
+var SIGNALR_VERSION = "8.0.7";
+var TRACE_MAPPING_VERSION = "0.3.25";
+function generateAggregator(functionsMap, cwd, variant, derivedByPath = {}) {
+  const lang = detectLanguage(functionsMap);
+  const ext = lang === "javascript" ? "js" : "ts";
+  const fileToFunctions = new Map;
+  for (const [name, entry] of Object.entries(functionsMap)) {
+    const file = entry.split(":")[0];
+    const existing = fileToFunctions.get(file);
+    if (existing) {
+      existing.push(name);
+    } else {
+      fileToFunctions.set(file, [name]);
+    }
+  }
+  for (const [file, names] of fileToFunctions) {
+    if (names.length > 1) {
+      throw new Error(`Multiple function definitions in the same file are not allowed.
+` + `File "${file}" is used by: ${names.join(", ")}.
+` + `Each function must be defined in its own file.`);
+    }
+  }
+  const files = [...fileToFunctions.keys()];
+  let outputFile;
+  let importPrefix;
+  if (variant === "serve") {
+    const dbgDir = join5(cwd, SERVER_RUNNER_DIR);
+    mkdirSync3(dbgDir, { recursive: true });
+    outputFile = join5(dbgDir, `function-main.${ext}`);
+    importPrefix = "../../";
+  } else {
+    outputFile = join5(cwd, `function-main.${ext}`);
+    importPrefix = "./";
+  }
+  const imports = files.map((file, i) => `import f${i} from "${importPrefix}${file}";`).join(`
+`);
+  const relevantDerived = {};
+  for (const file of files) {
+    const d = derivedByPath[file];
+    if (!d)
+      continue;
+    const entry = {};
+    if (d.input !== undefined)
+      entry.input = d.input;
+    if (d.output !== undefined)
+      entry.output = d.output;
+    if (entry.input !== undefined || entry.output !== undefined)
+      relevantDerived[file] = entry;
+  }
+  const hasDerived = Object.keys(relevantDerived).length > 0;
+  const entries = files.map((file, i) => {
+    const def = hasDerived ? `__lower(f${i}, "${file}")` : `f${i}`;
+    return `{ functionDef: ${def}, functionPath: "${file}" }`;
+  }).join(", ");
+  const header = lang === "javascript" ? `// @ts-check
+` : "";
+  const loweringBlock = hasDerived ? `const __derived = ${JSON.stringify(relevantDerived, null, 2)};
+` + `function __lower(def, path) {
+` + `  const d = __derived[path];
+` + `  if (!d) return def;
+` + `  const out = { ...def };
+` + `  if (d.input !== undefined) out.input = d.input;
+` + `  if (d.output !== undefined) out.output = d.output;
+` + `  return out;
+` + `}
+
+` : "";
+  const content = `${header}` + `// Generated by uipath-functions — do not edit
+` + `import { createApp } from "@uipath/coded-functions-js-runtime";
+` + `${imports}
+
+` + `${loweringBlock}` + `export default createApp([${entries}]);
+`;
+  writeFileSync5(outputFile, content, "utf-8");
+  return outputFile;
+}
+function detectLanguage(functionsMap) {
+  const first = Object.values(functionsMap)[0]?.split(":")[0] ?? "";
+  return extname2(first) === ".js" ? "javascript" : "typescript";
+}
+var SegmentTier = {
+  Literal: 0,
+  RegexParam: 1,
+  RequiredParam: 2,
+  OptionalParam: 3,
+  Wildcard: 4
+};
+function trimSlashes(slug) {
+  return slug.replace(/^\/+|\/+$/g, "");
 }
 function classifySegment(segment) {
   if (segment === "*") {
@@ -2589,10 +3049,13 @@ var DIAGNOSTIC_CODES = {
   UNSUPPORTED_VALIDATOR: "unsupported-validator",
   UNSUPPORTED_TYPE: "unsupported-type",
   NON_STATIC_LITERAL: "non-static-literal",
+  UNREADABLE_PROPERTY: "unreadable-property",
   MISSING_TYPE_ARGUMENT: "missing-type-argument",
   AMBIGUOUS_ROUTE: "ambiguous-route",
   MULTIPLE_FUNCTIONS_PER_FILE: "multiple-functions-per-file",
-  DEPRECATED_MARKER: "deprecated-marker"
+  DEPRECATED_MARKER: "deprecated-marker",
+  NO_FUNCTION_DEFINITION: "no-function-definition",
+  UNRESOLVED_SOURCE_FILE: "unresolved-source-file"
 };
 function extractFunctionContracts(sourceFile, checker) {
   const bindings = sdkImportBindings(sourceFile);
@@ -2610,6 +3073,21 @@ function extractFunctionContracts(sourceFile, checker) {
           if (diagnostic)
             diagnostics.push({ ...diagnostic, functionName: fn.name, field });
         }
+        const unreadable = isNestedInFunction(node) ? { fields: [], anyField: false } : unreadableProperties(arg);
+        if (unreadable.anyField) {
+          diagnostics.push({
+            ...diag(DIAGNOSTIC_CODES.UNREADABLE_PROPERTY, "the definition spreads another object or uses a computed key, so which " + "contract fields it carries is not statically known", "warning"),
+            functionName: fn.name
+          });
+        } else {
+          for (const field of unreadable.fields) {
+            diagnostics.push({
+              ...diag(DIAGNOSTIC_CODES.UNREADABLE_PROPERTY, METADATA_FIELDS.has(field) ? `${field} cannot be read statically: a shorthand property, a method, an ` + `accessor and a reference to a variable all read as absent. Write it at ` + `the defineFunction call as a string literal.` : `${field} is declared as a shorthand property, a method or an accessor, ` + `which reads as absent. Write it as \`${field}: <value>\`.`, "warning"),
+              functionName: fn.name,
+              ...field === "input" || field === "output" ? { field } : {}
+            });
+          }
+        }
         functions.push(fn);
       }
     }
@@ -2623,13 +3101,28 @@ function extractFromFiles(files, checker, limits) {
   const diagnostics = [];
   const maxPerFile = limits?.maxDefineFunctionsPerFile;
   for (const { functionPath, sourceFile } of files) {
-    if (!sourceFile)
+    if (!sourceFile) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.UNRESOLVED_SOURCE_FILE,
+        severity: "error",
+        message: `could not be loaded — the file is missing, unreadable, or excluded from the ` + `TypeScript program.`,
+        file: functionPath
+      });
       continue;
+    }
     const result = extractFunctionContracts(sourceFile, checker);
     for (const fn of result.functions)
       functions.push({ ...fn, functionPath });
     for (const d of result.diagnostics)
       diagnostics.push({ ...d, file: functionPath });
+    if (limits?.requireFunctionPerFile && result.functions.length === 0 && !hasDefaultExport(sourceFile, checker)) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.NO_FUNCTION_DEFINITION,
+        severity: "error",
+        message: `no default export — an entry point must default-export its function definition.`,
+        file: functionPath
+      });
+    }
     if (maxPerFile !== undefined && result.functions.length > maxPerFile) {
       diagnostics.push({
         code: DIAGNOSTIC_CODES.MULTIPLE_FUNCTIONS_PER_FILE,
@@ -2651,6 +3144,12 @@ function extractFromFiles(files, checker, limits) {
   return { functions, diagnostics };
 }
 var SDK_MODULE = "@uipath/coded-functions-js-sdk";
+function hasDefaultExport(sourceFile, checker) {
+  const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+  if (!moduleSymbol)
+    return false;
+  return checker.getExportsOfModule(moduleSymbol).some((s) => s.escapedName === "default");
+}
 var MARKER_EXPORTS = ["defineSchema", "type"];
 function sdkImportBindings(sourceFile) {
   const map = new Map;
@@ -2679,7 +3178,7 @@ function resolveField(obj, field, checker, bindings) {
   const prop = findProp(obj, field);
   if (!prop)
     return {};
-  const value = prop.initializer;
+  const value = unwrap(prop.initializer);
   const callee = ts.isCallExpression(value) && ts.isIdentifier(value.expression) ? value.expression.text : undefined;
   if (ts.isCallExpression(value) && callee !== undefined && MARKER_EXPORTS.some((name) => matchesSdkExport(callee, name, bindings))) {
     const typeArg = value.typeArguments?.[0];
@@ -2710,15 +3209,50 @@ function resolveField(obj, field, checker, bindings) {
   };
 }
 function propertyName(name) {
-  if (ts.isIdentifier(name) || ts.isStringLiteral(name))
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
     return name.text;
+  }
   return;
 }
+var CONTRACT_FIELDS = new Set(["name", "method", "path", "description", "input", "output"]);
+var METADATA_FIELDS = new Set(["name", "method", "path", "description"]);
+function isNestedInFunction(node) {
+  for (let current = node.parent;current && !ts.isSourceFile(current); current = current.parent) {
+    if (ts.isFunctionLike(current) || ts.isClassStaticBlockDeclaration(current))
+      return true;
+  }
+  return false;
+}
+function unreadableProperties(obj) {
+  const fields = new Set;
+  for (const property of obj.properties) {
+    if (ts.isPropertyAssignment(property)) {
+      const name2 = propertyName(property.name);
+      if (name2 === undefined)
+        return { fields: [], anyField: true };
+      if (METADATA_FIELDS.has(name2) && !isReadableMetadataValue(property.initializer)) {
+        fields.add(name2);
+      }
+      continue;
+    }
+    if (ts.isSpreadAssignment(property))
+      return { fields: [], anyField: true };
+    const name = property.name && propertyName(property.name);
+    if (name === undefined)
+      return { fields: [], anyField: true };
+    if (CONTRACT_FIELDS.has(name))
+      fields.add(name);
+  }
+  return { fields: [...fields], anyField: false };
+}
+function isReadableMetadataValue(value) {
+  return ts.isStringLiteralLike(unwrap(value));
+}
 function findProp(obj, field) {
   return obj.properties.find((p) => ts.isPropertyAssignment(p) && propertyName(p.name) === field);
 }
-function diag(code, message) {
-  return { code, severity: "error", message };
+function diag(code, message, severity = "error") {
+  return { code, severity, message };
 }
 function readMetadata(obj) {
   const meta = {};
@@ -2739,26 +3273,41 @@ function readMetadata(obj) {
     meta.tags = tags;
   return meta;
 }
+function unwrap(value) {
+  let current = value;
+  while (ts.isAsExpression(current) || ts.isParenthesizedExpression(current) || ts.isSatisfiesExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+}
 function stringProp(obj, field) {
   const prop = findProp(obj, field);
-  return prop && ts.isStringLiteralLike(prop.initializer) ? prop.initializer.text : undefined;
+  if (!prop)
+    return;
+  const value = unwrap(prop.initializer);
+  return ts.isStringLiteralLike(value) ? value.text : undefined;
 }
 function stringArrayProp(obj, field) {
   const prop = findProp(obj, field);
-  if (!prop || !ts.isArrayLiteralExpression(prop.initializer))
+  if (!prop)
+    return;
+  const array = unwrap(prop.initializer);
+  if (!ts.isArrayLiteralExpression(array))
     return;
   const values = [];
-  for (const el of prop.initializer.elements) {
-    if (!ts.isStringLiteralLike(el))
+  for (const el of array.elements) {
+    const value = unwrap(el);
+    if (!ts.isStringLiteralLike(value))
       return;
-    values.push(el.text);
+    values.push(value.text);
   }
   return values;
 }
 function literalToSchema(node) {
   return foldLiteral(node);
 }
-function foldLiteral(node) {
+function foldLiteral(expression) {
+  const node = unwrap(expression);
   if (ts.isStringLiteralLike(node))
     return node.text;
   if (ts.isNumericLiteral(node))
@@ -2786,176 +3335,618 @@ function foldLiteral(node) {
         throw new Error("object has a computed/non-static property key");
       obj[key] = foldLiteral(p.initializer);
     }
-    return obj;
+    return obj;
+  }
+  throw new Error(`not a static literal (${ts.SyntaxKind[node.kind]})`);
+}
+function extractDisk(opts) {
+  const { cwd, files } = opts;
+  const diskFs = {
+    readFile: () => {
+      return;
+    },
+    fileExists: () => false,
+    directoryExists: () => false,
+    currentDirectory: cwd
+  };
+  const rootNames = files.map((f) => resolve2(cwd, f));
+  const { program: program2, checker } = createProgram(diskFs, rootNames, readCompilerOptions(cwd));
+  const useCase = ts2.sys.useCaseSensitiveFileNames;
+  const canonical = (p) => {
+    const s = p.replace(/\\/g, "/");
+    return useCase ? s : s.toLowerCase();
+  };
+  const byPath = new Map(program2.getSourceFiles().map((sf) => [canonical(sf.fileName), sf]));
+  return extractFromFiles(files.map((file) => ({ functionPath: file, sourceFile: byPath.get(canonical(resolve2(cwd, file))) })), checker, opts.limits);
+}
+function readCompilerOptions(cwd) {
+  const configPath = ts2.findConfigFile(cwd, ts2.sys.fileExists, "tsconfig.json");
+  if (!configPath)
+    return CONSUMER_COMPILER_OPTIONS;
+  const read = ts2.readConfigFile(configPath, ts2.sys.readFile);
+  if (read.error || !read.config)
+    return CONSUMER_COMPILER_OPTIONS;
+  const parsed = ts2.parseJsonConfigFileContent(read.config, ts2.sys, dirname(configPath));
+  return { ...parsed.options, noEmit: true, allowJs: true };
+}
+function extractProject(functionsMap, cwd) {
+  const files = [...new Set(Object.values(functionsMap).map((v) => v.split(":")[0]))];
+  return extractDisk({
+    cwd,
+    files,
+    limits: { requireFunctionPerFile: true }
+  });
+}
+function toDerivedContracts(functions) {
+  const derived = {};
+  for (const fn of functions) {
+    if (fn.functionPath && (fn.input !== undefined || fn.output !== undefined)) {
+      derived[fn.functionPath] = fn;
+    }
+  }
+  return derived;
+}
+function deriveRunContract(relFile, cwd) {
+  const { functions } = extractDisk({ cwd, files: [relFile] });
+  const fn = functions.find((f) => f.input !== undefined || f.output !== undefined);
+  if (!fn)
+    return null;
+  const derived = {};
+  if (fn.input !== undefined)
+    derived.input = fn.input;
+  if (fn.output !== undefined)
+    derived.output = fn.output;
+  return derived;
+}
+function readBakedContract(relFile, cwd) {
+  const doc = readJsonIfExists(join6(cwd, "entry-points.json"));
+  const entryPoints = doc?.entryPoints;
+  if (!Array.isArray(entryPoints))
+    return null;
+  const target = stripContentPrefix(relFile);
+  const ep = entryPoints.find((e) => e?.type === "function" && typeof e.filePath === "string" && stripContentPrefix(e.filePath) === target);
+  if (!ep)
+    return null;
+  const derived = {};
+  if (ep.input !== undefined)
+    derived.input = ep.input;
+  if (ep.output !== undefined)
+    derived.output = ep.output;
+  return derived.input !== undefined || derived.output !== undefined ? derived : null;
+}
+function stripContentPrefix(p) {
+  const s = p.replace(/\\/g, "/");
+  return s.startsWith("content/") ? s.slice("content/".length) : s;
+}
+function readJsonIfExists(path3) {
+  if (!existsSync4(path3))
+    return null;
+  try {
+    return JSON.parse(readFileSync3(path3, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var SDK_VERSION2 = "0.6.2";
+var SDK_RANGE2 = `^${SDK_VERSION2}`;
+var SDK_PACKAGE_NAME2 = "@uipath/coded-functions-js-sdk";
+var SAMPLE_FUNCTION2 = {
+  name: "hello",
+  description: "Returns a greeting message.",
+  method: "POST",
+  path: "/hello",
+  entryExport: "default"
+};
+var httpSemantics2 = `  method: "${SAMPLE_FUNCTION2.method}",
+  path: "${SAMPLE_FUNCTION2.path}",
+`;
+var semanticsFor2 = (variant) => variant === "http" ? httpSemantics2 : "";
+var buildHelloTs2 = (variant) => `import { defineFunction, defineSchema, type FunctionContext } from "@uipath/coded-functions-js-sdk";
+
+interface HelloInput {
+  /**
+   * Name to greet — filled in by the runtime when omitted.
+   * @default "World"
+   */
+  name?: string;
+}
+
+interface HelloOutput {
+  message: string;
+}
+
+function main(input: HelloInput, ctx: FunctionContext): HelloOutput {
+  const output: HelloOutput = {
+    message: \`Hello, \${input.name}!\`,
+  };
+  return output;
+}
+
+export default defineFunction({
+  name: "${SAMPLE_FUNCTION2.name}",
+  description: "${SAMPLE_FUNCTION2.description}",
+${semanticsFor2(variant)}  input: defineSchema<HelloInput>(),
+  output: defineSchema<HelloOutput>(),
+  handler: main,
+});
+`;
+var buildHelloJs2 = (variant) => `// @ts-check
+import { defineFunction } from "@uipath/coded-functions-js-sdk";
+
+export default defineFunction({
+  name: "${SAMPLE_FUNCTION2.name}",
+  description: "${SAMPLE_FUNCTION2.description}",
+${semanticsFor2(variant)}  input: {
+    type: "object",
+    properties: {
+      name: { type: "string", default: "World" },
+    },
+    additionalProperties: false,
+  },
+  output: {
+    type: "object",
+    properties: {
+      message: { type: "string" },
+    },
+    required: ["message"],
+    additionalProperties: false,
+  },
+  handler: async (input, ctx) => ({
+    message: \`Hello, \${input.name}!\`,
+  }),
+});
+`;
+var HELLO_TS2 = buildHelloTs2("http");
+var HELLO_TS_JOB2 = buildHelloTs2("job");
+var HELLO_JS2 = buildHelloJs2("http");
+var HELLO_JS_JOB2 = buildHelloJs2("job");
+var SAMPLE_TSCONFIG2 = JSON.stringify({
+  compilerOptions: {
+    target: "ESNext",
+    module: "ESNext",
+    moduleResolution: "bundler",
+    strict: true,
+    allowImportingTsExtensions: true,
+    noEmit: true
+  },
+  include: ["**/*.ts"],
+  exclude: ["node_modules", "dist"]
+}, null, 2) + `
+`;
+var SAMPLE_LOCK_PACKAGES2 = {
+  "node_modules/@babel/runtime": {
+    version: "7.29.7",
+    resolved: "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+    integrity: "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
+    dev: true,
+    license: "MIT",
+    engines: { node: ">=6.9.0" }
+  },
+  "node_modules/@standard-schema/spec": {
+    version: "1.1.0",
+    resolved: "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+    integrity: "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+    dev: true,
+    license: "MIT"
+  },
+  [`node_modules/${SDK_PACKAGE_NAME2}`]: {
+    version: SDK_VERSION2,
+    dev: true,
+    dependencies: {
+      "@standard-schema/spec": "^1.1.0",
+      "json-schema-to-ts": "^3.1.1"
+    }
+  },
+  "node_modules/json-schema-to-ts": {
+    version: "3.1.1",
+    resolved: "https://registry.npmjs.org/json-schema-to-ts/-/json-schema-to-ts-3.1.1.tgz",
+    integrity: "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==",
+    dev: true,
+    license: "MIT",
+    dependencies: {
+      "@babel/runtime": "^7.18.3",
+      "ts-algebra": "^2.0.0"
+    },
+    engines: { node: ">=16" }
+  },
+  "node_modules/ts-algebra": {
+    version: "2.0.0",
+    resolved: "https://registry.npmjs.org/ts-algebra/-/ts-algebra-2.0.0.tgz",
+    integrity: "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==",
+    dev: true,
+    license: "MIT"
+  },
+  "node_modules/typescript": {
+    version: "5.9.3",
+    resolved: "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+    integrity: "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+    dev: true,
+    license: "Apache-2.0",
+    bin: { tsc: "bin/tsc", tsserver: "bin/tsserver" },
+    engines: { node: ">=14.17" }
+  }
+};
+var CONSUMER_COMPILER_OPTIONS2 = {
+  target: ts3.ScriptTarget.ES2020,
+  module: ts3.ModuleKind.ESNext,
+  moduleResolution: ts3.ModuleResolutionKind.Bundler,
+  allowImportingTsExtensions: true,
+  allowJs: true,
+  strict: true,
+  skipLibCheck: true,
+  noEmit: true
+};
+var DIAGNOSTIC_CODES2 = {
+  UNSUPPORTED_VALIDATOR: "unsupported-validator",
+  UNSUPPORTED_TYPE: "unsupported-type",
+  NON_STATIC_LITERAL: "non-static-literal",
+  UNREADABLE_PROPERTY: "unreadable-property",
+  MISSING_TYPE_ARGUMENT: "missing-type-argument",
+  AMBIGUOUS_ROUTE: "ambiguous-route",
+  MULTIPLE_FUNCTIONS_PER_FILE: "multiple-functions-per-file",
+  DEPRECATED_MARKER: "deprecated-marker",
+  NO_FUNCTION_DEFINITION: "no-function-definition",
+  UNRESOLVED_SOURCE_FILE: "unresolved-source-file"
+};
+var CONTRACT_FIELDS2 = new Set(["name", "method", "path", "description", "input", "output"]);
+var METADATA_FIELDS2 = new Set(["name", "method", "path", "description"]);
+var JOB_ATTACHMENT_REF = "#/definitions/job-attachment";
+var JOB_ATTACHMENT_DEFINITION_KEY = "job-attachment";
+var JOB_ATTACHMENT_DEFINITION = {
+  type: "object",
+  required: ["ID"],
+  "x-uipath-resource-kind": "JobAttachment",
+  properties: {
+    ID: { type: "string", description: "Orchestrator attachment key" },
+    FullName: { type: "string", description: "File name" },
+    MimeType: {
+      type: "string",
+      description: 'The MIME type of the content, such as "application/json" or "image/png"'
+    },
+    Metadata: {
+      type: "object",
+      description: "Dictionary<string, string> of metadata",
+      additionalProperties: { type: "string" }
+    }
   }
-  throw new Error(`not a static literal (${ts.SyntaxKind[node.kind]})`);
-}
-function extractDisk(opts) {
-  const { cwd, files } = opts;
-  const diskFs = {
-    readFile: () => {
-      return;
-    },
-    fileExists: () => false,
-    directoryExists: () => false,
-    currentDirectory: cwd
-  };
-  const rootNames = files.map((f) => resolve2(cwd, f));
-  const { program: program2, checker } = createProgram(diskFs, rootNames, readCompilerOptions(cwd));
-  const useCase = ts2.sys.useCaseSensitiveFileNames;
-  const canonical = (p) => {
-    const s = p.replace(/\\/g, "/");
-    return useCase ? s : s.toLowerCase();
-  };
-  const byPath = new Map(program2.getSourceFiles().map((sf) => [canonical(sf.fileName), sf]));
-  return extractFromFiles(files.map((file) => ({ functionPath: file, sourceFile: byPath.get(canonical(resolve2(cwd, file))) })), checker, opts.limits);
+};
+var ANNOTATION_KEYS = ["title", "description", "default"];
+var STRUCTURAL_KEYS = new Set(["type", "properties", "required", "additionalProperties"]);
+var STRING_PROPERTIES = ["ID", "FullName", "MimeType"];
+function stripAnnotations(node) {
+  const out = { ...node };
+  for (const key of ANNOTATION_KEYS)
+    delete out[key];
+  return out;
 }
-function readCompilerOptions(cwd) {
-  const configPath = ts2.findConfigFile(cwd, ts2.sys.fileExists, "tsconfig.json");
-  if (!configPath)
-    return CONSUMER_COMPILER_OPTIONS;
-  const read = ts2.readConfigFile(configPath, ts2.sys.readFile);
-  if (read.error || !read.config)
-    return CONSUMER_COMPILER_OPTIONS;
-  const parsed = ts2.parseJsonConfigFileContent(read.config, ts2.sys, dirname(configPath));
-  return { ...parsed.options, noEmit: true, allowJs: true };
+function isPlainString(node) {
+  if (!node)
+    return false;
+  const shape = stripAnnotations(node);
+  return Object.keys(shape).length === 1 && shape.type === "string";
 }
-function extractProject(functionsMap, cwd) {
-  const files = [...new Set(Object.values(functionsMap).map((v) => v.split(":")[0]))];
-  return extractDisk({ cwd, files });
+function isOpenObject(node) {
+  if (!node)
+    return false;
+  const shape = stripAnnotations(node);
+  if (shape.type !== "object")
+    return false;
+  return Object.keys(shape).every((key) => key === "type" || key === "additionalProperties");
 }
-function toDerivedContracts(functions) {
-  const derived = {};
-  for (const fn of functions) {
-    if (fn.functionPath && (fn.input !== undefined || fn.output !== undefined)) {
-      derived[fn.functionPath] = fn;
-    }
+function matchesJobAttachment(node) {
+  if (node.type !== "object")
+    return false;
+  if (node.additionalProperties !== false && node.additionalProperties !== undefined)
+    return false;
+  for (const key of Object.keys(node)) {
+    if (!STRUCTURAL_KEYS.has(key) && !ANNOTATION_KEYS.includes(key))
+      return false;
   }
-  return derived;
-}
-function deriveMarkerContracts(functionsMap, cwd) {
-  return toDerivedContracts(extractProject(functionsMap, cwd).functions);
-}
-function deriveRunContract(relFile, cwd) {
-  const { functions } = extractDisk({ cwd, files: [relFile] });
-  const fn = functions.find((f) => f.input !== undefined || f.output !== undefined);
-  if (!fn)
-    return null;
-  const derived = {};
-  if (fn.input !== undefined)
-    derived.input = fn.input;
-  if (fn.output !== undefined)
-    derived.output = fn.output;
-  return derived;
+  const props = node.properties;
+  if (!props)
+    return false;
+  if (Object.keys(props).length !== ("Metadata" in props ? 4 : 3))
+    return false;
+  if (!STRING_PROPERTIES.every((p) => isPlainString(props[p])))
+    return false;
+  if ("Metadata" in props && !isOpenObject(props.Metadata))
+    return false;
+  const required = node.required ?? [];
+  return required.includes("ID") && required.every((p) => STRING_PROPERTIES.includes(p));
+}
+function rewrite(node) {
+  if (matchesJobAttachment(node)) {
+    const ref = {};
+    for (const key of ANNOTATION_KEYS) {
+      if (key in node)
+        ref[key] = node[key];
+    }
+    ref.$ref = JOB_ATTACHMENT_REF;
+    return { node: ref, found: true };
+  }
+  let found = false;
+  const out = { ...node };
+  if (node.properties) {
+    const properties = {};
+    for (const [key, value] of Object.entries(node.properties)) {
+      const result = rewrite(value);
+      properties[key] = result.node;
+      found = found || result.found;
+    }
+    out.properties = properties;
+  }
+  if (node.items) {
+    const result = rewrite(node.items);
+    out.items = result.node;
+    found = found || result.found;
+  }
+  if (typeof node.additionalProperties === "object") {
+    const result = rewrite(node.additionalProperties);
+    out.additionalProperties = result.node;
+    found = found || result.found;
+  }
+  for (const key of ["anyOf", "oneOf", "allOf"]) {
+    const members = node[key];
+    if (members) {
+      const results = members.map(rewrite);
+      out[key] = results.map((r) => r.node);
+      found = found || results.some((r) => r.found);
+    }
+  }
+  return { node: out, found };
+}
+function transformAttachments(schema) {
+  const { node, found } = rewrite(schema);
+  if (found)
+    node.definitions = { [JOB_ATTACHMENT_DEFINITION_KEY]: JOB_ATTACHMENT_DEFINITION };
+  return node;
 }
-function readBakedContract(relFile, cwd) {
-  const doc = readJsonIfExists(join5(cwd, "entry-points.json"));
-  const entryPoints = doc?.entryPoints;
-  if (!Array.isArray(entryPoints))
-    return null;
-  const target = stripContentPrefix(relFile);
-  const ep = entryPoints.find((e) => e?.type === "function" && typeof e.filePath === "string" && stripContentPrefix(e.filePath) === target);
-  if (!ep)
-    return null;
-  const derived = {};
-  if (ep.input !== undefined)
-    derived.input = ep.input;
-  if (ep.output !== undefined)
-    derived.output = ep.output;
-  return derived.input !== undefined || derived.output !== undefined ? derived : null;
+function newId() {
+  return globalThis.crypto.randomUUID();
 }
-function stripContentPrefix(p) {
-  const s = p.replace(/\\/g, "/");
-  return s.startsWith("content/") ? s.slice("content/".length) : s;
+function buildEntryPointsDoc(functions, existing, filePathPrefix = "content/") {
+  const functionIds = new Map;
+  const transactionRoots = new Set;
+  const preserved = [];
+  for (const ep of existing?.entryPoints ?? []) {
+    if (ep.type === "function") {
+      functionIds.set(ep.filePath, ep.uniqueId);
+      if (ep.isTransactionRoot === true) {
+        transactionRoots.add(ep.filePath);
+      }
+    } else {
+      preserved.push(ep);
+    }
+  }
+  const functionEntries = functions.map((fn) => {
+    const filePath = filePathPrefix + (fn.functionPath ?? "");
+    return {
+      filePath,
+      uniqueId: functionIds.get(filePath) ?? newId(),
+      type: "function",
+      input: transformAttachments(fn.input ?? { type: "object" }),
+      output: transformAttachments(fn.output ?? { type: "object" }),
+      ...transactionRoots.has(filePath) ? { isTransactionRoot: true } : {}
+    };
+  });
+  return {
+    $schema: "https://cloud.uipath.com/draft/2024-12/entry-point",
+    $id: "entry-points.json",
+    entryPoints: [...preserved, ...functionEntries]
+  };
 }
-function readJsonIfExists(path3) {
-  if (!existsSync3(path3))
-    return null;
-  try {
-    return JSON.parse(readFileSync2(path3, "utf-8"));
-  } catch {
-    return null;
+function buildBindingsDoc(functions, entryPointIdByPath, existingBindings, filePathPrefix = "content/") {
+  const httpExisting = new Map;
+  const preserved = [];
+  for (const r of existingBindings?.resources ?? []) {
+    if (r.resource === "HttpTrigger") {
+      const meta = r.metadata;
+      if (meta?.Method && meta?.Slug) {
+        httpExisting.set(`${meta.Method}:${meta.Slug}`, { key: r.key, id: r.id });
+      }
+    } else {
+      preserved.push(r);
+    }
   }
+  const httpTriggers = functions.filter((fn) => fn.method && fn.path).map((fn) => {
+    const existing = httpExisting.get(`${fn.method}:${fn.path}`);
+    const bindingKey = existing?.key ?? newId();
+    const bindingId = existing?.id ?? newId();
+    const entryPointUniqueId = entryPointIdByPath.get(filePathPrefix + (fn.functionPath ?? ""));
+    if (!entryPointUniqueId) {
+      throw new Error(`Internal error: binding for "${fn.method} ${fn.path}" references entry point "${filePathPrefix}${fn.functionPath}", which is missing from entry-points.json.`);
+    }
+    return {
+      resource: "HttpTrigger",
+      key: bindingKey,
+      id: bindingId,
+      value: {
+        EntryPointUniqueId: {
+          DefaultValue: entryPointUniqueId,
+          IsExpression: false
+        }
+      },
+      metadata: {
+        BindingsVersion: "2.1",
+        Name: fn.name ?? "",
+        Method: fn.method,
+        Slug: fn.path,
+        CallingMode: "LongPolling",
+        Description: fn.description ?? ""
+      }
+    };
+  });
+  return {
+    $schema: "https://cloud.uipath.com/draft/2024-12/bindings",
+    version: "2.0",
+    resources: [...preserved, ...httpTriggers]
+  };
+}
+var BLOCKING_CODES = new Set([
+  DIAGNOSTIC_CODES2.NO_FUNCTION_DEFINITION,
+  DIAGNOSTIC_CODES2.UNRESOLVED_SOURCE_FILE
+]);
+var SILENT_CODES = new Set([DIAGNOSTIC_CODES2.UNSUPPORTED_VALIDATOR]);
+function isSilentSchemaSignal(d) {
+  return d.code === DIAGNOSTIC_CODES2.UNREADABLE_PROPERTY && d.field !== undefined;
 }
-function setupRunDependencies(cwd, serverRunnerTemplatePath = "") {
-  const serverRunnerDir = join6(cwd, SERVER_RUNNER_DIR);
+var REMEDIATION = {
+  [DIAGNOSTIC_CODES2.NO_FUNCTION_DEFINITION]: (d) => `Every file in functions/ is served as a function. If this file is a helper, move it out ` + `of functions/ or rename it to ${underscored(d.file)} so discovery skips it.`,
+  [DIAGNOSTIC_CODES2.UNRESOLVED_SOURCE_FILE]: () => `Check the path exists and that tsconfig.json does not exclude it.`
+};
+function reportDiagnostics(diagnostics) {
+  const blocking = diagnostics.filter((d) => BLOCKING_CODES.has(d.code));
+  const rest = diagnostics.filter((d) => !BLOCKING_CODES.has(d.code) && !SILENT_CODES.has(d.code) && !isSilentSchemaSignal(d));
+  for (const d of blocking)
+    console.error(`  Error: ${format(d)}`);
+  for (const d of rest)
+    console.warn(`  Warning: ${format(d)}`);
+  return blocking.length;
+}
+function reportDiagnosticsOrExit(diagnostics) {
+  const blocking = reportDiagnostics(diagnostics);
+  if (blocking === 0)
+    return;
+  console.error(`
+${blocking} error(s) in the project's function files — nothing was written. ` + `Fix them and re-run.`);
+  process.exit(1);
+}
+function format(d) {
+  const where = [d.functionName, d.field].filter(Boolean).join(".");
+  const location = [d.file, where ? `(${where})` : ""].filter(Boolean).join(" ");
+  const hint = REMEDIATION[d.code]?.(d);
+  return [location ? `${location}: ` : "", d.message, hint ? ` ${hint}` : ""].join("");
+}
+function underscored(file) {
+  if (!file)
+    return "_<name>.ts";
+  const dir = dirname2(file);
+  const renamed = `_${basename2(file)}`;
+  return dir === "." ? renamed : `${dir}/${renamed}`;
+}
+function installServerRunner(cwd, serverRunnerTemplatePath = "", packageManager) {
+  const serverRunnerDir = join7(cwd, SERVER_RUNNER_DIR);
   mkdirSync4(serverRunnerDir, { recursive: true });
-  if (serverRunnerTemplatePath !== "" && existsSync4(serverRunnerTemplatePath)) {
+  if (serverRunnerTemplatePath !== "" && existsSync5(serverRunnerTemplatePath)) {
     console.log("Copying server-runner ...");
     for (const entry of readdirSync(serverRunnerTemplatePath)) {
-      cpSync(join6(serverRunnerTemplatePath, entry), join6(serverRunnerDir, entry), { recursive: true });
+      cpSync(join7(serverRunnerTemplatePath, entry), join7(serverRunnerDir, entry), { recursive: true });
     }
     console.log("server-runner copied in " + serverRunnerDir + ".");
-  } else {
-    let runtimeVersion = "no-version";
-    let honoVersion = "no-version";
-    let tsxVersion = "no-version";
-    const pkgJson = JSON.parse(readFileSync3(join6(cwd, "package.json"), "utf-8"));
-    try {
-      const allDeps = { ...pkgJson.dependencies ?? {}, ...pkgJson.devDependencies ?? {} };
-      runtimeVersion = allDeps["@uipath/coded-functions-js-runtime"] ?? RUNTIME_VERSION;
-      honoVersion = allDeps["@hono/node-server"] ?? HONO_NODE_VERSION;
-      tsxVersion = allDeps["tsx"] ?? TSX_VERSION;
-    } catch {}
-    pkgJson.dependencies = {
-      "@uipath/coded-functions-js-runtime": runtimeVersion,
-      "@uipath/coreipc": COREIPC_VERSION,
-      "@hono/node-server": HONO_NODE_VERSION,
-      tsx: tsxVersion,
-      "@microsoft/signalr": SIGNALR_VERSION,
-      "@jridgewell/trace-mapping": TRACE_MAPPING_VERSION
-    };
-    writeFileSync5(join6(serverRunnerDir, "package.json"), JSON.stringify(pkgJson, null, 2), "utf-8");
-    const npmrc = join6(cwd, ".npmrc");
-    if (existsSync4(npmrc)) {
-      copyFileSync(npmrc, join6(serverRunnerDir, ".npmrc"));
-    }
-    console.log("Installing runtime dependencies ...");
-    const install = getInstallCommand(false, ["--prefer-offline"]);
-    const result = spawnSync3(install.cmd, install.args, {
-      cwd: serverRunnerDir,
-      stdio: "inherit",
-      shell: process.platform === "win32"
-    });
-    if (result.status !== 0) {
-      throw new Error("Failed to install .uipath/server-runner/ dependencies.");
-    } else {
-      console.log("Runtime dependencies installed.");
-    }
+    return;
   }
-  if (!existsSync4(join6(cwd, "node_modules"))) {
-    console.log("Preparing node_modules in package working folder.");
-    let packagesToCopy = ["@uipath/coded-functions-js-sdk"];
-    for (let i = 0;i < packagesToCopy.length; i++) {
-      const packageName = packagesToCopy[i];
-      mkdirSync4(join6(cwd, "node_modules", packageName), { recursive: true });
-      for (const entry of readdirSync(join6(serverRunnerDir, "node_modules", packageName))) {
-        cpSync(join6(serverRunnerDir, "node_modules", packageName, entry), join6(cwd, "node_modules", packageName, entry), { recursive: true });
-      }
+  const pkgJson = JSON.parse(readFileSync4(join7(cwd, "package.json"), "utf-8"));
+  pkgJson.dependencies = buildRunnerDependencies(cwd);
+  writeFileSync6(join7(serverRunnerDir, "package.json"), JSON.stringify(pkgJson, null, 2), "utf-8");
+  console.log("Installing runtime dependencies ...");
+  resolvePackageManager(cwd, packageManager).runInstall(serverRunnerDir, { preferOffline: true });
+  console.log("Runtime dependencies installed.");
+}
+function declaresProductionDependency(cwd, packageName) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync4(join7(cwd, "package.json"), "utf-8"));
+  } catch {
+    return false;
+  }
+  if (typeof parsed !== "object" || parsed === null || !("dependencies" in parsed)) {
+    return false;
+  }
+  const { dependencies } = parsed;
+  if (typeof dependencies !== "object" || dependencies === null) {
+    return false;
+  }
+  return Object.hasOwn(dependencies, packageName);
+}
+function installProjectProductionDependencies(cwd, manager = resolvePackageManager(cwd)) {
+  const serverRunnerDir = join7(cwd, SERVER_RUNNER_DIR);
+  console.log("Installing dependencies in package working folder.");
+  manager.runInstall(cwd, { production: true, preferOffline: true });
+  console.log("Preparing node_modules in package working folder.");
+  const packagesToCopy = ["@uipath/coded-functions-js-sdk"];
+  for (const packageName of packagesToCopy) {
+    if (declaresProductionDependency(cwd, packageName)) {
+      continue;
     }
-    console.log("Installing dependencies in package working folder.");
-    const install = getInstallCommand(true, ["--prefer-offline"]);
-    const result = spawnSync3(install.cmd, install.args, {
-      cwd,
-      stdio: "inherit",
-      shell: process.platform === "win32"
-    });
-    if (result.status !== 0) {
-      throw new Error("Failed to install package working folder dependencies.");
-    } else {
-      console.log("Package working folder dependencies installed.");
+    mkdirSync4(join7(cwd, "node_modules", packageName), { recursive: true });
+    for (const entry of readdirSync(join7(serverRunnerDir, "node_modules", packageName))) {
+      cpSync(join7(serverRunnerDir, "node_modules", packageName, entry), join7(cwd, "node_modules", packageName, entry), { recursive: true });
     }
   }
+  console.log("Package working folder dependencies installed.");
+}
+function provisionPackage(cwd, serverRunnerTemplatePath = "", packageManager) {
+  installServerRunner(cwd, serverRunnerTemplatePath, packageManager);
+  if (!existsSync5(join7(cwd, "node_modules"))) {
+    installProjectProductionDependencies(cwd, resolvePackageManager(cwd, packageManager));
+  }
+}
+function buildRunnerDependencies(cwd) {
+  let runtimeVersion = RUNTIME_VERSION;
+  let tsxVersion = TSX_VERSION;
+  try {
+    const pkgJson = JSON.parse(readFileSync4(join7(cwd, "package.json"), "utf-8"));
+    const allDeps = { ...pkgJson.dependencies ?? {}, ...pkgJson.devDependencies ?? {} };
+    runtimeVersion = allDeps["@uipath/coded-functions-js-runtime"] ?? RUNTIME_VERSION;
+    tsxVersion = allDeps["tsx"] ?? TSX_VERSION;
+  } catch {}
+  return {
+    "@uipath/coded-functions-js-runtime": runtimeVersion,
+    "@uipath/coreipc": COREIPC_VERSION,
+    tsx: tsxVersion,
+    "@microsoft/signalr": SIGNALR_VERSION,
+    "@jridgewell/trace-mapping": TRACE_MAPPING_VERSION
+  };
 }
 function resolveTsx(cwd) {
-  const dbgPkg = join6(cwd, SERVER_RUNNER_DIR, "package.json");
+  const dbgPkg = join7(cwd, SERVER_RUNNER_DIR, "package.json");
   try {
     const tsxPath = createRequire2(dbgPkg).resolve("tsx/cli");
     return ["node", [tsxPath]];
   } catch {
-    return ["npx", ["--yes", "tsx"]];
+    throw new Error(`tsx not found in ${SERVER_RUNNER_DIR}. Run 'uipath-functions install-server' and retry.`);
+  }
+}
+function resolveTsxLoader(cwd) {
+  const dbgPkg = join7(cwd, SERVER_RUNNER_DIR, "package.json");
+  try {
+    return ["--import", pathToFileURL(createRequire2(dbgPkg).resolve("tsx")).href];
+  } catch {
+    return;
+  }
+}
+function resolveDeno() {
+  return process.env.DENO_BINARY ?? (process.platform === "win32" ? "deno.exe" : "deno");
+}
+var denoOnPath;
+function denoAvailable() {
+  denoOnPath ??= spawnSync2(resolveDeno(), ["--version"], {
+    stdio: "ignore",
+    shell: process.platform === "win32"
+  }).status === 0;
+  return denoOnPath;
+}
+
+class ProjectNotInstalledError extends Error {
+  constructor(problem, remedyCommand, cwd) {
+    super(remedyCommand !== null ? `${problem}
+Run '${remedyCommand}' in ${cwd}, then retry.` : `${problem}
+Then retry in ${cwd}.`);
+    this.name = "ProjectNotInstalledError";
   }
 }
+function assert(check, cwd) {
+  if (!check.ready) {
+    throw new ProjectNotInstalledError(check.problem ?? "Project is not installed.", check.remedyCommand, cwd);
+  }
+}
+function assertDependenciesInstalled(cwd) {
+  assert(checkDependenciesInstalled(cwd), cwd);
+}
+function assertReadyToPackage(cwd) {
+  assert(checkDependenciesInstalled(cwd), cwd);
+  assert(checkLockCurrent(cwd), cwd);
+}
 function freePort(port) {
   try {
     let pid = null;
@@ -3058,17 +4049,17 @@ var SIGNAL_READY_DENO = `async function signalReady() {
 var FUNCTIONS_DIR = "functions";
 var SUPPORTED_EXTS = new Set([".ts", ".js"]);
 function syncFunctionsMap(cwd) {
-  const uipathJsonPath = join7(cwd, "uipath.json");
-  const functionsDir = join7(cwd, FUNCTIONS_DIR);
-  if (!existsSync5(uipathJsonPath) || !existsSync5(functionsDir))
+  const uipathJsonPath = join8(cwd, "uipath.json");
+  const functionsDir = join8(cwd, FUNCTIONS_DIR);
+  if (!existsSync6(uipathJsonPath) || !existsSync6(functionsDir))
     return false;
   const discovered = discoverFunctions(functionsDir);
-  const uipathJson = JSON.parse(readFileSync4(uipathJsonPath, "utf-8"));
+  const uipathJson = JSON.parse(readFileSync5(uipathJsonPath, "utf-8"));
   const existing = uipathJson.functions ?? {};
   if (mapsEqual(existing, discovered))
     return false;
   uipathJson.functions = Object.fromEntries(Object.keys(discovered).sort().map((k) => [k, discovered[k]]));
-  writeFileSync6(uipathJsonPath, JSON.stringify(uipathJson, null, 2) + `
+  writeFileSync7(uipathJsonPath, JSON.stringify(uipathJson, null, 2) + `
 `, "utf-8");
   return true;
 }
@@ -3077,7 +4068,7 @@ function discoverFunctions(functionsDir) {
   for (const entry of readdirSync2(functionsDir, { withFileTypes: true })) {
     if (!isFunctionFile(entry))
       continue;
-    const ext = extname2(entry.name);
+    const ext = extname3(entry.name);
     const key = entry.name.slice(0, -ext.length);
     discovered[key] = `${FUNCTIONS_DIR}/${entry.name}:default`;
   }
@@ -3087,7 +4078,7 @@ function isFunctionFile(entry) {
   if (!entry.isFile() || entry.name.startsWith("_") || entry.name.endsWith(".d.ts")) {
     return false;
   }
-  return SUPPORTED_EXTS.has(extname2(entry.name));
+  return SUPPORTED_EXTS.has(extname3(entry.name));
 }
 function mapsEqual(a, b) {
   const ak = Object.keys(a);
@@ -3098,29 +4089,40 @@ function registerServeCommand(program2) {
   program2.command("serve").description("Start local function server with hot reload.").option("--runtime <runtime>", "Runtime: node (default) or deno", "node").option("--port <port>", "Port to listen on", String(DEFAULT_PORT)).option("--production", "Run under production context and skip .uipath/server-runner install if already exists; also skip freePort check.").action(async (opts) => {
     const cwd = resolve3(".");
     const port = parseInt(opts.port, 10) || DEFAULT_PORT;
-    const uipathJsonPath = join8(cwd, "uipath.json");
-    if (!existsSync6(uipathJsonPath)) {
+    const uipathJsonPath = join9(cwd, "uipath.json");
+    if (!existsSync7(uipathJsonPath)) {
       console.error("No uipath.json found. Run 'uipath-functions init' first.");
       process.exit(1);
     }
     if (syncFunctionsMap(cwd)) {
       console.log("Updated functions map in uipath.json.");
     }
-    const uipathJson = JSON.parse(readFileSync5(uipathJsonPath, "utf-8"));
+    const uipathJson = JSON.parse(readFileSync6(uipathJsonPath, "utf-8"));
     if (!uipathJson.functions || Object.keys(uipathJson.functions).length === 0) {
       console.error("No functions defined in uipath.json. Add at least one function.");
       process.exit(1);
     }
-    const skipInstall = opts.production === true && existsSync6(join8(cwd, SERVER_RUNNER_DIR));
+    if (opts.production !== true) {
+      try {
+        assertDependenciesInstalled(cwd);
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    }
+    const extraction = extractProject(uipathJson.functions, cwd);
+    if (opts.production !== true)
+      reportDiagnosticsOrExit(extraction.diagnostics);
+    const skipInstall = opts.production === true && existsSync7(join9(cwd, SERVER_RUNNER_DIR));
     if (!skipInstall) {
       try {
-        setupRunDependencies(cwd);
+        installServerRunner(cwd);
       } catch (err) {
         console.error(err instanceof Error ? err.message : String(err));
         process.exit(1);
       }
     }
-    const derived = deriveMarkerContracts(uipathJson.functions, cwd);
+    const derived = toDerivedContracts(extraction.functions);
     const aggregatorPath = generateAggregator(uipathJson.functions, cwd, "serve", derived);
     if (opts.production !== true) {
       freePort(port);
@@ -3129,42 +4131,67 @@ function registerServeCommand(program2) {
     if (opts.production !== true) {
       process.env[DESIGN_TIME_ENV] = "1";
     }
+    const production = opts.production === true;
     if (opts.runtime === "deno") {
-      serveDeno(cwd, port, aggregatorPath);
+      serveDeno(cwd, port, aggregatorPath, production);
     } else {
-      serveNode(cwd, port, aggregatorPath);
+      serveNode(cwd, port, aggregatorPath, production);
     }
   });
 }
-function serveNode(cwd, port, aggregatorPath) {
-  const nodeEntryPath = join8(cwd, SERVER_RUNNER_DIR, "serve-node.ts");
-  const aggregatorFile = basename(aggregatorPath);
-  writeFileSync7(nodeEntryPath, `import { serve } from "@hono/node-server";
+function tsxServeArgs(entryPath, opts) {
+  return [
+    ...opts.production ? [] : ["watch"],
+    ...opts.envFile ? [`--env-file=${opts.envFile}`] : [],
+    entryPath
+  ];
+}
+function denoServeArgs(entryPath, opts) {
+  return [
+    "run",
+    "--allow-env",
+    "--allow-net",
+    "--allow-read",
+    "--allow-write",
+    ...opts.production ? [] : ["--watch"],
+    ...opts.envFile ? [`--env-file=${opts.envFile}`] : [],
+    entryPath
+  ];
+}
+function serveNode(cwd, port, aggregatorPath, production) {
+  const nodeEntryPath = join9(cwd, SERVER_RUNNER_DIR, "serve-node.ts");
+  const aggregatorFile = basename3(aggregatorPath);
+  writeFileSync8(nodeEntryPath, `import { serveNode } from "@uipath/coded-functions-js-runtime/node";
 ` + `import app from "./${aggregatorFile}";
 ` + `const port = Number(process.env.HTTP_SERVER_LISTEN_PORT ?? ${port});
 ` + `console.log("http://localhost:" + port);
 ` + `${SIGNAL_READY_NODE}
-` + `serve(
-        {
-          fetch: app.fetch,
-          port,
-        },
-        (info) => {
-          console.log(\`JS function node server listening on http://127.0.0.1:\${info.port}\`);
-          signalReady();
-        });
+` + `serveNode(app, port, (port) => {
+        console.log(\`JS function node server listening on http://127.0.0.1:\${port}\`);
+        signalReady();
+      });
 `, "utf-8");
-  const envFile = join8(cwd, ".env");
-  const envFileArgs = existsSync6(envFile) ? [`--env-file=${envFile}`] : [];
-  const [bin, tsxPrefix] = resolveTsx(cwd);
-  const proc = spawn(bin, [...tsxPrefix, "watch", ...envFileArgs, nodeEntryPath], {
+  const envFile = join9(cwd, ".env");
+  let bin;
+  let tsxPrefix;
+  try {
+    [bin, tsxPrefix] = resolveTsx(cwd);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  const tsxArgs = tsxServeArgs(nodeEntryPath, {
+    production,
+    envFile: existsSync7(envFile) ? envFile : undefined
+  });
+  const proc = spawn(bin, [...tsxPrefix, ...tsxArgs], {
     cwd,
     env: { ...process.env, HTTP_SERVER_LISTEN_PORT: String(port) },
     stdio: "inherit"
   });
   proc.on("error", (err) => {
     if (err.code === "ENOENT")
-      console.error("npx/tsx not found. Run 'uipath-functions setup'.");
+      console.error("node not found. Run 'uipath-functions setup'.");
     else
       console.error(err);
     process.exit(1);
@@ -3172,9 +4199,9 @@ function serveNode(cwd, port, aggregatorPath) {
   proc.on("exit", (code) => process.exit(code ?? 0));
 }
 function writeDenoServeEntry(cwd, port, aggregatorPath) {
-  const denoEntryPath = join8(cwd, SERVER_RUNNER_DIR, "serve-deno.ts");
-  const aggregatorFile = basename(aggregatorPath);
-  writeFileSync7(denoEntryPath, `import app from "./${aggregatorFile}";
+  const denoEntryPath = join9(cwd, SERVER_RUNNER_DIR, "serve-deno.ts");
+  const aggregatorFile = basename3(aggregatorPath);
+  writeFileSync8(denoEntryPath, `import app from "./${aggregatorFile}";
 ` + `const port = Number(Deno.env.get("HTTP_SERVER_LISTEN_PORT") ?? ${port});
 ` + `console.log("http://localhost:" + port);
 ` + `${SIGNAL_READY_DENO}
@@ -3184,24 +4211,18 @@ function writeDenoServeEntry(cwd, port, aggregatorPath) {
         onListen: () => {
           console.log(\`JS function deno server listening on http://127.0.0.1:\${port}\`);
           signalReady();
-        }
-      }, app.fetch);
-`, "utf-8");
-  return denoEntryPath;
-}
-function serveDeno(cwd, port, aggregatorPath) {
-  const denoEntryPath = writeDenoServeEntry(cwd, port, aggregatorPath);
-  const denoArgs = [
-    "run",
-    "--allow-env",
-    "--allow-net",
-    "--allow-read",
-    "--allow-write",
-    "--watch",
-    ...existsSync6(join8(cwd, ".env")) ? ["--env-file=.env"] : [],
-    denoEntryPath
-  ];
-  const deno = process.env.DENO_BINARY ?? (process.platform === "win32" ? "deno.exe" : "deno");
+        }
+      }, app.fetch);
+`, "utf-8");
+  return denoEntryPath;
+}
+function serveDeno(cwd, port, aggregatorPath, production) {
+  const denoEntryPath = writeDenoServeEntry(cwd, port, aggregatorPath);
+  const denoArgs = denoServeArgs(denoEntryPath, {
+    production,
+    envFile: existsSync7(join9(cwd, ".env")) ? ".env" : undefined
+  });
+  const deno = resolveDeno();
   const proc = spawn(deno, denoArgs, {
     cwd,
     env: { ...process.env, HTTP_SERVER_LISTEN_PORT: String(port) },
@@ -3312,7 +4333,25 @@ for (i = 0;i < 32; ++i)
   fdt[i] = 5;
 var i;
 var flm = /* @__PURE__ */ hMap(flt, 9, 0);
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
 var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m = a[0];
+  for (var i2 = 1;i2 < a.length; ++i2) {
+    if (a[i2] > m)
+      m = a[i2];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
 var shft = function(p) {
   return (p + 7) / 8 | 0;
 };
@@ -3348,6 +4387,147 @@ var err = function(ind, msg, nt) {
     throw e;
   return e;
 };
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i2 = 0;i2 < hcLen; ++i2) {
+          clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i2 = 0;i2 < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i2++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i2++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (;; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i2 = sym - 257, b = fleb[i2];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i2];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (;bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (;bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
 var wbits = function(d, p, v) {
   v <<= p & 7;
   var o = p / 8 | 0;
@@ -3695,6 +4875,15 @@ var mrg = function(a, b) {
     o[k] = b[k];
   return o;
 };
+var b2 = function(d, b) {
+  return d[b] | d[b + 1] << 8;
+};
+var b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var b8 = function(d, b) {
+  return b4(d, b) + b4(d, b + 4) * 4294967296;
+};
 var wbytes = function(d, b, v) {
   for (;v; ++b)
     d[b] = v, v >>>= 8;
@@ -3702,6 +4891,9 @@ var wbytes = function(d, b, v) {
 function deflateSync(data, opts) {
   return dopt(data, opts || {}, 0, 0);
 }
+function inflateSync(data, opts) {
+  return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
 var fltn = function(d, p, t, o) {
   for (var k in d) {
     var val = d[k], n = p + k, op = o;
@@ -3722,6 +4914,22 @@ try {
   td.decode(et, { stream: true });
   tds = 1;
 } catch (e) {}
+var dutf8 = function(d) {
+  for (var r = "", i2 = 0;; ) {
+    var c = d[i2++];
+    var eb = (c > 127) + (c > 223) + (c > 239);
+    if (i2 + eb > d.length)
+      return { s: r, r: slc(d, i2 - 1) };
+    if (!eb)
+      r += String.fromCharCode(c);
+    else if (eb == 3) {
+      c = ((c & 15) << 18 | (d[i2++] & 63) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+    } else if (eb & 1)
+      r += String.fromCharCode((c & 31) << 6 | d[i2++] & 63);
+    else
+      r += String.fromCharCode((c & 15) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63);
+  }
+};
 function strToU8(str, latin1) {
   if (latin1) {
     var ar_1 = new u8(str.length);
@@ -3755,6 +4963,48 @@ function strToU8(str, latin1) {
   }
   return slc(ar, 0, ai);
 }
+function strFromU8(dat, latin1) {
+  if (latin1) {
+    var r = "";
+    for (var i2 = 0;i2 < dat.length; i2 += 16384)
+      r += String.fromCharCode.apply(null, dat.subarray(i2, i2 + 16384));
+    return r;
+  } else if (td) {
+    return td.decode(dat);
+  } else {
+    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+    if (r.length)
+      err(8);
+    return s;
+  }
+}
+var slzh = function(d, b) {
+  return b + 30 + b2(d, b + 26) + b2(d, b + 28);
+};
+var zh = function(d, b, z) {
+  var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
+  var _a2 = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
+  return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
+};
+var z64hs = function(d, b, l, z, sc, su, off) {
+  var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
+  var nf = nsc + nsu + noff;
+  if (z && nf) {
+    for (;b + 4 < e; b += 4 + b2(d, b + 2)) {
+      if (b2(d, b) == 1) {
+        return [
+          nsc ? b8(d, b + 4 + 8 * nsu) : sc,
+          nsu ? b8(d, b + 4) : su,
+          noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off,
+          1
+        ];
+      }
+    }
+    if (z < 2)
+      err(13);
+  }
+  return [sc, su, off, 0];
+};
 var exfl = function(ex) {
   var le = 0;
   if (ex) {
@@ -3856,6 +5106,46 @@ function zipSync(data, opts) {
   wzf(out, o, files.length, cdl, oe);
   return out;
 }
+function unzipSync(data, opts) {
+  var files = {};
+  var e = data.length - 22;
+  for (;b4(data, e) != 101010256; --e) {
+    if (!e || data.length - e > 65558)
+      err(13);
+  }
+  var c = b2(data, e + 8);
+  if (!c)
+    return {};
+  var o = b4(data, e + 16);
+  var z = b4(data, e - 20) == 117853008;
+  if (z) {
+    var ze = b4(data, e - 12);
+    z = b4(data, ze) == 101075792;
+    if (z) {
+      c = b4(data, ze + 32);
+      o = b4(data, ze + 48);
+    }
+  }
+  var fltr = opts && opts.filter;
+  for (var i2 = 0;i2 < c; ++i2) {
+    var _a2 = zh(data, o, z), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+    o = no;
+    if (!fltr || fltr({
+      name: fn,
+      size: sc,
+      originalSize: su,
+      compression: c_2
+    })) {
+      if (!c_2)
+        files[fn] = slc(data, b, b + sc);
+      else if (c_2 == 8)
+        files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+      else
+        err(14, "unknown compression type " + c_2);
+    }
+  }
+  return files;
+}
 var isDockerCached;
 function hasDockerEnv() {
   try {
@@ -4427,324 +5717,91 @@ class NodeFileSystem {
       }
       return await fs6.readFile(path3);
     } catch (error) {
-      if (this.isEnoent(error))
-        return null;
-      throw error;
-    }
-  }
-  async writeFile(filePath, data) {
-    const dir = path2.dirname(filePath);
-    if (dir) {
-      await fs6.mkdir(dir, { recursive: true });
-    }
-    await fs6.writeFile(filePath, data);
-  }
-  async readdir(dirPath) {
-    try {
-      return await fs6.readdir(dirPath);
-    } catch (error) {
-      if (this.isEnoent(error))
-        return [];
-      throw error;
-    }
-  }
-  async stat(filePath) {
-    try {
-      const stats = await fs6.stat(filePath);
-      return {
-        isFile: () => stats.isFile(),
-        isDirectory: () => stats.isDirectory(),
-        size: stats.size,
-        mtimeMs: stats.mtimeMs
-      };
-    } catch (error) {
-      if (this.isEnoent(error))
-        return null;
-      throw error;
-    }
-  }
-  async exists(filePath) {
-    return existsSync7(filePath);
-  }
-  async mkdir(dirPath) {
-    await fs6.mkdir(dirPath, { recursive: true });
-  }
-  async rm(filePath) {
-    await fs6.rm(filePath, { recursive: true, force: true });
-  }
-  async rename(oldPath, newPath) {
-    await fs6.rename(oldPath, newPath);
-  }
-  async getTempDir() {
-    return await fs6.mkdtemp(path2.join(os2.tmpdir(), "uipath-fs-"));
-  }
-  async copyDirectory(sourcePath, destPath) {
-    const sourceStats = await this.stat(sourcePath);
-    if (!sourceStats) {
-      throw new Error(`Source directory does not exist: ${sourcePath}`);
-    }
-    if (!sourceStats.isDirectory()) {
-      throw new Error(`Source path is not a directory: ${sourcePath}`);
-    }
-    await this.mkdir(destPath);
-    const entries = await this.readdir(sourcePath);
-    for (const entry of entries) {
-      const srcEntry = path2.join(sourcePath, entry);
-      const destEntry = path2.join(destPath, entry);
-      const entryStats = await this.stat(srcEntry);
-      if (!entryStats)
-        continue;
-      if (entryStats.isDirectory()) {
-        await this.copyDirectory(srcEntry, destEntry);
-      } else if (entryStats.isFile()) {
-        const content = await this.readFile(srcEntry);
-        if (content !== null) {
-          await this.writeFile(destEntry, content);
-        }
-      }
-    }
-  }
-  isEnoent(error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-  }
-}
-var fsInstance = new NodeFileSystem;
-var getFileSystem = () => {
-  return fsInstance;
-};
-var EXCLUDED_NAMES = new Set([
-  "node_modules",
-  ".git",
-  ".env",
-  ".deno",
-  "dist",
-  ".uipath"
-]);
-var EXCLUDED_EXTENSIONS = [".nupkg"];
-var NPMRC = ".npmrc";
-var UIPATH_SCOPE = "@uipath:";
-var CREDENTIAL_KEYS = ["_authtoken", "_auth", "_password"];
-function isComment(line) {
-  return line === "" || line.startsWith("#") || line.startsWith(";");
-}
-function isOurs(line) {
-  const trimmed = line.trim();
-  if (isComment(trimmed))
-    return false;
-  const key = (trimmed.split("=")[0] ?? "").trim().toLowerCase();
-  return key.startsWith(UIPATH_SCOPE) || CREDENTIAL_KEYS.some((c) => key.endsWith(c));
-}
-function sanitizeNpmrc(content) {
-  const kept = content.split(/\r?\n/).filter((line) => !isOurs(line));
-  return kept.some((line) => !isComment(line.trim())) ? kept.join(`
-`) : null;
-}
-var LOCK_FILES = new Set(["bun.lock", "package-lock.json", "deno.lock", "yarn.lock"]);
-async function buildFunctionsPackage(fs7, options) {
-  const { projectPath, outputPath, projectStorageId } = options;
-  const contentPath = fs7.path.join(outputPath, "content");
-  await fs7.mkdir(outputPath);
-  await fs7.mkdir(contentPath);
-  const uipathJsonRaw = await fs7.readFile(fs7.path.join(projectPath, "uipath.json"), "utf-8");
-  if (!uipathJsonRaw) {
-    throw new Error("uipath.json not found. Run 'uipath-functions init' first.");
-  }
-  const uipathJson = JSON.parse(uipathJsonRaw);
-  const entryPointsRaw = await fs7.readFile(fs7.path.join(projectPath, "entry-points.json"), "utf-8");
-  if (!entryPointsRaw) {
-    throw new Error("entry-points.json not found. Run 'uipath-functions pack' to generate it.");
-  }
-  const entryPoints = JSON.parse(entryPointsRaw);
-  const bindingsRaw = await fs7.readFile(fs7.path.join(projectPath, "bindings_v2.json"), "utf-8");
-  if (!bindingsRaw) {
-    throw new Error("bindings_v2.json not found. Run 'uipath-functions pack' to generate it.");
-  }
-  const bindings = JSON.parse(bindingsRaw);
-  const packageJsonRaw = await fs7.readFile(fs7.path.join(projectPath, "package.json"), "utf-8");
-  const packageDependencies = packageJsonRaw ? JSON.parse(packageJsonRaw).dependencies ?? {} : {};
-  const targetRuntime = detectRuntime(uipathJson.functions);
-  const includeLockFile = options.excludeLockFile ? false : uipathJson.packOptions?.includeLockFile ?? true;
-  await copyProjectFiles(fs7, projectPath, contentPath, includeLockFile, uipathJson.packOptions);
-  const operateJson = {
-    $schema: "https://cloud.uipath.com/draft/2024-12/operate",
-    projectId: projectStorageId,
-    contentType: "function",
-    targetFramework: "Portable",
-    targetRuntime,
-    runtimeOptions: {
-      requiresUserInteraction: false,
-      isAttended: false
-    },
-    deploymentOptions: {
-      generateSlug: true
-    },
-    dependencies: packageDependencies
-  };
-  await fs7.writeFile(fs7.path.join(contentPath, "operate.json"), JSON.stringify(operateJson, null, 2));
-  await fs7.writeFile(fs7.path.join(contentPath, "entry-points.json"), JSON.stringify(entryPoints, null, 2));
-  await fs7.writeFile(fs7.path.join(contentPath, "bindings_v2.json"), JSON.stringify(bindings, null, 2));
-  const packageDescriptor = {
-    $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
-    files: {
-      "operate.json": "content/operate.json",
-      "entry-points.json": "content/entry-points.json",
-      "bindings.json": "content/bindings_v2.json"
-    }
-  };
-  for (const ep of entryPoints.entryPoints) {
-    const fnEntry = uipathJson.functions?.[ep.filePath];
-    const filePath = fnEntry ? fnEntry.split(":")[0] ?? ep.filePath : ep.filePath;
-    packageDescriptor.files[ep.filePath] = `${filePath}`;
-  }
-  await fs7.writeFile(fs7.path.join(contentPath, "package-descriptor.json"), JSON.stringify(packageDescriptor, null, 2));
-}
-function detectRuntime(functions) {
-  if (!functions)
-    return "javascript";
-  const first = Object.values(functions)[0];
-  if (!first)
-    return "javascript";
-  const filePath = first.split(":")[0] ?? "";
-  const ext = filePath.slice(filePath.lastIndexOf("."));
-  if (ext === ".py")
-    return "python";
-  return "javascript";
-}
-async function copyProjectFiles(fs7, sourcePath, destPath, includeLockFile, packOptions) {
-  const extraExcludedDirs = new Set(packOptions?.directoriesExcluded ?? []);
-  const extraExcludedFiles = new Set(packOptions?.filesExcluded ?? []);
-  async function walk(src, dest) {
-    await fs7.mkdir(dest);
-    const entries = await fs7.readdir(src);
-    for (const name of entries) {
-      if (EXCLUDED_NAMES.has(name))
-        continue;
-      if (extraExcludedDirs.has(name))
-        continue;
-      if (extraExcludedFiles.has(name))
-        continue;
-      if (EXCLUDED_EXTENSIONS.some((ext) => name.endsWith(ext)))
-        continue;
-      if (!includeLockFile && LOCK_FILES.has(name))
-        continue;
-      const srcEntry = fs7.path.join(src, name);
-      const destEntry = fs7.path.join(dest, name);
-      const stat2 = await fs7.stat(srcEntry);
-      if (stat2?.isDirectory()) {
-        await walk(srcEntry, destEntry);
-      } else if (name === NPMRC) {
-        const sanitized = sanitizeNpmrc(await fs7.readFile(srcEntry, "utf-8") ?? "");
-        if (sanitized !== null)
-          await fs7.writeFile(destEntry, sanitized);
-      } else if (stat2?.isFile()) {
-        const content = await fs7.readFile(srcEntry);
-        if (content)
-          await fs7.writeFile(destEntry, content);
-      }
+      if (this.isEnoent(error))
+        return null;
+      throw error;
     }
   }
-  await walk(sourcePath, destPath);
-}
-var CONSUMER_COMPILER_OPTIONS2 = {
-  target: ts3.ScriptTarget.ES2020,
-  module: ts3.ModuleKind.ESNext,
-  moduleResolution: ts3.ModuleResolutionKind.Bundler,
-  allowImportingTsExtensions: true,
-  allowJs: true,
-  strict: true,
-  skipLibCheck: true,
-  noEmit: true
-};
-var DIAGNOSTIC_CODES2 = {
-  UNSUPPORTED_VALIDATOR: "unsupported-validator",
-  UNSUPPORTED_TYPE: "unsupported-type",
-  NON_STATIC_LITERAL: "non-static-literal",
-  MISSING_TYPE_ARGUMENT: "missing-type-argument",
-  AMBIGUOUS_ROUTE: "ambiguous-route",
-  MULTIPLE_FUNCTIONS_PER_FILE: "multiple-functions-per-file",
-  DEPRECATED_MARKER: "deprecated-marker"
-};
-function newId() {
-  return globalThis.crypto.randomUUID();
-}
-function buildEntryPointsDoc(functions, existing, filePathPrefix = "content/") {
-  const functionIds = new Map;
-  const transactionRoots = new Set;
-  const preserved = [];
-  for (const ep of existing?.entryPoints ?? []) {
-    if (ep.type === "function") {
-      functionIds.set(ep.filePath, ep.uniqueId);
-      if (ep.isTransactionRoot === true) {
-        transactionRoots.add(ep.filePath);
-      }
-    } else {
-      preserved.push(ep);
+  async writeFile(filePath, data) {
+    const dir = path2.dirname(filePath);
+    if (dir) {
+      await fs6.mkdir(dir, { recursive: true });
     }
+    await fs6.writeFile(filePath, data);
   }
-  const functionEntries = functions.map((fn) => {
-    const filePath = filePathPrefix + (fn.functionPath ?? "");
-    return {
-      filePath,
-      uniqueId: functionIds.get(filePath) ?? newId(),
-      type: "function",
-      input: fn.input ?? { type: "object" },
-      output: fn.output ?? { type: "object" },
-      ...transactionRoots.has(filePath) ? { isTransactionRoot: true } : {}
-    };
-  });
-  return {
-    $schema: "https://cloud.uipath.com/draft/2024-12/entry-point",
-    $id: "entry-points.json",
-    entryPoints: [...preserved, ...functionEntries]
-  };
-}
-function buildBindingsDoc(functions, entryPointIdByPath, existingBindings, filePathPrefix = "content/") {
-  const httpExisting = new Map;
-  const preserved = [];
-  for (const r of existingBindings?.resources ?? []) {
-    if (r.resource === "HttpTrigger") {
-      const meta = r.metadata;
-      if (meta?.Method && meta?.Slug) {
-        httpExisting.set(`${meta.Method}:${meta.Slug}`, { key: r.key, id: r.id });
-      }
-    } else {
-      preserved.push(r);
+  async readdir(dirPath) {
+    try {
+      return await fs6.readdir(dirPath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return [];
+      throw error;
     }
   }
-  const httpTriggers = functions.filter((fn) => fn.method && fn.path).map((fn) => {
-    const existing = httpExisting.get(`${fn.method}:${fn.path}`);
-    const bindingKey = existing?.key ?? newId();
-    const bindingId = existing?.id ?? newId();
-    const entryPointUniqueId = entryPointIdByPath.get(filePathPrefix + (fn.functionPath ?? ""));
-    if (!entryPointUniqueId) {
-      throw new Error(`Internal error: binding for "${fn.method} ${fn.path}" references entry point "${filePathPrefix}${fn.functionPath}", which is missing from entry-points.json.`);
+  async stat(filePath) {
+    try {
+      const stats = await fs6.stat(filePath);
+      return {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        size: stats.size,
+        mtimeMs: stats.mtimeMs
+      };
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
     }
-    return {
-      resource: "HttpTrigger",
-      key: bindingKey,
-      id: bindingId,
-      value: {
-        EntryPointUniqueId: {
-          DefaultValue: entryPointUniqueId,
-          IsExpression: false
+  }
+  async exists(filePath) {
+    return existsSync8(filePath);
+  }
+  async mkdir(dirPath) {
+    await fs6.mkdir(dirPath, { recursive: true });
+  }
+  async rm(filePath) {
+    await fs6.rm(filePath, { recursive: true, force: true });
+  }
+  async rename(oldPath, newPath) {
+    await fs6.rename(oldPath, newPath);
+  }
+  async getTempDir() {
+    return await fs6.mkdtemp(path2.join(os2.tmpdir(), "uipath-fs-"));
+  }
+  async copyDirectory(sourcePath, destPath) {
+    const sourceStats = await this.stat(sourcePath);
+    if (!sourceStats) {
+      throw new Error(`Source directory does not exist: ${sourcePath}`);
+    }
+    if (!sourceStats.isDirectory()) {
+      throw new Error(`Source path is not a directory: ${sourcePath}`);
+    }
+    await this.mkdir(destPath);
+    const entries = await this.readdir(sourcePath);
+    for (const entry of entries) {
+      const srcEntry = path2.join(sourcePath, entry);
+      const destEntry = path2.join(destPath, entry);
+      const entryStats = await this.stat(srcEntry);
+      if (!entryStats)
+        continue;
+      if (entryStats.isDirectory()) {
+        await this.copyDirectory(srcEntry, destEntry);
+      } else if (entryStats.isFile()) {
+        const content = await this.readFile(srcEntry);
+        if (content !== null) {
+          await this.writeFile(destEntry, content);
         }
-      },
-      metadata: {
-        BindingsVersion: "2.1",
-        Name: fn.name ?? "",
-        Method: fn.method,
-        Slug: fn.path,
-        CallingMode: "LongPolling",
-        Description: fn.description ?? ""
       }
-    };
-  });
-  return {
-    $schema: "https://cloud.uipath.com/draft/2024-12/bindings",
-    version: "2.0",
-    resources: [...preserved, ...httpTriggers]
-  };
+    }
+  }
+  isEnoent(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+  }
 }
+var fsInstance = new NodeFileSystem;
+var getFileSystem = () => {
+  return fsInstance;
+};
 function toExtractedFunctions(endpoints) {
   return endpoints.map((e) => ({
     functionPath: e.functionPath,
@@ -4760,20 +5817,20 @@ var tsxRegistered = false;
 async function extractAndWriteEntryPointsAndBindings(aggregatorPath, projectPath) {
   if (!tsxRegistered) {
     try {
-      const dbgPkg = join10(projectPath, SERVER_RUNNER_DIR, "package.json");
+      const dbgPkg = join11(projectPath, SERVER_RUNNER_DIR, "package.json");
       const tsxEsm = createRequire4(dbgPkg).resolve("tsx/esm");
-      register(pathToFileURL(tsxEsm).href, pathToFileURL(join10(projectPath, SERVER_RUNNER_DIR) + "/").href);
+      register(pathToFileURL2(tsxEsm).href, pathToFileURL2(join11(projectPath, SERVER_RUNNER_DIR) + "/").href);
       tsxRegistered = true;
     } catch {}
   }
   let app;
   try {
-    const mod = await import(pathToFileURL(aggregatorPath).href);
+    const mod = await import(pathToFileURL2(aggregatorPath).href);
     app = mod.default;
   } catch (err2) {
     const msg = err2 instanceof Error ? err2.message : String(err2);
     if (msg.includes("Cannot find") || msg.includes("ERR_MODULE_NOT_FOUND")) {
-      throw new Error("Failed to load function modules. Run 'npm install' first, then retry.");
+      throw new Error(`Failed to load function modules. Run '${describeInstallCommand(projectPath)}' first, then retry.`);
     }
     throw new Error(`Manifest extraction failed.
 ${msg}`);
@@ -4789,40 +5846,47 @@ ${msg}`);
   return manifest;
 }
 function writeEntryPointsAndBindings(functions, projectPath) {
-  const epPath = join10(projectPath, "entry-points.json");
+  const epPath = join11(projectPath, "entry-points.json");
   let existingEntryPointsDoc = null;
-  if (existsSync8(epPath)) {
+  if (existsSync9(epPath)) {
     try {
-      existingEntryPointsDoc = JSON.parse(readFileSync6(epPath, "utf-8"));
+      existingEntryPointsDoc = JSON.parse(readFileSync7(epPath, "utf-8"));
     } catch {}
   }
   const entryPointsDoc = buildEntryPointsDoc(functions, existingEntryPointsDoc);
-  writeFileSync8(join10(projectPath, "entry-points.json"), JSON.stringify(entryPointsDoc, null, 2));
+  writeFileSync9(join11(projectPath, "entry-points.json"), JSON.stringify(entryPointsDoc, null, 2));
   const entryPointIdByPath = new Map;
   for (const ep of entryPointsDoc.entryPoints) {
     if (ep.type === "function" && !entryPointIdByPath.has(ep.filePath)) {
       entryPointIdByPath.set(ep.filePath, ep.uniqueId);
     }
   }
-  const bindingsPath = join10(projectPath, "bindings_v2.json");
+  const bindingsPath = join11(projectPath, "bindings_v2.json");
   let existingBindingsDoc = null;
-  if (existsSync8(bindingsPath)) {
+  if (existsSync9(bindingsPath)) {
     try {
-      existingBindingsDoc = JSON.parse(readFileSync6(bindingsPath, "utf-8"));
+      existingBindingsDoc = JSON.parse(readFileSync7(bindingsPath, "utf-8"));
     } catch {}
   }
   const bindingsDoc = buildBindingsDoc(functions, entryPointIdByPath, existingBindingsDoc);
-  writeFileSync8(join10(projectPath, "bindings_v2.json"), JSON.stringify(bindingsDoc, null, 2));
+  writeFileSync9(join11(projectPath, "bindings_v2.json"), JSON.stringify(bindingsDoc, null, 2));
 }
-async function writeManifest(extraction, aggregatorPath, projectPath) {
-  const needsExecution = extraction.diagnostics.some((d) => d.code === DIAGNOSTIC_CODES2.UNSUPPORTED_VALIDATOR);
-  for (const d of extraction.diagnostics) {
-    if (d.code === DIAGNOSTIC_CODES2.UNSUPPORTED_VALIDATOR)
-      continue;
-    const where = [d.functionName, d.field].filter(Boolean).join(".");
-    console.warn(`  Warning${where ? ` (${where})` : ""}: ${d.message}`);
+function manifestNeedsExecution(extraction, functionsMap) {
+  const forcesExecution = new Set([
+    DIAGNOSTIC_CODES2.UNSUPPORTED_VALIDATOR,
+    DIAGNOSTIC_CODES2.UNREADABLE_PROPERTY,
+    DIAGNOSTIC_CODES2.NON_STATIC_LITERAL
+  ]);
+  if (extraction.diagnostics.some((d) => forcesExecution.has(d.code))) {
+    return true;
   }
-  if (needsExecution) {
+  if (!functionsMap)
+    return false;
+  const covered = new Set(extraction.functions.map((f) => f.functionPath));
+  return Object.values(functionsMap).some((v) => !covered.has(v.split(":")[0]));
+}
+async function writeManifest(extraction, aggregatorPath, projectPath, functionsMap) {
+  if (manifestNeedsExecution(extraction, functionsMap)) {
     const manifest = await extractAndWriteEntryPointsAndBindings(aggregatorPath, projectPath);
     return { count: manifest.endpoints.length, static: false };
   }
@@ -4834,34 +5898,34 @@ async function writeManifest(extraction, aggregatorPath, projectPath) {
   return { count: functions.length, static: true };
 }
 async function generateManifests(projectPath) {
-  const uipathJsonPath = join11(projectPath, "uipath.json");
-  if (!existsSync9(uipathJsonPath)) {
+  const uipathJsonPath = join12(projectPath, "uipath.json");
+  if (!existsSync10(uipathJsonPath)) {
     throw new Error("No uipath.json found. Run 'uipath-functions init' first.");
   }
   if (syncFunctionsMap(projectPath)) {
     console.log("Updated functions map in uipath.json.");
   }
-  const uipathJson = JSON.parse(readFileSync7(uipathJsonPath, "utf-8"));
+  const uipathJson = JSON.parse(readFileSync8(uipathJsonPath, "utf-8"));
   if (!uipathJson.functions || Object.keys(uipathJson.functions).length === 0) {
     throw new Error("No functions defined in uipath.json.");
   }
-  let bootstrapped = false;
-  if (!existsSync9(join11(projectPath, "node_modules"))) {
-    setupRunDependencies(projectPath);
-    bootstrapped = true;
-  }
+  assertReadyToPackage(projectPath);
   const previousDesignTime = process.env[DESIGN_TIME_ENV];
   process.env[DESIGN_TIME_ENV] = "1";
   try {
-    console.log("Generating aggregator...");
     const extraction = extractProject(uipathJson.functions, projectPath);
+    const blocking = reportDiagnostics(extraction.diagnostics);
+    if (blocking > 0) {
+      throw new Error(`${blocking} error(s) in the project's function files — nothing was written. ` + `Fix them and re-run.`);
+    }
+    console.log("Generating aggregator...");
     const aggregatorPath = generateAggregator(uipathJson.functions, projectPath, "serve", toDerivedContracts(extraction.functions));
-    const needsExecution = extraction.diagnostics.some((d) => d.code === DIAGNOSTIC_CODES2.UNSUPPORTED_VALIDATOR);
-    if (needsExecution && !bootstrapped) {
-      setupRunDependencies(projectPath);
+    const needsExecution = manifestNeedsExecution(extraction, uipathJson.functions);
+    if (needsExecution) {
+      installServerRunner(projectPath);
     }
     console.log("Extracting function manifest...");
-    return await writeManifest(extraction, aggregatorPath, projectPath);
+    return await writeManifest(extraction, aggregatorPath, projectPath, uipathJson.functions);
   } finally {
     if (previousDesignTime === undefined) {
       delete process.env[DESIGN_TIME_ENV];
@@ -4871,8 +5935,11 @@ async function generateManifests(projectPath) {
   }
 }
 function registerPackCommand(program2) {
-  program2.command("pack").description("Pack the project into a .nupkg for deployment.").option("--nolock", "Exclude lock file from package").action(async (opts) => {
+  program2.command("pack").description("Pack the project into a .nupkg for deployment.").option("--nolock", "Deprecated and ignored: the project's lock file is always packaged").action(async (opts) => {
     const cwd = resolve5(".");
+    if (opts.nolock) {
+      console.warn("--nolock is ignored: the project's lock file is always packaged, the pod installs from it.");
+    }
     try {
       const result = await generateManifests(cwd);
       console.log(`  ${result.count} function(s) — ${result.static ? "extracted statically" : "executed to extract"}.`);
@@ -4880,24 +5947,23 @@ function registerPackCommand(program2) {
       console.error(err2 instanceof Error ? err2.message : String(err2));
       process.exit(1);
     }
-    const uipathJsonPath = join12(cwd, "uipath.json");
-    const uipathJson = JSON.parse(readFileSync8(uipathJsonPath, "utf-8"));
-    const packageJson = JSON.parse(readFileSync8(join12(cwd, "package.json"), "utf-8"));
+    const uipathJsonPath = join13(cwd, "uipath.json");
+    const uipathJson = JSON.parse(readFileSync9(uipathJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync9(join13(cwd, "package.json"), "utf-8"));
     const packageId = (packageJson.name ?? "functions").replace(/[^a-zA-Z0-9._-]/g, "") || "functions";
     const version = packageJson.version ?? "1.0.0";
     if (!uipathJson.projectId) {
       uipathJson.projectId = randomUUID();
-      writeFileSync9(uipathJsonPath, JSON.stringify(uipathJson, null, 2), "utf-8");
+      writeFileSync10(uipathJsonPath, JSON.stringify(uipathJson, null, 2), "utf-8");
     }
     console.log("Assembling package...");
-    const outputDir = join12(cwd, ".uipath", "package-build");
+    const outputDir = join13(cwd, ".uipath", "package-build");
     mkdirSync5(outputDir, { recursive: true });
     const fs7 = getFileSystem();
     await buildFunctionsPackage(fs7, {
       projectPath: cwd,
       outputPath: outputDir,
       projectStorageId: uipathJson.projectId,
-      excludeLockFile: opts.nolock,
       package: {
         id: packageId,
         version,
@@ -4917,12 +5983,12 @@ function zipToNupkg(buildDir, cwd, packageId, version) {
   const files = {};
   function walk(dir, prefix) {
     for (const name of readdirSync3(dir)) {
-      const abs = join12(dir, name);
+      const abs = join13(dir, name);
       const rel = prefix ? `${prefix}/${name}` : name;
       if (statSync(abs).isDirectory()) {
         walk(abs, rel);
       } else {
-        files[rel] = new Uint8Array(readFileSync8(abs));
+        files[rel] = new Uint8Array(readFileSync9(abs));
       }
     }
   }
@@ -4932,15 +5998,31 @@ function zipToNupkg(buildDir, cwd, packageId, version) {
   files["[Content_Types].xml"] = enc.encode(`<?xml version="1.0" encoding="utf-8"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="nuspec" ContentType="application/octet"/><Default Extension="ts" ContentType="application/octet"/><Default Extension="js" ContentType="application/octet"/><Default Extension="json" ContentType="application/octet"/></Types>`);
   files["_rels/.rels"] = enc.encode(`<?xml version="1.0" encoding="utf-8"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Type="http://schemas.microsoft.com/packaging/2010/07/manifest" Target="/${packageId}.nuspec" Id="Rd1"/></Relationships>`);
   const zipped = zipSync(files);
-  mkdirSync5(join12(cwd, ".uipath"), { recursive: true });
-  const nupkgPath = join12(cwd, ".uipath", `${packageId}.${version}.nupkg`);
-  writeFileSync9(nupkgPath, zipped);
+  mkdirSync5(join13(cwd, ".uipath"), { recursive: true });
+  const nupkgPath = join13(cwd, ".uipath", `${packageId}.${version}.nupkg`);
+  writeFileSync10(nupkgPath, zipped);
   return nupkgPath;
 }
 var GUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function isGuid(value) {
   return GUID_RE.test(value);
 }
+var CONTENT_PREFIX = "content/";
+function describeNupkgProblem(nupkg) {
+  const packedName = (entryName) => entryName.startsWith(CONTENT_PREFIX) ? entryName.slice(CONTENT_PREFIX.length) : null;
+  let entries;
+  try {
+    entries = unzipSync(nupkg, {
+      filter: (file) => {
+        const name = packedName(file.name);
+        return name !== null && affectsDependencyInstall(name);
+      }
+    });
+  } catch {
+    return "is not a valid .nupkg archive.";
+  }
+  return describePackagedInstallProblem(Object.keys(entries).flatMap((name) => packedName(name) ?? []));
+}
 async function fetchProcessFeeds(baseUrl, org, tenant, token) {
   const url = `${baseUrl}/${org}/${tenant}/orchestrator_/api/PackageFeeds/GetFeeds`;
   const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
@@ -5016,8 +6098,8 @@ Publish cancelled.
 function registerPublishCommand(program2) {
   program2.command("publish").description("Upload the packed .nupkg to an Orchestrator feed. Fetches available feeds and prompts for selection; press ESC to cancel.").option("--url <url>", "UiPath platform base URL (or UIPATH_URL env)").option("--org <org>", "Organization name (or UIPATH_ORGANIZATION_NAME env)").option("--tenant <tenant>", "Tenant name (or UIPATH_TENANT_NAME env)").option("--token <token>", "Access token (or UIPATH_ACCESS_TOKEN env)").option("--feed-id <id>", "Feed ID — skips the interactive picker (for CI use)").action(async (opts) => {
     const cwd = resolve6(".");
-    const nupkgDir = join13(cwd, ".uipath");
-    if (!existsSync10(nupkgDir)) {
+    const nupkgDir = join14(cwd, ".uipath");
+    if (!existsSync11(nupkgDir)) {
       console.error("No .uipath/ directory found. Run 'uipath-functions pack' first.");
       process.exit(1);
     }
@@ -5026,8 +6108,13 @@ function registerPublishCommand(program2) {
       console.error("No .nupkg found in .uipath/. Run 'uipath-functions pack' first.");
       process.exit(1);
     }
-    const nupkgFile = nupkgs.map((f) => ({ name: f, mtime: statSync2(join13(nupkgDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime)[0].name;
-    const nupkgPath = join13(nupkgDir, nupkgFile);
+    const nupkgFile = nupkgs.map((f) => ({ name: f, mtime: statSync2(join14(nupkgDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime)[0].name;
+    const nupkgPath = join14(nupkgDir, nupkgFile);
+    const nupkgProblem = describeNupkgProblem(readFileSync10(nupkgPath));
+    if (nupkgProblem) {
+      console.error(`${nupkgFile}: ${nupkgProblem} Run 'uipath-functions pack' again, then publish.`);
+      process.exit(1);
+    }
     const baseUrl = (opts.url ?? process.env["UIPATH_URL"])?.replace(/\/$/, "");
     const org = opts.org ?? process.env["UIPATH_ORGANIZATION_NAME"];
     const tenant = opts.tenant ?? process.env["UIPATH_TENANT_NAME"];
@@ -5073,7 +6160,7 @@ function registerPublishCommand(program2) {
     console.log(`
 Publishing ${nupkgFile} → ${feedLabel}...`);
     const form = new FormData;
-    const blob = new Blob([readFileSync9(nupkgPath)], {
+    const blob = new Blob([readFileSync10(nupkgPath)], {
       type: "application/octet-stream"
     });
     form.append("file", blob, nupkgFile);
@@ -5120,11 +6207,11 @@ function resolveStudioMetadata(opts) {
   };
 }
 function readLocalStudioMetadata(projectDir) {
-  const path3 = join14(projectDir, STUDIO_METADATA_PATH);
-  if (!existsSync11(path3))
+  const path3 = join15(projectDir, STUDIO_METADATA_PATH);
+  if (!existsSync12(path3))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync10(path3, "utf-8"));
+    const parsed = JSON.parse(readFileSync11(path3, "utf-8"));
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       return null;
     }
@@ -5134,9 +6221,9 @@ function readLocalStudioMetadata(projectDir) {
   }
 }
 function writeStudioMetadata(projectDir, metadata) {
-  const path3 = join14(projectDir, STUDIO_METADATA_PATH);
-  mkdirSync6(dirname3(path3), { recursive: true });
-  writeFileSync10(path3, JSON.stringify(metadata, null, 2) + `
+  const path3 = join15(projectDir, STUDIO_METADATA_PATH);
+  mkdirSync6(dirname4(path3), { recursive: true });
+  writeFileSync11(path3, JSON.stringify(metadata, null, 2) + `
 `, "utf-8");
   return path3;
 }
@@ -5161,7 +6248,7 @@ function claim(claims, name) {
 }
 function authorFromPackageJson(projectDir) {
   try {
-    const pkg = JSON.parse(readFileSync10(join14(projectDir, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync11(join15(projectDir, "package.json"), "utf-8"));
     if (typeof pkg.author === "string")
       return pkg.author.trim();
     return (pkg.author?.email ?? pkg.author?.name ?? "").trim();
@@ -5189,7 +6276,7 @@ var IGNORE_FILES = new Set([
   ".gitignore",
   ".uipathignore",
   ".gitkeep",
-  ".npmrc"
+  REGISTRY_CONFIG_FILE
 ]);
 var TEXT_EXTS = new Set([
   ".ts",
@@ -5229,7 +6316,7 @@ function collectLocalFiles(projectDir) {
         continue;
       if (name.startsWith(".") && IGNORE_FILES.has(name))
         continue;
-      const abs = join15(dir, name);
+      const abs = join16(dir, name);
       const stat2 = statSync3(abs);
       if (stat2.isDirectory()) {
         walk(abs);
@@ -5320,7 +6407,7 @@ async function performStructuralMigration(cfg, lockKey, plan) {
   const form = new FormData;
   form.append("DeletedResources", JSON.stringify(plan.filesToDelete.map((f) => f.id)));
   plan.filesToUpload.forEach((f, i2) => {
-    const content = readFileSync11(f.absolutePath);
+    const content = readFileSync12(f.absolutePath);
     const fileName = f.remotePath.split("/").at(-1);
     form.append(`AddedResources[${i2}].Content`, new Blob([content]), fileName);
     const parentPath = f.remotePath.includes("/") ? f.remotePath.slice(0, f.remotePath.lastIndexOf("/")) : "";
@@ -5328,7 +6415,7 @@ async function performStructuralMigration(cfg, lockKey, plan) {
       form.append(`AddedResources[${i2}].ParentPath`, parentPath);
   });
   plan.filesToUpdate.forEach(({ local, remoteId }, i2) => {
-    const content = readFileSync11(local.absolutePath);
+    const content = readFileSync12(local.absolutePath);
     const fileName = local.remotePath.split("/").at(-1);
     form.append(`ModifiedResources[${i2}].Content`, new Blob([content]), fileName);
     form.append(`ModifiedResources[${i2}].Id`, remoteId);
@@ -5380,7 +6467,7 @@ async function computePlan(cfg, localFiles, structure) {
       plan.filesToUpload.push(lf);
       return;
     }
-    const localContent = readFileSync11(lf.absolutePath);
+    const localContent = readFileSync12(lf.absolutePath);
     const localHash = computeHash(localContent, lf.absolutePath);
     const remoteContent = await downloadFile(cfg, remote.id);
     const remoteHash = computeHash(remoteContent, lf.absolutePath);
@@ -5449,9 +6536,9 @@ async function pushToStudio(cfg, projectDir, localFiles, onProgress) {
   }
 }
 function readPushCredentials(opts) {
-  const envPath = join15(process.cwd(), ".env");
-  if (existsSync12(envPath)) {
-    for (const line of readFileSync11(envPath, "utf-8").split(`
+  const envPath = join16(process.cwd(), ".env");
+  if (existsSync13(envPath)) {
+    for (const line of readFileSync12(envPath, "utf-8").split(`
 `)) {
       if (line.trimStart().startsWith("#"))
         continue;
@@ -5477,21 +6564,23 @@ function readPushCredentials(opts) {
 function registerPushCommand(program2) {
   program2.command("push").description("Sync the project to Studio Web (generate entry-points, diff, upload changed files).").option("--url <url>", "UiPath base URL (or UIPATH_URL in env)").option("--org <org>", "Organization name (or UIPATH_ORGANIZATION_NAME in env)").option("--tenant <tenant>", "Tenant name (or UIPATH_TENANT_NAME in env)").option("--token <token>", "Access token (or UIPATH_ACCESS_TOKEN in env)").option("--project-id <id>", "Studio Web project ID — mandatory (or UIPATH_PROJECT_ID in env)").action(async (opts) => {
     const cwd = resolve7(".");
-    const uipathJsonPath = join16(cwd, "uipath.json");
-    if (!existsSync13(uipathJsonPath)) {
+    const uipathJsonPath = join17(cwd, "uipath.json");
+    if (!existsSync14(uipathJsonPath)) {
       console.error("No uipath.json found. Run 'uipath-functions init' first.");
       process.exit(1);
     }
     if (syncFunctionsMap(cwd)) {
       console.log("Updated functions map in uipath.json.");
     }
-    const uipathJson = JSON.parse(readFileSync12(uipathJsonPath, "utf-8"));
+    const uipathJson = JSON.parse(readFileSync13(uipathJsonPath, "utf-8"));
     if (!uipathJson.functions || Object.keys(uipathJson.functions).length === 0) {
       console.error("No functions defined in uipath.json.");
       process.exit(1);
     }
-    if (!existsSync13(join16(cwd, "node_modules"))) {
-      console.error("node_modules not found. Run 'npm install' first.");
+    try {
+      assertReadyToPackage(cwd);
+    } catch (err2) {
+      console.error(err2 instanceof Error ? err2.message : String(err2));
       process.exit(1);
     }
     const creds = readPushCredentials(opts);
@@ -5502,14 +6591,18 @@ Create the project in Studio Web first to get UIPATH_PROJECT_ID.`);
     }
     if (!uipathJson.projectId) {
       uipathJson.projectId = creds.projectId;
-      writeFileSync11(uipathJsonPath, JSON.stringify(uipathJson, null, 2) + `
+      writeFileSync12(uipathJsonPath, JSON.stringify(uipathJson, null, 2) + `
 `, "utf-8");
     }
     console.log("Generating entry-points.json...");
     const extraction = extractProject(uipathJson.functions, cwd);
+    reportDiagnosticsOrExit(extraction.diagnostics);
     const aggregatorPath = generateAggregator(uipathJson.functions, cwd, "serve", toDerivedContracts(extraction.functions));
+    if (manifestNeedsExecution(extraction, uipathJson.functions)) {
+      installServerRunner(cwd);
+    }
     try {
-      const result = await writeManifest(extraction, aggregatorPath, cwd);
+      const result = await writeManifest(extraction, aggregatorPath, cwd, uipathJson.functions);
       console.log(`  ${result.count} function(s) exported — ${result.static ? "extracted statically" : "executed to extract"}.`);
     } catch (err2) {
       console.error(err2 instanceof Error ? err2.message : String(err2));
@@ -5544,7 +6637,7 @@ function resolveTargetFile(cwd, opts) {
     return null;
   const match = entry.match(/^(.*?):([A-Za-z_$][\w$]*)$/);
   const filePart = match ? match[1] : entry;
-  const abs = isAbsolute2(filePart) ? filePart : resolve8(cwd, filePart);
+  const abs = isAbsolute3(filePart) ? filePart : resolve8(cwd, filePart);
   return relative3(cwd, abs);
 }
 function writeDerivedContract(cwd, opts) {
@@ -5555,9 +6648,9 @@ function writeDerivedContract(cwd, opts) {
     const derived = opts.production ? readBakedContract(relFile, cwd) : deriveRunContract(relFile, cwd);
     if (!derived)
       return "";
-    const outPath = join17(cwd, DERIVED_CONTRACT_FILE);
-    mkdirSync7(join17(cwd, ".uipath/run"), { recursive: true });
-    writeFileSync12(outPath, JSON.stringify(derived), "utf-8");
+    const outPath = join18(cwd, DERIVED_CONTRACT_FILE);
+    mkdirSync7(join18(cwd, ".uipath/run"), { recursive: true });
+    writeFileSync13(outPath, JSON.stringify(derived), "utf-8");
     return outPath;
   } catch (err2) {
     console.error("contract preparation skipped: " + (err2 instanceof Error ? err2.message : String(err2)));
@@ -5565,7 +6658,7 @@ function writeDerivedContract(cwd, opts) {
   }
 }
 function readFunctionsMap(cwd) {
-  const parsed = readJsonIfExists2(join17(cwd, "uipath.json"));
+  const parsed = readJsonIfExists2(join18(cwd, "uipath.json"));
   const functions = isRecord(parsed) ? parsed.functions : undefined;
   if (!isRecord(functions))
     return {};
@@ -5580,32 +6673,58 @@ function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
 function readJsonIfExists2(path3) {
-  if (!existsSync14(path3))
+  if (!existsSync15(path3))
     return null;
   try {
-    return JSON.parse(readFileSync13(path3, "utf-8"));
+    return JSON.parse(readFileSync14(path3, "utf-8"));
   } catch {
     return null;
   }
 }
-var RUN_FUNCTION_CALL = `runFunction({ entrypoint: entrypoint || undefined, function: fn || undefined, input: input || undefined, inputFile: inputFile || undefined, context: context || undefined, contextFile: contextFile || undefined, derivedFile: derivedFile || undefined })`;
-var DENO_ENTRY_CONTENT = `import { runFunction } from "@uipath/coded-functions-js-runtime";
+var RUN_FUNCTION_CALL = `runtime.runFunction({ entrypoint: entrypoint || undefined, function: fn || undefined, input: input || undefined, inputFile: inputFile || undefined, context: context || undefined, contextFile: contextFile || undefined, derivedFile: derivedFile || undefined, ...traced })`;
+var TRACED_OPTIONS = `let traced = {};
+if (env.UIPATH_TRACE_STORE === "1") {
+  if (!runtime.traceStoreOptionsFromEnv) {
+    console.error("trace store: the installed @uipath/coded-functions-js-runtime predates --trace-store (needs >= 0.9.1); spans will not be posted.");
+  } else {
+    traced = runtime.traceStoreOptionsFromEnv(env, (detail) => console.error(\`trace store: ingest failed: \${detail}\`)) ?? {};
+    if (!traced.onSpans) { console.error("trace store: incomplete UIPATH_* trace scope/token; spans will not be posted."); }
+  }
+}`;
+var DENO_ENTRY_CONTENT = `import * as runtime from "@uipath/coded-functions-js-runtime";
 const [entrypoint, fn, input, inputFile, context, contextFile, derivedFile] = Deno.args;
+const env = Deno.env.toObject();
+${TRACED_OPTIONS}
 const exitCode = await ${RUN_FUNCTION_CALL};
 Deno.exit(exitCode);
 `;
-var NODE_ENTRY_CONTENT = `import { runFunction } from "@uipath/coded-functions-js-runtime";
+var NODE_ENTRY_CONTENT = `import * as runtime from "@uipath/coded-functions-js-runtime";
 const [entrypoint, fn, input, inputFile, context, contextFile, derivedFile] = process.argv.slice(2);
+const env = process.env;
+${TRACED_OPTIONS}
 ${RUN_FUNCTION_CALL}
   .then((code) => process.exit(code));
 `;
+var DEFAULT_INSPECTOR_ENDPOINT = "127.0.0.1:9229";
 function registerRunCommand(program2) {
-  program2.command("run").description("Execute a single coded function once (one-shot job) and report the result.").option("--runtime <runtime>", "Runtime: node (default) or deno", "node").option("--entrypoint <path>", "Path to the function file").option("--function <name>", "Function name resolved via uipath.json").option("--input <json>", "JSON input payload", "{}").option("--input-file <path>", "Path to a JSON input file (takes priority over --input)").option("--context <json>", "JSON runtime-context payload (used when --context-file is absent)").option("--context-file <path>", "Path to the runtime-context JSON file (takes priority over --context)").option("--production", "Run under production context; skip the .uipath/server-runner install when it already exists.").action((opts) => {
+  program2.command("run").description("Execute a single coded function once (one-shot job) and report the result.").option("--runtime <runtime>", "Runtime: node (default) or deno", "node").option("--entrypoint <path>", "Path to the function file").option("--function <name>", "Function name resolved via uipath.json").option("--input <json>", "JSON input payload", "{}").option("--input-file <path>", "Path to a JSON input file (takes priority over --input)").option("--context <json>", "JSON runtime-context payload (used when --context-file is absent)").option("--context-file <path>", "Path to the runtime-context JSON file (takes priority over --context)").option("--production", "Run under production context; skip the .uipath/server-runner install when it already exists.").option("--inspect [endpoint]", `Open the V8 inspector on host:port while the function runs (default ${DEFAULT_INSPECTOR_ENDPOINT})`).option("--inspect-wait [endpoint]", `Open the V8 inspector on host:port and wait for a debugger to attach before executing (default ${DEFAULT_INSPECTOR_ENDPOINT})`).option("--trace-store", "Post the run's trace spans to the platform trace store (scope from UIPATH_* env vars + UIPATH_ACCESS_TOKEN)").action(async (opts) => {
     const cwd = resolve9(".");
-    const skipInstall = opts.production === true && existsSync15(join18(cwd, SERVER_RUNNER_DIR));
+    if (opts.inspect && opts.inspectWait) {
+      console.error("Provide only one of --inspect or --inspect-wait.");
+      process.exit(1);
+    }
+    if (opts.production !== true) {
+      try {
+        assertDependenciesInstalled(cwd);
+      } catch (err2) {
+        console.error(err2 instanceof Error ? err2.message : String(err2));
+        process.exit(1);
+      }
+    }
+    const skipInstall = opts.production === true && existsSync16(join19(cwd, SERVER_RUNNER_DIR));
     if (!skipInstall) {
       try {
-        setupRunDependencies(cwd);
+        installServerRunner(cwd);
       } catch (err2) {
         console.error(err2 instanceof Error ? err2.message : String(err2));
         process.exit(1);
@@ -5620,58 +6739,135 @@ function registerRunCommand(program2) {
     }
   });
 }
-function denoPermissionFlags(cwd, production) {
+function inspectorFlags(opts) {
+  const endpoint = (value) => value === true ? DEFAULT_INSPECTOR_ENDPOINT : value;
+  if (opts.inspectWait) {
+    return [`--inspect-wait=${endpoint(opts.inspectWait)}`];
+  }
+  if (opts.inspect) {
+    return [`--inspect=${endpoint(opts.inspect)}`];
+  }
+  return [];
+}
+function runEnv(opts, base = process.env) {
+  const env = { ...base };
+  delete env.UIPATH_TRACE_STORE;
+  return opts.traceStore ? { ...env, UIPATH_TRACE_STORE: "1" } : env;
+}
+function denoPermissionFlags(cwd, production, env = process.env) {
   if (!production) {
     return ["--allow-env", "--allow-net", "--allow-read", "--allow-write", "--allow-sys", "--allow-run"];
   }
-  const jobDir = process.env.JOB_WORKING_DIRECTORY ?? cwd;
+  const jobDir = env.JOB_WORKING_DIRECTORY ?? cwd;
+  const endpoint = env.UIPATH_JOB_API_ENDPOINT_PATH;
+  const writeTargets = endpoint ? [jobDir, endpoint] : [jobDir];
   return [
     "--allow-env",
     "--allow-net",
     "--allow-read",
-    `--allow-write=${jobDir}`,
+    `--allow-write=${writeTargets.join(",")}`,
     "--allow-sys=hostname,cpus,osRelease,systemMemoryInfo"
   ];
 }
+function readIfPresent(path3) {
+  try {
+    return readFileSync15(path3, "utf-8");
+  } catch {
+    return;
+  }
+}
+function removeQuietly(path3) {
+  try {
+    rmSync2(path3, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function writeRunEntry(cwd, fileName, content) {
-  const serverRunnerDir = join18(cwd, SERVER_RUNNER_DIR);
+  const serverRunnerDir = join19(cwd, SERVER_RUNNER_DIR);
   mkdirSync8(serverRunnerDir, { recursive: true });
-  const entryPath = join18(serverRunnerDir, fileName);
-  if (!existsSync15(entryPath)) {
-    const tmp = `${entryPath}.${process.pid}.tmp`;
-    writeFileSync13(tmp, content, "utf-8");
+  const entryPath = join19(serverRunnerDir, fileName);
+  if (readIfPresent(entryPath) === content) {
+    return entryPath;
+  }
+  const tmp = `${entryPath}.${process.pid}.tmp`;
+  try {
+    writeFileSync14(tmp, content, "utf-8");
     renameSync(tmp, entryPath);
+  } catch (err2) {
+    removeQuietly(tmp);
+    if (!existsSync16(entryPath)) {
+      throw err2;
+    }
+    if (readIfPresent(entryPath) !== content) {
+      console.error(`Warning: could not refresh ${entryPath} (${err2 instanceof Error ? err2.message : String(err2)}); running the existing entry.`);
+    }
   }
   return entryPath;
 }
 function runArgs(opts) {
   return [opts.entrypoint ?? "", opts.function ?? "", opts.input ?? "{}", opts.inputFile ?? "", opts.context ?? "", opts.contextFile ?? "", opts.derivedFile ?? ""];
 }
-function onChildExit(proc, missingMessage) {
+var SIGNAL_EXIT_GRACE_MS = 2000;
+function onChildExit(proc, missingMessage, forwardSignals) {
+  let forwarded;
+  if (forwardSignals && process.platform !== "win32") {
+    for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+      process.once(signal, () => {
+        forwarded = signal;
+        proc.kill(signal);
+        setTimeout(() => process.kill(process.pid, signal), SIGNAL_EXIT_GRACE_MS).unref();
+      });
+    }
+  }
   proc.on("error", (err2) => {
     console.error(err2.code === "ENOENT" ? missingMessage : err2);
     process.exit(1);
   });
-  proc.on("exit", (code) => process.exit(code ?? 0));
+  proc.on("exit", (code, signal) => {
+    if (forwarded) {
+      process.kill(process.pid, forwarded);
+      return;
+    }
+    process.exit(code ?? (signal ? 1 : 0));
+  });
 }
 function runDeno(cwd, opts) {
   const entryPath = writeRunEntry(cwd, "run-deno.ts", DENO_ENTRY_CONTENT);
-  const deno = process.env.DENO_BINARY ?? (process.platform === "win32" ? "deno.exe" : "deno");
+  const deno = resolveDeno();
   const denoArgs = [
     "run",
     ...denoPermissionFlags(cwd, opts.production),
     "--no-check",
+    ...inspectorFlags(opts),
     entryPath,
     ...runArgs(opts)
   ];
-  const proc = spawn2(deno, denoArgs, { cwd, env: process.env, stdio: "inherit" });
-  onChildExit(proc, "Deno not found. Ensure DENO_BINARY is set or deno is on PATH.");
+  const proc = spawn2(deno, denoArgs, { cwd, env: runEnv(opts), stdio: "inherit" });
+  onChildExit(proc, "Deno not found. Ensure DENO_BINARY is set or deno is on PATH.", inspectorFlags(opts).length > 0);
+}
+function nodeCommand(cwd, inspector) {
+  const loader = inspector.length > 0 ? resolveTsxLoader(cwd) : undefined;
+  if (loader) {
+    return ["node", [...inspector, ...loader]];
+  }
+  const [bin, tsxPrefix] = resolveTsx(cwd);
+  return [bin, [...tsxPrefix, ...inspector]];
 }
 function runNode(cwd, opts) {
   const entryPath = writeRunEntry(cwd, "run-node.ts", NODE_ENTRY_CONTENT);
-  const [bin, tsxPrefix] = resolveTsx(cwd);
-  const proc = spawn2(bin, [...tsxPrefix, entryPath, ...runArgs(opts)], { cwd, env: process.env, stdio: "inherit" });
-  onChildExit(proc, "tsx not found. Run 'uipath-functions setup'.");
+  const inspector = inspectorFlags(opts);
+  let bin;
+  let prefix;
+  try {
+    [bin, prefix] = nodeCommand(cwd, inspector);
+  } catch (err2) {
+    console.error(err2 instanceof Error ? err2.message : String(err2));
+    process.exit(1);
+  }
+  const proc = spawn2(bin, [...prefix, entryPath, ...runArgs(opts)], { cwd, env: runEnv(opts), stdio: "inherit" });
+  onChildExit(proc, "node not found. Run 'uipath-functions setup'.", inspector.length > 0);
 }
 function registerInvokeCommand(program2) {
   program2.command("invoke <path>").description("Invoke a function against the local serve endpoint over HTTP (dev convenience). Pass the function's HTTP path, e.g. /hello.").option("--port <port>", "Port the local server is running on", "7070").option("--input <json>", "JSON input payload", "{}").action(async (path3, opts) => {
@@ -5707,8 +6903,15 @@ ${err2.message}`);
   });
 }
 function registerPrepareRuntimeCommand(program2) {
-  program2.command("runtime-install").description("Create a runner folder with a package.json and install runtime dependencies.").requiredOption("--path <folder>", "Target folder to create and install into").action((opts) => {
+  program2.command("runtime-install").description("Create a runner folder with a package.json and install runtime dependencies.").requiredOption("--path <folder>", "Target folder to create and install into").addOption(new Option("--package-manager <name-or-path>", "Install with this package manager instead of the folder's own").hideHelp()).action((opts) => {
     const runnerDir = resolve10(opts.path);
+    let manager;
+    try {
+      manager = resolvePackageManager(runnerDir, opts.packageManager);
+    } catch (err2) {
+      console.error(err2 instanceof Error ? err2.message : String(err2));
+      process.exit(1);
+    }
     mkdirSync9(runnerDir, { recursive: true });
     const pkg = {
       name: "runner",
@@ -5717,37 +6920,30 @@ function registerPrepareRuntimeCommand(program2) {
       dependencies: {
         "@uipath/coded-functions-js-runtime": RUNTIME_VERSION,
         "@uipath/coreipc": COREIPC_VERSION,
-        "@hono/node-server": HONO_NODE_VERSION,
         tsx: TSX_VERSION,
         "@microsoft/signalr": SIGNALR_VERSION,
         "@jridgewell/trace-mapping": TRACE_MAPPING_VERSION
       }
     };
-    const pkgPath = join19(runnerDir, "package.json");
-    writeFileSync14(pkgPath, JSON.stringify(pkg, null, 2), "utf-8");
+    const pkgPath = join20(runnerDir, "package.json");
+    writeFileSync15(pkgPath, JSON.stringify(pkg, null, 2), "utf-8");
     console.log(`Wrote ${pkgPath}`);
-    if (process.env["GITHUB_TOKEN"]) {
-      writeFileSync14(join19(runnerDir, ".npmrc"), NPM_RC, "utf-8");
-    }
+    writeRunnerRegistryConfig(runnerDir);
     console.log("Installing dependencies...");
-    const { cmd, args } = getInstallCommand(true);
-    const result = spawnSync4(cmd, args, {
-      cwd: runnerDir,
-      stdio: "inherit",
-      shell: process.platform === "win32"
-    });
-    if (result.status !== 0) {
-      console.error(`${cmd} install failed in ${runnerDir}.`);
+    try {
+      manager.runInstall(runnerDir, { production: true });
+    } catch (err2) {
+      console.error(err2 instanceof Error ? err2.message : String(err2));
       process.exit(1);
     }
     console.log(`Runner ready at ${runnerDir}`);
   });
 }
 function registerInstallServerCommand(program2) {
-  program2.command("install-server").description("Prepare runtime dependencies for running the function server.").option("--template <path>", "Path to the server-runner template folder").action((opts) => {
+  program2.command("install-server").description("Provision a packed project: install the server-runner and, when node_modules is missing, its production dependencies.").option("--template <path>", "Path to the server-runner template folder").addOption(new Option("--package-manager <name-or-path>", "Install with this package manager instead of the project's own").hideHelp()).action((opts) => {
     const cwd = resolve11(".");
     try {
-      setupRunDependencies(cwd, opts.template);
+      provisionPackage(cwd, opts.template, opts.packageManager);
     } catch (err2) {
       console.error(err2 instanceof Error ? err2.message : String(err2));
       process.exit(1);
@@ -5760,27 +6956,27 @@ var DEFAULT_INSPECT = "127.0.0.1:9231";
 var BRIDGE_FILE = "debug-bridge.ts";
 var WORKER_FILE = "debug-job-worker.ts";
 function resolveDebugAssetsDir(moduleUrl) {
-  const moduleDir = dirname4(fileURLToPath2(moduleUrl));
+  const moduleDir = dirname5(fileURLToPath2(moduleUrl));
   const candidates = [
-    join20(moduleDir, "deno-runtime", "debug"),
-    join20(moduleDir, "..", "deno-runtime", "debug"),
-    join20(moduleDir, "..", "..", "deno-runtime", "debug")
+    join21(moduleDir, "deno-runtime", "debug"),
+    join21(moduleDir, "..", "deno-runtime", "debug"),
+    join21(moduleDir, "..", "..", "deno-runtime", "debug")
   ];
   for (const candidate of candidates) {
-    if (existsSync16(join20(candidate, BRIDGE_FILE))) {
+    if (existsSync17(join21(candidate, BRIDGE_FILE))) {
       return candidate;
     }
   }
   throw new Error(`debug assets not found (looked in: ${candidates.join(", ")})`);
 }
 function stageDebugAssets(cwd) {
-  const stagedDir = join20(cwd, SERVER_RUNNER_DIR, "debug");
+  const stagedDir = join21(cwd, SERVER_RUNNER_DIR, "debug");
   mkdirSync10(stagedDir, { recursive: true });
   const assetsDir = resolveDebugAssetsDir(import.meta.url);
   for (const entry of readdirSync6(assetsDir)) {
-    writeFileSync15(join20(stagedDir, entry), readFileSync14(join20(assetsDir, entry), "utf-8"), "utf-8");
+    writeFileSync16(join21(stagedDir, entry), readFileSync16(join21(assetsDir, entry), "utf-8"), "utf-8");
   }
-  return { bridge: join20(stagedDir, BRIDGE_FILE), worker: join20(stagedDir, WORKER_FILE) };
+  return { bridge: join21(stagedDir, BRIDGE_FILE), worker: join21(stagedDir, WORKER_FILE) };
 }
 function buildBridgeSpawn(bridgePath, workerEntry, opts) {
   const modeEnv = opts.runAsJob ? {
@@ -5823,7 +7019,7 @@ function buildBridgeSpawn(bridgePath, workerEntry, opts) {
   };
 }
 function registerDebugCommand(program2) {
-  program2.command("debug").description("Debug a coded function: bridges StudioWeb's SignalR DebugHub to the Deno V8 inspector for line breakpoints.").option("--session <id>", "Debug session id / jobKey (must match the FE debug hub group)").option("--hub <url>", "SignalR DebugHub relay URL", DEFAULT_HUB).option("--run-as-job", "Debug a one-shot coded function job without an HTTP server").option("--entrypoint <path>", "Path to the function file (run-as-job mode)").option("--function <name>", "Which function from uipath.json to debug (default: the first)").option("--port <port>", "Port the debug server listens on", String(DEFAULT_PORT2)).option("--input <json>", "JSON input passed to the function's main method", "{}").option("--input-file <path>", "Path to a JSON input file (takes priority over --input)").option("--context <json>", "JSON runtime-context payload (used when --context-file is absent)").option("--context-file <path>", "Path to the runtime-context JSON file (takes priority over --context)").option("--production", "Use the preinstalled server-runner dependencies when available").option("--inspect <endpoint>", "V8 inspector endpoint for the spawned runner", DEFAULT_INSPECT).option("--token <jwt>", "Bearer token for a remote SignalR hub. Falls back to env HUB_ACCESS_TOKEN when omitted; leave both unset for an unauthenticated local hub.", "").action(async (opts) => {
+  program2.command("debug").description("Debug a coded function: bridges StudioWeb's SignalR DebugHub to the Deno V8 inspector for line breakpoints. Without Deno, --run-as-job falls back to a plain Node run of the same job.").option("--session <id>", "Debug session id / jobKey (must match the FE debug hub group)").option("--hub <url>", "SignalR DebugHub relay URL", DEFAULT_HUB).option("--run-as-job", "Debug a one-shot coded function job without an HTTP server").option("--entrypoint <path>", "Path to the function file (run-as-job mode)").option("--function <name>", "Which function from uipath.json to debug (default: the first)").option("--port <port>", "Port the debug server listens on", String(DEFAULT_PORT2)).option("--input <json>", "JSON input passed to the function's main method", "{}").option("--input-file <path>", "Path to a JSON input file (takes priority over --input)").option("--context <json>", "JSON runtime-context payload (used when --context-file is absent)").option("--context-file <path>", "Path to the runtime-context JSON file (takes priority over --context)").option("--production", "Use the preinstalled server-runner dependencies when available").option("--inspect <endpoint>", "V8 inspector endpoint for the spawned runner", DEFAULT_INSPECT).option("--token <jwt>", "Bearer token for a remote SignalR hub. Falls back to env HUB_ACCESS_TOKEN when omitted; leave both unset for an unauthenticated local hub.", "").action(async (opts) => {
     const cwd = resolve12(".");
     const runAsJob = opts.runAsJob === true;
     if (opts.entrypoint && !runAsJob) {
@@ -5838,17 +7034,17 @@ function registerDebugCommand(program2) {
       console.error("Provide only one of --entrypoint or --function.");
       process.exit(1);
     }
-    const uipathJsonPath = join20(cwd, "uipath.json");
-    if (!existsSync16(uipathJsonPath) && (!runAsJob || !opts.entrypoint)) {
+    const uipathJsonPath = join21(cwd, "uipath.json");
+    if (!existsSync17(uipathJsonPath) && (!runAsJob || !opts.entrypoint)) {
       console.error("No uipath.json found. Run 'uipath-functions init' first.");
       process.exit(1);
     }
-    if (!opts.entrypoint && existsSync16(uipathJsonPath) && syncFunctionsMap(cwd)) {
+    if (!opts.entrypoint && existsSync17(uipathJsonPath) && syncFunctionsMap(cwd)) {
       console.log("Updated functions map in uipath.json.");
     }
     const functions = {};
-    if (existsSync16(uipathJsonPath)) {
-      const uipathJson = JSON.parse(readFileSync14(uipathJsonPath, "utf-8"));
+    if (existsSync17(uipathJsonPath)) {
+      const uipathJson = JSON.parse(readFileSync16(uipathJsonPath, "utf-8"));
       if (typeof uipathJson === "object" && uipathJson !== null && "functions" in uipathJson && typeof uipathJson.functions === "object" && uipathJson.functions !== null) {
         for (const [name, entry] of Object.entries(uipathJson.functions)) {
           if (typeof entry === "string") {
@@ -5885,15 +7081,40 @@ function registerDebugCommand(program2) {
     }
     const fnName = opts.entrypoint ? "" : opts.function ?? names[0] ?? "";
     const port = runAsJob ? undefined : parseInt(opts.port, 10) || DEFAULT_PORT2;
-    const skipInstall = opts.production === true && existsSync16(join20(cwd, SERVER_RUNNER_DIR));
+    if (opts.production !== true) {
+      try {
+        assertDependenciesInstalled(cwd);
+      } catch (err2) {
+        console.error(err2 instanceof Error ? err2.message : String(err2));
+        process.exit(1);
+      }
+    }
+    const skipInstall = opts.production === true && existsSync17(join21(cwd, SERVER_RUNNER_DIR));
     if (!skipInstall) {
       try {
-        setupRunDependencies(cwd);
+        installServerRunner(cwd);
       } catch (err2) {
         console.error(err2 instanceof Error ? err2.message : String(err2));
         process.exit(1);
       }
     }
+    if (!denoAvailable()) {
+      if (!runAsJob) {
+        console.error("Deno not found, and the HTTP debug bridge needs it. Install it with 'uipath-functions setup --runtime deno', or debug a single invocation with --run-as-job.");
+        process.exit(1);
+      }
+      console.error("Deno not found: running the job under Node instead, without breakpoints or the debug hub bridge. Install Deno with 'uipath-functions setup --runtime deno' for a full debug session.");
+      const selector = { entrypoint: opts.entrypoint, function: fnName || undefined, production: opts.production };
+      runNode(cwd, {
+        ...selector,
+        input: inputJson,
+        inputFile: opts.inputFile,
+        context: opts.context,
+        contextFile: opts.contextFile,
+        derivedFile: writeDerivedContract(cwd, selector)
+      });
+      return;
+    }
     const staged = stageDebugAssets(cwd);
     let workerEntry;
     let derivedFile = "";
@@ -5901,7 +7122,9 @@ function registerDebugCommand(program2) {
       derivedFile = writeDerivedContract(cwd, { entrypoint: opts.entrypoint, function: opts.function, production: opts.production });
       workerEntry = staged.worker;
     } else {
-      const derived = deriveMarkerContracts(functions, cwd);
+      const extraction = extractProject(functions, cwd);
+      reportDiagnosticsOrExit(extraction.diagnostics);
+      const derived = toDerivedContracts(extraction.functions);
       const aggregatorPath = generateAggregator(functions, cwd, "serve", derived);
       workerEntry = writeDenoServeEntry(cwd, port, aggregatorPath);
       freePort(port);
@@ -5920,13 +7143,13 @@ function registerDebugCommand(program2) {
       context: opts.context ?? "",
       contextFile: opts.contextFile ?? "",
       token: opts.token && opts.token.length > 0 ? opts.token : process.env.HUB_ACCESS_TOKEN ?? "",
-      envFile: existsSync16(join20(cwd, ".env")) ? ".env" : "",
+      envFile: existsSync17(join21(cwd, ".env")) ? ".env" : "",
       derivedFile
     };
     const { args, env } = buildBridgeSpawn(staged.bridge, workerEntry, resolved);
     const target = resolved.entrypoint || resolved.functionName;
     console.log(runAsJob ? `Debug bridge: session=${resolved.session} hub=${resolved.hub} job=${target} inspector=${resolved.inspect}` : `Debug bridge: session=${resolved.session} hub=${resolved.hub} function=${fnName} port=${port} inspector=${resolved.inspect}`);
-    const deno = process.env.DENO_BINARY ?? (process.platform === "win32" ? "deno.exe" : "deno");
+    const deno = resolveDeno();
     const proc = spawn3(deno, args, {
       cwd,
       env: { ...process.env, ...env },
@@ -5943,8 +7166,8 @@ function registerDebugCommand(program2) {
     proc.on("exit", (code) => process.exit(code ?? 0));
   });
 }
-var __dirname3 = dirname5(fileURLToPath3(import.meta.url));
-var pkg = JSON.parse(readFileSync15(join21(__dirname3, "..", "package.json"), "utf-8"));
+var __dirname3 = dirname6(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(readFileSync17(join22(__dirname3, "..", "package.json"), "utf-8"));
 function buildProgram() {
   const program2 = new Command;
   program2.name("uipath-functions").description("Build, serve, and publish UiPath JS/TS Functions").version(pkg.version);
@@ -5967,4 +7190,4 @@ async function cliRunner(args) {
 }
 export { generateManifests, cliRunner };
 
-//# debugId=DF52938DC2551B7B64756E2164756E21
+//# debugId=A1F90FDD6E84435C64756E2164756E21