@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-MKB2EGIR.cjs

@@ -0,0 +1,148 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/route-runtime.ts
+function normalizeFarmRouteRuntimeConfig(value, source = "Route configuration") {
+  if (!value) return {};
+  const normalized = {};
+  if (value.runtime !== void 0) {
+    if (value.runtime !== "auto" && value.runtime !== "node" && value.runtime !== "edge") {
+      throw new TypeError(`${source} runtime must be "auto", "node", or "edge"`);
+    }
+    normalized.runtime = value.runtime;
+  }
+  if (value.regions !== void 0) {
+    if (value.regions === "auto") {
+      normalized.regions = "auto";
+    } else {
+      if (!Array.isArray(value.regions) || value.regions.length === 0) {
+        throw new TypeError(`${source} regions must be "auto" or a non-empty string array`);
+      }
+      const regions = Array.from(
+        new Set(
+          value.regions.map((region) => {
+            if (typeof region !== "string" || !region.trim() || /[\u0000-\u001f\u007f]/.test(region)) {
+              throw new TypeError(`${source} regions must contain non-empty region identifiers`);
+            }
+            return region.trim();
+          })
+        )
+      );
+      normalized.regions = regions;
+    }
+  }
+  if (value.maxDuration !== void 0) {
+    if (value.maxDuration === "auto") {
+      normalized.maxDuration = "auto";
+    } else if (typeof value.maxDuration !== "number" || !Number.isInteger(value.maxDuration) || value.maxDuration <= 0) {
+      throw new TypeError(`${source} maxDuration must be "auto" or a positive integer in seconds`);
+    } else {
+      normalized.maxDuration = value.maxDuration;
+    }
+  }
+  return normalized;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmRouteRuntimeConfig, "normalizeFarmRouteRuntimeConfig");
+function mergeFarmRouteRuntimeConfigs(...configs) {
+  const merged = {};
+  for (const config of configs) {
+    if (!config) continue;
+    if (config.runtime !== void 0) merged.runtime = config.runtime;
+    if (config.regions !== void 0) merged.regions = config.regions;
+    if (config.maxDuration !== void 0) merged.maxDuration = config.maxDuration;
+  }
+  return merged;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergeFarmRouteRuntimeConfigs, "mergeFarmRouteRuntimeConfigs");
+function resolveFarmRouteRuntimeConfig(config, source) {
+  const normalized = normalizeFarmRouteRuntimeConfig(config, source);
+  return {
+    runtime: _nullishCoalesce(normalized.runtime, () => ( "auto")),
+    ...normalized.regions && normalized.regions !== "auto" ? { regions: [...normalized.regions] } : {},
+    ...typeof normalized.maxDuration === "number" ? { maxDuration: normalized.maxDuration } : {}
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRouteRuntimeConfig, "resolveFarmRouteRuntimeConfig");
+function hasFarmRouteRuntimeControls(config) {
+  return Boolean(
+    config && (config.runtime !== void 0 || config.regions !== void 0 || config.maxDuration !== void 0)
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, hasFarmRouteRuntimeControls, "hasFarmRouteRuntimeControls");
+function getFarmRouteRuntimeConfig(value) {
+  if (!value || typeof value !== "object") return {};
+  const route = value;
+  return {
+    ...route.runtime !== void 0 ? { runtime: route.runtime } : {},
+    ...route.regions !== void 0 ? { regions: route.regions } : {},
+    ...route.maxDuration !== void 0 ? { maxDuration: route.maxDuration } : {}
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRouteRuntimeConfig, "getFarmRouteRuntimeConfig");
+function createFarmRouteRuntimeKey(config) {
+  return JSON.stringify({
+    runtime: config.runtime,
+    regions: config.regions || null,
+    maxDuration: config.maxDuration || null
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmRouteRuntimeKey, "createFarmRouteRuntimeKey");
+function resolveFarmRouteRuleRuntimeConfig(pathname, routeRules) {
+  if (!routeRules) return {};
+  const matches = Object.entries(routeRules).filter(
+    ([pattern, rule]) => hasFarmRouteRuntimeControls(rule) && farmRouteRuleMatches(pattern, pathname)
+  ).sort(([left], [right]) => compareFarmRouteRuleSpecificity(left, right));
+  return mergeFarmRouteRuntimeConfigs(...matches.map(([, rule]) => rule));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRouteRuleRuntimeConfig, "resolveFarmRouteRuleRuntimeConfig");
+function farmRouteRuleMatches(pattern, pathname) {
+  const normalizedPattern = normalizeRoutePattern(pattern);
+  const normalizedPathname = normalizeRoutePattern(pathname);
+  if (normalizedPattern === normalizedPathname) return true;
+  const expression = normalizedPattern.split("/").filter(Boolean).map((segment) => {
+    if (segment === "**") return ".*";
+    if (segment === "*") return "[^/]+";
+    if (/^\[\[\.\.\..+\]\]$/.test(segment)) return ".*";
+    if (/^\[\.\.\..+\]$/.test(segment)) return ".+";
+    if (/^\[.+\]$/.test(segment) || /^:.+$/.test(segment)) return "[^/]+";
+    return escapeRegExp(segment);
+  }).join("/");
+  return new RegExp(`^/${expression}/?$`).test(normalizedPathname);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, farmRouteRuleMatches, "farmRouteRuleMatches");
+function compareFarmRouteRuleSpecificity(left, right) {
+  const leftScore = getFarmRouteRuleSpecificity(left);
+  const rightScore = getFarmRouteRuleSpecificity(right);
+  return leftScore - rightScore || left.localeCompare(right);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compareFarmRouteRuleSpecificity, "compareFarmRouteRuleSpecificity");
+function getFarmRouteRuleSpecificity(pattern) {
+  return normalizeRoutePattern(pattern).split("/").filter(Boolean).reduce((score, segment) => {
+    if (segment === "**" || segment.startsWith("[[...")) return score + 1;
+    if (segment === "*" || segment.startsWith("[...")) return score + 10;
+    if (/^\[.+\]$/.test(segment) || /^:.+$/.test(segment)) return score + 50;
+    return score + 100;
+  }, 0);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRouteRuleSpecificity, "getFarmRouteRuleSpecificity");
+function normalizeRoutePattern(value) {
+  const withSlash = value.trim().startsWith("/") ? value.trim() : `/${value.trim()}`;
+  return withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRoutePattern, "normalizeRoutePattern");
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, escapeRegExp, "escapeRegExp");
+
+
+
+
+
+
+
+
+
+
+exports.normalizeFarmRouteRuntimeConfig = normalizeFarmRouteRuntimeConfig; exports.mergeFarmRouteRuntimeConfigs = mergeFarmRouteRuntimeConfigs; exports.resolveFarmRouteRuntimeConfig = resolveFarmRouteRuntimeConfig; exports.hasFarmRouteRuntimeControls = hasFarmRouteRuntimeControls; exports.getFarmRouteRuntimeConfig = getFarmRouteRuntimeConfig; exports.createFarmRouteRuntimeKey = createFarmRouteRuntimeKey; exports.resolveFarmRouteRuleRuntimeConfig = resolveFarmRouteRuleRuntimeConfig; exports.farmRouteRuleMatches = farmRouteRuleMatches;

package/dist/chunk-MQ3H6LT5.cjs

@@ -0,0 +1,202 @@
+"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/after.ts
+var _async_hooks = require('async_hooks');
+var AFTER_STORAGE = /* @__PURE__ */ Symbol.for("@farm.js/core/after-storage");
+function getAfterStorage() {
+  const runtime = globalThis;
+  const existing = runtime[AFTER_STORAGE];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new (0, _async_hooks.AsyncLocalStorage)();
+  runtime[AFTER_STORAGE] = storage;
+  return storage;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getAfterStorage, "getAfterStorage");
+var afterStorage = getAfterStorage();
+function defaultAfterErrorReporter(error) {
+  console.error("[Farm.js] after() callback failed:", error);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defaultAfterErrorReporter, "defaultAfterErrorReporter");
+function reportAfterError(state, error) {
+  try {
+    state.reportError(error);
+  } catch (e) {
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, reportAfterError, "reportAfterError");
+function createAfterRequestState(reportError = defaultAfterErrorReporter) {
+  let resolveResponseFinished;
+  let responseFinished = false;
+  const responseFinishedPromise = new Promise((resolve) => {
+    resolveResponseFinished = resolve;
+  });
+  const state = {
+    completion: Promise.resolve(),
+    finishResponse: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+      if (responseFinished) return;
+      responseFinished = true;
+      resolveResponseFinished();
+    }, "finishResponse"),
+    phase: "open",
+    reportError,
+    tasks: []
+  };
+  state.completion = responseFinishedPromise.then(
+    () => afterStorage.run(state, async () => {
+      state.phase = "running";
+      for (let index = 0; index < state.tasks.length; index++) {
+        const task = state.tasks[index];
+        task.start();
+        try {
+          await task.result;
+        } catch (error) {
+          reportAfterError(state, error);
+        }
+      }
+      state.phase = "closed";
+    })
+  );
+  return state;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createAfterRequestState, "createAfterRequestState");
+function registerPlatformLifetime(state, context) {
+  if (!_optionalChain([context, 'optionalAccess', _ => _.waitUntil])) return;
+  try {
+    context.waitUntil(state.completion);
+  } catch (error) {
+    reportAfterError(state, error);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, registerPlatformLifetime, "registerPlatformLifetime");
+function registerResponseFinishedHook(state, context) {
+  if (!_optionalChain([context, 'optionalAccess', _2 => _2.onResponseFinished])) return false;
+  try {
+    context.onResponseFinished(state.finishResponse);
+    return true;
+  } catch (error) {
+    reportAfterError(state, error);
+    return false;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, registerResponseFinishedHook, "registerResponseFinishedHook");
+function finishSoon(state) {
+  setTimeout(state.finishResponse, 0);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, finishSoon, "finishSoon");
+function wrapResponseBody(response, request, state) {
+  if (request.method === "HEAD" || response.status < 200 || response.status > 599 || !response.body || response.bodyUsed || response.body.locked) {
+    finishSoon(state);
+    return response;
+  }
+  const reader = response.body.getReader();
+  let released = false;
+  const releaseReader = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  }, "releaseReader");
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          releaseReader();
+          controller.close();
+          finishSoon(state);
+          return;
+        }
+        controller.enqueue(chunk.value);
+      } catch (error) {
+        releaseReader();
+        controller.error(error);
+        finishSoon(state);
+      }
+    },
+    cancel(reason) {
+      try {
+        return reader.cancel(reason);
+      } finally {
+        releaseReader();
+        finishSoon(state);
+      }
+    }
+  });
+  return new Response(body, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, wrapResponseBody, "wrapResponseBody");
+function after(callback) {
+  if (typeof callback !== "function") {
+    throw new TypeError("after() expects a callback function.");
+  }
+  const state = afterStorage.getStore();
+  if (!state) {
+    throw new Error("after() can only be used while Farm is handling a server request.");
+  }
+  if (state.phase === "closed") {
+    throw new Error("after() cannot schedule work after the request lifecycle has completed.");
+  }
+  let start;
+  const ready = new Promise((resolve) => {
+    start = resolve;
+  });
+  const result = ready.then(callback);
+  state.tasks.push({ result, start });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, after, "after");
+async function _runWithAfterRequest(request, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  registerPlatformLifetime(state, context);
+  const hasResponseHook = registerResponseFinishedHook(state, context);
+  try {
+    const response = await afterStorage.run(state, handler);
+    return hasResponseHook ? response : wrapResponseBody(response, request, state);
+  } catch (error) {
+    finishSoon(state);
+    throw error;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithAfterRequest, "_runWithAfterRequest");
+async function _runWithAfterNodeResponse(response, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  let finished = false;
+  const finish = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (finished) return;
+    finished = true;
+    response.off("finish", finish);
+    response.off("close", finish);
+    state.finishResponse();
+  }, "finish");
+  response.once("finish", finish);
+  response.once("close", finish);
+  if (response.writableEnded || response.destroyed) setTimeout(finish, 0);
+  registerPlatformLifetime(state, context);
+  return await afterStorage.run(state, handler);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithAfterNodeResponse, "_runWithAfterNodeResponse");
+function _withAfterNodeMiddleware(handler) {
+  return async (request, response, next) => {
+    await _runWithAfterNodeResponse(response, () => handler(request, response, next));
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _withAfterNodeMiddleware, "_withAfterNodeMiddleware");
+
+
+
+
+
+
+exports.after = after; exports._runWithAfterRequest = _runWithAfterRequest; exports._runWithAfterNodeResponse = _runWithAfterNodeResponse; exports._withAfterNodeMiddleware = _withAfterNodeMiddleware;

package/dist/chunk-MT763TDW.cjs

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/build/production-node-env.ts
+var productionNodeEnvStateKey = /* @__PURE__ */ Symbol.for("@farm.js/core/production-node-env-state");
+function getProductionNodeEnvState() {
+  return Reflect.get(globalThis, productionNodeEnvStateKey);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getProductionNodeEnvState, "getProductionNodeEnvState");
+async function withProductionNodeEnv(operation) {
+  let state = getProductionNodeEnvState();
+  if (state) {
+    state.depth += 1;
+  } else {
+    state = {
+      depth: 1,
+      original: process.env.NODE_ENV
+    };
+    Reflect.set(globalThis, productionNodeEnvStateKey, state);
+  }
+  process.env.NODE_ENV = "production";
+  try {
+    return await operation();
+  } finally {
+    state.depth -= 1;
+    if (state.depth > 0) {
+      process.env.NODE_ENV = "production";
+    } else {
+      Reflect.deleteProperty(globalThis, productionNodeEnvStateKey);
+      if (state.original === void 0) {
+        delete process.env.NODE_ENV;
+      } else {
+        process.env.NODE_ENV = state.original;
+      }
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, withProductionNodeEnv, "withProductionNodeEnv");
+
+
+
+exports.withProductionNodeEnv = withProductionNodeEnv;

package/dist/chunk-MWSK6C4J.cjs

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/island.ts
+var FARM_ISLAND_STRATEGIES = ["load", "interaction", "visible", "idle"];
+function isFarmIslandStrategy(value) {
+  return FARM_ISLAND_STRATEGIES.includes(value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmIslandStrategy, "isFarmIslandStrategy");
+var FARM_ISLAND_ACTIVATION_EVENTS = ["click", "submit", "pointerdown", "focusin"];
+var FARM_ISLAND_REPLAYABLE_SELECTOR = 'button,[role="button"],input[type="button"],input[type="submit"],input[type="reset"]';
+
+
+
+
+
+exports.isFarmIslandStrategy = isFarmIslandStrategy; exports.FARM_ISLAND_ACTIVATION_EVENTS = FARM_ISLAND_ACTIVATION_EVENTS; exports.FARM_ISLAND_REPLAYABLE_SELECTOR = FARM_ISLAND_REPLAYABLE_SELECTOR;

package/dist/chunk-MWWVKDW3.cjs

@@ -0,0 +1,169 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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/docs/search-client.ts
+var _fs = require('fs');
+var _module = require('module');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function isFarmDocsSearchEnabled(docs) {
+  if (!_optionalChain([docs, 'optionalAccess', _ => _.enabled])) return false;
+  const search = docs.config.search;
+  if (search === false) return false;
+  return !(search && typeof search === "object" && search.enabled === false);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmDocsSearchEnabled, "isFarmDocsSearchEnabled");
+function resolveFarmDocsSearchClientModule(root) {
+  try {
+    const requireFromApp = _module.createRequire.call(void 0, _path2.default.join(_path2.default.resolve(root), "package.json"));
+    const themeEntry = requireFromApp.resolve("@farming-labs/theme");
+    const commandSearchModule = _path2.default.join(_path2.default.dirname(themeEntry), "docs-command-search.mjs");
+    if (_fs.existsSync.call(void 0, commandSearchModule)) return commandSearchModule;
+  } catch (e) {
+  }
+  return void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmDocsSearchClientModule, "resolveFarmDocsSearchClientModule");
+function generateFarmDocsSearchBootstrapRuntime() {
+  return `(()=>{if(window.__farmDocsSearchBootstrap)return;window.__farmDocsSearchBootstrap=true;const queue=(trigger,event)=>{if(window.__FARM_DOCS_SEARCH_BRIDGE_ACTIVE__)return;event.preventDefault();event.stopPropagation();event.stopImmediatePropagation();window.__FARM_DOCS_SEARCH_PENDING__=trigger;window.__FARM_MOUNT_DOCS_SEARCH__?.()};document.addEventListener("click",(event)=>{const target=event.target instanceof Element?event.target.closest("[data-search-full]"):null;if(target)queue("button",event)},true);document.addEventListener("keydown",(event)=>{if((event.metaKey||event.ctrlKey)&&event.key.toLowerCase()==="k")queue("keyboard",event)},true)})();`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, generateFarmDocsSearchBootstrapRuntime, "generateFarmDocsSearchBootstrapRuntime");
+function generateFarmDocsSearchClientRuntime(enabled, moduleId) {
+  if (!enabled || !moduleId) {
+    return `
+function isFarmDocsSearchPage() {
+  return false;
+}
+
+async function mountFarmDocsSearch() {
+  return false;
+}
+`;
+  }
+  return `
+let farmDocsSearchRoot = null;
+let farmDocsSearchContainer = null;
+let farmDocsSearchModulePromise = null;
+let farmDocsSearchPendingTrigger = window.__FARM_DOCS_SEARCH_PENDING__ === 'keyboard'
+  ? 'keyboard'
+  : window.__FARM_DOCS_SEARCH_PENDING__
+    ? 'button'
+    : null;
+let farmDocsSearchReady = false;
+
+function isFarmDocsSearchPage() {
+  return document.querySelector('[data-farm-docs-search-root]') instanceof HTMLElement;
+}
+
+function replayFarmDocsSearchOpen() {
+  const pendingTrigger = farmDocsSearchPendingTrigger;
+  farmDocsSearchPendingTrigger = null;
+  window.__FARM_DOCS_SEARCH_PENDING__ = null;
+  if (!pendingTrigger) return;
+
+  queueMicrotask(() => {
+    if (pendingTrigger === 'keyboard') {
+      document.dispatchEvent(
+        new KeyboardEvent('keydown', {
+          key: 'k',
+          metaKey: true,
+          bubbles: true,
+          cancelable: true,
+        }),
+      );
+    } else {
+      const trigger = document.querySelector('[data-search-full]');
+      if (trigger instanceof HTMLElement) trigger.click();
+    }
+  });
+}
+
+function FarmDocsSearchBridge({ component, api }) {
+  React.useEffect(() => {
+    farmDocsSearchReady = true;
+    replayFarmDocsSearchOpen();
+    return () => {
+      farmDocsSearchReady = false;
+    };
+  }, []);
+
+  return React.createElement(component, { api });
+}
+
+function queueFarmDocsSearchOpen(trigger, event) {
+  if (farmDocsSearchReady) return;
+  event.preventDefault();
+  event.stopPropagation();
+  event.stopImmediatePropagation();
+  farmDocsSearchPendingTrigger = trigger;
+  window.__FARM_DOCS_SEARCH_PENDING__ = trigger;
+  void mountFarmDocsSearch();
+}
+
+document.addEventListener(
+  'click',
+  (event) => {
+    const target = event.target instanceof Element
+      ? event.target.closest('[data-search-full]')
+      : null;
+    if (target) queueFarmDocsSearchOpen('button', event);
+  },
+  true,
+);
+
+document.addEventListener(
+  'keydown',
+  (event) => {
+    if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === 'k') {
+      queueFarmDocsSearchOpen('keyboard', event);
+    }
+  },
+  true,
+);
+
+window.__FARM_DOCS_SEARCH_BRIDGE_ACTIVE__ = true;
+
+async function mountFarmDocsSearch() {
+  const container = document.querySelector('[data-farm-docs-search-root]');
+  if (!(container instanceof HTMLElement)) return false;
+  if (farmDocsSearchContainer === container && farmDocsSearchRoot) return true;
+
+  try {
+    farmDocsSearchModulePromise ||= import(${JSON.stringify(moduleId)});
+    const { DocsCommandSearch } = await farmDocsSearchModulePromise;
+    if (!container.isConnected) return false;
+
+    if (farmDocsSearchRoot) {
+      farmDocsSearchReady = false;
+      try {
+        farmDocsSearchRoot.unmount();
+      } catch {}
+    }
+
+    farmDocsSearchContainer = container;
+    farmDocsSearchRoot = createRoot(container);
+    farmDocsSearchRoot.render(
+      React.createElement(FarmDocsSearchBridge, {
+        component: DocsCommandSearch,
+        api: container.dataset.api || '/api/docs',
+      }),
+    );
+    return true;
+  } catch (error) {
+    farmDocsSearchModulePromise = null;
+    console.error('[Farm.js] Could not load docs search:', error);
+    return false;
+  }
+}
+
+window.__FARM_MOUNT_DOCS_SEARCH__ = mountFarmDocsSearch;
+`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, generateFarmDocsSearchClientRuntime, "generateFarmDocsSearchClientRuntime");
+
+
+
+
+
+
+exports.isFarmDocsSearchEnabled = isFarmDocsSearchEnabled; exports.resolveFarmDocsSearchClientModule = resolveFarmDocsSearchClientModule; exports.generateFarmDocsSearchBootstrapRuntime = generateFarmDocsSearchBootstrapRuntime; exports.generateFarmDocsSearchClientRuntime = generateFarmDocsSearchClientRuntime;

package/dist/{chunk-KTGFMHET.mjs → chunk-N6UROPT7.mjs}

@@ -7,7 +7,7 @@ import {
   parseMiddlewareCookieHeader,
   serializeMiddlewareCookie,
   serializeMiddlewareCookieDeletion
-} from "./chunk-NDD2YVGU.mjs";
+} from "./chunk-NRVGEI5I.mjs";
 import {
   emitFarmEvent
 } from "./chunk-FUZEBRP3.mjs";