@farm.js/core 0.1.17 → 0.1.18

package/dist/renderer-client.cjs

@@ -1,4253 +1,85 @@
-"use strict";
-"use client";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/renderer-client.ts
-var renderer_client_exports = {};
-__export(renderer_client_exports, {
-  createRendererAction: () => createRendererAction,
-  createRendererI18n: () => createRendererI18n,
-  createRendererQuery: () => createRendererQuery,
-  createRendererRouter: () => createRendererRouter,
-  createRendererTheme: () => createRendererTheme
-});
-module.exports = __toCommonJS(renderer_client_exports);
-
-// src/routing/specificity.ts
-var _AmbiguousRouteError = class _AmbiguousRouteError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AmbiguousRouteError";
-  }
-};
-__name(_AmbiguousRouteError, "AmbiguousRouteError");
-var AmbiguousRouteError = _AmbiguousRouteError;
-var _NonTerminalCatchAllRouteError = class _NonTerminalCatchAllRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "NonTerminalCatchAllRouteError";
-  }
-};
-__name(_NonTerminalCatchAllRouteError, "NonTerminalCatchAllRouteError");
-var NonTerminalCatchAllRouteError = _NonTerminalCatchAllRouteError;
-var _DuplicateRouteParameterError = class _DuplicateRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "DuplicateRouteParameterError";
-  }
-};
-__name(_DuplicateRouteParameterError, "DuplicateRouteParameterError");
-var DuplicateRouteParameterError = _DuplicateRouteParameterError;
-var _ReservedRouteParameterError = class _ReservedRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "ReservedRouteParameterError";
-  }
-};
-__name(_ReservedRouteParameterError, "ReservedRouteParameterError");
-var ReservedRouteParameterError = _ReservedRouteParameterError;
-var _BrowserUnstableRouteError = class _BrowserUnstableRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserUnstableRouteError";
-  }
-};
-__name(_BrowserUnstableRouteError, "BrowserUnstableRouteError");
-var BrowserUnstableRouteError = _BrowserUnstableRouteError;
-var SEGMENT_RANK = {
-  static: 4,
-  dynamic: 3,
-  "catch-all": 1,
-  "optional-catch-all": 0
-};
-var ROUTE_END_RANK = 2;
-function compareRouteSpecificity(left, right) {
-  const length = Math.max(left.length, right.length);
-  for (let index = 0; index < length; index++) {
-    const leftRank = index < left.length ? SEGMENT_RANK[left[index]] : ROUTE_END_RANK;
-    const rightRank = index < right.length ? SEGMENT_RANK[right[index]] : ROUTE_END_RANK;
-    if (leftRank !== rightRank) return rightRank - leftRank;
-  }
-  return 0;
-}
-__name(compareRouteSpecificity, "compareRouteSpecificity");
-var ROUTER_PARAMETER_NAME = "[A-Za-z0-9_$-]+";
-var PAGE_PARAMETER_PATTERN = /^(?:\[\[\.\.\.(.+)\]\]|\[\.\.\.(.+)\]|\[(.+)\])$/;
-var ROUTER_PARAMETER_PATTERN = /^(?:\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]|\[\.\.\.([A-Za-z0-9_$-]+)\]|\[([A-Za-z0-9_$-]+)\]|:([A-Za-z0-9_$-]+)|\*([A-Za-z0-9_$-]+)\??)$/;
-var RESERVED_PARAMETER_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function assertBrowserStableRoutePath(pattern) {
-  if (pattern.includes("\\") || hasControlCharacter(pattern)) {
-    throw new BrowserUnstableRouteError(
-      `Route path "${pattern}" cannot contain backslashes or control characters.`
-    );
-  }
-  for (const segment of pattern.split("/").filter(Boolean)) {
-    if (segment.startsWith("(") && segment.endsWith(")") || segment.startsWith("[") && segment.endsWith("]")) {
-      continue;
-    }
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
-      throw new BrowserUnstableRouteError(
-        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
-      );
-    }
-  }
-}
-__name(assertBrowserStableRoutePath, "assertBrowserStableRoutePath");
-function hasControlCharacter(value) {
-  return Array.from(value).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  });
-}
-__name(hasControlCharacter, "hasControlCharacter");
-function assertUniqueRouteParameters(pattern, syntax = "page") {
-  const parameterPattern = syntax === "router" ? ROUTER_PARAMETER_PATTERN : PAGE_PARAMETER_PATTERN;
-  const names = /* @__PURE__ */ new Set();
-  for (const segment of splitRoutePattern(pattern, syntax)) {
-    const match = parameterPattern.exec(segment);
-    const name = match?.slice(1).find(Boolean);
-    if (!name) continue;
-    if (RESERVED_PARAMETER_NAMES.has(name)) {
-      throw new ReservedRouteParameterError(
-        `Route parameter "${name}" in route "${pattern}" is reserved. Use a different parameter name.`
-      );
-    }
-    if (names.has(name)) {
-      throw new DuplicateRouteParameterError(
-        `Duplicate route parameter "${name}" in route "${pattern}". Each dynamic segment must use a unique name.`
-      );
-    }
-    names.add(name);
-  }
-}
-__name(assertUniqueRouteParameters, "assertUniqueRouteParameters");
-function splitRoutePattern(pattern, syntax) {
-  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
-    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
-  );
-}
-__name(splitRoutePattern, "splitRoutePattern");
-function assertTerminalCatchAll(pattern, syntax = "page") {
-  const segments = splitRoutePattern(pattern, syntax);
-  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
-  const catchAllPattern = new RegExp(
-    syntax === "router" ? `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\]|\\*${parameterName}\\??)$` : `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\])$`
-  );
-  const catchAllIndex = segments.findIndex((segment) => catchAllPattern.test(segment));
-  if (catchAllIndex >= 0 && catchAllIndex !== segments.length - 1) {
-    throw new NonTerminalCatchAllRouteError(
-      `Catch-all segment "${segments[catchAllIndex]}" must be the final segment in route "${pattern}".`
-    );
-  }
-}
-__name(assertTerminalCatchAll, "assertTerminalCatchAll");
-function getRoutePatternShape(pattern, syntax = "page") {
-  assertTerminalCatchAll(pattern, syntax);
-  const segments = splitRoutePattern(pattern, syntax).map((segment) => {
-    const specificity = getPatternSegmentSpecificity(segment, syntax);
-    if (specificity !== "static") return specificity;
-    try {
-      return `static:${decodeURIComponent(segment)}`;
-    } catch {
-      return `static:${segment}`;
-    }
-  });
-  return segments.length === 0 ? "/" : JSON.stringify(segments);
-}
-__name(getRoutePatternShape, "getRoutePatternShape");
-function getPatternSegmentSpecificity(segment, syntax) {
-  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
-  const supportsColonAndStar = syntax === "router";
-  if (new RegExp(`^\\[\\[\\.\\.\\.${parameterName}\\]\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}\\?$`).test(segment)) {
-    return "optional-catch-all";
-  }
-  if (new RegExp(`^\\[\\.\\.\\.${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}$`).test(segment)) {
-    return "catch-all";
-  }
-  if (new RegExp(`^\\[${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^:${parameterName}$`).test(segment)) {
-    return "dynamic";
-  }
-  return "static";
-}
-__name(getPatternSegmentSpecificity, "getPatternSegmentSpecificity");
-
-// src/routing/matcher.ts
-function parseRoutePattern(pattern) {
-  assertBrowserStableRoutePath(pattern);
-  assertTerminalCatchAll(pattern, "router");
-  assertUniqueRouteParameters(pattern, "router");
-  return splitRoutePattern2(pattern).filter((part) => !isRouteGroup(part)).map((part) => {
-    const optionalCatchAll = part.match(/^\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]$/);
-    if (optionalCatchAll) {
-      return {
-        type: "dynamic",
-        name: optionalCatchAll[1],
-        catchAll: true,
-        optional: true
-      };
-    }
-    const catchAll = part.match(/^\[\.\.\.([A-Za-z0-9_$-]+)\]$/);
-    if (catchAll) {
-      return {
-        type: "dynamic",
-        name: catchAll[1],
-        catchAll: true,
-        optional: false
-      };
-    }
-    const dynamic = part.match(/^\[([A-Za-z0-9_$-]+)\]$/) || part.match(/^:([A-Za-z0-9_$-]+)$/);
-    if (dynamic) {
-      return {
-        type: "dynamic",
-        name: dynamic[1],
-        catchAll: false,
-        optional: false
-      };
-    }
-    const star = part.match(/^\*([A-Za-z0-9_$-]+)(\?)?$/);
-    if (star) {
-      return {
-        type: "dynamic",
-        name: star[1],
-        catchAll: true,
-        optional: !!star[2]
-      };
-    }
-    return {
-      type: "static",
-      value: decodePathSegment(part)
-    };
-  });
-}
-__name(parseRoutePattern, "parseRoutePattern");
-function matchSegmentParts(segments, parts, allowTrailingSegments = false) {
-  const params = {};
-  if (segments.length === 0) {
-    return parts.length === 0 ? params : null;
-  }
-  let pathIndex = 0;
-  for (const segment of segments) {
-    if (segment.type === "static") {
-      if (decodePathSegment(parts[pathIndex] || "") !== segment.value) return null;
-      pathIndex++;
-      continue;
-    }
-    if (segment.catchAll) {
-      const remaining = parts.slice(pathIndex).map(decodePathSegment);
-      if (remaining.length === 0 && !segment.optional) return null;
-      params[segment.name] = remaining.join("/");
-      pathIndex = parts.length;
-      continue;
-    }
-    const value = parts[pathIndex];
-    if (!value) return null;
-    params[segment.name] = decodePathSegment(value);
-    pathIndex++;
-  }
-  return allowTrailingSegments || pathIndex === parts.length ? params : null;
-}
-__name(matchSegmentParts, "matchSegmentParts");
-function normalizePathname(value) {
-  const raw = value || "/";
-  let pathname = raw;
-  try {
-    pathname = new URL(raw, "http://farm.local").pathname;
-  } catch {
-    pathname = raw.split(/[?#]/, 1)[0] || "/";
-  }
-  pathname = pathname.replace(/\\/g, "/").replace(/\/+/g, "/");
-  if (!pathname.startsWith("/")) pathname = `/${pathname}`;
-  if (pathname.length > 1) pathname = pathname.replace(/\/+$/, "");
-  return pathname || "/";
-}
-__name(normalizePathname, "normalizePathname");
-function splitNormalizedPathname(pathname) {
-  return pathname.split("/").filter(Boolean);
-}
-__name(splitNormalizedPathname, "splitNormalizedPathname");
-function normalizeRoutePattern(value) {
-  let pathname = (value || "/").replace(/\\/g, "/").replace(/\/+/g, "/");
-  if (!pathname.startsWith("/")) pathname = `/${pathname}`;
-  if (pathname.length > 1) pathname = pathname.replace(/\/+$/, "");
-  return pathname || "/";
-}
-__name(normalizeRoutePattern, "normalizeRoutePattern");
-function splitRoutePattern2(pattern) {
-  return normalizeRoutePattern(pattern).split("/").filter(Boolean);
-}
-__name(splitRoutePattern2, "splitRoutePattern");
-function isRouteGroup(part) {
-  return part.startsWith("(") && part.endsWith(")");
-}
-__name(isRouteGroup, "isRouteGroup");
-function decodePathSegment(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-__name(decodePathSegment, "decodePathSegment");
-
-// src/router.ts
-function createFarmRouter(routes) {
-  const normalizedRoutes = routes.map(normalizeRouteInput);
-  const patternsByShape = /* @__PURE__ */ new Map();
-  for (const entry of normalizedRoutes) {
-    const shape = getRoutePatternShape(entry.route.path, "router");
-    const existingPattern = patternsByShape.get(shape);
-    if (existingPattern) {
-      throw new AmbiguousRouteError(
-        `Ambiguous route patterns "${existingPattern}" and "${entry.route.path}" match the same URLs. Keep only one route for this URL shape.`
-      );
-    }
-    patternsByShape.set(shape, entry.route.path);
-  }
-  normalizedRoutes.sort(compareRoutes);
-  const exactRoutes = /* @__PURE__ */ new Map();
-  for (const entry of normalizedRoutes) {
-    if (entry.segments.every((segment) => segment.type === "static")) {
-      const pathname = entry.segments.length ? `/${entry.segments.map((segment) => encodePathSegment(segment.value)).join("/")}` : "/";
-      exactRoutes.set(pathname, entry);
-    }
-  }
-  return {
-    routes: normalizedRoutes.map((entry) => entry.route),
-    match(pathname) {
-      const normalizedPathname = normalizePathname(pathname);
-      const exactRoute = exactRoutes.get(normalizedPathname);
-      if (exactRoute) {
-        return {
-          route: exactRoute.route,
-          pathname: normalizedPathname,
-          params: {}
-        };
-      }
-      const parts = splitNormalizedPathname(normalizedPathname);
-      for (const entry of normalizedRoutes) {
-        const params = matchSegmentParts(entry.segments, parts);
-        if (params) {
-          return {
-            route: entry.route,
-            pathname: normalizedPathname,
-            params
-          };
-        }
-      }
-      return null;
-    },
-    build: buildFarmRoutePath,
-    isActive: isFarmRouteActive
-  };
-}
-__name(createFarmRouter, "createFarmRouter");
-function buildFarmRoutePath(pattern, params = {}, options = {}) {
-  const parts = [];
-  for (const segment of parseRoutePattern(pattern)) {
-    if (segment.type === "static") {
-      parts.push(encodePathSegment(segment.value));
-      continue;
-    }
-    const value = params[segment.name];
-    const values = Array.isArray(value) ? value : value == null ? [] : [value];
-    if (values.length === 0) {
-      if (segment.optional) continue;
-      throw new Error(`Missing route param "${segment.name}" for ${pattern}.`);
-    }
-    if (!segment.catchAll && values.length > 1) {
-      throw new Error(`Route param "${segment.name}" for ${pattern} expects a single value.`);
-    }
-    const encodedValues = values.map((item) => {
-      const value2 = String(item);
-      if (!value2) {
-        throw new Error(
-          `Route param "${segment.name}" for ${pattern} cannot contain an empty path segment.`
-        );
-      }
-      return encodePathSegment(value2);
-    });
-    parts.push(...encodedValues);
-  }
-  let pathname = parts.length ? `/${parts.join("/")}` : "/";
-  if (options.trailingSlash && pathname !== "/") {
-    pathname = `${pathname}/`;
-  }
-  return appendQueryAndHash(pathname, options);
-}
-__name(buildFarmRoutePath, "buildFarmRoutePath");
-function isFarmRouteActive(pattern, pathname, options = {}) {
-  const normalizedPathname = normalizePathname(pathname);
-  const segments = parseRoutePattern(pattern);
-  const parts = splitNormalizedPathname(normalizedPathname);
-  if (matchSegmentParts(segments, parts)) return true;
-  if (options.exact !== false) return false;
-  if (segments.length === 0) return normalizedPathname === "/";
-  return matchSegmentParts(segments, parts, true) !== null;
-}
-__name(isFarmRouteActive, "isFarmRouteActive");
-function normalizeRouteInput(input, index) {
-  const route = typeof input === "string" ? { path: input } : input;
-  const segments = parseRoutePattern(route.path);
-  const path = normalizeRoutePattern(route.path);
-  return {
-    route: {
-      ...route,
-      path
-    },
-    segments,
-    specificity: segments.map(getRouterSegmentSpecificity),
-    index
-  };
-}
-__name(normalizeRouteInput, "normalizeRouteInput");
-function compareRoutes(left, right) {
-  const specificity = compareRouteSpecificity(left.specificity, right.specificity);
-  if (specificity !== 0) return specificity;
-  return left.index - right.index;
-}
-__name(compareRoutes, "compareRoutes");
-function getRouterSegmentSpecificity(segment) {
-  if (segment.type === "static") return "static";
-  if (!segment.catchAll) return "dynamic";
-  return segment.optional ? "optional-catch-all" : "catch-all";
-}
-__name(getRouterSegmentSpecificity, "getRouterSegmentSpecificity");
-function encodePathSegment(value) {
-  return encodeURIComponent(value);
-}
-__name(encodePathSegment, "encodePathSegment");
-function appendQueryAndHash(pathname, options) {
-  const search = createSearchParams(options.query);
-  const hash = options.hash ? `#${options.hash.replace(/^#/, "")}` : "";
-  const query = search.toString();
-  return `${pathname}${query ? `?${query}` : ""}${hash}`;
-}
-__name(appendQueryAndHash, "appendQueryAndHash");
-function createSearchParams(query) {
-  if (query instanceof URLSearchParams) return query;
-  const search = new URLSearchParams();
-  if (!query) return search;
-  for (const [key, value] of Object.entries(query)) {
-    const values = Array.isArray(value) ? value : [value];
-    for (const item of values) {
-      if (item == null) continue;
-      search.append(key, String(item));
-    }
-  }
-  return search;
-}
-__name(createSearchParams, "createSearchParams");
-
-// src/deferred.ts
-var FARM_DEFERRED_CONTENT_TYPE = "application/x-farm-deferred+json";
-var FARM_DEFERRED_ERROR_CODE = "FARM_DEFERRED_DATA_ERROR";
-var FARM_DEFERRED_MARKER = "$farmDeferred";
-var _DeferredDataError = class _DeferredDataError extends Error {
-  constructor(message = "Deferred route data failed to load") {
-    super(message);
-    this.name = "DeferredDataError";
-    this.code = FARM_DEFERRED_ERROR_CODE;
-  }
-};
-__name(_DeferredDataError, "DeferredDataError");
-var DeferredDataError = _DeferredDataError;
-async function readDeferredDataResponse(response, options = {}) {
-  const contentType = response.headers.get("Content-Type") || "";
-  if (!contentType.toLowerCase().startsWith(FARM_DEFERRED_CONTENT_TYPE)) {
-    const data2 = await response.json();
-    notifyDeferredComplete(options);
-    return data2;
-  }
-  if (!response.body) {
-    throw new DeferredDataError("Deferred route data response has no body");
-  }
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  const controllers = /* @__PURE__ */ new Map();
-  let buffer = "";
-  let complete = false;
-  const readLine = /* @__PURE__ */ __name(async () => {
-    while (true) {
-      const newline = buffer.indexOf("\n");
-      if (newline >= 0) {
-        const line = buffer.slice(0, newline);
-        buffer = buffer.slice(newline + 1);
-        return line;
-      }
-      if (complete) {
-        if (!buffer) return void 0;
-        const line = buffer;
-        buffer = "";
-        return line;
-      }
-      const chunk = await reader.read();
-      complete = chunk.done;
-      if (chunk.value) buffer += decoder.decode(chunk.value, { stream: !chunk.done });
-      if (chunk.done) buffer += decoder.decode();
-    }
-  }, "readLine");
-  const firstLine = await readLine();
-  if (!firstLine) {
-    reader.releaseLock();
-    throw new DeferredDataError("Deferred route data response is empty");
-  }
-  const initial = parseDeferredMessage(firstLine);
-  if (initial.type !== "data") {
-    reader.releaseLock();
-    throw new DeferredDataError("Deferred route data response is invalid");
-  }
-  const data = reviveDeferredValue(initial.data, controllers);
-  void (async () => {
-    try {
-      for (let line = await readLine(); line !== void 0; line = await readLine()) {
-        if (!line) continue;
-        const message = parseDeferredMessage(line);
-        if (message.type === "resolve") {
-          const controller = getControlledDeferred(message.id, controllers);
-          controller.resolve(reviveDeferredValue(message.data, controllers));
-        } else if (message.type === "reject") {
-          getControlledDeferred(message.id, controllers).reject(
-            new DeferredDataError(message.error?.message)
-          );
-        }
-      }
-      const outstanding = rejectPendingDeferred(
-        controllers,
-        "Deferred route data stream ended before completion"
-      );
-      if (outstanding === 0) notifyDeferredComplete(options);
-    } catch {
-      rejectPendingDeferred(controllers, "Deferred route data stream could not be read");
-    } finally {
-      reader.releaseLock();
-    }
-  })();
-  return data;
-}
-__name(readDeferredDataResponse, "readDeferredDataResponse");
-function notifyDeferredComplete(options) {
-  try {
-    options.onComplete?.();
-  } catch {
-  }
-}
-__name(notifyDeferredComplete, "notifyDeferredComplete");
-function reviveDeferredValue(value, controllers, settlements, applyingSettlements = /* @__PURE__ */ new Set()) {
-  if (isDeferredMarker(value)) {
-    const id = value[FARM_DEFERRED_MARKER];
-    if (id.startsWith("!")) {
-      return { [FARM_DEFERRED_MARKER]: id.slice(1) };
-    }
-    const controller = getControlledDeferred(id, controllers);
-    const settlement = settlements?.[id];
-    if (settlement && controller.promise.status === "pending") {
-      if (applyingSettlements.has(id)) return controller.promise;
-      applyingSettlements.add(id);
-      if (settlement.status === "fulfilled") {
-        controller.resolve(
-          reviveDeferredValue(settlement.value, controllers, settlements, applyingSettlements)
-        );
-      } else {
-        controller.reject(new DeferredDataError(settlement.error.message));
-      }
-      applyingSettlements.delete(id);
-    } else if (settlements && controller.promise.status === "pending") {
-      controller.reject(new DeferredDataError("Deferred route data was not resolved"));
-    }
-    return controller.promise;
-  }
-  if (Array.isArray(value)) {
-    return value.map(
-      (item) => reviveDeferredValue(item, controllers, settlements, applyingSettlements)
-    );
-  }
-  if (!value || typeof value !== "object") return value;
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) return value;
-  const output = {};
-  for (const [key, item] of Object.entries(value)) {
-    defineDataProperty(
-      output,
-      key,
-      reviveDeferredValue(item, controllers, settlements, applyingSettlements)
-    );
-  }
-  return output;
-}
-__name(reviveDeferredValue, "reviveDeferredValue");
-function defineDataProperty(output, key, value) {
-  if (key === "__proto__") {
-    Object.defineProperty(output, key, {
-      value,
-      enumerable: true,
-      writable: true,
-      configurable: true
-    });
-  } else {
-    output[key] = value;
-  }
-}
-__name(defineDataProperty, "defineDataProperty");
-function getControlledDeferred(id, controllers) {
-  const existing = controllers.get(id);
-  if (existing) return existing;
-  let nativeResolve;
-  let nativeReject;
-  const promise = new Promise((resolve, reject) => {
-    nativeResolve = resolve;
-    nativeReject = reject;
-  });
-  promise.status = "pending";
-  promise.catch(() => void 0);
-  const controlled = {
-    promise,
-    resolve(value) {
-      if (promise.status !== "pending") return;
-      promise.status = "fulfilled";
-      promise.value = value;
-      nativeResolve(value);
-    },
-    reject(error) {
-      if (promise.status !== "pending") return;
-      promise.status = "rejected";
-      promise.reason = error;
-      nativeReject(error);
-    }
-  };
-  controllers.set(id, controlled);
-  return controlled;
-}
-__name(getControlledDeferred, "getControlledDeferred");
-function isDeferredMarker(value) {
-  return Boolean(
-    value && typeof value === "object" && Object.keys(value).length === 1 && typeof value[FARM_DEFERRED_MARKER] === "string"
-  );
-}
-__name(isDeferredMarker, "isDeferredMarker");
-function parseDeferredMessage(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    throw new DeferredDataError("Deferred route data response contains invalid JSON");
-  }
-}
-__name(parseDeferredMessage, "parseDeferredMessage");
-function rejectPendingDeferred(controllers, message) {
-  let rejected = 0;
-  for (const controller of controllers.values()) {
-    if (controller.promise.status === "pending") {
-      controller.reject(new DeferredDataError(message));
-      rejected += 1;
-    }
-  }
-  return rejected;
-}
-__name(rejectPendingDeferred, "rejectPendingDeferred");
-
-// src/client-cancellation.ts
-function createClientCancellation(signal, timeoutMs = 0, parent) {
-  let timer;
-  let invalid;
-  let timeoutReason;
-  const signals = [signal, parent].filter((value) => !!value);
-  if (!Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 2147483647) {
-    invalid = new RangeError(
-      "timeoutMs must be an integer between 0 and 2147483647 (0 disables the deadline)."
-    );
-  } else if (timeoutMs > 0) {
-    const controller = new AbortController();
-    signals.push(controller.signal);
-    timer = setTimeout(() => {
-      timeoutReason = new DOMException("Client request timed out", "TimeoutError");
-      controller.abort(timeoutReason);
-    }, timeoutMs);
-  }
-  const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
-  let active = 0;
-  let closed = false;
-  const cleanup = /* @__PURE__ */ __name(() => {
-    if (closed && active === 0 && timer !== void 0) {
-      clearTimeout(timer);
-      timer = void 0;
-    }
-  }, "cleanup");
-  const check = /* @__PURE__ */ __name(() => {
-    if (invalid) throw invalid;
-    combined?.throwIfAborted();
-  }, "check");
-  return {
-    signal: combined,
-    get timedOut() {
-      return timeoutReason !== void 0 && combined?.reason === timeoutReason;
-    },
-    check,
-    hold() {
-      active++;
-      return () => {
-        active--;
-        cleanup();
-      };
-    },
-    // A race also bounds cooperative local dispatch and custom HTTP implementations.
-    // Late completion is consumed, but cannot turn a cancelled result into success.
-    async run(work) {
-      check();
-      active++;
-      let abort;
-      try {
-        if (!combined) return await work();
-        return await new Promise((resolve, reject) => {
-          abort = /* @__PURE__ */ __name(() => reject(combined.reason), "abort");
-          combined.addEventListener("abort", abort, { once: true });
-          Promise.resolve().then(() => {
-            check();
-            return work();
-          }).then(resolve, reject);
-        });
-      } finally {
-        if (abort) combined?.removeEventListener("abort", abort);
-        active--;
-        cleanup();
-      }
-    },
-    async delay(ms) {
-      let retryTimer;
-      try {
-        await this.run(
-          () => new Promise((resolve) => {
-            retryTimer = setTimeout(resolve, ms);
-          })
-        );
-      } finally {
-        if (retryTimer !== void 0) clearTimeout(retryTimer);
-      }
-    },
-    dispose() {
-      closed = true;
-      cleanup();
-    }
-  };
-}
-__name(createClientCancellation, "createClientCancellation");
-
-// src/client/history-sync.ts
-var FARM_HISTORY_CHANGE_EVENT = "farm:historychange";
-function dispatchHistoryChange(kind) {
-  window.dispatchEvent(
-    new CustomEvent(FARM_HISTORY_CHANGE_EVENT, {
-      detail: { kind }
-    })
-  );
-}
-__name(dispatchHistoryChange, "dispatchHistoryChange");
-function notifyHistoryChange(kind) {
-  if (typeof window === "undefined") return;
-  setTimeout(() => {
-    if (kind === "url-search" && !getInstalledFarmSPARouter()) {
-      window.dispatchEvent(new PopStateEvent("popstate"));
-      return;
-    }
-    dispatchHistoryChange(kind);
-  }, 0);
-}
-__name(notifyHistoryChange, "notifyHistoryChange");
-function notifyRouterHistoryChange() {
-  if (typeof window === "undefined") return;
-  setTimeout(() => dispatchHistoryChange("url-search"), 0);
-}
-__name(notifyRouterHistoryChange, "notifyRouterHistoryChange");
-function subscribeHistoryChange(listener) {
-  if (typeof window === "undefined") return () => {
-  };
-  window.addEventListener("popstate", listener);
-  window.addEventListener(FARM_HISTORY_CHANGE_EVENT, listener);
-  return () => {
-    window.removeEventListener("popstate", listener);
-    window.removeEventListener(FARM_HISTORY_CHANGE_EVENT, listener);
-  };
-}
-__name(subscribeHistoryChange, "subscribeHistoryChange");
-
-// src/deployment.ts
-var FARM_DEPLOYMENT_ID_HEADER = "x-farm-deployment-id";
-var FARM_DEPLOYMENT_MISMATCH_HEADER = "x-farm-deployment-mismatch";
-var FARM_DEPLOYMENT_MISMATCH_CODE = "FARM_DEPLOYMENT_MISMATCH";
-var FARM_DEPLOYMENT_MISMATCH_STATUS = 409;
-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;
-  }
-};
-__name(_FarmDeploymentMismatchError, "FarmDeploymentMismatchError");
-var FarmDeploymentMismatchError = _FarmDeploymentMismatchError;
-function createFarmDeploymentRequestHeaders(deploymentId, init) {
-  const headers = new Headers(init);
-  if (deploymentId) {
-    headers.set(FARM_DEPLOYMENT_ID_HEADER, deploymentId);
-  }
-  return headers;
-}
-__name(createFarmDeploymentRequestHeaders, "createFarmDeploymentRequestHeaders");
-function getFarmResponseDeploymentId(response) {
-  return response.headers.get(FARM_DEPLOYMENT_ID_HEADER)?.trim() || void 0;
-}
-__name(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";
-}
-__name(isFarmDeploymentMismatchResponse, "isFarmDeploymentMismatchResponse");
-function createFarmDeploymentMismatchError(response, clientDeploymentId) {
-  return new FarmDeploymentMismatchError(
-    clientDeploymentId,
-    getFarmResponseDeploymentId(response) || "unknown"
-  );
-}
-__name(createFarmDeploymentMismatchError, "createFarmDeploymentMismatchError");
-
-// src/client/hash-target.ts
-function getHashTargetElement(hash) {
-  const fragment = hash.startsWith("#") ? hash.slice(1) : hash;
-  if (!fragment) return null;
-  let decoded = fragment;
-  try {
-    decoded = decodeURIComponent(fragment);
-  } catch {
-  }
-  return document.getElementById(decoded) || document.getElementById(fragment) || document.getElementsByName(decoded)[0] || null;
-}
-__name(getHashTargetElement, "getHashTargetElement");
-
-// src/client/navigation-url.ts
-function isFarmExternalNavigationURL(url, currentOrigin) {
-  return url.protocol !== "http:" && url.protocol !== "https:" || url.origin !== currentOrigin;
-}
-__name(isFarmExternalNavigationURL, "isFarmExternalNavigationURL");
-function resolveFarmNavigationURL(href, documentUrl) {
-  return new URL(href, documentUrl);
-}
-__name(resolveFarmNavigationURL, "resolveFarmNavigationURL");
-
-// src/agent-json-ld.ts
-function pruneUndefined(object) {
-  const result = {};
-  for (const [key, value] of Object.entries(object)) {
-    if (value !== void 0 && value !== null && value !== "") result[key] = value;
-  }
-  return result;
-}
-__name(pruneUndefined, "pruneUndefined");
-function serializeJsonLd(value) {
-  return JSON.stringify(value).replace(/</g, "\\u003c");
-}
-__name(serializeJsonLd, "serializeJsonLd");
-function renderFarmAgentJsonLd(config, context2) {
-  const base = pruneUndefined({
-    name: config.name ?? context2.siteName ?? context2.title,
-    url: config.url ?? context2.metadataBase,
-    description: config.description ?? context2.description,
-    logo: config.logo,
-    sameAs: config.sameAs && config.sameAs.length > 0 ? config.sameAs : void 0
-  });
-  const object = {
-    "@context": "https://schema.org",
-    "@type": config.type || "Organization",
-    ...base,
-    ...config.properties || {}
-  };
-  if (Object.keys(object).length <= 2 && !config.properties) {
-    return "";
-  }
-  return `<script type="application/ld+json">${serializeJsonLd(object)}</script>`;
-}
-__name(renderFarmAgentJsonLd, "renderFarmAgentJsonLd");
-
-// src/metadata.ts
-var FARM_METADATA_ATTRIBUTE = "data-farm-metadata";
-function renderMetadataHead(metadata, options = {}) {
-  const resolvedMetadata = metadata || {};
-  const metadataBase = resolveMetadataBase(resolvedMetadata);
-  const explicitTitle = resolveMetadataTitle(resolvedMetadata.title);
-  const title = explicitTitle || "Farm.js App";
-  const tags = [];
-  appendMetaName(tags, "description", resolvedMetadata.description);
-  appendMetaName(tags, "keywords", normalizeKeywords(resolvedMetadata.keywords));
-  appendMetaName(tags, "author", resolvedMetadata.author);
-  if (Array.isArray(resolvedMetadata.authors)) {
-    for (const author of resolvedMetadata.authors) {
-      appendMetaName(tags, "author", author?.name);
-      if (author?.url) {
-        appendLink(tags, "author", resolveMetadataUrl(author.url, metadataBase));
-      }
-    }
-  }
-  appendMetaName(tags, "creator", resolvedMetadata.creator);
-  appendMetaName(tags, "publisher", resolvedMetadata.publisher);
-  appendMetaName(tags, "robots", normalizeRobots(resolvedMetadata.robots));
-  if (isRecord(resolvedMetadata.robots)) {
-    appendMetaName(tags, "googlebot", normalizeRobots(resolvedMetadata.robots.googleBot));
-  }
-  const alternates = resolvedMetadata.alternates;
-  const explicitCanonical = isRecord(alternates) ? alternates.canonical : void 0;
-  const canonicalHref = explicitCanonical != null ? resolveMetadataUrl(explicitCanonical, metadataBase) : options.pathname ? resolveMetadataUrl(sanitizeSelfCanonicalPathname(options.pathname), metadataBase) : void 0;
-  if (canonicalHref) {
-    appendLink(tags, "canonical", canonicalHref);
-  }
-  if (isRecord(alternates) && isRecord(alternates.languages)) {
-    for (const [language, href] of Object.entries(alternates.languages)) {
-      appendLink(tags, "alternate", resolveMetadataUrl(href, metadataBase), {
-        hreflang: language
-      });
-    }
-  }
-  if (isRecord(alternates) && isRecord(alternates.types)) {
-    for (const [type, value] of Object.entries(alternates.types)) {
-      for (const entry of normalizeArray(value)) {
-        const link = isRecord(entry) ? entry : { url: entry };
-        appendLink(tags, "alternate", resolveMetadataUrl(link.url, metadataBase), {
-          type,
-          title: link.title
-        });
-      }
-    }
-  }
-  const hasFavicon = appendIcons(tags, resolvedMetadata.icons, metadataBase);
-  if (resolvedMetadata.manifest) {
-    appendLink(
-      tags,
-      "manifest",
-      resolveMetadataUrl(resolvedMetadata.manifest, metadataBase)
-    );
-  }
-  appendNamedMetaRecord(tags, resolvedMetadata.other);
-  appendOpenGraph(tags, resolvedMetadata.openGraph, metadataBase);
-  appendTwitter(tags, resolvedMetadata.twitter, metadataBase);
-  appendVerification(tags, resolvedMetadata.verification);
-  if (options.jsonLd) {
-    const jsonLdConfig = options.jsonLd === true ? {} : options.jsonLd;
-    const jsonLdScript = renderFarmAgentJsonLd(jsonLdConfig, {
-      metadataBase,
-      siteName: isRecord(resolvedMetadata.openGraph) ? normalizeContent(resolvedMetadata.openGraph.siteName) : void 0,
-      title: explicitTitle,
-      description: normalizeContent(resolvedMetadata.description)
-    });
-    if (jsonLdScript) tags.push(jsonLdScript);
-  }
-  for (const entry of normalizeArray(resolvedMetadata.jsonLd)) {
-    if (!isRecord(entry)) continue;
-    tags.push(
-      `<script type="application/ld+json" ${FARM_METADATA_ATTRIBUTE}>${serializeJsonLd(entry)}</script>`
-    );
-  }
-  return {
-    title: escapeText(title),
-    tags: tags.length > 0 ? `
-  ${tags.join("\n  ")}` : "",
-    hasFavicon,
-    hasExplicitTitle: Boolean(explicitTitle)
-  };
-}
-__name(renderMetadataHead, "renderMetadataHead");
-function appendOpenGraph(tags, openGraph, metadataBase) {
-  if (!isRecord(openGraph)) return;
-  appendMetaProperty(tags, "og:title", openGraph.title);
-  appendMetaProperty(tags, "og:description", openGraph.description);
-  appendMetaProperty(tags, "og:url", resolveMetadataUrl(openGraph.url, metadataBase));
-  appendMetaProperty(tags, "og:site_name", openGraph.siteName);
-  appendMetaProperty(tags, "og:type", openGraph.type ?? "website");
-  appendMetaProperty(tags, "og:locale", openGraph.locale);
-  const images = normalizeMetadataImages(
-    openGraph.images ?? openGraph.image,
-    metadataBase
-  );
-  for (const image of images) {
-    appendMetaProperty(tags, "og:image", image.url);
-    appendMetaProperty(tags, "og:image:width", image.width);
-    appendMetaProperty(tags, "og:image:height", image.height);
-    appendMetaProperty(tags, "og:image:alt", image.alt);
-    appendMetaProperty(tags, "og:image:type", image.type);
-  }
-  if (openGraph.type === "article") {
-    appendMetaProperty(tags, "article:published_time", normalizeDate(openGraph.publishedTime));
-    appendMetaProperty(tags, "article:modified_time", normalizeDate(openGraph.modifiedTime));
-    for (const author of normalizeArray(openGraph.authors)) {
-      appendMetaProperty(tags, "article:author", author);
-    }
-    appendMetaProperty(tags, "article:section", openGraph.section);
-    for (const tag of normalizeArray(openGraph.tags)) {
-      appendMetaProperty(tags, "article:tag", tag);
-    }
-  }
-}
-__name(appendOpenGraph, "appendOpenGraph");
-function appendTwitter(tags, twitter, metadataBase) {
-  if (!isRecord(twitter)) return;
-  appendMetaName(tags, "twitter:card", twitter.card);
-  appendMetaName(tags, "twitter:site", twitter.site);
-  appendMetaName(tags, "twitter:creator", twitter.creator);
-  appendMetaName(tags, "twitter:title", twitter.title);
-  appendMetaName(tags, "twitter:description", twitter.description);
-  for (const image of normalizeMetadataImages(twitter.images, metadataBase)) {
-    appendMetaName(tags, "twitter:image", image.url);
-    appendMetaName(tags, "twitter:image:alt", image.alt);
-  }
-}
-__name(appendTwitter, "appendTwitter");
-function appendNamedMetaRecord(tags, record) {
-  if (!isRecord(record)) return;
-  for (const [name, value] of Object.entries(record)) {
-    for (const content of normalizeArray(value)) {
-      appendMetaName(tags, name, content, true);
-    }
-  }
-}
-__name(appendNamedMetaRecord, "appendNamedMetaRecord");
-function appendIcons(tags, icons, metadataBase) {
-  if (!icons) return false;
-  if (typeof icons === "string") {
-    const initialTagCount2 = tags.length;
-    appendLink(tags, "icon", resolveMetadataUrl(icons, metadataBase));
-    return tags.length > initialTagCount2;
-  }
-  if (!isRecord(icons)) return false;
-  const initialTagCount = tags.length;
-  appendIconList(tags, "icon", icons.icon, metadataBase);
-  appendIconList(tags, "shortcut icon", icons.shortcut, metadataBase);
-  const hasFavicon = tags.length > initialTagCount;
-  appendIconList(tags, "apple-touch-icon", icons.apple, metadataBase);
-  return hasFavicon;
-}
-__name(appendIcons, "appendIcons");
-function appendIconList(tags, rel, value, metadataBase) {
-  for (const icon of normalizeArray(value)) {
-    if (typeof icon === "string") {
-      appendLink(tags, rel, resolveMetadataUrl(icon, metadataBase));
-      continue;
-    }
-    if (!isRecord(icon)) continue;
-    appendLink(tags, rel, resolveMetadataUrl(icon.url, metadataBase), {
-      sizes: icon.sizes,
-      type: icon.type
-    });
-  }
-}
-__name(appendIconList, "appendIconList");
-function appendMetaName(tags, name, content, marked = false) {
-  const normalized = normalizeContent(content);
-  if (!normalized || !name) return;
-  const marker = marked ? ` ${FARM_METADATA_ATTRIBUTE}` : "";
-  tags.push(
-    `<meta name="${escapeAttribute(name)}" content="${escapeAttribute(normalized)}"${marker}>`
-  );
-}
-__name(appendMetaName, "appendMetaName");
-function appendMetaProperty(tags, property, content) {
-  const normalized = normalizeContent(content);
-  if (!normalized) return;
-  tags.push(
-    `<meta property="${escapeAttribute(property)}" content="${escapeAttribute(normalized)}">`
-  );
-}
-__name(appendMetaProperty, "appendMetaProperty");
-var VERIFICATION_META_NAMES = [
-  ["google", "google-site-verification"],
-  ["bing", "msvalidate.01"],
-  ["yandex", "yandex-verification"]
-];
-function appendVerification(tags, verification) {
-  if (!isRecord(verification)) return;
-  for (const [key, name] of VERIFICATION_META_NAMES) {
-    for (const token of normalizeArray(verification[key])) {
-      appendMetaName(tags, name, token);
-    }
-  }
-  appendNamedMetaRecord(tags, verification.other);
-}
-__name(appendVerification, "appendVerification");
-function appendLink(tags, rel, href, attrs = {}) {
-  const normalizedHref = normalizeContent(href);
-  if (!normalizedHref) return;
-  const attrText = Object.entries(attrs).map(([key, value]) => {
-    const normalized = normalizeContent(value);
-    return normalized ? ` ${key}="${escapeAttribute(normalized)}"` : "";
-  }).join("");
-  tags.push(
-    `<link rel="${escapeAttribute(rel)}" href="${escapeAttribute(normalizedHref)}"${attrText}>`
-  );
-}
-__name(appendLink, "appendLink");
-function normalizeMetadataImages(value, metadataBase) {
-  return normalizeArray(value).map((item) => {
-    if (typeof item === "string") {
-      return { url: resolveMetadataUrl(item, metadataBase) || item };
-    }
-    if (!isRecord(item)) return null;
-    const rawUrl = item.url || item.src;
-    const url = resolveMetadataUrl(rawUrl, metadataBase);
-    if (!url) return null;
-    return {
-      url,
-      width: normalizeNumber(item.width),
-      height: normalizeNumber(item.height),
-      alt: typeof item.alt === "string" ? item.alt : void 0,
-      type: typeof item.type === "string" ? item.type : void 0
-    };
-  }).filter((item) => item !== null);
-}
-__name(normalizeMetadataImages, "normalizeMetadataImages");
-function normalizeArray(value) {
-  if (value == null) return [];
-  return Array.isArray(value) ? value : [value];
-}
-__name(normalizeArray, "normalizeArray");
-function resolveMetadataTitle(title) {
-  if (typeof title === "string") return title;
-  if (isRecord(title)) {
-    return normalizeContent(title.default);
-  }
-  return void 0;
-}
-__name(resolveMetadataTitle, "resolveMetadataTitle");
-function normalizeKeywords(keywords) {
-  if (Array.isArray(keywords)) return keywords.filter(Boolean).join(", ");
-  return keywords;
-}
-__name(normalizeKeywords, "normalizeKeywords");
-var ROBOTS_FLAGS = ["noarchive", "nosnippet", "noimageindex"];
-var ROBOTS_VALUES = [
-  "max-snippet",
-  "max-image-preview",
-  "max-video-preview",
-  "unavailable_after"
-];
-function normalizeRobots(robots) {
-  if (typeof robots === "string") return robots;
-  if (!isRecord(robots)) return void 0;
-  const values = [];
-  if (typeof robots.index === "boolean") values.push(robots.index ? "index" : "noindex");
-  if (typeof robots.follow === "boolean") values.push(robots.follow ? "follow" : "nofollow");
-  for (const flag of ROBOTS_FLAGS) {
-    if (robots[flag] === true) values.push(flag);
-  }
-  for (const directive of ROBOTS_VALUES) {
-    const value = normalizeContent(robots[directive]);
-    if (value) values.push(`${directive}:${value}`);
-  }
-  return values.join(", ") || void 0;
-}
-__name(normalizeRobots, "normalizeRobots");
-function resolveMetadataBase(metadata) {
-  const base = metadata.metadataBase;
-  if (!base) return void 0;
-  return String(base);
-}
-__name(resolveMetadataBase, "resolveMetadataBase");
-function sanitizeSelfCanonicalPathname(pathname) {
-  if (typeof pathname !== "string" || pathname.length === 0) return "/";
-  const collapsed = pathname.replace(/^[/\\]+/, "/");
-  return collapsed.startsWith("/") ? collapsed : `/${collapsed}`;
-}
-__name(sanitizeSelfCanonicalPathname, "sanitizeSelfCanonicalPathname");
-function resolveMetadataUrl(value, metadataBase) {
-  const normalized = normalizeContent(value);
-  if (!normalized) return void 0;
-  if (!metadataBase) return normalized;
-  try {
-    return new URL(normalized, metadataBase).toString();
-  } catch {
-    return normalized;
-  }
-}
-__name(resolveMetadataUrl, "resolveMetadataUrl");
-function normalizeNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string") {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : void 0;
-  }
-  return void 0;
-}
-__name(normalizeNumber, "normalizeNumber");
-function normalizeDate(value) {
-  if (value instanceof Date) {
-    return Number.isNaN(value.getTime()) ? void 0 : value.toISOString();
-  }
-  return normalizeContent(value);
-}
-__name(normalizeDate, "normalizeDate");
-function normalizeContent(value) {
-  if (value == null) return void 0;
-  if (typeof value === "string") return value;
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
-  if (value instanceof URL) return value.toString();
-  return void 0;
-}
-__name(normalizeContent, "normalizeContent");
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-__name(isRecord, "isRecord");
-function escapeText(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-__name(escapeText, "escapeText");
-function escapeAttribute(value) {
-  return escapeText(value).replace(/"/g, "&quot;");
-}
-__name(escapeAttribute, "escapeAttribute");
-
-// src/client/metadata-reconciler.ts
-var MANAGED_ATTRIBUTE = FARM_METADATA_ATTRIBUTE;
-var OWNED_SELECTORS = [
-  'meta[name="description"]',
-  'meta[name="keywords"]',
-  'meta[name="author"]',
-  'meta[name="google-site-verification"]',
-  'meta[name="msvalidate.01"]',
-  'meta[name="yandex-verification"]',
-  'meta[name="creator"]',
-  'meta[name="publisher"]',
-  'meta[name="robots"]',
-  'meta[name="googlebot"]',
-  'link[rel="author"]',
-  'link[rel="canonical"]',
-  'link[rel="alternate"]',
-  'meta[property^="og:"]',
-  'meta[property^="article:"]',
-  'meta[name^="twitter:"]',
-  // Meta tags named by the app carry the marker, since no fixed name matches them.
-  `meta[${MANAGED_ATTRIBUTE}]`
-].join(", ");
-var ICON_SELECTORS = [
-  'link[rel="icon"]',
-  'link[rel="shortcut icon"]',
-  'link[rel="apple-touch-icon"]'
-].join(", ");
-var MANIFEST_SELECTOR = 'link[rel="manifest"]';
-var PAGE_JSON_LD_SELECTOR = `script[type="application/ld+json"][${MANAGED_ATTRIBUTE}]`;
-function removeAll(selector) {
-  for (const element of Array.from(document.head.querySelectorAll(selector))) {
-    element.remove();
-  }
-}
-__name(removeAll, "removeAll");
-function applyFarmMetadataToDocument(metadata, pathname) {
-  document.title = resolveMetadataTitle(metadata?.title) || "Farm.js App";
-  const rendered = renderMetadataHead(metadata, { pathname });
-  const template = document.createElement("template");
-  template.innerHTML = rendered.tags;
-  removeAll(OWNED_SELECTORS);
-  removeAll(PAGE_JSON_LD_SELECTOR);
-  if (metadata?.icons) removeAll(ICON_SELECTORS);
-  if (metadata?.manifest) removeAll(MANIFEST_SELECTOR);
-  for (const element of Array.from(template.content.children)) {
-    element.setAttribute(MANAGED_ATTRIBUTE, "");
-    document.head.appendChild(element);
-  }
-}
-__name(applyFarmMetadataToDocument, "applyFarmMetadataToDocument");
-
-// src/i18n/bridge.ts
-var FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
-function getActiveFarmI18nSnapshot() {
-  if (typeof window !== "undefined" && window.__FARM_I18N__) {
-    return window.__FARM_I18N__;
-  }
-  return globalThis[FARM_I18N_SNAPSHOT_RESOLVER]?.();
-}
-__name(getActiveFarmI18nSnapshot, "getActiveFarmI18nSnapshot");
-
-// src/base-path.ts
-var FARM_BASE_PATH = /* @__PURE__ */ Symbol.for("farm.basePath");
-function getFarmGlobalState() {
-  return globalThis;
-}
-__name(getFarmGlobalState, "getFarmGlobalState");
-function getFarmBasePath() {
-  return getFarmGlobalState()[FARM_BASE_PATH] ?? "";
-}
-__name(getFarmBasePath, "getFarmBasePath");
-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}`;
-}
-__name(applyFarmBasePath, "applyFarmBasePath");
-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}`;
-}
-__name(canonicalizeAppRelativeHref, "canonicalizeAppRelativeHref");
-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) || "/";
-}
-__name(stripFarmBasePath, "stripFarmBasePath");
-function normalizeFarmBasePath(basePath) {
-  if (!basePath || basePath === "/") return "";
-  const hasUnstableCharacters = /* @__PURE__ */ __name((candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  }), "hasUnstableCharacters");
-  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(/\/+$/, "");
-}
-__name(normalizeFarmBasePath, "normalizeFarmBasePath");
-
-// src/i18n/routing.ts
-function resolveFarmLocalePath(pathname, config) {
-  const normalized = normalizePathname2(stripFarmBasePath(pathname, config.basePath));
-  if (config.routing === "none") {
-    return { pathname: normalized, explicit: false };
-  }
-  const segments = normalized.split("/").filter(Boolean);
-  const firstSegment = segments[0];
-  const locale = config.locales.find(
-    (candidate) => candidate.toLowerCase() === firstSegment?.toLowerCase()
-  );
-  if (!locale) {
-    return { pathname: normalized, explicit: false };
-  }
-  const remaining = segments.slice(1);
-  return {
-    locale,
-    pathname: remaining.length > 0 ? `/${remaining.join("/")}` : "/",
-    explicit: true
-  };
-}
-__name(resolveFarmLocalePath, "resolveFarmLocalePath");
-function stripFarmLocaleFromPathname(pathname, config) {
-  return resolveFarmLocalePath(pathname, config).pathname;
-}
-__name(stripFarmLocaleFromPathname, "stripFarmLocaleFromPathname");
-function localizeFarmPathname(pathname, locale, config) {
-  const internalPathname = resolveFarmLocalePath(pathname, config).pathname;
-  let localizedPathname = internalPathname;
-  if (config.routing === "none") {
-    return applyFarmBasePath(localizedPathname, config.basePath);
-  }
-  if (config.routing === "prefix-except-default" && locale === config.defaultLocale) {
-    return applyFarmBasePath(localizedPathname, config.basePath);
-  }
-  localizedPathname = internalPathname === "/" ? `/${locale}` : `/${locale}${internalPathname}`;
-  return applyFarmBasePath(localizedPathname, config.basePath);
-}
-__name(localizeFarmPathname, "localizeFarmPathname");
-function localizeFarmHref(href, locale, config) {
-  if (!href.startsWith("/") || href.startsWith("//")) return href;
-  const url = new URL(href, "http://farm.local");
-  url.pathname = localizeFarmPathname(url.pathname, locale, config);
-  return `${url.pathname}${url.search}${url.hash}`;
-}
-__name(localizeFarmHref, "localizeFarmHref");
-function normalizePathname2(pathname) {
-  const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
-  if (withLeadingSlash === "/") return "/";
-  return withLeadingSlash.replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
-}
-__name(normalizePathname2, "normalizePathname");
-
-// src/i18n/client-state.ts
-var listeners = /* @__PURE__ */ new Set();
-var compiledFarmI18nMessages = /* @__PURE__ */ new Map();
-var currentSnapshot;
-function getFarmI18nClientState() {
-  return currentSnapshot || getActiveFarmI18nSnapshot();
-}
-__name(getFarmI18nClientState, "getFarmI18nClientState");
-function subscribeFarmI18n(listener) {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
-}
-__name(subscribeFarmI18n, "subscribeFarmI18n");
-function _hydrateFarmI18n(snapshot) {
-  if (!snapshot) return;
-  const changed = currentSnapshot?.locale !== snapshot.locale;
-  currentSnapshot = snapshot;
-  if (typeof window !== "undefined") window.__FARM_I18N__ = snapshot;
-  if (typeof document !== "undefined") {
-    document.documentElement.lang = snapshot.locale;
-    document.documentElement.dir = snapshot.direction;
-  }
-  if (changed) compiledFarmI18nMessages.clear();
-  for (const listener of listeners) listener();
-}
-__name(_hydrateFarmI18n, "_hydrateFarmI18n");
-function isFarmLocaleChangeHref(href) {
-  const snapshot = getFarmI18nClientState();
-  if (!snapshot || typeof window === "undefined") return false;
-  if (snapshot.routing === "none") return false;
-  const target = resolveFarmNavigationURL(href, window.location.href);
-  const match = resolveFarmLocalePath(target.pathname, snapshot);
-  const targetLocale = match.locale || snapshot.defaultLocale;
-  return targetLocale !== snapshot.locale;
-}
-__name(isFarmLocaleChangeHref, "isFarmLocaleChangeHref");
-
-// src/client/spa-router.ts
-var MAX_CONCURRENT_VIEWPORT_PREFETCHES = 4;
-var FARM_PAGE_STATE_KEY = "__farmPageState";
-var FARM_INTERCEPT_FROM_KEY = "__farmInterceptFrom";
-var FARM_HISTORY_INDEX_KEY = "__farmHistoryIndex";
-function readHistoryIndex(state) {
-  if (!state || typeof state !== "object") return null;
-  const value = state[FARM_HISTORY_INDEX_KEY];
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-__name(readHistoryIndex, "readHistoryIndex");
-var IDLE_NAVIGATION_STATE = {
-  state: "idle",
-  pending: false,
-  from: null,
-  to: null,
-  action: null,
-  startedAt: null
-};
-function getActiveLayoutChainHeader() {
-  if (typeof document === "undefined") return void 0;
-  const patterns = Array.from(
-    document.querySelectorAll('[data-farm-layout-boundary="true"]')
-  ).map((element) => element.dataset.farmLayoutPattern).filter((pattern) => Boolean(pattern));
-  return patterns.length > 0 ? JSON.stringify(patterns) : void 0;
-}
-__name(getActiveLayoutChainHeader, "getActiveLayoutChainHeader");
-var routerInstance = null;
-var _SPARouter = class _SPARouter {
-  constructor(options = {}) {
-    this.cache = /* @__PURE__ */ new Map();
-    this.prefetchingUrls = /* @__PURE__ */ new Set();
-    this.pendingPrefetches = /* @__PURE__ */ new Map();
-    this.cacheGeneration = 0;
-    this.observedPrefetchLinks = /* @__PURE__ */ new Map();
-    this.prefetchTimers = /* @__PURE__ */ new Map();
-    this.viewportPrefetchQueue = [];
-    this.viewportPrefetchTasksByHref = /* @__PURE__ */ new Map();
-    this.viewportPrefetchTasksByElement = /* @__PURE__ */ new Map();
-    this.activeViewportPrefetches = 0;
-    this.destroyed = false;
-    this.blockers = /* @__PURE__ */ new Set();
-    this.unloadBlockers = /* @__PURE__ */ new Map();
-    this.navigationListeners = /* @__PURE__ */ new Set();
-    this.navigationState = IDLE_NAVIGATION_STATE;
-    this.currentHistoryPath = null;
-    this.currentHistoryHash = "";
-    this.currentHistoryIndex = null;
-    this.suppressNextPopState = false;
-    this.navigationSequence = 0;
-    this.scrollElements = /* @__PURE__ */ new Map();
-    this.onPopState = /* @__PURE__ */ __name((event) => {
-      void this.handlePopState(event);
-    }, "onPopState");
-    this.onBeforeUnload = /* @__PURE__ */ __name((event) => {
-      if (this.shouldBlockUnload()) {
-        event.preventDefault();
-        event.returnValue = "";
-      }
-      this.saveScrollPosition(window.location.pathname + window.location.search);
-    }, "onBeforeUnload");
-    this.options = {
-      prefetchTimeout: options.prefetchTimeout ?? 100,
-      cacheMaxAge: options.cacheMaxAge ?? 3e4,
-      // 30 seconds
-      scrollRestoration: options.scrollRestoration ?? true,
-      shouldUseDocumentNavigation: options.shouldUseDocumentNavigation ?? (() => false),
-      deploymentId: options.deploymentId ?? readBrowserDeploymentId()
-    };
-    if (typeof window !== "undefined") {
-      window.addEventListener("popstate", this.onPopState);
-      window.addEventListener("beforeunload", this.onBeforeUnload);
-      this.currentHistoryPath = window.location.pathname + window.location.search;
-      this.currentHistoryHash = window.location.hash;
-      this.currentInterceptFrom = window.history.state?.[FARM_INTERCEPT_FROM_KEY];
-      const existingIndex = readHistoryIndex(window.history.state);
-      if (existingIndex == null) {
-        try {
-          window.history.replaceState(
-            {
-              ...window.history.state ?? {},
-              [FARM_HISTORY_INDEX_KEY]: 0
-            },
-            "",
-            window.location.href
-          );
-          this.currentHistoryIndex = 0;
-        } catch {
-          this.currentHistoryIndex = null;
-        }
-      } else {
-        this.currentHistoryIndex = existingIndex;
-      }
-    }
-  }
-  /** Remove global listeners. Intended for tests and teardown. */
-  destroy() {
-    if (typeof window === "undefined") return;
-    this.destroyed = true;
-    this.cancelActiveNavigation();
-    this.clearCache();
-    this.prefetchObserver?.disconnect();
-    this.prefetchObserver = void 0;
-    for (const timer of this.prefetchTimers.values()) clearTimeout(timer);
-    this.observedPrefetchLinks.clear();
-    this.prefetchTimers.clear();
-    for (const task of this.viewportPrefetchQueue) task.cancelled = true;
-    this.viewportPrefetchQueue.length = 0;
-    this.viewportPrefetchTasksByHref.clear();
-    this.viewportPrefetchTasksByElement.clear();
-    window.removeEventListener("popstate", this.onPopState);
-    window.removeEventListener("beforeunload", this.onBeforeUnload);
-  }
-  /**
-   * Set the navigation handler that updates React
-   */
-  setNavigationHandler(handler) {
-    this.onNavigate = handler;
-  }
-  /**
-   * Connect Farm's browser plugin lifecycle to SPA navigation.
-   */
-  setClientPluginManager(manager) {
-    this.clientPlugins = manager;
-  }
-  /**
-   * Navigate to a new URL
-   */
-  async navigate(href, options = {}) {
-    const {
-      replace = false,
-      scroll = true,
-      state,
-      viewTransition = false,
-      refresh = false
-    } = options;
-    const url = resolveFarmNavigationURL(href, window.location.href);
-    const pathname = url.pathname;
-    const search = url.search;
-    const fullPath = pathname + search;
-    if (isFarmExternalNavigationURL(url, window.location.origin) || isFarmLocaleChangeHref(url.toString()) || this.options.shouldUseDocumentNavigation(pathname)) {
-      this.cancelActiveNavigation();
-      if (replace) window.location.replace(url.toString());
-      else window.location.assign(url.toString());
-      return;
-    }
-    if (!refresh && pathname === window.location.pathname && search === window.location.search) {
-      this.cancelActiveNavigation();
-      if (url.hash === window.location.hash) return;
-      this.writePageState(
-        replace ? "replace" : "push",
-        state === void 0 ? readPageState() : state,
-        url.toString()
-      );
-      if (scroll) {
-        if (url.hash) {
-          getHashTargetElement(url.hash)?.scrollIntoView();
-        } else {
-          window.scrollTo(0, 0);
-        }
-      }
-      return;
-    }
-    const from = window.location.pathname + window.location.search;
-    if (await this.shouldBlockNavigation({
-      from,
-      to: fullPath,
-      action: replace ? "replace" : "push"
-    })) {
-      return;
-    }
-    if (this.options.scrollRestoration) {
-      this.saveScrollPosition(window.location.pathname + window.location.search);
-    }
-    const navigation = this.startNavigation({
-      from,
-      to: createNavigationLocation(url),
-      action: replace ? "replace" : "push"
-    });
-    let clientNavigation;
-    try {
-      clientNavigation = await this.clientPlugins?.beginNavigation({
-        from,
-        to: url,
-        action: replace ? "replace" : "push"
-      });
-      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
-      const pageData = await this.fetchPageData(
-        fullPath,
-        true,
-        from,
-        refresh,
-        navigation.controller.signal
-      );
-      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
-      if (clientNavigation) {
-        await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
-      }
-      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
-      await this.runViewTransition(
-        viewTransition,
-        () => this.isCurrentNavigation(navigation, clientNavigation) ? this.commitNavigation({
-          fullPath,
-          pageData,
-          pathname,
-          replace,
-          scroll,
-          state,
-          url
-        }) : Promise.resolve()
-      );
-      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
-      if (clientNavigation) {
-        await this.clientPlugins?.resolveNavigation(clientNavigation);
-        void this.clientPlugins?.scheduleNavigationRendered(clientNavigation);
-      }
-      this.finishNavigation(navigation);
-    } catch (error) {
-      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
-      if (clientNavigation) {
-        await this.clientPlugins?.failNavigation(clientNavigation, error);
-      }
-      this.finishNavigation(navigation);
-      console.error("[Farm.js] Navigation error:", error);
-      window.location.href = href;
-    }
-  }
-  /**
-   * Re-render the active route from the server while preserving the document,
-   * shared layouts, client runtime, and browser history entry.
-   */
-  refresh(options = {}) {
-    return this.navigate(window.location.href, {
-      ...options,
-      replace: true,
-      refresh: true,
-      scroll: options.scroll ?? false
-    });
-  }
-  /**
-   * Prefetch a URL
-   */
-  async prefetch(href) {
-    if (this.destroyed) return;
-    if (isFarmLocaleChangeHref(href)) return;
-    const url = resolveFarmNavigationURL(href, window.location.href);
-    if (isFarmExternalNavigationURL(url, window.location.origin)) return;
-    if (this.options.shouldUseDocumentNavigation(url.pathname)) return;
-    const fullPath = url.pathname + url.search;
-    const interceptFrom = window.location.pathname + window.location.search;
-    if (this.prefetchingUrls.has(fullPath)) return;
-    if (this.isCached(fullPath, interceptFrom)) return;
-    this.prefetchingUrls.add(fullPath);
-    try {
-      await this.fetchPageData(fullPath, false, interceptFrom);
-    } catch (error) {
-      console.warn("[Farm.js] Prefetch failed:", href, error);
-    } finally {
-      this.prefetchingUrls.delete(fullPath);
-    }
-  }
-  /**
-   * Observe an element for viewport intersection (prefetch when visible)
-   */
-  observeForPrefetch(element) {
-    if (this.destroyed || typeof IntersectionObserver === "undefined") return;
-    const href = element.getAttribute("href");
-    if (!href || this.isExternalUrl(href)) return;
-    this.unobserveForPrefetch(element);
-    const observer = this.getPrefetchObserver();
-    this.observedPrefetchLinks.set(element, href);
-    observer.observe(element);
-  }
-  /**
-   * Stop observing an element
-   */
-  unobserveForPrefetch(element) {
-    if (this.observedPrefetchLinks.delete(element)) {
-      this.prefetchObserver?.unobserve(element);
-    }
-    const timer = this.prefetchTimers.get(element);
-    if (timer !== void 0) {
-      clearTimeout(timer);
-      this.prefetchTimers.delete(element);
-    }
-    this.cancelQueuedViewportPrefetch(element);
-  }
-  getPrefetchObserver() {
-    this.prefetchObserver ?? (this.prefetchObserver = new IntersectionObserver(
-      (entries) => {
-        for (const entry of entries) {
-          if (!entry.isIntersecting) continue;
-          const element = entry.target;
-          const href = this.observedPrefetchLinks.get(element);
-          if (!href) continue;
-          this.prefetchObserver?.unobserve(element);
-          this.observedPrefetchLinks.delete(element);
-          const timer = setTimeout(() => {
-            if (this.prefetchTimers.get(element) !== timer) return;
-            this.prefetchTimers.delete(element);
-            this.enqueueViewportPrefetch(element, href);
-          }, this.options.prefetchTimeout);
-          this.prefetchTimers.set(element, timer);
-        }
-      },
-      { rootMargin: "200px" }
-    ));
-    return this.prefetchObserver;
-  }
-  enqueueViewportPrefetch(element, href) {
-    if (this.destroyed) return;
-    let task = this.viewportPrefetchTasksByHref.get(href);
-    if (!task) {
-      task = { href, elements: /* @__PURE__ */ new Set(), cancelled: false, started: false };
-      this.viewportPrefetchTasksByHref.set(href, task);
-      this.viewportPrefetchQueue.push(task);
-    }
-    task.elements.add(element);
-    this.viewportPrefetchTasksByElement.set(element, task);
-    this.drainViewportPrefetchQueue();
-  }
-  cancelQueuedViewportPrefetch(element) {
-    const task = this.viewportPrefetchTasksByElement.get(element);
-    if (!task) return;
-    this.viewportPrefetchTasksByElement.delete(element);
-    task.elements.delete(element);
-    if (task.elements.size > 0) return;
-    if (task.started) return;
-    task.cancelled = true;
-    if (this.viewportPrefetchTasksByHref.get(task.href) === task) {
-      this.viewportPrefetchTasksByHref.delete(task.href);
-    }
-  }
-  drainViewportPrefetchQueue() {
-    while (!this.destroyed && this.activeViewportPrefetches < MAX_CONCURRENT_VIEWPORT_PREFETCHES && this.viewportPrefetchQueue.length > 0) {
-      const task = this.viewportPrefetchQueue.shift();
-      if (task.cancelled || task.elements.size === 0) {
-        if (this.viewportPrefetchTasksByHref.get(task.href) === task) {
-          this.viewportPrefetchTasksByHref.delete(task.href);
-        }
-        continue;
-      }
-      task.started = true;
-      this.activeViewportPrefetches += 1;
-      let prefetchResult;
-      try {
-        prefetchResult = this.prefetch(task.href);
-      } catch {
-        prefetchResult = void 0;
-      }
-      void Promise.resolve(prefetchResult).catch(() => void 0).finally(() => {
-        if (this.viewportPrefetchTasksByHref.get(task.href) === task) {
-          this.viewportPrefetchTasksByHref.delete(task.href);
-        }
-        for (const element of task.elements) {
-          if (this.viewportPrefetchTasksByElement.get(element) === task) {
-            this.viewportPrefetchTasksByElement.delete(element);
-          }
-        }
-        this.activeViewportPrefetches -= 1;
-        this.drainViewportPrefetchQueue();
-      });
-    }
-  }
-  addBlocker(blocker, shouldBlockUnload) {
-    this.blockers.add(blocker);
-    this.unloadBlockers.set(
-      blocker,
-      shouldBlockUnload ?? (() => this.evaluateBlockerForUnload(blocker))
-    );
-    return () => {
-      this.blockers.delete(blocker);
-      this.unloadBlockers.delete(blocker);
-    };
-  }
-  getNavigationState() {
-    return this.navigationState;
-  }
-  subscribeNavigation(listener) {
-    this.navigationListeners.add(listener);
-    listener(this.navigationState);
-    return () => {
-      this.navigationListeners.delete(listener);
-    };
-  }
-  registerScrollElement(key, element) {
-    this.scrollElements.set(key, element);
-    this.restoreScrollElement(window.location.pathname + window.location.search, key, element);
-    return () => {
-      if (this.scrollElements.get(key) === element) {
-        this.scrollElements.delete(key);
-      }
-    };
-  }
-  pushState(state, href) {
-    this.writePageState("push", state, href);
-  }
-  replaceState(state, href) {
-    this.writePageState("replace", state, href);
-  }
-  /** @internal Keep shallow URL-search writes inside the router's history bookkeeping. */
-  writeURLSearch(action, href) {
-    this.writePageState(action, readPageState(), href, false);
-  }
-  async commitNavigation(options) {
-    const historyUrl = resolveFarmNavigationURL(
-      options.pageData.canonicalPath || options.fullPath,
-      window.location.href
-    );
-    historyUrl.hash = options.url.hash;
-    const historyPath = historyUrl.pathname + historyUrl.search + historyUrl.hash;
-    const historyState = createHistoryState(
-      historyPath,
-      options.state,
-      options.replace ? window.history.state : void 0,
-      options.pageData.interception?.from ?? null
-    );
-    const nextHistoryIndex = this.currentHistoryIndex == null ? null : options.replace ? this.currentHistoryIndex : this.currentHistoryIndex + 1;
-    if (nextHistoryIndex != null) {
-      historyState[FARM_HISTORY_INDEX_KEY] = nextHistoryIndex;
-    }
-    if (options.replace) {
-      window.history.replaceState(historyState, "", historyPath);
-    } else {
-      window.history.pushState(historyState, "", historyPath);
-    }
-    this.currentHistoryIndex = nextHistoryIndex;
-    const resolvedHistoryUrl = resolveFarmNavigationURL(historyPath, window.location.href);
-    this.currentHistoryPath = resolvedHistoryUrl.pathname + resolvedHistoryUrl.search;
-    this.currentHistoryHash = resolvedHistoryUrl.hash;
-    this.currentInterceptFrom = historyState[FARM_INTERCEPT_FROM_KEY];
-    notifyRouterHistoryChange();
-    this.updateDocumentMetadata(options.pageData.metadata);
-    _hydrateFarmI18n(options.pageData.i18n);
-    if (this.onNavigate) {
-      await this.onNavigate(options.pageData);
-    }
-    if (options.scroll) {
-      if (options.url.hash) {
-        const element = getHashTargetElement(options.url.hash);
-        if (element) {
-          element.scrollIntoView();
-        }
-      } else {
-        window.scrollTo(0, 0);
-      }
-    } else if (this.options.scrollRestoration) {
-      const restorePath = this.currentHistoryPath ?? options.fullPath;
-      this.restoreWindowScroll(restorePath);
-      this.restoreScrollElements(restorePath);
-    }
-  }
-  async runViewTransition(mode, callback) {
-    if (!mode || typeof document === "undefined") {
-      await callback();
-      return;
-    }
-    const startViewTransition = document.startViewTransition;
-    if (typeof startViewTransition !== "function") {
-      await callback();
-      return;
-    }
-    const transition = startViewTransition.call(document, () => callback());
-    const updateDone = transition?.updateCallbackDone || transition?.ready;
-    if (updateDone && typeof updateDone.then === "function") {
-      await updateDone;
-    }
-    transition?.finished?.catch?.(() => void 0);
-  }
-  /**
-   * Fetch page data from cache or server
-   */
-  async fetchPageData(path, recover = true, interceptFrom, fresh = false, signal) {
-    const cacheKey = getPageDataCacheKey(path, interceptFrom);
-    const cached = fresh ? void 0 : this.cache.get(cacheKey);
-    if (cached && Date.now() - cached.timestamp < this.options.cacheMaxAge) {
-      return cached.data;
-    }
-    const activeLayoutChain = getActiveLayoutChainHeader();
-    const prefetchKey = JSON.stringify([path, interceptFrom, activeLayoutChain]);
-    let generation = this.cacheGeneration;
-    const pending = this.pendingPrefetches.get(prefetchKey);
-    if (pending && recover) {
-      if (fresh) {
-        pending.cacheable = false;
-        pending.resolve(void 0);
-        this.pendingPrefetches.delete(prefetchKey);
-      } else {
-        const cancellation = createClientCancellation(signal);
-        try {
-          const data = await cancellation.run(() => pending.data);
-          cancellation.check();
-          if (data && pending.cacheable && generation === this.cacheGeneration) return data;
-        } finally {
-          cancellation.dispose();
-        }
-      }
-    }
-    generation = this.cacheGeneration;
-    let prefetch;
-    if (!recover) {
-      let resolve;
-      const data = new Promise((done) => {
-        resolve = done;
-      });
-      prefetch = { data, resolve, cacheable: true };
-      this.pendingPrefetches.set(prefetchKey, prefetch);
-    }
-    const cacheData = /* @__PURE__ */ __name((data) => {
-      if (!this.destroyed && generation === this.cacheGeneration && prefetch?.cacheable !== false) {
-        this.cachePageData(cacheKey, data);
-      }
-    }, "cacheData");
-    try {
-      return await this.requestPageData(
-        path,
-        recover,
-        interceptFrom,
-        activeLayoutChain,
-        signal,
-        cacheData,
-        prefetch?.resolve
-      );
-    } finally {
-      prefetch?.resolve(void 0);
-      if (prefetch && this.pendingPrefetches.get(prefetchKey) === prefetch) {
-        this.pendingPrefetches.delete(prefetchKey);
-      }
-    }
-  }
-  async requestPageData(path, recover, interceptFrom, activeLayoutChain, signal, cacheData, resolvePrefetch) {
-    const response = await fetch(`/__farm/page-data?path=${encodeURIComponent(path)}`, {
-      signal,
-      headers: createFarmDeploymentRequestHeaders(this.options.deploymentId, {
-        Accept: "application/x-farm-deferred+json, application/json",
-        "X-Farm-SPA": "1",
-        ...activeLayoutChain ? { "X-Farm-Layout-Chain": activeLayoutChain } : {},
-        ...interceptFrom ? { "X-Farm-Intercept-From": interceptFrom } : {}
-      })
-    });
-    if (isFarmDeploymentMismatchResponse(response, this.options.deploymentId)) {
-      const error = createFarmDeploymentMismatchError(
-        response,
-        this.options.deploymentId || "unknown"
-      );
-      dispatchDeploymentMismatch(error);
-      if (recover) {
-        window.location.assign(path);
-      }
-      throw error;
-    }
-    if (!response.ok) {
-      throw new Error(`Failed to fetch page data: ${response.status}`);
-    }
-    const isDeferredResponse = (response.headers.get("Content-Type") || "").toLowerCase().startsWith("application/x-farm-deferred+json");
-    if (!isDeferredResponse) {
-      const data2 = await readDeferredDataResponse(response);
-      cacheData(data2);
-      resolvePrefetch?.(data2);
-      return data2;
-    }
-    resolvePrefetch?.(void 0);
-    let data;
-    let streamCompleted = false;
-    const markStreamComplete = /* @__PURE__ */ __name(() => {
-      streamCompleted = true;
-      if (data) cacheData(data);
-    }, "markStreamComplete");
-    data = await readDeferredDataResponse(response, {
-      onComplete: markStreamComplete
-    });
-    if (streamCompleted) cacheData(data);
-    return data;
-  }
-  cachePageData(cacheKey, data) {
-    const now = Date.now();
-    for (const [key, entry] of this.cache) {
-      if (now - entry.timestamp >= this.options.cacheMaxAge) this.cache.delete(key);
-    }
-    this.cache.set(cacheKey, { data, timestamp: now });
-  }
-  /**
-   * Put the browser URL back on the rendered page after a blocked pop. When
-   * both entries carry a Farm history index the traversal is reversed
-   * exactly; otherwise the current path is pushed again, which restores the
-   * address bar at the cost of one extra history entry.
-   */
-  revertBlockedPopState(event, from) {
-    const eventIndex = readHistoryIndex(event.state);
-    if (eventIndex != null && this.currentHistoryIndex != null) {
-      const delta = eventIndex - this.currentHistoryIndex;
-      if (delta !== 0) {
-        this.suppressNextPopState = true;
-        window.history.go(-delta);
-        return;
-      }
-    }
-    try {
-      const restoredState = {
-        path: from
-      };
-      if (this.currentHistoryIndex != null && eventIndex != null) {
-        restoredState[FARM_HISTORY_INDEX_KEY] = eventIndex + 1;
-        this.currentHistoryIndex = eventIndex + 1;
-      }
-      window.history.pushState(restoredState, "", from);
-    } catch {
-    }
-  }
-  /**
-   * Handle browser back/forward navigation
-   */
-  async handlePopState(event) {
-    if (document.documentElement.dataset.farmDocsRuntime === "true") return;
-    if (this.suppressNextPopState) {
-      this.suppressNextPopState = false;
-      return;
-    }
-    const path = window.location.pathname + window.location.search;
-    const from = this.currentHistoryPath ?? path;
-    if (path === from && window.location.hash !== this.currentHistoryHash && event.state?.[FARM_INTERCEPT_FROM_KEY] === this.currentInterceptFrom) {
-      this.cancelActiveNavigation();
-      this.currentHistoryHash = window.location.hash;
-      this.currentHistoryIndex = readHistoryIndex(event.state);
-      return;
-    }
-    if (await this.shouldBlockNavigation({
-      from,
-      to: path,
-      action: "pop"
-    })) {
-      this.revertBlockedPopState(event, from);
-      return;
-    }
-    this.currentHistoryPath = path;
-    this.currentHistoryHash = window.location.hash;
-    this.currentInterceptFrom = event.state?.[FARM_INTERCEPT_FROM_KEY];
-    this.currentHistoryIndex = readHistoryIndex(event.state);
-    const navigation = this.startNavigation({
-      from,
-      to: createNavigationLocation(new URL(window.location.href)),
-      action: "pop"
-    });
-    let clientNavigation;
-    try {
-      clientNavigation = await this.clientPlugins?.beginNavigation({
-        from: null,
-        to: window.location.href,
-        action: "pop"
-      });
-      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
-      const interceptFrom = typeof event.state?.[FARM_INTERCEPT_FROM_KEY] === "string" ? event.state[FARM_INTERCEPT_FROM_KEY] : void 0;
-      const pageData = await this.fetchPageData(
-        path,
-        true,
-        interceptFrom,
-        false,
-        navigation.controller.signal
-      );
-      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
-      if (clientNavigation) {
-        await this.clientPlugins?.markNavigationLoaded(clientNavigation, pageData);
-      }
-      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
-      this.updateDocumentMetadata(pageData.metadata);
-      _hydrateFarmI18n(pageData.i18n);
-      if (this.onNavigate) {
-        await this.onNavigate(pageData);
-      }
-      const destinationPath = window.location.pathname + window.location.search;
-      if (window.location.hash) {
-        const target = getHashTargetElement(window.location.hash);
-        if (target) {
-          target.scrollIntoView();
-        } else if (this.options.scrollRestoration) {
-          this.restoreWindowScroll(destinationPath);
-        }
-      } else if (this.options.scrollRestoration) {
-        this.restoreWindowScroll(destinationPath);
-      }
-      if (this.options.scrollRestoration) {
-        this.restoreScrollElements(destinationPath);
-      }
-      if (clientNavigation) {
-        await this.clientPlugins?.resolveNavigation(clientNavigation);
-        void this.clientPlugins?.scheduleNavigationRendered(clientNavigation);
-      }
-      this.finishNavigation(navigation);
-    } catch (error) {
-      if (!this.isCurrentNavigation(navigation, clientNavigation)) return;
-      if (clientNavigation) {
-        await this.clientPlugins?.failNavigation(clientNavigation, error);
-      }
-      this.finishNavigation(navigation);
-      console.error("[Farm.js] Popstate navigation error:", error);
-      window.location.reload();
-    }
-  }
-  /**
-   * Check if URL is cached
-   */
-  isCached(path, interceptFrom) {
-    const cached = this.cache.get(getPageDataCacheKey(path, interceptFrom));
-    return cached !== void 0 && Date.now() - cached.timestamp < this.options.cacheMaxAge;
-  }
-  /**
-   * Check if URL is external
-   */
-  isExternalUrl(href) {
-    return href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//");
-  }
-  async shouldBlockNavigation(context2) {
-    for (const blocker of this.blockers) {
-      if (await blocker(context2)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  evaluateBlockerForUnload(blocker) {
-    const path = window.location.pathname + window.location.search;
-    const result = blocker({ from: path, to: path, action: "replace" });
-    if (result && typeof result !== "boolean") {
-      void result.catch(() => void 0);
-      return true;
-    }
-    return result === true;
-  }
-  shouldBlockUnload() {
-    for (const blocker of this.blockers) {
-      try {
-        if (this.unloadBlockers.get(blocker)?.()) return true;
-      } catch {
-        return true;
-      }
-    }
-    return false;
-  }
-  updateDocumentMetadata(metadata) {
-    applyFarmMetadataToDocument(metadata, window.location.pathname);
-  }
-  startNavigation(options) {
-    this.activeNavigation?.controller.abort("superseded");
-    const navigation = {
-      id: ++this.navigationSequence,
-      controller: new AbortController()
-    };
-    this.activeNavigation = navigation;
-    this.setNavigationState({
-      state: "loading",
-      pending: true,
-      from: options.from,
-      to: options.to,
-      action: options.action,
-      startedAt: Date.now()
-    });
-    return navigation;
-  }
-  isCurrentNavigation(navigation, clientNavigation) {
-    return this.activeNavigation?.id === navigation.id && !navigation.controller.signal.aborted && !clientNavigation?.signal.aborted;
-  }
-  finishNavigation(navigation) {
-    if (this.activeNavigation?.id !== navigation.id) return;
-    this.activeNavigation = void 0;
-    this.setNavigationState(IDLE_NAVIGATION_STATE);
-  }
-  cancelActiveNavigation() {
-    if (!this.activeNavigation) return;
-    this.activeNavigation.controller.abort("superseded");
-    this.activeNavigation = void 0;
-    this.setNavigationState(IDLE_NAVIGATION_STATE);
-  }
-  setNavigationState(state) {
-    this.navigationState = state;
-    for (const listener of this.navigationListeners) {
-      listener(state);
-    }
-  }
-  writePageState(action, state, href, notify = true) {
-    if (typeof window === "undefined") return;
-    const url = href ? resolveFarmNavigationURL(href, window.location.href).toString() : window.location.href;
-    const parsedUrl = new URL(url);
-    const nextPath = parsedUrl.pathname + parsedUrl.search;
-    const historyPath = nextPath + parsedUrl.hash;
-    const nextState = createHistoryState(historyPath, state, window.history.state);
-    if (action === "replace") {
-      window.history.replaceState(nextState, "", url);
-    } else {
-      if (this.currentHistoryIndex != null) {
-        nextState[FARM_HISTORY_INDEX_KEY] = this.currentHistoryIndex + 1;
-      }
-      window.history.pushState(nextState, "", url);
-      this.currentHistoryIndex = this.currentHistoryIndex == null ? null : this.currentHistoryIndex + 1;
-    }
-    this.currentHistoryPath = nextPath;
-    this.currentHistoryHash = parsedUrl.hash;
-    this.currentInterceptFrom = nextState[FARM_INTERCEPT_FROM_KEY];
-    if (notify) notifyHistoryChange("page-state");
-  }
-  /**
-   * Save scroll position for a path
-   */
-  saveScrollPosition(path) {
-    try {
-      sessionStorage.setItem(
-        `farm-scroll-${path}`,
-        JSON.stringify({ x: window.scrollX, y: window.scrollY })
-      );
-      for (const [key, element] of this.scrollElements) {
-        sessionStorage.setItem(
-          getScrollElementStorageKey(path, key),
-          JSON.stringify({ x: element.scrollLeft, y: element.scrollTop })
-        );
-      }
-    } catch {
-    }
-  }
-  /**
-   * Restore the saved window scroll position for a path.
-   */
-  restoreWindowScroll(path) {
-    try {
-      const saved = sessionStorage.getItem(`farm-scroll-${path}`);
-      if (saved) {
-        const { x, y } = JSON.parse(saved);
-        setTimeout(() => window.scrollTo(x, y), 0);
-      }
-    } catch {
-    }
-  }
-  /**
-   * Restore saved scroll positions for every registered scroll element. Keys
-   * are hash-stripped (see getScrollElementStorageKey), so this runs regardless
-   * of whether the destination URL carries a fragment.
-   */
-  restoreScrollElements(path) {
-    try {
-      for (const [key, element] of this.scrollElements) {
-        this.restoreScrollElement(path, key, element);
-      }
-    } catch {
-    }
-  }
-  restoreScrollElement(path, key, element) {
-    try {
-      const saved = sessionStorage.getItem(getScrollElementStorageKey(path, key));
-      if (!saved) return;
-      const { x, y } = JSON.parse(saved);
-      setTimeout(() => {
-        element.scrollLeft = x;
-        element.scrollTop = y;
-      }, 0);
-    } catch {
-    }
-  }
-  /**
-   * Clear the page cache
-   */
-  clearCache() {
-    this.cacheGeneration += 1;
-    this.cache.clear();
-    for (const pending of this.pendingPrefetches.values()) {
-      pending.cacheable = false;
-      pending.resolve(void 0);
-    }
-    this.pendingPrefetches.clear();
-  }
-};
-__name(_SPARouter, "SPARouter");
-var SPARouter = _SPARouter;
-function readBrowserDeploymentId() {
-  if (typeof window === "undefined") return void 0;
-  const runtimeId = window.__FARM_DEPLOYMENT_ID__;
-  if (typeof runtimeId === "string" && runtimeId) return runtimeId;
-  return document.querySelector('meta[name="farm-deployment-id"]')?.content;
-}
-__name(readBrowserDeploymentId, "readBrowserDeploymentId");
-function dispatchDeploymentMismatch(error) {
-  if (typeof window === "undefined" || typeof CustomEvent === "undefined") return;
-  window.dispatchEvent(new CustomEvent("farm:deployment-mismatch", { detail: error }));
-}
-__name(dispatchDeploymentMismatch, "dispatchDeploymentMismatch");
-function getInstalledFarmSPARouter() {
-  if (typeof window === "undefined") return void 0;
-  return window.__FARM_SPA_ROUTER__;
-}
-__name(getInstalledFarmSPARouter, "getInstalledFarmSPARouter");
-function getRouter() {
-  if (typeof window === "undefined") {
-    return new SPARouter();
-  }
-  const installedRouter = getInstalledFarmSPARouter();
-  if (installedRouter) {
-    routerInstance = installedRouter;
-    return installedRouter;
-  }
-  if (!routerInstance) {
-    routerInstance = new SPARouter();
-  }
-  return routerInstance;
-}
-__name(getRouter, "getRouter");
-function readPageState() {
-  if (typeof window === "undefined") return null;
-  const state = window.history.state;
-  if (!state || typeof state !== "object") return null;
-  return state[FARM_PAGE_STATE_KEY] ?? null;
-}
-__name(readPageState, "readPageState");
-function createHistoryState(path, pageState, currentState, interceptFrom) {
-  const base = currentState && typeof currentState === "object" ? { ...currentState } : {};
-  const nextState = {
-    ...base,
-    path,
-    [FARM_PAGE_STATE_KEY]: pageState
-  };
-  if (interceptFrom === null) {
-    delete nextState[FARM_INTERCEPT_FROM_KEY];
-  } else if (interceptFrom) {
-    nextState[FARM_INTERCEPT_FROM_KEY] = interceptFrom;
-  }
-  return nextState;
-}
-__name(createHistoryState, "createHistoryState");
-function getPageDataCacheKey(path, interceptFrom) {
-  return interceptFrom ? `${path}
-intercept:${interceptFrom}` : path;
-}
-__name(getPageDataCacheKey, "getPageDataCacheKey");
-function createNavigationLocation(url) {
-  return {
-    href: url.href,
-    pathname: url.pathname,
-    search: url.search,
-    hash: url.hash
-  };
-}
-__name(createNavigationLocation, "createNavigationLocation");
-function getScrollElementStorageKey(path, key) {
-  return `farm-scroll-${path}:${key}`;
-}
-__name(getScrollElementStorageKey, "getScrollElementStorageKey");
-
-// src/tracing.ts
-var import_api = require("@opentelemetry/api");
-var FARM_TRACER_NAME = "@farm.js/core";
-var ALL_SPAN_KINDS = [
-  "request",
-  "render",
-  "middleware",
-  "api",
-  "integration",
-  "storage",
-  "ppr",
-  "build",
-  "plugin"
-];
-var DEFAULT_IGNORED_PATHS = [
-  "/@vite/",
-  "/@fs/",
-  "/@id/",
-  "/@react-refresh",
-  "/node_modules/",
-  "/__vite",
-  "/.well-known/appspecific/"
-];
-var FARM_REQUEST_METHOD_CONTEXT_KEY = (0, import_api.createContextKey)("@farm.js/core/request-method");
-var TRACING_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/tracing-runtime/v1");
-var runtime = globalThis;
-var tracingState = runtime[TRACING_RUNTIME] ?? (runtime[TRACING_RUNTIME] = normalizeFarmTracingConfig(false));
-function normalizeFarmTracingConfig(config) {
-  if (!config) {
-    return {
-      enabled: false,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  if (config === true) {
-    return {
-      enabled: true,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  return {
-    enabled: config.enabled ?? true,
-    spans: new Set(config.spans ?? ALL_SPAN_KINDS),
-    recordEvents: config.recordEvents ?? true,
-    attributes: { ...config.attributes },
-    ignorePaths: [...DEFAULT_IGNORED_PATHS, ...config.ignorePaths ?? []]
-  };
-}
-__name(normalizeFarmTracingConfig, "normalizeFarmTracingConfig");
-function recordFarmEventTrace(event) {
-  if (!tracingState.enabled) return void 0;
-  const activeContext = import_api.context.active();
-  const activeSpan = import_api.trace.getSpan(activeContext);
-  const traceContext = getSpanTraceContext(activeSpan);
-  if (activeSpan && traceContext) {
-    if (event.type === "route.matched") {
-      const method = activeContext.getValue(FARM_REQUEST_METHOD_CONTEXT_KEY) ?? "HTTP";
-      activeSpan.updateName(`${method} ${event.route}`);
-      activeSpan.setAttribute("http.route", event.route);
-      activeSpan.setAttribute("farm.route", event.route);
-    }
-    if (tracingState.recordEvents) {
-      activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
-    }
-    const error = event.type === "request.error" ? void 0 : getEventError(event);
-    if (error !== void 0) {
-      if (event.type === "render.error") {
-        recordSpanException(activeSpan, error);
-      } else {
-        recordSpanError(activeSpan, error);
-      }
-    }
-  }
-  const completedTraceContext = recordCompletedEventSpan(event, activeContext);
-  return traceContext ?? completedTraceContext;
-}
-__name(recordFarmEventTrace, "recordFarmEventTrace");
-function recordCompletedEventSpan(event, parentContext) {
-  const descriptor = getCompletedSpanDescriptor(event);
-  if (!descriptor || !tracingState.spans.has(descriptor.kind)) return void 0;
-  const tracer = import_api.trace.getTracer(FARM_TRACER_NAME);
-  const span = tracer.startSpan(
-    descriptor.name,
-    {
-      kind: import_api.SpanKind.INTERNAL,
-      startTime: event.timestamp - descriptor.durationMs,
-      attributes: {
-        ...tracingState.attributes,
-        ...toEventAttributes(event),
-        "farm.event.type": event.type
-      }
-    },
-    parentContext
-  );
-  const status = "status" in event && typeof event.status === "number" ? event.status : void 0;
-  if (status !== void 0) setResponseStatus(span, status);
-  const error = getEventError(event);
-  if (error !== void 0) recordSpanError(span, error);
-  const traceContext = getSpanTraceContext(span);
-  span.end(event.timestamp);
-  return traceContext;
-}
-__name(recordCompletedEventSpan, "recordCompletedEventSpan");
-function getCompletedSpanDescriptor(event) {
-  if (!("durationMs" in event) || typeof event.durationMs !== "number") return void 0;
-  switch (event.type) {
-    case "render.complete":
-      return { kind: "render", name: `farm.render ${event.route}`, durationMs: event.durationMs };
-    case "render.stream.shellReady":
-      return {
-        kind: "render",
-        name: `farm.render.shell ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "render.stream.complete":
-      return {
-        kind: "render",
-        name: `farm.render.stream ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "middleware.complete":
-      return {
-        kind: "middleware",
-        name: `farm.middleware ${event.name ?? event.route ?? "anonymous"}`,
-        durationMs: event.durationMs
-      };
-    case "api.request.complete":
-    case "api.error":
-      return {
-        kind: "api",
-        name: `farm.api ${event.method} ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "integration.api.call.complete":
-      return {
-        kind: "integration",
-        name: `farm.integration ${event.integration}.${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "storage.query.complete":
-      return {
-        kind: "storage",
-        name: `farm.storage ${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "ppr.refresh.complete":
-      return {
-        kind: "ppr",
-        name: `farm.ppr.refresh ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "build.complete":
-      return {
-        kind: "build",
-        name: `farm.build${event.target ? ` ${event.target}` : ""}`,
-        durationMs: event.durationMs
-      };
-    case "plugin.hook.complete":
-      return {
-        kind: "plugin",
-        name: `farm.plugin ${event.plugin}.${event.hook}`,
-        durationMs: event.durationMs
-      };
-    default:
-      return void 0;
-  }
-}
-__name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
-function hashFarmCacheKey(value) {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index++) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-__name(hashFarmCacheKey, "hashFarmCacheKey");
-function toEventAttributes(event) {
-  const attributes = {};
-  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
-  for (const [key, value] of Object.entries(event)) {
-    if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
-      continue;
-    }
-    if (redactKey && key === "key" && typeof value === "string") {
-      attributes["farm.key_hash"] = hashFarmCacheKey(value);
-      continue;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      attributes[`farm.${key}`] = value;
-    } else if (Array.isArray(value)) {
-      if (value.every((entry) => typeof entry === "string")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "number")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "boolean")) {
-        attributes[`farm.${key}`] = value;
-      }
-    }
-  }
-  return attributes;
-}
-__name(toEventAttributes, "toEventAttributes");
-function getEventError(event) {
-  return "error" in event ? event.error : void 0;
-}
-__name(getEventError, "getEventError");
-function recordSpanException(span, error) {
-  const normalized = error instanceof Error ? error : new Error(String(error));
-  span.recordException(normalized);
-  return normalized;
-}
-__name(recordSpanException, "recordSpanException");
-function recordSpanError(span, error) {
-  const normalized = recordSpanException(span, error);
-  span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: normalized.message });
-}
-__name(recordSpanError, "recordSpanError");
-function setResponseStatus(span, status) {
-  span.setAttribute("http.response.status_code", status);
-  if (status >= 500) {
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR });
-  }
-}
-__name(setResponseStatus, "setResponseStatus");
-function getSpanTraceContext(span) {
-  if (!span) return void 0;
-  const spanContext = span.spanContext();
-  if (!(0, import_api.isSpanContextValid)(spanContext)) return void 0;
-  return {
-    traceId: spanContext.traceId,
-    spanId: spanContext.spanId,
-    traceSampled: (spanContext.traceFlags & 1) === 1
-  };
-}
-__name(getSpanTraceContext, "getSpanTraceContext");
-
-// src/observability.ts
-var OBSERVABILITY_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/observability-runtime/v1");
-var runtime2 = globalThis;
-var shared = runtime2[OBSERVABILITY_RUNTIME] ?? (runtime2[OBSERVABILITY_RUNTIME] = {
-  handlers: /* @__PURE__ */ new Set(),
-  unfilteredHandlers: /* @__PURE__ */ new Set(),
-  config: { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) }
-});
-var runtimeHandlers = shared.handlers;
-var unfilteredRuntimeHandlers = shared.unfilteredHandlers;
-var observabilityState = shared.config;
-function emitFarmEvent(input) {
-  const event = {
-    timestamp: Date.now(),
-    level: inferFarmEventLevel(input.type),
-    ...input
-  };
-  const traceContext = recordFarmEventTrace(event);
-  if (traceContext) {
-    event.traceId = traceContext.traceId;
-    event.spanId = traceContext.spanId;
-    event.traceSampled = traceContext.traceSampled;
-  }
-  notifyFarmEventHandlers(event, unfilteredRuntimeHandlers);
-  if (!shouldEmitFarmEvent(event)) return event;
-  if (observabilityState.logs) {
-    logFarmEvent(event);
-  }
-  notifyFarmEventHandlers(event, [...observabilityState.handlers, ...runtimeHandlers]);
-  return event;
-}
-__name(emitFarmEvent, "emitFarmEvent");
-function notifyFarmEventHandlers(event, handlers) {
-  for (const handler of handlers) {
-    try {
-      Promise.resolve(handler(event)).catch((error) => {
-        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-      });
-    } catch (error) {
-      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-    }
-  }
-}
-__name(notifyFarmEventHandlers, "notifyFarmEventHandlers");
-function shouldEmitFarmEvent(event) {
-  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
-    return false;
-  }
-  if (observabilityState.events && !observabilityState.events.has(event.type)) {
-    return false;
-  }
-  return true;
-}
-__name(shouldEmitFarmEvent, "shouldEmitFarmEvent");
-function inferFarmEventLevel(type) {
-  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
-    return "error";
-  }
-  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
-    return "warn";
-  }
-  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
-    return "debug";
-  }
-  return "info";
-}
-__name(inferFarmEventLevel, "inferFarmEventLevel");
-function logFarmEvent(event) {
-  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
-  switch (event.level) {
-    case "error":
-      console.error(message);
-      break;
-    case "warn":
-      console.warn(message);
-      break;
-    default:
-      console.log(message);
-      break;
-  }
-}
-__name(logFarmEvent, "logFarmEvent");
-function formatFarmEventDetails(event) {
-  const details = [];
-  const record = event;
-  for (const key of [
-    "route",
-    "pathname",
-    "method",
-    "status",
-    "key",
-    "tag",
-    "path",
-    "reason",
-    "durationMs",
-    "integration",
-    "server",
-    "tool",
-    "outcome",
-    "operation",
-    "plugin",
-    "hook",
-    "target",
-    "count"
-  ]) {
-    const value = record[key];
-    if (value !== void 0) {
-      details.push(`${key}=${formatDetailValue(value)}`);
-    }
-  }
-  return details.length > 0 ? ` ${details.join(" ")}` : "";
-}
-__name(formatFarmEventDetails, "formatFarmEventDetails");
-function formatDetailValue(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-__name(formatDetailValue, "formatDetailValue");
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-__name(formatError, "formatError");
-
-// src/cache-invalidation.ts
-var FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationState");
-var globalState = globalThis;
-function getFarmCacheInvalidationState() {
-  return globalState[FARM_CACHE_INVALIDATION_STATE] ?? (globalState[FARM_CACHE_INVALIDATION_STATE] = {
-    listeners: /* @__PURE__ */ new Set(),
-    taskListeners: /* @__PURE__ */ new Set()
-  });
-}
-__name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
-function subscribeFarmCacheInvalidation(listener) {
-  const state = getFarmCacheInvalidationState();
-  state.listeners.add(listener);
-  return () => state.listeners.delete(listener);
-}
-__name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
-
-// src/cache-invalidation-stream.ts
-var MAX_BUFFERED_BYTES = 64 * 1024;
-var textEncoder = new TextEncoder();
-
-// src/cache.ts
-var _FarmDataCache = class _FarmDataCache {
-  constructor(config = {}) {
-    this.entries = /* @__PURE__ */ new Map();
-    this.inflight = /* @__PURE__ */ new Map();
-    /** Local entries by tag, so tag counts and pruning never scan unrelated entries. */
-    this.entriesByTag = /* @__PURE__ */ new Map();
-    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
-    this.activeGenerations = /* @__PURE__ */ new Set();
-    this.version = 0;
-    this.generation = 0;
-    this.namespace = "farm";
-    this.local = true;
-    this.maxEntries = 1024;
-    this.lease = {
-      enabled: true,
-      ttlMs: 1e4,
-      waitTimeoutMs: 1e4,
-      pollIntervalMs: 25
-    };
-    this.configure(config);
-  }
-  configure(config = {}) {
-    this.generation++;
-    this.entries.clear();
-    this.entriesByTag.clear();
-    this.inflight.clear();
-    this.invalidatedTagVersions.clear();
-    this.activeGenerations.clear();
-    this.version = 0;
-    this.adapter = config.adapter;
-    this.namespace = normalizeCacheNamespace(config.namespace || "farm");
-    this.local = !config.adapter;
-    this.maxEntries = normalizePositiveInteger(config.maxEntries, 1024, "cache.maxEntries");
-    this.lease = config.lease === false ? { ...this.lease, enabled: false } : {
-      enabled: true,
-      ttlMs: normalizePositiveDuration(config.lease?.ttlMs, 1e4, "cache.lease.ttlMs"),
-      waitTimeoutMs: normalizePositiveDuration(
-        config.lease?.waitTimeoutMs,
-        1e4,
-        "cache.lease.waitTimeoutMs"
-      ),
-      pollIntervalMs: normalizePositiveDuration(
-        config.lease?.pollIntervalMs,
-        25,
-        "cache.lease.pollIntervalMs"
-      )
-    };
-  }
-  get adapterName() {
-    return this.adapter?.name || (this.adapter ? "custom" : "memory");
-  }
-  get hasAdapter() {
-    return this.adapter !== void 0;
-  }
-  get size() {
-    return this.entries.size;
-  }
-  get(key, options = {}) {
-    return this.getEntry(key, options)?.value;
-  }
-  getEntry(key, options = {}) {
-    const entry = this.entries.get(key);
-    if (!entry) {
-      emitFarmEvent({ type: "cache.miss", key });
-      return void 0;
-    }
-    const stale = this.isStale(entry, options.now);
-    if (stale) {
-      emitFarmEvent({
-        type: "cache.stale",
-        key,
-        tags: Array.from(entry.tags),
-        revalidate: entry.revalidate
-      });
-    }
-    if (!options.allowStale && stale) {
-      emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-      return void 0;
-    }
-    this.touchEntry(key, entry);
-    emitFarmEvent({
-      type: "cache.hit",
-      key,
-      tags: Array.from(entry.tags),
-      revalidate: entry.revalidate,
-      stale
-    });
-    return this.toPublicEntry(entry);
-  }
-  async getEntryAsync(key, options = {}) {
-    if (this.local) {
-      const localEntry = this.getEntry(key, options);
-      if (localEntry) return localEntry;
-    }
-    if (!this.adapter) {
-      return this.local ? void 0 : this.getEntry(key, options);
-    }
-    const generation = this.generation;
-    const adapter = this.adapter;
-    const namespace = this.namespace;
-    const entry = await adapter.get(`${namespace}:entry:${key}`);
-    if (generation !== this.generation) return void 0;
-    if (!entry) {
-      emitFarmEvent({ type: "cache.miss", key });
-      return void 0;
-    }
-    assertFarmCacheEntry(entry, key);
-    const stale = await this.isAdapterEntryStale(entry, options.now, adapter, namespace);
-    if (generation !== this.generation) return void 0;
-    if (stale) {
-      emitFarmEvent({
-        type: "cache.stale",
-        key,
-        tags: [...entry.tags],
-        revalidate: entry.revalidate
-      });
-      if (!options.allowStale) {
-        emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-        return void 0;
-      }
-    }
-    emitFarmEvent({
-      type: "cache.hit",
-      key,
-      tags: [...entry.tags],
-      revalidate: entry.revalidate,
-      stale
-    });
-    if (this.local && !stale) {
-      this.hydrateLocalEntry(entry);
-    }
-    return { ...entry, key };
-  }
-  set(key, value, options = {}) {
-    const revalidate = normalizeRevalidate(options.revalidate);
-    const tags = /* @__PURE__ */ new Set();
-    for (const tag of options.tags ?? []) {
-      tags.add(normalizeCacheTag(tag));
-    }
-    for (const routePath of options.paths ?? []) {
-      tags.add(createPathCacheTag(routePath));
-    }
-    const entry = {
-      key,
-      value,
-      tags,
-      tagVersions: void 0,
-      createdAt: options.createdAt ?? Date.now(),
-      createdVersion: ++this.version,
-      revalidate
-    };
-    this.storeLocalEntry(entry);
-    emitFarmEvent({
-      type: "cache.set",
-      key,
-      tags: Array.from(tags),
-      revalidate: entry.revalidate
-    });
-    return this.toPublicEntry(entry);
-  }
-  async setAsync(key, value, options = {}, tagVersions) {
-    return this.writeAsync(key, value, options, tagVersions);
-  }
-  async writeAsync(key, value, options, tagVersions, createdVersion) {
-    const revalidate = normalizeRevalidate(options.revalidate);
-    const tags = normalizeCacheOptionsTags(options);
-    const capturedVersions = tagVersions ?? await this.getAdapterTagVersions(Array.from(tags.values()));
-    const entry = {
-      key,
-      value,
-      tags: Array.from(tags),
-      tagVersions: capturedVersions,
-      createdAt: options.createdAt ?? Date.now(),
-      createdVersion: createdVersion ?? ++this.version,
-      revalidate
-    };
-    if (this.local) {
-      this.hydrateLocalEntry(entry);
-    }
-    if (this.adapter) {
-      await this.adapter.set(this.createAdapterKey(key), entry);
-    }
-    emitFarmEvent({
-      type: "cache.set",
-      key,
-      tags: [...entry.tags],
-      revalidate: entry.revalidate
-    });
-    return entry;
-  }
-  delete(key) {
-    const deleted = this.deleteLocalEntry(key);
-    emitFarmEvent({ type: "cache.delete", key, deleted });
-    return deleted;
-  }
-  async deleteAsync(key) {
-    const deleted = this.deleteLocalEntry(key);
-    if (this.adapter) {
-      await this.adapter.delete(this.createAdapterKey(key));
-    }
-    emitFarmEvent({ type: "cache.delete", key, deleted: this.adapter ? true : deleted });
-    return this.adapter ? true : deleted;
-  }
-  clear() {
-    const count = this.entries.size;
-    this.generation++;
-    this.entries.clear();
-    this.entriesByTag.clear();
-    this.inflight.clear();
-    this.invalidatedTagVersions.clear();
-    this.activeGenerations.clear();
-    this.version = 0;
-    emitFarmEvent({ type: "cache.clear", count });
-  }
-  async clearAsync() {
-    this.clear();
-    await this.adapter?.clear?.();
-  }
-  isStale(entry, now = Date.now()) {
-    if (typeof entry.revalidate === "number" && entry.revalidate >= 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
-      return true;
-    }
-    for (const tag of entry.tags) {
-      const invalidatedVersion = this.invalidatedTagVersions.get(normalizeCacheTag(tag));
-      if (typeof invalidatedVersion === "number" && typeof entry.createdVersion === "number" && invalidatedVersion > entry.createdVersion) {
-        return true;
-      }
-    }
-    return false;
-  }
-  async isStaleAsync(entry, now = Date.now()) {
-    if (this.adapter) {
-      return this.isAdapterEntryStale(entry, now);
-    }
-    return this.isStale(entry, now);
-  }
-  revalidateTag(tag, options = {}) {
-    const normalized = normalizeCacheTag(tag);
-    const count = this.invalidateTag(normalized);
-    emitFarmEvent(
-      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
-    );
-    return count;
-  }
-  async revalidateTagAsync(tag, options = {}) {
-    const normalized = normalizeCacheTag(tag);
-    const count = this.invalidateTag(normalized);
-    await this.adapter?.invalidateTags?.([this.createAdapterTag(normalized)]);
-    emitFarmEvent(
-      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
-    );
-    return count;
-  }
-  revalidatePath(routePath) {
-    const normalizedPath = normalizeRevalidatePath(routePath);
-    const pathTag = createPathCacheTag(normalizedPath);
-    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
-    const count = this.invalidateTag(pathTag);
-    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
-    if (pprCount > 0) {
-      emitFarmEvent({
-        type: "ppr.shell.invalidated",
-        route: normalizedPath,
-        reason: "revalidatePath",
-        count: pprCount
-      });
-    }
-    return count;
-  }
-  async revalidatePathAsync(routePath) {
-    const normalizedPath = normalizeRevalidatePath(routePath);
-    const pathTag = createPathCacheTag(normalizedPath);
-    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
-    const count = this.invalidateTag(pathTag);
-    await this.adapter?.invalidateTags?.([this.createAdapterTag(pathTag)]);
-    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
-    if (pprCount > 0) {
-      emitFarmEvent({
-        type: "ppr.shell.invalidated",
-        route: normalizedPath,
-        reason: "revalidatePath",
-        count: pprCount
-      });
-    }
-    return count;
-  }
-  async getOrSet(key, producer, options = {}) {
-    normalizeRevalidate(options.revalidate);
-    const cached = await this.getEntryAsync(key);
-    if (cached) {
-      return cached.value;
-    }
-    const inflight = this.inflight.get(key);
-    if (inflight && !this.wasInvalidatedSince(inflight.tags, inflight.startVersion)) {
-      emitFarmEvent({ type: "cache.dedupe", key });
-      return inflight.promise;
-    }
-    const tags = Array.from(normalizeCacheOptionsTags(options));
-    const generation = this.generation;
-    const startVersion = this.version;
-    const promise = this.fillCacheEntry(key, producer, options, tags, generation).catch((error) => {
-      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
-      throw error;
-    }).finally(() => {
-      if (this.inflight.get(key)?.promise === promise) {
-        this.inflight.delete(key);
-      }
-    });
-    this.inflight.set(key, { promise, tags, startVersion });
-    return promise;
-  }
-  /** A fill that started before one of its tags was invalidated cannot satisfy later readers. */
-  wasInvalidatedSince(tags, version) {
-    for (const tag of tags) {
-      const invalidatedVersion = this.invalidatedTagVersions.get(tag);
-      if (invalidatedVersion !== void 0 && invalidatedVersion > version) return true;
-    }
-    return false;
-  }
-  async fillCacheEntry(key, producer, options, tags, generation) {
-    const adapter = this.adapter;
-    const namespace = this.namespace;
-    const lease = { ...this.lease };
-    const leaseKey = `${namespace}:lease:${key}`;
-    let leaseToken;
-    if (adapter?.acquireLease && adapter.releaseLease && lease.enabled) {
-      leaseToken = await adapter.acquireLease(leaseKey, lease.ttlMs);
-      if (!leaseToken) {
-        const shared2 = await this.waitForAdapterEntry(
-          key,
-          adapter,
-          namespace,
-          lease,
-          generation
-        );
-        if (shared2) {
-          emitFarmEvent({ type: "cache.dedupe", key });
-          return shared2.value;
-        }
-        if (generation === this.generation) {
-          leaseToken = await adapter.acquireLease(leaseKey, lease.ttlMs);
-        }
-      }
-    }
-    const initialCreatedVersion = this.version;
-    const activeGeneration = {
-      tags: new Set(tags),
-      createdVersion: initialCreatedVersion
-    };
-    this.activeGenerations.add(activeGeneration);
-    try {
-      const initialTagVersions = await this.getAdapterTagVersions(tags, adapter, namespace);
-      const value = await producer();
-      if (generation === this.generation) {
-        await this.writeAsync(key, value, options, initialTagVersions, initialCreatedVersion);
-      }
-      return value;
-    } finally {
-      this.activeGenerations.delete(activeGeneration);
-      this.pruneInvalidatedTagVersions(activeGeneration.tags);
-      if (leaseToken && adapter?.releaseLease) {
-        try {
-          await adapter.releaseLease(leaseKey, leaseToken);
-        } catch (error) {
-          emitFarmEvent({ type: "cache.error", key, operation: "set", error });
-        }
-      }
-    }
-  }
-  async waitForAdapterEntry(key, adapter, namespace, lease, generation) {
-    const deadline = Date.now() + lease.waitTimeoutMs;
-    while (Date.now() < deadline) {
-      await delay(lease.pollIntervalMs);
-      if (generation !== this.generation) return void 0;
-      const entry = await adapter.get(`${namespace}:entry:${key}`);
-      if (generation !== this.generation) return void 0;
-      if (!entry) {
-        emitFarmEvent({ type: "cache.miss", key });
-        continue;
-      }
-      assertFarmCacheEntry(entry, key);
-      const stale = await this.isAdapterEntryStale(entry, Date.now(), adapter, namespace);
-      if (generation !== this.generation) return void 0;
-      if (stale) {
-        emitFarmEvent({
-          type: "cache.stale",
-          key,
-          tags: [...entry.tags],
-          revalidate: entry.revalidate
-        });
-        emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-      } else {
-        emitFarmEvent({
-          type: "cache.hit",
-          key,
-          tags: [...entry.tags],
-          revalidate: entry.revalidate,
-          stale: false
-        });
-        return { ...entry, key };
-      }
-    }
-    return void 0;
-  }
-  countEntriesForTags(tags) {
-    let count = 0;
-    for (const entry of this.entriesByTag.get(tags[0]) ?? []) {
-      if (tags.every((tag) => entry.tags.has(tag))) {
-        count++;
-      }
-    }
-    return count;
-  }
-  invalidateTag(normalizedTag) {
-    const count = this.entriesByTag.get(normalizedTag)?.size ?? 0;
-    this.invalidatedTagVersions.delete(normalizedTag);
-    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
-    this.pruneInvalidatedTagVersions([normalizedTag]);
-    return count;
-  }
-  toPublicEntry(entry) {
-    return {
-      key: entry.key,
-      value: entry.value,
-      tags: Array.from(entry.tags),
-      tagVersions: entry.tagVersions,
-      createdAt: entry.createdAt,
-      createdVersion: entry.createdVersion,
-      revalidate: entry.revalidate
-    };
-  }
-  hydrateLocalEntry(entry) {
-    this.storeLocalEntry({
-      key: entry.key,
-      value: entry.value,
-      tags: new Set(entry.tags.map(normalizeCacheTag)),
-      tagVersions: entry.tagVersions,
-      createdAt: entry.createdAt,
-      createdVersion: entry.createdVersion ?? ++this.version,
-      revalidate: normalizeRevalidate(entry.revalidate)
-    });
-  }
-  touchEntry(key, entry) {
-    this.entries.delete(key);
-    this.entries.set(key, entry);
-  }
-  storeLocalEntry(entry) {
-    const removed = [];
-    const replaced = this.detachLocalEntry(entry.key);
-    if (replaced) removed.push(replaced);
-    this.entries.set(entry.key, entry);
-    for (const tag of entry.tags) {
-      let tagged = this.entriesByTag.get(tag);
-      if (!tagged) this.entriesByTag.set(tag, tagged = /* @__PURE__ */ new Set());
-      tagged.add(entry);
-    }
-    while (this.entries.size > this.maxEntries) {
-      const oldestKey = this.entries.keys().next().value;
-      if (oldestKey === void 0) break;
-      removed.push(this.detachLocalEntry(oldestKey));
-    }
-    for (const removedEntry of removed) this.pruneInvalidatedTagVersions(removedEntry.tags);
-  }
-  deleteLocalEntry(key) {
-    const entry = this.detachLocalEntry(key);
-    if (!entry) return false;
-    this.pruneInvalidatedTagVersions(entry.tags);
-    return true;
-  }
-  detachLocalEntry(key) {
-    const entry = this.entries.get(key);
-    if (!entry) return void 0;
-    this.entries.delete(key);
-    for (const tag of entry.tags) {
-      const tagged = this.entriesByTag.get(tag);
-      if (!tagged) continue;
-      tagged.delete(entry);
-      if (tagged.size === 0) this.entriesByTag.delete(tag);
-    }
-    return entry;
-  }
-  /**
-   * Drop invalidation versions that no local entry or active fill can be stale against.
-   * Callers pass only the tags whose dependents just changed, so the cost is bounded by
-   * the entries sharing those tags rather than by the whole cache.
-   */
-  pruneInvalidatedTagVersions(tags) {
-    tags: for (const tag of tags) {
-      const invalidatedVersion = this.invalidatedTagVersions.get(tag);
-      if (invalidatedVersion === void 0) continue;
-      for (const entry of this.entriesByTag.get(tag) ?? []) {
-        if (entry.createdVersion < invalidatedVersion) continue tags;
-      }
-      for (const generation of this.activeGenerations) {
-        if (generation.tags.has(tag) && generation.createdVersion < invalidatedVersion)
-          continue tags;
-      }
-      this.invalidatedTagVersions.delete(tag);
-    }
-  }
-  createAdapterKey(key) {
-    return `${this.namespace}:entry:${key}`;
-  }
-  createAdapterTag(tag) {
-    return `${this.namespace}:tag:${tag}`;
-  }
-  async getAdapterTagVersions(tags, adapter = this.adapter, namespace = this.namespace) {
-    if (!adapter?.getTagVersions || tags.length === 0) return {};
-    const normalized = tags.map(normalizeCacheTag);
-    const physicalTags = normalized.map((tag) => `${namespace}:tag:${tag}`);
-    const versions = await adapter.getTagVersions(physicalTags);
-    return Object.fromEntries(
-      normalized.map((tag, index) => [
-        tag,
-        normalizeAdapterVersion(versions[physicalTags[index]])
-      ])
-    );
-  }
-  async isAdapterEntryStale(entry, now = Date.now(), adapter = this.adapter, namespace = this.namespace) {
-    if (typeof entry.revalidate === "number" && entry.revalidate >= 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
-      return true;
-    }
-    const currentVersions = await this.getAdapterTagVersions(entry.tags, adapter, namespace);
-    for (const tag of entry.tags) {
-      if (normalizeAdapterVersion(currentVersions[tag]) > normalizeAdapterVersion(entry.tagVersions?.[tag])) {
-        return true;
-      }
-    }
-    return false;
-  }
-};
-__name(_FarmDataCache, "FarmDataCache");
-var FarmDataCache = _FarmDataCache;
-var FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
-var farmDataCacheGlobal = globalThis;
-var sharedFarmDataCache = farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] ?? (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] = new FarmDataCache());
-function createPathCacheTag(routePath) {
-  return `path:${normalizeRevalidatePath(routePath)}`;
-}
-__name(createPathCacheTag, "createPathCacheTag");
-function normalizeRevalidatePath(routePath) {
-  if (typeof routePath !== "string") {
-    throw new TypeError("revalidatePath expects a path string.");
-  }
-  let normalized = routePath.trim();
-  if (!normalized) {
-    throw new Error("revalidatePath expects a non-empty path.");
-  }
-  try {
-    if (/^https?:\/\//i.test(normalized)) {
-      normalized = new URL(normalized).pathname;
-    }
-  } catch {
-  }
-  normalized = normalized.split(/[?#]/, 1)[0] ?? normalized;
-  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
-  normalized = normalized.replace(/\/{2,}/g, "/");
-  normalized = new URL(normalized, "http://farm.invalid").pathname;
-  if (normalized.length > 1) {
-    normalized = normalized.replace(/\/+$/, "");
-  }
-  return normalized || "/";
-}
-__name(normalizeRevalidatePath, "normalizeRevalidatePath");
-function createFarmCacheKey(parts) {
-  return stableSerialize(parts);
-}
-__name(createFarmCacheKey, "createFarmCacheKey");
-function normalizeRevalidate(revalidate) {
-  if (revalidate === false || revalidate === void 0) {
-    return revalidate;
-  }
-  if (!Number.isFinite(revalidate) || revalidate < 0) {
-    throw new TypeError("Cache revalidate must be false or a finite, non-negative number.");
-  }
-  return revalidate;
-}
-__name(normalizeRevalidate, "normalizeRevalidate");
-function normalizeCacheTag(tag) {
-  if (typeof tag !== "string") {
-    throw new TypeError("Cache tags must be strings.");
-  }
-  const normalized = tag.trim();
-  if (!normalized) {
-    throw new Error("Cache tags cannot be empty.");
-  }
-  return normalized;
-}
-__name(normalizeCacheTag, "normalizeCacheTag");
-function normalizeCacheNamespace(namespace) {
-  if (typeof namespace !== "string") {
-    throw new TypeError("Cache namespace must be a string.");
-  }
-  const normalized = namespace.trim().replace(/:+$/g, "");
-  if (!normalized) {
-    throw new Error("Cache namespace cannot be empty.");
-  }
-  return normalized;
-}
-__name(normalizeCacheNamespace, "normalizeCacheNamespace");
-function normalizeAdapterVersion(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
-}
-__name(normalizeAdapterVersion, "normalizeAdapterVersion");
-function normalizePositiveDuration(value, fallback, name) {
-  if (value === void 0) return fallback;
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new TypeError(`${name} must be a positive number of milliseconds.`);
-  }
-  return Math.floor(value);
-}
-__name(normalizePositiveDuration, "normalizePositiveDuration");
-function normalizePositiveInteger(value, fallback, name) {
-  if (value === void 0) return fallback;
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new TypeError(`${name} must be a positive integer.`);
-  }
-  return value;
-}
-__name(normalizePositiveInteger, "normalizePositiveInteger");
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-__name(delay, "delay");
-function normalizeCacheOptionsTags(options) {
-  const tags = /* @__PURE__ */ new Set();
-  for (const tag of options.tags ?? []) {
-    tags.add(normalizeCacheTag(tag));
-  }
-  for (const routePath of options.paths ?? []) {
-    tags.add(createPathCacheTag(routePath));
-  }
-  return tags;
-}
-__name(normalizeCacheOptionsTags, "normalizeCacheOptionsTags");
-function assertFarmCacheEntry(entry, expectedKey) {
-  if (!entry || typeof entry !== "object" || entry.key !== expectedKey || !Array.isArray(entry.tags) || typeof entry.createdAt !== "number") {
-    throw new TypeError(
-      `Cache adapter returned an invalid entry for ${JSON.stringify(expectedKey)}.`
-    );
-  }
-}
-__name(assertFarmCacheEntry, "assertFarmCacheEntry");
-function getFunctionCacheIdentity(fn) {
-  const name = fn.name || "anonymous";
-  return `${name}:${hashFunctionSource(String(fn))}`;
-}
-__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
-function hashFunctionSource(source) {
-  let hash = 2166136261;
-  for (let index = 0; index < source.length; index++) {
-    hash ^= source.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36);
-}
-__name(hashFunctionSource, "hashFunctionSource");
-function compareCodepoint(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-__name(compareCodepoint, "compareCodepoint");
-function serializeBinaryBytes(bytes) {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-__name(serializeBinaryBytes, "serializeBinaryBytes");
-function serializeCanonicalStringEntries(entries, seen) {
-  const valuesByKey = /* @__PURE__ */ new Map();
-  for (const [key, item] of entries) {
-    const values = valuesByKey.get(key);
-    if (values) values.push(item);
-    else valuesByKey.set(key, [item]);
-  }
-  return Array.from(valuesByKey.keys()).sort(compareCodepoint).flatMap(
-    (key) => valuesByKey.get(key).map((item) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`)
-  ).join(",");
-}
-__name(serializeCanonicalStringEntries, "serializeCanonicalStringEntries");
-function isPlainCacheKeyObject(value) {
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype === null) return true;
-  const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
-  return Object.getPrototypeOf(prototype) === null && typeof constructor === "function" && constructor.name === "Object";
-}
-__name(isPlainCacheKeyObject, "isPlainCacheKeyObject");
-function getCacheKeyValueType(value) {
-  const prototype = Object.getPrototypeOf(value);
-  const constructor = prototype ? Object.getOwnPropertyDescriptor(prototype, "constructor")?.value : void 0;
-  if (typeof constructor === "function" && constructor.name) {
-    return constructor.name;
-  }
-  return Object.prototype.toString.call(value).slice(8, -1) || "object";
-}
-__name(getCacheKeyValueType, "getCacheKeyValueType");
-function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  const valueType = typeof value;
-  if (valueType === "string") return JSON.stringify(value);
-  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
-    return `${valueType}:${String(value)}`;
-  }
-  if (valueType === "symbol") {
-    return `symbol:${String(value)}`;
-  }
-  if (valueType === "function") {
-    return `function:${getFunctionCacheIdentity(value)}`;
-  }
-  if (value instanceof Date) {
-    return Number.isNaN(value.getTime()) ? "date:invalid" : `date:${value.toISOString()}`;
-  }
-  if (value instanceof URL) {
-    return `url:${value.toString()}`;
-  }
-  if (value instanceof RegExp) {
-    return `regexp:${value.toString()}`;
-  }
-  if (value instanceof ArrayBuffer) {
-    return `arraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
-  }
-  if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
-    return `sharedarraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
-  }
-  if (ArrayBuffer.isView(value)) {
-    const viewType = Object.prototype.toString.call(value).slice(8, -1);
-    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-    return `binary:${viewType}:${serializeBinaryBytes(bytes)}`;
-  }
-  if (value && typeof value === "object") {
-    if (seen.has(value)) {
-      return "[Circular]";
-    }
-    seen.add(value);
-    if (Array.isArray(value)) {
-      const items = [];
-      for (let index = 0; index < value.length; index++) {
-        items.push(
-          Object.prototype.hasOwnProperty.call(value, index) ? stableSerialize(value[index], seen) : "[Hole]"
-        );
-      }
-      seen.delete(value);
-      return `[${items.join(",")}]`;
-    }
-    if (value instanceof Set) {
-      const items = Array.from(value, (item) => stableSerialize(item, seen)).sort(compareCodepoint);
-      seen.delete(value);
-      return `set:[${items.join(",")}]`;
-    }
-    if (value instanceof Map) {
-      const items = Array.from(
-        value,
-        ([key, item]) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`
-      ).sort(compareCodepoint);
-      seen.delete(value);
-      return `map:[${items.join(",")}]`;
-    }
-    if (value instanceof URLSearchParams) {
-      const serialized2 = serializeCanonicalStringEntries(value, seen);
-      seen.delete(value);
-      return `urlsearchparams:[${serialized2}]`;
-    }
-    if (value instanceof Headers) {
-      const serialized2 = serializeCanonicalStringEntries(value, seen);
-      seen.delete(value);
-      return `headers:[${serialized2}]`;
-    }
-    if (!isPlainCacheKeyObject(value)) {
-      throw new TypeError(
-        `Cache keys do not support ${getCacheKeyValueType(value)} values. Convert the value to an explicit stable string or structured key before caching.`
-      );
-    }
-    const entries = Object.entries(value).sort(
-      ([a], [b]) => compareCodepoint(a, b)
-    );
-    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
-    seen.delete(value);
-    return `{${serialized}}`;
-  }
-  return String(value);
-}
-__name(stableSerialize, "stableSerialize");
+"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; }"use client";
 
-// src/client-cache.ts
-var invalidationTrackers = /* @__PURE__ */ new WeakMap();
-function trackFarmClientCacheInvalidations(cache) {
-  let trackers = invalidationTrackers.get(cache);
-  if (!trackers) {
-    trackers = /* @__PURE__ */ new Set();
-    invalidationTrackers.set(cache, trackers);
-  }
-  const keys = /* @__PURE__ */ new Set();
-  trackers.add(keys);
-  return {
-    has(key) {
-      const resolved = cache.resolveKey(key);
-      for (const invalidated of keys) {
-        if (cache.resolveKey(invalidated) === resolved) return true;
-      }
-      return false;
-    },
-    dispose() {
-      if (!trackers.delete(keys)) return;
-      keys.clear();
-      if (trackers.size === 0) invalidationTrackers.delete(cache);
-    }
-  };
-}
-__name(trackFarmClientCacheInvalidations, "trackFarmClientCacheInvalidations");
-var cacheFinalizer = typeof FinalizationRegistry === "function" ? new FinalizationRegistry((unsubscribe) => unsubscribe()) : void 0;
-var DEFAULT_GC_SWEEP_INTERVAL_MS = 3e4;
-var _FarmClientDataCache = class _FarmClientDataCache {
-  constructor(options = {}) {
-    this.entries = /* @__PURE__ */ new Map();
-    this.aliases = /* @__PURE__ */ new Map();
-    this.aliasesByTarget = /* @__PURE__ */ new Map();
-    this.invalidatedAt = /* @__PURE__ */ new Map();
-    this.listeners = /* @__PURE__ */ new Map();
-    this.inflight = /* @__PURE__ */ new Map();
-    this.pendingMetadataSweeps = /* @__PURE__ */ new Set();
-    this.gcSweepIntervalMs = options.gcSweepIntervalMs ?? DEFAULT_GC_SWEEP_INTERVAL_MS;
-    if (options.subscribeToInvalidation !== false) {
-      if (typeof WeakRef === "function") {
-        const reference = new WeakRef(this);
-        const unsubscribe = _FarmClientDataCache.subscribeWeakCache(reference);
-        cacheFinalizer?.register(this, unsubscribe, reference);
-        this.unsubscribeInvalidation = unsubscribe;
-      } else {
-        this.unsubscribeInvalidation = subscribeFarmCacheInvalidation(
-          (key) => this.applyInvalidation(key, Date.now(), false)
-        );
-      }
-    }
-  }
-  // This closure must only capture a weak reference, never the cache itself.
-  static subscribeWeakCache(reference) {
-    const unsubscribe = subscribeFarmCacheInvalidation((key) => {
-      const cache = reference.deref();
-      if (cache) cache.applyInvalidation(key, Date.now(), false);
-      else dispose();
-    });
-    function dispose() {
-      unsubscribe();
-      cacheFinalizer?.unregister(reference);
-    }
-    __name(dispose, "dispose");
-    return dispose;
-  }
-  get size() {
-    return this.entries.size;
-  }
-  /** @internal Attach or detach the persistence engine's observation sink. */
-  attachPersistence(sink) {
-    this.persistence = sink;
-  }
-  resolveKey(key) {
-    let resolved = key;
-    const seen = /* @__PURE__ */ new Set();
-    while (this.aliases.has(resolved) && !seen.has(resolved)) {
-      seen.add(resolved);
-      resolved = this.aliases.get(resolved);
-    }
-    return resolved;
-  }
-  get(key, now = Date.now()) {
-    const resolved = this.resolveKey(key);
-    const entry = this.entries.get(resolved);
-    if (!entry) return void 0;
-    if (entry.gcAt !== void 0 && now >= entry.gcAt) {
-      if (entry.fetching) return void 0;
-      this.entries.delete(resolved);
-      this.persistence?.onDelete(resolved);
-      this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
-      this.emit(resolved);
-      return void 0;
-    }
-    return entry;
-  }
-  set(key, entry) {
-    const resolved = this.resolveKey(key);
-    const invalidatedAt = this.invalidatedAt.get(resolved);
-    const nextEntry = invalidatedAt !== void 0 && invalidatedAt > entry.updatedAt ? { ...entry, staleAt: 0, invalidatedAt } : { ...entry, invalidatedAt: void 0 };
-    if (invalidatedAt === void 0 || entry.updatedAt >= invalidatedAt) {
-      this.invalidatedAt.delete(resolved);
-    }
-    this.entries.set(resolved, nextEntry);
-    this.pendingMetadataSweeps.delete(resolved);
-    if (nextEntry.gcAt !== void 0) this.scheduleGcSweep();
-    this.persistence?.onSet(resolved, nextEntry);
-    this.emit(resolved);
-    return this;
-  }
-  delete(key) {
-    const resolved = this.resolveKey(key);
-    const deleted = this.entries.delete(resolved);
-    this.inflight.delete(resolved);
-    if (deleted) this.persistence?.onDelete(resolved);
-    if (deleted || this.pendingMetadataSweeps.has(resolved)) {
-      this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
-    }
-    this.emit(resolved);
-    return deleted;
-  }
-  clear() {
-    const keys = /* @__PURE__ */ new Set([...this.entries.keys(), ...this.listeners.keys()]);
-    this.entries.clear();
-    this.aliases.clear();
-    this.aliasesByTarget.clear();
-    this.invalidatedAt.clear();
-    this.inflight.clear();
-    this.pendingMetadataSweeps.clear();
-    this.persistence?.onClear();
-    for (const key of keys) this.emit(key);
-  }
-  dispose() {
-    this.unsubscribeInvalidation?.();
-    this.unsubscribeInvalidation = void 0;
-    if (this.gcTimer !== void 0) {
-      clearTimeout(this.gcTimer);
-      this.gcTimer = void 0;
-    }
-    this.clear();
-  }
-  isStale(key, now = Date.now()) {
-    const entry = this.get(key, now);
-    return !entry || entry.invalidatedAt !== void 0 || now >= entry.staleAt;
-  }
-  invalidate(key, now = Date.now()) {
-    this.applyInvalidation(key, now, true);
-  }
-  applyInvalidation(key, now, retainUnowned) {
-    const resolved = this.resolveKey(key);
-    for (const keys of invalidationTrackers.get(this) ?? []) keys.add(resolved);
-    const entry = this.entries.get(resolved);
-    const alreadyRetained = this.invalidatedAt.has(resolved);
-    if (retainUnowned || entry || alreadyRetained || this.hasMetadataOwner(resolved)) {
-      this.invalidatedAt.set(resolved, now);
-      if (!entry && !retainUnowned && !alreadyRetained) this.pendingMetadataSweeps.add(resolved);
-    }
-    if (entry) {
-      this.entries.set(resolved, {
-        ...entry,
-        staleAt: 0,
-        invalidatedAt: now
-      });
-    }
-    this.emit(resolved, "invalidate");
-  }
-  hasMetadataOwner(key) {
-    const related = /* @__PURE__ */ new Set([key]);
-    for (const target of related) {
-      if (this.listeners.has(target) || this.inflight.has(target)) return true;
-      for (const alias of this.aliasesByTarget.get(target) ?? []) related.add(alias);
-    }
-    return false;
-  }
-  alias(alias, key) {
-    const resolved = this.resolveKey(key);
-    if (alias === resolved) return;
-    const aliasEntry = this.entries.get(alias);
-    const aliasInvalidatedAt = this.invalidatedAt.get(alias) ?? aliasEntry?.invalidatedAt;
-    const resolvedInvalidatedAt = this.invalidatedAt.get(resolved);
-    if (aliasEntry && !this.entries.has(resolved)) {
-      this.entries.set(resolved, aliasEntry);
-      this.persistence?.onSet(resolved, aliasEntry);
-    }
-    if (this.entries.delete(alias)) this.persistence?.onDelete(alias);
-    this.invalidatedAt.delete(alias);
-    const invalidatedAt = [aliasInvalidatedAt, resolvedInvalidatedAt].reduce(
-      (latest, value) => value === void 0 ? latest : latest === void 0 ? value : Math.max(latest, value),
-      void 0
-    );
-    const resolvedEntry = this.entries.get(resolved);
-    if (invalidatedAt !== void 0 && (!resolvedEntry || invalidatedAt > resolvedEntry.updatedAt)) {
-      this.invalidatedAt.set(resolved, invalidatedAt);
-      if (resolvedEntry) {
-        this.entries.set(resolved, {
-          ...resolvedEntry,
-          staleAt: 0,
-          invalidatedAt
-        });
-      }
-    } else if (invalidatedAt !== void 0) {
-      this.invalidatedAt.delete(resolved);
-      if (resolvedEntry?.invalidatedAt !== void 0) {
-        this.entries.set(resolved, { ...resolvedEntry, invalidatedAt: void 0 });
-      }
-    }
-    const aliasInflight = this.inflight.get(alias);
-    if (aliasInflight && !this.inflight.has(resolved)) {
-      this.inflight.set(resolved, aliasInflight);
-    }
-    this.inflight.delete(alias);
-    if (this.pendingMetadataSweeps.delete(alias) && !this.entries.has(resolved)) {
-      this.pendingMetadataSweeps.add(resolved);
-    }
-    const previousTarget = this.aliases.get(alias);
-    if (previousTarget !== resolved) {
-      const previousResolved = previousTarget !== void 0 && this.pendingMetadataSweeps.size > 0 ? this.resolveKey(alias) : void 0;
-      this.removeAlias(alias);
-      this.aliases.set(alias, resolved);
-      let aliases = this.aliasesByTarget.get(resolved);
-      if (!aliases) this.aliasesByTarget.set(resolved, aliases = /* @__PURE__ */ new Set());
-      aliases.add(alias);
-      if (previousResolved !== void 0) this.sweepPendingEntryMetadata(previousResolved);
-    }
-    this.emit(alias);
-    this.emit(resolved, this.invalidatedAt.has(resolved) ? "invalidate" : void 0);
-  }
-  subscribe(key, listener) {
-    let listeners2 = this.listeners.get(key);
-    if (!listeners2) {
-      listeners2 = /* @__PURE__ */ new Set();
-      this.listeners.set(key, listeners2);
-    }
-    listeners2.add(listener);
-    return () => {
-      listeners2.delete(listener);
-      if (listeners2.size === 0 && this.listeners.get(key) === listeners2) {
-        this.listeners.delete(key);
-        this.sweepPendingEntryMetadata(key);
-      }
-    };
-  }
-  getInflight(key) {
-    return this.inflight.get(this.resolveKey(key));
-  }
-  setInflight(key, promise) {
-    this.inflight.set(this.resolveKey(key), promise);
-  }
-  deleteInflight(key) {
-    const resolved = this.resolveKey(key);
-    if (this.inflight.delete(resolved)) this.sweepPendingEntryMetadata(resolved);
-  }
-  scheduleGcSweep() {
-    if (this.gcSweepIntervalMs === false || this.gcTimer !== void 0) return;
-    const timer = setTimeout(() => {
-      this.gcTimer = void 0;
-      this.sweepExpiredEntries();
-    }, this.gcSweepIntervalMs);
-    timer.unref?.();
-    this.gcTimer = timer;
-  }
-  sweepExpiredEntries(now = Date.now()) {
-    const watched = /* @__PURE__ */ new Set();
-    for (const key of this.listeners.keys()) watched.add(this.resolveKey(key));
-    let remaining = false;
-    const swept = /* @__PURE__ */ new Set();
-    for (const [key, entry] of this.entries) {
-      if (entry.gcAt === void 0) continue;
-      if (now < entry.gcAt || entry.fetching || this.inflight.has(key) || watched.has(key)) {
-        remaining = true;
-        continue;
-      }
-      this.entries.delete(key);
-      this.persistence?.onDelete(key);
-      swept.add(key);
-    }
-    if (swept.size > 0) this.sweepEntryMetadata(swept);
-    if (remaining) this.scheduleGcSweep();
-  }
-  /**
-   * Entry eviction alone leaves the per-key metadata behind. `invalidatedAt`
-   * marks and provisional aliases are created per query invocation, so with
-   * dynamic keys they accumulate for the lifetime of the page even though the
-   * entries they describe are long gone.
-   */
-  sweepEntryMetadata(swept) {
-    const protectedKeys = /* @__PURE__ */ new Set();
-    for (const key of swept) if (this.hasMetadataOwner(key)) protectedKeys.add(key);
-    for (const key of swept) {
-      if (this.entries.has(key)) {
-        this.pendingMetadataSweeps.delete(key);
-      } else if (protectedKeys.has(key)) {
-        this.pendingMetadataSweeps.add(key);
-      } else {
-        this.pendingMetadataSweeps.delete(key);
-        this.invalidatedAt.delete(key);
-      }
-    }
-    const related = /* @__PURE__ */ new Set();
-    const targets = new Set(swept);
-    for (const target of targets) {
-      for (const alias of this.aliasesByTarget.get(target) ?? []) {
-        related.add(alias);
-        targets.add(alias);
-      }
-    }
-    const removable = [];
-    for (const alias of related) {
-      if (this.entries.has(alias) || this.listeners.has(alias) || this.inflight.has(alias))
-        continue;
-      const resolved = this.resolveKey(alias);
-      if (!swept.has(resolved)) continue;
-      if (this.entries.has(resolved) || protectedKeys.has(resolved)) continue;
-      removable.push(alias);
-    }
-    for (const alias of removable) {
-      this.removeAlias(alias);
-      this.invalidatedAt.delete(alias);
-    }
-  }
-  removeAlias(alias) {
-    const target = this.aliases.get(alias);
-    if (target === void 0) return;
-    this.aliases.delete(alias);
-    const aliases = this.aliasesByTarget.get(target);
-    aliases?.delete(alias);
-    if (aliases?.size === 0) this.aliasesByTarget.delete(target);
-  }
-  sweepPendingEntryMetadata(key) {
-    if (this.pendingMetadataSweeps.size === 0) return;
-    if (key !== void 0) {
-      const resolved = this.resolveKey(key);
-      if (this.pendingMetadataSweeps.has(resolved)) {
-        this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
-      }
-      return;
-    }
-    this.sweepEntryMetadata(new Set(this.pendingMetadataSweeps));
-  }
-  emit(key, event) {
-    this.notifyListeners(key, event);
-    if (this.listeners.size === 0) return;
-    for (const [alias, target] of this.aliases) {
-      if (!this.listeners.has(alias)) continue;
-      if (this.resolveKey(target) === key) {
-        this.notifyListeners(alias, event);
-      }
-    }
-  }
-  notifyListeners(key, event) {
-    for (const listener of this.listeners.get(key) ?? []) {
-      try {
-        listener(event);
-      } catch (error) {
-        const detail = error instanceof Error ? error.stack ?? error.message : String(error);
-        console.warn(`[farm:client-cache] cache listener failed: ${detail}`);
-      }
-    }
-  }
-};
-__name(_FarmClientDataCache, "FarmClientDataCache");
-var FarmClientDataCache = _FarmClientDataCache;
-var FARM_CLIENT_DATA_CACHE = /* @__PURE__ */ Symbol.for("farm.clientDataCache");
-var clientCacheGlobal = globalThis;
-var sharedFarmClientDataCache = clientCacheGlobal[FARM_CLIENT_DATA_CACHE] ?? (clientCacheGlobal[FARM_CLIENT_DATA_CACHE] = new FarmClientDataCache());
-function getFarmClientDataCache() {
-  return sharedFarmClientDataCache;
-}
-__name(getFarmClientDataCache, "getFarmClientDataCache");
 
-// src/client-revalidation.ts
-function attachRevalidationListeners(refresh, options = {}) {
-  if (typeof window === "undefined") return () => {
-  };
-  const onFocus = options.refetchOnWindowFocus === false ? void 0 : refresh;
-  const onOnline = options.refetchOnReconnect === false ? void 0 : refresh;
-  if (onFocus) window.addEventListener("focus", onFocus);
-  if (onOnline) window.addEventListener("online", onOnline);
-  return () => {
-    if (onFocus) window.removeEventListener("focus", onFocus);
-    if (onOnline) window.removeEventListener("online", onOnline);
-  };
-}
-__name(attachRevalidationListeners, "attachRevalidationListeners");
+var _chunkDYEJQTDNcjs = require('./chunk-DYEJQTDN.cjs');
 
-// src/server-query-runtime.ts
-var FARM_SERVER_QUERY_CLIENT_STATE = /* @__PURE__ */ Symbol.for("farm.serverQueryClientState");
-var serverQueryClientGlobal = globalThis;
-var serverQueryClientState = serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] ?? (serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] = {
-  functionIds: /* @__PURE__ */ new WeakMap(),
-  nextFunctionId: 0,
-  active: [],
-  latestOwners: /* @__PURE__ */ new Map(),
-  owners: /* @__PURE__ */ new Set()
-});
-serverQueryClientState.latestOwners ?? (serverQueryClientState.latestOwners = /* @__PURE__ */ new Map());
-serverQueryClientState.owners ?? (serverQueryClientState.owners = /* @__PURE__ */ new Set());
-function isServerQueryOwnerSuperseded(owner, key) {
-  const cache = getFarmClientDataCache();
-  const resolved = cache.resolveKey(key);
-  for (const superseded of owner.supersededKeys ?? []) {
-    if (cache.resolveKey(superseded) === resolved) return true;
-  }
-  return false;
-}
-__name(isServerQueryOwnerSuperseded, "isServerQueryOwnerSuperseded");
-function claimServerQueryKey(owner, key) {
-  if (isServerQueryOwnerSuperseded(owner, key)) return false;
-  const resolved = getFarmClientDataCache().resolveKey(key);
-  for (const older of serverQueryClientState.owners) {
-    if (older === owner) break;
-    older.supersededKeys.add(resolved);
-  }
-  return true;
-}
-__name(claimServerQueryKey, "claimServerQueryKey");
-var RAW_SERVER_QUERY_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-query");
-function assertNotRawServerQueryInBrowser(query) {
-  if (typeof window === "undefined" || typeof document === "undefined") return;
-  if (!query?.[RAW_SERVER_QUERY_SYMBOL]) return;
-  throw new Error(
-    [
-      "useServerQuery received a raw server query implementation in the browser.",
-      "Server query handlers run only on the server. Enable the server-function transform (add @farm.js/plugin/rsc and set experimental.serverActions: true in farm.config.ts) so client imports become server references,",
-      "or call the query from server code / an API route (createAPIClient) instead."
-    ].join("\n")
-  );
-}
-__name(assertNotRawServerQueryInBrowser, "assertNotRawServerQueryInBrowser");
-function isCurrentServerQueryOwner(provisionalKey, owner) {
-  return serverQueryClientState.latestOwners.get(provisionalKey) === owner && !isServerQueryOwnerSuperseded(owner, provisionalKey);
-}
-__name(isCurrentServerQueryOwner, "isCurrentServerQueryOwner");
-function createServerQueryCallKey(query, input) {
-  let id = serverQueryClientState.functionIds.get(query);
-  if (!id) {
-    id = ++serverQueryClientState.nextFunctionId;
-    serverQueryClientState.functionIds.set(query, id);
-  }
-  return createFarmCacheKey(["server-query-call", id, input]);
-}
-__name(createServerQueryCallKey, "createServerQueryCallKey");
-async function fetchServerQuery(query, input, options = {}) {
-  const cache = getFarmClientDataCache();
-  const provisionalKey = createServerQueryCallKey(query, input);
-  const entry = cache.get(provisionalKey);
-  const stale = cache.isStale(provisionalKey);
-  const inflight = cache.getInflight(provisionalKey);
-  if (!options.force && entry && stale && (entry.status !== "pending" || entry.updatedAt !== 0) && entry.status !== "error" && (options.swr ?? true)) {
-    if (!inflight) {
-      void executeServerQuery(query, input, provisionalKey, options).catch(() => void 0);
-    }
-    return entry.data;
-  }
-  if (inflight && !options.force) return inflight;
-  if (!options.force && entry && !stale && entry.status !== "error") return entry.data;
-  return executeServerQuery(query, input, provisionalKey, options);
-}
-__name(fetchServerQuery, "fetchServerQuery");
-async function executeServerQuery(query, input, provisionalKey, options) {
-  assertNotRawServerQueryInBrowser(query);
-  const cache = getFarmClientDataCache();
-  const inflight = cache.getInflight(provisionalKey);
-  if (inflight && !options.force) return inflight;
-  const owner = {
-    invalidations: trackFarmClientCacheInvalidations(cache),
-    supersededKeys: /* @__PURE__ */ new Set()
-  };
-  serverQueryClientState.latestOwners.set(provisionalKey, owner);
-  serverQueryClientState.owners.add(owner);
-  claimServerQueryKey(owner, provisionalKey);
-  const previous = cache.get(provisionalKey);
-  cache.set(provisionalKey, {
-    data: previous?.data,
-    updatedAt: previous?.updatedAt ?? 0,
-    staleAt: previous?.staleAt ?? 0,
-    gcAt: previous?.gcAt,
-    invalidatedAt: previous?.invalidatedAt,
-    status: "pending",
-    error: null,
-    fetching: true
-  });
-  let promise;
-  promise = (async () => {
-    await Promise.resolve();
-    try {
-      serverQueryClientState.active.push({ provisionalKey, owner });
-      let pending;
-      try {
-        pending = query(input);
-      } finally {
-        serverQueryClientState.active.pop();
-      }
-      const data = await pending;
-      const transported = cache.get(provisionalKey);
-      if (isCurrentServerQueryOwner(provisionalKey, owner) && (!transported || transported.fetching)) {
-        const updatedAt = Date.now();
-        cache.set(provisionalKey, {
-          data,
-          updatedAt,
-          staleAt: owner.invalidations.has(provisionalKey) ? 0 : options.staleTime === false ? Number.POSITIVE_INFINITY : updatedAt + (options.staleTime ?? 0),
-          status: "success",
-          error: null,
-          fetching: false
-        });
-      }
-      return data;
-    } catch (cause) {
-      const error = normalizeServerQueryError(cause);
-      if (isCurrentServerQueryOwner(provisionalKey, owner)) {
-        const current = cache.get(provisionalKey);
-        cache.set(provisionalKey, {
-          data: current?.data,
-          updatedAt: current?.updatedAt ?? 0,
-          staleAt: current?.staleAt ?? 0,
-          gcAt: current?.gcAt,
-          invalidatedAt: current?.invalidatedAt,
-          status: "error",
-          error,
-          fetching: false
-        });
-      }
-      throw error;
-    } finally {
-      const invalidated = isCurrentServerQueryOwner(provisionalKey, owner) && owner.invalidations.has(provisionalKey);
-      owner.invalidations.dispose();
-      serverQueryClientState.owners.delete(owner);
-      owner.supersededKeys.clear();
-      if (cache.getInflight(provisionalKey) === promise) {
-        cache.deleteInflight(provisionalKey);
-      }
-      if (serverQueryClientState.latestOwners.get(provisionalKey) === owner) {
-        serverQueryClientState.latestOwners.delete(provisionalKey);
-      }
-      if (invalidated) cache.invalidate(provisionalKey);
-    }
-  })();
-  cache.setInflight(provisionalKey, promise);
-  return promise;
-}
-__name(executeServerQuery, "executeServerQuery");
-function normalizeServerQueryError(cause) {
-  if (cause instanceof Error) return cause;
-  const error = new Error(typeof cause === "string" ? cause : "Server query failed");
-  error.cause = cause;
-  return error;
-}
-__name(normalizeServerQueryError, "normalizeServerQueryError");
 
-// src/theme/runtime.ts
-var FALLBACK_CLIENT_SNAPSHOT = Object.freeze({
-  theme: "system",
-  resolvedTheme: "light",
-  mounted: true
-});
-var cachedClientSnapshot = FALLBACK_CLIENT_SNAPSHOT;
-function snapshotsMatch(left, right) {
-  return left.theme === right.theme && left.resolvedTheme === right.resolvedTheme && left.mounted === right.mounted;
-}
-__name(snapshotsMatch, "snapshotsMatch");
-function getTheme() {
-  const next = typeof window === "undefined" ? FALLBACK_CLIENT_SNAPSHOT : window.__FARM_THEME__?.snapshot;
-  if (!next) return cachedClientSnapshot;
-  if (!snapshotsMatch(cachedClientSnapshot, next)) cachedClientSnapshot = next;
-  return cachedClientSnapshot;
-}
-__name(getTheme, "getTheme");
-function setTheme(theme) {
-  const runtime3 = typeof window === "undefined" ? void 0 : window.__FARM_THEME__;
-  if (!runtime3) {
-    throw new Error("The FARMJS theme runtime is not enabled. Add `theme` to farm.config.ts.");
-  }
-  runtime3.setTheme(theme);
-}
-__name(setTheme, "setTheme");
-function toggleTheme() {
-  const next = getTheme().resolvedTheme === "dark" ? "light" : "dark";
-  setTheme(next);
-  return next;
-}
-__name(toggleTheme, "toggleTheme");
-function subscribeTheme(listener) {
-  if (typeof window === "undefined") return () => {
-  };
-  const handleThemeChange = /* @__PURE__ */ __name(() => {
-    getTheme();
-    listener();
-  }, "handleThemeChange");
-  window.addEventListener("farm:themechange", handleThemeChange);
-  return () => window.removeEventListener("farm:themechange", handleThemeChange);
-}
-__name(subscribeTheme, "subscribeTheme");
 
-// src/i18n/resolver.ts
-function createFarmLocaleCookie(locale, config) {
-  const cookie = config.cookie;
-  let value = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(locale)}`;
-  value += `; Max-Age=${cookie.maxAge}`;
-  value += `; Path=${cookie.path}`;
-  value += `; SameSite=${capitalize(cookie.sameSite)}`;
-  if (cookie.secure) value += "; Secure";
-  return value;
-}
-__name(createFarmLocaleCookie, "createFarmLocaleCookie");
-function capitalize(value) {
-  return value.charAt(0).toUpperCase() + value.slice(1);
-}
-__name(capitalize, "capitalize");
 
-// src/i18n/client-runtime.ts
-var import_intl_messageformat = __toESM(require("intl-messageformat"));
-var readOwnMessage = /* @__PURE__ */ __name((messages, key) => Object.prototype.hasOwnProperty.call(messages, key) ? messages[key] : void 0, "readOwnMessage");
-var translate = /* @__PURE__ */ __name((key, values, rich = false) => {
-  const snapshot = requireSnapshot();
-  const message = readOwnMessage(snapshot.messages, key);
-  if (message === void 0) return key;
-  const cacheKey = `${snapshot.locale}\0${key}\0${message}`;
-  let formatter = compiledFarmI18nMessages.get(cacheKey);
-  if (!formatter) {
-    formatter = new import_intl_messageformat.default(message, snapshot.locale);
-    compiledFarmI18nMessages.set(cacheKey, formatter);
-  }
-  const result = formatter.format(values);
-  if (rich) return Array.isArray(result) && result.length === 1 ? result[0] : result;
-  if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
-    throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
-  }
-  return Array.isArray(result) ? result.join("") : String(result);
-}, "translate");
-var t = /* @__PURE__ */ __name(((key, values) => translate(key, values)), "t");
-t.rich = (key, values) => translate(key, values, true);
-t.raw = (key) => readOwnMessage(requireSnapshot().messages, key) ?? key;
-t.has = (key) => Object.prototype.hasOwnProperty.call(requireSnapshot().messages, key);
-function createFarmClientTranslator() {
-  return ((key, ...args) => t(key, ...args));
-}
-__name(createFarmClientTranslator, "createFarmClientTranslator");
-function requireSnapshot() {
-  const snapshot = getFarmI18nClientState();
-  if (!snapshot) {
-    throw new Error("Farm i18n is not configured or has not been hydrated.");
-  }
-  return snapshot;
-}
-__name(requireSnapshot, "requireSnapshot");
+var _chunkY4YWHNKUcjs = require('./chunk-Y4YWHNKU.cjs');
+
+
+
+
+
+var _chunkFK6GO24Vcjs = require('./chunk-FK6GO24V.cjs');
+
+
+var _chunkSU7MH53Pcjs = require('./chunk-SU7MH53P.cjs');
+require('./chunk-PCOTGFSM.cjs');
+
+
+
+
+var _chunkWJ3HK3LJcjs = require('./chunk-WJ3HK3LJ.cjs');
+
+
+
+var _chunk5OVTOKGHcjs = require('./chunk-5OVTOKGH.cjs');
+require('./chunk-R5A5KNVX.cjs');
+require('./chunk-SWN467MP.cjs');
+
+
+var _chunkI7PUUDGYcjs = require('./chunk-I7PUUDGY.cjs');
+require('./chunk-J7FSKED3.cjs');
+require('./chunk-SK35NQKK.cjs');
+
+
+var _chunk75BRBIFPcjs = require('./chunk-75BRBIFP.cjs');
+require('./chunk-OXSIH4D6.cjs');
+require('./chunk-R5JIFR6B.cjs');
+require('./chunk-C5GUTBZK.cjs');
+require('./chunk-QBK2AA4U.cjs');
+require('./chunk-H6G5INWM.cjs');
+require('./chunk-ZEG3OPIB.cjs');
+require('./chunk-LIUGYUX3.cjs');
+require('./chunk-E3UK5IIB.cjs');
+
+
+
+var _chunkBIDYX3SLcjs = require('./chunk-BIDYX3SL.cjs');
+
+
+
+
+
+var _chunkI57LW5VZcjs = require('./chunk-I57LW5VZ.cjs');
+require('./chunk-NO3WWW3N.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
 
 // src/renderer-client.ts
 function createRendererRouter(options = {}) {
-  const basePath = options.basePath === void 0 ? getFarmBasePath() : normalizeFarmBasePath(options.basePath);
-  const matcher = options.routes?.length ? createFarmRouter([...options.routes]) : null;
-  const router = getRouter();
+  const basePath = options.basePath === void 0 ? _chunkI57LW5VZcjs.getFarmBasePath.call(void 0, ) : _chunkI57LW5VZcjs.normalizeFarmBasePath.call(void 0, options.basePath);
+  const matcher = _optionalChain([options, 'access', _ => _.routes, 'optionalAccess', _2 => _2.length]) ? _chunkSU7MH53Pcjs.createFarmRouter.call(void 0, [...options.routes]) : null;
+  const router = _chunkWJ3HK3LJcjs.getRouter.call(void 0, );
   let snapshot = readRendererRouterSnapshot(basePath, matcher, router.getNavigationState());
-  const read = /* @__PURE__ */ __name(() => {
+  const read = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
     snapshot = readRendererRouterSnapshot(basePath, matcher, router.getNavigationState());
     return snapshot;
   }, "read");
   return {
-    getSnapshot: /* @__PURE__ */ __name(() => snapshot, "getSnapshot"),
+    getSnapshot: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => snapshot, "getSnapshot"),
     subscribe(listener) {
       if (typeof window === "undefined") return () => {
       };
-      const notify = /* @__PURE__ */ __name(() => {
+      const notify = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
         read();
         listener();
       }, "notify");
       const unsubscribeNavigation = router.subscribeNavigation(notify);
-      const unsubscribeHistory = subscribeHistoryChange(notify);
+      const unsubscribeHistory = _chunkWJ3HK3LJcjs.subscribeHistoryChange.call(void 0, notify);
       read();
       return () => {
         unsubscribeNavigation();
@@ -4263,8 +95,8 @@ function createRendererRouter(options = {}) {
         replace: true
       });
     },
-    refresh: /* @__PURE__ */ __name((refreshOptions) => typeof window === "undefined" ? Promise.resolve() : router.refresh(refreshOptions), "refresh"),
-    prefetch: /* @__PURE__ */ __name((href) => typeof window === "undefined" ? Promise.resolve() : router.prefetch(resolveRendererHref(href, basePath)), "prefetch"),
+    refresh: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (refreshOptions) => typeof window === "undefined" ? Promise.resolve() : router.refresh(refreshOptions), "refresh"),
+    prefetch: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (href) => typeof window === "undefined" ? Promise.resolve() : router.prefetch(resolveRendererHref(href, basePath)), "prefetch"),
     back() {
       if (typeof window !== "undefined") window.history.back();
     },
@@ -4285,11 +117,11 @@ function createRendererRouter(options = {}) {
     }
   };
 }
-__name(createRendererRouter, "createRendererRouter");
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRendererRouter, "createRendererRouter");
 function createRendererAction(target, options = {}) {
   const serverFn = resolveRendererServerFn(target);
-  const listeners2 = /* @__PURE__ */ new Set();
-  const initialResult = options.initialResult ?? null;
+  const listeners = /* @__PURE__ */ new Set();
+  const initialResult = _nullishCoalesce(options.initialResult, () => ( null));
   let requestId = 0;
   let pendingCount = 0;
   let latestSettledStatus = "idle";
@@ -4299,21 +131,21 @@ function createRendererAction(target, options = {}) {
     data: initialResult,
     error: null
   };
-  const update = /* @__PURE__ */ __name((next) => {
+  const update = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (next) => {
     snapshot = next;
-    for (const listener of listeners2) listener();
+    for (const listener of listeners) listener();
   }, "update");
   return {
-    getSnapshot: /* @__PURE__ */ __name(() => snapshot, "getSnapshot"),
+    getSnapshot: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => snapshot, "getSnapshot"),
     subscribe(listener) {
-      listeners2.add(listener);
-      return () => listeners2.delete(listener);
+      listeners.add(listener);
+      return () => listeners.delete(listener);
     },
     async submit(input) {
       const currentRequest = ++requestId;
       const previous = snapshot.data;
       const formData = isRendererFormData(input) ? input : void 0;
-      const optimistic = options.optimistic?.({ input, formData, current: previous });
+      const optimistic = _optionalChain([options, 'access', _3 => _3.optimistic, 'optionalCall', _4 => _4({ input, formData, current: previous })]);
       const hasOptimistic = optimistic !== void 0;
       pendingCount += 1;
       update({
@@ -4333,8 +165,8 @@ function createRendererAction(target, options = {}) {
             data: result,
             error: null
           });
-          options.onSuccess?.(result);
-          options.onSettled?.(result, null);
+          _optionalChain([options, 'access', _5 => _5.onSuccess, 'optionalCall', _6 => _6(result)]);
+          _optionalChain([options, 'access', _7 => _7.onSettled, 'optionalCall', _8 => _8(result, null)]);
         } else if (pendingCount === 0) {
           update({ ...snapshot, pending: false, status: latestSettledStatus });
         }
@@ -4350,8 +182,8 @@ function createRendererAction(target, options = {}) {
             data: hasOptimistic && options.rollbackOnError ? previous : options.resetOnSubmit === false ? snapshot.data : null,
             error
           });
-          options.onError?.(error);
-          options.onSettled?.(null, error);
+          _optionalChain([options, 'access', _9 => _9.onError, 'optionalCall', _10 => _10(error)]);
+          _optionalChain([options, 'access', _11 => _11.onSettled, 'optionalCall', _12 => _12(null, error)]);
         } else if (pendingCount === 0) {
           update({ ...snapshot, pending: false, status: latestSettledStatus });
         }
@@ -4366,21 +198,21 @@ function createRendererAction(target, options = {}) {
     }
   };
 }
-__name(createRendererAction, "createRendererAction");
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRendererAction, "createRendererAction");
 function createRendererQuery(query, input, options = {}) {
-  const cache = getFarmClientDataCache();
-  const key = createServerQueryCallKey(query, input);
-  const listeners2 = /* @__PURE__ */ new Set();
+  const cache = _chunkI7PUUDGYcjs.getFarmClientDataCache.call(void 0, );
+  const key = _chunkY4YWHNKUcjs.createServerQueryCallKey.call(void 0, query, input);
+  const listeners = /* @__PURE__ */ new Set();
   let unsubscribeCache;
   let cleanupBrowser;
-  const run = /* @__PURE__ */ __name((force = false) => fetchServerQuery(query, input, { ...options, force }), "run");
-  const ensureStarted = /* @__PURE__ */ __name(() => {
+  const run = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (force = false) => _chunkY4YWHNKUcjs.fetchServerQuery.call(void 0, query, input, { ...options, force }), "run");
+  const ensureStarted = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
     if (options.enabled === false || unsubscribeCache) return;
     unsubscribeCache = cache.subscribe(key, () => {
-      for (const listener of listeners2) listener();
+      for (const listener of listeners) listener();
     });
     if (!cache.get(key) || cache.isStale(key)) void run().catch(() => void 0);
-    cleanupBrowser = attachRevalidationListeners(
+    cleanupBrowser = _chunkY4YWHNKUcjs.attachRevalidationListeners.call(void 0, 
       () => {
         if (cache.isStale(key)) void run().catch(() => void 0);
       },
@@ -4393,60 +225,60 @@ function createRendererQuery(query, input, options = {}) {
   return {
     getSnapshot() {
       const entry = cache.get(key);
-      const status = entry?.status ?? (entry ? "success" : "idle");
+      const status = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _13 => _13.status]), () => ( (entry ? "success" : "idle")));
       return {
-        data: entry?.data,
-        error: entry?.error ?? null,
+        data: _optionalChain([entry, 'optionalAccess', _14 => _14.data]),
+        error: _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _15 => _15.error]), () => ( null)),
         status,
-        pending: status === "pending" && (entry?.updatedAt ?? 0) === 0,
-        fetching: entry?.fetching ?? false,
+        pending: status === "pending" && (_nullishCoalesce(_optionalChain([entry, 'optionalAccess', _16 => _16.updatedAt]), () => ( 0))) === 0,
+        fetching: _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _17 => _17.fetching]), () => ( false)),
         stale: cache.isStale(key)
       };
     },
     subscribe(listener) {
-      listeners2.add(listener);
+      listeners.add(listener);
       ensureStarted();
-      return () => listeners2.delete(listener);
+      return () => listeners.delete(listener);
     },
-    refetch: /* @__PURE__ */ __name(() => run(true), "refetch"),
+    refetch: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => run(true), "refetch"),
     dispose() {
-      unsubscribeCache?.();
-      cleanupBrowser?.();
+      _optionalChain([unsubscribeCache, 'optionalCall', _18 => _18()]);
+      _optionalChain([cleanupBrowser, 'optionalCall', _19 => _19()]);
       unsubscribeCache = void 0;
       cleanupBrowser = void 0;
-      listeners2.clear();
+      listeners.clear();
     }
   };
 }
-__name(createRendererQuery, "createRendererQuery");
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRendererQuery, "createRendererQuery");
 function createRendererTheme() {
   return {
-    getSnapshot: getTheme,
-    subscribe: subscribeTheme,
-    setTheme,
-    toggleTheme
+    getSnapshot: _chunkFK6GO24Vcjs.getTheme,
+    subscribe: _chunkFK6GO24Vcjs.subscribeTheme,
+    setTheme: _chunkFK6GO24Vcjs.setTheme,
+    toggleTheme: _chunkFK6GO24Vcjs.toggleTheme
   };
 }
-__name(createRendererTheme, "createRendererTheme");
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRendererTheme, "createRendererTheme");
 function createRendererI18n() {
   return {
-    getSnapshot: getFarmI18nClientState,
-    subscribe: subscribeFarmI18n,
-    t: createFarmClientTranslator(),
+    getSnapshot: _chunk5OVTOKGHcjs.getFarmI18nClientState,
+    subscribe: _chunk5OVTOKGHcjs.subscribeFarmI18n,
+    t: _chunkDYEJQTDNcjs.createFarmClientTranslator.call(void 0, ),
     setLocale(locale) {
-      const snapshot = getFarmI18nClientState();
+      const snapshot = _chunk5OVTOKGHcjs.getFarmI18nClientState.call(void 0, );
       if (!snapshot) throw new Error("Farm i18n is not configured or has not been hydrated.");
       if (!snapshot.locales.includes(locale)) {
         throw new Error(`Unsupported Farm i18n locale "${locale}".`);
       }
       if (typeof window === "undefined") return;
-      document.cookie = createFarmLocaleCookie(locale, { cookie: snapshot.cookie });
+      document.cookie = _chunk75BRBIFPcjs.createFarmLocaleCookie.call(void 0, locale, { cookie: snapshot.cookie });
       const href = `${window.location.pathname}${window.location.search}${window.location.hash}`;
-      window.location.assign(localizeFarmHref(href, locale, snapshot));
+      window.location.assign(_chunkBIDYX3SLcjs.localizeFarmHref.call(void 0, href, locale, snapshot));
     }
   };
 }
-__name(createRendererI18n, "createRendererI18n");
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRendererI18n, "createRendererI18n");
 function readRendererRouterSnapshot(basePath, matcher, navigation) {
   if (typeof window === "undefined") {
     return {
@@ -4458,22 +290,22 @@ function readRendererRouterSnapshot(basePath, matcher, navigation) {
     };
   }
   const url = new URL(window.location.href);
-  const pathname = stripFarmBasePath(url.pathname, basePath);
-  const i18n = getFarmI18nClientState();
-  const routePathname = i18n ? stripFarmLocaleFromPathname(pathname, i18n) : pathname;
+  const pathname = _chunkI57LW5VZcjs.stripFarmBasePath.call(void 0, url.pathname, basePath);
+  const i18n = _chunk5OVTOKGHcjs.getFarmI18nClientState.call(void 0, );
+  const routePathname = i18n ? _chunkBIDYX3SLcjs.stripFarmLocaleFromPathname.call(void 0, pathname, i18n) : pathname;
   return {
     pathname,
     searchParams: url.searchParams,
-    params: matcher?.match(routePathname)?.params || {},
-    pageState: readPageState(),
+    params: _optionalChain([matcher, 'optionalAccess', _20 => _20.match, 'call', _21 => _21(routePathname), 'optionalAccess', _22 => _22.params]) || {},
+    pageState: _chunkWJ3HK3LJcjs.readPageState.call(void 0, ),
     navigation
   };
 }
-__name(readRendererRouterSnapshot, "readRendererRouterSnapshot");
+_chunkS3JO3N4Hcjs.__name.call(void 0, readRendererRouterSnapshot, "readRendererRouterSnapshot");
 function resolveRendererHref(href, basePath) {
-  return applyFarmBasePath(href, basePath);
+  return _chunkI57LW5VZcjs.applyFarmBasePath.call(void 0, href, basePath);
 }
-__name(resolveRendererHref, "resolveRendererHref");
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveRendererHref, "resolveRendererHref");
 function resolveRendererServerFn(target) {
   if (typeof target === "function") return target;
   if (target && typeof target.action === "function") return target.action;
@@ -4481,23 +313,22 @@ function resolveRendererServerFn(target) {
     "createRendererAction requires a server function or a route with a declared action"
   );
 }
-__name(resolveRendererServerFn, "resolveRendererServerFn");
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveRendererServerFn, "resolveRendererServerFn");
 function normalizeRendererClientError(cause) {
   if (cause instanceof Error) return cause;
   const error = new Error(typeof cause === "string" ? cause : "FARMJS client operation failed");
   error.cause = cause;
   return error;
 }
-__name(normalizeRendererClientError, "normalizeRendererClientError");
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRendererClientError, "normalizeRendererClientError");
 function isRendererFormData(value) {
   return typeof FormData !== "undefined" && value instanceof FormData;
 }
-__name(isRendererFormData, "isRendererFormData");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createRendererAction,
-  createRendererI18n,
-  createRendererQuery,
-  createRendererRouter,
-  createRendererTheme
-});
+_chunkS3JO3N4Hcjs.__name.call(void 0, isRendererFormData, "isRendererFormData");
+
+
+
+
+
+
+exports.createRendererAction = createRendererAction; exports.createRendererI18n = createRendererI18n; exports.createRendererQuery = createRendererQuery; exports.createRendererRouter = createRendererRouter; exports.createRendererTheme = createRendererTheme;