@epoch32/visage 1.1.3 → 1.1.4

package/dist/index-061jf06a.js

@@ -0,0 +1,848 @@
+import {
+  ERROR_CODE_TO_STATUS2,
+  RPCError2,
+  matchesRulePattern
+} from "./index-965ryh36.js";
+import {
+  validateWithSchema2
+} from "./index-2zz0g2n2.js";
+import {
+  createMutation2,
+  createQuery2
+} from "./index-y9bq7h9g.js";
+// src/api/client.ts
+async function resolveHeaders(headers, fullPath = "") {
+  if (!headers)
+    return {};
+  if (typeof headers === "function") {
+    return await headers();
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(headers)) {
+    if (typeof val === "object" || typeof val === "function") {
+      if (matchesRulePattern(key, fullPath, fullPath)) {
+        const resolved = typeof val === "function" ? await val() : val;
+        if (resolved && typeof resolved === "object") {
+          Object.assign(result, resolved);
+        }
+      }
+    } else if (typeof val === "string") {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function buildUrl(baseUrl, pathSegments, queryParams) {
+  const cleanBase = baseUrl.replace(/\/+$/, "");
+  const cleanPath = pathSegments.filter(Boolean).join("/");
+  let url = cleanPath ? `${cleanBase}/${cleanPath}` : cleanBase;
+  if (queryParams !== undefined && queryParams !== null) {
+    if (typeof queryParams === "object") {
+      const params = new URLSearchParams;
+      for (const [k, v] of Object.entries(queryParams)) {
+        if (v !== undefined && v !== null) {
+          if (typeof v === "object") {
+            params.set(k, JSON.stringify(v));
+          } else {
+            params.set(k, String(v));
+          }
+        }
+      }
+      const qs = params.toString();
+      if (qs) {
+        url += `${url.includes("?") ? "&" : "?"}${qs}`;
+      }
+    } else {
+      url += `${url.includes("?") ? "&" : "?"}input=${encodeURIComponent(String(queryParams))}`;
+    }
+  }
+  return url;
+}
+function createApiProxy(options, path = []) {
+  const handlerFn = (...args) => {
+    if (args.length > 0) {
+      return createApiProxy(options, [...path, String(args[0])]);
+    }
+    return createApiProxy(options, path);
+  };
+  return new Proxy(handlerFn, {
+    get(_target, prop) {
+      if (prop === "then")
+        return;
+      const fullPath = path.join("/");
+      if (prop === "get") {
+        return async (input, callOpts) => {
+          const fetchFn = options.fetch ?? globalThis.fetch;
+          const url = buildUrl(options.baseUrl, path, input);
+          const dynamicHeaders = await resolveHeaders(options.headers, fullPath);
+          const headers = {
+            Accept: "application/json",
+            ...dynamicHeaders,
+            ...callOpts?.headers
+          };
+          const devtools = typeof window !== "undefined" ? window.__VISAGE_DEVTOOLS__ : null;
+          const logId = devtools?.logRpcCall({
+            id: `api_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+            path: fullPath,
+            type: "query",
+            input
+          });
+          try {
+            const res = await fetchFn(url, {
+              method: "GET",
+              headers,
+              signal: callOpts?.signal
+            });
+            const contentType = res.headers.get("Content-Type") || "";
+            if (contentType.includes("application/json")) {
+              const body = await res.json();
+              if (body && typeof body === "object" && "ok" in body) {
+                if (!body.ok) {
+                  devtools?.updateRpcCall(logId, { status: "error", error: body.error });
+                  throw new RPCError2({
+                    code: body.error?.code || "INTERNAL_SERVER_ERROR",
+                    message: body.error?.message || "Request failed",
+                    issues: body.error?.issues
+                  });
+                }
+                devtools?.updateRpcCall(logId, { status: "success", response: body.data });
+                return body.data;
+              }
+              if (!res.ok) {
+                throw new Error(`Request failed with status ${res.status}`);
+              }
+              devtools?.updateRpcCall(logId, { status: "success", response: body });
+              return body;
+            }
+            if (!res.ok) {
+              throw new Error(`Request failed with status ${res.status}`);
+            }
+            const text = await res.text();
+            devtools?.updateRpcCall(logId, { status: "success", response: text });
+            return text;
+          } catch (err) {
+            devtools?.updateRpcCall(logId, { status: "error", error: err });
+            throw err;
+          }
+        };
+      }
+      if (prop === "post" || prop === "put" || prop === "patch" || prop === "delete" || prop === "del") {
+        const httpMethod = prop === "del" ? "DELETE" : prop.toUpperCase();
+        return async (body, callOpts) => {
+          const fetchFn = options.fetch ?? globalThis.fetch;
+          const url = buildUrl(options.baseUrl, path);
+          const dynamicHeaders = await resolveHeaders(options.headers, fullPath);
+          const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...dynamicHeaders,
+            ...callOpts?.headers
+          };
+          const devtools = typeof window !== "undefined" ? window.__VISAGE_DEVTOOLS__ : null;
+          const logId = devtools?.logRpcCall({
+            id: `api_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+            path: fullPath,
+            type: "mutation",
+            input: body
+          });
+          try {
+            const res = await fetchFn(url, {
+              method: httpMethod,
+              headers,
+              body: body !== undefined ? JSON.stringify(body) : undefined,
+              signal: callOpts?.signal
+            });
+            const contentType = res.headers.get("Content-Type") || "";
+            if (contentType.includes("application/json")) {
+              const resBody = await res.json();
+              if (resBody && typeof resBody === "object" && "ok" in resBody) {
+                if (!resBody.ok) {
+                  devtools?.updateRpcCall(logId, { status: "error", error: resBody.error });
+                  throw new RPCError2({
+                    code: resBody.error?.code || "INTERNAL_SERVER_ERROR",
+                    message: resBody.error?.message || "Request failed",
+                    issues: resBody.error?.issues
+                  });
+                }
+                devtools?.updateRpcCall(logId, { status: "success", response: resBody.data });
+                return resBody.data;
+              }
+              if (!res.ok) {
+                throw new Error(`Request failed with status ${res.status}`);
+              }
+              devtools?.updateRpcCall(logId, { status: "success", response: resBody });
+              return resBody;
+            }
+            if (!res.ok) {
+              throw new Error(`Request failed with status ${res.status}`);
+            }
+            const text = await res.text();
+            devtools?.updateRpcCall(logId, { status: "success", response: text });
+            return text;
+          } catch (err) {
+            devtools?.updateRpcCall(logId, { status: "error", error: err });
+            throw err;
+          }
+        };
+      }
+      if (prop === "subscribe") {
+        return (input, callbacks) => {
+          const fetchFn = options.fetch ?? globalThis.fetch;
+          const url = buildUrl(options.baseUrl, path, input);
+          const controller = new AbortController;
+          const devtools = typeof window !== "undefined" ? window.__VISAGE_DEVTOOLS__ : null;
+          const logId = devtools?.logRpcCall({
+            id: `api_sse_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+            path: fullPath,
+            type: "subscription",
+            input
+          });
+          (async () => {
+            try {
+              const dynamicHeaders = await resolveHeaders(options.headers, fullPath);
+              const headers = {
+                Accept: "text/event-stream",
+                ...dynamicHeaders
+              };
+              const res = await fetchFn(url, {
+                method: "GET",
+                headers,
+                signal: controller.signal
+              });
+              if (!res.ok || !res.body) {
+                throw new Error(`SSE stream failed with status ${res.status}`);
+              }
+              const reader = res.body.getReader();
+              const decoder = new TextDecoder;
+              let buffer = "";
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                  break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split(`
+
+`);
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                  const trimmed = line.trim();
+                  if (trimmed.startsWith("data:")) {
+                    const jsonStr = trimmed.slice(5).trim();
+                    try {
+                      const parsed = JSON.parse(jsonStr);
+                      devtools?.logRpcEvent(logId, parsed);
+                      callbacks.onData(parsed);
+                    } catch (parseErr) {
+                      devtools?.updateRpcCall(logId, { status: "error", error: parseErr });
+                      callbacks.onError?.(parseErr);
+                    }
+                  } else if (trimmed.startsWith("event: error")) {
+                    devtools?.updateRpcCall(logId, { status: "error" });
+                    callbacks.onError?.(new Error("Server SSE error"));
+                  }
+                }
+              }
+              callbacks.onComplete?.();
+            } catch (err) {
+              if (!controller.signal.aborted) {
+                callbacks.onError?.(err);
+              }
+            }
+          })();
+          return {
+            unsubscribe: () => {
+              controller.abort();
+            }
+          };
+        };
+      }
+      if (prop === "queryKey") {
+        return (input) => {
+          const resolved = typeof input === "function" ? input() : input;
+          const key = [...path];
+          if (resolved !== undefined)
+            key.push(resolved);
+          return key;
+        };
+      }
+      if (prop === "queryOptions") {
+        return (input, extra) => {
+          const resolved = typeof input === "function" ? input() : input;
+          const key = [...path];
+          if (resolved !== undefined)
+            key.push(resolved);
+          return {
+            queryKey: key,
+            queryFn: ({ signal }) => {
+              const proxy = createApiProxy(options, path);
+              return proxy.get(resolved, { signal });
+            },
+            ...extra
+          };
+        };
+      }
+      if (prop === "createQuery" || prop === "useQuery") {
+        return (input, extra) => {
+          const proxy = createApiProxy(options, path);
+          return createQuery2(() => proxy.queryOptions(input, extra));
+        };
+      }
+      if (prop === "mutationKey") {
+        return () => [...path];
+      }
+      if (prop === "mutationOptions") {
+        return (extra) => {
+          return {
+            mutationKey: [...path],
+            mutationFn: (body) => {
+              const proxy = createApiProxy(options, path);
+              return proxy.post(body);
+            },
+            ...extra
+          };
+        };
+      }
+      if (prop === "createMutation" || prop === "useMutation") {
+        return (extra) => {
+          const proxy = createApiProxy(options, path);
+          return createMutation2(proxy.mutationOptions(extra));
+        };
+      }
+      return createApiProxy(options, [...path, prop]);
+    }
+  });
+}
+function createApiClient2(options) {
+  return createApiProxy(options, []);
+}
+// src/api/pragma.ts
+var PRAGMA_REGEX = /(?:\/\/\s*@visage-middleware\s+([^\r\n]+))|(?:\/\*\s*@visage-middleware\s+([\s\S]*?)\*\/)/i;
+function parsePragma2(sourceCode) {
+  if (!sourceCode || typeof sourceCode !== "string") {
+    return { cascade: true, match: ["*"], exclude: [], priority: 0 };
+  }
+  const match = sourceCode.match(PRAGMA_REGEX);
+  if (!match) {
+    return { cascade: true, match: ["*"], exclude: [], priority: 0 };
+  }
+  const rawDirective = (match[1] || match[2] || "").trim();
+  const pragma = {
+    cascade: true,
+    match: ["*"],
+    exclude: [],
+    priority: 0
+  };
+  const pairs = rawDirective.split(/,(?![^[]*\])/);
+  for (const pair of pairs) {
+    const colonIdx = pair.indexOf(":");
+    if (colonIdx === -1)
+      continue;
+    const key = pair.slice(0, colonIdx).trim().toLowerCase();
+    const valStr = pair.slice(colonIdx + 1).trim();
+    if (key === "cascade") {
+      pragma.cascade = valStr === "true" || valStr === "1";
+    } else if (key === "priority") {
+      const num = Number.parseInt(valStr, 10);
+      if (!Number.isNaN(num))
+        pragma.priority = num;
+    } else if (key === "match" || key === "exclude") {
+      let items = [];
+      if (valStr.startsWith("[") && valStr.endsWith("]")) {
+        try {
+          items = JSON.parse(valStr.replace(/'/g, '"'));
+        } catch {
+          items = valStr.slice(1, -1).split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+        }
+      } else {
+        items = [valStr.replace(/^['"]|['"]$/g, "")];
+      }
+      if (key === "match")
+        pragma.match = items;
+      if (key === "exclude")
+        pragma.exclude = items;
+    }
+  }
+  return pragma;
+}
+function globToRegExp2(pattern) {
+  const normalized = pattern.trim().replace(/^\/+|\/+$/g, "");
+  if (normalized === "*" || normalized === "**" || normalized === "") {
+    return /^.*$/;
+  }
+  const escaped = normalized.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "___DOUBLE_STAR___").replace(/\*/g, "[^/]+").replace(/___DOUBLE_STAR___/g, ".*");
+  return new RegExp(`^(?:/)?${escaped}(?:/)?$`);
+}
+function matchesAnyPattern2(routePath, patterns) {
+  if (!patterns || patterns.length === 0)
+    return false;
+  const cleanPath = routePath.replace(/^\/+|\/+$/g, "");
+  for (const pat of patterns) {
+    const cleanPat = pat.replace(/^\/+|\/+$/g, "");
+    if (cleanPat === "*" || cleanPat === "**")
+      return true;
+    if (cleanPat === cleanPath)
+      return true;
+    if (globToRegExp2(cleanPat).test(cleanPath))
+      return true;
+  }
+  return false;
+}
+function shouldApplyMiddleware2(pragma, routePath, routeDir, middlewareDir) {
+  const normRouteDir = routeDir.replace(/^\/+|\/+$/g, "");
+  const normMwDir = middlewareDir.replace(/^\/+|\/+$/g, "");
+  const isDirectDir = normRouteDir === normMwDir;
+  const isSubDir = normMwDir === "" ? normRouteDir !== "" : normRouteDir.startsWith(`${normMwDir}/`);
+  if (!isDirectDir && !isSubDir) {
+    return false;
+  }
+  const isCascade = pragma.cascade ?? true;
+  if (isSubDir && !isCascade) {
+    return false;
+  }
+  let relativePath = routePath.replace(/^\/+|\/+$/g, "");
+  if (normMwDir && relativePath.startsWith(normMwDir)) {
+    relativePath = relativePath.slice(normMwDir.length).replace(/^\/+/, "");
+  }
+  if (pragma.exclude && pragma.exclude.length > 0) {
+    if (matchesAnyPattern2(routePath, pragma.exclude) || matchesAnyPattern2(relativePath, pragma.exclude)) {
+      return false;
+    }
+  }
+  if (!pragma.match || pragma.match.length === 0 || pragma.match.includes("*")) {
+    return true;
+  }
+  return matchesAnyPattern2(routePath, pragma.match) || matchesAnyPattern2(relativePath, pragma.match);
+}
+
+// src/api/file-router.ts
+function compileRoutePattern2(path) {
+  const paramNames = [];
+  const normalized = path.replace(/\/+$/, "") || "/";
+  const regexStr = normalized.replace(/:([a-zA-Z0-9_]+)/g, (_, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  }).replace(/\*([a-zA-Z0-9_]+)/g, (_, name) => {
+    paramNames.push(name);
+    return "(.*)";
+  });
+  const pattern = new RegExp(`^${regexStr}(?:/)?$`);
+  return { pattern, paramNames };
+}
+function normalizeFilePath2(rawPath) {
+  const cleaned = rawPath.replace(/^\.\//, "").replace(/\.(ts|tsx|js|jsx)$/, "").replace(/^(src\/)?(routes|api)\//, "");
+  const parts = cleaned.split("/").filter(Boolean);
+  const fileName = parts.pop() || "";
+  const isMiddleware = fileName === "_middleware";
+  const dirParts = [...parts];
+  const directory = `/${dirParts.join("/")}`.replace(/\/+$/, "") || "/";
+  if (isMiddleware) {
+    return {
+      isMiddleware: true,
+      routePath: directory,
+      directory
+    };
+  }
+  if (fileName !== "index") {
+    const transformedFile = fileName.replace(/\[\.\.\.([a-zA-Z0-9_]+)\]/g, "*$1").replace(/\[([a-zA-Z0-9_]+)\]/g, ":$1");
+    parts.push(transformedFile);
+  }
+  const routePath = `/${parts.join("/")}`.replace(/\/+$/, "") || "/";
+  return {
+    isMiddleware: false,
+    routePath,
+    directory
+  };
+}
+function buildFileRouter2(files, sourceMap = {}) {
+  const middlewaresByDir = [];
+  const rawRoutes = [];
+  for (const [filePath, mod] of Object.entries(files)) {
+    const { isMiddleware, routePath, directory } = normalizeFilePath2(filePath);
+    const sourceCode = sourceMap[filePath] || "";
+    const pragma = mod.pragma || parsePragma2(sourceCode);
+    if (isMiddleware) {
+      const mwFn = typeof mod === "function" ? mod : mod.middleware || mod.default;
+      if (typeof mwFn === "function") {
+        middlewaresByDir.push({
+          fn: mwFn,
+          pragma,
+          filePath,
+          directory
+        });
+      }
+    } else {
+      rawRoutes.push({
+        filePath,
+        routePath,
+        directory,
+        module: mod
+      });
+    }
+  }
+  middlewaresByDir.sort((a, b) => {
+    const dirA = a.directory || "/";
+    const dirB = b.directory || "/";
+    const depthA = dirA.split("/").filter(Boolean).length;
+    const depthB = dirB.split("/").filter(Boolean).length;
+    if (depthA !== depthB)
+      return depthA - depthB;
+    return (b.pragma.priority ?? 0) - (a.pragma.priority ?? 0);
+  });
+  const routes = [];
+  for (const raw of rawRoutes) {
+    const applicableMiddlewares = middlewaresByDir.filter((mw) => shouldApplyMiddleware2(mw.pragma, raw.routePath, raw.directory, mw.directory || "/"));
+    const { pattern, paramNames } = compileRoutePattern2(raw.routePath);
+    const procedures = {};
+    const mod = raw.module;
+    if (mod.default && typeof mod.default === "object" && "type" in mod.default) {
+      procedures.default = mod.default;
+    }
+    for (const [key, val] of Object.entries(mod)) {
+      if (val && typeof val === "object" && "type" in val && "options" in val) {
+        procedures[key] = val;
+      }
+    }
+    const handler = typeof mod.default === "function" && !("type" in mod.default) ? mod.default : undefined;
+    routes.push({
+      pattern,
+      paramNames,
+      routePath: raw.routePath,
+      filePath: raw.filePath,
+      directory: raw.directory,
+      procedures,
+      middlewares: applicableMiddlewares,
+      handler
+    });
+  }
+  routes.sort((a, b) => {
+    const isParamA = a.routePath.includes(":") || a.routePath.includes("*");
+    const isParamB = b.routePath.includes(":") || b.routePath.includes("*");
+    if (isParamA !== isParamB)
+      return isParamA ? 1 : -1;
+    return b.routePath.length - a.routePath.length;
+  });
+  return routes;
+}
+// src/api/middleware.ts
+async function executeMiddlewareChain2(middlewares, req, url, params, initialCtx = {}) {
+  let currentCtx = { ...initialCtx };
+  let earlyResponse;
+  let index = 0;
+  const runner = async () => {
+    if (index >= middlewares.length) {
+      return;
+    }
+    const currentMw = middlewares[index++];
+    const next = async (enriched) => {
+      if (enriched && typeof enriched === "object") {
+        currentCtx = { ...currentCtx, ...enriched };
+      }
+      await runner();
+      return currentCtx;
+    };
+    const result = await currentMw({
+      req,
+      ctx: currentCtx,
+      url,
+      params,
+      next
+    });
+    if (result instanceof Response) {
+      earlyResponse = result;
+    }
+  };
+  await runner();
+  return {
+    response: earlyResponse,
+    ctx: currentCtx
+  };
+}
+
+// src/api/handler.ts
+function handleCors(req, config) {
+  if (!config)
+    return null;
+  const origin = req.headers.get("Origin") || "*";
+  const isAllowed = !config.origin || config.origin === "*" || typeof config.origin === "function" && config.origin(origin) || Array.isArray(config.origin) && config.origin.includes(origin) || config.origin === origin;
+  if (req.method === "OPTIONS") {
+    const headers = new Headers;
+    if (isAllowed) {
+      headers.set("Access-Control-Allow-Origin", origin);
+    }
+    headers.set("Access-Control-Allow-Methods", (config.methods || ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"]).join(", "));
+    headers.set("Access-Control-Allow-Headers", (config.allowedHeaders || ["Content-Type", "Authorization", "x-visage-rpc"]).join(", "));
+    if (config.credentials) {
+      headers.set("Access-Control-Allow-Credentials", "true");
+    }
+    if (config.maxAge) {
+      headers.set("Access-Control-Max-Age", config.maxAge.toString());
+    }
+    return new Response(null, { status: 204, headers });
+  }
+  return null;
+}
+function applyCorsHeaders(res, req, config) {
+  if (!config)
+    return res;
+  const origin = req.headers.get("Origin") || "*";
+  res.headers.set("Access-Control-Allow-Origin", origin);
+  if (config.credentials) {
+    res.headers.set("Access-Control-Allow-Credentials", "true");
+  }
+  return res;
+}
+function createApiHandler2(routes, config = {}) {
+  const prefix = config.prefix ? `/${config.prefix.replace(/^\/+|\/+$/g, "")}` : "";
+  return async (req) => {
+    const corsPreflight = handleCors(req, config.cors);
+    if (corsPreflight)
+      return corsPreflight;
+    const url = new URL(req.url);
+    let pathname = url.pathname;
+    if (prefix && pathname.startsWith(prefix)) {
+      pathname = pathname.slice(prefix.length) || "/";
+    }
+    let matchedRoute = null;
+    const pathParams = {};
+    for (const route of routes) {
+      const match = pathname.match(route.pattern);
+      if (match) {
+        matchedRoute = route;
+        route.paramNames.forEach((name, i) => {
+          pathParams[name] = decodeURIComponent(match[i + 1] || "");
+        });
+        break;
+      }
+    }
+    if (!matchedRoute) {
+      return applyCorsHeaders(new Response(JSON.stringify({
+        ok: false,
+        error: { code: "NOT_FOUND", message: `Route not found: ${pathname}` }
+      }), { status: 404, headers: { "Content-Type": "application/json" } }), req, config.cors);
+    }
+    try {
+      const method = req.method.toUpperCase();
+      let procedure = matchedRoute.procedures.default;
+      if (!procedure) {
+        if (method === "GET") {
+          procedure = matchedRoute.procedures.GET || matchedRoute.procedures.get;
+        } else if (method === "POST") {
+          procedure = matchedRoute.procedures.POST || matchedRoute.procedures.post;
+        } else if (method === "PUT") {
+          procedure = matchedRoute.procedures.PUT || matchedRoute.procedures.put;
+        } else if (method === "DELETE") {
+          procedure = matchedRoute.procedures.DELETE || matchedRoute.procedures.del || matchedRoute.procedures.delete;
+        } else if (method === "PATCH") {
+          procedure = matchedRoute.procedures.PATCH || matchedRoute.procedures.patch;
+        }
+      }
+      const mwFns = [
+        ...matchedRoute.middlewares.map((m) => m.fn),
+        ...procedure?.middlewares || []
+      ];
+      const { response: earlyResponse, ctx } = await executeMiddlewareChain2(mwFns, req, url, pathParams);
+      if (earlyResponse) {
+        return applyCorsHeaders(earlyResponse, req, config.cors);
+      }
+      if (matchedRoute.handler) {
+        const res = await matchedRoute.handler(req, ctx);
+        return applyCorsHeaders(res, req, config.cors);
+      }
+      if (!procedure) {
+        return applyCorsHeaders(new Response(JSON.stringify({
+          ok: false,
+          error: {
+            code: "METHOD_NOT_ALLOWED",
+            message: `Method ${method} not allowed on ${pathname}`
+          }
+        }), { status: 405, headers: { "Content-Type": "application/json" } }), req, config.cors);
+      }
+      let rawInput = {};
+      if (method === "GET") {
+        const inputQuery = url.searchParams.get("input");
+        if (inputQuery) {
+          try {
+            rawInput = JSON.parse(inputQuery);
+          } catch {
+            rawInput = inputQuery;
+          }
+        } else {
+          const spObj = {};
+          url.searchParams.forEach((val, key) => {
+            spObj[key] = val;
+          });
+          if (Object.keys(spObj).length > 0) {
+            rawInput = spObj;
+          }
+        }
+      } else {
+        const contentType = req.headers.get("Content-Type") || "";
+        if (contentType.includes("application/json")) {
+          try {
+            rawInput = await req.json();
+          } catch {
+            rawInput = {};
+          }
+        }
+      }
+      if (typeof rawInput === "object" && rawInput !== null) {
+        rawInput = { ...pathParams, ...rawInput };
+      }
+      let validatedInput = rawInput;
+      if (procedure.options.input) {
+        const validation = await validateWithSchema2(procedure.options.input, rawInput);
+        if (!validation.success) {
+          return applyCorsHeaders(new Response(JSON.stringify({
+            ok: false,
+            error: {
+              code: "BAD_REQUEST",
+              message: "Validation Error",
+              issues: validation.issues
+            }
+          }), { status: 400, headers: { "Content-Type": "application/json" } }), req, config.cors);
+        }
+        validatedInput = validation.data;
+      }
+      if (procedure.type === "subscription") {
+        const generator = procedure.options.resolve({
+          input: validatedInput,
+          ctx,
+          req,
+          params: pathParams
+        });
+        const stream = new ReadableStream({
+          async start(controller) {
+            const encoder = new TextEncoder;
+            try {
+              for await (const chunk of generator) {
+                const payload = `data: ${JSON.stringify(chunk)}
+
+`;
+                controller.enqueue(encoder.encode(payload));
+              }
+              controller.close();
+            } catch (err) {
+              controller.error(err);
+            }
+          }
+        });
+        const sseRes = new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          }
+        });
+        return applyCorsHeaders(sseRes, req, config.cors);
+      }
+      const result = await procedure.options.resolve({
+        input: validatedInput,
+        ctx,
+        req,
+        params: pathParams
+      });
+      const successRes = new Response(JSON.stringify({ ok: true, data: result }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      });
+      return applyCorsHeaders(successRes, req, config.cors);
+    } catch (err) {
+      if (config.onError) {
+        const customRes = await config.onError(err, req);
+        return applyCorsHeaders(customRes, req, config.cors);
+      }
+      const statusCode = err instanceof RPCError2 ? err.statusCode : ERROR_CODE_TO_STATUS2[err?.code] || 500;
+      const code = err instanceof RPCError2 ? err.code : "INTERNAL_SERVER_ERROR";
+      const message = err?.message || "Internal Server Error";
+      const errRes = new Response(JSON.stringify({ ok: false, error: { code, message } }), {
+        status: statusCode,
+        headers: { "Content-Type": "application/json" }
+      });
+      return applyCorsHeaders(errRes, req, config.cors);
+    }
+  };
+}
+function createApi2(files, sourceMapOrConfig, maybeConfig) {
+  const sourceMap = sourceMapOrConfig && !("prefix" in sourceMapOrConfig) && !("cors" in sourceMapOrConfig) ? sourceMapOrConfig : {};
+  const config = maybeConfig || (sourceMapOrConfig && (("prefix" in sourceMapOrConfig) || ("cors" in sourceMapOrConfig)) ? sourceMapOrConfig : {});
+  const routes = buildFileRouter2(files, sourceMap);
+  const fetchHandler = createApiHandler2(routes, config);
+  return {
+    routes,
+    fetch: fetchHandler
+  };
+}
+// src/api/procedure.ts
+function query2(options) {
+  return {
+    type: "query",
+    options
+  };
+}
+function mutation2(options) {
+  return {
+    type: "mutation",
+    options
+  };
+}
+function subscription2(options) {
+  return {
+    type: "subscription",
+    options: {
+      ...options,
+      resolve: options.resolve
+    }
+  };
+}
+function defineMiddleware2(fn, pragma = { cascade: true, match: ["*"] }) {
+  return {
+    fn,
+    pragma
+  };
+}
+
+class ProcedureBuilder2 {
+  _middlewares = [];
+  _inputSchema;
+  constructor(middlewares = [], inputSchema) {
+    this._middlewares = middlewares;
+    this._inputSchema = inputSchema;
+  }
+  use(middleware) {
+    return new ProcedureBuilder2([...this._middlewares, middleware], this._inputSchema);
+  }
+  input(schema) {
+    return new ProcedureBuilder2(this._middlewares, schema);
+  }
+  query(resolve) {
+    return {
+      type: "query",
+      options: {
+        input: this._inputSchema,
+        resolve
+      },
+      middlewares: this._middlewares
+    };
+  }
+  mutation(resolve) {
+    return {
+      type: "mutation",
+      options: {
+        input: this._inputSchema,
+        resolve
+      },
+      middlewares: this._middlewares
+    };
+  }
+  subscription(resolve) {
+    return {
+      type: "subscription",
+      options: {
+        resolve
+      },
+      middlewares: this._middlewares
+    };
+  }
+}
+var procedure2 = new ProcedureBuilder2;
+export { createApiClient2, parsePragma2, globToRegExp2, matchesAnyPattern2, shouldApplyMiddleware2, compileRoutePattern2, normalizeFilePath2, buildFileRouter2, executeMiddlewareChain2, createApiHandler2, createApi2, query2, mutation2, subscription2, defineMiddleware2, ProcedureBuilder2, procedure2 };