@uipath/function-tool 1.205.0-preview.267 → 1.205.0-preview.269

package/dist/{cliRunner-23vh097s.js → cliRunner-6t7v6dqr.js}

@@ -1,42 +1,42 @@
-import"./packager-tool-1de529jm.js";
+import {
+  __require,
+  __toESM
+} from "./packager-tool-1de529jm.js";
 
 // ../../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 dirname6, join as join22 } from "node:path";
+import { dirname as dirname7, 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 { existsSync as existsSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync3, writeFileSync as writeFileSync3 } 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 { copyFileSync, existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { copyFileSync, existsSync as existsSync2, readFileSync as readFileSync2 } 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 { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } 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 writeFileSync5, mkdirSync as mkdirSync3 } from "node:fs";
+import { writeFileSync as writeFileSync4, 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 { 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 { existsSync as existsSync5, linkSync, lstatSync, mkdirSync as mkdirSync4, readFileSync as readFileSync4, readdirSync, symlinkSync, writeFileSync as writeFileSync5, cpSync } from "node:fs";
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { createRequire as createRequire2 } from "node:module";
 import { join as join7 } from "node:path";
 import { pathToFileURL } from "node:url";
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync2, writeFileSync as writeFileSync6 } 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 { mkdirSync as mkdirSync5, readFileSync as readFileSync9, readdirSync as readdirSync3, rmSync, statSync, writeFileSync as writeFileSync9 } from "node:fs";
 import { join as join13, resolve as resolve5 } from "node:path";
 import { randomUUID } from "node:crypto";
 import { createRequire as createRequire3 } from "module";
@@ -77,29 +77,29 @@ import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:
 import { join as join12 } from "node:path";
 import { createRequire as createRequire4 } from "node:module";
 import { register } from "node:module";
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } 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 join14, resolve as resolve6 } from "node:path";
-import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "node:fs";
 import { join as join17, resolve as resolve7 } from "node:path";
 import { createHash } from "node:crypto";
 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 { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync10 } 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 { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync15, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync13 } from "node:fs";
 import { join as join19, resolve as resolve9 } from "node:path";
 import { spawn as spawn2 } 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 { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync14, rmSync as rmSync2, writeFileSync as writeFileSync12 } from "node:fs";
+import { basename as basename5, dirname as dirname5, isAbsolute as isAbsolute3, join as join18, relative as relative3, resolve as resolve8 } from "node:path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync14 } from "node:fs";
 import { join as join20, resolve as resolve10 } from "node:path";
 import { resolve as resolve11 } 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 { existsSync as existsSync17, mkdirSync as mkdirSync10, readFileSync as readFileSync16, readdirSync as readdirSync6, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname6, 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";
@@ -113,7 +113,7 @@ function __accessProp(key) {
 }
 var __toESMCache_node;
 var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
+var __toESM2 = (mod, isNodeMode, target) => {
   var canCache = mod != null && typeof mod === "object";
   if (canCache) {
     var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
@@ -134,7 +134,7 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+var __require2 = /* @__PURE__ */ createRequire(import.meta.url);
 var require_error = __commonJS((exports) => {
 
   class CommanderError extends Error {
@@ -703,11 +703,11 @@ var require_suggestSimilar = __commonJS((exports) => {
   exports.suggestSimilar = suggestSimilar;
 });
 var require_command = __commonJS((exports) => {
-  var EventEmitter = __require("node:events").EventEmitter;
-  var childProcess4 = __require("node:child_process");
-  var path3 = __require("node:path");
-  var fs7 = __require("node:fs");
-  var process22 = __require("node:process");
+  var EventEmitter = __require2("node:events").EventEmitter;
+  var childProcess4 = __require2("node:child_process");
+  var path3 = __require2("node:path");
+  var fs7 = __require2("node:fs");
+  var process22 = __require2("node:process");
   var { Argument, humanReadableArgName } = require_argument();
   var { CommanderError } = require_error();
   var { Help } = require_help();
@@ -1961,7 +1961,7 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidArgumentError = InvalidArgumentError;
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
-var import__ = __toESM(require_commander(), 1);
+var import__ = __toESM2(require_commander(), 1);
 var {
   program,
   createCommand,
@@ -2459,37 +2459,43 @@ async function copyProjectFiles(fs7, sourcePath, destPath, lockFile, packOptions
   }
   await walk(sourcePath, destPath);
 }
+var NPM_PRODUCTION_FLAGS = ["--omit=dev", "--ignore-scripts", "--allow-git=none"];
+var BUN_PRODUCTION_FLAGS = ["--production", "--ignore-scripts"];
+var STRICT_INSTALL_ENV = "UIPATH_FUNCTIONS_REQUIRE_LOCK_FILE";
 var COMMANDS = {
   npm: {
     bin: "npm",
-    args: ({ production, preferOffline }) => [
+    args: ({ production }) => [
       "install",
-      ...production === true ? ["--omit=dev"] : [],
-      ...preferOffline === true ? ["--prefer-offline"] : []
+      ...production === true ? NPM_PRODUCTION_FLAGS : []
     ],
+    strictArgs: ({ production }) => [
+      "ci",
+      ...production === true ? NPM_PRODUCTION_FLAGS : []
+    ],
+    strictlyReads: ["npm"],
     verifyArgs: ["ci", "--dry-run", "--no-audit", "--no-fund"],
     saysLockDiffers: (output) => output.includes("EUSAGE")
   },
   bun: {
     bin: "bun",
-    args: ({ production, preferOffline }) => [
+    args: ({ production }) => [
+      "install",
+      ...production === true ? BUN_PRODUCTION_FLAGS : []
+    ],
+    strictArgs: ({ production }) => [
       "install",
-      ...production === true ? ["--production"] : [],
-      ...preferOffline === true ? ["--prefer-offline"] : []
+      ...production === true ? BUN_PRODUCTION_FLAGS : [],
+      "--frozen-lockfile"
     ],
+    strictlyReads: ["bun", "npm"],
     verifyArgs: ["install", "--frozen-lockfile", "--dry-run"],
     saysLockDiffers: (output) => output.includes("lockfile had changes")
   }
 };
 var FALLBACK_ORDER = ["npm", "bun"];
+var DESIGN_TIME_MANAGER = SUPPORTED_MANAGERS.find((manager) => manager.name === "npm");
 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;
@@ -2543,7 +2549,7 @@ function detectProjectManager(cwd) {
 }
 function resolvePackageManager(cwd, required) {
   const { name, bin, shell } = required === undefined ? chosenInvocation(cwd) : requiredInvocation(required);
-  const { args, verifyArgs, saysLockDiffers } = COMMANDS[name];
+  const { args, strictArgs, verifyArgs, saysLockDiffers } = COMMANDS[name];
   return {
     name,
     verifyLock(dir) {
@@ -2561,11 +2567,17 @@ ${result.stderr ?? ""}`;
     },
     runInstall(dir, options = {}) {
       shareRegistryConfig(cwd, dir);
-      const argv = args(options);
+      let argv = args(options);
+      if (options.production === true) {
+        const mode = chooseInstallMode(name, dir);
+        console.log(mode.report);
+        if (mode.strict)
+          argv = strictArgs(options);
+      }
       console.log(`Running: ${bin} ${argv.join(" ")}`);
       const result = spawnSync(bin, argv, {
         cwd: dir,
-        stdio: "inherit",
+        stdio: ["inherit", 2, "inherit"],
         shell
       });
       if (result.status !== 0) {
@@ -2574,6 +2586,18 @@ ${result.stderr ?? ""}`;
     }
   };
 }
+function chooseInstallMode(name, dir) {
+  const present = presentLockFiles(dir);
+  const reproducible = COMMANDS[name].strictlyReads.map((owner) => SUPPORTED_MANAGERS.find((manager) => manager.name === owner).lockFile).find((lockFile) => present.has(lockFile));
+  if (reproducible !== undefined) {
+    return { strict: true, report: `Install mode: strict, reproducing ${reproducible} with ${name}.` };
+  }
+  const missing = present.size === 0 ? "the project has no lock file" : `${name} cannot install strictly from ${[...present].join(" and ")}`;
+  if (/^(1|true)$/i.test(process.env[STRICT_INSTALL_ENV] ?? "")) {
+    return { strict: true, report: `Install mode: strict, as the host requires, although ${missing}.` };
+  }
+  return { strict: false, report: `Install mode: regular, ${missing}.` };
+}
 function chooseManager(cwd) {
   const available = detectAvailableManagers();
   const desired = detectProjectManager(cwd);
@@ -2622,17 +2646,27 @@ function checkDependenciesInstalled(cwd) {
   return {
     ready: false,
     problem: "node_modules not found.",
-    remedyCommand: describeInstallCommand(cwd)
+    remedyCommand: describeInstallCommand()
+  };
+}
+function checkDesignTimeManager(cwd) {
+  const present = presentLockFiles(cwd);
+  const foreign = SUPPORTED_MANAGERS.filter((manager) => manager !== DESIGN_TIME_MANAGER && present.has(manager.lockFile)).map((manager) => manager.lockFile);
+  if (foreign.length === 0)
+    return { ready: true, problem: null, remedyCommand: null };
+  const found = foreign.join(" and ");
+  return {
+    ready: false,
+    problem: `Found ${found}. Projects built and run on a developer machine use ` + `${DESIGN_TIME_MANAGER.name}'s ${DESIGN_TIME_MANAGER.lockFile}: delete ${found}.`,
+    remedyCommand: describeInstallCommand()
   };
 }
 function checkLockCurrent(cwd) {
-  const detection = detectPackageManager(presentLockFiles(cwd));
-  if (detection.kind !== "found") {
-    const { problem, remedyCommand } = describeDependencyProblem(detection);
-    return { ready: false, problem, remedyCommand };
+  const { lockFile } = DESIGN_TIME_MANAGER;
+  if (!existsSync2(join3(cwd, lockFile))) {
+    return { ready: false, problem: `${lockFile} not found.`, remedyCommand: describeInstallCommand() };
   }
-  const { lockFile, installHint } = detection.manager;
-  const { verdict, detail } = resolvePackageManager(cwd).verifyLock(cwd);
+  const { verdict, detail } = resolveDesignTimePackageManager(cwd).verifyLock(cwd);
   if (verdict === "current")
     return { ready: true, problem: null, remedyCommand: null };
   if (verdict === "unknown") {
@@ -2645,14 +2679,41 @@ function checkLockCurrent(cwd) {
   return {
     ready: false,
     problem: detail === "" ? `${lockFile} is out of date.` : `${lockFile} is out of date: ${detail}`,
-    remedyCommand: installHint
+    remedyCommand: describeInstallCommand()
+  };
+}
+function npmGitDependencyQuery(shell) {
+  return ["query", shell ? '":type(git)"' : ":type(git)", "--package-lock-only"];
+}
+function checkNoGitDependencies(cwd) {
+  const { lockFile } = DESIGN_TIME_MANAGER;
+  const { bin, shell } = requiredInvocation(DESIGN_TIME_MANAGER.name);
+  const result = spawnSync(bin, npmGitDependencyQuery(shell), { cwd, encoding: "utf-8", shell });
+  if (result.status !== 0) {
+    const detail = firstComplaint(`${result.stdout ?? ""}
+${result.stderr ?? ""}`);
+    return {
+      ready: false,
+      problem: `Could not check ${lockFile} for git dependencies${detail === "" ? "." : `: ${detail}`}`,
+      remedyCommand: null
+    };
+  }
+  const names = new Set(JSON.parse(result.stdout).map(({ location }) => location.split("node_modules/").at(-1)));
+  if (names.size === 0)
+    return { ready: true, problem: null, remedyCommand: null };
+  return {
+    ready: false,
+    problem: `Git dependencies cannot be packaged: ${[...names].sort().join(", ")}. Depend on a registry version of each.`,
+    remedyCommand: describeInstallCommand()
   };
 }
-function describeInstallCommand(cwd) {
-  const name = detectProjectManager(cwd) ?? FALLBACK_ORDER[0];
-  const { bin, args } = COMMANDS[name];
+function describeInstallCommand() {
+  const { bin, args } = COMMANDS[DESIGN_TIME_MANAGER.name];
   return `${bin} ${args({}).join(" ")}`;
 }
+function resolveDesignTimePackageManager(cwd) {
+  return resolvePackageManager(cwd, DESIGN_TIME_MANAGER.name);
+}
 function affectsDependencyInstall(fileName) {
   return CANDIDATE_LOCK_FILES.includes(fileName);
 }
@@ -2672,6 +2733,13 @@ function registerNewCommand(program2) {
       process.exit(1);
     }
     ensureSetup();
+    let manager;
+    try {
+      manager = resolveDesignTimePackageManager(projectDir);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
     const withSample = !opts.empty;
     const sampleFile = `functions/${SAMPLE_FUNCTION.name}.${lang}`;
     scaffoldProject({
@@ -2681,13 +2749,13 @@ function registerNewCommand(program2) {
       functions: withSample ? { [SAMPLE_FUNCTION.name]: `${sampleFile}:${SAMPLE_FUNCTION.entryExport}` } : {}
     });
     if (withSample) {
-      writeFileSync4(join4(projectDir, sampleFile), lang === "ts" ? HELLO_TS : HELLO_JS, "utf-8");
+      writeFileSync3(join4(projectDir, sampleFile), lang === "ts" ? HELLO_TS : HELLO_JS, "utf-8");
     }
     console.log(`
 Created ${projectName}/`);
     console.log("Installing dependencies...");
     try {
-      resolvePackageManager(projectDir).runInstall(projectDir);
+      manager.runInstall(projectDir);
     } catch (err) {
       console.error(err instanceof Error ? err.message : String(err));
       process.exit(1);
@@ -2705,12 +2773,12 @@ Ready. Next steps:`);
 }
 var SERVER_RUNNER_DIR = ".uipath/server-runner";
 var DESIGN_TIME_ENV = "DESIGN_TIME";
-var RUNTIME_VERSION = "^0.9.0";
+var RUNTIME_VERSION = "^0.10.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 = {}) {
+function generateAggregator(functionsMap, cwd, variant, contractsByFile = {}) {
   const lang = detectLanguage(functionsMap);
   const ext = lang === "javascript" ? "js" : "ts";
   const fileToFunctions = new Map;
@@ -2744,9 +2812,9 @@ function generateAggregator(functionsMap, cwd, variant, derivedByPath = {}) {
   }
   const imports = files.map((file, i) => `import f${i} from "${importPrefix}${file}";`).join(`
 `);
-  const relevantDerived = {};
+  const relevantContracts = {};
   for (const file of files) {
-    const d = derivedByPath[file];
+    const d = contractsByFile[file];
     if (!d)
       continue;
     const entry = {};
@@ -2755,22 +2823,23 @@ function generateAggregator(functionsMap, cwd, variant, derivedByPath = {}) {
     if (d.output !== undefined)
       entry.output = d.output;
     if (entry.input !== undefined || entry.output !== undefined)
-      relevantDerived[file] = entry;
+      relevantContracts[file] = entry;
   }
-  const hasDerived = Object.keys(relevantDerived).length > 0;
+  const hasContracts = Object.keys(relevantContracts).length > 0;
   const entries = files.map((file, i) => {
-    const def = hasDerived ? `__lower(f${i}, "${file}")` : `f${i}`;
+    const def = hasContracts ? `__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)};
+  const loweringBlock = hasContracts ? `const __contracts = ${JSON.stringify(relevantContracts, null, 2)};
+` + `const __lowers = (v) => v !== undefined && !(typeof v === "object" && v !== null && "~standard" in v);
 ` + `function __lower(def, path) {
-` + `  const d = __derived[path];
+` + `  const d = __contracts[path];
 ` + `  if (!d) return def;
 ` + `  const out = { ...def };
-` + `  if (d.input !== undefined) out.input = d.input;
-` + `  if (d.output !== undefined) out.output = d.output;
+` + `  if (__lowers(def.input) && d.input !== undefined) out.input = d.input;
+` + `  if (__lowers(def.output) && d.output !== undefined) out.output = d.output;
 ` + `  return out;
 ` + `}
 
@@ -2781,7 +2850,7 @@ function generateAggregator(functionsMap, cwd, variant, derivedByPath = {}) {
 
 ` + `${loweringBlock}` + `export default createApp([${entries}]);
 `;
-  writeFileSync5(outputFile, content, "utf-8");
+  writeFileSync4(outputFile, content, "utf-8");
   return outputFile;
 }
 function detectLanguage(functionsMap) {
@@ -2846,70 +2915,89 @@ function findRouteConflicts(routes) {
   }
   return pairs;
 }
-function typeToSchema(type, checker, topLevel = true) {
-  if (!topLevel && type.flags & ts.TypeFlags.Unknown)
+var TS;
+async function loadTypeScript() {
+  TS ??= (await import("typescript")).default;
+  return TS;
+}
+function typeToSchema(type, checker, topLevel = true, options = {}) {
+  if (!topLevel && type.flags & TS.TypeFlags.Unknown)
     return {};
-  if (type.flags & ts.TypeFlags.Boolean)
+  if (!topLevel && type.flags & TS.TypeFlags.Null)
+    return { type: "null" };
+  if (type.flags & TS.TypeFlags.Boolean)
     return { type: "boolean" };
-  if (type.flags & ts.TypeFlags.BooleanLiteral)
+  if (type.flags & TS.TypeFlags.BooleanLiteral)
     return { type: "boolean" };
-  if (type.flags & ts.TypeFlags.String)
+  if (type.flags & TS.TypeFlags.String)
     return { type: "string" };
-  if (type.flags & ts.TypeFlags.Number)
+  if (type.flags & TS.TypeFlags.Number)
     return { type: "number" };
-  if (type.flags & ts.TypeFlags.StringLiteral)
+  if (type.flags & TS.TypeFlags.StringLiteral)
     return { type: "string", const: type.value };
-  if (type.flags & ts.TypeFlags.NumberLiteral)
+  if (type.flags & TS.TypeFlags.NumberLiteral)
     return { type: "number", const: type.value };
-  if (type.flags & ts.TypeFlags.EnumLiteral && !type.isUnion()) {
+  if (type.flags & TS.TypeFlags.EnumLiteral && !type.isUnion()) {
     const value = type.value;
     return typeof value === "number" ? { type: "number", const: value } : { type: "string", const: value };
   }
-  if (isDate(type))
-    return { type: "string", format: "date-time" };
+  if (isDate(type)) {
+    if (options.allowDate)
+      return { type: "string", format: "date-time" };
+    throw new ContractTypeError("Date", "JSON has no Date; the value arrives as an ISO 8601 string", DIAGNOSTIC_CODES.UNSUPPORTED_DATE);
+  }
   if (checker.isArrayType(type)) {
     const [elem] = checker.getTypeArguments(type);
     if (!elem)
       throw new Error("Array type has no element type argument");
-    return { type: "array", items: typeToSchema(elem, checker, false) };
+    return { type: "array", items: atPath("[]", () => typeToSchema(elem, checker, false, options)) };
   }
   if (isTupleType(type))
     reject(type, checker, "tuple types are not supported — use an array or an object");
   if (type.isIntersection()) {
     for (const member of type.types) {
-      if (member.flags & ts.TypeFlags.String)
+      if (member.flags & TS.TypeFlags.String)
         return { type: "string" };
-      if (member.flags & ts.TypeFlags.Number)
+      if (member.flags & TS.TypeFlags.Number)
         return { type: "number" };
-      if (member.flags & ts.TypeFlags.Boolean)
+      if (member.flags & TS.TypeFlags.Boolean)
         return { type: "boolean" };
     }
-    return objectToSchema(type, checker);
+    return objectToSchema(type, checker, options);
   }
   if (type.isUnion())
-    return unionToSchema(type, checker);
-  if (type.flags & ts.TypeFlags.Any)
+    return unionToSchema(type, checker, topLevel, options);
+  if (type.flags & TS.TypeFlags.Any)
     reject(type, checker, "declare the shape explicitly instead of any");
-  if (type.flags & ts.TypeFlags.Unknown)
+  if (type.flags & TS.TypeFlags.Unknown)
     reject(type, checker, "a contract root must declare its shape — unknown is only supported in value positions (e.g. Record<string, unknown>)");
-  if (type.flags & (ts.TypeFlags.BigInt | ts.TypeFlags.BigIntLiteral))
+  if (type.flags & (TS.TypeFlags.BigInt | TS.TypeFlags.BigIntLiteral))
     reject(type, checker, "JSON has no bigint — use number or string");
-  if (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void))
+  if (type.flags & (TS.TypeFlags.Null | TS.TypeFlags.Undefined | TS.TypeFlags.Void))
     reject(type, checker, "a contract member cannot be null/undefined/void on its own");
-  if (type.flags & ts.TypeFlags.ESSymbol)
+  if (type.flags & TS.TypeFlags.ESSymbol)
     reject(type, checker, "symbols are not serializable");
   if (type.getCallSignatures().length > 0)
     reject(type, checker, "function types cannot be part of a contract");
-  if (type.flags & ts.TypeFlags.Object)
-    return objectToSchema(type, checker);
+  if (type.flags & TS.TypeFlags.Object)
+    return objectToSchema(type, checker, options);
   reject(type, checker);
 }
-function unionToSchema(type, checker) {
-  const parts = type.types.filter((t) => !(t.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Void)));
-  if (parts.length === 2 && parts.every((t) => t.flags & ts.TypeFlags.BooleanLiteral))
+function unionToSchema(type, checker, topLevel, options) {
+  const parts = type.types.filter((t) => !(t.flags & (TS.TypeFlags.Undefined | TS.TypeFlags.Null | TS.TypeFlags.Void)));
+  if (parts.length === 0) {
+    if (!topLevel && type.types.some((t) => t.flags & TS.TypeFlags.Null))
+      return { type: "null" };
+    reject(type, checker, "a contract member cannot be null/undefined/void on its own");
+  }
+  const schema = membersToSchema(parts, checker, options);
+  return type.types.some((t) => t.flags & TS.TypeFlags.Null) ? withNull(schema) : schema;
+}
+function membersToSchema(parts, checker, options) {
+  if (parts.length === 2 && parts.every((t) => t.flags & TS.TypeFlags.BooleanLiteral))
     return { type: "boolean" };
   if (parts.length === 1)
-    return typeToSchema(parts[0], checker, false);
+    return typeToSchema(parts[0], checker, false, options);
   const values = parts.map(literalValue);
   if (parts.length > 1 && values.every((v) => v !== undefined)) {
     const vals = values;
@@ -2918,18 +3006,27 @@ function unionToSchema(type, checker) {
     if (vals.every((v) => typeof v === "number"))
       return { type: "number", enum: vals };
   }
-  return { anyOf: parts.map((t) => typeToSchema(t, checker, false)) };
+  return { anyOf: parts.map((t) => typeToSchema(t, checker, false, options)) };
+}
+function withNull(schema) {
+  return { anyOf: [...schema.anyOf ?? [schema], { type: "null" }] };
 }
-function objectToSchema(type, checker) {
+function objectToSchema(type, checker, options) {
   const properties = {};
   const required = [];
   for (const sym of checker.getPropertiesOfType(type)) {
     const decl = sym.valueDeclaration ?? sym.declarations?.[0];
     if (!decl)
       throw new Error(`Property "${sym.name}" has no declaration`);
-    const optional = !!(sym.flags & ts.SymbolFlags.Optional);
+    const optional = !!(sym.flags & TS.SymbolFlags.Optional);
     const propType = checker.getTypeOfSymbolAtLocation(sym, decl);
-    const propSchema = typeToSchema(optional ? stripUndefined(propType) : propType, checker, false);
+    const propSchema = atPath(sym.name, () => {
+      const schema2 = typeToSchema(optional ? stripUndefined(propType) : propType, checker, false, options);
+      const format = jsDocFormat(sym, checker, options.allowDate);
+      if (format !== undefined)
+        applyFormat(schema2, format, options.allowDate);
+      return schema2;
+    });
     const defaultValue = jsDocDefault(sym, checker);
     if (defaultValue !== undefined)
       propSchema.default = defaultValue;
@@ -2942,8 +3039,8 @@ function objectToSchema(type, checker) {
     schema.properties = properties;
   if (required.length > 0)
     schema.required = required;
-  const stringIndex = checker.getIndexInfoOfType(type, ts.IndexKind.String);
-  schema.additionalProperties = stringIndex ? typeToSchema(stringIndex.type, checker, false) : false;
+  const stringIndex = checker.getIndexInfoOfType(type, TS.IndexKind.String);
+  schema.additionalProperties = stringIndex ? atPath("*", () => typeToSchema(stringIndex.type, checker, false, options)) : false;
   return schema;
 }
 function jsDocDefault(sym, checker) {
@@ -2959,46 +3056,104 @@ function jsDocDefault(sym, checker) {
     return text;
   }
 }
+var FORMATS = ["date-time", "date", "time", "email", "uri", "uuid"];
+function jsDocFormat(sym, checker, lenient = false) {
+  const tag = sym.getJsDocTags(checker).find((t) => t.name === "format");
+  if (!tag)
+    return;
+  const text = (tag.text ?? []).map((p) => p.text).join("").trim();
+  if (!FORMATS.includes(text)) {
+    if (lenient)
+      return;
+    throw new ContractTypeError(`@format ${text}`, `supported formats are ${FORMATS.join(", ")}`, DIAGNOSTIC_CODES.UNSUPPORTED_FORMAT);
+  }
+  return text;
+}
+function applyFormat(schema, format, lenient = false) {
+  const arms = (schema.anyOf ?? [schema]).filter((s) => s.type !== "null");
+  if (lenient && arms.some((s) => s.format))
+    return;
+  if (arms.length === 0 || !arms.every((s) => s.type === "string" && s.const === undefined && s.enum === undefined)) {
+    if (lenient)
+      return;
+    throw new ContractTypeError(`@format ${format}`, "a format applies to a string property", DIAGNOSTIC_CODES.UNSUPPORTED_FORMAT);
+  }
+  for (const s of arms)
+    s.format = format;
+}
 function stripUndefined(type) {
   if (!type.isUnion())
     return type;
-  const parts = type.types.filter((t) => !(t.flags & ts.TypeFlags.Undefined));
+  const parts = type.types.filter((t) => !(t.flags & TS.TypeFlags.Undefined));
   return parts.length === 1 ? parts[0] : type;
 }
 function literalValue(t) {
-  if (t.flags & (ts.TypeFlags.StringLiteral | ts.TypeFlags.NumberLiteral | ts.TypeFlags.EnumLiteral)) {
+  if (t.flags & (TS.TypeFlags.StringLiteral | TS.TypeFlags.NumberLiteral | TS.TypeFlags.EnumLiteral)) {
     return t.value;
   }
   return;
 }
 function isDate(type) {
-  return type.getSymbol()?.getName() === "Date" && type.getCallSignatures().length === 0;
+  const sym = type.getSymbol();
+  return sym?.getName() === "Date" && type.getCallSignatures().length === 0 && !!sym.declarations?.some((d) => d.getSourceFile().hasNoDefaultLib);
 }
 function isTupleType(type) {
   const target = type.target;
-  return !!target && !!(target.objectFlags & ts.ObjectFlags.Tuple);
+  return !!target && !!(target.objectFlags & TS.ObjectFlags.Tuple);
+}
+
+class ContractTypeError extends Error {
+  typeName;
+  detail;
+  code;
+  path = [];
+  constructor(typeName, detail, code = DIAGNOSTIC_CODES.UNSUPPORTED_TYPE) {
+    super();
+    this.typeName = typeName;
+    this.detail = detail;
+    this.code = code;
+    this.message = this.describe();
+  }
+  under(segment) {
+    this.path.unshift(segment);
+    this.message = this.describe();
+  }
+  describe() {
+    const at = this.path.length > 0 ? ` at ${this.path.join(".").replaceAll(".[]", "[]")}` : "";
+    return `Unsupported type in function contract${at}: ${this.typeName}` + (this.detail ? ` — ${this.detail}` : "") + ". The contract format is a curated JSON Schema subset.";
+  }
+}
+function atPath(segment, derive) {
+  try {
+    return derive();
+  } catch (err) {
+    if (err instanceof ContractTypeError)
+      err.under(segment);
+    throw err;
+  }
 }
 function reject(type, checker, detail) {
-  const name = checker.typeToString(type);
-  throw new Error(`Unsupported type in function contract: ${name}` + (detail ? ` — ${detail}` : "") + ". The contract format is a curated JSON Schema subset.");
-}
-var CONSUMER_COMPILER_OPTIONS = {
-  target: ts.ScriptTarget.ES2020,
-  module: ts.ModuleKind.ESNext,
-  moduleResolution: ts.ModuleResolutionKind.Bundler,
-  allowImportingTsExtensions: true,
-  allowJs: true,
-  strict: true,
-  skipLibCheck: true,
-  noEmit: true
-};
+  throw new ContractTypeError(checker.typeToString(type), detail);
+}
+function consumerCompilerOptions() {
+  return {
+    target: TS.ScriptTarget.ES2020,
+    module: TS.ModuleKind.ESNext,
+    moduleResolution: TS.ModuleResolutionKind.Bundler,
+    allowImportingTsExtensions: true,
+    allowJs: true,
+    strict: true,
+    skipLibCheck: true,
+    noEmit: true
+  };
+}
 function createProgram(fs7, rootNames, options) {
   const selfContained = fs7.defaultLibFileName !== undefined;
   const host = selfContained ? selfContainedHost(fs7) : diskBackedHost(fs7, options);
   if (!selfContained)
     assertDefaultLibReachable(host, options);
-  const program2 = ts.createProgram(rootNames, options, host);
-  return { program: program2, checker: program2.getTypeChecker() };
+  const program2 = TS.createProgram(rootNames, options, host);
+  return { program: program2, checker: program2.getTypeChecker(), host };
 }
 function assertDefaultLibReachable(host, options) {
   const libPath = host.getDefaultLibFileName(options);
@@ -3006,10 +3161,10 @@ function assertDefaultLibReachable(host, options) {
     return;
   throw new Error(`TypeScript lib not found at "${libPath}".
 ` + `Type derivation cannot run without it — Array/Record/Date/Promise would resolve to ` + `any and produce wrong schemas.
-` + `That path comes from the 'typescript' module's own location. If it names a directory ` + `from another machine, 'typescript' was bundled into the caller: build with ` + `'--external typescript' so it resolves from node_modules at runtime. If the project ` + `sets "noLib", remove it.`);
+That path comes from the 'typescript' module's own location. If it names a directory from another machine, 'typescript' was bundled into the caller: build with '--external typescript' so it resolves from node_modules at runtime. If the project sets "noLib", remove it.`);
 }
 function diskBackedHost(fs7, options) {
-  const host = ts.createCompilerHost(options, true);
+  const host = TS.createCompilerHost(options, true);
   host.getCurrentDirectory = () => fs7.currentDirectory;
   const baseGetSourceFile = host.getSourceFile.bind(host);
   const baseReadFile = host.readFile.bind(host);
@@ -3017,7 +3172,7 @@ function diskBackedHost(fs7, options) {
   const baseDirectoryExists = host.directoryExists?.bind(host);
   host.getSourceFile = (name, langVersion, onError, shouldCreate) => {
     const text = fs7.readFile(name);
-    return text !== undefined ? ts.createSourceFile(name, text, langVersion, true) : baseGetSourceFile(name, langVersion, onError, shouldCreate);
+    return text !== undefined ? TS.createSourceFile(name, text, langVersion, true) : baseGetSourceFile(name, langVersion, onError, shouldCreate);
   };
   host.readFile = (name) => {
     const text = fs7.readFile(name);
@@ -3031,7 +3186,7 @@ function selfContainedHost(fs7) {
   return {
     getSourceFile: (name, langVersion) => {
       const text = fs7.readFile(name);
-      return text !== undefined ? ts.createSourceFile(name, text, langVersion, true) : undefined;
+      return text !== undefined ? TS.createSourceFile(name, text, langVersion, true) : undefined;
     },
     getDefaultLibFileName: () => fs7.defaultLibFileName,
     getDefaultLibLocation: () => fs7.defaultLibLocation ?? "/",
@@ -3050,6 +3205,8 @@ function selfContainedHost(fs7) {
 var DIAGNOSTIC_CODES = {
   UNSUPPORTED_VALIDATOR: "unsupported-validator",
   UNSUPPORTED_TYPE: "unsupported-type",
+  UNSUPPORTED_DATE: "unsupported-date",
+  UNSUPPORTED_FORMAT: "unsupported-format",
   NON_STATIC_LITERAL: "non-static-literal",
   UNREADABLE_PROPERTY: "unreadable-property",
   MISSING_TYPE_ARGUMENT: "missing-type-argument",
@@ -3057,51 +3214,64 @@ var DIAGNOSTIC_CODES = {
   MULTIPLE_FUNCTIONS_PER_FILE: "multiple-functions-per-file",
   DEPRECATED_MARKER: "deprecated-marker",
   NO_FUNCTION_DEFINITION: "no-function-definition",
-  UNRESOLVED_SOURCE_FILE: "unresolved-source-file"
+  UNRESOLVED_SOURCE_FILE: "unresolved-source-file",
+  UNLINKED_DEFINITION: "unlinked-definition",
+  UNLINKED_CONTRACT_TYPE: "unlinked-contract-type"
 };
-function extractFunctionContracts(sourceFile, checker) {
+function walkDefinitions(sourceFile, checker, sdk, options) {
   const bindings = sdkImportBindings(sourceFile);
-  const functions = [];
-  const diagnostics = [];
+  const defs = [];
   const visit = (node) => {
-    if (isDefineFunctionCall(node, bindings)) {
+    if (isDefineFunctionCall(node, bindings, checker, sdk)) {
       const arg = node.arguments[0];
-      if (arg && ts.isObjectLiteralExpression(arg)) {
+      if (arg && TS.isObjectLiteralExpression(arg)) {
         const fn = { ...readMetadata(arg) };
+        const diagnostics = [];
+        const markers = [];
         for (const field of ["input", "output"]) {
-          const { schema, diagnostic } = resolveField(arg, field, checker, bindings);
+          const { schema, diagnostic, marker } = resolveField(arg, field, checker, bindings, sdk, options);
           if (schema !== undefined)
             fn[field] = schema;
           if (diagnostic)
             diagnostics.push({ ...diagnostic, functionName: fn.name, field });
+          if (marker)
+            markers.push(marker);
+        }
+        for (const p of arg.properties) {
+          const name = TS.isPropertyAssignment(p) ? propertyName(p.name) : undefined;
+          if ((name === "input" || name === "output") && p !== findProp(arg, name)) {
+            markers.push(unwrap(p.initializer));
+          }
         }
         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"),
+            ...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"),
+              ...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);
+        defs.push({ node, fn, diagnostics, markers });
       }
     }
-    ts.forEachChild(node, visit);
+    TS.forEachChild(node, visit);
   };
   visit(sourceFile);
-  return { functions, diagnostics };
+  return defs;
 }
-function extractFromFiles(files, checker, limits) {
+function extractFromFiles(files, checker, limits, exportName = "default", sdk, options) {
   const functions = [];
   const diagnostics = [];
+  const allCalls = [];
   const maxPerFile = limits?.maxDefineFunctionsPerFile;
+  const scope = sdk ?? sdkExportsFromImports(files.map((f) => f.sourceFile), checker);
   for (const { functionPath, sourceFile } of files) {
     if (!sourceFile) {
       diagnostics.push({
@@ -3112,12 +3282,38 @@ function extractFromFiles(files, checker, limits) {
       });
       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)) {
+    const defs = walkDefinitions(sourceFile, checker, scope, options);
+    for (const d of defs)
+      allCalls.push({ ...d.fn, functionPath });
+    const hasDefault = exportSymbol(sourceFile, checker, "default") !== undefined;
+    const target = exportSymbol(sourceFile, checker, exportName);
+    const hasTarget = target !== undefined;
+    const served = target && !referencesItself(sourceFile, checker) && targetExpression(target, sourceFile, checker);
+    const linked = defs.find((d) => d.node === served);
+    if (linked) {
+      functions.push({ ...linked.fn, functionPath });
+      for (const d of linked.diagnostics)
+        diagnostics.push({ ...d, file: functionPath });
+    }
+    const markers = hasTarget ? markerCalls(sourceFile, checker, scope) : [];
+    const consumed = new Set(defs.flatMap((d) => d.markers));
+    const unsafeMarker = linked ? markers.some((m) => !consumed.has(m)) : markers.length > 0;
+    if (unsafeMarker) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.UNLINKED_CONTRACT_TYPE,
+        severity: "error",
+        message: `a defineSchema<T>() in this file cannot be derived: only one written directly as the input or output of the defineFunction(...) call the file serves can be.`,
+        file: functionPath
+      });
+    } else if (hasTarget && !linked && defs.length > 0) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.UNLINKED_DEFINITION,
+        severity: "warning",
+        message: `the served export is not a defineFunction(...) call this file makes directly, so no entry point is produced statically; the CLI reads it by executing the module.`,
+        file: functionPath
+      });
+    }
+    if (limits?.requireFunctionPerFile && !hasDefault) {
       diagnostics.push({
         code: DIAGNOSTIC_CODES.NO_FUNCTION_DEFINITION,
         severity: "error",
@@ -3125,11 +3321,11 @@ function extractFromFiles(files, checker, limits) {
         file: functionPath
       });
     }
-    if (maxPerFile !== undefined && result.functions.length > maxPerFile) {
+    if (maxPerFile !== undefined && defs.length > maxPerFile) {
       diagnostics.push({
         code: DIAGNOSTIC_CODES.MULTIPLE_FUNCTIONS_PER_FILE,
         severity: "error",
-        message: `${result.functions.length} functions are defined in one file; at most ${maxPerFile} ` + `allowed. Move each defineFunction into its own file.`,
+        message: `${defs.length} functions are defined in one file; at most ${maxPerFile} allowed. Move each defineFunction into its own file.`,
         file: functionPath
       });
     }
@@ -3138,31 +3334,162 @@ function extractFromFiles(files, checker, limits) {
     diagnostics.push({
       code: DIAGNOSTIC_CODES.AMBIGUOUS_ROUTE,
       severity: "warning",
-      message: `route "${a.method} ${a.path}" (${a.functionPath}) overlaps "${b.method} ${b.path}" ` + `(${b.functionPath}): they match the same requests and are separated only by a ` + `deterministic tie-break — give them distinct paths to make routing unambiguous.`,
+      message: `route "${a.method} ${a.path}" (${a.functionPath}) overlaps "${b.method} ${b.path}" (${b.functionPath}): they match the same requests and are separated only by a ` + `deterministic tie-break — give them distinct paths to make routing unambiguous.`,
       functionName: a.name,
       file: a.functionPath
     });
   }
-  return { functions, diagnostics };
+  return { functions, diagnostics, allCalls };
 }
 var SDK_MODULE = "@uipath/coded-functions-js-sdk";
-function hasDefaultExport(sourceFile, checker) {
-  const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
-  if (!moduleSymbol)
+function isTypeOnlyImport(node) {
+  const clause = node.importClause;
+  if (!clause)
     return false;
-  return checker.getExportsOfModule(moduleSymbol).some((s) => s.escapedName === "default");
+  if (clause.isTypeOnly)
+    return true;
+  const named = clause.namedBindings;
+  return !clause.name && named !== undefined && TS.isNamedImports(named) && named.elements.every((e) => e.isTypeOnly);
+}
+function isTypeOnlyExport(node) {
+  if (node.isTypeOnly)
+    return true;
+  const clause = node.exportClause;
+  return clause !== undefined && TS.isNamedExports(clause) && clause.elements.every((e) => e.isTypeOnly);
+}
+function referencesItself(sourceFile, checker) {
+  const self = checker.getSymbolAtLocation(sourceFile);
+  let found = false;
+  const visit = (node) => {
+    if (found)
+      return;
+    const typeOnly = TS.isImportDeclaration(node) ? isTypeOnlyImport(node) : TS.isExportDeclaration(node) && isTypeOnlyExport(node);
+    const spec = typeOnly ? undefined : TS.isImportDeclaration(node) || TS.isExportDeclaration(node) ? node.moduleSpecifier : TS.isCallExpression(node) && node.expression.kind === TS.SyntaxKind.ImportKeyword ? node.arguments[0] : undefined;
+    if (self && spec && checker.getSymbolAtLocation(spec) === self)
+      found = true;
+    if (TS.isCallExpression(node) && TS.isIdentifier(node.expression) && node.expression.text === "eval")
+      found = true;
+    TS.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}
+function exportSymbol(sourceFile, checker, exportName) {
+  const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+  return moduleSymbol && checker.getExportsOfModule(moduleSymbol).find((s) => s.escapedName === exportName);
+}
+function targetExpression(sym, sourceFile, checker) {
+  const decl = sym.declarations?.length === 1 ? sym.declarations[0] : undefined;
+  if (!decl || decl.getSourceFile() !== sourceFile)
+    return;
+  if (TS.isExportAssignment(decl) && !decl.isExportEquals) {
+    const expr = unwrap(decl.expression);
+    return TS.isIdentifier(expr) ? constInitializer(checker.getSymbolAtLocation(expr), decl, sourceFile, checker, decl) : expr;
+  }
+  if (TS.isExportSpecifier(decl) && !decl.parent.parent.moduleSpecifier) {
+    return constInitializer(checker.getExportSpecifierLocalTargetSymbol(decl), decl, sourceFile, checker);
+  }
+  if (TS.isVariableDeclaration(decl))
+    return constInitializer(sym, undefined, sourceFile, checker);
+  return;
+}
+function constInitializer(sym, site, sourceFile, checker, evaluatedAt) {
+  const decl = sym?.declarations?.length === 1 ? sym.declarations[0] : undefined;
+  if (!decl || !TS.isVariableDeclaration(decl) || decl.getSourceFile() !== sourceFile || evaluatedAt !== undefined && decl.end > evaluatedAt.pos || !decl.initializer || !TS.isVariableDeclarationList(decl.parent) || !(decl.parent.flags & TS.NodeFlags.Const)) {
+    return;
+  }
+  let references = 0;
+  const count = (node) => {
+    if (node === site || TS.isTypeNode(node))
+      return;
+    if (TS.isIdentifier(node) && node !== decl.name) {
+      const target = TS.isShorthandPropertyAssignment(node.parent) && node.parent.name === node ? checker.getShorthandAssignmentValueSymbol(node.parent) : checker.getSymbolAtLocation(node);
+      if (target === sym)
+        references++;
+    }
+    TS.forEachChild(node, count);
+  };
+  count(sourceFile);
+  return references === 0 ? unwrap(decl.initializer) : undefined;
 }
 var MARKER_EXPORTS = ["defineSchema", "type"];
+function sdkExports(program2, host, options) {
+  const cache = TS.createModuleResolutionCache(program2.getCurrentDirectory(), (f) => f, options);
+  const entries = new Set;
+  for (const sf of program2.getSourceFiles()) {
+    const specifiers = program2.isSourceFileFromExternalLibrary(sf) ? [] : [SDK_MODULE];
+    for (const stmt of sf.statements) {
+      const spec = TS.isImportDeclaration(stmt) || TS.isExportDeclaration(stmt) ? stmt.moduleSpecifier : undefined;
+      if (spec && TS.isStringLiteral(spec))
+        specifiers.push(spec.text);
+    }
+    for (const spec of specifiers) {
+      const resolved = TS.resolveModuleName(spec, sf.fileName, options, host, cache).resolvedModule;
+      const name = resolved?.packageId?.name;
+      if (resolved && name === SDK_MODULE)
+        entries.add(resolved.resolvedFileName);
+    }
+  }
+  const checker = program2.getTypeChecker();
+  const exports = new Map;
+  for (const file of entries) {
+    const entry = program2.getSourceFile(file);
+    const moduleSymbol = entry && checker.getSymbolAtLocation(entry);
+    if (!moduleSymbol)
+      continue;
+    for (const s of checker.getExportsOfModule(moduleSymbol)) {
+      exports.set(s.flags & TS.SymbolFlags.Alias ? checker.getAliasedSymbol(s) : s, s.name);
+    }
+  }
+  return exports;
+}
+function markerCalls(sourceFile, checker, sdk) {
+  const bindings = sdkImportBindings(sourceFile);
+  const found = [];
+  const visit = (node) => {
+    if (TS.isCallExpression(node)) {
+      if (sdkCallee(node, MARKER_EXPORTS, bindings, checker, sdk))
+        found.push(node);
+    }
+    TS.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}
+function sdkCallee(call, names, bindings, checker, sdk) {
+  const callee = call.expression;
+  if (TS.isIdentifier(callee))
+    return names.find((n) => matchesSdkExport(callee, n, bindings, checker, sdk));
+  if (!TS.isPropertyAccessExpression(callee) || !TS.isIdentifier(callee.expression))
+    return;
+  const ns = callee.expression;
+  if (sdk && sdk.size > 0) {
+    const resolved = sdkExportName(callee.name, checker, sdk);
+    return names.find((n) => n === resolved);
+  }
+  return isSdkNamespace(ns, checker) ? names.find((n) => n === callee.name.text) : undefined;
+}
+function isSdkNamespace(id, checker) {
+  const decl = checker.getSymbolAtLocation(id)?.declarations?.[0];
+  if (!decl || !TS.isNamespaceImport(decl))
+    return false;
+  const spec = decl.parent.parent.moduleSpecifier;
+  return TS.isStringLiteral(spec) && spec.text === SDK_MODULE;
+}
+function isNamespaceImportBinding(id, checker) {
+  const decl = checker.getSymbolAtLocation(id)?.declarations?.[0];
+  return decl !== undefined && TS.isNamespaceImport(decl);
+}
 function sdkImportBindings(sourceFile) {
   const map = new Map;
   for (const stmt of sourceFile.statements) {
-    if (!ts.isImportDeclaration(stmt))
+    if (!TS.isImportDeclaration(stmt))
       continue;
     const spec = stmt.moduleSpecifier;
-    if (!ts.isStringLiteral(spec) || spec.text !== SDK_MODULE)
+    if (!TS.isStringLiteral(spec) || spec.text !== SDK_MODULE)
       continue;
     const named = stmt.importClause?.namedBindings;
-    if (named && ts.isNamedImports(named)) {
+    if (named && TS.isNamedImports(named)) {
       for (const el of named.elements) {
         map.set(el.name.text, (el.propertyName ?? el.name).text);
       }
@@ -3170,36 +3497,91 @@ function sdkImportBindings(sourceFile) {
   }
   return map;
 }
-function matchesSdkExport(local, exportName, bindings) {
-  return bindings.size > 0 ? bindings.get(local) === exportName : local === exportName;
+function matchesSdkExport(callee, exportName, bindings, checker, sdk) {
+  if (sdk && sdk.size > 0)
+    return sdkExportName(callee, checker, sdk) === exportName;
+  if (hasImplementation(callee, checker))
+    return false;
+  return (bindings.size > 0 ? bindings.get(callee.text) : callee.text) === exportName;
+}
+function hasImplementation(id, checker) {
+  let sym = checker.getSymbolAtLocation(id);
+  if (sym && sym.flags & TS.SymbolFlags.Alias)
+    sym = checker.getAliasedSymbol(sym);
+  const decl = sym?.declarations?.[0];
+  if (!decl || decl.getSourceFile().isDeclarationFile)
+    return false;
+  return !(TS.getCombinedModifierFlags(decl) & TS.ModifierFlags.Ambient);
+}
+function sdkExportsFromImports(sourceFiles, checker) {
+  const exports = new Map;
+  for (const sf of sourceFiles) {
+    for (const stmt of sf?.statements ?? []) {
+      const spec = TS.isImportDeclaration(stmt) || TS.isExportDeclaration(stmt) ? stmt.moduleSpecifier : undefined;
+      if (!spec || !TS.isStringLiteral(spec) || spec.text !== SDK_MODULE)
+        continue;
+      const moduleSymbol = checker.getSymbolAtLocation(spec);
+      for (const s of moduleSymbol ? checker.getExportsOfModule(moduleSymbol) : []) {
+        exports.set(s.flags & TS.SymbolFlags.Alias ? checker.getAliasedSymbol(s) : s, s.name);
+      }
+    }
+  }
+  return exports.size > 0 ? exports : undefined;
+}
+function sdkExportName(id, checker, sdk, seen = new Set) {
+  let sym = checker.getSymbolAtLocation(id);
+  if (!sym)
+    return;
+  if (sym.flags & TS.SymbolFlags.Alias)
+    sym = checker.getAliasedSymbol(sym);
+  const name = sdk.get(sym);
+  if (name !== undefined)
+    return name;
+  if (seen.has(sym))
+    return null;
+  seen.add(sym);
+  const decl = sym.declarations?.[0];
+  if (!decl)
+    return;
+  if (TS.isVariableDeclaration(decl) && decl.initializer && TS.isVariableDeclarationList(decl.parent) && decl.parent.flags & TS.NodeFlags.Const) {
+    const init = unwrap(decl.initializer);
+    if (TS.isIdentifier(init))
+      return sdkExportName(init, checker, sdk, seen) ?? null;
+    if (TS.isPropertyAccessExpression(init) && TS.isIdentifier(init.expression) && isNamespaceImportBinding(init.expression, checker)) {
+      return sdkExportName(init.name, checker, sdk, seen) ?? null;
+    }
+  }
+  return null;
 }
-function isDefineFunctionCall(node, bindings) {
-  return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && matchesSdkExport(node.expression.text, "defineFunction", bindings);
+function isDefineFunctionCall(node, bindings, checker, sdk) {
+  return TS.isCallExpression(node) && TS.isIdentifier(node.expression) && matchesSdkExport(node.expression, "defineFunction", bindings, checker, sdk);
 }
-function resolveField(obj, field, checker, bindings) {
+function resolveField(obj, field, checker, bindings, sdk, options) {
   const prop = findProp(obj, field);
   if (!prop)
     return {};
   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 calleeId = TS.isCallExpression(value) && TS.isIdentifier(value.expression) ? value.expression : undefined;
+  const marker = calleeId && MARKER_EXPORTS.find((name) => matchesSdkExport(calleeId, name, bindings, checker, sdk));
+  if (TS.isCallExpression(value) && marker !== undefined) {
     const typeArg = value.typeArguments?.[0];
     if (!typeArg) {
-      return { diagnostic: diag(DIAGNOSTIC_CODES.MISSING_TYPE_ARGUMENT, `${field}: defineSchema<T>() is missing its type argument`) };
+      return { diagnostic: diag(DIAGNOSTIC_CODES.MISSING_TYPE_ARGUMENT, `${field}: defineSchema<T>() is missing its type argument`), marker: value };
     }
-    const viaDeprecatedName = (bindings.size > 0 ? bindings.get(callee) : callee) === "type";
+    const viaDeprecatedName = marker === "type";
     const deprecation = viaDeprecatedName ? {
       code: DIAGNOSTIC_CODES.DEPRECATED_MARKER,
       severity: "warning",
       message: `${field}: \`type\` is deprecated — use \`defineSchema\` instead`
     } : undefined;
     try {
-      return { schema: typeToSchema(checker.getTypeFromTypeNode(typeArg), checker), diagnostic: deprecation };
+      return { schema: typeToSchema(checker.getTypeFromTypeNode(typeArg), checker, true, options), diagnostic: deprecation, marker: value };
     } catch (err) {
-      return { diagnostic: diag(DIAGNOSTIC_CODES.UNSUPPORTED_TYPE, `${field}: ${err.message}`) };
+      const code = err instanceof ContractTypeError ? err.code : DIAGNOSTIC_CODES.UNSUPPORTED_TYPE;
+      return { diagnostic: diag(code, `${field}: ${err.message}`), marker: value };
     }
   }
-  if (ts.isObjectLiteralExpression(value)) {
+  if (TS.isObjectLiteralExpression(value)) {
     try {
       return { schema: literalToSchema(value) };
     } catch (err) {
@@ -3211,7 +3593,7 @@ function resolveField(obj, field, checker, bindings) {
   };
 }
 function propertyName(name) {
-  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+  if (TS.isIdentifier(name) || TS.isStringLiteral(name) || TS.isNumericLiteral(name)) {
     return name.text;
   }
   return;
@@ -3219,8 +3601,8 @@ function propertyName(name) {
 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))
+  for (let current = node.parent;current && !TS.isSourceFile(current); current = current.parent) {
+    if (TS.isFunctionLike(current) || TS.isClassStaticBlockDeclaration(current))
       return true;
   }
   return false;
@@ -3228,16 +3610,16 @@ function isNestedInFunction(node) {
 function unreadableProperties(obj) {
   const fields = new Set;
   for (const property of obj.properties) {
-    if (ts.isPropertyAssignment(property)) {
+    if (TS.isPropertyAssignment(property)) {
       const name2 = propertyName(property.name);
-      if (name2 === undefined)
+      if (name2 === undefined || name2 === "__proto__")
         return { fields: [], anyField: true };
       if (METADATA_FIELDS.has(name2) && !isReadableMetadataValue(property.initializer)) {
         fields.add(name2);
       }
       continue;
     }
-    if (ts.isSpreadAssignment(property))
+    if (TS.isSpreadAssignment(property) || TS.isGetAccessorDeclaration(property))
       return { fields: [], anyField: true };
     const name = property.name && propertyName(property.name);
     if (name === undefined)
@@ -3248,10 +3630,15 @@ function unreadableProperties(obj) {
   return { fields: [...fields], anyField: false };
 }
 function isReadableMetadataValue(value) {
-  return ts.isStringLiteralLike(unwrap(value));
+  return TS.isStringLiteralLike(unwrap(value));
 }
 function findProp(obj, field) {
-  return obj.properties.find((p) => ts.isPropertyAssignment(p) && propertyName(p.name) === field);
+  for (let i = obj.properties.length - 1;i >= 0; i--) {
+    const p = obj.properties[i];
+    if (TS.isPropertyAssignment(p) && propertyName(p.name) === field)
+      return p;
+  }
+  return;
 }
 function diag(code, message, severity = "error") {
   return { code, severity, message };
@@ -3277,7 +3664,7 @@ function readMetadata(obj) {
 }
 function unwrap(value) {
   let current = value;
-  while (ts.isAsExpression(current) || ts.isParenthesizedExpression(current) || ts.isSatisfiesExpression(current)) {
+  while (TS.isAsExpression(current) || TS.isParenthesizedExpression(current) || TS.isSatisfiesExpression(current)) {
     current = current.expression;
   }
   return current;
@@ -3287,19 +3674,19 @@ function stringProp(obj, field) {
   if (!prop)
     return;
   const value = unwrap(prop.initializer);
-  return ts.isStringLiteralLike(value) ? value.text : undefined;
+  return TS.isStringLiteralLike(value) ? value.text : undefined;
 }
 function stringArrayProp(obj, field) {
   const prop = findProp(obj, field);
   if (!prop)
     return;
   const array = unwrap(prop.initializer);
-  if (!ts.isArrayLiteralExpression(array))
+  if (!TS.isArrayLiteralExpression(array))
     return;
   const values = [];
   for (const el of array.elements) {
     const value = unwrap(el);
-    if (!ts.isStringLiteralLike(value))
+    if (!TS.isStringLiteralLike(value))
       return;
     values.push(value.text);
   }
@@ -3310,26 +3697,26 @@ function literalToSchema(node) {
 }
 function foldLiteral(expression) {
   const node = unwrap(expression);
-  if (ts.isStringLiteralLike(node))
+  if (TS.isStringLiteralLike(node))
     return node.text;
-  if (ts.isNumericLiteral(node))
+  if (TS.isNumericLiteral(node))
     return Number(node.text);
-  if (node.kind === ts.SyntaxKind.TrueKeyword)
+  if (node.kind === TS.SyntaxKind.TrueKeyword)
     return true;
-  if (node.kind === ts.SyntaxKind.FalseKeyword)
+  if (node.kind === TS.SyntaxKind.FalseKeyword)
     return false;
-  if (node.kind === ts.SyntaxKind.NullKeyword)
+  if (node.kind === TS.SyntaxKind.NullKeyword)
     return null;
-  if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand)) {
+  if (TS.isPrefixUnaryExpression(node) && node.operator === TS.SyntaxKind.MinusToken && TS.isNumericLiteral(node.operand)) {
     return -Number(node.operand.text);
   }
-  if (ts.isArrayLiteralExpression(node)) {
+  if (TS.isArrayLiteralExpression(node)) {
     return node.elements.map((el) => foldLiteral(el));
   }
-  if (ts.isObjectLiteralExpression(node)) {
+  if (TS.isObjectLiteralExpression(node)) {
     const obj = {};
     for (const p of node.properties) {
-      if (!ts.isPropertyAssignment(p)) {
+      if (!TS.isPropertyAssignment(p)) {
         throw new Error("object has a non-literal member (spread, shorthand, method, or getter)");
       }
       const key = propertyName(p.name);
@@ -3339,9 +3726,10 @@ function foldLiteral(expression) {
     }
     return obj;
   }
-  throw new Error(`not a static literal (${ts.SyntaxKind[node.kind]})`);
+  throw new Error(`not a static literal (${TS.SyntaxKind[node.kind]})`);
 }
-function extractDisk(opts) {
+async function extractDisk(opts) {
+  const TS2 = await loadTypeScript();
   const { cwd, files } = opts;
   const diskFs = {
     readFile: () => {
@@ -3352,83 +3740,26 @@ function extractDisk(opts) {
     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 options = readCompilerOptions(TS2, cwd);
+  const { program: program2, checker, host } = createProgram(diskFs, rootNames, options);
+  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);
+  return extractFromFiles(files.map((file) => ({ functionPath: file, sourceFile: byPath.get(canonical(resolve2(cwd, file))) })), checker, opts.limits, opts.exportName, sdkExports(program2, host, options), opts.derive);
 }
-function readCompilerOptions(cwd) {
-  const configPath = ts2.findConfigFile(cwd, ts2.sys.fileExists, "tsconfig.json");
+function readCompilerOptions(TS2, 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);
+    return consumerCompilerOptions();
+  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 consumerCompilerOptions();
+  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";
@@ -3568,19 +3899,11 @@ var SAMPLE_LOCK_PACKAGES2 = {
     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",
+  UNSUPPORTED_DATE: "unsupported-date",
+  UNSUPPORTED_FORMAT: "unsupported-format",
   NON_STATIC_LITERAL: "non-static-literal",
   UNREADABLE_PROPERTY: "unreadable-property",
   MISSING_TYPE_ARGUMENT: "missing-type-argument",
@@ -3588,7 +3911,9 @@ var DIAGNOSTIC_CODES2 = {
   MULTIPLE_FUNCTIONS_PER_FILE: "multiple-functions-per-file",
   DEPRECATED_MARKER: "deprecated-marker",
   NO_FUNCTION_DEFINITION: "no-function-definition",
-  UNRESOLVED_SOURCE_FILE: "unresolved-source-file"
+  UNRESOLVED_SOURCE_FILE: "unresolved-source-file",
+  UNLINKED_DEFINITION: "unlinked-definition",
+  UNLINKED_CONTRACT_TYPE: "unlinked-contract-type"
 };
 var CONTRACT_FIELDS2 = new Set(["name", "method", "path", "description", "input", "output"]);
 var METADATA_FIELDS2 = new Set(["name", "method", "path", "description"]);
@@ -3706,6 +4031,9 @@ function transformAttachments(schema) {
 function newId() {
   return globalThis.crypto.randomUUID();
 }
+function toDocumentSchema(schema) {
+  return transformAttachments(schema ?? { type: "object" });
+}
 function buildEntryPointsDoc(functions, existing, filePathPrefix = "content/") {
   const functionIds = new Map;
   const transactionRoots = new Set;
@@ -3726,8 +4054,8 @@ function buildEntryPointsDoc(functions, existing, filePathPrefix = "content/") {
       filePath,
       uniqueId: functionIds.get(filePath) ?? newId(),
       type: "function",
-      input: transformAttachments(fn.input ?? { type: "object" }),
-      output: transformAttachments(fn.output ?? { type: "object" }),
+      input: toDocumentSchema(fn.input),
+      output: toDocumentSchema(fn.output),
       ...transactionRoots.has(filePath) ? { isTransactionRoot: true } : {}
     };
   });
@@ -3786,15 +4114,28 @@ function buildBindingsDoc(functions, entryPointIdByPath, existingBindings, fileP
 }
 var BLOCKING_CODES = new Set([
   DIAGNOSTIC_CODES2.NO_FUNCTION_DEFINITION,
-  DIAGNOSTIC_CODES2.UNRESOLVED_SOURCE_FILE
+  DIAGNOSTIC_CODES2.UNRESOLVED_SOURCE_FILE,
+  DIAGNOSTIC_CODES2.UNSUPPORTED_TYPE,
+  DIAGNOSTIC_CODES2.UNSUPPORTED_DATE,
+  DIAGNOSTIC_CODES2.UNSUPPORTED_FORMAT,
+  DIAGNOSTIC_CODES2.MISSING_TYPE_ARGUMENT,
+  DIAGNOSTIC_CODES2.UNLINKED_CONTRACT_TYPE
+]);
+var DESIGN_TIME_ONLY_CODES = new Set([DIAGNOSTIC_CODES2.UNLINKED_CONTRACT_TYPE]);
+var SILENT_CODES = new Set([
+  DIAGNOSTIC_CODES2.UNSUPPORTED_VALIDATOR,
+  DIAGNOSTIC_CODES2.UNLINKED_DEFINITION
 ]);
-var SILENT_CODES = new Set([DIAGNOSTIC_CODES2.UNSUPPORTED_VALIDATOR]);
 function isSilentSchemaSignal(d) {
   return d.code === DIAGNOSTIC_CODES2.UNREADABLE_PROPERTY && d.field !== undefined;
 }
 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.`
+  [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.`,
+  [DIAGNOSTIC_CODES2.UNSUPPORTED_TYPE]: () => `Declare this contract as a JSON Schema literal instead, or keep it on a validator like zod, which the CLI reads by executing the module.`,
+  [DIAGNOSTIC_CODES2.UNSUPPORTED_DATE]: (d) => `Declare it as a \`string\` tagged \`/** @format date-time */\`, and ` + (d.field === "output" ? `return \`date.toISOString()\` from the handler.` : `call \`new Date(value)\` in the handler.`),
+  [DIAGNOSTIC_CODES2.UNSUPPORTED_FORMAT]: () => `Tag a \`string\` property with one of the supported formats.`,
+  [DIAGNOSTIC_CODES2.UNLINKED_CONTRACT_TYPE]: () => `Put it in the served call, \`export default defineFunction({ input: defineSchema<T>(), ... })\`, or declare the contract as a JSON Schema literal or a validator.`
 };
 function reportDiagnostics(diagnostics) {
   const blocking = diagnostics.filter((d) => BLOCKING_CODES.has(d.code));
@@ -3813,6 +4154,11 @@ function reportDiagnosticsOrExit(diagnostics) {
 ${blocking} error(s) in the project's function files — nothing was written. ` + `Fix them and re-run.`);
   process.exit(1);
 }
+function describeBlockingDiagnostics(diagnostics) {
+  const blocking = diagnostics.filter((d) => BLOCKING_CODES.has(d.code) && !DESIGN_TIME_ONLY_CODES.has(d.code));
+  return blocking.length === 0 ? null : blocking.map(format).join(`
+`);
+}
 function format(d) {
   const where = [d.functionName, d.field].filter(Boolean).join(".");
   const location = [d.file, where ? `(${where})` : ""].filter(Boolean).join(" ");
@@ -3826,24 +4172,207 @@ function underscored(file) {
   const renamed = `_${basename2(file)}`;
   return dir === "." ? renamed : `${dir}/${renamed}`;
 }
-function installServerRunner(cwd, serverRunnerTemplatePath = "", packageManager) {
+var ALLOW_DATE_ENV = "UIPATH_FUNCTIONS_ALLOW_DATE";
+var DERIVE_ENV = "UIPATH_FUNCTIONS_DERIVE_CONTRACTS";
+var allowDateAnnounced = false;
+var deriveAnnounced = false;
+function executionDeriveOptions() {
+  const allowDate = /^(1|true)$/i.test(process.env[ALLOW_DATE_ENV] ?? "");
+  if (allowDate && !allowDateAnnounced) {
+    allowDateAnnounced = true;
+    console.warn(`${ALLOW_DATE_ENV} is set: a Date in a defineSchema<T>() contract derives as a date-time string, and the handler receives that string. A @format that would block is skipped.`);
+  }
+  return { allowDate };
+}
+function extractProject(functionsMap, cwd, derive) {
+  const files = [...new Set(Object.values(functionsMap).map((v) => v.split(":")[0]))];
+  return extractDisk({
+    cwd,
+    files,
+    limits: { requireFunctionPerFile: true },
+    derive
+  });
+}
+function contractsFromExtraction(extraction) {
+  const legacyFiles = new Set(extraction.diagnostics.filter((d) => d.code === DIAGNOSTIC_CODES2.UNLINKED_CONTRACT_TYPE).map((d) => d.file));
+  const linked = new Set(extraction.functions.map((f) => f.functionPath));
+  const legacy = (extraction.allCalls ?? []).filter((f) => legacyFiles.has(f.functionPath) && !linked.has(f.functionPath));
+  const contracts = {};
+  for (const fn of [...legacy, ...extraction.functions]) {
+    if (fn.functionPath && (fn.input !== undefined || fn.output !== undefined)) {
+      contracts[fn.functionPath] = { ...fn, ...toDocumentForm(fn) };
+    }
+  }
+  return contracts;
+}
+async function extractContract(relFile, cwd, exportName = "default", derive, gate = false) {
+  const { functions, diagnostics } = await extractDisk({ cwd, files: [relFile], exportName, derive });
+  if (gate)
+    reportDiagnosticsOrExit(diagnostics);
+  else if (describeBlockingDiagnostics(diagnostics))
+    console.error(describeBlockingDiagnostics(diagnostics));
+  const fn = functions[0];
+  if (!fn || fn.input === undefined && fn.output === undefined)
+    return null;
+  return toDocumentForm(fn);
+}
+function toDocumentForm(fn) {
+  const out = {};
+  if (fn.input !== undefined)
+    out.input = toDocumentSchema(fn.input);
+  if (fn.output !== undefined)
+    out.output = toDocumentSchema(fn.output);
+  return out;
+}
+function readDocument(cwd) {
+  const doc = readJsonIfExists(join6(cwd, "entry-points.json"));
+  if (!Array.isArray(doc?.entryPoints))
+    return null;
+  const byPath = new Map;
+  for (const ep of doc.entryPoints) {
+    if (ep?.type !== "function" || typeof ep.filePath !== "string")
+      continue;
+    if (ep.input === undefined || ep.output === undefined)
+      continue;
+    const entry = {};
+    if (!isUndeclared(ep.input))
+      entry.input = ep.input;
+    if (!isUndeclared(ep.output))
+      entry.output = ep.output;
+    byPath.set(stripContentPrefix(ep.filePath), entry);
+  }
+  return byPath;
+}
+function contractFromDocument(relFile, cwd) {
+  const entry = readDocument(cwd)?.get(stripContentPrefix(relFile));
+  return entry && (entry.input !== undefined || entry.output !== undefined) ? entry : null;
+}
+async function resolveContracts(functionsMap, cwd, production, extract) {
+  if (production && !derivesFromSource()) {
+    const fromDocument = contractsFromDocument(functionsMap, cwd);
+    if (fromDocument)
+      return fromDocument;
+    throw new IncompleteDocumentError(describeGap(functionsMap, cwd));
+  }
+  return contractsFromExtraction(await extract());
+}
+
+class IncompleteDocumentError extends Error {
+}
+function derivesFromSource() {
+  const derive = /^(1|true)$/i.test(process.env[DERIVE_ENV] ?? "");
+  if (derive && !deriveAnnounced) {
+    deriveAnnounced = true;
+    console.warn(`${DERIVE_ENV} is set: contracts come from source instead of entry-points.json.`);
+  }
+  return derive;
+}
+function describeGap(functionsMap, cwd) {
+  const byPath = readDocument(cwd);
+  if (!byPath)
+    return "entry-points.json is absent or unreadable; pack the project again.";
+  const missing = declaredFiles(functionsMap).filter((file) => !byPath.has(stripContentPrefix(file)));
+  return `entry-points.json has no entry for ${missing.join(", ")}; pack the project again.`;
+}
+function declaredFiles(functionsMap) {
+  return [...new Set(Object.values(functionsMap).map((v) => v.split(":")[0]))];
+}
+function contractsFromDocument(functionsMap, cwd) {
+  const byPath = readDocument(cwd);
+  if (!byPath)
+    return null;
+  const contracts = {};
+  for (const file of declaredFiles(functionsMap)) {
+    const entry = byPath.get(stripContentPrefix(file));
+    if (!entry)
+      return null;
+    if (entry.input !== undefined || entry.output !== undefined)
+      contracts[file] = entry;
+  }
+  return contracts;
+}
+function isUndeclared(schema) {
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema))
+    return true;
+  const keys = Object.keys(schema);
+  return keys.length === 1 && keys[0] === "type" && schema.type === "object";
+}
+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 INVALID_FUNCTION_DEFINITION = "JsCodedFunction.InvalidFunctionDefinition";
+var DEPLOYMENT = "Deployment";
+async function reportStartupFailure(title, detail) {
+  const ipcEndpoint = process.env.JS_FUNCTION_API_IPC_ENDPOINT;
+  if (!ipcEndpoint)
+    return;
+
+  class IHttpFunctionServerApi {
+    SignalStartupFailed(_error) {
+      throw undefined;
+    }
+  }
+  const error = {
+    code: INVALID_FUNCTION_DEFINITION,
+    title,
+    detail,
+    category: DEPLOYMENT
+  };
+  try {
+    const { ipc } = await import("./index-q8r0mcyb.js").then((m)=>__toESM(m.default,1));
+    const proxy = ipc.proxy.withAddress(ipc.namedPipe(ipcEndpoint)).withService(IHttpFunctionServerApi);
+    await proxy.SignalStartupFailed(error);
+    await ipc.disposeChannel(ipc.namedPipe(ipcEndpoint));
+  } catch (err) {
+    console.error("Failed to report startup failure to handler:", err);
+  }
+}
+async function failStartup(detail) {
+  if (detail === null)
+    return;
+  console.error(detail);
+  await reportStartupFailure("The function package could not be loaded", detail);
+  process.exit(1);
+}
+function installServerRunner(cwd, { production, serverRunnerTemplatePath = "", packageManager, hardLink = false }) {
   const serverRunnerDir = join7(cwd, SERVER_RUNNER_DIR);
   mkdirSync4(serverRunnerDir, { recursive: true });
   if (serverRunnerTemplatePath !== "" && existsSync5(serverRunnerTemplatePath)) {
     console.log("Copying server-runner ...");
     for (const entry of readdirSync(serverRunnerTemplatePath)) {
-      cpSync(join7(serverRunnerTemplatePath, entry), join7(serverRunnerDir, entry), { recursive: true });
+      cpSync(join7(serverRunnerTemplatePath, entry), join7(serverRunnerDir, entry), { recursive: true, filter: hardLink ? copyUnlessHardLinked : undefined });
     }
     console.log("server-runner copied in " + serverRunnerDir + ".");
     return;
   }
-  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");
+  writeFileSync5(join7(serverRunnerDir, "package.json"), JSON.stringify(runnerManifest(), null, 2), "utf-8");
   console.log("Installing runtime dependencies ...");
-  resolvePackageManager(cwd, packageManager).runInstall(serverRunnerDir, { preferOffline: true });
+  const manager = production ? resolvePackageManager(cwd, packageManager) : resolveDesignTimePackageManager(cwd);
+  manager.runInstall(serverRunnerDir);
   console.log("Runtime dependencies installed.");
 }
+function copyUnlessHardLinked(from, to) {
+  try {
+    linkSync(from, to);
+    return false;
+  } catch {
+    return !isSameFile(from, to);
+  }
+}
+function isSameFile(a, b) {
+  const [first, second] = [lstatSync(a, { bigint: true }), lstatSync(b, { bigint: true, throwIfNoEntry: false })];
+  return first.ino === second?.ino && first.dev === second?.dev;
+}
 function declaresProductionDependency(cwd, packageName) {
   let parsed;
   try {
@@ -3863,7 +4392,7 @@ function declaresProductionDependency(cwd, 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 });
+  manager.runInstall(cwd, { production: true });
   console.log("Preparing node_modules in package working folder.");
   const packagesToCopy = ["@uipath/coded-functions-js-sdk"];
   for (const packageName of packagesToCopy) {
@@ -3877,27 +4406,24 @@ function installProjectProductionDependencies(cwd, manager = resolvePackageManag
   }
   console.log("Package working folder dependencies installed.");
 }
-function provisionPackage(cwd, serverRunnerTemplatePath = "", packageManager) {
-  installServerRunner(cwd, serverRunnerTemplatePath, packageManager);
+function provisionPackage(cwd, serverRunnerTemplatePath = "", packageManager, hardLink = false) {
+  installServerRunner(cwd, { production: true, serverRunnerTemplatePath, packageManager, hardLink });
   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 {}
+function runnerManifest() {
   return {
-    "@uipath/coded-functions-js-runtime": runtimeVersion,
-    "@uipath/coreipc": COREIPC_VERSION,
-    tsx: tsxVersion,
-    "@microsoft/signalr": SIGNALR_VERSION,
-    "@jridgewell/trace-mapping": TRACE_MAPPING_VERSION
+    name: "runner",
+    private: true,
+    type: "module",
+    dependencies: {
+      "@uipath/coded-functions-js-runtime": RUNTIME_VERSION,
+      "@uipath/coreipc": COREIPC_VERSION,
+      tsx: TSX_VERSION,
+      "@microsoft/signalr": SIGNALR_VERSION,
+      "@jridgewell/trace-mapping": TRACE_MAPPING_VERSION
+    }
   };
 }
 function resolveTsx(cwd) {
@@ -3943,11 +4469,13 @@ function assert(check, cwd) {
   }
 }
 function assertDependenciesInstalled(cwd) {
+  assert(checkDesignTimeManager(cwd), cwd);
   assert(checkDependenciesInstalled(cwd), cwd);
 }
 function assertReadyToPackage(cwd) {
-  assert(checkDependenciesInstalled(cwd), cwd);
+  assertDependenciesInstalled(cwd);
   assert(checkLockCurrent(cwd), cwd);
+  assert(checkNoGitDependencies(cwd), cwd);
 }
 function freePort(port) {
   try {
@@ -3969,7 +4497,28 @@ function freePort(port) {
     }
   } catch {}
 }
+var SIGNAL_READY_IPC = `  const ipcEndpoint = (typeof Deno !== "undefined" ? Deno.env.get("JS_FUNCTION_API_IPC_ENDPOINT") : process.env.JS_FUNCTION_API_IPC_ENDPOINT);
+  if (ipcEndpoint) {
+    console.log("Signaling ready to handler via CoreIPC on endpoint: " + ipcEndpoint);
+    try {
+      const { ipc } = await import("@uipath/coreipc");
+      class IHttpFunctionServerApi {
+        SignalReady() { throw void 0; }
+      }
+      const proxy = ipc.proxy
+        .withAddress(ipc.namedPipe(ipcEndpoint))
+        .withService(IHttpFunctionServerApi);
+      await proxy.SignalReady();
+      await ipc.disposeChannel(ipc.namedPipe(ipcEndpoint));
+      console.log("Sent ready signal to handler via CoreIPC");
+    } catch (e) {
+      console.error("Failed to send ready signal via CoreIPC:", e);
+    }
+    return;
+  }
+`;
 var SIGNAL_READY_NODE = `async function signalReady() {
+${SIGNAL_READY_IPC}
   const socketPath = (typeof Deno !== "undefined" ? Deno.env.get("JS_FUNCTION_API_SOCKET") : process.env.JS_FUNCTION_API_SOCKET);
   if (!socketPath) {
     return;
@@ -3999,26 +4548,7 @@ var SIGNAL_READY_NODE = `async function signalReady() {
   });
 }`;
 var SIGNAL_READY_DENO = `async function signalReady() {
-  const ipcEndpoint = (typeof Deno !== "undefined" ? Deno.env.get("JS_FUNCTION_API_IPC_ENDPOINT") : process.env.JS_FUNCTION_API_IPC_ENDPOINT);
-  if (ipcEndpoint) {
-    console.log("Signaling ready to handler via CoreIPC on endpoint: " + ipcEndpoint);
-    try {
-      const { ipc } = await import("@uipath/coreipc");
-      class IJsFunctionApi {
-        SignalReady() { throw void 0; }
-      }
-      const proxy = ipc.proxy
-        .withAddress(ipc.namedPipe(ipcEndpoint))
-        .withService(IJsFunctionApi);
-      await proxy.SignalReady();
-      await ipc.disposeChannel(ipc.namedPipe(ipcEndpoint));
-      console.log("Sent ready signal to handler via CoreIPC");
-    } catch (e) {
-      console.error("Failed to send ready signal via CoreIPC:", e);
-    }
-    return;
-  }
-
+${SIGNAL_READY_IPC}
   const socketPath = (typeof Deno !== "undefined" ? Deno.env.get("JS_FUNCTION_API_SOCKET") : process.env.JS_FUNCTION_API_SOCKET);
   if (!socketPath) {
     return;
@@ -4061,7 +4591,7 @@ function syncFunctionsMap(cwd) {
   if (mapsEqual(existing, discovered))
     return false;
   uipathJson.functions = Object.fromEntries(Object.keys(discovered).sort().map((k) => [k, discovered[k]]));
-  writeFileSync7(uipathJsonPath, JSON.stringify(uipathJson, null, 2) + `
+  writeFileSync6(uipathJsonPath, JSON.stringify(uipathJson, null, 2) + `
 `, "utf-8");
   return true;
 }
@@ -4087,6 +4617,16 @@ function mapsEqual(a, b) {
   return ak.length === Object.keys(b).length && ak.every((k) => a[k] === b[k]);
 }
 var DEFAULT_PORT = 7070;
+var LOAD_AGGREGATOR = (aggregatorFile) => `let app;
+try {
+  ({ default: app } = await import("./${aggregatorFile}"));
+} catch (err) {
+  try {
+    const runtime = await import("@uipath/coded-functions-js-runtime");
+    await runtime.reportModuleLoadFailure?.(err);
+  } catch {}
+  throw err;
+}`;
 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(".");
@@ -4112,20 +4652,29 @@ function registerServeCommand(program2) {
         process.exit(1);
       }
     }
-    const extraction = extractProject(uipathJson.functions, cwd);
-    if (opts.production !== true)
-      reportDiagnosticsOrExit(extraction.diagnostics);
+    const contracts = await resolveContracts(uipathJson.functions, cwd, opts.production === true, async () => {
+      const extraction = await extractProject(uipathJson.functions, cwd, executionDeriveOptions());
+      if (opts.production !== true) {
+        reportDiagnosticsOrExit(extraction.diagnostics);
+      } else {
+        await failStartup(describeBlockingDiagnostics(extraction.diagnostics));
+      }
+      return extraction;
+    }).catch(async (err) => {
+      if (err instanceof IncompleteDocumentError)
+        await failStartup(err.message);
+      throw err;
+    });
     const skipInstall = opts.production === true && existsSync7(join9(cwd, SERVER_RUNNER_DIR));
     if (!skipInstall) {
       try {
-        installServerRunner(cwd);
+        installServerRunner(cwd, { production: opts.production === true });
       } catch (err) {
         console.error(err instanceof Error ? err.message : String(err));
         process.exit(1);
       }
     }
-    const derived = toDerivedContracts(extraction.functions);
-    const aggregatorPath = generateAggregator(uipathJson.functions, cwd, "serve", derived);
+    const aggregatorPath = generateAggregator(uipathJson.functions, cwd, "serve", contracts);
     if (opts.production !== true) {
       freePort(port);
     }
@@ -4160,19 +4709,23 @@ function denoServeArgs(entryPath, opts) {
     entryPath
   ];
 }
-function serveNode(cwd, port, aggregatorPath, production) {
+function writeNodeServeEntry(cwd, port, aggregatorPath) {
   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}
-` + `serveNode(app, port, (port) => {
+  writeFileSync7(nodeEntryPath, `import { serveNode } from "@uipath/coded-functions-js-runtime/node";
+${LOAD_AGGREGATOR(aggregatorFile)}
+const port = Number(process.env.HTTP_SERVER_LISTEN_PORT ?? ${port});
+console.log("http://localhost:" + port);
+${SIGNAL_READY_NODE}
+serveNode(app, port, (port) => {
         console.log(\`JS function node server listening on http://127.0.0.1:\${port}\`);
         signalReady();
       });
 `, "utf-8");
+  return nodeEntryPath;
+}
+function serveNode(cwd, port, aggregatorPath, production) {
+  const nodeEntryPath = writeNodeServeEntry(cwd, port, aggregatorPath);
   const envFile = join9(cwd, ".env");
   let bin;
   let tsxPrefix;
@@ -4203,11 +4756,11 @@ function serveNode(cwd, port, aggregatorPath, production) {
 function writeDenoServeEntry(cwd, port, aggregatorPath) {
   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}
-` + `Deno.serve(
+  writeFileSync7(denoEntryPath, `${LOAD_AGGREGATOR(aggregatorFile)}
+const port = Number(Deno.env.get("HTTP_SERVER_LISTEN_PORT") ?? ${port});
+console.log("http://localhost:" + port);
+${SIGNAL_READY_DENO}
+Deno.serve(
       {
         port,
         onListen: () => {
@@ -4959,7 +5512,7 @@ function strToU8(str, latin1) {
     else if (c < 2048)
       w(192 | c >> 6), w(128 | c & 63);
     else if (c > 55295 && c < 57344)
-      c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i2) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
+      c = 65536 + (c & 1047552) | str.charCodeAt(++i2) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
     else
       w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
   }
@@ -5832,7 +6385,7 @@ async function extractAndWriteEntryPointsAndBindings(aggregatorPath, projectPath
   } 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 '${describeInstallCommand(projectPath)}' first, then retry.`);
+      throw new Error(`Failed to load function modules. Run '${describeInstallCommand()}' first, then retry.`);
     }
     throw new Error(`Manifest extraction failed.
 ${msg}`);
@@ -5844,10 +6397,10 @@ ${msg}`);
   if (manifest.endpoints.length === 0) {
     throw new Error("No functions found. Add at least one defineFunction() in your functions/ directory.");
   }
-  writeEntryPointsAndBindings(toExtractedFunctions(manifest.endpoints), projectPath);
+  await writeEntryPointsAndBindings(toExtractedFunctions(manifest.endpoints), projectPath, false);
   return manifest;
 }
-function writeEntryPointsAndBindings(functions, projectPath) {
+async function writeEntryPointsAndBindings(functions, projectPath, compile) {
   const epPath = join11(projectPath, "entry-points.json");
   let existingEntryPointsDoc = null;
   if (existsSync9(epPath)) {
@@ -5856,7 +6409,9 @@ function writeEntryPointsAndBindings(functions, projectPath) {
     } catch {}
   }
   const entryPointsDoc = buildEntryPointsDoc(functions, existingEntryPointsDoc);
-  writeFileSync9(join11(projectPath, "entry-points.json"), JSON.stringify(entryPointsDoc, null, 2));
+  if (compile)
+    await compileContracts(functions, entryPointsDoc.entryPoints, projectPath);
+  writeFileSync8(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)) {
@@ -5871,7 +6426,7 @@ function writeEntryPointsAndBindings(functions, projectPath) {
     } catch {}
   }
   const bindingsDoc = buildBindingsDoc(functions, entryPointIdByPath, existingBindingsDoc);
-  writeFileSync9(join11(projectPath, "bindings_v2.json"), JSON.stringify(bindingsDoc, null, 2));
+  writeFileSync8(join11(projectPath, "bindings_v2.json"), JSON.stringify(bindingsDoc, null, 2));
 }
 function manifestNeedsExecution(extraction, functionsMap) {
   const forcesExecution = new Set([
@@ -5888,6 +6443,7 @@ function manifestNeedsExecution(extraction, functionsMap) {
   return Object.values(functionsMap).some((v) => !covered.has(v.split(":")[0]));
 }
 async function writeManifest(extraction, aggregatorPath, projectPath, functionsMap) {
+  installServerRunner(projectPath, { production: false });
   if (manifestNeedsExecution(extraction, functionsMap)) {
     const manifest = await extractAndWriteEntryPointsAndBindings(aggregatorPath, projectPath);
     return { count: manifest.endpoints.length, static: false };
@@ -5896,9 +6452,26 @@ async function writeManifest(extraction, aggregatorPath, projectPath, functionsM
   if (functions.length === 0) {
     throw new Error("No functions found. Add at least one defineFunction() in your functions/ directory.");
   }
-  writeEntryPointsAndBindings(functions, projectPath);
+  await writeEntryPointsAndBindings(functions, projectPath, true);
   return { count: functions.length, static: true };
 }
+async function compileContracts(functions, entryPoints, projectPath) {
+  const shim = join11(projectPath, SERVER_RUNNER_DIR, "compile-contracts.mjs");
+  writeFileSync8(shim, `export { createApp } from "@uipath/coded-functions-js-runtime";
+`);
+  const { createApp } = await import(pathToFileURL2(shim).href);
+  const byPath = new Map(entryPoints.filter((ep) => ep.type === "function").map((ep) => [ep.filePath, ep]));
+  for (const fn of functions) {
+    const ep = byPath.get("content/" + (fn.functionPath ?? ""));
+    try {
+      createApp([{ functionPath: fn.functionPath, functionDef: { ...fn, input: ep?.input, output: ep?.output, contractVersion: "v1", handler: () => {
+        return;
+      } } }]);
+    } catch (err2) {
+      throw new Error(`${fn.name ?? fn.functionPath}: the runtime rejects this contract. ${err2.message}`);
+    }
+  }
+}
 async function generateManifests(projectPath) {
   const uipathJsonPath = join12(projectPath, "uipath.json");
   if (!existsSync10(uipathJsonPath)) {
@@ -5915,17 +6488,13 @@ async function generateManifests(projectPath) {
   const previousDesignTime = process.env[DESIGN_TIME_ENV];
   process.env[DESIGN_TIME_ENV] = "1";
   try {
-    const extraction = extractProject(uipathJson.functions, projectPath);
+    const extraction = await 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 = manifestNeedsExecution(extraction, uipathJson.functions);
-    if (needsExecution) {
-      installServerRunner(projectPath);
-    }
+    const aggregatorPath = generateAggregator(uipathJson.functions, projectPath, "serve", contractsFromExtraction(extraction));
     console.log("Extracting function manifest...");
     return await writeManifest(extraction, aggregatorPath, projectPath, uipathJson.functions);
   } finally {
@@ -5956,7 +6525,7 @@ function registerPackCommand(program2) {
     const version = packageJson.version ?? "1.0.0";
     if (!uipathJson.projectId) {
       uipathJson.projectId = randomUUID();
-      writeFileSync10(uipathJsonPath, JSON.stringify(uipathJson, null, 2), "utf-8");
+      writeFileSync9(uipathJsonPath, JSON.stringify(uipathJson, null, 2), "utf-8");
     }
     console.log("Assembling package...");
     const outputDir = join13(cwd, ".uipath", "package-build");
@@ -6002,7 +6571,7 @@ function zipToNupkg(buildDir, cwd, packageId, version) {
   const zipped = zipSync(files);
   mkdirSync5(join13(cwd, ".uipath"), { recursive: true });
   const nupkgPath = join13(cwd, ".uipath", `${packageId}.${version}.nupkg`);
-  writeFileSync10(nupkgPath, zipped);
+  writeFileSync9(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;
@@ -6225,7 +6794,7 @@ function readLocalStudioMetadata(projectDir) {
 function writeStudioMetadata(projectDir, metadata) {
   const path3 = join15(projectDir, STUDIO_METADATA_PATH);
   mkdirSync6(dirname4(path3), { recursive: true });
-  writeFileSync11(path3, JSON.stringify(metadata, null, 2) + `
+  writeFileSync10(path3, JSON.stringify(metadata, null, 2) + `
 `, "utf-8");
   return path3;
 }
@@ -6333,8 +6902,11 @@ function collectLocalFiles(projectDir) {
   walk(projectDir);
   return results;
 }
+function studioApiBase(cfg) {
+  return `${cfg.baseUrl}/${cfg.orgId}/studio_/backend/api`;
+}
 function projectBase(cfg) {
-  return `${cfg.baseUrl}/${cfg.orgId}/studio_/backend/api/Project/${cfg.projectId}`;
+  return `${studioApiBase(cfg)}/Project/${cfg.projectId}`;
 }
 function authHeaders(cfg, lockKey) {
   const h = {
@@ -6345,7 +6917,50 @@ function authHeaders(cfg, lockKey) {
     h["x-uipath-sw-lockkey"] = lockKey;
   return h;
 }
+async function getJson(cfg, url) {
+  const res = await fetch(url, { headers: authHeaders(cfg) }).catch(() => null);
+  if (!res?.ok || res.status === 204)
+    return null;
+  return await res.json().catch(() => null);
+}
+async function serverDrivesLocking(cfg) {
+  const config = await getJson(cfg, `${studioApiBase(cfg)}/Locks/Configuration`);
+  return config?.serverDrivesLockingStrategies === true;
+}
+function serverLocksUrl(cfg, query, lockKey) {
+  const keySegment = lockKey ? `/${encodeURIComponent(lockKey)}` : "";
+  return `${studioApiBase(cfg)}/Locks${keySegment}?${new URLSearchParams(query)}`;
+}
 async function acquireLock(cfg) {
+  return await serverDrivesLocking(cfg) ? acquireServerDrivenLock(cfg) : acquireClientDrivenLock(cfg);
+}
+async function acquireServerDrivenLock(cfg) {
+  const project = await getJson(cfg, projectBase(cfg));
+  const solutionId = project?.solutionId;
+  const projectScope = solutionId ? { sId: solutionId, pId: cfg.projectId } : { pId: cfg.projectId };
+  const existing = await getJson(cfg, serverLocksUrl(cfg, projectScope));
+  const lockKey = existing?.lockKey ?? crypto.randomUUID();
+  const sharedOnly = existing?.lockKey ? existing.isShared ?? false : true;
+  const putRes = await fetch(serverLocksUrl(cfg, projectScope, lockKey), {
+    method: "PUT",
+    headers: { ...authHeaders(cfg), "Content-Type": "application/json" },
+    body: JSON.stringify({ sharedOnly })
+  });
+  if (putRes.status === 409 || putRes.status === 423)
+    throw lockedError();
+  if (!putRes.ok) {
+    const text = await putRes.text().catch(() => "");
+    throw new Error(`Failed to acquire project lock: ${putRes.status}
+${text}`);
+  }
+  const releaseScope = solutionId ? { sId: solutionId } : { pId: cfg.projectId };
+  return {
+    key: lockKey,
+    owned: !existing?.lockKey,
+    serverReleaseQuery: { ...releaseScope, sharedOnly: String(sharedOnly) }
+  };
+}
+async function acquireClientDrivenLock(cfg) {
   const getRes = await fetch(`${projectBase(cfg)}/Lock?api-version=2`, {
     headers: authHeaders(cfg)
   });
@@ -6370,10 +6985,11 @@ ${text}`);
   }
   return { key: lockKey, owned: true };
 }
-async function releaseLock(cfg, lockKey) {
-  await fetch(`${projectBase(cfg)}/Lock/${lockKey}?api-version=2`, {
+async function releaseLock(cfg, lock) {
+  const url = lock.serverReleaseQuery ? serverLocksUrl(cfg, lock.serverReleaseQuery, lock.key) : `${projectBase(cfg)}/Lock/${lock.key}?api-version=2`;
+  await fetch(url, {
     method: "DELETE",
-    headers: authHeaders(cfg, lockKey)
+    headers: authHeaders(cfg, lock.key)
   }).catch(() => {});
 }
 async function fetchStructure(cfg) {
@@ -6450,7 +7066,8 @@ async function downloadFile(cfg, fileId) {
 function isProtectedRemotePath(path3) {
   return path3 === "project.uiproj" || path3 === ".project" || path3.startsWith(".project/") || path3 === ".uipath" || path3.startsWith(".uipath/") || path3 === ".settings" || path3.startsWith(".settings/");
 }
-async function computePlan(cfg, localFiles, structure) {
+var EVALS_DIR = "evals";
+async function computePlan(cfg, localFiles, structure, keepRemoteEvals) {
   const remoteFileMap = new Map(structure.files.map((f) => [f.path, f]));
   const plan = {
     filesToUpload: [],
@@ -6459,9 +7076,11 @@ async function computePlan(cfg, localFiles, structure) {
   };
   const localPaths = new Set(localFiles.map((f) => f.remotePath));
   for (const rf of structure.files) {
-    if (!localPaths.has(rf.path) && !isProtectedRemotePath(rf.path)) {
-      plan.filesToDelete.push(rf);
-    }
+    if (localPaths.has(rf.path) || isProtectedRemotePath(rf.path))
+      continue;
+    if (keepRemoteEvals && rf.path.startsWith(`${EVALS_DIR}/`))
+      continue;
+    plan.filesToDelete.push(rf);
   }
   const comparisons = localFiles.map(async (lf) => {
     const remote = remoteFileMap.get(lf.remotePath);
@@ -6520,7 +7139,9 @@ async function pushToStudio(cfg, projectDir, localFiles, onProgress) {
     log("Fetching remote structure...");
     const structure = await fetchStructure(cfg);
     log("Computing diff...");
-    const plan = await computePlan(cfg, localFiles, structure);
+    const evalsDir = statSync3(join16(projectDir, EVALS_DIR), { throwIfNoEntry: false });
+    const keepRemoteEvals = !evalsDir?.isDirectory();
+    const plan = await computePlan(cfg, localFiles, structure, keepRemoteEvals);
     const total = plan.filesToUpload.length + plan.filesToUpdate.length + plan.filesToDelete.length;
     const remoteMetadata = structure.files.find((f) => f.path === STUDIO_METADATA_PATH);
     if (total === 0 && remoteMetadata) {
@@ -6533,7 +7154,7 @@ async function pushToStudio(cfg, projectDir, localFiles, onProgress) {
     await cleanupEmptyFolders(cfg, lock.key);
   } finally {
     if (lock?.owned) {
-      await releaseLock(cfg, lock.key);
+      await releaseLock(cfg, lock);
     }
   }
 }
@@ -6593,16 +7214,13 @@ Create the project in Studio Web first to get UIPATH_PROJECT_ID.`);
     }
     if (!uipathJson.projectId) {
       uipathJson.projectId = creds.projectId;
-      writeFileSync12(uipathJsonPath, JSON.stringify(uipathJson, null, 2) + `
+      writeFileSync11(uipathJsonPath, JSON.stringify(uipathJson, null, 2) + `
 `, "utf-8");
     }
     console.log("Generating entry-points.json...");
-    const extraction = extractProject(uipathJson.functions, cwd);
+    const extraction = await extractProject(uipathJson.functions, cwd);
     reportDiagnosticsOrExit(extraction.diagnostics);
-    const aggregatorPath = generateAggregator(uipathJson.functions, cwd, "serve", toDerivedContracts(extraction.functions));
-    if (manifestNeedsExecution(extraction, uipathJson.functions)) {
-      installServerRunner(cwd);
-    }
+    const aggregatorPath = generateAggregator(uipathJson.functions, cwd, "serve", contractsFromExtraction(extraction));
     try {
       const result = await writeManifest(extraction, aggregatorPath, cwd, uipathJson.functions);
       console.log(`  ${result.count} function(s) exported — ${result.static ? "extracted statically" : "executed to extract"}.`);
@@ -6627,8 +7245,12 @@ Push complete.`);
     }
   });
 }
-var DERIVED_CONTRACT_FILE = ".uipath/run/derived-contracts.json";
-function resolveTargetFile(cwd, opts) {
+function contractFilePath(cwd) {
+  const jobDir = process.env.JOB_WORKING_DIRECTORY;
+  const fileName = jobDir ? `contract.${basename5(jobDir)}.json` : "contract.json";
+  return join18(cwd, ".uipath", "run", fileName);
+}
+function resolveTargetEntry(cwd, opts) {
   let entry = opts.entrypoint;
   if (!entry && opts.function) {
     const mapped = readFunctionsMap(cwd)[opts.function];
@@ -6640,19 +7262,25 @@ function resolveTargetFile(cwd, opts) {
   const match = entry.match(/^(.*?):([A-Za-z_$][\w$]*)$/);
   const filePart = match ? match[1] : entry;
   const abs = isAbsolute3(filePart) ? filePart : resolve8(cwd, filePart);
-  return relative3(cwd, abs);
+  return { file: relative3(cwd, abs), exportName: match ? match[2] : "default" };
 }
-function writeDerivedContract(cwd, opts) {
+async function writeContractFile(cwd, opts) {
   try {
-    const relFile = resolveTargetFile(cwd, opts);
-    if (!relFile)
+    const target = resolveTargetEntry(cwd, opts);
+    if (!target)
       return "";
-    const derived = opts.production ? readBakedContract(relFile, cwd) : deriveRunContract(relFile, cwd);
-    if (!derived)
+    const fromDocument = opts.production === true && !derivesFromSource();
+    const contract = fromDocument && target.exportName === "default" ? contractFromDocument(target.file, cwd) : await extractContract(target.file, cwd, target.exportName, executionDeriveOptions(), !fromDocument);
+    if (!contract)
       return "";
-    const outPath = join18(cwd, DERIVED_CONTRACT_FILE);
-    mkdirSync7(join18(cwd, ".uipath/run"), { recursive: true });
-    writeFileSync13(outPath, JSON.stringify(derived), "utf-8");
+    const outPath = contractFilePath(cwd);
+    mkdirSync7(dirname5(outPath), { recursive: true });
+    writeFileSync12(outPath, JSON.stringify(contract), "utf-8");
+    process.once("exit", () => {
+      try {
+        rmSync2(outPath, { force: true });
+      } catch {}
+    });
     return outPath;
   } catch (err2) {
     console.error("contract preparation skipped: " + (err2 instanceof Error ? err2.message : String(err2)));
@@ -6726,13 +7354,16 @@ function registerRunCommand(program2) {
     const skipInstall = opts.production === true && existsSync16(join19(cwd, SERVER_RUNNER_DIR));
     if (!skipInstall) {
       try {
-        installServerRunner(cwd);
+        installServerRunner(cwd, { production: opts.production === true });
       } catch (err2) {
         console.error(err2 instanceof Error ? err2.message : String(err2));
         process.exit(1);
       }
     }
-    const derivedFile = writeDerivedContract(cwd, opts);
+    if (syncFunctionsMap(cwd)) {
+      console.log("Updated functions map in uipath.json.");
+    }
+    const derivedFile = await writeContractFile(cwd, opts);
     const runOpts = { ...opts, derivedFile };
     if (opts.runtime === "deno") {
       runDeno(cwd, runOpts);
@@ -6780,7 +7411,7 @@ function readIfPresent(path3) {
 }
 function removeQuietly(path3) {
   try {
-    rmSync2(path3, { force: true });
+    rmSync3(path3, { force: true });
     return true;
   } catch {
     return false;
@@ -6795,7 +7426,7 @@ function writeRunEntry(cwd, fileName, content) {
   }
   const tmp = `${entryPath}.${process.pid}.tmp`;
   try {
-    writeFileSync14(tmp, content, "utf-8");
+    writeFileSync13(tmp, content, "utf-8");
     renameSync(tmp, entryPath);
   } catch (err2) {
     removeQuietly(tmp);
@@ -6915,22 +7546,10 @@ function registerPrepareRuntimeCommand(program2) {
       process.exit(1);
     }
     mkdirSync9(runnerDir, { recursive: true });
-    const pkg = {
-      name: "runner",
-      private: true,
-      type: "module",
-      dependencies: {
-        "@uipath/coded-functions-js-runtime": RUNTIME_VERSION,
-        "@uipath/coreipc": COREIPC_VERSION,
-        tsx: TSX_VERSION,
-        "@microsoft/signalr": SIGNALR_VERSION,
-        "@jridgewell/trace-mapping": TRACE_MAPPING_VERSION
-      }
-    };
+    const pkg = runnerManifest();
     const pkgPath = join20(runnerDir, "package.json");
-    writeFileSync15(pkgPath, JSON.stringify(pkg, null, 2), "utf-8");
+    writeFileSync14(pkgPath, JSON.stringify(pkg, null, 2), "utf-8");
     console.log(`Wrote ${pkgPath}`);
-    writeRunnerRegistryConfig(runnerDir);
     console.log("Installing dependencies...");
     try {
       manager.runInstall(runnerDir, { production: true });
@@ -6942,10 +7561,10 @@ function registerPrepareRuntimeCommand(program2) {
   });
 }
 function registerInstallServerCommand(program2) {
-  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) => {
+  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").option("--hard-link", "Hard-link the template's files instead of copying them").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 {
-      provisionPackage(cwd, opts.template, opts.packageManager);
+      provisionPackage(cwd, opts.template, opts.packageManager, opts.hardLink);
     } catch (err2) {
       console.error(err2 instanceof Error ? err2.message : String(err2));
       process.exit(1);
@@ -6957,8 +7576,31 @@ var DEFAULT_HUB = "http://127.0.0.1:5099/signalr/robotdebug";
 var DEFAULT_INSPECT = "127.0.0.1:9231";
 var BRIDGE_FILE = "debug-bridge.ts";
 var WORKER_FILE = "debug-job-worker.ts";
+function parseDebugRuntime(value) {
+  return value === "node" || value === "deno" ? value : undefined;
+}
+var MAX_ATTACH_TIMEOUT_SECONDS = 86400;
+function parseAttach(attach, runAsJob) {
+  if (attach === true && !runAsJob) {
+    throw new Error("--attach requires --run-as-job.");
+  }
+  return attach === true;
+}
+function parseAttachTimeout(value, attach) {
+  if (value === undefined) {
+    return;
+  }
+  const seconds = Number(value);
+  if (!Number.isInteger(seconds) || seconds < 1 || seconds > MAX_ATTACH_TIMEOUT_SECONDS) {
+    throw new Error(`--attach-timeout must be a whole number of seconds from 1 to ${MAX_ATTACH_TIMEOUT_SECONDS}.`);
+  }
+  if (!attach) {
+    throw new Error("--attach-timeout requires --attach.");
+  }
+  return seconds;
+}
 function resolveDebugAssetsDir(moduleUrl) {
-  const moduleDir = dirname5(fileURLToPath2(moduleUrl));
+  const moduleDir = dirname6(fileURLToPath2(moduleUrl));
   const candidates = [
     join21(moduleDir, "deno-runtime", "debug"),
     join21(moduleDir, "..", "deno-runtime", "debug"),
@@ -6976,11 +7618,11 @@ function stageDebugAssets(cwd) {
   mkdirSync10(stagedDir, { recursive: true });
   const assetsDir = resolveDebugAssetsDir(import.meta.url);
   for (const entry of readdirSync6(assetsDir)) {
-    writeFileSync16(join21(stagedDir, entry), readFileSync16(join21(assetsDir, entry), "utf-8"), "utf-8");
+    writeFileSync15(join21(stagedDir, entry), readFileSync16(join21(assetsDir, entry), "utf-8"), "utf-8");
   }
   return { bridge: join21(stagedDir, BRIDGE_FILE), worker: join21(stagedDir, WORKER_FILE) };
 }
-function buildBridgeSpawn(bridgePath, workerEntry, opts) {
+function buildBridgeSpawn(bridgePath, workerEntry, opts, nodeLoader = []) {
   const modeEnv = opts.runAsJob ? {
     DEBUG_RUN_AS_JOB: "1",
     FN_ENTRYPOINT: opts.entrypoint,
@@ -6988,27 +7630,33 @@ function buildBridgeSpawn(bridgePath, workerEntry, opts) {
     FN_INPUT_FILE: opts.inputFile,
     FN_CONTEXT: opts.context,
     FN_CONTEXT_FILE: opts.contextFile,
-    FN_DERIVED_FILE: opts.derivedFile
+    FN_DERIVED_FILE: opts.derivedFile,
+    ...opts.attach ? { DEBUG_ATTACH: "1" } : {},
+    ...opts.attachTimeoutSeconds ? { DEBUG_ATTACH_TIMEOUT_MS: String(opts.attachTimeoutSeconds * 1000) } : {}
   } : {
     DEBUG_RUN_AS_JOB: "0",
     FN_NAME: opts.functionName,
     FN_FILE: opts.functionFile,
     FN_PORT: String(opts.port ?? DEFAULT_PORT2)
   };
-  return {
-    args: [
-      "run",
-      "--node-modules-dir=manual",
+  const envFileArg = opts.envFile ? [`--env-file=${opts.envFile}`] : [];
+  const args = opts.runtime === "deno" ? [
+    "run",
+    "--node-modules-dir=manual",
+    ...opts.production ? denoPermissionFlags(process.cwd(), true) : [
       "--allow-env",
       "--allow-net",
       "--allow-read",
       "--allow-write",
       "--allow-run",
-      ...opts.runAsJob ? ["--allow-sys"] : [],
-      ...opts.envFile ? [`--env-file=${opts.envFile}`] : [],
-      `--inspect=${opts.inspect}`,
-      bridgePath
+      ...opts.runAsJob ? ["--allow-sys"] : []
     ],
+    ...envFileArg,
+    `--inspect=${opts.inspect}`,
+    bridgePath
+  ] : [`--inspect=${opts.inspect}`, ...nodeLoader, ...envFileArg, bridgePath];
+  return {
+    args,
     env: {
       DEBUG_SESSION_ID: opts.session,
       HUB_URL: opts.hub,
@@ -7021,9 +7669,23 @@ 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. 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) => {
+  program2.command("debug").description("Debug a coded function: bridges StudioWeb's SignalR DebugHub to the V8 inspector of a Node (default) or Deno debuggee for line breakpoints.").option("--runtime <runtime>", "Runtime hosting the bridge and its debuggee: node (default) or deno", "node").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, and give the debuggee run --production's permissions").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.", "").option("--attach", "Run-as-job mode: a debugger attaches to this job instead of launching it. The job runs its own input and function once, keeps running when the debugger leaves, and reports its result as `run` does").option("--attach-timeout <seconds>", `With --attach: run the job without a debugger when none attaches within this many seconds (1-${MAX_ATTACH_TIMEOUT_SECONDS})`).action(async (opts) => {
     const cwd = resolve12(".");
     const runAsJob = opts.runAsJob === true;
+    let attach = false;
+    let attachTimeoutSeconds;
+    try {
+      attach = parseAttach(opts.attach, runAsJob);
+      attachTimeoutSeconds = parseAttachTimeout(opts.attachTimeout, attach);
+    } catch (err2) {
+      console.error(err2 instanceof Error ? err2.message : String(err2));
+      process.exit(1);
+    }
+    const runtime = parseDebugRuntime(opts.runtime);
+    if (!runtime) {
+      console.error(`Unknown runtime: ${opts.runtime}. Use node or deno.`);
+      process.exit(1);
+    }
     if (opts.entrypoint && !runAsJob) {
       console.error("--entrypoint requires --run-as-job.");
       process.exit(1);
@@ -7036,6 +7698,10 @@ function registerDebugCommand(program2) {
       console.error("Provide only one of --entrypoint or --function.");
       process.exit(1);
     }
+    if (runtime === "deno" && !denoAvailable()) {
+      console.error("Deno not found. Install it with 'uipath-functions setup --runtime deno', or pass --runtime node.");
+      process.exit(1);
+    }
     const uipathJsonPath = join21(cwd, "uipath.json");
     if (!existsSync17(uipathJsonPath) && (!runAsJob || !opts.entrypoint)) {
       console.error("No uipath.json found. Run 'uipath-functions init' first.");
@@ -7094,44 +7760,44 @@ function registerDebugCommand(program2) {
     const skipInstall = opts.production === true && existsSync17(join21(cwd, SERVER_RUNNER_DIR));
     if (!skipInstall) {
       try {
-        installServerRunner(cwd);
+        installServerRunner(cwd, { production: opts.production === true });
       } 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.");
+    let nodeLoader = [];
+    if (runtime === "node") {
+      const loader = resolveTsxLoader(cwd);
+      if (!loader) {
+        console.error(`tsx not found in ${SERVER_RUNNER_DIR}. Run 'uipath-functions install-server' and retry.`);
         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;
+      nodeLoader = loader;
     }
     const staged = stageDebugAssets(cwd);
     let workerEntry;
     let derivedFile = "";
     if (runAsJob) {
-      derivedFile = writeDerivedContract(cwd, { entrypoint: opts.entrypoint, function: opts.function, production: opts.production });
+      derivedFile = await writeContractFile(cwd, { entrypoint: opts.entrypoint, function: opts.function, production: opts.production });
       workerEntry = staged.worker;
     } else {
-      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);
+      const contracts = await resolveContracts(functions, cwd, opts.production === true, async () => {
+        const extraction = await extractProject(functions, cwd, executionDeriveOptions());
+        reportDiagnosticsOrExit(extraction.diagnostics);
+        return extraction;
+      }).catch((err2) => {
+        if (!(err2 instanceof IncompleteDocumentError))
+          throw err2;
+        console.error(err2.message);
+        process.exit(1);
+      });
+      const aggregatorPath = generateAggregator(functions, cwd, "serve", contracts);
+      workerEntry = runtime === "deno" ? writeDenoServeEntry(cwd, port, aggregatorPath) : writeNodeServeEntry(cwd, port, aggregatorPath);
       freePort(port);
     }
     const resolved = {
+      runtime,
       session: opts.session && opts.session.length > 0 ? opts.session : randomUUID2(),
       hub: opts.hub,
       inspect: opts.inspect,
@@ -7139,27 +7805,30 @@ function registerDebugCommand(program2) {
       runAsJob,
       entrypoint: opts.entrypoint ?? "",
       functionName: fnName,
-      functionFile: fnName ? resolveTargetFile(cwd, { function: fnName }) ?? "" : "",
+      functionFile: fnName ? resolveTargetEntry(cwd, { function: fnName })?.file ?? "" : "",
       input: inputJson,
       inputFile: opts.inputFile ?? "",
       context: opts.context ?? "",
       contextFile: opts.contextFile ?? "",
       token: opts.token && opts.token.length > 0 ? opts.token : process.env.HUB_ACCESS_TOKEN ?? "",
       envFile: existsSync17(join21(cwd, ".env")) ? ".env" : "",
-      derivedFile
+      derivedFile,
+      production: opts.production === true,
+      ...attach ? { attach } : {},
+      ...attachTimeoutSeconds ? { attachTimeoutSeconds } : {}
     };
-    const { args, env } = buildBridgeSpawn(staged.bridge, workerEntry, resolved);
+    const { args, env } = buildBridgeSpawn(staged.bridge, workerEntry, resolved, nodeLoader);
     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 = resolveDeno();
-    const proc = spawn3(deno, args, {
+    console.log(runAsJob ? `Debug bridge: runtime=${runtime} session=${resolved.session} hub=${resolved.hub} job=${target} inspector=${resolved.inspect}` : `Debug bridge: runtime=${runtime} session=${resolved.session} hub=${resolved.hub} function=${fnName} port=${port} inspector=${resolved.inspect}`);
+    const bin = runtime === "deno" ? resolveDeno() : "node";
+    const proc = spawn3(bin, args, {
       cwd,
       env: { ...process.env, ...env },
       stdio: "inherit"
     });
     proc.on("error", (err2) => {
       if (err2.code === "ENOENT") {
-        console.error("Deno not found. Run 'uipath-functions setup --runtime deno'.");
+        console.error(runtime === "deno" ? "Deno not found. Run 'uipath-functions setup --runtime deno'." : "node not found. Run 'uipath-functions setup'.");
       } else {
         console.error(err2);
       }
@@ -7168,7 +7837,7 @@ function registerDebugCommand(program2) {
     proc.on("exit", (code) => process.exit(code ?? 0));
   });
 }
-var __dirname3 = dirname6(fileURLToPath3(import.meta.url));
+var __dirname3 = dirname7(fileURLToPath3(import.meta.url));
 var pkg = JSON.parse(readFileSync17(join22(__dirname3, "..", "package.json"), "utf-8"));
 function buildProgram() {
   const program2 = new Command;
@@ -7195,4 +7864,4 @@ export {
   generateManifests
 };
 
-//# debugId=94EBF991AB3525F364756E2164756E21
+//# debugId=D0840AE987D2809064756E2164756E21