@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-ZWM5KGAA.cjs

@@ -0,0 +1,566 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkM7MKQXAFcjs = require('./chunk-M7MKQXAF.cjs');
+
+
+
+
+
+var _chunk3BU22U3Mcjs = require('./chunk-3BU22U3M.cjs');
+
+
+
+
+
+var _chunkZ2HLU4IXcjs = require('./chunk-Z2HLU4IX.cjs');
+
+
+var _chunkM2L4MYDQcjs = require('./chunk-M2L4MYDQ.cjs');
+
+
+
+var _chunkSHLXACIOcjs = require('./chunk-SHLXACIO.cjs');
+
+
+var _chunk5QIKR7RRcjs = require('./chunk-5QIKR7RR.cjs');
+
+
+var _chunkE3UK5IIBcjs = require('./chunk-E3UK5IIB.cjs');
+
+
+var _chunkUQZ4AYTHcjs = require('./chunk-UQZ4AYTH.cjs');
+
+
+var _chunkKNBBQHO2cjs = require('./chunk-KNBBQHO2.cjs');
+
+
+
+
+var _chunkOX6O6WVAcjs = require('./chunk-OX6O6WVA.cjs');
+
+
+var _chunkUXFQ3UDAcjs = require('./chunk-UXFQ3UDA.cjs');
+
+
+var _chunkBIDYX3SLcjs = require('./chunk-BIDYX3SL.cjs');
+
+
+var _chunkI57LW5VZcjs = require('./chunk-I57LW5VZ.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/middleware/context.ts
+var _CookieJarImpl = class _CookieJarImpl {
+  constructor(req, res) {
+    this.req = req;
+    this.res = res;
+    this.cookies = _chunk3BU22U3Mcjs.parseMiddlewareCookieHeader.call(void 0, req.headers.cookie);
+    const existing = res.getHeader("Set-Cookie");
+    this.setCookies = Array.isArray(existing) ? existing.map(String) : existing === void 0 ? [] : [String(existing)];
+  }
+  get(name) {
+    return this.cookies[name];
+  }
+  set(name, value, options = {}) {
+    this.cookies[name] = value;
+    const cookieString = _chunk3BU22U3Mcjs.serializeMiddlewareCookie.call(void 0, name, value, options);
+    this.setCookies.push(cookieString);
+    this.res.setHeader("Set-Cookie", this.setCookies);
+  }
+  delete(name, options = {}) {
+    delete this.cookies[name];
+    this.setCookies.push(_chunk3BU22U3Mcjs.serializeMiddlewareCookieDeletion.call(void 0, name, options));
+    this.res.setHeader("Set-Cookie", this.setCookies);
+  }
+  getAll() {
+    return { ...this.cookies };
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _CookieJarImpl, "CookieJarImpl");
+var CookieJarImpl = _CookieJarImpl;
+function createContext(req, res, viteServer, parent, server) {
+  const url = _chunkUXFQ3UDAcjs.resolveFarmRequestURL.call(void 0, req, { trustProxy: _optionalChain([server, 'optionalAccess', _ => _.trustProxy]) });
+  const headers = /* @__PURE__ */ new Map();
+  const data = _optionalChain([parent, 'optionalAccess', _2 => _2.data]) ? new Map(parent.data) : /* @__PURE__ */ new Map();
+  const locals = _optionalChain([parent, 'optionalAccess', _3 => _3.locals]) ? new Map(parent.locals) : /* @__PURE__ */ new Map();
+  const cookies = new CookieJarImpl(req, res);
+  if (_optionalChain([parent, 'optionalAccess', _4 => _4.headers])) {
+    for (const [key, value] of Object.entries(parent.headers)) {
+      headers.set(key, value);
+    }
+  }
+  let handled = false;
+  const applyResponseHeaders = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    for (const [key, value] of headers) {
+      try {
+        res.setHeader(key, value);
+      } catch (e) {
+      }
+    }
+  }, "applyResponseHeaders");
+  const ctx = {
+    request: req,
+    response: res,
+    url,
+    pathname: url.pathname,
+    searchParams: url.searchParams,
+    method: req.method || "GET",
+    params: {},
+    route: url.pathname,
+    parent,
+    vite: {
+      isDev: process.env.NODE_ENV !== "production",
+      hmr: !!_optionalChain([viteServer, 'optionalAccess', _5 => _5.hot]),
+      server: viteServer
+    },
+    data,
+    locals,
+    headers,
+    cookies,
+    _handled: false,
+    redirect(redirectUrl, status = 307) {
+      if (handled) {
+        console.warn("Response already sent, cannot redirect");
+        return;
+      }
+      ctx._redirectUrl = redirectUrl;
+      ctx._handled = true;
+      handled = true;
+      applyResponseHeaders();
+      res.writeHead(status, {
+        Location: redirectUrl,
+        "Content-Type": "text/plain"
+      });
+      res.end(`Redirecting to ${redirectUrl}`);
+    },
+    rewrite(rewriteUrl) {
+      ctx._rewriteUrl = rewriteUrl;
+      const newUrl = new URL(rewriteUrl, ctx.url);
+      ctx.url = newUrl;
+      ctx.pathname = newUrl.pathname;
+      ctx.searchParams = newUrl.searchParams;
+      ctx.route = newUrl.pathname;
+      req.url = rewriteUrl;
+    },
+    json(jsonData, status = 200) {
+      if (handled) {
+        console.warn("Response already sent, cannot send JSON");
+        return;
+      }
+      ctx._handled = true;
+      handled = true;
+      applyResponseHeaders();
+      res.writeHead(status, {
+        "Content-Type": "application/json"
+      });
+      res.end(JSON.stringify(jsonData));
+    },
+    text(content, status = 200) {
+      if (handled) {
+        console.warn("Response already sent, cannot send text");
+        return;
+      }
+      ctx._handled = true;
+      handled = true;
+      applyResponseHeaders();
+      res.writeHead(status, {
+        "Content-Type": "text/plain"
+      });
+      res.end(content);
+    },
+    html(content, status = 200) {
+      if (handled) {
+        console.warn("Response already sent, cannot send HTML");
+        return;
+      }
+      ctx._handled = true;
+      handled = true;
+      applyResponseHeaders();
+      res.writeHead(status, {
+        "Content-Type": "text/html"
+      });
+      res.end(content);
+    }
+  };
+  return ctx;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createContext, "createContext");
+
+// src/middleware/manager.ts
+var _fs = require('fs'); var fs = _interopRequireWildcard(_fs);
+var _path = require('path'); var path = _interopRequireWildcard(_path);
+
+// src/middleware/path.ts
+function appendMiddlewareRoutePath(routePath, directoryName) {
+  const marker = _chunkM7MKQXAFcjs.parseInterceptionMarker.call(void 0, directoryName);
+  if (marker) {
+    const owner = routePath.split("/").filter(Boolean);
+    const parts = [
+      ...marker.root ? [] : owner.slice(0, Math.max(0, owner.length - marker.up)),
+      ...marker.remainder ? [marker.remainder] : []
+    ];
+    return `/${parts.join("/")}`;
+  }
+  if (directoryName.startsWith("(") && directoryName.endsWith(")") || _chunkM7MKQXAFcjs.isRouteSlotSegment.call(void 0, directoryName)) {
+    return routePath;
+  }
+  return routePath === "/" ? `/${directoryName}` : `${routePath}/${directoryName}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendMiddlewareRoutePath, "appendMiddlewareRoutePath");
+function appendMiddlewareDirectory(directory, directoryName) {
+  return directory === "" ? directoryName : `${directory}/${directoryName}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendMiddlewareDirectory, "appendMiddlewareDirectory");
+function countSegments(value) {
+  return value.split("/").filter(Boolean).length;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, countSegments, "countSegments");
+function compareMiddlewareRouteLocations(left, right) {
+  return countSegments(left.path) - countSegments(right.path) || left.path.localeCompare(right.path) || countSegments(left.directory) - countSegments(right.directory) || left.directory.localeCompare(right.directory);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compareMiddlewareRouteLocations, "compareMiddlewareRouteLocations");
+
+// src/middleware/manager.ts
+function isMiddlewareResponse(value) {
+  return value instanceof Response;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isMiddlewareResponse, "isMiddlewareResponse");
+var _MiddlewareManager = class _MiddlewareManager {
+  constructor(appDir, viteServer, config, i18n, server, apiBasePath) {
+    this.middleware = [];
+    this.configMiddleware = [];
+    this.appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
+    this.viteServer = viteServer;
+    this.i18n = i18n;
+    this.server = server;
+    this.toMiddlewarePathnames = _chunkKNBBQHO2cjs.createFarmAPIMiddlewarePathnames.call(void 0, apiBasePath);
+    this.configure(config);
+  }
+  configure(config) {
+    this.configMiddleware = [];
+    this.globalConfig = void 0;
+    if (!config) return;
+    const entries = Array.isArray(config) ? config : [config];
+    for (const [index, entry] of entries.entries()) {
+      const handlers = this.getConfigHandlers(entry);
+      const middlewareConfig = this.toMiddlewareConfig(entry);
+      _chunkZ2HLU4IXcjs.compileMiddlewareConfig.call(void 0, middlewareConfig);
+      if (handlers.length === 0) {
+        this.globalConfig = middlewareConfig;
+        continue;
+      }
+      this.configMiddleware.push({
+        path: "/",
+        filePath: `farm.config.ts#middleware-${index}`,
+        handlers,
+        config: middlewareConfig,
+        source: "config"
+      });
+    }
+  }
+  /**
+   * Discover all middleware.ts files
+   */
+  async discover() {
+    const middlewareByDirectory = /* @__PURE__ */ new Map();
+    for (const appDir of this.appDirs) {
+      const discovered = [];
+      await this.discoverInDirectory(appDir, "/", "", discovered);
+      for (const entry of discovered) {
+        _chunkZ2HLU4IXcjs.compileMiddlewareRoute.call(void 0, entry.middleware);
+        middlewareByDirectory.set(entry.location.directory, entry);
+      }
+    }
+    this.middleware = Array.from(middlewareByDirectory.values()).sort((left, right) => compareMiddlewareRouteLocations(left.location, right.location)).map((entry) => entry.middleware);
+    if (process.env.FARM_VERBOSE && this.middleware.length > 0) {
+      _chunk5QIKR7RRcjs.logger.success(`Discovered ${this.middleware.length} middleware files`);
+      for (const mw of this.middleware) {
+        _chunk5QIKR7RRcjs.logger.info(`  ${mw.path} (${mw.handlers.length} handlers)`);
+      }
+    }
+  }
+  /**
+   * Recursively discover middleware files
+   */
+  async discoverInDirectory(dir, routePath, directory, discovered) {
+    if (!fs.existsSync(dir)) {
+      return;
+    }
+    const middlewareFile = this.findMiddlewareFile(dir);
+    if (middlewareFile) {
+      const middleware = await this.loadMiddleware(middlewareFile, routePath);
+      if (middleware) {
+        discovered.push({ location: { path: routePath, directory }, middleware });
+      }
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        await this.discoverInDirectory(
+          path.join(dir, entry.name),
+          appendMiddlewareRoutePath(routePath, entry.name),
+          appendMiddlewareDirectory(directory, entry.name),
+          discovered
+        );
+      }
+    }
+  }
+  /**
+   * Find middleware file in directory
+   */
+  findMiddlewareFile(dir) {
+    const extensions = [".ts", ".tsx", ".js", ".jsx"];
+    for (const ext of extensions) {
+      const filePath = path.join(dir, `middleware${ext}`);
+      if (fs.existsSync(filePath)) {
+        return filePath;
+      }
+    }
+    return null;
+  }
+  /**
+   * Load a middleware file
+   */
+  async loadMiddleware(filePath, routePath) {
+    try {
+      let module;
+      if (this.viteServer) {
+        module = await _chunkSHLXACIOcjs.loadFarmDevModule.call(void 0, this.viteServer, filePath);
+      } else {
+        module = await import(
+          /* @vite-ignore */
+          _chunkSHLXACIOcjs.toFileModuleUrl.call(void 0, filePath)
+        );
+      }
+      const normalized = _chunk3BU22U3Mcjs.normalizeMiddlewareModule.call(void 0, module, routePath);
+      if (!normalized) {
+        throw new Error("must export a default handler or a named middleware handler");
+      }
+      if (normalized.config) {
+        _chunkZ2HLU4IXcjs.compileMiddlewareConfig.call(void 0, normalized.config);
+      }
+      return {
+        path: routePath,
+        filePath,
+        handlers: normalized.handlers,
+        config: normalized.config,
+        source: "file"
+      };
+    } catch (error) {
+      throw new Error(`Failed to load middleware ${filePath}: ${error}`);
+    }
+  }
+  /**
+   * Execute middleware for a request
+   */
+  async execute(req, res) {
+    const url = _chunkUXFQ3UDAcjs.resolveFarmRequestURL.call(void 0, req, { trustProxy: _optionalChain([this, 'access', _6 => _6.server, 'optionalAccess', _7 => _7.trustProxy]) });
+    const pathname = url.pathname;
+    const toRoutePathname = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (value) => _optionalChain([this, 'access', _8 => _8.i18n, 'optionalAccess', _9 => _9.enabled]) ? _chunkBIDYX3SLcjs.stripFarmLocaleFromPathname.call(void 0, value, this.i18n) : _chunkI57LW5VZcjs.stripFarmBasePath.call(void 0, value, _nullishCoalesce(_optionalChain([this, 'access', _10 => _10.i18n, 'optionalAccess', _11 => _11.basePath]), () => ( "/"))), "toRoutePathname");
+    const routePathname = toRoutePathname(pathname);
+    const toMiddlewarePathnames = this.toMiddlewarePathnames;
+    const method = req.method || "GET";
+    const startTime = Date.now();
+    let parentData;
+    let ctx = createContext(req, res, this.viteServer, void 0, this.server);
+    if (this.globalConfig) {
+      const globalMatch = this.matchesConfig(routePathname, this.globalConfig, ctx);
+      if (!globalMatch.matched) {
+        return false;
+      }
+      if (globalMatch.params) {
+        ctx.params = { ...ctx.params, ...globalMatch.params };
+      }
+    }
+    const applicable = [
+      ...this.configMiddleware.map((mw) => ({ mw, routeMatch: { matched: true } })),
+      ...this.middleware.map((mw) => ({
+        mw,
+        routeMatch: _chunkZ2HLU4IXcjs.matchesMiddlewareRouteAt.call(void 0, toMiddlewarePathnames(routePathname), mw)
+      })).filter((entry) => entry.routeMatch.matched)
+    ];
+    if (applicable.length === 0) {
+      return false;
+    }
+    const pc = _chunkM2L4MYDQcjs.createCliColors.call(void 0, );
+    const log = [
+      pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
+      pc.dim("[") + pc.bold(pc.magenta("MIDDLEWARE")) + pc.dim("]"),
+      pc.dim("[") + pc.bold(pc.white(method.padEnd(3))) + pc.dim("]"),
+      pc.gray("Executing middleware: "),
+      pc.gray(pathname),
+      pc.dim(` (${(Date.now() - startTime).toFixed(2)}ms)`)
+    ].join(" ");
+    console.log(log);
+    const ran = /* @__PURE__ */ new Set();
+    const allMiddleware = [...this.configMiddleware, ...this.middleware];
+    const globalConfig = this.globalConfig;
+    const trustProxy = _optionalChain([this, 'access', _12 => _12.server, 'optionalAccess', _13 => _13.trustProxy]);
+    function* applicableMiddleware() {
+      let passPathname = routePathname;
+      let pass = applicable;
+      for (; ; ) {
+        for (const entry of pass) yield { ...entry, pathname: passPathname };
+        const rewrittenPathname = toRoutePathname(
+          _chunkUXFQ3UDAcjs.resolveFarmRequestURL.call(void 0, req, { trustProxy }).pathname
+        );
+        if (rewrittenPathname === passPathname) return;
+        passPathname = rewrittenPathname;
+        const passPathnames = toMiddlewarePathnames(passPathname);
+        if (globalConfig && !_chunkZ2HLU4IXcjs.matchesMiddlewareConfigAt.call(void 0, passPathnames, globalConfig, ctx).matched) {
+          return;
+        }
+        pass = allMiddleware.filter((mw) => !ran.has(mw)).map((mw) => ({
+          mw,
+          routeMatch: mw.source === "config" ? { matched: true } : _chunkZ2HLU4IXcjs.matchesMiddlewareRouteAt.call(void 0, passPathnames, mw)
+        })).filter((entry) => entry.routeMatch.matched);
+      }
+    }
+    _chunkS3JO3N4Hcjs.__name.call(void 0, applicableMiddleware, "applicableMiddleware");
+    for (const { mw, routeMatch, pathname: passPathname } of applicableMiddleware()) {
+      const configMatch = mw.config ? this.matchesConfig(passPathname, mw.config, ctx) : { matched: true };
+      if (!configMatch.matched) {
+        continue;
+      }
+      ran.add(mw);
+      if (routeMatch.params) {
+        ctx.params = { ...ctx.params, ...routeMatch.params };
+      }
+      if (configMatch.params) {
+        ctx.params = { ...ctx.params, ...configMatch.params };
+      }
+      if (parentData) {
+        ctx = createContext(req, res, this.viteServer, parentData, this.server);
+        if (routeMatch.params) {
+          ctx.params = { ...ctx.params, ...routeMatch.params };
+        }
+        if (configMatch.params) {
+          ctx.params = { ...ctx.params, ...configMatch.params };
+        }
+      }
+      const middlewareStartTime = Date.now();
+      const middlewareEvent = {
+        route: mw.path,
+        pathname,
+        name: mw.filePath
+      };
+      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "middleware.start", ...middlewareEvent });
+      try {
+        let handlerIndex = 0;
+        let returnedResponse;
+        const executeNext = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => {
+          if (handlerIndex < mw.handlers.length) {
+            const handler = mw.handlers[handlerIndex++];
+            const result2 = await handler(ctx, executeNext);
+            if (isMiddlewareResponse(result2)) {
+              returnedResponse = result2;
+              return result2;
+            }
+          }
+          return returnedResponse;
+        }, "executeNext");
+        const result = await executeNext();
+        const response = isMiddlewareResponse(result) ? result : returnedResponse;
+        if (response) {
+          if (!res.headersSent && !res.writableEnded) {
+            for (const [key, value] of ctx.headers) {
+              try {
+                res.setHeader(key, value);
+              } catch (error) {
+              }
+            }
+          }
+          _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: response.status
+          });
+          await _chunkUQZ4AYTHcjs.sendWebResponse.call(void 0, res, response);
+          return true;
+        }
+        if (ctx._handled || res.headersSent || res.writableEnded) {
+          _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: res.statusCode
+          });
+          return true;
+        }
+        _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+          type: "middleware.complete",
+          ...middlewareEvent,
+          durationMs: Date.now() - middlewareStartTime
+        });
+      } catch (error) {
+        _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, 
+          _chunkOX6O6WVAcjs.isFarmRedirectError.call(void 0, error) || _chunkOX6O6WVAcjs.isFarmNotFoundError.call(void 0, error) ? {
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: _chunkOX6O6WVAcjs.isFarmRedirectError.call(void 0, error) ? _chunkOX6O6WVAcjs.getFarmRedirectError.call(void 0, error).status : 404
+          } : { type: "middleware.error", ...middlewareEvent, error }
+        );
+        throw error;
+      }
+      parentData = {
+        data: new Map(ctx.data),
+        locals: new Map(ctx.locals),
+        headers: Object.fromEntries(ctx.headers)
+      };
+    }
+    if (!res.headersSent && !res.writableEnded) {
+      for (const [key, value] of ctx.headers) {
+        try {
+          res.setHeader(key, value);
+        } catch (error) {
+        }
+      }
+    }
+    req.__FARM_MIDDLEWARE_DATA__ = new Map(ctx.data);
+    req.__FARM_MIDDLEWARE_CONTEXT__ = new Map(ctx.locals);
+    return false;
+  }
+  /**
+   * Check if pathname matches middleware config
+   */
+  matchesConfig(pathname, config, ctx) {
+    return _chunkZ2HLU4IXcjs.matchesMiddlewareConfigAt.call(void 0, this.toMiddlewarePathnames(pathname), config, ctx);
+  }
+  /**
+   * Reload middleware (for HMR)
+   */
+  async reload() {
+    await this.discover();
+  }
+  getMiddlewares() {
+    return [...this.configMiddleware, ...this.middleware];
+  }
+  hasMiddleware() {
+    return this.configMiddleware.length > 0 || this.middleware.length > 0;
+  }
+  getConfigHandlers(entry) {
+    const handlers = [];
+    if ("handler" in entry && typeof entry.handler === "function") {
+      handlers.push(entry.handler);
+    }
+    if ("handlers" in entry && Array.isArray(entry.handlers)) {
+      handlers.push(...entry.handlers.filter((handler) => typeof handler === "function"));
+    }
+    return handlers;
+  }
+  toMiddlewareConfig(entry) {
+    const { matcher, exclude, runtime } = entry;
+    return { matcher, exclude, runtime };
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _MiddlewareManager, "MiddlewareManager");
+var MiddlewareManager = _MiddlewareManager;
+
+
+
+
+
+
+
+exports.createContext = createContext; exports.appendMiddlewareRoutePath = appendMiddlewareRoutePath; exports.appendMiddlewareDirectory = appendMiddlewareDirectory; exports.compareMiddlewareRouteLocations = compareMiddlewareRouteLocations; exports.MiddlewareManager = MiddlewareManager;

package/dist/chunk-ZZSRYEYU.mjs

@@ -0,0 +1,53 @@
+import {
+  bundleNodeModule
+} from "./chunk-SFGWNC43.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/instrumentation.ts
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+var INSTRUMENTATION_EXTENSIONS = ["ts", "mts", "js", "mjs"];
+function resolveFarmInstrumentationFile(root, srcDir = "src") {
+  const candidates = [
+    ...INSTRUMENTATION_EXTENSIONS.map(
+      (extension) => path.join(root, srcDir, `instrumentation.${extension}`)
+    ),
+    ...INSTRUMENTATION_EXTENSIONS.map(
+      (extension) => path.join(root, `instrumentation.${extension}`)
+    )
+  ].filter((candidate) => fs.existsSync(candidate));
+  if (candidates.length > 1) {
+    throw new Error(
+      `Farm.js found multiple instrumentation files:
+${candidates.map((candidate) => `- ${path.relative(root, candidate)}`).join("\n")}
+Keep only one instrumentation file in the project root or ${srcDir}/.`
+    );
+  }
+  return candidates[0] ?? null;
+}
+__name(resolveFarmInstrumentationFile, "resolveFarmInstrumentationFile");
+async function loadFarmInstrumentation(filePath, root) {
+  if (!filePath) return null;
+  const outputDirectory = path.join(root, ".farm", ".instrumentation-loader");
+  const outputFile = path.join(outputDirectory, "instrumentation.mjs");
+  await fs.promises.mkdir(outputDirectory, { recursive: true });
+  await bundleNodeModule({
+    root,
+    entry: filePath,
+    outfile: outputFile,
+    target: "node20",
+    externalPackages: true
+  });
+  const url = pathToFileURL(outputFile);
+  url.searchParams.set("t", String(Date.now()));
+  return await import(url.href);
+}
+__name(loadFarmInstrumentation, "loadFarmInstrumentation");
+
+export {
+  resolveFarmInstrumentationFile,
+  loadFarmInstrumentation
+};

package/dist/client/lifecycle.cjs

@@ -1,8 +1,8 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
 
 
-var _chunk2XGBJSDVcjs = require('../chunk-2XGBJSDV.cjs');
-require('../chunk-BTZ5O6VM.cjs');
+var _chunkVB6UCX3Vcjs = require('../chunk-VB6UCX3V.cjs');
+require('../chunk-S3JO3N4H.cjs');
 
 
-exports.defineClient = _chunk2XGBJSDVcjs.defineClient;
+exports.defineClient = _chunkVB6UCX3Vcjs.defineClient;

package/dist/client/lifecycle.mjs

@@ -1,8 +1,8 @@
 "use client";
 import {
   defineClient
-} from "../chunk-IFTGERT3.mjs";
-import "../chunk-Y6FXYEAI.mjs";
+} from "../chunk-H4AMB6ZE.mjs";
+import "../chunk-LPEX4YW6.mjs";
 export {
   defineClient
 };

package/dist/client-plugins.cjs

@@ -1,9 +1,9 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
-var _chunk2XGBJSDVcjs = require('./chunk-2XGBJSDV.cjs');
-require('./chunk-BTZ5O6VM.cjs');
+var _chunkVB6UCX3Vcjs = require('./chunk-VB6UCX3V.cjs');
+require('./chunk-S3JO3N4H.cjs');
 
 
 
-exports.FarmClientPluginManager = _chunk2XGBJSDVcjs.FarmClientPluginManager; exports.createClientPluginManager = _chunk2XGBJSDVcjs.createClientPluginManager;
+exports.FarmClientPluginManager = _chunkVB6UCX3Vcjs.FarmClientPluginManager; exports.createClientPluginManager = _chunkVB6UCX3Vcjs.createClientPluginManager;

package/dist/client-plugins.mjs

@@ -1,8 +1,8 @@
 import {
   FarmClientPluginManager,
   createClientPluginManager
-} from "./chunk-IFTGERT3.mjs";
-import "./chunk-Y6FXYEAI.mjs";
+} from "./chunk-H4AMB6ZE.mjs";
+import "./chunk-LPEX4YW6.mjs";
 export {
   FarmClientPluginManager,
   createClientPluginManager