@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-C3VRMB6H.cjs

@@ -0,0 +1,85 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkY4YWHNKUcjs = require('./chunk-Y4YWHNKU.cjs');
+
+
+var _chunkI7PUUDGYcjs = require('./chunk-I7PUUDGY.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/server-query-client.ts
+var _react = require('react');
+function useServerQuery(query, input, options = {}) {
+  const cache = _chunkI7PUUDGYcjs.getFarmClientDataCache.call(void 0, );
+  const key = _chunkY4YWHNKUcjs.createServerQueryCallKey.call(void 0, query, input);
+  const inputRef = _react.useRef.call(void 0, input);
+  const optionsRef = _react.useRef.call(void 0, options);
+  const mountedKeyRef = _react.useRef.call(void 0, void 0);
+  const pendingInvalidationRef = _react.useRef.call(void 0, false);
+  inputRef.current = input;
+  optionsRef.current = options;
+  const subscribe = _react.useCallback.call(void 0, 
+    (listener) => cache.subscribe(key, (event) => {
+      if (event === "invalidate") pendingInvalidationRef.current = true;
+      else if (_optionalChain([cache, 'access', _ => _.get, 'call', _2 => _2(key), 'optionalAccess', _3 => _3.fetching])) {
+        pendingInvalidationRef.current = false;
+      }
+      listener();
+    }),
+    [cache, key]
+  );
+  const getSnapshot = _react.useCallback.call(void 0, () => cache.get(key), [cache, key]);
+  const entry = _react.useSyncExternalStore.call(void 0, subscribe, getSnapshot, () => void 0);
+  const run = _react.useCallback.call(void 0, 
+    (force = false) => {
+      pendingInvalidationRef.current = false;
+      return _chunkY4YWHNKUcjs.fetchServerQuery.call(void 0, query, inputRef.current, {
+        ...optionsRef.current,
+        force
+      });
+    },
+    [query]
+  );
+  _react.useEffect.call(void 0, () => {
+    if (options.enabled === false) {
+      mountedKeyRef.current = void 0;
+      return;
+    }
+    const firstReadForKey = mountedKeyRef.current !== key;
+    if (firstReadForKey) mountedKeyRef.current = key;
+    if (firstReadForKey && (!entry || cache.isStale(key)) || pendingInvalidationRef.current && _optionalChain([entry, 'optionalAccess', _4 => _4.invalidatedAt]) !== void 0 && !entry.fetching) {
+      void run().catch(() => void 0);
+    }
+  }, [cache, entry, key, options.enabled, run]);
+  _react.useEffect.call(void 0, () => {
+    if (options.enabled === false) return;
+    return _chunkY4YWHNKUcjs.attachRevalidationListeners.call(void 0, 
+      () => {
+        if (cache.isStale(key)) void run().catch(() => void 0);
+      },
+      {
+        refetchOnWindowFocus: options.refetchOnWindowFocus,
+        refetchOnReconnect: options.refetchOnReconnect
+      }
+    );
+  }, [cache, key, options.enabled, options.refetchOnReconnect, options.refetchOnWindowFocus, run]);
+  const status = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _5 => _5.status]), () => ( (entry ? "success" : "idle")));
+  const fetching = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _6 => _6.fetching]), () => ( false));
+  return {
+    data: _optionalChain([entry, 'optionalAccess', _7 => _7.data]),
+    error: _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _8 => _8.error]), () => ( null)),
+    status,
+    pending: status === "pending" && (_nullishCoalesce(_optionalChain([entry, 'optionalAccess', _9 => _9.updatedAt]), () => ( 0))) === 0,
+    fetching,
+    stale: cache.isStale(key),
+    refetch: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => run(true), "refetch")
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, useServerQuery, "useServerQuery");
+
+
+
+exports.useServerQuery = useServerQuery;

package/dist/chunk-C5GUTBZK.cjs

@@ -0,0 +1,173 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/deployment.ts
+var FARM_DEPLOYMENT_ID_HEADER = "x-farm-deployment-id";
+var FARM_DEPLOYMENT_MISMATCH_HEADER = "x-farm-deployment-mismatch";
+var FARM_DEPLOYMENT_COOKIE = "__farm_deployment";
+var FARM_DEPLOYMENT_MISMATCH_CODE = "FARM_DEPLOYMENT_MISMATCH";
+var FARM_DEPLOYMENT_MISMATCH_STATUS = 409;
+function getFarmPresetRuntime(preset) {
+  if (preset === "cloudflare" || preset === "cloudflare-pages" || preset === "cloudflare-module" || preset === "netlify-edge" || preset === "vercel-edge" || preset === "deno") {
+    return "edge";
+  }
+  if (preset === "node-server" || preset === "vercel" || preset === "netlify" || preset === "aws-lambda" || preset === "azure" || preset === "firebase" || preset === "bun" || preset === "self-host" || preset === "farm") {
+    return "node";
+  }
+  return "unknown";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmPresetRuntime, "getFarmPresetRuntime");
+var _FarmDeploymentMismatchError = class _FarmDeploymentMismatchError extends Error {
+  constructor(clientDeploymentId, serverDeploymentId) {
+    super("The application was updated while this page was open. Refresh before trying again.");
+    this.clientDeploymentId = clientDeploymentId;
+    this.serverDeploymentId = serverDeploymentId;
+    this.name = "FarmDeploymentMismatchError";
+    this.code = FARM_DEPLOYMENT_MISMATCH_CODE;
+    this.retryable = false;
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _FarmDeploymentMismatchError, "FarmDeploymentMismatchError");
+var FarmDeploymentMismatchError = _FarmDeploymentMismatchError;
+function normalizeFarmDeploymentId(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new TypeError("Farm deploymentId must be a non-empty string");
+  }
+  const normalized = value.trim();
+  if (normalized.length > 200 || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    throw new TypeError("Farm deploymentId must be at most 200 characters without control bytes");
+  }
+  return normalized;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmDeploymentId, "normalizeFarmDeploymentId");
+function createFarmDeploymentRequestHeaders(deploymentId, init) {
+  const headers = new Headers(init);
+  if (deploymentId) {
+    headers.set(FARM_DEPLOYMENT_ID_HEADER, deploymentId);
+  }
+  return headers;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmDeploymentRequestHeaders, "createFarmDeploymentRequestHeaders");
+function getFarmRequestDeploymentId(request) {
+  const headerValue = _optionalChain([request, 'access', _ => _.headers, 'access', _2 => _2.get, 'call', _3 => _3(FARM_DEPLOYMENT_ID_HEADER), 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  if (headerValue) return headerValue;
+  if (isSafeRequestMethod(request.method)) return void 0;
+  return readCookie(request.headers.get("cookie"), FARM_DEPLOYMENT_COOKIE);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRequestDeploymentId, "getFarmRequestDeploymentId");
+function getFarmDeploymentMismatch(request, serverDeploymentId) {
+  if (!serverDeploymentId) return null;
+  const clientDeploymentId = getFarmRequestDeploymentId(request);
+  if (!clientDeploymentId || clientDeploymentId === serverDeploymentId) return null;
+  return { clientDeploymentId, serverDeploymentId };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmDeploymentMismatch, "getFarmDeploymentMismatch");
+function createFarmDeploymentMismatchResponse(mismatch) {
+  return new Response(
+    JSON.stringify({
+      error: FARM_DEPLOYMENT_MISMATCH_CODE,
+      message: "The application deployment changed. Refresh before retrying this request."
+    }),
+    {
+      status: FARM_DEPLOYMENT_MISMATCH_STATUS,
+      headers: {
+        "Cache-Control": "no-store",
+        "Content-Type": "application/json; charset=utf-8",
+        [FARM_DEPLOYMENT_ID_HEADER]: mismatch.serverDeploymentId,
+        [FARM_DEPLOYMENT_MISMATCH_HEADER]: "1"
+      }
+    }
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmDeploymentMismatchResponse, "createFarmDeploymentMismatchResponse");
+function withFarmDeploymentResponse(response, deploymentId, options = {}) {
+  if (!deploymentId) return response;
+  const headers = new Headers(response.headers);
+  headers.set(FARM_DEPLOYMENT_ID_HEADER, deploymentId);
+  if (options.setCookie) {
+    headers.append(
+      "Set-Cookie",
+      createFarmDeploymentCookie(
+        deploymentId,
+        _nullishCoalesce(options.cookiePath, () => ( "/")),
+        _nullishCoalesce(options.secureCookie, () => ( false))
+      )
+    );
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, withFarmDeploymentResponse, "withFarmDeploymentResponse");
+function getFarmResponseDeploymentId(response) {
+  return _optionalChain([response, 'access', _6 => _6.headers, 'access', _7 => _7.get, 'call', _8 => _8(FARM_DEPLOYMENT_ID_HEADER), 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]) || void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmResponseDeploymentId, "getFarmResponseDeploymentId");
+function isFarmDeploymentMismatchResponse(response, clientDeploymentId) {
+  const serverDeploymentId = getFarmResponseDeploymentId(response);
+  if (clientDeploymentId && serverDeploymentId && clientDeploymentId !== serverDeploymentId) {
+    return true;
+  }
+  return response.status === FARM_DEPLOYMENT_MISMATCH_STATUS && response.headers.get(FARM_DEPLOYMENT_MISMATCH_HEADER) === "1";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmDeploymentMismatchResponse, "isFarmDeploymentMismatchResponse");
+function createFarmDeploymentMismatchError(response, clientDeploymentId) {
+  return new FarmDeploymentMismatchError(
+    clientDeploymentId,
+    getFarmResponseDeploymentId(response) || "unknown"
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmDeploymentMismatchError, "createFarmDeploymentMismatchError");
+function createFarmDeploymentCookie(deploymentId, path = "/", secure = false) {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return [
+    `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
+    `Path=${normalizedPath}`,
+    "HttpOnly",
+    "SameSite=Lax",
+    secure ? "Secure" : ""
+  ].filter(Boolean).join("; ");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmDeploymentCookie, "createFarmDeploymentCookie");
+function readCookie(cookieHeader, name) {
+  if (!cookieHeader) return void 0;
+  for (const part of cookieHeader.split(";")) {
+    const separator = part.indexOf("=");
+    if (separator === -1 || part.slice(0, separator).trim() !== name) continue;
+    const value = part.slice(separator + 1).trim();
+    try {
+      return decodeURIComponent(value);
+    } catch (e) {
+      return value;
+    }
+  }
+  return void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readCookie, "readCookie");
+function isSafeRequestMethod(method) {
+  return ["GET", "HEAD", "OPTIONS", "QUERY"].includes(method.toUpperCase());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isSafeRequestMethod, "isSafeRequestMethod");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_DEPLOYMENT_ID_HEADER = FARM_DEPLOYMENT_ID_HEADER; exports.FARM_DEPLOYMENT_MISMATCH_HEADER = FARM_DEPLOYMENT_MISMATCH_HEADER; exports.FARM_DEPLOYMENT_COOKIE = FARM_DEPLOYMENT_COOKIE; exports.FARM_DEPLOYMENT_MISMATCH_CODE = FARM_DEPLOYMENT_MISMATCH_CODE; exports.FARM_DEPLOYMENT_MISMATCH_STATUS = FARM_DEPLOYMENT_MISMATCH_STATUS; exports.getFarmPresetRuntime = getFarmPresetRuntime; exports.FarmDeploymentMismatchError = FarmDeploymentMismatchError; exports.normalizeFarmDeploymentId = normalizeFarmDeploymentId; exports.createFarmDeploymentRequestHeaders = createFarmDeploymentRequestHeaders; exports.getFarmRequestDeploymentId = getFarmRequestDeploymentId; exports.getFarmDeploymentMismatch = getFarmDeploymentMismatch; exports.createFarmDeploymentMismatchResponse = createFarmDeploymentMismatchResponse; exports.withFarmDeploymentResponse = withFarmDeploymentResponse; exports.getFarmResponseDeploymentId = getFarmResponseDeploymentId; exports.isFarmDeploymentMismatchResponse = isFarmDeploymentMismatchResponse; exports.createFarmDeploymentMismatchError = createFarmDeploymentMismatchError; exports.createFarmDeploymentCookie = createFarmDeploymentCookie;

package/dist/chunk-CIAGU2X4.cjs

@@ -0,0 +1,337 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkTIWHTW3Qcjs = require('./chunk-TIWHTW3Q.cjs');
+
+
+var _chunk2CQ74SP6cjs = require('./chunk-2CQ74SP6.cjs');
+
+
+var _chunkWMAPPDMMcjs = require('./chunk-WMAPPDMM.cjs');
+
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/type-generator.ts
+var _fs = require('fs');
+var _module = require('module');
+var _path = require('path');
+var _esmodulelexer = require('es-module-lexer');
+var moduleLexerInitialized = false;
+var JSX_ROUTE_LOADERS = { ".jsx": "jsx", ".tsx": "tsx" };
+var esbuildTransformSync;
+function transformJSXRoute(content, loader, filePath) {
+  _nullishCoalesce(esbuildTransformSync, () => ( (esbuildTransformSync = _module.createRequire.call(void 0, typeof __filename === "string" ? __filename : _chunkS3JO3N4Hcjs.define_import_meta_default.url)(
+    "esbuild"
+  ).transformSync)));
+  return esbuildTransformSync(content, { loader, sourcefile: filePath }).code;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, transformJSXRoute, "transformJSXRoute");
+var API_CLIENT_METHOD_SEGMENTS = /* @__PURE__ */ new Set([
+  "get",
+  "head",
+  "query",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "options"
+]);
+var _APITypeGenerator = class _APITypeGenerator {
+  constructor(appDir) {
+    this.appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
+  }
+  /**
+   * Scan all API route files and extract route information
+   */
+  scanAPIRoutes() {
+    const methodSources = /* @__PURE__ */ new Map();
+    for (const appDir of this.appDirs) {
+      const apiDir = _path.join.call(void 0, appDir, "api");
+      if (!_fs.existsSync.call(void 0, apiDir)) continue;
+      const discovered = [];
+      this.scanDirectory(apiDir, appDir, discovered);
+      for (const route of discovered) {
+        const routeMethods = _nullishCoalesce(methodSources.get(route.path), () => ( /* @__PURE__ */ new Map()));
+        for (const method of route.methods) {
+          routeMethods.set(method, route);
+        }
+        methodSources.set(route.path, routeMethods);
+      }
+    }
+    const routes = [];
+    for (const [routePath, methods] of methodSources) {
+      const routesByFile = /* @__PURE__ */ new Map();
+      for (const [method, route] of methods) {
+        const existing = routesByFile.get(route.filePath);
+        if (existing) {
+          existing.methods.push(method);
+        } else {
+          routesByFile.set(route.filePath, {
+            ...route,
+            path: routePath,
+            methods: [method]
+          });
+        }
+      }
+      routes.push(...routesByFile.values());
+    }
+    return routes.sort(
+      (left, right) => left.path.localeCompare(right.path) || left.filePath.localeCompare(right.filePath)
+    );
+  }
+  scanDirectory(dir, appDir, routes, basePath = "") {
+    const items = _fs.readdirSync.call(void 0, dir, { withFileTypes: true });
+    for (const item of items) {
+      const fullPath = _path.join.call(void 0, dir, item.name);
+      if (item.isDirectory()) {
+        const newBasePath = basePath ? `${basePath}/${item.name}` : item.name;
+        this.scanDirectory(fullPath, appDir, routes, newBasePath);
+      } else if (_chunk2CQ74SP6cjs.isFarmAPIRouteFileName.call(void 0, item.name)) {
+        const routeInfo = this.extractRouteInfo(fullPath, appDir, basePath);
+        if (routeInfo) {
+          routes.push(routeInfo);
+        }
+      }
+    }
+  }
+  extractRouteInfo(filePath, appDir, basePath) {
+    try {
+      const content = _fs.readFileSync.call(void 0, filePath, "utf-8");
+      const methods = this.extractExportedMethods(content, filePath);
+      if (methods.length === 0) {
+        return null;
+      }
+      const relativePath = _path.relative.call(void 0, appDir, filePath);
+      const apiPath = basePath ? `/api/${basePath}` : "/api";
+      return {
+        path: apiPath,
+        methods,
+        filePath,
+        relativePath
+      };
+    } catch (error) {
+      console.warn(`Failed to read route file ${filePath}:`, error);
+      return null;
+    }
+  }
+  extractExportedMethods(content, filePath) {
+    if (!moduleLexerInitialized) {
+      _esmodulelexer.initSync.call(void 0, );
+      moduleLexerInitialized = true;
+    }
+    const httpMethods = ["GET", "HEAD", "QUERY", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
+    const loader = JSX_ROUTE_LOADERS[_path.extname.call(void 0, filePath)];
+    const source = loader ? transformJSXRoute(content, loader, filePath) : content;
+    const [, exports] = _esmodulelexer.parse.call(void 0, source);
+    const valueExports = new Set(
+      exports.filter((specifier) => !this.isTypeOnlyExportSpecifier(source, specifier.s)).map((specifier) => specifier.n)
+    );
+    return httpMethods.filter((method) => valueExports.has(method));
+  }
+  isTypeOnlyExportSpecifier(content, exportNameStart) {
+    let cursor = exportNameStart - 1;
+    while (cursor >= 0) {
+      while (cursor >= 0 && /\s/.test(content[cursor])) cursor--;
+      if (content.slice(cursor - 1, cursor + 1) === "*/") {
+        const commentStart = content.lastIndexOf("/*", cursor - 1);
+        if (commentStart >= 0) {
+          cursor = commentStart - 1;
+          continue;
+        }
+      }
+      const lineStart = content.lastIndexOf("\n", cursor) + 1;
+      const lineCommentStart = content.indexOf("//", lineStart);
+      if (lineCommentStart >= 0 && lineCommentStart <= cursor) {
+        cursor = lineCommentStart - 1;
+        continue;
+      }
+      break;
+    }
+    const tokenEnd = cursor + 1;
+    while (cursor >= 0 && /[A-Za-z0-9_$]/.test(content[cursor])) cursor--;
+    return content.slice(cursor + 1, tokenEnd) === "type";
+  }
+  /**
+   * Generate TypeScript code for the API router
+   */
+  generateAPIRouter(routes, options = {}) {
+    const imports = [];
+    const pluginTypes = [];
+    if (_optionalChain([options, 'access', _ => _.pluginConfigs, 'optionalAccess', _2 => _2.length])) {
+      imports.push('import type { PluginAPIRouter } from "@farm.js/core/api";');
+      options.pluginConfigs.forEach((filePath, index) => {
+        const importPath = this.getRouteImportPath({ filePath }, options.outFile);
+        imports.push(`import type FarmPluginConfig${index} from ${JSON.stringify(importPath)};`);
+        pluginTypes.push(`PluginAPIRouter<typeof FarmPluginConfig${index}>`);
+      });
+    }
+    const routeGroups = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      const key = route.path;
+      if (!routeGroups.has(key)) {
+        routeGroups.set(key, []);
+      }
+      routeGroups.get(key).push(route);
+    }
+    const routeMethodsByPath = /* @__PURE__ */ new Map();
+    for (const [routePath, routeList] of routeGroups) {
+      const cleanPath = routePath === "/api" ? "" : routePath.replace(/^\/api\//, "");
+      routeMethodsByPath.set(
+        cleanPath,
+        new Set(routeList.flatMap((route) => route.methods.map((method) => method.toLowerCase())))
+      );
+    }
+    for (const route of _nullishCoalesce(options.pluginRoutes, () => ( []))) {
+      const cleanPath = route.path === "/api" ? "" : route.path.replace(/^\/api\//, "");
+      const methods = _nullishCoalesce(routeMethodsByPath.get(cleanPath), () => ( /* @__PURE__ */ new Set()));
+      methods.add(route.method.toLowerCase());
+      routeMethodsByPath.set(cleanPath, methods);
+    }
+    const createRouteTreeNode = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => /* @__PURE__ */ Object.create(null), "createRouteTreeNode");
+    const nestedStructure = createRouteTreeNode();
+    const usedRouteNames = /* @__PURE__ */ new Map();
+    for (const [path, routeList] of routeGroups) {
+      const routeName = this.uniqueRouteName(path, usedRouteNames);
+      const cleanPath = path === "/api" ? "" : path.replace(/^\/api\//, "");
+      const parts = cleanPath ? cleanPath.split("/") : [];
+      const methodSources = /* @__PURE__ */ new Map();
+      for (const route of routeList) {
+        for (const method of route.methods) methodSources.set(method, route);
+      }
+      const allMethods = [...methodSources.keys()];
+      for (const method of allMethods) {
+        const importPath = this.getRouteImportPath(methodSources.get(method), options.outFile);
+        const importName = `${method}_${routeName}`;
+        imports.push(
+          `import type { ${method} as ${importName} } from ${JSON.stringify(importPath)};`
+        );
+      }
+      if (parts.length === 0) {
+        for (const method of allMethods) {
+          const importName = `${method}_${routeName}`;
+          const methodName = method.toLowerCase();
+          nestedStructure[methodName] = `typeof ${importName}`;
+        }
+      } else {
+        const hasMethodCollision = parts.some((part, index) => {
+          if (part === "$params" || index === 0 && part === "integrations") return true;
+          if (!API_CLIENT_METHOD_SEGMENTS.has(part)) return false;
+          const parentPath = parts.slice(0, index).join("/");
+          return _optionalChain([routeMethodsByPath, 'access', _3 => _3.get, 'call', _4 => _4(parentPath), 'optionalAccess', _5 => _5.has, 'call', _6 => _6(part)]) === true;
+        });
+        const typePath = hasMethodCollision ? [`/${cleanPath}`] : parts;
+        let current = nestedStructure;
+        for (let i = 0; i < typePath.length; i++) {
+          const part = typePath[i];
+          if (i === typePath.length - 1) {
+            current[part] = createRouteTreeNode();
+            for (const method of allMethods) {
+              const importName = `${method}_${routeName}`;
+              const methodName = method.toLowerCase();
+              current[part][methodName] = `typeof ${importName}`;
+            }
+          } else {
+            if (!Object.prototype.hasOwnProperty.call(current, part)) {
+              current[part] = createRouteTreeNode();
+            }
+            current = current[part];
+          }
+        }
+      }
+    }
+    const typeExports = this.structureToTypeString(nestedStructure, 1);
+    const manifest = /* @__PURE__ */ new Map();
+    const shapes = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      _chunkWMAPPDMMcjs.registerAPIRouteShape.call(void 0, shapes, route.path, route.filePath, "app");
+      const methods = _nullishCoalesce(manifest.get(route.path), () => ( /* @__PURE__ */ new Set()));
+      for (const method of route.methods) methods.add(method);
+      manifest.set(route.path, methods);
+    }
+    for (const route of _nullishCoalesce(options.pluginRoutes, () => ( []))) {
+      _chunkWMAPPDMMcjs.registerAPIRouteShape.call(void 0, shapes, route.path, `plugin:${route.path}`, "app");
+      const methods = _nullishCoalesce(manifest.get(route.path), () => ( /* @__PURE__ */ new Set()));
+      if (methods.has(route.method))
+        throw new Error(`Duplicate API route for ${route.method} ${route.path}`);
+      methods.add(route.method);
+      manifest.set(route.path, methods);
+    }
+    const routeManifest = [...manifest].sort(([a], [b]) => a.localeCompare(b)).map(([path, methods]) => ({ path, methods: [...methods].sort() }));
+    const manifestSource = routeManifest.length ? `[
+${routeManifest.map(
+      ({ path, methods }) => `  {
+    path: ${JSON.stringify(path)},
+    methods: [${methods.map((method) => JSON.stringify(method)).join(", ")}],
+  },`
+    ).join("\n")}
+]` : "[]";
+    return `/**
+ * Auto-generated API router types
+ * This file is automatically generated - do not edit manually
+ *
+ * Server modules are imported only as types. Runtime data contains paths and methods only.
+ */
+
+${imports.join("\n")}
+
+// Type-only representation of your API routes
+export type APIRouter = ${pluginTypes.length ? `${pluginTypes.join(" & ")} & ` : ""}{
+${typeExports}
+};
+
+// Pass this schema-free manifest to createApiClients({ routes: apiRoutes }).
+export const apiRoutes = ${manifestSource} as const;
+`;
+  }
+  getRouteImportPath(route, outFile) {
+    if (!outFile) {
+      return `../app/${route.relativePath.replace(/\\/g, "/").replace(/\.(ts|tsx|js|jsx)$/, "")}`;
+    }
+    const relativeImport = _path.relative.call(void 0, _path.dirname.call(void 0, outFile), route.filePath).replace(/\\/g, "/").replace(/\.(ts|tsx|js|jsx)$/, "");
+    return relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
+  }
+  pathToRouteName(path) {
+    return (path === "/api" ? "root" : path.replace(/^\/api\//, "")).replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "_");
+  }
+  uniqueRouteName(path, usedNames) {
+    const base = this.pathToRouteName(path);
+    const seen = usedNames.get(base);
+    usedNames.set(base, (_nullishCoalesce(seen, () => ( 0))) + 1);
+    return seen ? `${base}_${seen + 1}` : base;
+  }
+  structureToTypeString(obj, indent) {
+    const spaces = "  ".repeat(indent);
+    const lines = [];
+    for (const [key, value] of Object.entries(obj)) {
+      const propertyKey = this.toTypePropertyKey(key);
+      if (typeof value === "string") {
+        lines.push(`${spaces}${propertyKey}: ${value};`);
+      } else if (typeof value === "object") {
+        lines.push(`${spaces}${propertyKey}: {`);
+        lines.push(this.structureToTypeString(value, indent + 1));
+        lines.push(`${spaces}};`);
+      }
+    }
+    return lines.join("\n");
+  }
+  toTypePropertyKey(key) {
+    return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
+  }
+  /**
+   * Generate the API index file
+   */
+  generateAPIIndex(outputPath) {
+    const routes = this.scanAPIRoutes();
+    const content = this.generateAPIRouter(routes, { outFile: outputPath });
+    _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, outputPath), { recursive: true });
+    _chunkTIWHTW3Qcjs.writeFileIfChanged.call(void 0, outputPath, content);
+    console.log(`\u2705 Generated API types for ${routes.length} routes`);
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _APITypeGenerator, "APITypeGenerator");
+var APITypeGenerator = _APITypeGenerator;
+
+
+
+exports.APITypeGenerator = APITypeGenerator;

package/dist/chunk-CMGMGHUZ.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/utils/runtime-env.ts
+function getFarmRuntimeBindings() {
+  const runtimeBindings = globalThis.__env__;
+  return runtimeBindings && typeof runtimeBindings === "object" ? runtimeBindings : void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRuntimeBindings, "getFarmRuntimeBindings");
+function readFarmEnvironmentValue(name) {
+  const runtimeValue = _optionalChain([getFarmRuntimeBindings, 'call', _ => _(), 'optionalAccess', _2 => _2[name]]);
+  if (typeof runtimeValue === "string") return runtimeValue;
+  return typeof process !== "undefined" ? _optionalChain([process, 'access', _3 => _3.env, 'optionalAccess', _4 => _4[name]]) : void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readFarmEnvironmentValue, "readFarmEnvironmentValue");
+function isFarmDeployedRuntime() {
+  if (getFarmRuntimeBindings()) return true;
+  return readFarmEnvironmentValue("NODE_ENV") === "production";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmDeployedRuntime, "isFarmDeployedRuntime");
+
+
+
+
+
+exports.getFarmRuntimeBindings = getFarmRuntimeBindings; exports.readFarmEnvironmentValue = readFarmEnvironmentValue; exports.isFarmDeployedRuntime = isFarmDeployedRuntime;