@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-IK6LVLKC.cjs

@@ -0,0 +1,51 @@
+"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(); } }
+
+
+
+var _chunkLYLEZIG3cjs = require('./chunk-LYLEZIG3.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/docs/engine.ts
+var FARMING_LABS_DOCS_INSTALL_HINT = _chunkLYLEZIG3cjs.formatOptionalPeerInstallHint.call(void 0, 
+  "@farming-labs/docs",
+  "use the docs engine"
+);
+var engine;
+var loading;
+function loadFarmDocsEngine() {
+  _nullishCoalesce(loading, () => ( (loading = Promise.all([import("@farming-labs/docs"), import("@farming-labs/docs/server")]).then(
+    ([docs, server]) => {
+      engine = {
+        ...docs,
+        resolveApiReferenceOpenApiDiscovery: server.resolveApiReferenceOpenApiDiscovery
+      };
+      return engine;
+    },
+    (error) => {
+      loading = void 0;
+      if (!_chunkLYLEZIG3cjs.isMissingPackageError.call(void 0, error, "@farming-labs/docs")) throw error;
+      throw _chunkLYLEZIG3cjs.withOptionalPeerCause.call(void 0, 
+        new Error(
+          `docs is enabled, but @farming-labs/docs is not installed. ${FARMING_LABS_DOCS_INSTALL_HINT}`
+        ),
+        error
+      );
+    }
+  ))));
+  return loading;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loadFarmDocsEngine, "loadFarmDocsEngine");
+function docsEngine() {
+  if (!engine) {
+    throw new Error("Farm docs engine was used before loadFarmDocsEngine() resolved.");
+  }
+  return engine;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, docsEngine, "docsEngine");
+
+
+
+
+exports.loadFarmDocsEngine = loadFarmDocsEngine; exports.docsEngine = docsEngine;

package/dist/chunk-IOEH4VWN.mjs

@@ -0,0 +1,202 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/after.ts
+import { AsyncLocalStorage } from "async_hooks";
+var AFTER_STORAGE = /* @__PURE__ */ Symbol.for("@farm.js/core/after-storage");
+function getAfterStorage() {
+  const runtime = globalThis;
+  const existing = runtime[AFTER_STORAGE];
+  if (existing instanceof AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new AsyncLocalStorage();
+  runtime[AFTER_STORAGE] = storage;
+  return storage;
+}
+__name(getAfterStorage, "getAfterStorage");
+var afterStorage = getAfterStorage();
+function defaultAfterErrorReporter(error) {
+  console.error("[Farm.js] after() callback failed:", error);
+}
+__name(defaultAfterErrorReporter, "defaultAfterErrorReporter");
+function reportAfterError(state, error) {
+  try {
+    state.reportError(error);
+  } catch {
+  }
+}
+__name(reportAfterError, "reportAfterError");
+function createAfterRequestState(reportError = defaultAfterErrorReporter) {
+  let resolveResponseFinished;
+  let responseFinished = false;
+  const responseFinishedPromise = new Promise((resolve) => {
+    resolveResponseFinished = resolve;
+  });
+  const state = {
+    completion: Promise.resolve(),
+    finishResponse: /* @__PURE__ */ __name(() => {
+      if (responseFinished) return;
+      responseFinished = true;
+      resolveResponseFinished();
+    }, "finishResponse"),
+    phase: "open",
+    reportError,
+    tasks: []
+  };
+  state.completion = responseFinishedPromise.then(
+    () => afterStorage.run(state, async () => {
+      state.phase = "running";
+      for (let index = 0; index < state.tasks.length; index++) {
+        const task = state.tasks[index];
+        task.start();
+        try {
+          await task.result;
+        } catch (error) {
+          reportAfterError(state, error);
+        }
+      }
+      state.phase = "closed";
+    })
+  );
+  return state;
+}
+__name(createAfterRequestState, "createAfterRequestState");
+function registerPlatformLifetime(state, context) {
+  if (!context?.waitUntil) return;
+  try {
+    context.waitUntil(state.completion);
+  } catch (error) {
+    reportAfterError(state, error);
+  }
+}
+__name(registerPlatformLifetime, "registerPlatformLifetime");
+function registerResponseFinishedHook(state, context) {
+  if (!context?.onResponseFinished) return false;
+  try {
+    context.onResponseFinished(state.finishResponse);
+    return true;
+  } catch (error) {
+    reportAfterError(state, error);
+    return false;
+  }
+}
+__name(registerResponseFinishedHook, "registerResponseFinishedHook");
+function finishSoon(state) {
+  setTimeout(state.finishResponse, 0);
+}
+__name(finishSoon, "finishSoon");
+function wrapResponseBody(response, request, state) {
+  if (request.method === "HEAD" || response.status < 200 || response.status > 599 || !response.body || response.bodyUsed || response.body.locked) {
+    finishSoon(state);
+    return response;
+  }
+  const reader = response.body.getReader();
+  let released = false;
+  const releaseReader = /* @__PURE__ */ __name(() => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  }, "releaseReader");
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          releaseReader();
+          controller.close();
+          finishSoon(state);
+          return;
+        }
+        controller.enqueue(chunk.value);
+      } catch (error) {
+        releaseReader();
+        controller.error(error);
+        finishSoon(state);
+      }
+    },
+    cancel(reason) {
+      try {
+        return reader.cancel(reason);
+      } finally {
+        releaseReader();
+        finishSoon(state);
+      }
+    }
+  });
+  return new Response(body, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+__name(wrapResponseBody, "wrapResponseBody");
+function after(callback) {
+  if (typeof callback !== "function") {
+    throw new TypeError("after() expects a callback function.");
+  }
+  const state = afterStorage.getStore();
+  if (!state) {
+    throw new Error("after() can only be used while Farm is handling a server request.");
+  }
+  if (state.phase === "closed") {
+    throw new Error("after() cannot schedule work after the request lifecycle has completed.");
+  }
+  let start;
+  const ready = new Promise((resolve) => {
+    start = resolve;
+  });
+  const result = ready.then(callback);
+  state.tasks.push({ result, start });
+}
+__name(after, "after");
+async function _runWithAfterRequest(request, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  registerPlatformLifetime(state, context);
+  const hasResponseHook = registerResponseFinishedHook(state, context);
+  try {
+    const response = await afterStorage.run(state, handler);
+    return hasResponseHook ? response : wrapResponseBody(response, request, state);
+  } catch (error) {
+    finishSoon(state);
+    throw error;
+  }
+}
+__name(_runWithAfterRequest, "_runWithAfterRequest");
+async function _runWithAfterNodeResponse(response, handler, context) {
+  if (afterStorage.getStore()) {
+    return await handler();
+  }
+  const state = createAfterRequestState();
+  let finished = false;
+  const finish = /* @__PURE__ */ __name(() => {
+    if (finished) return;
+    finished = true;
+    response.off("finish", finish);
+    response.off("close", finish);
+    state.finishResponse();
+  }, "finish");
+  response.once("finish", finish);
+  response.once("close", finish);
+  if (response.writableEnded || response.destroyed) setTimeout(finish, 0);
+  registerPlatformLifetime(state, context);
+  return await afterStorage.run(state, handler);
+}
+__name(_runWithAfterNodeResponse, "_runWithAfterNodeResponse");
+function _withAfterNodeMiddleware(handler) {
+  return async (request, response, next) => {
+    await _runWithAfterNodeResponse(response, () => handler(request, response, next));
+  };
+}
+__name(_withAfterNodeMiddleware, "_withAfterNodeMiddleware");
+
+export {
+  after,
+  _runWithAfterRequest,
+  _runWithAfterNodeResponse,
+  _withAfterNodeMiddleware
+};

package/dist/chunk-IWZKTWHZ.cjs

@@ -0,0 +1,435 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkYWN746UScjs = require('./chunk-YWN746US.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");
+  }
+  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 _chunkYWN746UScjs.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;