@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-SA7MLSP4.mjs

@@ -0,0 +1,229 @@
+import {
+  writeFileIfChanged
+} from "./chunk-Q5B4LNON.mjs";
+import {
+  resolveFarmComponentExtensions
+} from "./chunk-ES2LD2YD.mjs";
+import {
+  parseRouteSlotFile
+} from "./chunk-K3RU5MOR.mjs";
+import {
+  discoverProgrammaticRoutePaths
+} from "./chunk-FSXSQQTV.mjs";
+import {
+  parseRoutePath
+} from "./chunk-JSDV2NUN.mjs";
+
+// src/routing/generate-route-types.ts
+import * as path from "path";
+import * as fs from "fs";
+function routeSegmentsToTsTypeLiteral(segments) {
+  if (segments.length === 0) return '"/"';
+  const hasDynamic = segments.some((s) => s.startsWith("["));
+  if (!hasDynamic) return JSON.stringify("/" + segments.join("/"));
+  const parts = segments.map((s) => {
+    if (s.startsWith("[[...") || s.startsWith("[...")) return "${string}";
+    if (s.startsWith("[")) return "${string}";
+    return s;
+  });
+  return "`/" + parts.join("/") + "`";
+}
+function routePatternToTsTypeLiterals(pattern) {
+  if (pattern === "/") return ['"/"'];
+  let variants = [[]];
+  for (const segment of pattern.slice(1).split("/").filter(Boolean)) {
+    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+      variants = variants.flatMap((parts) => [parts, [...parts, segment]]);
+    } else {
+      variants = variants.map((parts) => [...parts, segment]);
+    }
+  }
+  return variants.map(routeSegmentsToTsTypeLiteral);
+}
+function routePatternToRouteLiteral(pattern) {
+  return JSON.stringify(pattern);
+}
+function renderTypeUnion(values) {
+  return values.length <= 1 ? values[0] || "never" : `
+  | ${values.join("\n  | ")}`;
+}
+function renderTypeAlias(name, value) {
+  return `export type ${name} =${value.startsWith("\n") ? "" : " "}${value};`;
+}
+function createRoutePattern(route) {
+  if (route.segments.length === 0) return "/";
+  return "/" + route.segments.map((seg) => {
+    if (!seg.isDynamic) return seg.segment;
+    if (seg.isCatchAll) return seg.isOptional ? `[[...${seg.segment}]]` : `[...${seg.segment}]`;
+    return `[${seg.segment}]`;
+  }).join("/");
+}
+var DEFAULT_OUT_FILE = "farm-routes.d.ts";
+async function generateRouteTypes(options) {
+  const root = path.resolve(options.root);
+  const srcDir = options.srcDir || "src";
+  const outFile = options.outFile || DEFAULT_OUT_FILE;
+  const outPath = path.isAbsolute(outFile) ? outFile : path.join(root, srcDir, outFile);
+  const content = await createRouteTypeDeclarations(options, outPath);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  writeFileIfChanged(outPath, content);
+  return outPath;
+}
+async function createRouteTypeDeclarations(options, outPath) {
+  const { extraRoutes = [], suppressLintOnLink = false } = options;
+  const { pages: patterns, modules: routeModulePatterns } = await scanRoutePatterns(options);
+  for (const route of extraRoutes) {
+    if (route.startsWith("/")) {
+      patterns.add(route);
+      routeModulePatterns.add(route);
+    }
+  }
+  const sortedPatterns = Array.from(patterns).sort();
+  const typeLiterals = Array.from(new Set(sortedPatterns.flatMap(routePatternToTsTypeLiterals)));
+  const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
+  const routeModulePatternLiterals = Array.from(routeModulePatterns).sort().map(routePatternToRouteLiteral);
+  const routePathType = suppressLintOnLink ? "string" : renderTypeUnion(typeLiterals);
+  const routePatternType = suppressLintOnLink ? "string" : renderTypeUnion(patternLiterals);
+  const routeModulePatternType = renderTypeUnion(routeModulePatternLiterals);
+  const routeTypesImportPath = `./${path.basename(outPath).replace(/\.d\.ts$/, "")}`;
+  const linkAugmentationBlock = suppressLintOnLink ? "" : `
+declare module "@farm.js/core/client" {
+  interface LinkDefaultRoute {
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
+  }
+}
+
+declare module "@farm.js/core" {
+  interface LinkDefaultRoute {
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
+  }
+  // Ensure root import ("@farm.js/core") uses the same typed Link signature as client entry.
+  const Link: typeof import("@farm.js/core/client").Link;
+}
+
+// Internal declaration path used by @farm.js/core root type re-exports.
+declare module "@farm.js/core/dist/client.js" {
+  interface LinkDefaultRoute {
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
+  }
+}
+`;
+  const routeModuleAugmentationBlock = `
+declare global {
+  namespace FarmJS {
+    interface RouteRegistry {
+      pattern: import(${JSON.stringify(routeTypesImportPath)}).RouteModulePattern;
+    }
+  }
+}
+`;
+  const content = `/**
+ * Auto-generated route types from src/app.
+ * Link href and route component props are typed automatically from generated declarations.
+ * Regenerated on dev start and when routes change.
+ * Set suppressLintOnLink: true in farm.config.ts to accept any string on Link href.
+ */
+${renderTypeAlias("RoutePath", routePathType)}
+${renderTypeAlias("RoutePattern", routePatternType)}
+${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentationBlock}${routeModuleAugmentationBlock}
+`;
+  return content;
+}
+var PLATFORM_FILE = /^(?:(page|layout)\.(native|ios|android)\.(?:tsx|ts|jsx|js)|page\.(kt|swift))$/;
+async function scanRoutePatterns(options) {
+  const { root, srcDir = "src" } = options;
+  const sourceRoots = options.sourceRoots ?? [{ name: "project", root, srcDir, layer: false }];
+  const componentExtensions = resolveFarmComponentExtensions(options.componentExtensions).map(
+    (extension) => extension.slice(1)
+  );
+  const pages = /* @__PURE__ */ new Set();
+  const modules = /* @__PURE__ */ new Set();
+  const pageFiles = /* @__PURE__ */ new Map();
+  const nativePages = /* @__PURE__ */ new Map();
+  const nativeLayouts = /* @__PURE__ */ new Map();
+  const { glob } = await import("tinyglobby");
+  for (const source of sourceRoots) {
+    const appDir = path.join(source.root, source.srcDir, "app");
+    if (fs.existsSync(appDir)) {
+      const routeModuleFiles = await glob(
+        `**/{page,layout,loading,error}.{${componentExtensions.join(",")},md,mdx}`,
+        { cwd: appDir, expandDirectories: false }
+      );
+      for (const file of routeModuleFiles) {
+        if (parseRouteSlotFile(file)) continue;
+        const route = parseRoutePath(file);
+        const pattern = createRoutePattern(route);
+        modules.add(pattern);
+        if (route.type === "page") {
+          pages.add(pattern);
+          if (options.platformFiles) pageFiles.set(pattern, path.join(appDir, file));
+        }
+      }
+      if (options.platformFiles) {
+        scanPlatformRouteFiles(
+          appDir,
+          await glob(
+            ["**/{page,layout}.{native,ios,android}.{tsx,ts,jsx,js}", "**/page.{kt,swift}"],
+            { cwd: appDir, expandDirectories: false }
+          ),
+          nativePages,
+          nativeLayouts
+        );
+      }
+    }
+    for (const route of await discoverProgrammaticRoutePaths(source.root, source.srcDir)) {
+      pages.add(route);
+      modules.add(route);
+    }
+  }
+  if (!options.platformFiles) return { pages, modules };
+  const nativeOnlyPages = /* @__PURE__ */ new Set();
+  for (const [pattern, files] of nativePages) {
+    if (pages.has(pattern)) continue;
+    if (files.native) {
+      nativeOnlyPages.add(pattern);
+      continue;
+    }
+    const file = path.relative(root, Object.values(files)[0]);
+    const dir = path.dirname(file);
+    throw new Error(
+      `${file.replace(/\\/g, "/")} has no web page next to it. Add ${path.join(dir, "page.tsx").replace(/\\/g, "/")} (the route's web screen and fallback), or ${path.join(dir, "page.native.tsx").replace(/\\/g, "/")} to make the route native-only on both OSes.`
+    );
+  }
+  return { pages, modules, pageFiles, nativePages, nativeLayouts, nativeOnlyPages };
+}
+function scanPlatformRouteFiles(appDir, files, nativePages, nativeLayouts) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const file of [...files].sort()) {
+    const normalized = file.replace(/\\/g, "/");
+    const match = PLATFORM_FILE.exec(path.posix.basename(normalized));
+    if (!match) continue;
+    const kind = match[1] ?? "page";
+    const platform = match[2] ?? match[3];
+    const twin = path.posix.join(path.posix.dirname(normalized), `${kind}.tsx`);
+    if (kind === "page" && parseRouteSlotFile(twin)) continue;
+    const dir = path.posix.dirname(normalized);
+    const pattern = kind === "page" ? createRoutePattern(parseRoutePath(twin)) : dir === "." ? "/" : `/${dir}`;
+    const key = `${kind}\0${pattern}\0${platform}`;
+    const previous = seen.get(key);
+    if (previous) {
+      throw new Error(
+        `Duplicate ${platform} ${kind} for "${pattern}": found ${previous} and ${normalized} in ${appDir}. Keep one.`
+      );
+    }
+    seen.set(key, normalized);
+    const target = kind === "page" ? nativePages : nativeLayouts;
+    const entry = { ...target.get(pattern) };
+    entry[platform] = path.join(appDir, normalized);
+    target.set(pattern, entry);
+  }
+}
+
+export {
+  generateRouteTypes,
+  createRouteTypeDeclarations,
+  scanRoutePatterns
+};

package/dist/chunk-SBDWCDS6.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/api/route-files.ts
+function isFarmAPIRouteFileName(fileName) {
+  return /^route\.(?:ts|tsx|js|jsx)$/.test(fileName);
+}
+
+
+
+exports.isFarmAPIRouteFileName = isFarmAPIRouteFileName;

package/dist/chunk-SF3JB56B.mjs

@@ -0,0 +1,82 @@
+// src/base-path.ts
+var FARM_BASE_PATH = /* @__PURE__ */ Symbol.for("farm.basePath");
+function getFarmGlobalState() {
+  return globalThis;
+}
+function setFarmBasePath(basePath) {
+  getFarmGlobalState()[FARM_BASE_PATH] = normalizeFarmBasePath(basePath);
+}
+function getFarmBasePath() {
+  return getFarmGlobalState()[FARM_BASE_PATH] ?? "";
+}
+function applyFarmBasePath(href, basePath = getFarmBasePath()) {
+  const normalizedBasePath = normalizeFarmBasePath(basePath);
+  if (!normalizedBasePath || !href.startsWith("/") || href.startsWith("//")) return href;
+  const canonicalHref = canonicalizeAppRelativeHref(href);
+  if (canonicalHref === normalizedBasePath || canonicalHref.startsWith(`${normalizedBasePath}/`) || canonicalHref.startsWith(`${normalizedBasePath}?`) || canonicalHref.startsWith(`${normalizedBasePath}#`)) {
+    return canonicalHref;
+  }
+  return `${normalizedBasePath}${canonicalHref}`;
+}
+function canonicalizeAppRelativeHref(href) {
+  const origin = "http://farm.local";
+  const resolved = new URL(href, origin);
+  if (resolved.origin !== origin) {
+    throw new Error("Farm app-relative href cannot change the URL origin.");
+  }
+  return `${resolved.pathname}${resolved.search}${resolved.hash}`;
+}
+function stripFarmBasePath(pathname, basePath = getFarmBasePath()) {
+  const normalizedBasePath = normalizeFarmBasePath(basePath);
+  if (!normalizedBasePath) return pathname || "/";
+  if (pathname === normalizedBasePath) return "/";
+  if (!pathname.startsWith(`${normalizedBasePath}/`)) return pathname || "/";
+  return pathname.slice(normalizedBasePath.length) || "/";
+}
+function normalizeFarmBasePath(basePath) {
+  if (!basePath || basePath === "/") return "";
+  const hasUnstableCharacters = (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+  if (hasUnstableCharacters(basePath)) {
+    throw new Error("Farm basePath cannot contain backslashes or control characters.");
+  }
+  const pathname = basePath.trim();
+  if (!pathname || pathname === "/") return "";
+  if (pathname.includes("?") || pathname.includes("#")) {
+    throw new Error("Farm basePath cannot contain a query string or hash.");
+  }
+  if (pathname.startsWith("//") || /^[a-z][a-z\d+.-]*:\/\//i.test(pathname)) {
+    throw new Error('Farm basePath must be a pathname such as "/docs", not a URL.');
+  }
+  for (const segment of pathname.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+    }
+    if (hasUnstableCharacters(decoded)) {
+      throw new Error("Farm basePath cannot contain backslashes or control characters.");
+    }
+    if (decoded.includes("/")) {
+      throw new Error("Farm basePath cannot contain percent-encoded path separators.");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new Error('Farm basePath cannot contain "." or ".." path segments.');
+    }
+  }
+  return `/${pathname}`.replace(/\/{2,}/g, "/").replace(/\/+$/, "");
+}
+function normalizeFarmConfigBasePath(basePath) {
+  return normalizeFarmBasePath(basePath) || "/";
+}
+
+export {
+  setFarmBasePath,
+  getFarmBasePath,
+  applyFarmBasePath,
+  stripFarmBasePath,
+  normalizeFarmBasePath,
+  normalizeFarmConfigBasePath
+};

package/dist/chunk-SG57PX7K.cjs

@@ -0,0 +1,65 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/app-manifest-config.ts
+var NAME = "agent.manifest";
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function checkKeys(value, keys, name) {
+  for (const key of Object.keys(value)) {
+    if (!keys.includes(key)) {
+      throw new TypeError(`${name} has an unknown option "${key}"; expected ${keys.join(", ")}.`);
+    }
+  }
+}
+function readBoolean(value, name, fallback = true) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "boolean") throw new TypeError(`${name} must be a boolean.`);
+  return value;
+}
+function readHide(value, name) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || !entry.trim())) {
+    throw new TypeError(`${name} must be an array of non-empty strings.`);
+  }
+  return [...new Set(value.map((entry) => entry.trim()))];
+}
+function readSection(value, name, keys, read) {
+  if (value === false) return false;
+  if (value === void 0 || value === true) return read({});
+  if (!isObject(value)) throw new TypeError(`${name} must be true, false, or an options object.`);
+  checkKeys(value, keys, name);
+  return read(value);
+}
+function resolveFarmAppManifestConfig(input) {
+  if (input === false) return false;
+  if (input !== void 0 && input !== true && !isObject(input)) {
+    throw new TypeError(`${NAME} must be true, false, or an options object.`);
+  }
+  const config = isObject(input) ? input : {};
+  checkKeys(config, ["app", "packages", "mcp", "webmcp", "integrations", "agent", "plugins"], NAME);
+  const packages = config.packages;
+  if (packages !== void 0 && typeof packages !== "boolean" && packages !== "names") {
+    throw new TypeError(`${NAME}.packages must be true, false, or "names".`);
+  }
+  return {
+    app: readSection(config.app, `${NAME}.app`, ["version", "renderer", "build"], (app) => ({
+      version: readBoolean(app.version, `${NAME}.app.version`),
+      renderer: readBoolean(app.renderer, `${NAME}.app.renderer`),
+      build: readBoolean(app.build, `${NAME}.app.build`)
+    })),
+    packages: _nullishCoalesce(packages, () => ( true)),
+    mcp: readSection(config.mcp, `${NAME}.mcp`, ["schemas", "hide"], (mcp) => ({
+      schemas: readBoolean(mcp.schemas, `${NAME}.mcp.schemas`),
+      hide: readHide(mcp.hide, `${NAME}.mcp.hide`)
+    })),
+    webmcp: readSection(config.webmcp, `${NAME}.webmcp`, ["hide"], (webmcp) => ({
+      hide: readHide(webmcp.hide, `${NAME}.webmcp.hide`)
+    })),
+    integrations: readBoolean(config.integrations, `${NAME}.integrations`),
+    agent: readBoolean(config.agent, `${NAME}.agent`),
+    plugins: readBoolean(config.plugins, `${NAME}.plugins`)
+  };
+}
+
+
+
+exports.resolveFarmAppManifestConfig = resolveFarmAppManifestConfig;

package/dist/chunk-SGBNF56S.cjs

@@ -0,0 +1,44 @@
+"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; }// src/deployment-environment.ts
+function isFarmProductionDeploymentEnvironment(env = process.env) {
+  const environment = normalizeEnvironment(env.VERCEL_ENV);
+  const targetEnvironment = normalizeEnvironment(env.VERCEL_TARGET_ENV);
+  if (environment && environment !== "production") return false;
+  if (targetEnvironment && targetEnvironment !== "production") return false;
+  if (isTrue(env.NETLIFY)) {
+    const context = normalizeEnvironment(env.CONTEXT);
+    if (context && context !== "production") return false;
+  }
+  if (isTrue(env.IS_PULL_REQUEST)) return false;
+  return true;
+}
+function isFarmPreviewDeploymentEnvironment(env) {
+  return resolveFarmPreviewDeployment(env, false);
+}
+function resolveFarmPreviewDeployment(env, builtAsPreview) {
+  const explicit = _optionalChain([env, 'optionalAccess', _ => _.FARM_PREVIEW]);
+  if (isTrue(explicit)) return true;
+  if (isFalse(explicit)) return false;
+  if (builtAsPreview || !env) return builtAsPreview;
+  if (normalizeEnvironment(env.VERCEL_ENV) === "preview") return true;
+  if (isTrue(env.NETLIFY)) {
+    const context = normalizeEnvironment(env.CONTEXT);
+    if (context === "deploy-preview" || context === "branch-deploy") return true;
+  }
+  return isTrue(env.IS_PULL_REQUEST);
+}
+function normalizeEnvironment(value) {
+  const normalized = _optionalChain([value, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3(), 'access', _4 => _4.toLowerCase, 'call', _5 => _5()]);
+  return normalized || void 0;
+}
+function isTrue(value) {
+  return value !== void 0 && ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+function isFalse(value) {
+  return value !== void 0 && ["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+
+
+
+
+
+exports.isFarmProductionDeploymentEnvironment = isFarmProductionDeploymentEnvironment; exports.isFarmPreviewDeploymentEnvironment = isFarmPreviewDeploymentEnvironment; exports.resolveFarmPreviewDeployment = resolveFarmPreviewDeployment;

package/dist/chunk-SHD265HW.cjs

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/schema-capabilities.ts
+function assertNoSchemaListField(field, fieldPath, target) {
+  if (!field.list) {
+    return;
+  }
+  throw new Error(
+    `Schema field "${fieldPath}" declares list: true, but ${target} does not support list fields. Use type: "json" for an array value or model the values in a related table.`
+  );
+}
+
+// src/schema-reference.ts
+function isDatabaseEnforcedReference(reference) {
+  return reference.enforced === void 0 || reference.enforced === "db";
+}
+
+
+
+
+exports.assertNoSchemaListField = assertNoSchemaListField; exports.isDatabaseEnforcedReference = isDatabaseEnforcedReference;

package/dist/chunk-SHIWRBFI.cjs

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/secret-compare.ts
+function farmSecretsMatch(provided, expected) {
+  if (typeof provided !== "string" || typeof expected !== "string") return false;
+  if (expected.length === 0) return false;
+  let mismatch = provided.length ^ expected.length;
+  const length = Math.max(provided.length, expected.length);
+  for (let index = 0; index < length; index += 1) {
+    const providedCode = index < provided.length ? provided.charCodeAt(index) : 0;
+    const expectedCode = index < expected.length ? expected.charCodeAt(index) : 0;
+    mismatch |= providedCode ^ expectedCode;
+  }
+  return mismatch === 0;
+}
+
+
+
+exports.farmSecretsMatch = farmSecretsMatch;

package/dist/chunk-SM25ZC4S.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// package.json
+var version = "0.1.62";
+
+// src/version.ts
+var FARM_VERSION = version;
+
+
+
+exports.FARM_VERSION = FARM_VERSION;

package/dist/chunk-SM2SYWAR.cjs

@@ -0,0 +1,49 @@
+"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; }// src/docs/adapter-client.ts
+function getFarmDocsAdapterConfigModule(docs) {
+  if (!_optionalChain([docs, 'optionalAccess', _ => _.enabled]) || !_optionalChain([docs, 'access', _2 => _2.adapter, 'optionalAccess', _3 => _3.react]) || !docs.configPath) return void 0;
+  return docs.configPath.endsWith(".json") ? void 0 : docs.configPath.replace(/\\/g, "/");
+}
+function generateFarmDocsAdapterClientRuntime(reactModule, configModule) {
+  if (!reactModule) {
+    return `
+async function hydrateFarmDocsAdapterRuntime() {
+  return false;
+}
+`;
+  }
+  return `
+async function hydrateFarmDocsAdapterRuntime() {
+  const runtime = window.__FARM_DOCS_ADAPTER__;
+  if (!runtime) return false;
+  // The docs server flags pages whose config holds what its JSON copy cannot (icons,
+  // MDX components, callbacks); the adapter restores those from the module itself.
+  // Fetch it alongside the adapter rather than after it: they don't depend on each other.
+  const [FarmDocsAdapterReact, configModule] = await Promise.all([
+    import(${JSON.stringify(reactModule)}),
+    runtime.configModule ? ${configModule ? `import(${JSON.stringify(configModule)})` : "undefined"} : undefined,
+  ]);
+  if (typeof FarmDocsAdapterReact.hydrateFarmDocs !== "function") {
+    throw new Error("The configured Farm docs adapter does not export hydrateFarmDocs().");
+  }
+  FarmDocsAdapterReact.hydrateFarmDocs({
+    config: runtime.config || {},
+    data: runtime.data,
+    ...(configModule ? { configModule: configModule.default ?? configModule } : {}),
+  });
+  return true;
+}
+`;
+}
+
+// src/docs/config-secrets.ts
+function isSecretDocsConfigKey(key) {
+  const normalized = key.replace(/[-_]/g, "").toLowerCase();
+  if (!normalized || normalized.endsWith("env")) return false;
+  return /apikey|token|secret|password|authorization|credential/.test(normalized);
+}
+
+
+
+
+
+exports.getFarmDocsAdapterConfigModule = getFarmDocsAdapterConfigModule; exports.generateFarmDocsAdapterClientRuntime = generateFarmDocsAdapterClientRuntime; exports.isSecretDocsConfigKey = isSecretDocsConfigKey;