@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-UQZ4AYTH.cjs

@@ -0,0 +1,168 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/server/response.ts
+function watchResponseEvent(res, events) {
+  if (typeof res.once !== "function" || typeof res.removeListener !== "function") {
+    return null;
+  }
+  let settled = false;
+  const listeners = events.map(([event, value]) => {
+    const listener = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+      if (settled) return;
+      settled = true;
+      dispose();
+      resolvePromise(value);
+    }, "listener");
+    return { event, listener };
+  });
+  let resolvePromise;
+  const promise = new Promise((resolve) => {
+    resolvePromise = resolve;
+    for (const { event, listener } of listeners) {
+      res.once(event, listener);
+    }
+  });
+  const dispose = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    for (const { event, listener } of listeners) {
+      res.removeListener(event, listener);
+    }
+  }, "dispose");
+  return { promise, dispose };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, watchResponseEvent, "watchResponseEvent");
+async function waitForWritable(res) {
+  if (res.writableEnded || res.destroyed) {
+    return false;
+  }
+  const watcher = watchResponseEvent(res, [
+    ["drain", true],
+    ["close", false],
+    ["error", false]
+  ]);
+  if (!watcher) {
+    return false;
+  }
+  try {
+    return await watcher.promise;
+  } finally {
+    watcher.dispose();
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, waitForWritable, "waitForWritable");
+function splitSetCookieHeader(value) {
+  const cookies = [];
+  let start = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] !== ",") continue;
+    let next = index + 1;
+    while (value[next] === " " || value[next] === "	") next += 1;
+    const equals = value.indexOf("=", next);
+    if (equals === -1) continue;
+    const separator = value.slice(next, equals);
+    if (separator.length === 0 || /[;,\s]/.test(separator)) continue;
+    cookies.push(value.slice(start, index).trim());
+    start = next;
+    index = next - 1;
+  }
+  cookies.push(value.slice(start).trim());
+  return cookies.filter(Boolean);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, splitSetCookieHeader, "splitSetCookieHeader");
+function applyWebResponseHeaders(res, headers, options = {}) {
+  const responseHeaders = headers;
+  const rawSetCookies = _optionalChain([responseHeaders, 'access', _ => _.raw, 'optionalCall', _2 => _2(), 'access', _3 => _3["set-cookie"]]);
+  const setCookies = _optionalChain([responseHeaders, 'access', _4 => _4.getSetCookie, 'optionalCall', _5 => _5()]) || rawSetCookies || [];
+  const existing = options.appendSetCookie && typeof res.getHeader === "function" ? res.getHeader("Set-Cookie") : void 0;
+  const existingCookies = Array.isArray(existing) ? existing.map(String) : existing === void 0 ? [] : [String(existing)];
+  let fallbackSetCookie = "";
+  headers.forEach((value, key) => {
+    if (key.toLowerCase() === "set-cookie") {
+      fallbackSetCookie = value;
+      return;
+    }
+    res.setHeader(key, value);
+  });
+  const cookies = setCookies.length > 0 ? setCookies : fallbackSetCookie ? splitSetCookieHeader(fallbackSetCookie) : [];
+  if (cookies.length > 0) {
+    res.setHeader("Set-Cookie", [...existingCookies, ...cookies]);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyWebResponseHeaders, "applyWebResponseHeaders");
+async function sendWebResponse(res, response) {
+  res.statusCode = response.status;
+  applyWebResponseHeaders(res, response.headers, { appendSetCookie: true });
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  if (typeof res.write !== "function") {
+    const body = await response.arrayBuffer();
+    res.end(Buffer.from(body));
+    return;
+  }
+  const reader = response.body.getReader();
+  const disconnectWatcher = watchResponseEvent(res, [
+    ["close", true],
+    ["error", true]
+  ]);
+  try {
+    while (true) {
+      if (res.destroyed) {
+        void reader.cancel().catch(() => {
+        });
+        return;
+      }
+      const read = reader.read().then((result) => ({ type: "read", result }));
+      const next = disconnectWatcher ? await Promise.race([
+        read,
+        disconnectWatcher.promise.then(() => ({ type: "disconnect" }))
+      ]) : await read;
+      if (next.type === "disconnect") {
+        void reader.cancel().catch(() => {
+        });
+        return;
+      }
+      const { done, value } = next.result;
+      if (done) {
+        break;
+      }
+      if (!value || value.byteLength === 0) {
+        continue;
+      }
+      if (!res.write(value)) {
+        if (!await waitForWritable(res)) {
+          void reader.cancel().catch(() => {
+          });
+          return;
+        }
+      }
+    }
+    res.end();
+  } catch (error) {
+    void reader.cancel(error).catch(() => {
+    });
+    if (!res.writableEnded) {
+      const responseError = error instanceof Error ? error : new Error(String(error));
+      if (typeof res.destroy === "function") {
+        res.destroy(responseError);
+      } else {
+        res.end();
+      }
+    }
+    throw error;
+  } finally {
+    _optionalChain([disconnectWatcher, 'optionalAccess', _6 => _6.dispose, 'call', _7 => _7()]);
+    try {
+      reader.releaseLock();
+    } catch (e) {
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, sendWebResponse, "sendWebResponse");
+
+
+
+
+exports.applyWebResponseHeaders = applyWebResponseHeaders; exports.sendWebResponse = sendWebResponse;

package/dist/chunk-US2QVW3E.cjs

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/utils/decode.ts
+function decodeRouteSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch (e) {
+    return segment;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, decodeRouteSegment, "decodeRouteSegment");
+function canonicalizeRequestPathSegments(pathname) {
+  const segments = pathname.split("/").filter(Boolean);
+  if (!pathname.includes("%")) return segments;
+  return segments.map(decodeRouteSegment);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, canonicalizeRequestPathSegments, "canonicalizeRequestPathSegments");
+function canonicalizeRequestPathname(pathname) {
+  const encoded = pathname.includes("%");
+  if (!encoded && !pathname.includes("//")) return pathname;
+  const collapsed = pathname.replace(/\/{2,}/g, "/");
+  if (!encoded) return collapsed;
+  return collapsed.split("/").map((segment) => {
+    const decoded = decodeRouteSegment(segment);
+    return decoded === segment ? segment : decoded.replace(/\//g, "%2F");
+  }).join("/");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, canonicalizeRequestPathname, "canonicalizeRequestPathname");
+
+
+
+
+
+exports.decodeRouteSegment = decodeRouteSegment; exports.canonicalizeRequestPathSegments = canonicalizeRequestPathSegments; exports.canonicalizeRequestPathname = canonicalizeRequestPathname;

package/dist/{chunk-NUD6XBMO.mjs → chunk-UTBVHYS3.mjs}

@@ -3,10 +3,10 @@ import {
   loadFarmDocsPage,
   resolveFarmDocsContentDir,
   toFarmDocsMarkdownPage
-} from "./chunk-MOQNHLTS.mjs";
+} from "./chunk-5QOEPUYE.mjs";
 import {
   resolveDocsConfig
-} from "./chunk-IXTEENRS.mjs";
+} from "./chunk-QGVJVSNX.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";

package/dist/{chunk-76MNRHTS.mjs → chunk-UUYF3CHN.mjs}

@@ -1,13 +1,13 @@
 import {
   getFarmClientDataCache,
   trackFarmClientCacheInvalidations
-} from "./chunk-HKLRP3BN.mjs";
+} from "./chunk-5SPPCN5J.mjs";
 import {
   isFarmServerQueryResult
 } from "./chunk-KGB5UXJJ.mjs";
 import {
   createFarmCacheKey
-} from "./chunk-IGO2HEV7.mjs";
+} from "./chunk-F6SJAKFJ.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";

package/dist/chunk-VB6UCX3V.cjs

@@ -0,0 +1,421 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client/plugin.ts
+function defineClient(definition) {
+  return definition;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineClient, "defineClient");
+var PERFORMANCE_ENTRY_TYPES = [
+  "navigation",
+  "paint",
+  "largest-contentful-paint",
+  "layout-shift",
+  "event"
+];
+var _FarmClientPluginManager = class _FarmClientPluginManager {
+  constructor(registrations, options) {
+    this.instances = [];
+    this.performanceObservers = [];
+    this.navigationSequence = 0;
+    this.starting = false;
+    this.started = false;
+    this.closed = false;
+    this.reportedErrors = /* @__PURE__ */ new WeakSet();
+    this.handleWindowError = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (event) => {
+      const error = _nullishCoalesce(event.error, () => ( new Error(event.message || "Unknown browser error")));
+      void this.reportError(error, "window", void 0, this.getLocation(), event);
+    }, "handleWindowError");
+    this.handleUnhandledRejection = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (event) => {
+      void this.reportError(
+        event.reason,
+        "unhandled-rejection",
+        void 0,
+        this.getLocation(),
+        event
+      );
+    }, "handleUnhandledRejection");
+    this.handlePageHide = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (event) => {
+      if (event.persisted) return;
+      void this.close("pagehide");
+    }, "handlePageHide");
+    this.registrations = sortRegistrations(registrations);
+    this.options = {
+      ...options,
+      isDev: _nullishCoalesce(options.isDev, () => ( false)),
+      isProd: _nullishCoalesce(options.isProd, () => ( !options.isDev)),
+      window: _nullishCoalesce(options.window, () => ( (typeof window !== "undefined" ? window : void 0)))
+    };
+  }
+  start() {
+    if (this.startPromise) return this.startPromise;
+    this.startPromise = Promise.resolve().then(() => this.startInternal());
+    return this.startPromise;
+  }
+  async beginHydration(input) {
+    await this.start();
+    const session = {
+      ...input,
+      location: this.getLocation(),
+      startedAt: now()
+    };
+    await this.runHook(
+      "hydration.before",
+      (instance) => _optionalChain([instance, 'access', _ => _.plugin, 'access', _2 => _2.hydration, 'optionalAccess', _3 => _3.before, 'optionalCall', _4 => _4({
+        ...this.createStateEvent(instance),
+        ...session
+      })])
+    );
+    return session;
+  }
+  async completeHydration(session, options = {}) {
+    await this.runHook(
+      "hydration.after",
+      (instance) => _optionalChain([instance, 'access', _5 => _5.plugin, 'access', _6 => _6.hydration, 'optionalAccess', _7 => _7.after, 'optionalCall', _8 => _8({
+        ...this.createStateEvent(instance),
+        ...session,
+        durationMs: now() - session.startedAt,
+        recovered: _nullishCoalesce(options.recovered, () => ( false))
+      })])
+    );
+  }
+  async failHydration(session, error) {
+    await this.reportError(error, "hydration", void 0, session.location);
+  }
+  async beginNavigation(input) {
+    await this.start();
+    _optionalChain([this, 'access', _9 => _9.currentNavigation, 'optionalAccess', _10 => _10.controller, 'access', _11 => _11.abort, 'call', _12 => _12("superseded")]);
+    const controller = new AbortController();
+    const session = {
+      id: `navigation:${++this.navigationSequence}`,
+      from: input.from === null ? null : toClientLocation(_nullishCoalesce(input.from, () => ( this.getLocation().href)), this.getBaseUrl()),
+      to: toClientLocation(input.to, this.getBaseUrl()),
+      action: input.action,
+      signal: controller.signal,
+      startedAt: now(),
+      route: input.route
+    };
+    this.currentNavigation = { controller, session };
+    await this.runHook(
+      "navigation.before",
+      (instance) => _optionalChain([instance, 'access', _13 => _13.plugin, 'access', _14 => _14.navigation, 'optionalAccess', _15 => _15.before, 'optionalCall', _16 => _16({
+        ...this.createStateEvent(instance),
+        ...session
+      })])
+    );
+    return session;
+  }
+  async markNavigationLoaded(session, data) {
+    if (session.signal.aborted) return;
+    await this.runHook(
+      "navigation.loaded",
+      (instance) => _optionalChain([instance, 'access', _17 => _17.plugin, 'access', _18 => _18.navigation, 'optionalAccess', _19 => _19.loaded, 'optionalCall', _20 => _20({
+        ...this.createStateEvent(instance),
+        ...session,
+        data,
+        durationMs: now() - session.startedAt
+      })])
+    );
+  }
+  cancelNavigation(session, reason = "canceled") {
+    const current = this.currentNavigation;
+    if (!current || session && current.session !== session) return;
+    current.controller.abort(reason);
+    this.currentNavigation = void 0;
+  }
+  async resolveNavigation(session) {
+    if (session.signal.aborted) return;
+    await this.runHook(
+      "navigation.resolved",
+      (instance) => _optionalChain([instance, 'access', _21 => _21.plugin, 'access', _22 => _22.navigation, 'optionalAccess', _23 => _23.resolved, 'optionalCall', _24 => _24({
+        ...this.createStateEvent(instance),
+        ...session,
+        durationMs: now() - session.startedAt
+      })])
+    );
+  }
+  scheduleNavigationRendered(session) {
+    if (session.signal.aborted) return Promise.resolve();
+    const clientWindow = this.options.window;
+    const schedule = _optionalChain([clientWindow, 'optionalAccess', _25 => _25.requestAnimationFrame]) ? (callback) => clientWindow.requestAnimationFrame(() => clientWindow.requestAnimationFrame(callback)) : (callback) => setTimeout(callback, 0);
+    return new Promise((resolve) => {
+      schedule(() => {
+        if (session.signal.aborted || this.closed) {
+          resolve();
+          return;
+        }
+        void this.runHook(
+          "navigation.rendered",
+          (instance) => _optionalChain([instance, 'access', _26 => _26.plugin, 'access', _27 => _27.navigation, 'optionalAccess', _28 => _28.rendered, 'optionalCall', _29 => _29({
+            ...this.createStateEvent(instance),
+            ...session,
+            durationMs: now() - session.startedAt
+          })])
+        ).finally(() => {
+          if (_optionalChain([this, 'access', _30 => _30.currentNavigation, 'optionalAccess', _31 => _31.session]) === session) {
+            this.currentNavigation = void 0;
+          }
+          resolve();
+        });
+      });
+    });
+  }
+  async failNavigation(session, error) {
+    if (!session.signal.aborted) {
+      await this.runHook(
+        "navigation.error",
+        (instance) => _optionalChain([instance, 'access', _32 => _32.plugin, 'access', _33 => _33.navigation, 'optionalAccess', _34 => _34.error, 'optionalCall', _35 => _35({
+          ...this.createStateEvent(instance),
+          ...session,
+          durationMs: now() - session.startedAt,
+          error
+        })])
+      );
+      await this.reportError(error, "navigation", session, session.to);
+    }
+    if (_optionalChain([this, 'access', _36 => _36.currentNavigation, 'optionalAccess', _37 => _37.session]) === session) {
+      this.currentNavigation = void 0;
+    }
+  }
+  async reportError(error, phase, navigation, location = this.getLocation(), sourceEvent) {
+    if (this.closed) return;
+    if (isObject(error)) {
+      if (this.reportedErrors.has(error)) return;
+      this.reportedErrors.add(error);
+    }
+    if (!this.started && !this.starting) await this.start();
+    if (this.closed) return;
+    await this.runErrorHooks({ error, phase, navigation, location }, void 0, sourceEvent);
+  }
+  close(reason = "manual") {
+    if (this.closePromise) return this.closePromise;
+    this.closePromise = this.closeInternal(reason);
+    return this.closePromise;
+  }
+  getPlugins() {
+    return this.instances.map(({ registration }) => ({
+      name: registration.name,
+      version: registration.version
+    }));
+  }
+  async startInternal() {
+    if (this.started || this.closed) return;
+    if (process.env.NODE_ENV !== "production" && this.options.isDev && this.options.window) {
+      try {
+        const { createFarmRuntimeErrorOverlay } = await import("@farm.js/core/internal/client-error-overlay");
+        this.runtimeErrorOverlay = createFarmRuntimeErrorOverlay({ window: this.options.window });
+      } catch (error) {
+        this.logHookError("farm:runtime-error-overlay", "load", error);
+      }
+    }
+    this.starting = true;
+    try {
+      for (const registration of this.registrations) {
+        try {
+          const definition = registration.definition;
+          if (!definition || typeof definition !== "object") {
+            throw new TypeError(
+              `Client plugin "${registration.name}" does not define a lifecycle object`
+            );
+          }
+          const instance = {
+            registration,
+            plugin: definition,
+            state: void 0
+          };
+          instance.state = await _optionalChain([definition, 'access', _38 => _38.setup, 'optionalCall', _39 => _39(this.createSetupEvent(instance))]);
+          this.instances.push(instance);
+        } catch (error) {
+          this.logHookError(registration.name, "setup", error);
+          await this.runErrorHooks({
+            error,
+            phase: "setup",
+            location: this.getLocation()
+          });
+        }
+      }
+      this.started = true;
+      this.installBrowserListeners();
+      this.installPerformanceObservers();
+    } finally {
+      this.starting = false;
+    }
+  }
+  installBrowserListeners() {
+    const clientWindow = this.options.window;
+    if (!clientWindow) return;
+    if (this.runtimeErrorOverlay || this.instances.some(({ plugin }) => plugin.error)) {
+      clientWindow.addEventListener("error", this.handleWindowError);
+      clientWindow.addEventListener("unhandledrejection", this.handleUnhandledRejection);
+    }
+    clientWindow.addEventListener("pagehide", this.handlePageHide);
+  }
+  installPerformanceObservers() {
+    if (!this.instances.some(({ plugin }) => plugin.performance)) return;
+    const Observer = typeof PerformanceObserver !== "undefined" ? PerformanceObserver : void 0;
+    if (!Observer) return;
+    const supported = new Set(Observer.supportedEntryTypes || []);
+    for (const type of PERFORMANCE_ENTRY_TYPES) {
+      if (!supported.has(type)) continue;
+      try {
+        const observer = new Observer((list) => {
+          for (const entry of list.getEntries()) {
+            void this.runHook(
+              "performance",
+              (instance) => _optionalChain([instance, 'access', _40 => _40.plugin, 'access', _41 => _41.performance, 'optionalCall', _42 => _42({
+                ...this.createStateEvent(instance),
+                entry,
+                location: this.getLocation()
+              })])
+            );
+          }
+        });
+        observer.observe({ type, buffered: true });
+        this.performanceObservers.push(observer);
+      } catch (error) {
+        void this.reportError(error, "performance");
+      }
+    }
+  }
+  async closeInternal(reason) {
+    if (this.closed) return;
+    if (this.startPromise) await this.startPromise;
+    this.closed = true;
+    _optionalChain([this, 'access', _43 => _43.currentNavigation, 'optionalAccess', _44 => _44.controller, 'access', _45 => _45.abort, 'call', _46 => _46(reason)]);
+    this.currentNavigation = void 0;
+    const clientWindow = this.options.window;
+    _optionalChain([clientWindow, 'optionalAccess', _47 => _47.removeEventListener, 'call', _48 => _48("error", this.handleWindowError)]);
+    _optionalChain([clientWindow, 'optionalAccess', _49 => _49.removeEventListener, 'call', _50 => _50("unhandledrejection", this.handleUnhandledRejection)]);
+    _optionalChain([clientWindow, 'optionalAccess', _51 => _51.removeEventListener, 'call', _52 => _52("pagehide", this.handlePageHide)]);
+    for (const observer of this.performanceObservers) observer.disconnect();
+    this.performanceObservers.length = 0;
+    _optionalChain([this, 'access', _53 => _53.runtimeErrorOverlay, 'optionalAccess', _54 => _54.destroy, 'call', _55 => _55()]);
+    for (const instance of [...this.instances].reverse()) {
+      try {
+        await _optionalChain([instance, 'access', _56 => _56.plugin, 'access', _57 => _57.close, 'optionalCall', _58 => _58({
+          ...this.createStateEvent(instance),
+          reason
+        })]);
+      } catch (error) {
+        this.logHookError(instance.registration.name, "close", error);
+      }
+    }
+  }
+  async runHook(hook, invoke) {
+    for (const instance of this.instances) {
+      try {
+        await invoke(instance);
+      } catch (error) {
+        this.logHookError(instance.registration.name, hook, error);
+        await this.runErrorHooks(
+          {
+            error,
+            phase: `plugin:${hook}`,
+            location: this.getLocation()
+          },
+          instance
+        );
+      }
+    }
+  }
+  async runErrorHooks(event, excluded, sourceEvent) {
+    _optionalChain([this, 'access', _59 => _59.runtimeErrorOverlay, 'optionalAccess', _60 => _60.show, 'call', _61 => _61(event.error, {
+      phase: event.phase,
+      location: event.location,
+      sourceEvent
+    })]);
+    for (const instance of this.instances) {
+      if (instance === excluded || !instance.plugin.error) continue;
+      try {
+        await instance.plugin.error({
+          ...this.createStateEvent(instance),
+          ...event
+        });
+      } catch (error) {
+        this.logHookError(instance.registration.name, "error", error);
+      }
+    }
+  }
+  createSetupEvent(instance) {
+    return {
+      plugin: {
+        name: instance.registration.name,
+        version: instance.registration.version
+      },
+      public: readonlyPublicData(instance.registration.public),
+      router: this.options.router,
+      isDev: Boolean(this.options.isDev),
+      isProd: Boolean(this.options.isProd),
+      deploymentId: this.options.deploymentId
+    };
+  }
+  createStateEvent(instance) {
+    return {
+      ...this.createSetupEvent(instance),
+      state: instance.state
+    };
+  }
+  getLocation() {
+    const href = _nullishCoalesce(_optionalChain([this, 'access', _62 => _62.options, 'access', _63 => _63.window, 'optionalAccess', _64 => _64.location, 'access', _65 => _65.href]), () => ( "http://localhost/"));
+    return toClientLocation(href, href);
+  }
+  getBaseUrl() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _66 => _66.options, 'access', _67 => _67.window, 'optionalAccess', _68 => _68.location, 'access', _69 => _69.href]), () => ( "http://localhost/"));
+  }
+  logHookError(name, hook, error) {
+    console.error(`[Farm.js] Client plugin "${name}" failed in ${hook}:`, error);
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _FarmClientPluginManager, "FarmClientPluginManager");
+var FarmClientPluginManager = _FarmClientPluginManager;
+function createClientPluginManager(registrations, options) {
+  return new FarmClientPluginManager(registrations, options);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createClientPluginManager, "createClientPluginManager");
+function sortRegistrations(registrations) {
+  const rank = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (enforce) => enforce === "pre" ? 0 : enforce === "post" ? 2 : 1, "rank");
+  return registrations.map((registration, index) => ({ registration, index })).sort(
+    (left, right) => rank(left.registration.enforce) - rank(right.registration.enforce) || left.index - right.index
+  ).map(({ registration }) => registration);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, sortRegistrations, "sortRegistrations");
+function toClientLocation(input, base) {
+  if (typeof input === "object" && "href" in input && "pathname" in input) {
+    return {
+      href: input.href,
+      pathname: input.pathname,
+      search: input.search,
+      hash: input.hash
+    };
+  }
+  const url = new URL(input, base);
+  return {
+    href: url.href,
+    pathname: url.pathname,
+    search: url.search,
+    hash: url.hash
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toClientLocation, "toClientLocation");
+function readonlyPublicData(value) {
+  if (value && typeof value === "object") {
+    return Object.freeze(value);
+  }
+  return value;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readonlyPublicData, "readonlyPublicData");
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, now, "now");
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isObject, "isObject");
+
+
+
+
+
+exports.defineClient = defineClient; exports.FarmClientPluginManager = FarmClientPluginManager; exports.createClientPluginManager = createClientPluginManager;