@faapi/faapi 6.23.0 → 6.24.0

package/dist/cli/index.js

@@ -649,9 +649,9 @@ var init_constants = __esm({
 });
 
 // src/utils/normalizePath.ts
-function normalizePath(path35) {
-  if (!path35) return "";
-  let result = path35.replace(/\\/g, "/");
+function normalizePath(path34) {
+  if (!path34) return "";
+  let result = path34.replace(/\\/g, "/");
   result = result.replace(/\/+/g, "/");
   result = result.replace(/\/+$/, "");
   if (result && !result.startsWith("/")) {
@@ -3082,8 +3082,6 @@ var init_generateToolArtifacts = __esm({
 
 // src/agents/scanAgents.ts
 import fg3 from "fast-glob";
-import path15 from "path";
-import fs12 from "fs";
 function extractAgentNameFromPath(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
   const match = normalized.match(/(?:^|\/)agents\/(.+)\/handler\.ts$/);
@@ -3094,11 +3092,6 @@ function extractAgentNameFromPath(filePath) {
   }
   return match[1].replace(/\//g, ".");
 }
-function detectAgentExports(source) {
-  return {
-    hasRun: RUN_EXPORT_RE.test(source)
-  };
-}
 async function scanAgents(rootDir, patterns) {
   const files = await fg3(patterns, {
     cwd: rootDir,
@@ -3113,9 +3106,6 @@ async function scanAgents(rootDir, patterns) {
     if (fileName !== "handler.ts" && fileName !== "handler.js") {
       continue;
     }
-    const absPath = path15.resolve(rootDir, normalizedFile);
-    const source = await fs12.promises.readFile(absPath, "utf8").catch(() => "");
-    const { hasRun } = detectAgentExports(source);
     const name = extractAgentNameFromPath(normalizedFile);
     const prevFile = seen.get(name);
     if (prevFile) {
@@ -3126,18 +3116,16 @@ async function scanAgents(rootDir, patterns) {
     seen.set(name, normalizedFile);
     agents.push({
       name,
-      filePath: normalizedFile,
-      hasRun
+      filePath: normalizedFile
     });
   }
   return agents;
 }
-var DEFAULT_AGENT_PATTERNS, RUN_EXPORT_RE;
+var DEFAULT_AGENT_PATTERNS;
 var init_scanAgents = __esm({
   "src/agents/scanAgents.ts"() {
     "use strict";
     DEFAULT_AGENT_PATTERNS = ["src/agents/**/handler.ts"];
-    RUN_EXPORT_RE = /export\s+(?:async\s+)?(?:function\s+|const\s+)run\b/;
   }
 });
 
@@ -3146,12 +3134,21 @@ import ts11 from "typescript";
 function extractAgentMetadata(program, filePath, pathMeta) {
   const sourceFile = program.getSourceFile(filePath);
   if (!sourceFile) return null;
+  const runOwner = findRunExportOwner(sourceFile);
+  if (runOwner) {
+    throw SchemaExtractionError.at(
+      runOwner,
+      "run",
+      "agent \u81EA\u5B9A\u4E49 run \u5DF2\u79FB\u9664\u2014\u2014agent \u7EDF\u4E00\u4E3A\u58F0\u660E\u5F0F\u6267\u884C\uFF08config + \u9ED8\u8BA4 reactLoop\uFF09\u3002\u7F16\u6392\u573A\u666F\u8BF7\u6CE8\u518C tool\uFF08src/tools/ \u4E0B\u5BFC\u51FA\u51FD\u6570\uFF0C\u6709 schema/trace/\u9274\u6743\u94A9\u5B50\uFF09\uFF0C\u591A agent \u534F\u4F5C\u7528 config.agents \u58F0\u660E sub-agent",
+      sourceFile
+    );
+  }
   const configFound = findConfigExport(sourceFile);
   if (!configFound) {
     throw SchemaExtractionError.at(
       sourceFile,
       "config.systemPrompt",
-      "agent \u5FC5\u586B\u2014\u2014\u8BF7\u5728 config \u5757\u58F0\u660E\u7CFB\u7EDF\u63D0\u793A\u8BCD\uFF08\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u3001\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\u6216\u5176 + \u62FC\u63A5\uFF09",
+      "agent \u5FC5\u586B\u2014\u2014\u8BF7\u5728 config \u5757\u58F0\u660E systemPrompt\uFF08\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u3001\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\u6216\u5176 + \u62FC\u63A5\uFF09\u6216 systemPromptFile\uFF08\u76F8\u5BF9 resources \u76EE\u5F55\u7684\u8DEF\u5F84\u5B57\u9762\u91CF\uFF09\u4E8C\u9009\u4E00",
       sourceFile
     );
   }
@@ -3167,16 +3164,13 @@ function extractAgentMetadata(program, filePath, pathMeta) {
   const jsDoc = getJSDocFromNode(configFound.jsDocOwner);
   const description = extractDescription(jsDoc);
   const agentNameOverride = extractJSDocTagValue(jsDoc, "agent");
-  const { systemPrompt, tools, agents, model, maxTurns, inputDescription } = extractConfigFields(
-    objectLiteral,
-    sourceFile
-  );
+  const { systemPrompt, systemPromptFile, tools, agents, model, maxTurns, inputDescription } = extractConfigFields(objectLiteral, sourceFile);
   return {
     name: agentNameOverride ?? pathMeta.name,
     description,
     filePath: pathMeta.filePath,
-    hasRun: pathMeta.hasRun,
     systemPrompt,
+    systemPromptFile,
     tools,
     agents,
     model,
@@ -3184,6 +3178,25 @@ function extractAgentMetadata(program, filePath, pathMeta) {
     inputDescription
   };
 }
+function findRunExportOwner(sourceFile) {
+  let result = null;
+  ts11.forEachChild(sourceFile, (node) => {
+    if (result) return;
+    if (ts11.isFunctionDeclaration(node) && hasExportModifier(node) && node.name?.text === "run") {
+      result = node;
+      return;
+    }
+    if (ts11.isVariableStatement(node) && hasExportModifier(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (ts11.isIdentifier(decl.name) && decl.name.text === "run") {
+          result = node;
+          return;
+        }
+      }
+    }
+  });
+  return result;
+}
 function findConfigExport(sourceFile) {
   let result = null;
   ts11.forEachChild(sourceFile, (node) => {
@@ -3226,6 +3239,7 @@ function getReturnObjectLiteral(fn) {
 }
 function extractConfigFields(objLit, sourceFile) {
   let systemPrompt;
+  let systemPromptFile;
   let tools;
   let agents;
   let model;
@@ -3249,6 +3263,9 @@ function extractConfigFields(objLit, sourceFile) {
       case "systemPrompt":
         systemPrompt = requireStringValue(prop, "systemPrompt", sourceFile);
         break;
+      case "systemPromptFile":
+        systemPromptFile = requireStringValue(prop, "systemPromptFile", sourceFile);
+        break;
       case "tools":
         tools = requireStringArrayValue(prop, "tools", sourceFile);
         break;
@@ -3268,20 +3285,28 @@ function extractConfigFields(objLit, sourceFile) {
         throw SchemaExtractionError.at(
           prop,
           `config.${propName}`,
-          "\u672A\u77E5 config \u5B57\u6BB5\u2014\u2014\u4EC5\u652F\u6301 systemPrompt / tools / agents / model / maxTurns / inputDescription",
+          "\u672A\u77E5 config \u5B57\u6BB5\u2014\u2014\u4EC5\u652F\u6301 systemPrompt / systemPromptFile / tools / agents / model / maxTurns / inputDescription",
           sourceFile
         );
     }
   }
-  if (systemPrompt === void 0) {
+  if (systemPrompt !== void 0 && systemPromptFile !== void 0) {
+    throw SchemaExtractionError.at(
+      objLit,
+      "config.systemPrompt",
+      "systemPrompt \u4E0E systemPromptFile \u4E92\u65A5\u2014\u2014\u5185\u8054\u7CFB\u7EDF\u63D0\u793A\u8BCD\u4E0E resources \u6587\u4EF6\u4E8C\u9009\u4E00",
+      sourceFile
+    );
+  }
+  if (systemPrompt === void 0 && systemPromptFile === void 0) {
     throw SchemaExtractionError.at(
       objLit,
       "config.systemPrompt",
-      "agent \u5FC5\u586B\u2014\u2014\u8BF7\u5728 config \u5757\u58F0\u660E\u7CFB\u7EDF\u63D0\u793A\u8BCD\uFF08\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u3001\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\u6216\u5176 + \u62FC\u63A5\uFF09",
+      "agent \u5FC5\u586B\u2014\u2014\u8BF7\u5728 config \u5757\u58F0\u660E systemPrompt\uFF08\u5B57\u7B26\u4E32\u5B57\u9762\u91CF\u3001\u65E0\u63D2\u503C\u6A21\u677F\u5B57\u7B26\u4E32\u6216\u5176 + \u62FC\u63A5\uFF09\u6216 systemPromptFile\uFF08\u76F8\u5BF9 resources \u76EE\u5F55\u7684\u8DEF\u5F84\u5B57\u9762\u91CF\uFF09\u4E8C\u9009\u4E00",
       sourceFile
     );
   }
-  return { systemPrompt, tools, agents, model, maxTurns, inputDescription };
+  return { systemPrompt, systemPromptFile, tools, agents, model, maxTurns, inputDescription };
 }
 function getPropertyName(name) {
   if (ts11.isIdentifier(name)) return name.text;
@@ -3364,13 +3389,13 @@ var init_extractAgentMetadata = __esm({
 });
 
 // src/cli/generateAgentArtifacts.ts
-import path16 from "path";
+import path15 from "path";
 function serializeAgents(agents, dist = "dist") {
   return agents.map((a) => ({
     name: a.name,
     description: a.description,
-    hasRun: a.hasRun,
     systemPrompt: a.systemPrompt,
+    systemPromptFile: a.systemPromptFile,
     tools: a.tools,
     agents: a.agents,
     model: a.model,
@@ -3390,8 +3415,8 @@ function hydrateAgents(manifest) {
     name: a.name,
     description: a.description ?? void 0,
     filePath: a.filePath,
-    hasRun: a.hasRun,
     systemPrompt: a.systemPrompt ?? void 0,
+    systemPromptFile: a.systemPromptFile ?? void 0,
     tools: a.tools ?? void 0,
     agents: a.agents ?? void 0,
     model: a.model ?? void 0,
@@ -3423,14 +3448,13 @@ function validateAgentList(metadata) {
 }
 async function generateAgentArtifacts(agents, rootDir, dist) {
   const metadata = [];
-  const programByFile = createPrograms(agents.map((m) => path16.resolve(rootDir, m.filePath)));
+  const programByFile = createPrograms(agents.map((m) => path15.resolve(rootDir, m.filePath)));
   for (const manifest of agents) {
-    const absPath = path16.resolve(rootDir, manifest.filePath);
+    const absPath = path15.resolve(rootDir, manifest.filePath);
     const program = programByFile.get(absPath);
     const result = extractAgentMetadata(program, absPath, {
       name: manifest.name,
-      filePath: manifest.filePath,
-      hasRun: manifest.hasRun
+      filePath: manifest.filePath
     });
     if (!result) {
       throw new Error(
@@ -3441,7 +3465,7 @@ async function generateAgentArtifacts(agents, rootDir, dist) {
   }
   validateAgentList(metadata);
   const serialized = serializeAgents(metadata, dist);
-  const agentsPath = path16.resolve(rootDir, dist, AGENTS_FILE);
+  const agentsPath = path15.resolve(rootDir, dist, AGENTS_FILE);
   await writeAgentsModule(serialized, agentsPath);
   return metadata;
 }
@@ -3459,8 +3483,8 @@ var init_generateAgentArtifacts = __esm({
 
 // src/task/scanTasks.ts
 import fg4 from "fast-glob";
-import path17 from "path";
-import fs13 from "fs";
+import path16 from "path";
+import fs12 from "fs";
 function parseNumericLiteral(raw) {
   return Number(raw.replace(/_/g, ""));
 }
@@ -3482,12 +3506,12 @@ async function scanTasks(rootDir, patterns) {
   const seen = /* @__PURE__ */ new Map();
   for (const file of files) {
     const normalizedFile = file.replace(/\\/g, "/");
-    const fileName = path17.posix.basename(normalizedFile);
+    const fileName = path16.posix.basename(normalizedFile);
     if (fileName !== TASK_FILENAME) {
       continue;
     }
-    const absPath = path17.resolve(rootDir, normalizedFile);
-    const source = await fs13.promises.readFile(absPath, "utf8").catch(() => "");
+    const absPath = path16.resolve(rootDir, normalizedFile);
+    const source = await fs12.promises.readFile(absPath, "utf8").catch(() => "");
     const name = filePathToTaskName(normalizedFile);
     const prevFile = seen.get(name);
     if (prevFile) {
@@ -3536,7 +3560,7 @@ var init_scanTasks = __esm({
 });
 
 // src/cli/generateTaskArtifacts.ts
-import path18 from "path";
+import path17 from "path";
 function serializeTasks(tasks, dist = "dist") {
   return tasks.map((t) => ({
     name: t.name,
@@ -3569,7 +3593,7 @@ function collectTaskSchemaSources(tasks, rootDir) {
   const tasksByFile = /* @__PURE__ */ new Map();
   for (const task of tasks) {
     if (!task.inputTypeName) continue;
-    const absPath = path18.resolve(rootDir, task.filePath);
+    const absPath = path17.resolve(rootDir, task.filePath);
     let list = tasksByFile.get(absPath);
     if (!list) {
       list = [];
@@ -3626,9 +3650,9 @@ function generateTaskSchemaFileSource(sources, resolveType, helpersImportPath) {
 async function generateTaskArtifacts(manifests, rootDir, dist) {
   const metadata = [];
   if (manifests.length > 0) {
-    const programByFile = createPrograms(manifests.map((m) => path18.resolve(rootDir, m.filePath)));
+    const programByFile = createPrograms(manifests.map((m) => path17.resolve(rootDir, m.filePath)));
     for (const manifest of manifests) {
-      const absPath = path18.resolve(rootDir, manifest.filePath);
+      const absPath = path17.resolve(rootDir, manifest.filePath);
       const result = extractToolMetadata(programByFile.get(absPath), absPath, "run", {
         name: manifest.name,
         filePath: manifest.filePath
@@ -3639,7 +3663,7 @@ async function generateTaskArtifacts(manifests, rootDir, dist) {
     }
   }
   const serialized = serializeTasks(manifests, dist);
-  const tasksPath = path18.resolve(rootDir, dist, TASKS_FILE);
+  const tasksPath = path17.resolve(rootDir, dist, TASKS_FILE);
   await writeTasksModule(serialized, tasksPath);
   if (metadata.length === 0) {
     return hydrateTasks(serialized);
@@ -3672,8 +3696,8 @@ var init_generateTaskArtifacts = __esm({
 });
 
 // src/cli/compileSourceFiles.ts
-import path19 from "path";
-import fs14 from "fs";
+import path18 from "path";
+import fs13 from "fs";
 import fg5 from "fast-glob";
 async function compileSourceFiles(options) {
   const { rootDir, dist, files, logLevel = "silent", production, atomicWrite } = options;
@@ -3686,11 +3710,11 @@ async function compileSourceFiles(options) {
   if (entryPoints.length === 0) {
     return { compiledFiles: [] };
   }
-  const absDist = path19.resolve(rootDir, dist);
-  await fs14.promises.mkdir(absDist, { recursive: true });
+  const absDist = path18.resolve(rootDir, dist);
+  await fs13.promises.mkdir(absDist, { recursive: true });
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
-  const outbase = path19.resolve(rootDir, APP_DIR);
+  const outbase = path18.resolve(rootDir, APP_DIR);
   const result = await esbuild.build({
     entryPoints,
     outdir: absDist,
@@ -3710,10 +3734,10 @@ async function compileSourceFiles(options) {
   if (atomicWrite && result.outputFiles) {
     await Promise.all(
       result.outputFiles.map(async (file) => {
-        await fs14.promises.mkdir(path19.dirname(file.path), { recursive: true });
+        await fs13.promises.mkdir(path18.dirname(file.path), { recursive: true });
         const tmp = `${file.path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-        await fs14.promises.writeFile(tmp, file.contents);
-        await fs14.promises.rename(tmp, file.path);
+        await fs13.promises.writeFile(tmp, file.contents);
+        await fs13.promises.rename(tmp, file.path);
       })
     );
   }
@@ -3741,12 +3765,12 @@ var init_compileDevRoutes = __esm({
 });
 
 // src/cli/compileOnDemand.ts
-import path20 from "path";
-import fs15 from "fs";
+import path19 from "path";
+import fs14 from "fs";
 function isProductFresh(sourceAbsPath, productAbsPath) {
   try {
-    const srcStat = fs15.statSync(sourceAbsPath);
-    const prodStat = fs15.statSync(productAbsPath);
+    const srcStat = fs14.statSync(sourceAbsPath);
+    const prodStat = fs14.statSync(productAbsPath);
     return prodStat.mtimeMs >= srcStat.mtimeMs;
   } catch {
     return false;
@@ -3776,7 +3800,7 @@ async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   if (state.compiledFiles.has(sourceAbsPath)) {
     return false;
   }
-  if (!fs15.existsSync(sourceAbsPath)) {
+  if (!fs14.existsSync(sourceAbsPath)) {
     return false;
   }
   const productPath = prodSourcePathToProductPath(sourceAbsPath, rootDir, dist);
@@ -3826,11 +3850,11 @@ async function ensureMiddlewaresCompiled(middlewarePaths, rootDir) {
   }
 }
 function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
-  const rel = path20.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const rel = path19.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   if (!rel.startsWith("src/")) return null;
   const relWithoutSrc = rel.slice(4);
   const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
-  return path20.resolve(rootDir, dist, jsRel);
+  return path19.resolve(rootDir, dist, jsRel);
 }
 function clearGeneratedSchemas() {
   state.generatedSchemas.clear();
@@ -3845,9 +3869,9 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   if (state.generatedSchemas.has(schemaPath)) {
     return false;
   }
-  const prodAbsPath = path20.resolve(rootDir, routeFilePath);
+  const prodAbsPath = path19.resolve(rootDir, routeFilePath);
   const sourceAbsPath = prodPathToSourcePath(prodAbsPath, rootDir, dist);
-  if (!fs15.existsSync(sourceAbsPath)) {
+  if (!fs14.existsSync(sourceAbsPath)) {
     return false;
   }
   if (isProductFresh(sourceAbsPath, schemaPath)) {
@@ -3859,7 +3883,7 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   if (fileRoutes.length === 0 && fileWsRoutes.length === 0) {
     return false;
   }
-  const sourceRelPath = path20.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const sourceRelPath = path19.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
   const sourceWsRoutes = fileWsRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
   const generatePromise = (async () => {
@@ -3881,7 +3905,7 @@ async function deleteSchemaFiles(routes, rootDir, dist) {
     if (deleted.has(schemaPath)) continue;
     deleted.add(schemaPath);
     try {
-      await fs15.promises.unlink(schemaPath);
+      await fs14.promises.unlink(schemaPath);
     } catch {
     }
   }
@@ -3889,19 +3913,19 @@ async function deleteSchemaFiles(routes, rootDir, dist) {
 function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
   const cached = sourcePathCache.get(prodAbsPath);
   if (cached) return cached;
-  const rel = path20.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
+  const rel = path19.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
   let relWithoutDist = rel;
   if (relWithoutDist.startsWith(`${dist}/`)) {
     relWithoutDist = relWithoutDist.slice(dist.length + 1);
   }
   const srcRel = `src/${relWithoutDist}`;
   const tsRel = srcRel.replace(/\.js$/, ".ts");
-  const tsAbs = path20.resolve(rootDir, tsRel);
+  const tsAbs = path19.resolve(rootDir, tsRel);
   let result;
-  if (fs15.existsSync(tsAbs)) {
+  if (fs14.existsSync(tsAbs)) {
     result = tsAbs;
   } else {
-    result = path20.resolve(rootDir, srcRel);
+    result = path19.resolve(rootDir, srcRel);
   }
   sourcePathCache.set(prodAbsPath, result);
   return result;
@@ -3932,15 +3956,15 @@ var init_compileOnDemand = __esm({
 });
 
 // src/config/loadConfig.ts
-import path21 from "path";
-import fs16 from "fs";
+import path20 from "path";
+import fs15 from "fs";
 async function loadConfig(rootDir, dist) {
-  const configProductPath = path21.resolve(rootDir, dist, CONFIG_PRODUCT_FILE);
-  if (fs16.existsSync(configProductPath)) {
+  const configProductPath = path20.resolve(rootDir, dist, CONFIG_PRODUCT_FILE);
+  if (fs15.existsSync(configProductPath)) {
     const module = await importWithCacheBust(configProductPath);
     return module.default ?? {};
   }
-  const hasSourceConfig = fs16.existsSync(path21.join(rootDir, "faapi.config.ts")) || fs16.existsSync(path21.join(rootDir, "faapi.config.js"));
+  const hasSourceConfig = fs15.existsSync(path20.join(rootDir, "faapi.config.ts")) || fs15.existsSync(path20.join(rootDir, "faapi.config.js"));
   if (hasSourceConfig) {
     throw new Error(
       `[faapi] ${dist}/${CONFIG_PRODUCT_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
@@ -3958,8 +3982,8 @@ var init_loadConfig = __esm({
 });
 
 // src/cli/loadEnv.ts
-import fs17 from "fs";
-import path22 from "path";
+import fs16 from "fs";
+import path21 from "path";
 function resolveEnv() {
   return process.env.NODE_ENV || "development";
 }
@@ -4026,9 +4050,9 @@ function loadEnv(rootDir) {
   const files = getEnvFiles(env);
   const merged = {};
   for (const file of files) {
-    const filePath = path22.join(rootDir, file);
-    if (!fs17.existsSync(filePath)) continue;
-    const content = fs17.readFileSync(filePath, "utf-8");
+    const filePath = path21.join(rootDir, file);
+    if (!fs16.existsSync(filePath)) continue;
+    const content = fs16.readFileSync(filePath, "utf-8");
     const parsed = parseEnvFile(content, merged);
     Object.assign(merged, parsed);
   }
@@ -4134,7 +4158,7 @@ var init_esm = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? lstat : stat;
         if (wantBigintFsStats) {
-          this._stat = (path35) => statMethod(path35, { bigint: true });
+          this._stat = (path34) => statMethod(path34, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -4159,8 +4183,8 @@ var init_esm = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path35, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path35));
+              const { path: path34, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path34));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -4200,20 +4224,20 @@ var init_esm = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path35, depth) {
+      async _exploreDir(path34, depth) {
         let files;
         try {
-          files = await readdir(path35, this._rdOptions);
+          files = await readdir(path34, this._rdOptions);
         } catch (error) {
           this._onError(error);
         }
-        return { files, depth, path: path35 };
+        return { files, depth, path: path34 };
       }
-      async _formatEntry(dirent, path35) {
+      async _formatEntry(dirent, path34) {
         let entry;
         const basename3 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = presolve(pjoin(path35, basename3));
+          const fullPath = presolve(pjoin(path34, basename3));
           entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
@@ -4274,16 +4298,16 @@ import { watchFile, unwatchFile, watch as fs_watch } from "fs";
 import { open, stat as stat2, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
 import * as sysPath from "path";
 import { type as osType } from "os";
-function createFsWatchInstance(path35, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path34, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path35);
-    emitRaw(rawEvent, evPath, { watchedPath: path35 });
-    if (evPath && path35 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path35, evPath), KEY_LISTENERS, sysPath.join(path35, evPath));
+    listener(path34);
+    emitRaw(rawEvent, evPath, { watchedPath: path34 });
+    if (evPath && path34 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path34, evPath), KEY_LISTENERS, sysPath.join(path34, evPath));
     }
   };
   try {
-    return fs_watch(path35, {
+    return fs_watch(path34, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -4628,12 +4652,12 @@ var init_handler = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path35, fullPath, options, handlers) => {
+    setFsWatchListener = (path34, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path35, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path34, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -4644,7 +4668,7 @@ var init_handler = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path35,
+          path34,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -4659,7 +4683,7 @@ var init_handler = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error.code === "EPERM") {
             try {
-              const fd = await open(path35, "r");
+              const fd = await open(path34, "r");
               await fd.close();
               broadcastErr(error);
             } catch (err) {
@@ -4690,7 +4714,7 @@ var init_handler = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path35, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path34, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -4712,7 +4736,7 @@ var init_handler = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path35, curr));
+              foreach(cont.listeners, (listener2) => listener2(path34, curr));
             }
           })
         };
@@ -4740,13 +4764,13 @@ var init_handler = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path35, listener) {
+      _watchWithNodeFs(path34, listener) {
         const opts = this.fsw.options;
-        const directory = sysPath.dirname(path35);
-        const basename3 = sysPath.basename(path35);
+        const directory = sysPath.dirname(path34);
+        const basename3 = sysPath.basename(path34);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename3);
-        const absolutePath = sysPath.resolve(path35);
+        const absolutePath = sysPath.resolve(path34);
         const options = {
           persistent: opts.persistent
         };
@@ -4756,12 +4780,12 @@ var init_handler = __esm({
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
           options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path35, absolutePath, options, {
+          closer = setFsWatchFileListener(path34, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path35, absolutePath, options, {
+          closer = setFsWatchListener(path34, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -4783,7 +4807,7 @@ var init_handler = __esm({
         let prevStats = stats;
         if (parent.has(basename3))
           return;
-        const listener = async (path35, newStats) => {
+        const listener = async (path34, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -4797,11 +4821,11 @@ var init_handler = __esm({
                 this.fsw._emit(EV.CHANGE, file, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path35);
+                this.fsw._closeFile(path34);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path35, closer2);
+                  this.fsw._addPathCloser(path34, closer2);
               } else {
                 prevStats = newStats2;
               }
@@ -4833,7 +4857,7 @@ var init_handler = __esm({
        * @param item basename of this item
        * @returns true if no more processing is needed for this entry.
        */
-      async _handleSymlink(entry, directory, path35, item) {
+      async _handleSymlink(entry, directory, path34, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -4843,7 +4867,7 @@ var init_handler = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await fsrealpath(path35);
+            linkPath = await fsrealpath(path34);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -4853,12 +4877,12 @@ var init_handler = __esm({
           if (dir.has(item)) {
             if (this.fsw._symlinkPaths.get(full) !== linkPath) {
               this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, path35, entry.stats);
+              this.fsw._emit(EV.CHANGE, path34, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path35, entry.stats);
+            this.fsw._emit(EV.ADD, path34, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -4887,9 +4911,9 @@ var init_handler = __esm({
             return;
           }
           const item = entry.path;
-          let path35 = sysPath.join(directory, item);
+          let path34 = sysPath.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path35, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path34, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -4898,8 +4922,8 @@ var init_handler = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path35 = sysPath.join(dir, sysPath.relative(dir, path35));
-            this._addToNodeFs(path35, initialAdd, wh, depth + 1);
+            path34 = sysPath.join(dir, sysPath.relative(dir, path34));
+            this._addToNodeFs(path34, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve3, reject) => {
@@ -4968,13 +4992,13 @@ var init_handler = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path35, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path34, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path35) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path34) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path35);
+        const wh = this.fsw._getWatchHelpers(path34);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -4990,8 +5014,8 @@ var init_handler = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sysPath.resolve(path35);
-            const targetPath = follow ? await fsrealpath(path35) : path35;
+            const absPath = sysPath.resolve(path34);
+            const targetPath = follow ? await fsrealpath(path34) : path34;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -5001,29 +5025,29 @@ var init_handler = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await fsrealpath(path35) : path35;
+            const targetPath = follow ? await fsrealpath(path34) : path34;
             if (this.fsw.closed)
               return;
             const parent = sysPath.dirname(wh.watchPath);
             this.fsw._getWatchedDir(parent).add(wh.watchPath);
             this.fsw._emit(EV.ADD, wh.watchPath, stats);
-            closer = await this._handleDir(parent, stats, initialAdd, depth, path35, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path34, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sysPath.resolve(path35), targetPath);
+              this.fsw._symlinkPaths.set(sysPath.resolve(path34), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path35, closer);
+            this.fsw._addPathCloser(path34, closer);
           return false;
         } catch (error) {
           if (this.fsw._handleError(error)) {
             ready();
-            return path35;
+            return path34;
           }
         }
       }
@@ -5062,26 +5086,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath2(path35) {
-  if (typeof path35 !== "string")
+function normalizePath2(path34) {
+  if (typeof path34 !== "string")
     throw new Error("string expected");
-  path35 = sysPath2.normalize(path35);
-  path35 = path35.replace(/\\/g, "/");
+  path34 = sysPath2.normalize(path34);
+  path34 = path34.replace(/\\/g, "/");
   let prepend = false;
-  if (path35.startsWith("//"))
+  if (path34.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path35.match(DOUBLE_SLASH_RE2))
-    path35 = path35.replace(DOUBLE_SLASH_RE2, "/");
+  while (path34.match(DOUBLE_SLASH_RE2))
+    path34 = path34.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path35 = "/" + path35;
-  return path35;
+    path34 = "/" + path34;
+  return path34;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path35 = normalizePath2(testString);
+  const path34 = normalizePath2(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path35, stats)) {
+    if (pattern(path34, stats)) {
       return true;
     }
   }
@@ -5142,19 +5166,19 @@ var init_esm2 = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path35) => toUnix(sysPath2.normalize(toUnix(path35)));
-    normalizeIgnored = (cwd = "") => (path35) => {
-      if (typeof path35 === "string") {
-        return normalizePathToUnix(sysPath2.isAbsolute(path35) ? path35 : sysPath2.join(cwd, path35));
+    normalizePathToUnix = (path34) => toUnix(sysPath2.normalize(toUnix(path34)));
+    normalizeIgnored = (cwd = "") => (path34) => {
+      if (typeof path34 === "string") {
+        return normalizePathToUnix(sysPath2.isAbsolute(path34) ? path34 : sysPath2.join(cwd, path34));
       } else {
-        return path35;
+        return path34;
       }
     };
-    getAbsolutePath = (path35, cwd) => {
-      if (sysPath2.isAbsolute(path35)) {
-        return path35;
+    getAbsolutePath = (path34, cwd) => {
+      if (sysPath2.isAbsolute(path34)) {
+        return path34;
       }
-      return sysPath2.join(cwd, path35);
+      return sysPath2.join(cwd, path34);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -5209,10 +5233,10 @@ var init_esm2 = __esm({
     STAT_METHOD_F = "stat";
     STAT_METHOD_L = "lstat";
     WatchHelper = class {
-      constructor(path35, follow, fsw) {
+      constructor(path34, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path35;
-        this.path = path35 = path35.replace(REPLACER_RE, "");
+        const watchPath = path34;
+        this.path = path34 = path34.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sysPath2.resolve(watchPath);
         this.dirParts = [];
@@ -5334,20 +5358,20 @@ var init_esm2 = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path35) => {
-            const absPath = getAbsolutePath(path35, cwd);
+          paths = paths.map((path34) => {
+            const absPath = getAbsolutePath(path34, cwd);
             return absPath;
           });
         }
-        paths.forEach((path35) => {
-          this._removeIgnoredPath(path35);
+        paths.forEach((path34) => {
+          this._removeIgnoredPath(path34);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path35) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path35, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path34) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path34, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -5369,17 +5393,17 @@ var init_esm2 = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path35) => {
-          if (!sysPath2.isAbsolute(path35) && !this._closers.has(path35)) {
+        paths.forEach((path34) => {
+          if (!sysPath2.isAbsolute(path34) && !this._closers.has(path34)) {
             if (cwd)
-              path35 = sysPath2.join(cwd, path35);
-            path35 = sysPath2.resolve(path35);
+              path34 = sysPath2.join(cwd, path34);
+            path34 = sysPath2.resolve(path34);
           }
-          this._closePath(path35);
-          this._addIgnoredPath(path35);
-          if (this._watched.has(path35)) {
+          this._closePath(path34);
+          this._addIgnoredPath(path34);
+          if (this._watched.has(path34)) {
             this._addIgnoredPath({
-              path: path35,
+              path: path34,
               recursive: true
             });
           }
@@ -5443,38 +5467,38 @@ var init_esm2 = __esm({
        * @param stats arguments to be passed with event
        * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
        */
-      async _emit(event, path35, stats) {
+      async _emit(event, path34, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path35 = sysPath2.normalize(path35);
+          path34 = sysPath2.normalize(path34);
         if (opts.cwd)
-          path35 = sysPath2.relative(opts.cwd, path35);
-        const args = [path35];
+          path34 = sysPath2.relative(opts.cwd, path34);
+        const args = [path34];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path35))) {
+        if (awf && (pw = this._pendingWrites.get(path34))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path35, [event, ...args]);
+            this._pendingUnlinks.set(path34, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path36) => {
+              this._pendingUnlinks.forEach((entry, path35) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path36);
+                this._pendingUnlinks.delete(path35);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path35)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path34)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path35);
+            this._pendingUnlinks.delete(path34);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -5492,16 +5516,16 @@ var init_esm2 = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path35, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path34, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path35, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path34, 50);
           if (isThrottled)
             return this;
         }
         if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path35) : path35;
+          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path34) : path34;
           let stats2;
           try {
             stats2 = await stat3(fullPath);
@@ -5532,23 +5556,23 @@ var init_esm2 = __esm({
        * @param timeout duration of time to suppress duplicate actions
        * @returns tracking object or false if action should be suppressed
        */
-      _throttle(actionType, path35, timeout) {
+      _throttle(actionType, path34, timeout) {
         if (!this._throttled.has(actionType)) {
           this._throttled.set(actionType, /* @__PURE__ */ new Map());
         }
         const action = this._throttled.get(actionType);
         if (!action)
           throw new Error("invalid throttle");
-        const actionPath = action.get(path35);
+        const actionPath = action.get(path34);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path35);
+          const item = action.get(path34);
           const count = item ? item.count : 0;
-          action.delete(path35);
+          action.delete(path34);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -5556,7 +5580,7 @@ var init_esm2 = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path35, thr);
+        action.set(path34, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -5570,44 +5594,44 @@ var init_esm2 = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path35, threshold, event, awfEmit) {
+      _awaitWriteFinish(path34, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path35;
-        if (this.options.cwd && !sysPath2.isAbsolute(path35)) {
-          fullPath = sysPath2.join(this.options.cwd, path35);
+        let fullPath = path34;
+        if (this.options.cwd && !sysPath2.isAbsolute(path34)) {
+          fullPath = sysPath2.join(this.options.cwd, path34);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           statcb(fullPath, (err, curStat) => {
-            if (err || !writes.has(path35)) {
+            if (err || !writes.has(path34)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path35).lastChange = now2;
+              writes.get(path34).lastChange = now2;
             }
-            const pw = writes.get(path35);
+            const pw = writes.get(path34);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path35);
+              writes.delete(path34);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path35)) {
-          writes.set(path35, {
+        if (!writes.has(path34)) {
+          writes.set(path34, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path35);
+              writes.delete(path34);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -5618,8 +5642,8 @@ var init_esm2 = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path35, stats) {
-        if (this.options.atomic && DOT_RE.test(path35))
+      _isIgnored(path34, stats) {
+        if (this.options.atomic && DOT_RE.test(path34))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -5629,17 +5653,17 @@ var init_esm2 = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path35, stats);
+        return this._userIgnored(path34, stats);
       }
-      _isntIgnored(path35, stat4) {
-        return !this._isIgnored(path35, stat4);
+      _isntIgnored(path34, stat4) {
+        return !this._isIgnored(path34, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path35) {
-        return new WatchHelper(path35, this.options.followSymlinks, this);
+      _getWatchHelpers(path34) {
+        return new WatchHelper(path34, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -5671,63 +5695,63 @@ var init_esm2 = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path35 = sysPath2.join(directory, item);
-        const fullPath = sysPath2.resolve(path35);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path35) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path35, 100))
+        const path34 = sysPath2.join(directory, item);
+        const fullPath = sysPath2.resolve(path34);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path34) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path34, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path35);
+        const wp = this._getWatchedDir(path34);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path35, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path34, nested));
         const parent = this._getWatchedDir(directory);
         const wasTracked = parent.has(item);
         parent.remove(item);
         if (this._symlinkPaths.has(fullPath)) {
           this._symlinkPaths.delete(fullPath);
         }
-        let relPath = path35;
+        let relPath = path34;
         if (this.options.cwd)
-          relPath = sysPath2.relative(this.options.cwd, path35);
+          relPath = sysPath2.relative(this.options.cwd, path34);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path35);
+        this._watched.delete(path34);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path35))
-          this._emit(eventName, path35);
-        this._closePath(path35);
+        if (wasTracked && !this._isIgnored(path34))
+          this._emit(eventName, path34);
+        this._closePath(path34);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path35) {
-        this._closeFile(path35);
-        const dir = sysPath2.dirname(path35);
-        this._getWatchedDir(dir).remove(sysPath2.basename(path35));
+      _closePath(path34) {
+        this._closeFile(path34);
+        const dir = sysPath2.dirname(path34);
+        this._getWatchedDir(dir).remove(sysPath2.basename(path34));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path35) {
-        const closers = this._closers.get(path35);
+      _closeFile(path34) {
+        const closers = this._closers.get(path34);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path35);
+        this._closers.delete(path34);
       }
-      _addPathCloser(path35, closer) {
+      _addPathCloser(path34, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path35);
+        let list = this._closers.get(path34);
         if (!list) {
           list = [];
-          this._closers.set(path35, list);
+          this._closers.set(path34, list);
         }
         list.push(closer);
       }
@@ -5819,41 +5843,41 @@ var init_rebuildScheduler = __esm({
 });
 
 // src/cli/copyResources.ts
-import path23 from "path";
-import fs18 from "fs";
+import path22 from "path";
+import fs17 from "fs";
 function isResourceSourcePath(rootDir, absPath) {
-  return isInsideDir(absPath, path23.resolve(rootDir, RESOURCES_DIR));
+  return isInsideDir(absPath, path22.resolve(rootDir, RESOURCES_DIR));
 }
 function resolveResourcesDir(rootDir, dist) {
-  return path23.resolve(rootDir, dist, RESOURCES_OUTPUT_DIR);
+  return path22.resolve(rootDir, dist, RESOURCES_OUTPUT_DIR);
 }
 async function copyResources(rootDir, dist) {
-  const sourceDir = path23.resolve(rootDir, RESOURCES_DIR);
-  if (!fs18.existsSync(sourceDir)) return false;
+  const sourceDir = path22.resolve(rootDir, RESOURCES_DIR);
+  if (!fs17.existsSync(sourceDir)) return false;
   const outDir = resolveResourcesDir(rootDir, dist);
-  await fs18.promises.rm(outDir, { recursive: true, force: true });
-  await fs18.promises.cp(sourceDir, outDir, { recursive: true });
+  await fs17.promises.rm(outDir, { recursive: true, force: true });
+  await fs17.promises.cp(sourceDir, outDir, { recursive: true });
   return true;
 }
 async function copyResourceFile(rootDir, dist, absSourceFile) {
-  const sourceDir = path23.resolve(rootDir, RESOURCES_DIR);
+  const sourceDir = path22.resolve(rootDir, RESOURCES_DIR);
   if (!isInsideDir(absSourceFile, sourceDir)) {
     throw new Error(`[faapi] copyResourceFile: ${absSourceFile} is not under ${RESOURCES_DIR}`);
   }
-  if (!fs18.existsSync(absSourceFile)) return;
-  const rel = path23.relative(sourceDir, absSourceFile);
-  const dest = path23.join(resolveResourcesDir(rootDir, dist), rel);
-  await fs18.promises.mkdir(path23.dirname(dest), { recursive: true });
-  await fs18.promises.cp(absSourceFile, dest);
+  if (!fs17.existsSync(absSourceFile)) return;
+  const rel = path22.relative(sourceDir, absSourceFile);
+  const dest = path22.join(resolveResourcesDir(rootDir, dist), rel);
+  await fs17.promises.mkdir(path22.dirname(dest), { recursive: true });
+  await fs17.promises.cp(absSourceFile, dest);
 }
 async function removeResourceFile(rootDir, dist, absSourceFile) {
-  const sourceDir = path23.resolve(rootDir, RESOURCES_DIR);
+  const sourceDir = path22.resolve(rootDir, RESOURCES_DIR);
   if (!isInsideDir(absSourceFile, sourceDir)) {
     throw new Error(`[faapi] removeResourceFile: ${absSourceFile} is not under ${RESOURCES_DIR}`);
   }
-  const rel = path23.relative(sourceDir, absSourceFile);
-  const dest = path23.join(resolveResourcesDir(rootDir, dist), rel);
-  await fs18.promises.rm(dest, { force: true });
+  const rel = path22.relative(sourceDir, absSourceFile);
+  const dest = path22.join(resolveResourcesDir(rootDir, dist), rel);
+  await fs17.promises.rm(dest, { force: true });
 }
 var RESOURCES_DIR, RESOURCES_OUTPUT_DIR;
 var init_copyResources = __esm({
@@ -5866,7 +5890,7 @@ var init_copyResources = __esm({
 });
 
 // src/cli/watcher.ts
-import path24 from "path";
+import path23 from "path";
 import { existsSync as existsSync2 } from "fs";
 function startWatcher(options) {
   const { rootDir, app, devDist } = options;
@@ -5901,9 +5925,9 @@ function startWatcher(options) {
     }
   });
   const CONFIG_FILES = ["faapi.config.ts", "faapi.config.js"];
-  const configAbsPaths = new Set(CONFIG_FILES.map((f) => path24.resolve(rootDir, f)));
+  const configAbsPaths = new Set(CONFIG_FILES.map((f) => path23.resolve(rootDir, f)));
   const watchPaths = ["src", "tsconfig.json", ...CONFIG_FILES];
-  const scheduleOnly = /* @__PURE__ */ new Set([...configAbsPaths, path24.resolve(rootDir, "tsconfig.json")]);
+  const scheduleOnly = /* @__PURE__ */ new Set([...configAbsPaths, path23.resolve(rootDir, "tsconfig.json")]);
   const watcher = esm_default.watch(watchPaths, {
     cwd: rootDir,
     ignoreInitial: true,
@@ -5914,14 +5938,14 @@ function startWatcher(options) {
       }
       if (!stats) return false;
       if (stats.isDirectory()) return false;
-      if (isResourceSourcePath(rootDir, path24.resolve(rootDir, filePath))) return false;
+      if (isResourceSourcePath(rootDir, path23.resolve(rootDir, filePath))) return false;
       return !filePath.endsWith(".ts") && !filePath.endsWith(".js");
     }
   });
   watcher.on("add", (file) => handleFileEvent(file));
   watcher.on("change", (file) => handleFileEvent(file));
   function handleFileEvent(file) {
-    const abs = path24.resolve(rootDir, file);
+    const abs = path23.resolve(rootDir, file);
     if (isResourceSourcePath(rootDir, abs)) {
       void copyResourceFile(rootDir, devDist, abs).catch((err) => {
         console.error(
@@ -5941,7 +5965,7 @@ function startWatcher(options) {
     scheduler.addFiles([abs]);
   }
   watcher.on("unlink", (file) => {
-    const abs = path24.resolve(rootDir, file);
+    const abs = path23.resolve(rootDir, file);
     if (isResourceSourcePath(rootDir, abs)) {
       void removeResourceFile(rootDir, devDist, abs).catch((err) => {
         console.error(
@@ -6056,25 +6080,25 @@ function getWsIndex(routes) {
   wsIndexCache.set(routes, index);
   return index;
 }
-function matchRoute(routes, method, path35) {
+function matchRoute(routes, method, path34) {
   const index = getHttpIndex(routes);
   const upper = method.toUpperCase();
-  const hit = matchByMethod(index, upper, path35);
+  const hit = matchByMethod(index, upper, path34);
   if (hit) return hit;
   if (upper === "HEAD") {
-    return matchByMethod(index, "GET", path35);
+    return matchByMethod(index, "GET", path34);
   }
   return null;
 }
-function matchByMethod(index, method, path35) {
-  const staticHit = index.static.get(`${method}|${path35}`);
+function matchByMethod(index, method, path34) {
+  const staticHit = index.static.get(`${method}|${path34}`);
   if (staticHit) {
     return { route: staticHit, params: {} };
   }
   if (index.dynamics.length === 0) {
     return null;
   }
-  const pathSegments = path35.split("/").filter(Boolean);
+  const pathSegments = path34.split("/").filter(Boolean);
   for (const entry of index.dynamics) {
     const route = entry.route;
     if (route.method !== method) {
@@ -6087,31 +6111,31 @@ function matchByMethod(index, method, path35) {
   }
   return null;
 }
-function matchWsRoute(wsRoutes, path35) {
+function matchWsRoute(wsRoutes, path34) {
   const index = getWsIndex(wsRoutes);
-  const staticHit = index.static.get(path35);
+  const staticHit = index.static.get(path34);
   if (staticHit) {
     return { route: staticHit, params: {} };
   }
   for (const route of index.dynamics) {
-    const params = matchDynamicPath(route.urlPath, path35, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path34, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function findAllowedMethods(routes, path35) {
+function findAllowedMethods(routes, path34) {
   const index = getHttpIndex(routes);
   const methods = /* @__PURE__ */ new Set();
-  const staticMethods = index.methodsByStaticPath.get(path35);
+  const staticMethods = index.methodsByStaticPath.get(path34);
   if (staticMethods) {
     for (const method of staticMethods) {
       methods.add(method);
     }
   }
   if (index.dynamics.length > 0) {
-    const pathSegments = path35.split("/").filter(Boolean);
+    const pathSegments = path34.split("/").filter(Boolean);
     for (const entry of index.dynamics) {
       const params = matchSegments(
         entry.segments,
@@ -6129,10 +6153,10 @@ function findAllowedMethods(routes, path35) {
   }
   return Array.from(methods);
 }
-function matchDynamicPath(pattern, path35, paramNames, isCatchAll) {
+function matchDynamicPath(pattern, path34, paramNames, isCatchAll) {
   return matchSegments(
     pattern.split("/").filter(Boolean),
-    path35.split("/").filter(Boolean),
+    path34.split("/").filter(Boolean),
     paramNames,
     isCatchAll
   );
@@ -6611,14 +6635,14 @@ var init_httpErrors = __esm({
       issues;
     };
     RouteNotFoundError = class extends FaapiError {
-      constructor(path35) {
-        super("ROUTE_NOT_FOUND", `Route not found: ${path35}`, 404);
+      constructor(path34) {
+        super("ROUTE_NOT_FOUND", `Route not found: ${path34}`, 404);
         this.name = "RouteNotFoundError";
       }
     };
     MethodNotAllowedError = class extends FaapiError {
-      constructor(method, path35, allowedMethods) {
-        super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path35}`, 405);
+      constructor(method, path34, allowedMethods) {
+        super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path34}`, 405);
         this.allowedMethods = allowedMethods;
         this.name = "MethodNotAllowedError";
       }
@@ -6754,17 +6778,17 @@ var init_formatEntry = __esm({
 });
 
 // src/logger/fileSink.ts
-import fs19 from "fs";
-import path25 from "path";
+import fs18 from "fs";
+import path24 from "path";
 function createFileLogSink(options) {
-  fs19.mkdirSync(options.dir, { recursive: true });
+  fs18.mkdirSync(options.dir, { recursive: true });
   const streams = /* @__PURE__ */ new Map();
   const getStream = (name) => {
     if (streams.has(name)) return streams.get(name);
     return void 0;
   };
   const openStream = (name) => {
-    const stream = fs19.createWriteStream(path25.join(options.dir, `${name}.log`), { flags: "a" });
+    const stream = fs18.createWriteStream(path24.join(options.dir, `${name}.log`), { flags: "a" });
     stream.on("error", () => {
     });
     streams.set(name, stream);
@@ -7972,9 +7996,9 @@ async function validateInput(schemaPath, method, inputType, input) {
 function mapZodIssues(error) {
   return error.issues.map((issue) => {
     const code = mapZodCode(issue);
-    const path35 = issue.path.map(String).join(".") || "";
+    const path34 = issue.path.map(String).join(".") || "";
     return {
-      path: path35,
+      path: path34,
       code,
       expected: issue.expected ?? mapExpectedFromMessage(issue.message),
       received: issue.received ?? mapReceivedFromMessage(issue.message),
@@ -8498,9 +8522,9 @@ var init_wsHandler = __esm({
 });
 
 // src/server/handleWsUpgrade.ts
-import fs20 from "fs";
+import fs19 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
-import path26 from "path";
+import path25 from "path";
 function getPathname(req) {
   const url = req.url ?? "/";
   const idx = url.indexOf("?");
@@ -8511,7 +8535,7 @@ async function loadWsHandler(filePath, ctx, rootDir) {
     const dist = getDevDist();
     if (dist) {
       const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-      if (sourcePath && fs20.existsSync(sourcePath)) {
+      if (sourcePath && fs19.existsSync(sourcePath)) {
         await ensureCompiled(sourcePath, rootDir, dist);
       }
     }
@@ -8653,7 +8677,7 @@ function attachWebSocket(options) {
     let upgraded = false;
     const finalHandler = async () => {
       const schemaPath = getRuntimeSchemaPath(route.filePath, dist, rootDir);
-      if (fs20.existsSync(schemaPath)) {
+      if (fs19.existsSync(schemaPath)) {
         if (isDevOnDemandEnabled()) {
           const devDist = getDevDist();
           if (devDist) {
@@ -8692,7 +8716,7 @@ function attachWebSocket(options) {
       }
       let handlers;
       try {
-        const absoluteFilePath = path26.resolve(rootDir, route.filePath);
+        const absoluteFilePath = path25.resolve(rootDir, route.filePath);
         handlers = await loadWsHandler(absoluteFilePath, ctx, rootDir);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
@@ -8773,7 +8797,7 @@ import {
 import { createSecureServer as createHttp2SecureServer } from "http2";
 import { readFileSync } from "fs";
 import { Readable as Readable3 } from "stream";
-import path27 from "path";
+import path26 from "path";
 function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT, requestSignal) {
   const forwardedProto = req.headers["x-forwarded-proto"];
   const protocol = Array.isArray(forwardedProto) ? forwardedProto[0]?.split(",")[0]?.trim() ?? "http" : forwardedProto?.split(",")[0]?.trim() ?? "http";
@@ -8979,7 +9003,7 @@ function getRoutePaths(route, rootDir, dist) {
   let cached = routePathCache.get(route);
   if (!cached) {
     cached = {
-      absFilePath: path27.resolve(rootDir, route.filePath),
+      absFilePath: path26.resolve(rootDir, route.filePath),
       schemaPath: getRuntimeSchemaPath(route.filePath, dist, rootDir)
     };
     routePathCache.set(route, cached);
@@ -9412,7 +9436,11 @@ async function runTaskInWorker(options) {
       worker.postMessage({
         type: "run",
         payload,
-        taskCtx: { config: safeConfig(taskCtx.config), job: taskCtx.job },
+        taskCtx: {
+          config: safeConfig(taskCtx.config),
+          resourcesDir: taskCtx.resourcesDir,
+          job: taskCtx.job
+        },
         registries: options.registries,
         log: options.log
       });
@@ -9538,7 +9566,7 @@ function createTaskLogger(level, scope, fields) {
 });
 
 // src/task/taskQueue.ts
-import path28 from "path";
+import path27 from "path";
 function createTaskQueue(deps) {
   const { registry, rootDir, driver } = deps;
   const registriesView = deps.registries ?? createEmptyTaskRegistriesView();
@@ -9568,7 +9596,7 @@ function createTaskQueue(deps) {
   }
   const loadTaskModule = deps.loadTaskModule ?? (async (filePath) => await import(filePath));
   const loadPayloadSchema = deps.loadPayloadSchema ?? (async (filePath) => {
-    const zodPath = path28.join(path28.dirname(filePath), "zod.js");
+    const zodPath = path27.join(path27.dirname(filePath), "zod.js");
     try {
       const mod = await import(zodPath);
       const schemaKey = Object.keys(mod).find((k) => k.endsWith("Schema"));
@@ -9596,7 +9624,7 @@ function createTaskQueue(deps) {
       const meta = registry.get(name);
       schemaCache.set(
         name,
-        await loadPayloadSchema(path28.resolve(rootDir, meta.filePath)).catch(() => void 0)
+        await loadPayloadSchema(path27.resolve(rootDir, meta.filePath)).catch(() => void 0)
       );
     }
     const schema = schemaCache.get(name);
@@ -9632,10 +9660,11 @@ function createTaskQueue(deps) {
       let result;
       if (meta.timeoutMs !== void 0 && meta.timeoutMs > 0) {
         result = await (deps.runIsolated ?? runTaskInWorker)({
-          taskModulePath: path28.resolve(rootDir, meta.filePath),
+          taskModulePath: path27.resolve(rootDir, meta.filePath),
           payload: job.payload,
           taskCtx: {
             config: deps.config,
+            resourcesDir: deps.resourcesDir,
             job: { id: job.id, name: job.name, attempt: job.attempt }
           },
           registries: snapshotRegistries(),
@@ -9657,7 +9686,7 @@ function createTaskQueue(deps) {
       } else {
         let mod = moduleCache2.get(job.name);
         if (!mod) {
-          mod = await loadTaskModule(path28.resolve(rootDir, meta.filePath));
+          mod = await loadTaskModule(path27.resolve(rootDir, meta.filePath));
           moduleCache2.set(job.name, mod);
         }
         if (typeof mod.run !== "function") {
@@ -9666,6 +9695,7 @@ function createTaskQueue(deps) {
         const taskCtx = {
           signal: job.signal,
           config: deps.config,
+          resourcesDir: deps.resourcesDir,
           job: { id: job.id, name: job.name, attempt: job.attempt },
           registries: registriesView,
           log: createLogger(`task:${job.name}`, {
@@ -9946,8 +9976,8 @@ var init_cronScheduler = __esm({
 });
 
 // src/cli/loadPlugins.ts
-import path29 from "path";
-import fs21 from "fs";
+import path28 from "path";
+import fs20 from "fs";
 import { pathToFileURL as pathToFileURL3 } from "url";
 async function loadPlugins(declarations, ctx, rootDir, dist) {
   const handlerWrappers = [];
@@ -10010,30 +10040,30 @@ async function loadPlugins(declarations, ctx, rootDir, dist) {
   return { handlerWrappers, upgradeWrappers, failures };
 }
 function resolveLocalPluginSource(specifier, baseDir) {
-  const base = path29.isAbsolute(specifier) ? specifier : path29.resolve(baseDir, specifier);
-  if ((TS_EXTS.test(base) || JS_EXTS.test(base)) && fs21.existsSync(base)) return base;
+  const base = path28.isAbsolute(specifier) ? specifier : path28.resolve(baseDir, specifier);
+  if ((TS_EXTS.test(base) || JS_EXTS.test(base)) && fs20.existsSync(base)) return base;
   for (const ext of [".ts", ".js"]) {
-    if (fs21.existsSync(base + ext)) return base + ext;
+    if (fs20.existsSync(base + ext)) return base + ext;
   }
   for (const indexExt of ["/index.ts", "/index.js"]) {
-    if (fs21.existsSync(base + indexExt)) return base + indexExt;
+    if (fs20.existsSync(base + indexExt)) return base + indexExt;
   }
   return null;
 }
 function mirrorProductPath(sourcePath, baseDir, distDir) {
-  let rel = path29.relative(baseDir, sourcePath).replace(/\\/g, "/");
+  let rel = path28.relative(baseDir, sourcePath).replace(/\\/g, "/");
   if (rel.startsWith("src/")) rel = rel.slice(4);
-  return path29.resolve(distDir, rel.replace(TS_EXTS, ".js"));
+  return path28.resolve(distDir, rel.replace(TS_EXTS, ".js"));
 }
 async function importPluginModule(specifier, baseDir, dist) {
   const isRelative = specifier.startsWith("./") || specifier.startsWith("../");
-  if (!isRelative && !path29.isAbsolute(specifier)) {
+  if (!isRelative && !path28.isAbsolute(specifier)) {
     return import(specifier);
   }
-  const distDir = dist ? path29.resolve(baseDir, dist) : null;
+  const distDir = dist ? path28.resolve(baseDir, dist) : null;
   const sourcePath = resolveLocalPluginSource(specifier, baseDir);
   const productPath = sourcePath && distDir ? mirrorProductPath(sourcePath, baseDir, distDir) : null;
-  if (productPath !== null && fs21.existsSync(productPath) && (sourcePath === null || isProductFresh(sourcePath, productPath))) {
+  if (productPath !== null && fs20.existsSync(productPath) && (sourcePath === null || isProductFresh(sourcePath, productPath))) {
     return import(pathToFileURL3(productPath).href);
   }
   if (sourcePath && TS_EXTS.test(sourcePath)) {
@@ -10042,13 +10072,13 @@ async function importPluginModule(specifier, baseDir, dist) {
         `Local plugin "${specifier}" has no up-to-date build artifact (dist is stale or missing). Run "faapi build" first, or use "faapi dev" for on-demand compilation.`
       );
     }
-    const relFromRoot = path29.relative(baseDir, sourcePath).replace(/\\/g, "/");
+    const relFromRoot = path28.relative(baseDir, sourcePath).replace(/\\/g, "/");
     if (relFromRoot.startsWith("src/")) {
       await ensureCompiled(sourcePath, baseDir, dist);
     } else {
       await compileProjectModules([sourcePath], baseDir, dist);
     }
-    if (productPath && fs21.existsSync(productPath)) {
+    if (productPath && fs20.existsSync(productPath)) {
       return import(pathToFileURL3(productPath).href);
     }
   }
@@ -10060,7 +10090,7 @@ async function importPluginModule(specifier, baseDir, dist) {
     `${specifier}/index.ts`,
     `${specifier}.js`,
     `${specifier}/index.js`
-  ].map((c) => path29.isAbsolute(c) ? c : path29.join(baseDir, c));
+  ].map((c) => path28.isAbsolute(c) ? c : path28.join(baseDir, c));
   throw new Error(
     `Cannot find local plugin "${specifier}" (resolved from ${baseDir}). Expected one of:
   ${candidates.join("\n  ")}
@@ -10095,11 +10125,11 @@ var init_loadPlugins = __esm({
 });
 
 // src/cli/manifestLoader.ts
-import fs22 from "fs";
-import path30 from "path";
+import fs21 from "fs";
+import path29 from "path";
 async function loadAndHydrateTools(rootDir, dist, registries = defaultRegistries) {
-  const toolsPath = path30.resolve(rootDir, dist, TOOLS_FILE2);
-  if (!fs22.existsSync(toolsPath)) {
+  const toolsPath = path29.resolve(rootDir, dist, TOOLS_FILE2);
+  if (!fs21.existsSync(toolsPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(toolsPath);
@@ -10108,8 +10138,8 @@ async function loadAndHydrateTools(rootDir, dist, registries = defaultRegistries
   return hydrated;
 }
 async function loadAndHydrateAgents(rootDir, dist, registries = defaultRegistries) {
-  const agentsPath = path30.resolve(rootDir, dist, AGENTS_FILE2);
-  if (!fs22.existsSync(agentsPath)) {
+  const agentsPath = path29.resolve(rootDir, dist, AGENTS_FILE2);
+  if (!fs21.existsSync(agentsPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(agentsPath);
@@ -10124,8 +10154,8 @@ function getTaskDriverOptions(config) {
   return void 0;
 }
 async function loadAndHydrateTasks(rootDir, dist, registries = defaultRegistries) {
-  const tasksPath = path30.resolve(rootDir, dist, TASKS_FILE);
-  if (!fs22.existsSync(tasksPath)) {
+  const tasksPath = path29.resolve(rootDir, dist, TASKS_FILE);
+  if (!fs21.existsSync(tasksPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(tasksPath);
@@ -10272,8 +10302,8 @@ var init_injectMock = __esm({
 });
 
 // src/cli/createAppCore.ts
-import fs23 from "fs";
-import path31 from "path";
+import fs22 from "fs";
+import path30 from "path";
 function isFaapiConfigKey(key) {
   return FAAPI_CONFIG_KEYS.has(key);
 }
@@ -10299,8 +10329,7 @@ function logStartupSummary(routes, wsRoutes, tools, agents, taskMetas, p) {
   if (agents.length > 0) {
     console.log(`- Loaded ${agents.length} agent(s):`);
     for (const agent of agents) {
-      const exports = agent.hasRun ? "run" : "-";
-      console.log(`  ${agent.name} [${exports}]  ${agent.filePath}`);
+      console.log(`  ${agent.name}  ${agent.filePath}`);
     }
   }
   if (taskMetas.length > 0) {
@@ -10315,8 +10344,8 @@ async function createAppBase(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const dist = options?.dist ?? process.env.FAAPI_DIST ?? DEFAULT_DIST;
   const resourcesDir = resolveResourcesDir(rootDir, dist);
-  const routesPath = path31.resolve(rootDir, dist, ROUTES_FILE);
-  if (!fs23.existsSync(routesPath)) {
+  const routesPath = path30.resolve(rootDir, dist, ROUTES_FILE);
+  if (!fs22.existsSync(routesPath)) {
     throw new Error(
       `[faapi] ${dist}/${ROUTES_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
     );
@@ -10337,6 +10366,7 @@ async function createAppBase(options) {
     registry: registries.task,
     rootDir,
     config,
+    resourcesDir,
     registries: createTaskRegistriesView(registries),
     driver: taskDriver,
     onFailed: config?.task?.onFailed
@@ -10378,6 +10408,7 @@ async function createAppBase(options) {
     config?.plugins,
     {
       rootDir,
+      resourcesDir,
       registries,
       routes: sorted,
       getRoutes: () => sorted,
@@ -10578,7 +10609,7 @@ var init_createAppCore = __esm({
 });
 
 // src/cli/createDevApp.ts
-import path32 from "path";
+import path31 from "path";
 async function createDevApp(options) {
   const { app, ctx } = await createAppBase(options);
   const devApp = app;
@@ -10628,7 +10659,7 @@ async function createDevApp(options) {
     if (!suppressProgramInvalidation) invalidateProgramCache();
     const tasks = await scanTasks(ctx.rootDir, TASK_PATTERNS);
     for (const task of tasks) {
-      await ensureCompiled(path32.resolve(ctx.rootDir, task.filePath), ctx.rootDir, ctx.dist);
+      await ensureCompiled(path31.resolve(ctx.rootDir, task.filePath), ctx.rootDir, ctx.dist);
     }
     await generateTaskArtifacts(tasks, ctx.rootDir, ctx.dist);
     ctx.taskQueue.invalidateModules();
@@ -10685,7 +10716,7 @@ __export(devCommand_exports, {
   generateTaskArtifactsForDev: () => generateTaskArtifactsForDev,
   generateToolArtifactsForDev: () => generateToolArtifactsForDev
 });
-import path33 from "path";
+import path32 from "path";
 async function devCommand(options) {
   const rootDir = process.cwd();
   if (!process.env.NODE_ENV) process.env.NODE_ENV = "development";
@@ -10709,7 +10740,7 @@ async function devCommand(options) {
   console.log("- Copying resources...");
   const copied = await copyResources(rootDir, devDist);
   if (copied)
-    console.log(`  Copied src/resources \u2192 ${path33.resolve(rootDir, devDist, "resources")}`);
+    console.log(`  Copied src/resources \u2192 ${path32.resolve(rootDir, devDist, "resources")}`);
   console.log("- Starting dev app...");
   const app = await createDevApp({ rootDir, port: options?.port });
   await app.listen();
@@ -10718,7 +10749,7 @@ async function devCommand(options) {
 async function generateRouteArtifacts(rootDir, patterns, dist) {
   const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, dist);
   const sorted = sortRoutes(routes);
-  const routesPath = path33.resolve(rootDir, dist, ROUTES_FILE2);
+  const routesPath = path32.resolve(rootDir, dist, ROUTES_FILE2);
   const serialized = serializeRoutes(sorted, wsRoutes, rootDir, dist);
   await writeRoutesModule(serialized, routesPath);
 }
@@ -10733,7 +10764,7 @@ async function generateAgentArtifactsForDev(rootDir, dist) {
 async function generateTaskArtifactsForDev(rootDir, dist) {
   const tasks = await scanTasks(rootDir, TASK_PATTERNS);
   for (const task of tasks) {
-    await ensureCompiled(path33.resolve(rootDir, task.filePath), rootDir, dist);
+    await ensureCompiled(path32.resolve(rootDir, task.filePath), rootDir, dist);
   }
   await generateTaskArtifacts(tasks, rootDir, dist);
 }
@@ -10782,15 +10813,15 @@ var buildCommand_exports = {};
 __export(buildCommand_exports, {
   buildCommand: () => buildCommand
 });
-import path34 from "path";
-import fs24 from "fs";
+import path33 from "path";
+import fs23 from "fs";
 async function buildCommand(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const outdir = options?.dist ?? DEFAULT_DIST2;
-  const absOut = path34.resolve(rootDir, outdir);
-  const realRoot = toRealPath(path34.resolve(rootDir));
+  const absOut = path33.resolve(rootDir, outdir);
+  const realRoot = toRealPath(path33.resolve(rootDir));
   if (isInsideDir(toRealPath(absOut), realRoot)) {
-    fs24.rmSync(absOut, { recursive: true, force: true });
+    fs23.rmSync(absOut, { recursive: true, force: true });
   } else {
     console.warn(
       `! Output directory "${outdir}" is outside the project root, skipping clean (stale artifacts may remain)`
@@ -10798,10 +10829,10 @@ async function buildCommand(options) {
   }
   await compileConfig({ rootDir, dist: outdir });
   const _config = await loadConfig(rootDir, outdir);
-  const pkgPath = path34.resolve(rootDir, "package.json");
-  if (fs24.existsSync(pkgPath)) {
+  const pkgPath = path33.resolve(rootDir, "package.json");
+  if (fs23.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs23.readFileSync(pkgPath, "utf-8"));
       if (pkg.type !== "module") {
         console.warn(
           '! package.json is missing "type": "module" \u2014 build output is ESM and `node dist/main` will fail without it'
@@ -10829,7 +10860,7 @@ async function buildCommand(options) {
   if (localPluginSources.length > 0) {
     console.log("\n[2.5/9] Compiling local plugins...");
     const outside = localPluginSources.filter((p) => {
-      const rel = path34.relative(rootDir, p).replace(/\\/g, "/");
+      const rel = path33.relative(rootDir, p).replace(/\\/g, "/");
       return !rel.startsWith("src/");
     });
     if (outside.length > 0) {
@@ -10844,9 +10875,9 @@ async function buildCommand(options) {
   reportRouteConflicts(sorted);
   console.log("\n[4/9] Generating schema...");
   await generateSchemaFiles(sorted, rootDir, outdir, wsRoutes);
-  console.log(`  Schema: zod.js files under ${path34.resolve(rootDir, outdir)}`);
+  console.log(`  Schema: zod.js files under ${path33.resolve(rootDir, outdir)}`);
   console.log("\n[5/9] Generating routes manifest...");
-  const routesPath = path34.resolve(rootDir, outdir, "faapi-routes.js");
+  const routesPath = path33.resolve(rootDir, outdir, "faapi-routes.js");
   const serialized = serializeRoutes(sorted, wsRoutes, rootDir, outdir);
   await writeRoutesModule(serialized, routesPath);
   console.log(`  Written to ${routesPath}`);
@@ -10854,24 +10885,24 @@ async function buildCommand(options) {
   const tools = await scanTools(rootDir, TOOL_PATTERNS);
   const toolMeta = await generateToolArtifacts(tools, rootDir, outdir);
   console.log(`  Found ${toolMeta.length} tool(s)`);
-  console.log(`  Tool manifest: ${path34.resolve(rootDir, outdir, "faapi-tools.js")}`);
+  console.log(`  Tool manifest: ${path33.resolve(rootDir, outdir, "faapi-tools.js")}`);
   console.log("\n[7/9] Generating agent manifest...");
   const agents = await scanAgents(rootDir, DEFAULT_AGENT_PATTERNS);
   const agentMeta = await generateAgentArtifacts(agents, rootDir, outdir);
   console.log(`  Found ${agentMeta.length} agent(s)`);
-  console.log(`  Agent manifest: ${path34.resolve(rootDir, outdir, "faapi-agents.js")}`);
+  console.log(`  Agent manifest: ${path33.resolve(rootDir, outdir, "faapi-agents.js")}`);
   console.log("\n[7.5/9] Generating task manifest and schema...");
   const tasks = await scanTasks(rootDir, TASK_PATTERNS);
   const taskMeta = await generateTaskArtifacts(tasks, rootDir, outdir);
   console.log(`  Found ${taskMeta.length} task(s)`);
-  console.log(`  Task manifest: ${path34.resolve(rootDir, outdir, "faapi-tasks.js")}`);
+  console.log(`  Task manifest: ${path33.resolve(rootDir, outdir, "faapi-tasks.js")}`);
   console.log("\n[8/9] Copying resources...");
   const resourcesCopied = await copyResources(rootDir, outdir);
   if (resourcesCopied) {
-    console.log(`  Copied src/resources \u2192 ${path34.resolve(rootDir, outdir, "resources")}`);
+    console.log(`  Copied src/resources \u2192 ${path33.resolve(rootDir, outdir, "resources")}`);
   }
   console.log("\n[9/9] Generating entry file...");
-  const mainPath = path34.resolve(rootDir, outdir, "main.js");
+  const mainPath = path33.resolve(rootDir, outdir, "main.js");
   const createProdAppArgs = options?.dist && options.dist !== DEFAULT_DIST2 ? `{ dist: ${JSON.stringify(outdir)} }` : "";
   const mainContent = `// \u7531 faapi build \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91
 import { createProdApp, loadEnv } from '@faapi/faapi';
@@ -10883,7 +10914,7 @@ loadEnv(process.cwd());
 const app = await createProdApp(${createProdAppArgs});
 await app.listen();
 `;
-  await fs24.promises.writeFile(mainPath, mainContent, "utf-8");
+  await fs23.promises.writeFile(mainPath, mainContent, "utf-8");
   console.log(`  Written to ${mainPath}`);
   console.log("\nfaapi build completed");
 }
@@ -10897,7 +10928,7 @@ function extractLocalPluginSources(declarations, rootDir) {
     else if (Array.isArray(decl)) specifier = decl[0];
     else if ("path" in decl) specifier = decl.path;
     if (!specifier) continue;
-    if (!specifier.startsWith("./") && !specifier.startsWith("../") && !path34.isAbsolute(specifier)) {
+    if (!specifier.startsWith("./") && !specifier.startsWith("../") && !path33.isAbsolute(specifier)) {
       continue;
     }
     const source = resolveLocalPluginSource(specifier, rootDir);