@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-WROEFVNO.cjs

@@ -1,236 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
-
-var _chunkYX3DBN4Mcjs = require('./chunk-YX3DBN4M.cjs');
-
-
-
-
-
-var _chunkDVM4FKZLcjs = require('./chunk-DVM4FKZL.cjs');
-
-
-var _chunkOX6O6WVAcjs = require('./chunk-OX6O6WVA.cjs');
-
-
-var _chunkZTP3BJG6cjs = require('./chunk-ZTP3BJG6.cjs');
-
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/plugins/redirects.ts
-function createRedirectsPlugin(redirects, {
-  beforeRequest: overrideBeforeRequest,
-  afterResponse: overrideAfterResponse,
-  i18n
-} = {}) {
-  for (const redirect of redirects) {
-    if (redirect.statusCode !== void 0 && !_chunkOX6O6WVAcjs.isFarmRedirectStatus.call(void 0, redirect.statusCode)) {
-      throw new RangeError(
-        `Redirect "${redirect.source}" statusCode must be one of 301, 302, 303, 307, or 308.`
-      );
-    }
-  }
-  const compiledRedirects = redirects.map((redirect) => ({
-    redirect,
-    pattern: _chunkDVM4FKZLcjs.compileConfigRoutePattern.call(void 0, redirect.source)
-  }));
-  return {
-    name: "farm:redirects",
-    enforce: "pre",
-    async beforeRequest(req, res, context) {
-      if (overrideBeforeRequest) {
-        await overrideBeforeRequest(req, res, context);
-      }
-      const url = _chunkZTP3BJG6cjs.resolveFarmRequestURL.call(void 0, req);
-      const routePath = _chunkDVM4FKZLcjs.resolveConfigRoutePathname.call(void 0, url.pathname, i18n);
-      const pathname = routePath.pathname;
-      for (const { redirect, pattern } of compiledRedirects) {
-        const match = pathname.match(pattern.regex);
-        if (match) {
-          const localizedDestination = _chunkDVM4FKZLcjs.localizeConfigRouteDestination.call(void 0, 
-            _chunkDVM4FKZLcjs.interpolateConfigRouteDestination.call(void 0, redirect.destination, match, pattern.tokens),
-            routePath.locale,
-            i18n
-          );
-          const destination = _chunkYX3DBN4Mcjs.appendFarmRedirectQuery.call(void 0, localizedDestination, url.search);
-          const statusCode = _nullishCoalesce(redirect.statusCode, () => ( (redirect.permanent ? 308 : 307)));
-          res.writeHead(statusCode, {
-            Location: destination
-          });
-          res.end();
-          return;
-        }
-      }
-    },
-    async afterResponse(req, res, context) {
-      if (overrideAfterResponse) {
-        await overrideAfterResponse(req, res, context);
-      }
-    }
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createRedirectsPlugin, "createRedirectsPlugin");
-
-// src/plugins/headers.ts
-var FARM_CONFIG_HEADERS_FINALIZER = /* @__PURE__ */ Symbol.for("farm.configHeadersFinalizer");
-function appendConfiguredLinkHeader(res, value) {
-  const current = res.getHeader("Link");
-  if (current === void 0) {
-    res.setHeader("Link", value);
-    return;
-  }
-  const currentValue = Array.isArray(current) ? current.join(", ") : String(current);
-  if (currentValue !== value && !currentValue.endsWith(`, ${value}`)) {
-    res.setHeader("Link", `${currentValue}, ${value}`);
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, appendConfiguredLinkHeader, "appendConfiguredLinkHeader");
-function appendConfiguredSetCookieHeader(res, value) {
-  const current = res.getHeader("Set-Cookie");
-  if (current === void 0) {
-    res.setHeader("Set-Cookie", value);
-    return;
-  }
-  const values = (Array.isArray(current) ? current : [current]).map(String);
-  if (!values.includes(value)) {
-    res.setHeader("Set-Cookie", [...values, value]);
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, appendConfiguredSetCookieHeader, "appendConfiguredSetCookieHeader");
-function applyResponseHeaders(res, matchedHeaders) {
-  for (const headers of matchedHeaders) {
-    for (const header of headers) {
-      const key = header.key.toLowerCase();
-      if (key === "link") {
-        appendConfiguredLinkHeader(res, header.value);
-      } else if (key === "set-cookie") {
-        appendConfiguredSetCookieHeader(res, header.value);
-      } else {
-        res.setHeader(header.key, header.value);
-      }
-    }
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, applyResponseHeaders, "applyResponseHeaders");
-function applyWriteHeadHeaders(res, headers) {
-  if (Array.isArray(headers)) {
-    let setCookieWritten = false;
-    for (let index = 0; index + 1 < headers.length; index += 2) {
-      const key = String(headers[index]);
-      const value = headers[index + 1];
-      if (key.toLowerCase() === "set-cookie" && setCookieWritten) {
-        const current = res.getHeader("Set-Cookie");
-        const values = (Array.isArray(current) ? current : [current]).filter(
-          (entry) => entry !== void 0
-        );
-        res.setHeader("Set-Cookie", [...values, ...Array.isArray(value) ? value : [value]]);
-      } else {
-        res.setHeader(key, value);
-        if (key.toLowerCase() === "set-cookie") setCookieWritten = true;
-      }
-    }
-    return;
-  }
-  if (!headers || typeof headers !== "object") return;
-  for (const [key, value] of Object.entries(headers)) {
-    if (value !== void 0) res.setHeader(key, value);
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, applyWriteHeadHeaders, "applyWriteHeadHeaders");
-function createHeadersPlugin(headers, {
-  beforeRequest: overrideBeforeRequest,
-  afterResponse: overrideAfterResponse,
-  i18n
-} = {}) {
-  const compiledHeaders = headers.map((config) => ({
-    config,
-    pattern: _chunkDVM4FKZLcjs.compileConfigRoutePattern.call(void 0, config.source)
-  }));
-  return {
-    name: "farm:headers",
-    enforce: "pre",
-    async beforeRequest(req, res, context) {
-      if (overrideBeforeRequest) {
-        await overrideBeforeRequest(req, res, context);
-      }
-      const url = _chunkZTP3BJG6cjs.resolveFarmRequestURL.call(void 0, req);
-      const pathname = _chunkDVM4FKZLcjs.resolveConfigRoutePathname.call(void 0, url.pathname, i18n).pathname;
-      const matchedHeaders = compiledHeaders.filter(({ pattern }) => pattern.regex.test(pathname)).map(({ config }) => config.headers);
-      applyResponseHeaders(res, matchedHeaders);
-      const responseWithFinalizer = res;
-      if (matchedHeaders.length === 0 || responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER]) {
-        return;
-      }
-      responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER] = true;
-      const writeHead = res.writeHead;
-      res.writeHead = ((statusCode, ...args) => {
-        const statusMessage = typeof args[0] === "string" ? args.shift() : void 0;
-        applyWriteHeadHeaders(res, args[0]);
-        applyResponseHeaders(res, matchedHeaders);
-        return statusMessage === void 0 ? writeHead.call(res, statusCode) : writeHead.call(res, statusCode, statusMessage);
-      });
-    },
-    async afterResponse(req, res, context) {
-      if (overrideAfterResponse) {
-        await overrideAfterResponse(req, res, context);
-      }
-    }
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createHeadersPlugin, "createHeadersPlugin");
-
-// src/plugins/env.ts
-function createEnvPlugin(env, {
-  beforeRequest: overrideBeforeRequest,
-  afterResponse: overrideAfterResponse
-} = {}) {
-  return {
-    name: "farm:env",
-    configResolved(config, context) {
-      for (const [key, value] of Object.entries(env)) {
-        process.env[key] = value;
-      }
-    },
-    async beforeRequest(req, res, context) {
-      if (overrideBeforeRequest) {
-        await overrideBeforeRequest(req, res, context);
-      }
-    },
-    async afterResponse(req, res, context) {
-      if (overrideAfterResponse) {
-        await overrideAfterResponse(req, res, context);
-      }
-    }
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createEnvPlugin, "createEnvPlugin");
-
-// src/plugins/logger.ts
-function createLoggerPlugin({
-  beforeRequest,
-  afterResponse
-} = {}) {
-  const plugin = {
-    name: "farm:logger",
-    enforce: "post"
-  };
-  if (beforeRequest) {
-    plugin.beforeRequest = async (req, res, context) => {
-      await beforeRequest(req, res, context);
-    };
-  }
-  if (afterResponse) {
-    plugin.afterResponse = async (req, res, context) => {
-      await afterResponse(req, res, context);
-    };
-  }
-  return plugin;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createLoggerPlugin, "createLoggerPlugin");
-
-
-
-
-
-
-exports.createRedirectsPlugin = createRedirectsPlugin; exports.createHeadersPlugin = createHeadersPlugin; exports.createEnvPlugin = createEnvPlugin; exports.createLoggerPlugin = createLoggerPlugin;

package/dist/chunk-WU7ZS3EM.cjs

@@ -1,440 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
-
-var _chunk6MVFHNYZcjs = require('./chunk-6MVFHNYZ.cjs');
-
-
-var _chunkARJWXNQLcjs = require('./chunk-ARJWXNQL.cjs');
-
-
-
-
-var _chunkNO3WWW3Ncjs = require('./chunk-NO3WWW3N.cjs');
-
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/api/endpoint.ts
-var _bettercall = require('better-call');
-var _EndpointFailure = class _EndpointFailure extends Error {
-  constructor(code, data, options) {
-    super(options.message);
-    this.name = "EndpointFailure";
-    this.code = code;
-    this.data = data;
-    this.status = options.status;
-  }
-};
-_chunkS3JO3N4Hcjs.__name.call(void 0, _EndpointFailure, "EndpointFailure");
-var EndpointFailure = _EndpointFailure;
-function isEndpointFailure(value) {
-  return value instanceof EndpointFailure;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isEndpointFailure, "isEndpointFailure");
-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 = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (async (ctx) => {
-    const execution = await runEndpointMiddleware(
-      middleware,
-      ctx,
-      handler,
-      error,
-      options.invalidates
-    );
-    return execution.result;
-  }), "wrappedHandler");
-  const {
-    middleware: _middleware,
-    errors: _errors,
-    invalidates: _invalidates,
-    openapi: _openapi,
-    mcp: _mcp,
-    ...betterCallOptions
-  } = options;
-  const endpoint = _bettercall.createEndpoint.call(void 0, 
-    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: _chunkARJWXNQLcjs.isMultipartSchema.call(void 0, options.body) ? "form-data" : options.body,
-    query: options.query,
-    inputQuery: options.query,
-    headers: options.headers,
-    response: null,
-    errors
-  };
-  return endpoint;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createEndpoint, "createEndpoint");
-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);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeEndpointErrors, "normalizeEndpointErrors");
-function resolveEndpointErrorSchema(definition) {
-  if (definition.data && definition.schema) {
-    throw new TypeError("Endpoint errors cannot define both data and schema");
-  }
-  return _nullishCoalesce(definition.data, () => ( definition.schema));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, resolveEndpointErrorSchema, "resolveEndpointErrorSchema");
-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: _nullishCoalesce(definition.message, () => ( "Request failed"))
-    });
-  });
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createEndpointErrorHandler, "createEndpointErrorHandler");
-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);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeEndpointMiddleware, "normalizeEndpointMiddleware");
-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
-    )
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, runEndpointMiddleware, "runEndpointMiddleware");
-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 _chunk6MVFHNYZcjs.applyFarmCacheInvalidationTargets.call(void 0, targets);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, applyEndpointInvalidations, "applyEndpointInvalidations");
-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);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createInitialEndpointContext, "createInitialEndpointContext");
-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);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, mergeEndpointContext, "mergeEndpointContext");
-function isPlainEndpointContext(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isPlainEndpointContext, "isPlainEndpointContext");
-function isEndpointResponse(value) {
-  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isEndpointResponse, "isEndpointResponse");
-function forbiddenEndpointResponse() {
-  return new Response(JSON.stringify({ error: "Forbidden" }), {
-    status: 403,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, forbiddenEndpointResponse, "forbiddenEndpointResponse");
-function GET(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "GET" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "GET" }, args[1]);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, GET, "GET");
-function HEAD(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "HEAD" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "HEAD" }, args[1]);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, HEAD, "HEAD");
-function QUERY(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "QUERY" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "QUERY" }, args[1]);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, QUERY, "QUERY");
-function POST(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "POST" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "POST" }, args[1]);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, POST, "POST");
-function PUT(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "PUT" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "PUT" }, args[1]);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, PUT, "PUT");
-function DELETE(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "DELETE" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "DELETE" }, args[1]);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, DELETE, "DELETE");
-function PATCH(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "PATCH" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "PATCH" }, args[1]);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, PATCH, "PATCH");
-function OPTIONS(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "OPTIONS" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "OPTIONS" }, args[1]);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, OPTIONS, "OPTIONS");
-
-// src/api/route.ts
-var unavailablePluginLocalAPI = Object.freeze({
-  available: false,
-  get() {
-    return void 0;
-  },
-  list() {
-    return [];
-  }
-});
-function createRouteFactory() {
-  return createRouteFactoryAt("");
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createRouteFactory, "createRouteFactory");
-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 = _nullishCoalesce(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);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createRouteFactoryAt, "createRouteFactoryAt");
-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.`
-    );
-  }
-  _chunkNO3WWW3Ncjs.assertBrowserStableRoutePath.call(void 0, path);
-  _chunkNO3WWW3Ncjs.assertUniqueRouteParameters.call(void 0, path, "api");
-  _chunkNO3WWW3Ncjs.getRoutePatternShape.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, joinRoutePath, "joinRoutePath");
-function resolvePluginRoutes(plugins = [], context = {}) {
-  return plugins.flatMap((plugin) => {
-    if (!plugin.routes) return [];
-    const routes = plugin.routes({
-      route: createRouteFactory(),
-      api: _nullishCoalesce(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;
-  });
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, resolvePluginRoutes, "resolvePluginRoutes");
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.EndpointFailure = EndpointFailure; exports.isEndpointFailure = isEndpointFailure; exports.createEndpoint = createEndpoint; exports.GET = GET; exports.HEAD = HEAD; exports.QUERY = QUERY; exports.POST = POST; exports.PUT = PUT; exports.DELETE = DELETE; exports.PATCH = PATCH; exports.OPTIONS = OPTIONS; exports.createRouteFactory = createRouteFactory; exports.resolvePluginRoutes = resolvePluginRoutes;