@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-R62SF5R4.mjs

@@ -0,0 +1,410 @@
+import {
+  applyFarmCacheInvalidationTargets
+} from "./chunk-RLEALQEN.mjs";
+import {
+  isMultipartSchema
+} from "./chunk-YT3SLLZK.mjs";
+import {
+  assertBrowserStableRoutePath,
+  assertUniqueRouteParameters,
+  getRoutePatternShape
+} from "./chunk-AYP2YFVN.mjs";
+
+// src/api/endpoint.ts
+import { createEndpoint as betterCallEndpoint } from "better-call";
+var EndpointFailure = class extends Error {
+  constructor(code, data, options) {
+    super(options.message);
+    this.name = "EndpointFailure";
+    this.code = code;
+    this.data = data;
+    this.status = options.status;
+  }
+};
+function isEndpointFailure(value) {
+  return value instanceof EndpointFailure;
+}
+function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
+  let path;
+  let options;
+  let handler;
+  if (typeof pathOrOptions === "function") {
+    path = "";
+    options = {};
+    handler = pathOrOptions;
+  } else if (typeof pathOrOptions === "string") {
+    path = pathOrOptions;
+    options = optionsOrHandler;
+    handler = maybeHandler;
+  } else {
+    path = "";
+    options = pathOrOptions;
+    handler = optionsOrHandler;
+  }
+  if (typeof handler !== "function") {
+    throw new TypeError("createEndpoint requires a handler function");
+  }
+  if (options.use !== void 0) {
+    throw new TypeError(
+      "createEndpoint does not support the `use` option. Move these functions to `middleware`: each receives the endpoint context and returns an object, true, false, or a Response."
+    );
+  }
+  const middleware = normalizeEndpointMiddleware(options.middleware);
+  const errors = normalizeEndpointErrors(options.errors);
+  const error = createEndpointErrorHandler(errors);
+  const wrappedHandler = (async (ctx) => {
+    const execution = await runEndpointMiddleware(
+      middleware,
+      ctx,
+      handler,
+      error,
+      options.invalidates
+    );
+    return execution.result;
+  });
+  const {
+    middleware: _middleware,
+    errors: _errors,
+    invalidates: _invalidates,
+    openapi: _openapi,
+    mcp: _mcp,
+    ...betterCallOptions
+  } = options;
+  const endpoint = betterCallEndpoint(
+    path || "/__farm_auto_path__",
+    betterCallOptions,
+    wrappedHandler
+  );
+  endpoint.__path = path || void 0;
+  endpoint.__method = options.method || (path ? "GET" : void 0);
+  endpoint.__autoPath = !path;
+  endpoint.__handler = wrappedHandler;
+  endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, error, options.invalidates);
+  endpoint.__middleware = middleware;
+  endpoint.__sourceHandler = handler;
+  endpoint.__invalidates = options.invalidates;
+  endpoint.__errors = errors;
+  endpoint.__openapi = options.openapi;
+  endpoint.__mcp = options.mcp;
+  endpoint.__types = {
+    body: options.body,
+    inputBody: isMultipartSchema(options.body) ? "form-data" : options.body,
+    query: options.query,
+    inputQuery: options.query,
+    headers: options.headers,
+    response: null,
+    errors
+  };
+  return endpoint;
+}
+var EMPTY_ENDPOINT_MIDDLEWARE = Object.freeze([]);
+var EMPTY_ENDPOINT_CONTEXT = Object.freeze(/* @__PURE__ */ Object.create(null));
+var UNSAFE_ENDPOINT_CONTEXT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function normalizeEndpointErrors(definitions) {
+  if (definitions === void 0) return Object.freeze({});
+  if (!isPlainEndpointContext(definitions)) {
+    throw new TypeError("createEndpoint errors must be an object");
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [code, definition] of Object.entries(definitions)) {
+    if (!code.trim()) {
+      throw new TypeError("Endpoint error codes cannot be empty");
+    }
+    if (!definition || typeof definition !== "object") {
+      throw new TypeError(`Endpoint error "${code}" must be an object`);
+    }
+    if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
+      throw new TypeError(`Endpoint error "${code}" status must be an integer between 400 and 599`);
+    }
+    const dataSchema = resolveEndpointErrorSchema(definition);
+    if (!dataSchema || typeof dataSchema.parse !== "function") {
+      throw new TypeError(`Endpoint error "${code}" requires a data schema with parse()`);
+    }
+    if (definition.message !== void 0 && typeof definition.message !== "string") {
+      throw new TypeError(`Endpoint error "${code}" message must be a string`);
+    }
+    normalized[code] = Object.freeze({ ...definition });
+  }
+  return Object.freeze(normalized);
+}
+function resolveEndpointErrorSchema(definition) {
+  if (definition.data && definition.schema) {
+    throw new TypeError("Endpoint errors cannot define both data and schema");
+  }
+  return definition.data ?? definition.schema;
+}
+function createEndpointErrorHandler(definitions) {
+  return ((code, data) => {
+    const definition = definitions[code];
+    if (!definition) {
+      throw new TypeError(`Endpoint error "${code}" is not declared`);
+    }
+    const parsed = resolveEndpointErrorSchema(definition).parse(data);
+    throw new EndpointFailure(code, parsed, {
+      status: definition.status,
+      message: definition.message ?? "Request failed"
+    });
+  });
+}
+function normalizeEndpointMiddleware(middleware) {
+  if (middleware === void 0) return EMPTY_ENDPOINT_MIDDLEWARE;
+  if (!Array.isArray(middleware)) {
+    throw new TypeError("createEndpoint middleware must be an array of functions");
+  }
+  const normalized = [...middleware];
+  for (const entry of normalized) {
+    if (typeof entry !== "function") {
+      throw new TypeError("createEndpoint middleware entries must be functions");
+    }
+  }
+  return Object.freeze(normalized);
+}
+async function runEndpointMiddleware(middleware, handlerContext, handler, error, invalidations) {
+  let context = createInitialEndpointContext(handlerContext.context);
+  for (let index = 0; index < middleware.length; index++) {
+    const result2 = await middleware[index]({ ...handlerContext, context });
+    if (isEndpointResponse(result2)) {
+      return {
+        result: result2,
+        context,
+        handlerExecuted: false,
+        invalidations: []
+      };
+    }
+    if (result2 === false) {
+      return {
+        result: forbiddenEndpointResponse(),
+        context,
+        handlerExecuted: false,
+        invalidations: []
+      };
+    }
+    if (result2 === true) continue;
+    if (!isPlainEndpointContext(result2)) {
+      throw new TypeError(
+        `Endpoint middleware ${index + 1} must return an object, true, false, or a Response`
+      );
+    }
+    context = mergeEndpointContext(context, result2, index);
+  }
+  const result = await handler({ ...handlerContext, context, error, fail: error });
+  return {
+    result,
+    context,
+    handlerExecuted: true,
+    invalidations: await applyEndpointInvalidations(
+      invalidations,
+      {
+        ...handlerContext,
+        context,
+        result
+      },
+      result
+    )
+  };
+}
+async function applyEndpointInvalidations(declaration, context, result) {
+  if (!declaration || isEndpointResponse(result) && result.status >= 400) {
+    return [];
+  }
+  const targets = typeof declaration === "function" ? await declaration(context) : declaration;
+  if (!Array.isArray(targets)) {
+    throw new TypeError(
+      "Endpoint invalidates must resolve to an array of { key }, { path }, or { tag } targets"
+    );
+  }
+  return applyFarmCacheInvalidationTargets(targets);
+}
+function createInitialEndpointContext(value) {
+  if (value === void 0 || value === null) return EMPTY_ENDPOINT_CONTEXT;
+  if (!isPlainEndpointContext(value)) {
+    throw new TypeError("Endpoint context must be a plain object");
+  }
+  return mergeEndpointContext(EMPTY_ENDPOINT_CONTEXT, value);
+}
+function mergeEndpointContext(current, added, middlewareIndex) {
+  const next = Object.assign(/* @__PURE__ */ Object.create(null), current);
+  for (const key of Reflect.ownKeys(added)) {
+    if (!Object.prototype.propertyIsEnumerable.call(added, key)) continue;
+    if (typeof key === "string" && UNSAFE_ENDPOINT_CONTEXT_KEYS.has(key)) {
+      throw new TypeError(`Endpoint middleware cannot provide the unsafe context key "${key}"`);
+    }
+    if (Object.prototype.hasOwnProperty.call(current, key)) {
+      const source = middlewareIndex === void 0 ? "Endpoint context" : `Endpoint middleware ${middlewareIndex + 1}`;
+      throw new TypeError(`${source} cannot replace the existing context key "${String(key)}"`);
+    }
+    next[key] = added[key];
+  }
+  return Object.freeze(next);
+}
+function isPlainEndpointContext(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isEndpointResponse(value) {
+  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
+}
+function forbiddenEndpointResponse() {
+  return new Response(JSON.stringify({ error: "Forbidden" }), {
+    status: 403,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function GET(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "GET" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "GET" }, args[1]);
+}
+function HEAD(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "HEAD" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "HEAD" }, args[1]);
+}
+function QUERY(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "QUERY" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "QUERY" }, args[1]);
+}
+function POST(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "POST" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "POST" }, args[1]);
+}
+function PUT(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "PUT" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "PUT" }, args[1]);
+}
+function DELETE(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "DELETE" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "DELETE" }, args[1]);
+}
+function PATCH(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "PATCH" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "PATCH" }, args[1]);
+}
+function OPTIONS(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "OPTIONS" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "OPTIONS" }, args[1]);
+}
+
+// src/api/route.ts
+var unavailablePluginLocalAPI = Object.freeze({
+  available: false,
+  get() {
+    return void 0;
+  },
+  list() {
+    return [];
+  }
+});
+function createRouteFactory() {
+  return createRouteFactoryAt("");
+}
+function createRouteFactoryAt(prefix) {
+  const factory = {
+    scope(child) {
+      return createRouteFactoryAt(joinRoutePath(prefix, child));
+    }
+  };
+  for (const method of [
+    "GET",
+    "HEAD",
+    "QUERY",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "OPTIONS"
+  ]) {
+    factory[method.toLowerCase()] = (child, options) => {
+      const path = joinRoutePath(prefix, child);
+      const input = options.input ?? {};
+      const endpoint = createEndpoint(
+        path,
+        {
+          method,
+          body: input.body,
+          query: input.query,
+          headers: input.headers,
+          middleware: options.middleware,
+          mcp: options.mcp
+        },
+        (ctx) => options.handler(ctx.request, {
+          input: { body: ctx.body, query: ctx.query, headers: ctx.headers, params: ctx.params },
+          params: ctx.params,
+          context: ctx.context
+        })
+      );
+      endpoint.__types.params = input.params;
+      endpoint.__output = options.output;
+      return Object.freeze({ path, method, endpoint });
+    };
+  }
+  return Object.freeze(factory);
+}
+function joinRoutePath(prefix, child) {
+  if (typeof child !== "string") throw new TypeError("Route paths must be strings.");
+  const path = child === "" ? prefix : `${prefix}/${child.replace(/^\//, "")}`;
+  if (!(path === "/api" || path.startsWith("/api/")) || /[?#]|\/\/|\/$/.test(path)) {
+    throw new TypeError(
+      `Plugin route "${path}" must be a canonical /api path without a query, hash, or empty segment.`
+    );
+  }
+  assertBrowserStableRoutePath(path);
+  assertUniqueRouteParameters(path, "api");
+  getRoutePatternShape(path, "api");
+  for (const segment of path.split("/")) {
+    if (["__proto__", "constructor", "prototype", "$params"].includes(segment)) {
+      throw new TypeError(`Route segment "${segment}" is reserved.`);
+    }
+  }
+  return path;
+}
+function resolvePluginRoutes(plugins = [], context = {}) {
+  return plugins.flatMap((plugin) => {
+    if (!plugin.routes) return [];
+    const routes = plugin.routes({
+      route: createRouteFactory(),
+      api: context.api ?? unavailablePluginLocalAPI
+    });
+    if (!Array.isArray(routes))
+      throw new TypeError(`Plugin "${plugin.name}" routes must return an array synchronously.`);
+    for (const route of routes) {
+      if (!route || joinRoutePath("", route.path) !== route.path || typeof route.endpoint !== "function" || !["GET", "HEAD", "QUERY", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"].includes(
+        route.method
+      )) {
+        throw new TypeError(`Plugin "${plugin.name}" returned an invalid API route.`);
+      }
+    }
+    return routes;
+  });
+}
+
+export {
+  EndpointFailure,
+  isEndpointFailure,
+  createEndpoint,
+  GET,
+  HEAD,
+  QUERY,
+  POST,
+  PUT,
+  DELETE,
+  PATCH,
+  OPTIONS,
+  createRouteFactory,
+  resolvePluginRoutes
+};

package/dist/chunk-RD623KW4.cjs

@@ -0,0 +1,203 @@
+"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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/renderer.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _module = require('module');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _url = require('url');
+var DEFAULT_RENDERER_CAPABILITIES = Object.freeze({
+  streaming: Object.freeze({ node: false, web: false }),
+  // Conservative default: assume a re-render rebuilds until a renderer states
+  // otherwise, so callers do not silently rely on reconciliation.
+  reconcilesRerenders: false,
+  functionComponents: false
+});
+function getFarmRendererCapabilities(renderer) {
+  const defaultStreaming = {
+    node: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _ => _.capabilities, 'optionalAccess', _2 => _2.streaming, 'optionalAccess', _3 => _3.node]), () => ( DEFAULT_RENDERER_CAPABILITIES.streaming.node)),
+    web: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _4 => _4.capabilities, 'optionalAccess', _5 => _5.streaming, 'optionalAccess', _6 => _6.web]), () => ( DEFAULT_RENDERER_CAPABILITIES.streaming.web))
+  };
+  const runtimes = Object.fromEntries(
+    ["node", "edge"].flatMap((runtime) => {
+      const override = _optionalChain([renderer, 'optionalAccess', _7 => _7.capabilities, 'optionalAccess', _8 => _8.streaming, 'optionalAccess', _9 => _9.runtimes, 'optionalAccess', _10 => _10[runtime]]);
+      if (!override) return [];
+      return [
+        [
+          runtime,
+          {
+            node: _nullishCoalesce(override.node, () => ( defaultStreaming.node)),
+            web: _nullishCoalesce(override.web, () => ( defaultStreaming.web))
+          }
+        ]
+      ];
+    })
+  );
+  return {
+    streaming: {
+      ...defaultStreaming,
+      ...Object.keys(runtimes).length > 0 ? { runtimes } : {}
+    },
+    reconcilesRerenders: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _11 => _11.capabilities, 'optionalAccess', _12 => _12.reconcilesRerenders]), () => ( DEFAULT_RENDERER_CAPABILITIES.reconcilesRerenders)),
+    functionComponents: _nullishCoalesce(_optionalChain([renderer, 'optionalAccess', _13 => _13.capabilities, 'optionalAccess', _14 => _14.functionComponents]), () => ( DEFAULT_RENDERER_CAPABILITIES.functionComponents))
+  };
+}
+function getFarmRendererStreamingCapabilitiesForRuntime(renderer, runtime) {
+  const streaming = getFarmRendererCapabilities(renderer).streaming;
+  if (runtime === "unknown") return { node: streaming.node, web: streaming.web };
+  return _nullishCoalesce(_optionalChain([streaming, 'access', _15 => _15.runtimes, 'optionalAccess', _16 => _16[runtime]]), () => ( { node: streaming.node, web: streaming.web }));
+}
+function assertFarmRendererStreamingRuntime(name, renderer, runtimeModule, runtime) {
+  const declared = getFarmRendererStreamingCapabilitiesForRuntime(renderer, runtime);
+  const runtimeDeclaration = _optionalChain([runtimeModule, 'access', _17 => _17.capabilities, 'optionalAccess', _18 => _18.streaming]);
+  if (runtimeDeclaration) {
+    const advertised = getFarmRendererStreamingCapabilitiesForRuntime(
+      { capabilities: { streaming: runtimeDeclaration } },
+      runtime
+    );
+    if (declared.node && !advertised.node || declared.web && !advertised.web) {
+      throw new Error(
+        `Renderer \`${name}\` server module advertises ${JSON.stringify(advertised)} streaming for the ${runtime} runtime, which does not satisfy its descriptor ${JSON.stringify(declared)}.`
+      );
+    }
+  }
+  if (declared.node && typeof runtimeModule.renderToPipeableStream !== "function") {
+    throw new Error(
+      `Renderer \`${name}\` advertises Node streaming for the ${runtime} runtime but its server module does not export renderToPipeableStream().`
+    );
+  }
+  if (declared.web && typeof runtimeModule.renderToReadableStream !== "function") {
+    throw new Error(
+      `Renderer \`${name}\` advertises Web streaming for the ${runtime} runtime but its server module does not export renderToReadableStream().`
+    );
+  }
+  return declared;
+}
+var FARM_COMPONENT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+function resolveFarmComponentExtensions(extensions = []) {
+  return Array.from(
+    new Set(
+      [...FARM_COMPONENT_EXTENSIONS, ...extensions].map((extension) => {
+        const normalized = extension.trim().toLowerCase();
+        return normalized.startsWith(".") ? normalized : `.${normalized}`;
+      })
+    )
+  ).filter((extension) => extension.length > 1);
+}
+function getFarmRendererComponentExtensions(renderer) {
+  return resolveFarmComponentExtensions(_optionalChain([renderer, 'optionalAccess', _19 => _19.componentExtensions]));
+}
+var REACT_RENDERER = Object.freeze({
+  name: "react",
+  vite: "@farm.js/core/renderer/react/vite",
+  server: "@farm.js/core/renderer/react/server",
+  client: "@farm.js/core/renderer/react/client",
+  jsxImportSource: "react",
+  dedupe: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"],
+  optimizeDeps: [
+    "react",
+    "react-dom",
+    "react-dom/client",
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime"
+  ],
+  capabilities: {
+    streaming: {
+      node: true,
+      web: false,
+      runtimes: { edge: { node: false, web: true } }
+    },
+    reconcilesRerenders: true,
+    functionComponents: true
+  }
+});
+function defineRenderer(renderer) {
+  return renderer;
+}
+function resolveFarmRenderer(renderer) {
+  const resolved = renderer || REACT_RENDERER;
+  const fields = ["name", "vite", "server", "client"];
+  for (const field of fields) {
+    if (typeof resolved[field] !== "string" || resolved[field].trim().length === 0) {
+      throw new TypeError(`Farm renderer \`${field}\` must be a non-empty string.`);
+    }
+  }
+  if (resolved.appSetup !== void 0 && (typeof resolved.appSetup !== "string" || resolved.appSetup.trim().length === 0)) {
+    throw new TypeError("Farm renderer `appSetup` must be a non-empty module path.");
+  }
+  return {
+    ...resolved,
+    componentExtensions: [...resolved.componentExtensions || []],
+    dedupe: [...resolved.dedupe || []],
+    optimizeDeps: [...resolved.optimizeDeps || []],
+    buildConcurrency: resolved.buildConcurrency || "parallel",
+    capabilities: getFarmRendererCapabilities(resolved),
+    options: resolved.options ? { ...resolved.options } : void 0
+  };
+}
+async function readFarmRendererWebStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let html = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    html += typeof value === "string" ? value : decoder.decode(value, { stream: true });
+  }
+  return html + decoder.decode();
+}
+function isReactRenderer(renderer) {
+  return !renderer || renderer.name === "react";
+}
+function resolveFarmRendererAppSetup(root, renderer) {
+  if (!renderer.appSetup) return null;
+  const filePath = _path2.default.resolve(root, renderer.appSetup);
+  if (!_fs2.default.existsSync(filePath)) {
+    throw new Error(`Renderer \`${renderer.name}\` app setup module was not found: ${filePath}`);
+  }
+  return filePath;
+}
+function resolveFarmRendererModule(root, specifier) {
+  const requireFromApp = _module.createRequire.call(void 0, _path2.default.join(_path2.default.resolve(root), "package.json"));
+  return requireFromApp.resolve(specifier);
+}
+function createFarmReactJsxPlugin() {
+  return {
+    name: "farm:react-jsx",
+    config(config) {
+      if (this && _optionalChain([this, 'access', _20 => _20.meta, 'optionalAccess', _21 => _21.rolldownVersion])) return;
+      if (config.esbuild === false || _optionalChain([config, 'access', _22 => _22.esbuild, 'optionalAccess', _23 => _23.jsx]) !== void 0) return;
+      return { esbuild: { jsx: "automatic" } };
+    }
+  };
+}
+async function loadFarmRendererVitePlugins(renderer, root, options = {}) {
+  if (renderer.vite === REACT_RENDERER.vite) return [createFarmReactJsxPlugin()];
+  const modulePath = resolveFarmRendererModule(root, renderer.vite);
+  const rendererModule = await import(_url.pathToFileURL.call(void 0, modulePath).href);
+  if (typeof rendererModule.createFarmRendererPlugin !== "function") {
+    throw new Error(
+      `Renderer \`${renderer.name}\` module ${renderer.vite} must export createFarmRendererPlugin().`
+    );
+  }
+  const created = await rendererModule.createFarmRendererPlugin({
+    ...options,
+    rendererOptions: renderer.options
+  });
+  if (!created) return [];
+  return Array.isArray(created) ? [...created] : [created];
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.getFarmRendererCapabilities = getFarmRendererCapabilities; exports.getFarmRendererStreamingCapabilitiesForRuntime = getFarmRendererStreamingCapabilitiesForRuntime; exports.assertFarmRendererStreamingRuntime = assertFarmRendererStreamingRuntime; exports.FARM_COMPONENT_EXTENSIONS = FARM_COMPONENT_EXTENSIONS; exports.resolveFarmComponentExtensions = resolveFarmComponentExtensions; exports.getFarmRendererComponentExtensions = getFarmRendererComponentExtensions; exports.REACT_RENDERER = REACT_RENDERER; exports.defineRenderer = defineRenderer; exports.resolveFarmRenderer = resolveFarmRenderer; exports.readFarmRendererWebStream = readFarmRendererWebStream; exports.isReactRenderer = isReactRenderer; exports.resolveFarmRendererAppSetup = resolveFarmRendererAppSetup; exports.resolveFarmRendererModule = resolveFarmRendererModule; exports.loadFarmRendererVitePlugins = loadFarmRendererVitePlugins;

package/dist/chunk-RFKTJTWZ.mjs

@@ -0,0 +1,26 @@
+// src/trailing-slash.ts
+var FARM_TRAILING_SLASH_PREFERENCE = /* @__PURE__ */ Symbol.for("farm.trailingSlashPreference");
+function getFarmGlobalState() {
+  return globalThis;
+}
+function setFarmTrailingSlashPreference(enabled) {
+  getFarmGlobalState()[FARM_TRAILING_SLASH_PREFERENCE] = enabled === true;
+}
+function getFarmTrailingSlashPreference() {
+  return getFarmGlobalState()[FARM_TRAILING_SLASH_PREFERENCE] === true;
+}
+function normalizeFarmTrailingSlashPathname(pathname, enabled) {
+  if (pathname === "/") return pathname;
+  if (enabled) return pathname.endsWith("/") ? pathname : `${pathname}/`;
+  return pathname.replace(/\/+$/, "") || "/";
+}
+function resolveFarmTrailingSlashRedirect(url, enabled) {
+  const pathname = normalizeFarmTrailingSlashPathname(url.pathname, enabled);
+  return pathname === url.pathname ? null : `${pathname}${url.search}`;
+}
+
+export {
+  setFarmTrailingSlashPreference,
+  getFarmTrailingSlashPreference,
+  resolveFarmTrailingSlashRedirect
+};