@faapi/faapi 6.6.0 → 6.8.0

package/dist/cli/index.js

@@ -2260,8 +2260,10 @@ var init_resolveInjection = __esm({
       // Phase 2.3
       agents: "agents",
       // Phase 2.3
-      tasks: "tasks"
+      tasks: "tasks",
       // 任务子系统：TaskClient（入队/查询）
+      log: "log"
+      // 请求级日志器（ctx.log 同一实例：scope http，自动带 requestId 等字段）
     };
     injectionCache = /* @__PURE__ */ new WeakMap();
   }
@@ -3376,6 +3378,9 @@ var init_generateAgentArtifacts = __esm({
 import fg4 from "fast-glob";
 import path16 from "path";
 import fs12 from "fs";
+function parseNumericLiteral(raw) {
+  return Number(raw.replace(/_/g, ""));
+}
 function filePathToTaskName(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
   const match = normalized.match(/(?:^|\/)tasks\/(.+)\/task\.ts$/);
@@ -3413,24 +3418,37 @@ async function scanTasks(rootDir, patterns) {
     const concurrency = CONCURRENCY_RE.exec(source)?.[1];
     const retries = RETRIES_RE.exec(source)?.[1];
     const timeoutMs = TIMEOUT_MS_RE.exec(source)?.[1];
+    const graceMs = GRACE_MS_RE.exec(source)?.[1];
     if (cron !== void 0) manifest.cron = cron;
-    if (concurrency !== void 0) manifest.concurrency = Number(concurrency);
-    if (retries !== void 0) manifest.retries = Number(retries);
-    if (timeoutMs !== void 0) manifest.timeoutMs = Number(timeoutMs);
+    if (concurrency !== void 0) manifest.concurrency = parseNumericLiteral(concurrency);
+    if (retries !== void 0) manifest.retries = parseNumericLiteral(retries);
+    if (timeoutMs !== void 0) {
+      const value = parseNumericLiteral(timeoutMs);
+      if (value < MIN_ISOLATED_TIMEOUT_MS) {
+        throw new Error(
+          `[faapi] Task "${name}" timeoutMs ${value} is below the minimum ${MIN_ISOLATED_TIMEOUT_MS}ms (1 minute). Declaring a timeout means this is a long-running task that needs real cancellation \u2014 tasks finishing within a minute do not need one: remove timeoutMs to run in-process (implement your own deadline with Promise.race if needed), or raise it.`
+        );
+      }
+      manifest.timeoutMs = value;
+    }
+    if (graceMs !== void 0) manifest.graceMs = parseNumericLiteral(graceMs);
     tasks.push(manifest);
   }
   return tasks.sort((a, b) => a.name.localeCompare(b.name));
 }
-var TASK_PATTERNS, TASK_FILENAME, CRON_RE, CONCURRENCY_RE, RETRIES_RE, TIMEOUT_MS_RE;
+var TASK_PATTERNS, TASK_FILENAME, CRON_RE, NUM_LITERAL, CONCURRENCY_RE, RETRIES_RE, TIMEOUT_MS_RE, GRACE_MS_RE, MIN_ISOLATED_TIMEOUT_MS;
 var init_scanTasks = __esm({
   "src/task/scanTasks.ts"() {
     "use strict";
     TASK_PATTERNS = ["src/tasks/**/task.ts"];
     TASK_FILENAME = "task.ts";
     CRON_RE = /(?:^|\n)\s*cron:\s*['"`]([^'"`\n]+)['"`]/;
-    CONCURRENCY_RE = /(?:^|\n)\s*concurrency:\s*(\d+)/;
-    RETRIES_RE = /(?:^|\n)\s*retries:\s*(\d+)/;
-    TIMEOUT_MS_RE = /(?:^|\n)\s*timeoutMs:\s*(\d+)/;
+    NUM_LITERAL = "(\\d+(?:_\\d+)*)";
+    CONCURRENCY_RE = new RegExp(`(?:^|\\n)\\s*concurrency:\\s*${NUM_LITERAL}`);
+    RETRIES_RE = new RegExp(`(?:^|\\n)\\s*retries:\\s*${NUM_LITERAL}`);
+    TIMEOUT_MS_RE = new RegExp(`(?:^|\\n)\\s*timeoutMs:\\s*${NUM_LITERAL}`);
+    GRACE_MS_RE = new RegExp(`(?:^|\\n)\\s*graceMs:\\s*${NUM_LITERAL}`);
+    MIN_ISOLATED_TIMEOUT_MS = 6e4;
   }
 });
 
@@ -3443,7 +3461,8 @@ function serializeTasks(tasks, dist = "dist") {
     ...t.cron !== void 0 ? { cron: t.cron } : {},
     ...t.concurrency !== void 0 ? { concurrency: t.concurrency } : {},
     ...t.retries !== void 0 ? { retries: t.retries } : {},
-    ...t.timeoutMs !== void 0 ? { timeoutMs: t.timeoutMs } : {}
+    ...t.timeoutMs !== void 0 ? { timeoutMs: t.timeoutMs } : {},
+    ...t.graceMs !== void 0 ? { graceMs: t.graceMs } : {}
   }));
 }
 async function writeTasksModule(manifest, outputPath) {
@@ -3459,7 +3478,8 @@ function hydrateTasks(manifest) {
     cron: t.cron ?? void 0,
     concurrency: t.concurrency ?? void 0,
     retries: t.retries ?? void 0,
-    timeoutMs: t.timeoutMs ?? void 0
+    timeoutMs: t.timeoutMs ?? void 0,
+    graceMs: t.graceMs ?? void 0
   }));
 }
 function collectTaskSchemaSources(tasks, rootDir) {
@@ -6368,7 +6388,131 @@ var init_responseFormatter = __esm({
   }
 });
 
+// src/logger/logger.ts
+function assertLogLevel(value, source) {
+  if (typeof value !== "string" || !VALID_LEVELS.includes(value)) {
+    throw new Error(
+      `[faapi] Invalid log level from ${source}: ${String(value)}. Expected one of: ${VALID_LEVELS.join(", ")}.`
+    );
+  }
+}
+function configureLogging(config) {
+  if (config === void 0) {
+    globalState.level = null;
+    globalState.sink = null;
+    globalState.disabled = false;
+    return;
+  }
+  const objectConfig = typeof config === "object" ? config : {};
+  globalState.disabled = config === false;
+  globalState.sink = objectConfig.sink ?? null;
+  if (objectConfig.level !== void 0) {
+    assertLogLevel(objectConfig.level, "config.log.level");
+    globalState.level = objectConfig.level;
+  } else if (process.env.LOG_LEVEL !== void 0) {
+    assertLogLevel(process.env.LOG_LEVEL, "LOG_LEVEL env");
+    globalState.level = process.env.LOG_LEVEL;
+  } else {
+    globalState.level = null;
+  }
+}
+function globalThreshold() {
+  return globalState.level ?? "info";
+}
+function getEffectiveLogLevel() {
+  return globalThreshold();
+}
+function serializeFieldValue(value) {
+  if (value instanceof Error) {
+    return { name: value.name, message: value.message, stack: value.stack };
+  }
+  return value;
+}
+function formatEntry(entry) {
+  let line = `[${entry.time}] ${entry.level.toUpperCase()} `;
+  if (entry.scope) line += `[${entry.scope}] `;
+  line += entry.message;
+  if (entry.fields !== void 0) {
+    const plain = Object.fromEntries(
+      Object.entries(entry.fields).map(([k, v]) => [k, serializeFieldValue(v)])
+    );
+    try {
+      line += ` ${JSON.stringify(plain)}`;
+    } catch (err) {
+      line += ` [unserializable fields: ${err instanceof Error ? err.message : String(err)}]`;
+    }
+  }
+  return line;
+}
+function globalDispatch(entry) {
+  if (globalState.disabled) return;
+  (globalState.sink ?? consoleSink)(entry);
+}
+function writeLogEntry(entry) {
+  if (LEVEL_RANK[entry.level] < LEVEL_RANK[globalThreshold()]) return;
+  globalDispatch(entry);
+}
+function createLogger(scope, options) {
+  const baseScope = scope;
+  const baseFields = options?.fields;
+  const write = (level, message, callFields, scopeSuffix) => {
+    const threshold = options?.level ?? globalThreshold();
+    if (LEVEL_RANK[level] < LEVEL_RANK[threshold]) return;
+    const entry = {
+      level,
+      message,
+      time: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const fullScope = scopeSuffix === void 0 ? baseScope : baseScope === void 0 ? scopeSuffix : `${baseScope}:${scopeSuffix}`;
+    if (fullScope !== void 0) entry.scope = fullScope;
+    if (baseFields !== void 0 || callFields !== void 0) {
+      entry.fields = { ...baseFields, ...callFields };
+    }
+    if (options?.sink) {
+      options.sink(entry);
+    } else {
+      globalDispatch(entry);
+    }
+  };
+  const makeLogger = (scopeSuffix) => ({
+    debug: (message, fields) => write("debug", message, fields, scopeSuffix),
+    info: (message, fields) => write("info", message, fields, scopeSuffix),
+    warn: (message, fields) => write("warn", message, fields, scopeSuffix),
+    error: (message, fields) => write("error", message, fields, scopeSuffix),
+    child: (childScope) => makeLogger(scopeSuffix === void 0 ? childScope : `${scopeSuffix}:${childScope}`)
+  });
+  return makeLogger(void 0);
+}
+var LEVEL_RANK, VALID_LEVELS, globalState, CONSOLE_METHOD, consoleSink;
+var init_logger = __esm({
+  "src/logger/logger.ts"() {
+    "use strict";
+    LEVEL_RANK = { debug: 0, info: 1, warn: 2, error: 3 };
+    VALID_LEVELS = ["debug", "info", "warn", "error"];
+    globalState = {
+      level: null,
+      sink: null,
+      disabled: false
+    };
+    CONSOLE_METHOD = {
+      debug: "debug",
+      info: "info",
+      warn: "warn",
+      error: "error"
+    };
+    consoleSink = (entry) => {
+      console[CONSOLE_METHOD[entry.level]](formatEntry(entry));
+    };
+  }
+});
+
 // src/runtime/createContext.ts
+function resolveRequestId(request) {
+  const header = request.headers.get("x-request-id");
+  const first = header?.split(",")[0]?.trim();
+  if (first) return first;
+  return crypto.randomUUID();
+}
 function parseCookies(cookieHeader) {
   const cookies = /* @__PURE__ */ new Map();
   if (!cookieHeader) return cookies;
@@ -6402,7 +6546,13 @@ function createContextFromUrl(request, url, params, config = {}, ip = "", regist
   for (const [key, val] of parsedCookies) {
     cookiesObj[key] = val;
   }
+  const requestId = resolveRequestId(request);
+  const log = createLogger("http", {
+    fields: { requestId, method: request.method, path: url.pathname }
+  });
   const ctx = {
+    requestId,
+    log,
     request,
     params,
     query: url.searchParams,
@@ -6507,6 +6657,7 @@ var init_createContext = __esm({
     "use strict";
     init_sse();
     init_responseFormatter();
+    init_logger();
   }
 });
 
@@ -7074,6 +7225,9 @@ function getBuiltinInjectionValue(type, ctx, body) {
     // 任务子系统：注入 TaskClient（入队/查询）；未注册工厂（无 app 编排）时 undefined
     case "tasks":
       return ctx.registries ? ctx.registries.taskHandle.get(ctx) : void 0;
+    // 请求级日志器：与 ctx.log 同一实例（scope http，自动带 requestId/method/path 字段）
+    case "log":
+      return ctx.log;
     default:
       return void 0;
   }
@@ -7698,6 +7852,7 @@ function logger(options = {}) {
       const response = await next();
       const duration = Date.now() - start;
       const entry = {
+        requestId: ctx.requestId,
         method: ctx.method,
         path: ctx.path,
         status: response.status,
@@ -7710,6 +7865,7 @@ function logger(options = {}) {
       const message = err instanceof Error ? err.message : String(err);
       const status = err?.statusCode ?? 500;
       const entry = {
+        requestId: ctx.requestId,
         method: ctx.method,
         path: ctx.path,
         status,
@@ -7721,7 +7877,7 @@ function logger(options = {}) {
     }
   };
 }
-var init_logger = __esm({
+var init_logger2 = __esm({
   "src/middleware/logger.ts"() {
     "use strict";
   }
@@ -8299,7 +8455,7 @@ var init_createServer = __esm({
     init_helmet();
     init_compression();
     init_etag();
-    init_logger();
+    init_logger2();
     init_handleWsUpgrade();
     init_serverUtils();
     init_generateSchemaFiles();
@@ -8366,9 +8522,16 @@ import * as mod from '${moduleUrl}';
 
 ${BUILD_VIEW_SOURCE}
 
+${SERIALIZE_ERROR_SOURCE}
+
+${BUILD_LOGGER_SOURCE}
+
 const run = mod.run;
 if (typeof run !== 'function') {
-  parentPort.postMessage({ type: 'error', message: 'Task module has no run export' });
+  parentPort.postMessage({
+    type: 'error',
+    error: { name: 'Error', message: 'Task module has no run export', stack: undefined, props: {} },
+  });
 } else {
   let controller = null;
   parentPort.on('message', async (msg) => {
@@ -8381,21 +8544,45 @@ if (typeof run !== 'function') {
     const { payload, taskCtx } = msg;
     try {
       const registries = buildRegistriesView(msg.registries);
-      const result = await run(payload, { ...taskCtx, signal: controller.signal, registries });
+      const progress = (value) => parentPort.postMessage({ type: 'progress', value });
+      const taskLog = msg.log ? createTaskLogger(msg.log.level, msg.log.scope, msg.log.fields) : undefined;
+      const result = await run(payload, { ...taskCtx, signal: controller.signal, registries, progress, log: taskLog });
       parentPort.postMessage({ type: 'done', result });
     } catch (err) {
-      parentPort.postMessage({
-        type: 'error',
-        message: err instanceof Error ? err.message : String(err),
-      });
+      const serialized = serializeError(err);
+      try {
+        parentPort.postMessage({ type: 'error', error: serialized });
+      } catch (_) {
+        // props \u542B\u4E0D\u53EF\u514B\u9686\u503C\uFF08\u51FD\u6570\u7B49\uFF09\u65F6\u4E22\u5F03 props\uFF0C\u4FDD\u5E95 name/message/stack
+        parentPort.postMessage({
+          type: 'error',
+          error: { name: serialized.name, message: serialized.message, stack: serialized.stack, props: {} },
+        });
+      }
     }
   });
 }
 `;
 }
+function reviveError(payload) {
+  const err = new Error(payload?.message ?? "task worker error");
+  if (payload?.name !== void 0) err.name = payload.name;
+  if (payload?.stack !== void 0) err.stack = payload.stack;
+  if (payload?.props) {
+    for (const [key, value] of Object.entries(payload.props)) {
+      err[key] = value;
+    }
+  }
+  return err;
+}
 async function runTaskInWorker(options) {
   const { taskModulePath, payload, taskCtx, timeoutMs, externalSignal } = options;
-  const killGraceMs = options.killGraceMs ?? KILL_GRACE_MS;
+  const killGraceMs = options.graceMs ?? KILL_GRACE_MS;
+  if (externalSignal?.aborted) {
+    throw new TaskCancelledError(
+      `Task "${taskCtx.job.name}" cancelled before start (driver stop signal already aborted)`
+    );
+  }
   const moduleUrl = pathToFileURL2(taskModulePath).href;
   const wrapperUrl = new URL(
     `data:text/javascript,${encodeURIComponent(buildWrapperSource(moduleUrl))}`
@@ -8443,27 +8630,39 @@ async function runTaskInWorker(options) {
       () => startCancel(`timed out after ${timeoutMs}ms`),
       timeoutMs
     );
-    worker.on("message", (msg) => {
-      if (phase === "grace") {
-        if (msg?.type === "done") {
-          finish(
-            () => reject(
-              new TaskCancelledError(
-                `Task "${taskCtx.job.name}" ${cancelReason} (task completed after the timeout)`
+    worker.on(
+      "message",
+      (msg) => {
+        if (phase === "grace") {
+          if (msg?.type === "done") {
+            finish(
+              () => reject(
+                new TaskCancelledError(
+                  `Task "${taskCtx.job.name}" ${cancelReason} (task completed after the timeout)`
+                )
               )
-            )
-          );
+            );
+          } else if (msg?.type === "error") {
+            finish(() => reject(new TaskCancelledError(msg.error?.message ?? cancelReason)));
+          }
+          return;
+        }
+        if (phase !== "running") return;
+        if (msg?.type === "done") {
+          finish(() => resolve3(msg.result));
         } else if (msg?.type === "error") {
-          finish(() => reject(new TaskCancelledError(msg.message ?? cancelReason)));
+          finish(() => reject(reviveError(msg.error)));
+        } else if (msg?.type === "progress") {
+          options.onProgress?.(msg.value);
+        } else if (msg?.type === "log") {
+          options.onLog?.(msg.entry);
         }
-        return;
-      }
-      if (phase !== "running") return;
-      if (msg?.type === "done") {
-        finish(() => resolve3(msg.result));
-      } else if (msg?.type === "error") {
-        finish(() => reject(new Error(msg.message ?? "task worker error")));
       }
+    );
+    worker.on("messageerror", () => {
+      finish(
+        () => reject(new Error(`Task "${taskCtx.job.name}" worker message could not be deserialized`))
+      );
     });
     worker.on("error", (err) => {
       finish(() => reject(err));
@@ -8480,7 +8679,8 @@ async function runTaskInWorker(options) {
         type: "run",
         payload,
         taskCtx: { config: safeConfig(taskCtx.config), job: taskCtx.job },
-        registries: options.registries
+        registries: options.registries,
+        log: options.log
       });
     } catch (err) {
       finish(
@@ -8491,7 +8691,7 @@ async function runTaskInWorker(options) {
     }
   });
 }
-var KILL_GRACE_MS, TaskCancelledError, BUILD_VIEW_SOURCE;
+var KILL_GRACE_MS, TaskCancelledError, BUILD_VIEW_SOURCE, SERIALIZE_ERROR_SOURCE, BUILD_LOGGER_SOURCE;
 var init_taskWorker = __esm({
   "src/task/taskWorker.ts"() {
     "use strict";
@@ -8556,6 +8756,49 @@ function buildRegistriesView(snapshot) {
     },
   };
 }
+`;
+    SERIALIZE_ERROR_SOURCE = `
+function serializeError(err) {
+  if (err instanceof Error) {
+    var props = {};
+    var keys = Object.keys(err);
+    for (var i = 0; i < keys.length; i++) {
+      props[keys[i]] = err[keys[i]];
+    }
+    return { name: err.name, message: err.message, stack: err.stack, props: props };
+  }
+  return { name: 'Error', message: String(err), stack: undefined, props: {} };
+}
+`;
+    BUILD_LOGGER_SOURCE = `
+var LOG_RANK = { debug: 0, info: 1, warn: 2, error: 3 };
+function createTaskLogger(level, scope, fields) {
+  function make(suffix) {
+    function write(lvl, message, callFields) {
+      if (LOG_RANK[lvl] < LOG_RANK[level]) return;
+      var entry = { level: lvl, message: message, time: new Date().toISOString() };
+      var fullScope = suffix === undefined ? scope : scope === undefined ? suffix : scope + ':' + suffix;
+      if (fullScope !== undefined) entry.scope = fullScope;
+      if (fields !== undefined || callFields !== undefined) {
+        entry.fields = Object.assign({}, fields, callFields);
+      }
+      try {
+        parentPort.postMessage({ type: 'log', entry: entry });
+      } catch (_) {
+        entry.fields = { warning: 'log fields not cloneable across worker boundary, dropped' };
+        parentPort.postMessage({ type: 'log', entry: entry });
+      }
+    }
+    return {
+      debug: function (m, f) { write('debug', m, f); },
+      info: function (m, f) { write('info', m, f); },
+      warn: function (m, f) { write('warn', m, f); },
+      error: function (m, f) { write('error', m, f); },
+      child: function (cs) { return make(suffix === undefined ? cs : suffix + ':' + cs); },
+    };
+  }
+  return make(undefined);
+}
 `;
   }
 });
@@ -8570,6 +8813,25 @@ function createTaskQueue(deps) {
   const schemaCache = /* @__PURE__ */ new Map();
   let started = false;
   let stopped = false;
+  let finishedCount = 0;
+  function transitionStatus(record, status) {
+    const wasTerminal = TERMINAL_STATUSES.has(record.status);
+    const nowTerminal = TERMINAL_STATUSES.has(status);
+    if (!wasTerminal && nowTerminal) finishedCount++;
+    else if (wasTerminal && !nowTerminal) finishedCount--;
+    record.status = status;
+  }
+  function evictFinishedRecords() {
+    let toEvict = finishedCount - MAX_FINISHED_RECORDS;
+    for (const [id, job] of records) {
+      if (toEvict <= 0) break;
+      if (TERMINAL_STATUSES.has(job.status)) {
+        records.delete(id);
+        finishedCount--;
+        toEvict--;
+      }
+    }
+  }
   const loadTaskModule = deps.loadTaskModule ?? (async (filePath) => await import(filePath));
   const loadPayloadSchema = deps.loadPayloadSchema ?? (async (filePath) => {
     const zodPath = path25.join(path25.dirname(filePath), "zod.js");
@@ -8628,7 +8890,8 @@ function createTaskQueue(deps) {
       createdAt: Date.now()
     };
     record.attempts = job.attempt;
-    record.status = "running";
+    transitionStatus(record, "running");
+    delete record.progress;
     record.error = void 0;
     records.set(job.id, record);
     try {
@@ -8642,8 +8905,20 @@ function createTaskQueue(deps) {
             job: { id: job.id, name: job.name, attempt: job.attempt }
           },
           registries: snapshotRegistries(),
+          // 日志配置随 workerData 下发（纯数据），worker 内联重建 taskCtx.log，
+          // 条目回传宿主走统一管道（scope/fields 与进程内路径一致）
+          log: {
+            level: getEffectiveLogLevel(),
+            scope: `task:${job.name}`,
+            fields: { jobId: job.id, task: job.name, attempt: job.attempt }
+          },
           timeoutMs: meta.timeoutMs,
-          externalSignal: job.signal
+          graceMs: meta.graceMs,
+          externalSignal: job.signal,
+          onProgress: (value) => {
+            if (record.status === "running") record.progress = value;
+          },
+          onLog: writeLogEntry
         });
       } else {
         let mod = moduleCache2.get(job.name);
@@ -8658,17 +8933,25 @@ function createTaskQueue(deps) {
           signal: job.signal,
           config: deps.config,
           job: { id: job.id, name: job.name, attempt: job.attempt },
-          registries: registriesView
+          registries: registriesView,
+          log: createLogger(`task:${job.name}`, {
+            fields: { jobId: job.id, task: job.name, attempt: job.attempt }
+          }),
+          progress: (value) => {
+            if (record.status === "running") record.progress = value;
+          }
         };
         result = await mod.run(job.payload, taskCtx);
       }
-      record.status = "done";
+      transitionStatus(record, "done");
       record.result = result;
+      evictFinishedRecords();
       return result;
     } catch (err) {
       const cancelled = err instanceof TaskCancelledError || job.signal.aborted;
-      record.status = cancelled ? "cancelled" : "failed";
+      transitionStatus(record, cancelled ? "cancelled" : "failed");
       record.error = err instanceof Error ? err.message : String(err);
+      evictFinishedRecords();
       if (deps.onFailed) {
         void Promise.resolve().then(
           () => deps.onFailed({
@@ -8763,7 +9046,8 @@ function createTaskQueue(deps) {
       }
       await driver.cancel(name, id);
       const record = records.get(id);
-      if (record) record.status = "cancelled";
+      if (record) transitionStatus(record, "cancelled");
+      evictFinishedRecords();
     },
     async retry(name, id) {
       if (!driver.retry) {
@@ -8773,7 +9057,7 @@ function createTaskQueue(deps) {
       }
       await driver.retry(name, id);
       const record = records.get(id);
-      if (record) record.status = "pending";
+      if (record) transitionStatus(record, "pending");
     },
     async start() {
       if (stopped) {
@@ -8800,12 +9084,16 @@ function createTaskQueue(deps) {
   };
   return queue;
 }
+var TERMINAL_STATUSES, MAX_FINISHED_RECORDS;
 var init_taskQueue = __esm({
   "src/task/taskQueue.ts"() {
     "use strict";
     init_httpErrors();
     init_taskWorker();
     init_registries();
+    init_logger();
+    TERMINAL_STATUSES = /* @__PURE__ */ new Set(["done", "failed", "cancelled"]);
+    MAX_FINISHED_RECORDS = 1e3;
   }
 });
 
@@ -9151,6 +9439,7 @@ async function createAppBase(options) {
     );
   }
   const config = await loadConfig(rootDir, dist);
+  configureLogging(config?.log);
   const serialized = await importWithCacheBust(routesPath);
   const hydrated = await hydrateRoutes(serialized);
   let sorted = sortRoutes(hydrated.routes);
@@ -9487,6 +9776,7 @@ var init_createAppCore = __esm({
     init_loadTaskDriver();
     init_idleTaskDriver();
     init_cronScheduler();
+    init_logger();
     init_loadPlugins();
     init_importWithCacheBust();
     init_registries();
@@ -9510,6 +9800,7 @@ var init_createAppCore = __esm({
       "etag",
       "bodyLimit",
       "logger",
+      "log",
       "http2",
       "trustedProxy",
       "response",