@farm.js/core 0.1.51-beta.3 → 0.1.60

package/dist/chunk-3YMLUNL2.cjs

@@ -0,0 +1,251 @@
+"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; }// src/mobile/native-specs.ts
+var _fs = require('fs');
+var _module = require('module');
+var _path = require('path'); var path = _interopRequireWildcard(_path);
+var UnsupportedType = class extends Error {
+};
+var parsers = /* @__PURE__ */ new Map();
+function loadCodegen(root) {
+  const cached = parsers.get(root);
+  if (cached) return cached;
+  let codegenDir;
+  let load;
+  try {
+    let reactNative;
+    for (let dir = root; ; dir = path.dirname(dir)) {
+      const candidate = path.join(dir, "node_modules", "react-native", "package.json");
+      if (_fs.existsSync.call(void 0, candidate)) {
+        reactNative = _fs.realpathSync.call(void 0, candidate);
+        break;
+      }
+      if (path.dirname(dir) === dir) throw new Error(`react-native is not installed in ${root}.`);
+    }
+    load = _module.createRequire.call(void 0, reactNative);
+    codegenDir = path.dirname(load.resolve("@react-native/codegen/package.json"));
+  } catch (error) {
+    throw Object.assign(
+      new Error(
+        "Reading a native module spec needs React Native's Codegen (@react-native/codegen, installed with react-native). Add react-native to the app's dependencies and install them."
+      ),
+      { cause: error }
+    );
+  }
+  const typescript = load(path.join(codegenDir, "lib/parsers/typescript/parser.js"));
+  const flow = load(path.join(codegenDir, "lib/parsers/flow/parser.js"));
+  const loaded = { typescript: new typescript.TypeScriptParser(), flow: new flow.FlowParser() };
+  parsers.set(root, loaded);
+  return loaded;
+}
+function hasFarmNativeCodegen(root) {
+  try {
+    loadCodegen(root);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function describe(annotation) {
+  switch (annotation.type) {
+    case "FunctionTypeAnnotation":
+      return "a callback";
+    case "MixedTypeAnnotation":
+      return "a mixed value";
+    case "ReservedTypeAnnotation":
+      return String(_nullishCoalesce(annotation.name, () => ( "a reserved type")));
+    case "EventEmitterTypeAnnotation":
+      return "an event emitter";
+    default:
+      return annotation.type.replace(/TypeAnnotation$/, "");
+  }
+}
+function toType(annotation, module, options = {}) {
+  switch (annotation.type) {
+    case "NullableTypeAnnotation":
+      return {
+        ...toType(annotation.typeAnnotation, module, options),
+        nullable: true
+      };
+    case "StringTypeAnnotation":
+      return { type: "string" };
+    case "NumberTypeAnnotation":
+    case "DoubleTypeAnnotation":
+    case "FloatTypeAnnotation":
+      return { type: "number" };
+    case "Int32TypeAnnotation":
+      return { type: "number", integer: true };
+    case "BooleanTypeAnnotation":
+      return { type: "boolean" };
+    case "StringLiteralTypeAnnotation":
+    case "NumberLiteralTypeAnnotation":
+      return { type: "literal", values: [annotation.value] };
+    case "UnionTypeAnnotation":
+    case "StringLiteralUnionTypeAnnotation": {
+      const types = _nullishCoalesce(annotation.types, () => ( []));
+      const values = types.map((member) => member.value);
+      if (types.length > 0 && types.every(
+        (member) => member.type === "StringLiteralTypeAnnotation" || member.type === "NumberLiteralTypeAnnotation"
+      ) && (values.every((value) => typeof value === "string") || values.every((value) => typeof value === "number"))) {
+        return { type: "literal", values };
+      }
+      throw new UnsupportedType("a union that is not all string or all number literals");
+    }
+    case "EnumDeclaration": {
+      const members = _nullishCoalesce(_optionalChain([module, 'access', _ => _.enumMap, 'optionalAccess', _2 => _2[String(annotation.name)], 'optionalAccess', _3 => _3.members]), () => ( []));
+      const values = members.map((member) => _optionalChain([member, 'access', _4 => _4.value, 'optionalAccess', _5 => _5.value]));
+      if (values.length > 0 && (values.every((value) => typeof value === "string") || values.every((value) => typeof value === "number"))) {
+        return { type: "literal", values };
+      }
+      throw new UnsupportedType(`the enum ${String(annotation.name)}`);
+    }
+    case "ObjectTypeAnnotation": {
+      const properties = _nullishCoalesce(annotation.properties, () => ( []));
+      return {
+        type: "object",
+        properties: properties.map((property) => ({
+          name: property.name,
+          optional: property.optional === true,
+          type: toType(property.typeAnnotation, module, options)
+        }))
+      };
+    }
+    case "TypeAliasTypeAnnotation": {
+      const alias = _optionalChain([module, 'access', _6 => _6.aliasMap, 'optionalAccess', _7 => _7[String(annotation.name)]]);
+      if (!alias) throw new UnsupportedType(`the unknown type ${String(annotation.name)}`);
+      return toType(alias, module, options);
+    }
+    case "GenericObjectTypeAnnotation":
+      return { type: "map" };
+    case "ArrayTypeAnnotation": {
+      const element = annotation.elementType;
+      if (!element || element.type === "AnyTypeAnnotation") return { type: "array" };
+      return { type: "array", element: toType(element, module, options) };
+    }
+    case "VoidTypeAnnotation":
+      if (options.returns) return { type: "void" };
+      break;
+  }
+  if (options.returns) return { type: "unknown" };
+  throw new UnsupportedType(describe(annotation));
+}
+function readFarmNativeWebSpec(options) {
+  const codegen = loadCodegen(options.root);
+  const parser = /\.tsx?$/.test(options.file) ? codegen.typescript : codegen.flow;
+  let schema;
+  try {
+    schema = parser.parseFile(options.file);
+  } catch (error) {
+    const shown = path.relative(options.root, options.file).split(path.sep).join("/");
+    throw Object.assign(
+      new Error(`React Native's Codegen rejected ${shown}: ${error.message}`),
+      { cause: error }
+    );
+  }
+  const module = Object.values(schema.modules).find((entry) => entry.type === "NativeModule");
+  const result = { methods: [], unsupported: [] };
+  for (const method of _nullishCoalesce(_optionalChain([module, 'optionalAccess', _8 => _8.spec, 'optionalAccess', _9 => _9.methods]), () => ( []))) {
+    let fn = method.typeAnnotation;
+    if (fn.type === "NullableTypeAnnotation") fn = fn.typeAnnotation;
+    if (fn.type !== "FunctionTypeAnnotation") continue;
+    const returned = fn.returnTypeAnnotation;
+    if (_optionalChain([returned, 'optionalAccess', _10 => _10.type]) !== "PromiseTypeAnnotation") continue;
+    const params = _nullishCoalesce(fn.params, () => ( []));
+    try {
+      result.methods.push({
+        name: method.name,
+        params: params.map((param) => {
+          try {
+            return {
+              name: param.name,
+              optional: param.optional === true,
+              type: toType(param.typeAnnotation, module)
+            };
+          } catch (error) {
+            if (!(error instanceof UnsupportedType)) throw error;
+            throw new UnsupportedType(
+              `its parameter ${param.name} is ${error.message}, which a web screen cannot send`
+            );
+          }
+        }),
+        returns: toType(
+          _nullishCoalesce(returned.elementType, () => ( { type: "VoidTypeAnnotation" })),
+          module,
+          { returns: true }
+        )
+      });
+    } catch (error) {
+      if (!(error instanceof UnsupportedType)) throw error;
+      result.unsupported.push({ method: method.name, reason: error.message });
+    }
+  }
+  return result;
+}
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function renderFarmNativeType(type) {
+  let rendered;
+  switch (type.type) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "void":
+    case "unknown":
+      rendered = type.type;
+      break;
+    case "literal":
+      rendered = type.values.map((value) => JSON.stringify(value)).join(" | ");
+      break;
+    case "map":
+      rendered = "Record<string, unknown>";
+      break;
+    case "array": {
+      const element = type.element ? renderFarmNativeType(type.element) : "unknown";
+      rendered = `Array<${element}>`;
+      break;
+    }
+    case "object":
+      rendered = type.properties.length ? `{ ${type.properties.map(
+        (property) => `${IDENTIFIER.test(property.name) ? property.name : JSON.stringify(property.name)}${property.optional ? "?" : ""}: ${renderFarmNativeType(property.type)}`
+      ).join("; ")} }` : "{}";
+      break;
+  }
+  return type.nullable ? `${rendered} | null` : rendered;
+}
+function renderFarmNativeMethod(method) {
+  const lastRequired = method.params.reduce(
+    (last, param, index) => param.optional ? last : index,
+    -1
+  );
+  const params = method.params.map((param, index) => {
+    const type = renderFarmNativeType(param.type);
+    if (!param.optional) return `${param.name}: ${type}`;
+    return index > lastRequired ? `${param.name}?: ${type}` : `${param.name}: ${type} | undefined`;
+  }).join(", ");
+  return `${method.name}(${params}): Promise<${renderFarmNativeType(method.returns)}>;`;
+}
+function createFarmNativeModuleTypeDeclarations(specs, options) {
+  if (specs.length === 0 || !hasFarmNativeCodegen(options.root)) return void 0;
+  const modules = specs.map((spec) => {
+    const { methods } = readFarmNativeWebSpec({ root: options.root, file: spec.file });
+    const body = methods.filter((method) => method.name !== "available").map((method) => `      ${renderFarmNativeMethod(method)}`).join("\n");
+    return `    ${spec.name}: {${body ? `
+${body}
+    ` : ""}};`;
+  });
+  return `/**
+ * Auto-generated from the Codegen specs in src/native: native.<module> from @farm.js/core/native.
+ * Web screens reach a module's Promise methods only when mobile.modules.<name>.web is true, and
+ * only inside the Android shell; check native.<module>.available() first.
+ */
+declare module "@farm.js/core/native" {
+  interface FarmNativeModules {
+${modules.join("\n")}
+  }
+}`;
+}
+
+
+
+
+
+
+
+exports.hasFarmNativeCodegen = hasFarmNativeCodegen; exports.readFarmNativeWebSpec = readFarmNativeWebSpec; exports.renderFarmNativeType = renderFarmNativeType; exports.renderFarmNativeMethod = renderFarmNativeMethod; exports.createFarmNativeModuleTypeDeclarations = createFarmNativeModuleTypeDeclarations;

package/dist/chunk-4JTQPOKO.cjs

@@ -0,0 +1,137 @@
+"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 _chunkRAWWCDCTcjs = require('./chunk-RAWWCDCT.cjs');
+
+
+
+var _chunkA25FXJ7Dcjs = require('./chunk-A25FXJ7D.cjs');
+
+// src/mobile/shell-response.ts
+var FARM_SHELL_HEADER = "X-Farm-Shell";
+function isFarmMobileShellRequest(request) {
+  const value = request.headers.get(FARM_SHELL_HEADER);
+  return value !== null && /^[a-z][a-z0-9-]{0,31}$/.test(value);
+}
+function isHtml(response) {
+  return _optionalChain([response, 'access', _ => _.headers, 'access', _2 => _2.get, 'call', _3 => _3("content-type"), 'optionalAccess', _4 => _4.toLowerCase, 'call', _5 => _5(), 'access', _6 => _6.includes, 'call', _7 => _7("text/html")]) === true;
+}
+function appendVary(headers, name) {
+  const current = headers.get("Vary");
+  if (!current) {
+    headers.set("Vary", name);
+    return;
+  }
+  const names = current.split(",").map((value) => value.trim().toLowerCase());
+  if (names.includes("*") || names.includes(name.toLowerCase())) return;
+  headers.set("Vary", `${current}, ${name}`);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var MAX_HELD_TAG = 4096;
+function createFarmMobileShellRewriter(client) {
+  const entry = new RegExp(`(["'])${escapeRegExp(client.webEntry)}\\1`, "g");
+  const webOnly = new Set(client.webOnly);
+  const preload = /<link rel="modulepreload" href="\/([^"]+)"[^>]*>/g;
+  let held = "";
+  return (text, final = false) => {
+    let input = held + text;
+    held = "";
+    if (!final) {
+      const open = input.lastIndexOf("<");
+      if (open !== -1 && input.indexOf(">", open) === -1 && input.length - open <= MAX_HELD_TAG) {
+        held = input.slice(open);
+        input = input.slice(0, open);
+      }
+    }
+    return input.replace(entry, (_match, quote) => `${quote}${client.entry}${quote}`).replace(preload, (tag, file) => webOnly.has(file) ? "" : tag);
+  };
+}
+function _applyFarmMobileShellClient(request, response, client, onPrivate) {
+  if (!client || !isHtml(response)) return response;
+  if (!isFarmMobileShellRequest(request) || !response.body) {
+    return _chunkA25FXJ7Dcjs._withFarmResponseHeaders.call(void 0, response, (headers2) => appendVary(headers2, FARM_SHELL_HEADER));
+  }
+  _optionalChain([onPrivate, 'optionalCall', _8 => _8()]);
+  const headers = new Headers(_chunkRAWWCDCTcjs._withFarmGuardedResponseCache.call(void 0, response).headers);
+  appendVary(headers, FARM_SHELL_HEADER);
+  headers.delete("content-length");
+  headers.delete("etag");
+  const rewrite = createFarmMobileShellRewriter(client);
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const body = response.body.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        const output = rewrite(decoder.decode(chunk, { stream: true }));
+        if (output) controller.enqueue(encoder.encode(output));
+      },
+      flush(controller) {
+        const output = rewrite(decoder.decode(), true);
+        if (output) controller.enqueue(encoder.encode(output));
+      }
+    })
+  );
+  return _chunkA25FXJ7Dcjs._markFarmOwnedResponse.call(void 0, 
+    new Response(body, { status: response.status, statusText: response.statusText, headers })
+  );
+}
+
+// src/mobile/shell-render.ts
+var FARM_SHELL_RENDER_HEADER = "X-Farm-Shell-Render";
+var FARM_SHELL_ROUTE_HEADER = "X-Farm-Shell-Route";
+var FARM_SHELL_PARAM_SEGMENT = "__farm_shell__";
+function constantTimeEqual(left, right) {
+  if (left.length !== right.length) return false;
+  let difference = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+  }
+  return difference === 0;
+}
+function _isFarmMobileShellRenderRequest(request, token) {
+  const value = request.headers.get(FARM_SHELL_RENDER_HEADER);
+  return token.length > 0 && value !== null && constantTimeEqual(value, token);
+}
+function stripRouteGroups(pattern) {
+  const segments = pattern.split("/").filter((segment) => segment && !(segment.startsWith("(") && segment.endsWith(")")));
+  return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+function isDynamicPattern(pattern) {
+  return pattern.split("/").some((segment) => segment.startsWith("["));
+}
+function _checkFarmMobileShellRoute(check) {
+  const route = stripRouteGroups(check.route);
+  if (check.requested === null || stripRouteGroups(check.requested) !== route) {
+    return `the request matched ${route}, not ${_nullishCoalesce(check.requested, () => ( "a requested route"))}`;
+  }
+  if (check.loading === null) return "it has no loading file";
+  if (isDynamicPattern(check.loading)) {
+    return `its loading file is in a dynamic folder (${stripRouteGroups(check.loading)})`;
+  }
+  const layout = check.layouts.find(isDynamicPattern);
+  if (layout !== void 0) {
+    return `a layout is in a dynamic folder (${stripRouteGroups(layout)})`;
+  }
+  return null;
+}
+function createFarmMobileShellRenderPath(route) {
+  const segments = [];
+  for (const segment of route.split("/")) {
+    if (!segment || segment.startsWith("(") && segment.endsWith(")")) continue;
+    if (segment.startsWith("[[...") && segment.endsWith("]]")) continue;
+    segments.push(segment.startsWith("[") ? FARM_SHELL_PARAM_SEGMENT : segment);
+  }
+  return `/${segments.join("/")}`;
+}
+
+
+
+
+
+
+
+
+
+
+exports.FARM_SHELL_HEADER = FARM_SHELL_HEADER; exports._applyFarmMobileShellClient = _applyFarmMobileShellClient; exports.FARM_SHELL_RENDER_HEADER = FARM_SHELL_RENDER_HEADER; exports.FARM_SHELL_ROUTE_HEADER = FARM_SHELL_ROUTE_HEADER; exports.FARM_SHELL_PARAM_SEGMENT = FARM_SHELL_PARAM_SEGMENT; exports._isFarmMobileShellRenderRequest = _isFarmMobileShellRenderRequest; exports._checkFarmMobileShellRoute = _checkFarmMobileShellRoute; exports.createFarmMobileShellRenderPath = createFarmMobileShellRenderPath;

package/dist/{chunk-7MD37P5V.cjs → chunk-4P23B7DU.cjs}

@@ -1,9 +1,9 @@
 "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 _chunk4SEHMBL4cjs = require('./chunk-4SEHMBL4.cjs');
+var _chunkDPJ66FSIcjs = require('./chunk-DPJ66FSI.cjs');
 
 
-var _chunkD7UQC4O6cjs = require('./chunk-D7UQC4O6.cjs');
+var _chunkLT4VAF5Zcjs = require('./chunk-LT4VAF5Z.cjs');
 
 
 var _chunkEVIWKPJVcjs = require('./chunk-EVIWKPJV.cjs');
@@ -75,7 +75,7 @@ function resolveFarmInfraAnalytics(env = processEnv()) {
   };
 }
 function classifyFarmInfraAgent(userAgent) {
-  return _chunkD7UQC4O6cjs.classifyFarmAgent.call(void 0, userAgent);
+  return _chunkLT4VAF5Zcjs.classifyFarmAgent.call(void 0, userAgent);
 }
 function routeTemplate(pattern) {
   return typeof pattern === "string" && pattern.length <= 256 && /^\/(?!\/)[a-zA-Z0-9_./:[\]()*-]*$/.test(pattern) ? pattern : "/[unmatched]";
@@ -273,7 +273,7 @@ function requestEvent(metadata, method, status, durationMs) {
     id: uuid(),
     requestId: metadata.id,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    route: routeTemplate(_chunk4SEHMBL4cjs.getFarmRouteLabel.call(void 0, metadata.route)),
+    route: routeTemplate(_chunkDPJ66FSIcjs.getFarmRouteLabel.call(void 0, metadata.route)),
     agent: metadata.agent,
     kind: "request",
     method,
@@ -286,7 +286,7 @@ function toolEvent(metadata, event) {
     id: uuid(),
     requestId: metadata.id,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    route: routeTemplate(_chunk4SEHMBL4cjs.getFarmRouteLabel.call(void 0, metadata.route)),
+    route: routeTemplate(_chunkDPJ66FSIcjs.getFarmRouteLabel.call(void 0, metadata.route)),
     agent: metadata.agent,
     kind: "mcp.tool",
     tool: event.tool,

package/dist/{chunk-3BLEXUGE.mjs → chunk-55U5QIXQ.mjs}

@@ -1,6 +1,6 @@
 import {
   createFarmMarkdownRouteModule
-} from "./chunk-3Z63X45F.mjs";
+} from "./chunk-E72UD6ME.mjs";
 
 // src/app-markdown.ts
 import { readFile } from "fs/promises";

package/dist/{chunk-TWHXBMLJ.cjs → chunk-5JNUYGNF.cjs}

@@ -18,7 +18,7 @@ var _chunkERMUL73Lcjs = require('./chunk-ERMUL73L.cjs');
 var _chunk6JHZPB52cjs = require('./chunk-6JHZPB52.cjs');
 
 
-var _chunkD7UQC4O6cjs = require('./chunk-D7UQC4O6.cjs');
+var _chunkLT4VAF5Zcjs = require('./chunk-LT4VAF5Z.cjs');
 
 
 var _chunkLIFUPCXWcjs = require('./chunk-LIFUPCXW.cjs');
@@ -1179,11 +1179,11 @@ function shouldReturnMarkdown(request) {
   if (url.pathname.endsWith(".md")) return true;
   const accept = request.headers.get("accept");
   const markdown = Math.max(
-    _chunkD7UQC4O6cjs.farmAcceptQuality.call(void 0, accept, "text/markdown"),
-    _chunkD7UQC4O6cjs.farmAcceptQuality.call(void 0, accept, "text/plain")
+    _chunkLT4VAF5Zcjs.farmAcceptQuality.call(void 0, accept, "text/markdown"),
+    _chunkLT4VAF5Zcjs.farmAcceptQuality.call(void 0, accept, "text/plain")
   );
   if (markdown <= 0) return false;
-  return markdown >= _chunkD7UQC4O6cjs.farmAcceptQuality.call(void 0, accept, "text/html", { wildcards: true });
+  return markdown >= _chunkLT4VAF5Zcjs.farmAcceptQuality.call(void 0, accept, "text/html", { wildcards: true });
 }
 function escapeAttribute(value) {
   return escapeHtml(value).replace(/'/g, "&#39;");

package/dist/{chunk-53SACYBY.cjs → chunk-6BJJYOFL.cjs}

@@ -2,7 +2,7 @@
 
 
 
-var _chunk46KXZBOGcjs = require('./chunk-46KXZBOG.cjs');
+var _chunkQAS7KE7Jcjs = require('./chunk-QAS7KE7J.cjs');
 
 
 var _chunkD22BUQKWcjs = require('./chunk-D22BUQKW.cjs');
@@ -36,10 +36,10 @@ async function handleFarmDefaultMCPRequest(request, context) {
     return transportError(403, "Cross-origin requests are not allowed.");
   }
   const protocolHeader = request.headers.get("mcp-protocol-version");
-  if (protocolHeader && !_chunk46KXZBOGcjs.FARM_DEFAULT_MCP_PROTOCOL_VERSIONS.includes(protocolHeader.trim())) {
+  if (protocolHeader && !_chunkQAS7KE7Jcjs.FARM_DEFAULT_MCP_PROTOCOL_VERSIONS.includes(protocolHeader.trim())) {
     return transportError(
       400,
-      `Unsupported MCP-Protocol-Version: ${protocolHeader.slice(0, 32)}. Supported: ${_chunk46KXZBOGcjs.FARM_DEFAULT_MCP_PROTOCOL_VERSIONS.join(", ")}.`
+      `Unsupported MCP-Protocol-Version: ${protocolHeader.slice(0, 32)}. Supported: ${_chunkQAS7KE7Jcjs.FARM_DEFAULT_MCP_PROTOCOL_VERSIONS.join(", ")}.`
     );
   }
   const contentType = _nullishCoalesce(request.headers.get("content-type"), () => ( ""));
@@ -95,7 +95,7 @@ async function dispatch(method, params, request, context) {
   switch (method) {
     case "initialize": {
       const requested = isRecord(params) ? params.protocolVersion : void 0;
-      const protocolVersion = typeof requested === "string" && _chunk46KXZBOGcjs.FARM_DEFAULT_MCP_PROTOCOL_VERSIONS.includes(requested) ? requested : _chunk46KXZBOGcjs.FARM_DEFAULT_MCP_PROTOCOL_VERSIONS[0];
+      const protocolVersion = typeof requested === "string" && _chunkQAS7KE7Jcjs.FARM_DEFAULT_MCP_PROTOCOL_VERSIONS.includes(requested) ? requested : _chunkQAS7KE7Jcjs.FARM_DEFAULT_MCP_PROTOCOL_VERSIONS[0];
       return {
         protocolVersion,
         capabilities: { tools: { listChanged: false } },
@@ -103,7 +103,7 @@ async function dispatch(method, params, request, context) {
           name: context.server.name,
           version: context.server.version,
           ...context.server.title ? { title: context.server.title } : {},
-          description: _chunk46KXZBOGcjs.FARM_DEFAULT_MCP_DESCRIPTION
+          description: _chunkQAS7KE7Jcjs.FARM_DEFAULT_MCP_DESCRIPTION
         },
         instructions: INSTRUCTIONS
       };
@@ -111,7 +111,7 @@ async function dispatch(method, params, request, context) {
     case "ping":
       return {};
     case "tools/list":
-      return { tools: _chunk46KXZBOGcjs.FARM_DEFAULT_MCP_TOOLS };
+      return { tools: _chunkQAS7KE7Jcjs.FARM_DEFAULT_MCP_TOOLS };
     case "tools/call":
       return callTool(params, request, context);
     default:
@@ -122,7 +122,7 @@ async function callTool(params, request, context) {
   if (!isRecord(params) || typeof params.name !== "string") {
     throw new FarmMCPRequestError(INVALID_PARAMS, "tools/call needs a tool name.");
   }
-  const tool = _chunk46KXZBOGcjs.FARM_DEFAULT_MCP_TOOLS.find(({ name }) => name === params.name);
+  const tool = _chunkQAS7KE7Jcjs.FARM_DEFAULT_MCP_TOOLS.find(({ name }) => name === params.name);
   if (!tool) {
     throw new FarmMCPRequestError(INVALID_PARAMS, `Unknown tool: ${params.name.slice(0, 64)}`);
   }