eddev 2.0.0-beta.57 → 2.0.0-beta.58

package/dist/app/entry/spa-root.js

@@ -1,9 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { QueryClientProvider } from "@tanstack/react-query";
-import { BrowserRouter } from "../lib/routing/components/BrowserRouter.js";
-import { getQueryClient } from "../utils/query-client.js";
-import { DevUILoader } from "../lib/devtools/loader.js";
 import { Suspense } from "react";
+import { DevUILoader } from "../lib/devtools/loader.js";
+import { BrowserRouter } from "../lib/routing/components/BrowserRouter.js";
+import { APIProvider } from "../utils/APIProvider.js";
 export function SPARoot() {
-    return (_jsxs(QueryClientProvider, { client: getQueryClient(), children: [_jsx(Suspense, { children: _jsx(BrowserRouter, {}) }), _jsx(DevUILoader, {})] }));
+    return (_jsxs(APIProvider, { children: [_jsx(Suspense, { children: _jsx(BrowserRouter, {}) }), _jsx(DevUILoader, {})] }));
 }

package/dist/app/entry/ssr-root-client.js

@@ -1,14 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { QueryClientProvider } from "@tanstack/react-query";
 import { Suspense, useEffect, useState } from "react";
+import { useSnapshot } from "valtio";
 import { DevUILoader } from "../lib/devtools/loader.js";
 import { BrowserRouter } from "../lib/routing/components/BrowserRouter.js";
-import { getQueryClient } from "../utils/query-client.js";
-import { MetaTags } from "./MetaTags.js";
-import { useSnapshot } from "valtio";
 import { clientMetaTags } from "../lib/routing/context.js";
+import { APIProvider } from "../utils/APIProvider.js";
+import { MetaTags } from "./MetaTags.js";
 export function SSRClientRoot(props) {
-    return (_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [_jsx(DynamicMetaTags, { tags: props.metaTags }), _jsx(Trackers, { position: "head" }), props.assets] }), _jsxs("body", { children: [_jsx(Trackers, { position: "body" }), _jsxs(QueryClientProvider, { client: getQueryClient(), children: [_jsx(Suspense, { children: _jsx(BrowserRouter, {}) }), _jsx(DevUILoader, {})] }), _jsx(Trackers, { position: "footer" })] })] }));
+    return (_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [_jsx(DynamicMetaTags, { tags: props.metaTags }), _jsx(Trackers, { position: "head" }), props.assets] }), _jsxs("body", { children: [_jsx(Trackers, { position: "body" }), _jsxs(APIProvider, { children: [_jsx(Suspense, { children: _jsx(BrowserRouter, {}) }), _jsx(DevUILoader, {})] }), _jsx(Trackers, { position: "footer" })] })] }));
 }
 function DynamicMetaTags(props) {
     const dynamicTags = useSnapshot(clientMetaTags).tags;

package/dist/app/entry/ssr-root.js

@@ -1,15 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { QueryClientProvider } from "@tanstack/react-query";
 import { Suspense } from "react";
 import { SSRRouter } from "../lib/routing/components/SSRRouter.js";
 import { getRouteMeta, normalizeRoute } from "../lib/routing/utils.js";
-import { getQueryClient } from "../utils/query-client.js";
+import { APIProvider } from "../utils/APIProvider.js";
 import { MetaTags } from "./MetaTags.js";
 export function SSRRoot(props) {
     const loader = props.loader;
     loader.setAppData(props.initialData.appData.data);
     loader.populateRouteData(props.pathname, props.initialData);
-    return (_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [_jsx(MetaTags, { tags: props.metaTags }), props.assets] }), _jsx("body", { children: _jsx(QueryClientProvider, { client: getQueryClient(), children: _jsx(Suspense, { children: _jsx(SSRRouter, { loader: loader, route: normalizeRoute({
+    return (_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [_jsx(MetaTags, { tags: props.metaTags }), props.assets] }), _jsx("body", { children: _jsx(APIProvider, { children: _jsx(Suspense, { children: _jsx(SSRRouter, { loader: loader, route: normalizeRoute({
                                 id: "initial",
                                 component: loader.getRouteComponent(props.initialData.view),
                                 key: "",

package/dist/app/lib/blocks/editor/EditorSupport.js

@@ -1,8 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { QueryClientProvider } from "@tanstack/react-query";
 import { createContext, Suspense, useContext } from "react";
-import { getQueryClient } from "../../../utils/query-client.js";
 import { blockManifestReader } from "../../internal/read-block-manifest.js";
+import { APIProvider } from "../../../utils/APIProvider.js";
 import { ErrorBoundaryEditor } from "./ErrorBoundaryEditor.js";
 export const BlockContext = createContext(undefined);
 export function EditableBlock({ payload }) {
@@ -15,5 +14,5 @@ export function EditableBlock({ payload }) {
     const BlockComponent = getBlock();
     if (!BlockComponent)
         return _jsx("div", { children: "Unable to load block component" });
-    return (_jsx(ErrorBoundaryEditor, { children: _jsx(QueryClientProvider, { client: getQueryClient(), children: _jsx(Suspense, { children: _jsx(BlockComponent, { ...payload }) }) }) }));
+    return (_jsx(ErrorBoundaryEditor, { children: _jsx(APIProvider, { children: _jsx(Suspense, { children: _jsx(BlockComponent, { ...payload }) }) }) }));
 }

package/dist/app/lib/hooks/queryUtils.d.ts

@@ -1,4 +1,5 @@
 import { FetchQueryOptions, UndefinedInitialDataInfiniteOptions, UndefinedInitialDataOptions, UseInfiniteQueryResult, UseMutationOptions, UseMutationResult, UseQueryResult } from "@tanstack/react-query";
+import { TRPCClientError } from "@trpc/client";
 type OptionalMaybes<T> = T extends any[] ? T : T extends {
     [key: string]: any;
 } ? {
@@ -53,4 +54,30 @@ export type UseMutationFunction<TData, TArgs> = ((options?: Omit<UseMutationOpti
     }) => Promise<TData>;
 };
 export declare function createUseMutation<TData extends any, TArgs extends MaybeVars>(init: CreateUseQueryOptions): UseMutationFunction<TData, TArgs>;
+type RPCQueryName = RPCRouter["queries"]["key"];
+type RPCQueryResult<T> = Extract<RPCRouter["queries"], {
+    key: T;
+}>["output"];
+type RPCQueryInput<T> = Extract<RPCRouter["queries"], {
+    key: T;
+}>["input"];
+type RPCQueryError<T> = TRPCClientError<Extract<RPCRouter["queries"], {
+    key: T;
+}>["procedure"]>;
+export declare function useRPCQuery<TName extends RPCQueryName>(key: TName, args: OptionalMaybes<RPCQueryInput<TName>>, options?: Omit<UndefinedInitialDataOptions<RPCQueryResult<TName>, RPCQueryError<TName>, RPCQueryResult<TName>>, "queryKey" | "queryFn"> & {
+    headers?: Record<string, string>;
+}): UseQueryResult<RPCQueryResult<TName>, RPCQueryError<TName>>;
+type RPCMutationName = RPCRouter["mutations"]["key"];
+type RPCMutationResult<T> = Extract<RPCRouter["mutations"], {
+    key: T;
+}>["output"];
+type RPCMutationInput<T> = Extract<RPCRouter["mutations"], {
+    key: T;
+}>["input"];
+type RPCMutationError<T> = TRPCClientError<Extract<RPCRouter["mutations"], {
+    key: T;
+}>["procedure"]>;
+export declare function useRPCMutation<TName extends RPCMutationName>(key: TName, options?: Omit<UseMutationOptions<RPCMutationResult<TName>, RPCMutationError<TName>, RPCMutationInput<TName>>, "mutationFn"> & {
+    headers?: Record<string, string>;
+}): UseMutationResult<RPCMutationResult<TName>, RPCMutationError<TName>, RPCMutationInput<TName>>;
 export {};

package/dist/app/lib/hooks/queryUtils.js

@@ -2,6 +2,7 @@ import { useInfiniteQuery, useMutation, useQuery, } from "@tanstack/react-query"
 import { useEffect, useState } from "react";
 import { joinURL } from "ufo";
 import { getQueryClient } from "../../utils/query-client.js";
+import { getRPCClient } from "../../utils/trpc-client.js";
 import { apiConfig } from "../runtime/apiConfig.js";
 class QueryError extends Error {
     name = "QueryError";
@@ -52,8 +53,8 @@ export function createUseQuery(init) {
     const hook = (args, options) => {
         const customKey = apiConfig.customQueryKey;
         return useQuery({
-            queryKey: [init.name, args, options?.headers, options?.headers, customKey],
-            queryFn: (args) => fetchGETQuery(init.name, args.queryKey[1] ? JSON.stringify(args.queryKey[1]) : "", {
+            queryKey: ["query", init.name, args, options?.headers, customKey],
+            queryFn: (args) => fetchGETQuery(init.name, args.queryKey[2] ? JSON.stringify(args.queryKey[2]) : "", {
                 headers: options?.headers,
             }),
             ...options,
@@ -62,8 +63,8 @@ export function createUseQuery(init) {
     hook.fetch = async (args, options) => {
         const customKey = apiConfig.customQueryKey;
         return getQueryClient().fetchQuery({
-            queryKey: [init.name, args, options?.headers, options?.headers, customKey],
-            queryFn: (args) => fetchGETQuery(init.name, args.queryKey[1] ? JSON.stringify(args.queryKey[1]) : "", {
+            queryKey: ["query", init.name, args, options?.headers, customKey],
+            queryFn: (args) => fetchGETQuery(init.name, args.queryKey[2] ? JSON.stringify(args.queryKey[2]) : "", {
                 headers: options?.headers,
             }),
             ...options,
@@ -99,11 +100,11 @@ export function createUseInfiniteQuery(init) {
             });
         }, []);
         return useInfiniteQuery({
-            queryKey: [init.name, args, init.defaultLimit, options?.headers, options?.headers, customKey],
+            queryKey: ["query", init.name, args, init.defaultLimit, options?.headers, customKey],
             queryFn: async (args) => {
                 const finalArgs = {
-                    limit: args.queryKey[2],
-                    ...(args.queryKey[1] ?? {}),
+                    limit: args.queryKey[3],
+                    ...(args.queryKey[2] ?? {}),
                     cursor: args.pageParam,
                 };
                 const data = await fetchGETQuery(init.name, JSON.stringify(finalArgs), {
@@ -181,7 +182,7 @@ const fetchMutation = async (name, params, opts) => {
 export function createUseMutation(init) {
     const hook = (options) => {
         return useMutation({
-            mutationKey: [init.name],
+            mutationKey: ["mutation", init.name],
             mutationFn: (args) => fetchMutation(init.name, args, {
                 headers: options?.headers,
             }),
@@ -195,3 +196,22 @@ export function createUseMutation(init) {
     };
     return hook;
 }
+// @ts-ignore
+export function useRPCQuery(key, args, options) {
+    return useQuery({
+        queryKey: ["rpcQuery", key, args],
+        queryFn: async (args) => {
+            return getRPCClient().query(key, args.queryKey[2]);
+        },
+        ...options,
+    });
+}
+export function useRPCMutation(key, options) {
+    return useMutation({
+        mutationKey: ["rpcMutation", key],
+        mutationFn: async (args) => {
+            return getRPCClient().mutation(key, args);
+        },
+        ...options,
+    });
+}

package/dist/app/lib/hooks/useRPC.d.ts

@@ -1,7 +1,3 @@
-export declare const useRPCQuery: RPCUseQuery;
-export declare const useRPCMutation: RPCUseMutation;
-export declare const useRPCInfiniteQuery: RPCUseInfiniteQuery;
-export declare const rpcClient: null;
 export type UseRPCMutationResult = any;
 export type UseRPCQueryResult = any;
 export type UseRPCInfiniteQueryResult = any;

package/dist/app/lib/hooks/useRPC.js

@@ -1,9 +1,2 @@
-const trpc = {};
-// @ts-ignore
-export const useRPCQuery = trpc.useQuery;
-// @ts-ignore
-export const useRPCMutation = trpc.useMutation;
-// @ts-ignore
-export const useRPCInfiniteQuery = trpc.useInfiniteQuery;
-export const rpcClient = null;
+// const trpc = {}
 export const RPCClientError = null;

package/dist/app/lib/internal/finalize-rpc.d.ts

@@ -0,0 +1,17 @@
+import type { AnyTRPCMutationProcedure, AnyTRPCProcedure, AnyTRPCQueryProcedure, AnyTRPCSubscriptionProcedure, inferProcedureInput, inferProcedureOutput } from "@trpc/server";
+type RouterTable = Record<string, Record<string, AnyTRPCProcedure> | AnyTRPCProcedure>;
+type RouterEntry<T extends RouterTable, U extends AnyTRPCProcedure, P extends string = ""> = {
+    [K in keyof T]: K extends string ? T[K] extends U ? {
+        key: `${P}${K}`;
+        input: inferProcedureInput<T[K]>;
+        output: inferProcedureOutput<T[K]>;
+        procedure: T[K] extends AnyTRPCProcedure ? T[K] : never;
+    } : T[K] extends Record<string, U> ? RouterEntry<T[K], U, `${K}.`> : never : never;
+}[keyof T];
+type RouterTypes<T extends RouterTable> = {
+    queries: RouterEntry<T, AnyTRPCQueryProcedure>;
+    mutations: RouterEntry<T, AnyTRPCMutationProcedure>;
+    subscriptions: RouterEntry<T, AnyTRPCSubscriptionProcedure>;
+};
+export declare function finalizeRPCRouter<T extends RouterTable>(router: T): RouterTypes<T>;
+export {};

package/dist/app/lib/internal/finalize-rpc.js

@@ -0,0 +1,3 @@
+export function finalizeRPCRouter(router) {
+    return router;
+}

package/dist/app/lib/internal/index.d.ts

@@ -2,3 +2,4 @@ export * from "./read-block-manifest.js";
 export * from "./read-view-manifest.js";
 export * from "./read-admin-manifest.js";
 export * from "./internal-store.js";
+export * from "./finalize-rpc.js";

package/dist/app/lib/internal/index.js

@@ -2,3 +2,4 @@ export * from "./read-block-manifest.js";
 export * from "./read-view-manifest.js";
 export * from "./read-admin-manifest.js";
 export * from "./internal-store.js";
+export * from "./finalize-rpc.js";

package/dist/app/server/index.d.ts

@@ -2,3 +2,4 @@ export * from "./render-ssr-page.js";
 export * from "./server-context.js";
 export * from "./proxy-wp-admin.js";
 export * from "./defineRouter.js";
+export * from "./rpc.js";

package/dist/app/server/index.js

@@ -2,3 +2,4 @@ export * from "./render-ssr-page.js";
 export * from "./server-context.js";
 export * from "./proxy-wp-admin.js";
 export * from "./defineRouter.js";
+export * from "./rpc.js";

package/dist/app/server/proxy-wp-admin.d.ts

@@ -1,3 +1,2 @@
 import { EventHandlerRequest, H3Event } from "vinxi/http";
-import { ServerContext } from "./server-context.js";
-export declare function proxyWpAdmin(event: H3Event<EventHandlerRequest>, serverContext: ServerContext): Promise<Response>;
+export declare function proxyWpAdmin(event: H3Event<EventHandlerRequest>): Promise<Response>;

package/dist/app/server/proxy-wp-admin.js

@@ -1,7 +1,9 @@
 /// <reference types="vinxi/types/server" />
 import { splitSetCookieString } from "cookie-es";
 import { getProxyRequestHeaders, getRequestURL, getWebRequest } from "vinxi/http";
-export async function proxyWpAdmin(event, serverContext) {
+import { ServerContext } from "./server-context.js";
+export async function proxyWpAdmin(event) {
+    const serverContext = ServerContext.main;
     const replaceUrls = serverContext.replaceUrls;
     const req = getWebRequest(event);
     const proxyUrl = serverContext.getOriginUrl(getRequestURL(event).href);

package/dist/app/server/render-ssr-page.d.ts

@@ -1,5 +1,11 @@
-import type { RouteData, TrackerTags } from "../lib/routing/types.js";
-import { ServerContext } from "./server-context.js";
-export declare function renderPageToSSRStream(pathname: string, initialData: RouteData & {
-    trackers?: TrackerTags;
-}, serverContext: ServerContext): Promise<unknown>;
+import type { RouteDataWithTrackers } from "../lib/routing/types.js";
+type SSRArgs = {
+    pathname: string;
+    initialData: RouteDataWithTrackers;
+};
+export declare function getSsrStream(args: SSRArgs): Promise<ReadableStream<Uint8Array>>;
+type RenderArgs = {
+    pathname: string;
+};
+export declare function renderPage(args: RenderArgs): Promise<Response>;
+export {};

package/dist/app/server/render-ssr-page.js

@@ -4,10 +4,12 @@ import { Suspense } from "react";
 import { renderToPipeableStream } from "react-dom/server";
 import { SSRRoot } from "../entry/ssr-root.js";
 import { RouteLoader } from "../lib/routing/loader.js";
-export async function renderPageToSSRStream(pathname, initialData, serverContext) {
-    const clientManifest = serverContext.runtime.getManifest("client");
+import { ServerContext } from "./server-context.js";
+import { Writable } from "stream";
+export async function getSsrStream(args) {
+    const clientManifest = ServerContext.main.runtime.getManifest("client");
     const assets = await clientManifest.inputs[clientManifest.handler].assets();
-    const jsx = (_jsx(SSRRoot, { assets: _jsx(Suspense, { children: assets.map((m) => renderAsset(m)) }), metaTags: initialData?.meta?.head || [], pathname: pathname, initialData: initialData, loader: new RouteLoader() }));
+    const jsx = (_jsx(SSRRoot, { assets: _jsx(Suspense, { children: assets.map((m) => renderAsset(m)) }), metaTags: args.initialData?.meta?.head || [], pathname: args.pathname, initialData: args.initialData, loader: new RouteLoader() }));
     const stream = await new Promise(async (resolve, reject) => {
         // console.log("Rendering to pipable")
         const stream = renderToPipeableStream(jsx, {
@@ -17,15 +19,82 @@ export async function renderPageToSSRStream(pathname, initialData, serverContext
             },
             onShellError(err) {
                 console.log("onShellError", err);
-                resolve("An error occurred");
+                reject(err);
             },
             onError(err, errInfo) {
                 console.log("Error occurred after shell ready", err, errInfo);
                 console.error(err);
             },
             bootstrapModules: [clientManifest.inputs[clientManifest.handler].output.path],
-            bootstrapScriptContent: `window.manifest = ${JSON.stringify(await clientManifest.json())};\nwindow._PAGE_DATA = ${JSON.stringify(initialData)};\nwindow._TRACKERS = ${JSON.stringify(initialData.trackers)}`,
+            bootstrapScriptContent: `window.manifest = ${JSON.stringify(await clientManifest.json())};\nwindow._PAGE_DATA = ${JSON.stringify(args.initialData)};\nwindow._TRACKERS = ${JSON.stringify(args.initialData.trackers)}`,
         });
     });
-    return stream;
+    return new ReadableStream({
+        async start(controller) {
+            const writableStream = new Writable({
+                emitClose: true,
+                write(chunk, encoding, callback) {
+                    controller.enqueue(chunk);
+                    callback();
+                },
+                final(callback) {
+                    controller.close();
+                    callback();
+                },
+            });
+            stream.pipe(writableStream);
+        },
+    });
+}
+export async function renderPage(args) {
+    const serverContext = ServerContext.main;
+    let headers = new Headers();
+    let responseInit = {
+        headers,
+    };
+    try {
+        const [{ appData, trackers }, response] = await Promise.all([
+            serverContext.fetchAppData(),
+            serverContext.fetchRouteData({
+                pathname: args.pathname,
+                withAppData: false,
+                headers: {},
+                query: {},
+            }),
+        ]);
+        let data;
+        try {
+            data = await response.json();
+            data.appData = appData;
+            data.trackers = trackers;
+        }
+        catch (err) {
+            data = {
+                view: "_error",
+                viewType: "react",
+                viewData: {},
+                appData: appData,
+            };
+            console.error(err);
+            responseInit.status = 500;
+        }
+        headers.set("Content-Type", "text/html; charset=utf-8");
+        const stream = await getSsrStream({
+            ...args,
+            initialData: data,
+        });
+        return new Response(stream, responseInit);
+    }
+    catch (err) {
+        console.error(err);
+        return new Response('<!DOCTYPE html><html><head><title>500 Internal Server Error</title></head><body><h1>500 Internal Server Error</h1><p>"' +
+            String(err) +
+            '"</p></body></html>', {
+            status: 500,
+            statusText: "Internal Server Error",
+            headers: {
+                "Content-Type": "text/html; charset=utf-8",
+            },
+        });
+    }
 }

package/dist/app/server/rpc.d.ts

@@ -0,0 +1,56 @@
+import { AnyProcedure } from "@trpc/server";
+import { FetchCreateContextFnOptions } from "@trpc/server/adapters/fetch";
+export declare const rpcApi: {
+    _config: import("@trpc/server/unstable-core-do-not-import").RootConfig<{
+        ctx: RPCContext;
+        meta: object;
+        errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: true;
+    }>;
+    procedure: import("@trpc/server/unstable-core-do-not-import").ProcedureBuilder<RPCContext, object, object, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, false>;
+    middleware: <$ContextOverrides>(fn: import("@trpc/server/unstable-core-do-not-import").MiddlewareFunction<RPCContext, object, object, $ContextOverrides, unknown>) => import("@trpc/server/unstable-core-do-not-import").MiddlewareBuilder<RPCContext, object, $ContextOverrides, unknown>;
+    router: {
+        <TInput extends import("@trpc/server").RouterRecord>(input: TInput): import("@trpc/server/unstable-core-do-not-import").BuiltRouter<{
+            ctx: RPCContext;
+            meta: object;
+            errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+            transformer: true;
+        }, TInput>;
+        <TInput extends import("@trpc/server/unstable-core-do-not-import").CreateRouterOptions>(input: TInput): import("@trpc/server/unstable-core-do-not-import").BuiltRouter<{
+            ctx: RPCContext;
+            meta: object;
+            errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+            transformer: true;
+        }, import("@trpc/server/unstable-core-do-not-import").DecorateCreateRouterOptions<TInput>>;
+    };
+    mergeRouters: typeof import("@trpc/server/unstable-core-do-not-import").mergeRouters;
+    createCallerFactory: <TRecord extends import("@trpc/server").RouterRecord>(router: Pick<import("@trpc/server/unstable-core-do-not-import").Router<{
+        ctx: RPCContext;
+        meta: object;
+        errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: true;
+    }, TRecord>, "_def">) => import("@trpc/server/unstable-core-do-not-import").RouterCaller<{
+        ctx: RPCContext;
+        meta: object;
+        errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: true;
+    }, TRecord>;
+};
+type RouterSchema = Record<string, Record<string, AnyProcedure> | AnyProcedure>;
+export declare const rpc: {
+    middleware: <$ContextOverrides>(fn: import("@trpc/server/unstable-core-do-not-import").MiddlewareFunction<RPCContext, object, object, $ContextOverrides, unknown>) => import("@trpc/server/unstable-core-do-not-import").MiddlewareBuilder<RPCContext, object, $ContextOverrides, unknown>;
+    procedure: import("@trpc/server/unstable-core-do-not-import").ProcedureBuilder<RPCContext, object, object, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, false>;
+    router<T extends RouterSchema>(routes: T): T;
+};
+export declare function defineServerContext<T>(func: (opts: FetchCreateContextFnOptions) => T): (opts: FetchCreateContextFnOptions) => T;
+export declare function instantiateRouter<T extends RouterSchema>(routes: T): import("@trpc/server/unstable-core-do-not-import").BuiltRouter<{
+    ctx: RPCContext;
+    meta: object;
+    errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+    transformer: true;
+}, T>;
+export type InferRPCServerContext<TFunc extends null | ((opts: FetchCreateContextFnOptions) => any)> = {
+    req: Request;
+    resHeaders: Headers;
+} & (TFunc extends (opts: FetchCreateContextFnOptions) => infer T ? T : {});
+export {};

package/dist/app/server/rpc.js

@@ -0,0 +1,18 @@
+import { initTRPC } from "@trpc/server";
+import superjson from "superjson";
+export const rpcApi = initTRPC.context().create({
+    transformer: superjson,
+});
+export const rpc = {
+    middleware: rpcApi.middleware,
+    procedure: rpcApi.procedure,
+    router(routes) {
+        return routes;
+    },
+};
+export function defineServerContext(func) {
+    return func;
+}
+export function instantiateRouter(routes) {
+    return rpcApi.router(routes);
+}

package/dist/app/server/server-context.d.ts

@@ -21,6 +21,7 @@ export declare class ServerContext {
     dev: boolean;
     origin: string;
     replaceUrls?: (text: string) => string;
+    static main: ServerContext;
     constructor(conf: ServerContextArgs);
     get runtime(): ServerContextRuntime;
     static setRuntime(rt: ServerContextRuntime): void;

package/dist/app/server/server-context.js

@@ -18,12 +18,14 @@ export class ServerContext {
     dev;
     origin;
     replaceUrls;
+    static main;
     constructor(conf) {
         this.dev = conf.dev;
         this.origin = conf.origin;
         if (conf.replaceUrls) {
             this.replaceUrls = createUrlReplacer(conf.replaceUrls);
         }
+        ServerContext.main = this;
     }
     get runtime() {
         return runtime;

package/dist/app/utils/APIProvider.d.ts

@@ -0,0 +1,2 @@
+import { PropsWithChildren } from "react";
+export declare function APIProvider(props: PropsWithChildren<{}>): import("react/jsx-runtime").JSX.Element;

package/dist/app/utils/APIProvider.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { QueryProvider } from "./query-client";
+export function APIProvider(props) {
+    return _jsx(QueryProvider, { children: props.children });
+}

package/dist/app/utils/BlockErrorBoundary.d.ts

@@ -1,5 +1,5 @@
 import { Component, ErrorInfo, ReactNode } from "react";
-import { BlocksContext, ContentBlock } from "../lib/blocks/ContentBlocks";
+import { BlocksContext, ContentBlock } from "../lib/blocks/ContentBlocks.js";
 interface Props {
     block: ContentBlock;
     blockContext: BlocksContext;

package/dist/app/utils/BlockErrorBoundary.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Component } from "react";
-import { errorHandling } from "../lib/runtime";
-import { ErrorMessage } from "./ErrorMessage";
+import { errorHandling } from "../lib/runtime/errorHandling.js";
+import { ErrorMessage } from "./ErrorMessage.js";
 export class BlockErrorBoundary extends Component {
     state = {
         hasError: false,

package/dist/app/utils/RouteErrorBoundary.d.ts

@@ -1,5 +1,5 @@
 import { Component, ErrorInfo, ReactNode } from "react";
-import { RouteState } from "../lib/routing";
+import { RouteState } from "../lib/routing/types.js";
 interface Props {
     route: RouteState;
     children: ReactNode;

package/dist/app/utils/RouteErrorBoundary.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Component } from "react";
-import { errorHandling } from "../lib/runtime";
-import { ErrorMessage } from "./ErrorMessage";
+import { errorHandling } from "../lib/runtime/errorHandling.js";
+import { ErrorMessage } from "./ErrorMessage.js";
 export class RouteErrorBoundary extends Component {
     state = {
         hasError: false,

package/dist/app/utils/query-client.d.ts

@@ -1,2 +1,4 @@
 import { QueryClient } from "@tanstack/react-query";
+import { PropsWithChildren } from "react";
 export declare function getQueryClient(): QueryClient;
+export declare function QueryProvider(props: PropsWithChildren<{}>): import("react/jsx-runtime").JSX.Element;

package/dist/app/utils/query-client.js

@@ -1,4 +1,5 @@
-import { QueryClient } from "@tanstack/react-query";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { QueryClientProvider, QueryClient } from "@tanstack/react-query";
 let queryClient = null;
 export function getQueryClient() {
     if (!queryClient) {
@@ -14,3 +15,6 @@ export function getQueryClient() {
     }
     return queryClient;
 }
+export function QueryProvider(props) {
+    return _jsx(QueryClientProvider, { client: getQueryClient(), children: props.children });
+}

package/dist/app/utils/trpc-client.d.ts

@@ -0,0 +1,2 @@
+import { TRPCUntypedClient } from "@trpc/client";
+export declare function getRPCClient(): TRPCUntypedClient<any>;

package/dist/app/utils/trpc-client.js

@@ -0,0 +1,34 @@
+import { createTRPCUntypedClient, httpLink, splitLink, unstable_httpSubscriptionLink, } from "@trpc/client";
+import SuperJSON from "superjson";
+import { parseURL, stringifyParsedURL } from "ufo";
+let client;
+export function getRPCClient() {
+    if (env.rpcEnabled) {
+        if (!client) {
+            // @ts-ignore
+            const endpoint = env.serverless ? "/" : window.SERVERLESS_ENDPOINT ?? "/";
+            client = createTRPCUntypedClient({
+                links: [
+                    splitLink({
+                        // uses the httpSubscriptionLink for subscriptions
+                        condition: (op) => op.type === "subscription",
+                        true: unstable_httpSubscriptionLink({
+                            url: endpoint,
+                            transformer: SuperJSON,
+                        }),
+                        false: httpLink({
+                            url: endpoint,
+                            fetch: (input, init) => {
+                                const parsed = parseURL(input);
+                                parsed.pathname = "/" + parsed.pathname.replace(/(^\/|\/$)/g, "").replace(/\./g, "/") + "/";
+                                return fetch(stringifyParsedURL(parsed), init);
+                            },
+                            transformer: SuperJSON,
+                        }),
+                    }),
+                ],
+            });
+        }
+    }
+    return client;
+}

package/dist/node/cli/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "2.0.0-beta.57";
+export declare const VERSION = "2.0.0-beta.58";

package/dist/node/cli/version.js

@@ -1 +1 @@
-export const VERSION = "2.0.0-beta.57";
+export const VERSION = "2.0.0-beta.58";

package/dist/node/compiler/dev-server.js

@@ -39,6 +39,7 @@ export class DevServer {
             publicUrl: this.project.publicUrl,
             rootDir: this.project.rootDir,
             log: console,
+            rpcBases: (await this.project.serverRoutes.get()).bases,
         });
         const preset = process.env.TARGET ??
             process.env.PRESET ??

package/dist/node/compiler/get-vite-config.js

@@ -15,7 +15,7 @@ export function envPlugin(args) {
         themePath: JSON.stringify(args.publicUrl),
         devUI: args.mode === "development" ? "true" : "false",
         serverlessOrigin: JSON.stringify("http://serverleress-endpoint"),
-        rpcEnabled: "false",
+        rpcEnabled: "true",
         origin: JSON.stringify(process.env.SITE_URL ?? "/"),
     };
     const expandDefines = (obj, prefixes = []) => {

package/dist/node/compiler/vinxi-app.d.ts

@@ -7,6 +7,7 @@ export type AppArgs = {
     log?: StatefulLog<any>;
     preset?: string;
     routes?: CustomRoute[];
+    rpcBases?: string[];
 };
 type HTTPMethod = "GET" | "POST" | "PUT" | "OPTIONS" | "HEAD";
 type CustomRouteFunction = (req: Request) => Response;

package/dist/node/compiler/vinxi-app.js

@@ -11,6 +11,7 @@ export function createVinxiApp(args) {
             mode: args.mode,
             serverless: true,
         });
+    console.log("Creating Vinxi app with args", args.rpcBases);
     return createApp({
         server: {
             // experimental: {
@@ -76,6 +77,24 @@ export function createVinxiApp(args) {
                 dir: "./assets",
                 base: joinURL(args.publicUrl, "assets"),
             },
+            {
+                name: "trpc-api",
+                type: "http",
+                base: "/trpc/",
+                handler: `${folder}/handler.trpc-api.ts`,
+                target: "server",
+                plugins: () => [
+                    tsconfigPaths(),
+                    envPlugin({
+                        rootDir: args.rootDir,
+                        console: log,
+                        mode: args.mode,
+                        publicUrl: args.publicUrl,
+                        serverless: true,
+                        target: "frontend",
+                    }),
+                ],
+            },
             {
                 name: "data-api",
                 type: "http",
@@ -87,7 +106,7 @@ export function createVinxiApp(args) {
                     envPlugin({
                         rootDir: args.rootDir,
                         console: log,
-                        mode: "development",
+                        mode: args.mode,
                         publicUrl: args.publicUrl,
                         serverless: true,
                         target: "frontend",
@@ -105,7 +124,7 @@ export function createVinxiApp(args) {
                     envPlugin({
                         rootDir: args.rootDir,
                         console: log,
-                        mode: "development",
+                        mode: args.mode,
                         publicUrl: args.publicUrl,
                         serverless: true,
                         target: "frontend",
@@ -121,7 +140,7 @@ export function createVinxiApp(args) {
                     ...corePlugins({
                         rootDir: args.rootDir,
                         console: log,
-                        mode: "development",
+                        mode: args.mode,
                         publicUrl: args.publicUrl,
                         serverless: true,
                         target: "frontend",
@@ -138,7 +157,7 @@ export function createVinxiApp(args) {
                     ...corePlugins({
                         rootDir: args.rootDir,
                         console: log,
-                        mode: "development",
+                        mode: args.mode,
                         publicUrl: args.publicUrl,
                         serverless: true,
                         target: "cms",
@@ -146,6 +165,24 @@ export function createVinxiApp(args) {
                 ],
                 base: "/_admin",
             },
+            ...(args.rpcBases ?? []).map((base) => ({
+                name: "trpc-api",
+                type: "http",
+                base: "/" + base.replace(/^\//, ""),
+                handler: `${folder}/handler.trpc-api.ts`,
+                target: "server",
+                plugins: () => [
+                    tsconfigPaths(),
+                    envPlugin({
+                        rootDir: args.rootDir,
+                        console: log,
+                        mode: args.mode,
+                        publicUrl: args.publicUrl,
+                        serverless: true,
+                        target: "frontend",
+                    }),
+                ],
+            })),
             {
                 name: "ssr",
                 type: "http",
@@ -155,7 +192,7 @@ export function createVinxiApp(args) {
                     ...corePlugins({
                         rootDir: args.rootDir,
                         console: log,
-                        mode: "development",
+                        mode: args.mode,
                         publicUrl: args.publicUrl,
                         serverless: true,
                         target: "frontend",

package/dist/node/compiler/vinxi-codegen.js

@@ -1,5 +1,6 @@
 import { code, imp } from "ts-poet";
 import { FSCodegen } from "../utils/fs-codegen.js";
+import { camelCase } from "change-case-all";
 export function getVinxiFolder(opts) {
     return (opts.mode === "development" ? "dev" : "prod") + (opts.serverless ? "" : "-spa");
 }
@@ -246,55 +247,58 @@ export function createVinxiCodegen(opts) {
         import "./manifest/blocks.js"
         import "./manifest/styles.js"
         import "./manifest/views.js"
+        import "./context.js"
 
-        import { proxyWpAdmin, renderPageToSSRStream } from "eddev/server"
-        import { eventHandler, getRequestURL, setResponseHeader, setResponseStatus } from "vinxi/http"
-        import { serverContext } from "./context.js"
+        import { proxyWpAdmin, ServerContext, renderPage } from "eddev/server"
+        import { eventHandler, getRequestURL } from "vinxi/http"
         import { RouteData } from "eddev/routing"
 
         export default eventHandler({
           handler: async (event) => {
+            const serverContext = ServerContext.main
             const url = getRequestURL(event)
 
             if (url.pathname.includes(".")) {
-              return proxyWpAdmin(event, serverContext)
+              return proxyWpAdmin(event)
             }
 
-            try {
-              const [{appData, trackers}, response] = await Promise.all([
-                serverContext.fetchAppData(),
-                serverContext.fetchRouteData({
-                  pathname: url.pathname,
-                  withAppData: false,
-                  headers: {},
-                  query: {},
-                }),
-              ])
-
-              let data: RouteData
-              try {
-                data = await response.json()
-                data.appData = appData
-                data.trackers = trackers
-              } catch (err) {
-                data = {
-                  view: "_error",
-                  viewType: "react",
-                  viewData: {},
-                  appData: appData,
-                }
-                console.error(err)
-                setResponseStatus(event, 500)
-              }
-              setResponseHeader(event, "Content-Type", "text/html; charset=utf-8")
-              return renderPageToSSRStream(url.pathname, data, serverContext)
-            } catch (err) {
-              console.error(err)
-              setResponseStatus(event, 500)
-              setResponseHeader(event, "Content-Type", "text/html; charset=utf-8")
-              return '<!DOCTYPE html><html><head><title>500 Internal Server Error</title></head><body><h1>500 Internal Server Error</h1><p>"'+err.message+'"</p></body></html>'
-            }
-          },
+            return renderPage({ pathname: url.pathname })
+
+          //   try {
+          //     const [{appData, trackers}, response] = await Promise.all([
+          //       serverContext.fetchAppData(),
+          //       serverContext.fetchRouteData({
+          //         pathname: url.pathname,
+          //         withAppData: false,
+          //         headers: {},
+          //         query: {},
+          //       }),
+          //     ])
+
+          //     let data: RouteData
+          //     try {
+          //       data = await response.json()
+          //       data.appData = appData
+          //       data.trackers = trackers
+          //     } catch (err) {
+          //       data = {
+          //         view: "_error",
+          //         viewType: "react",
+          //         viewData: {},
+          //         appData: appData,
+          //       }
+          //       console.error(err)
+          //       setResponseStatus(event, 500)
+          //     }
+          //     setResponseHeader(event, "Content-Type", "text/html; charset=utf-8")
+          //     return renderPageToSSRStream(url.pathname, data)
+          //   } catch (err) {
+          //     console.error(err)
+          //     setResponseStatus(event, 500)
+          //     setResponseHeader(event, "Content-Type", "text/html; charset=utf-8")
+          //     return '<!DOCTYPE html><html><head><title>500 Internal Server Error</title></head><body><h1>500 Internal Server Error</h1><p>"'+err.message+'"</p></body></html>'
+          //   }
+          }
         })
     `,
         });
@@ -306,10 +310,10 @@ export function createVinxiCodegen(opts) {
       /// <reference types="vinxi/types/server" />
       import { proxyWpAdmin } from "eddev/server"
       import { eventHandler } from "vinxi/http"
-      import { serverContext } from "./context.js"
+      import  "./context.js"
 
       export default eventHandler(async (event) => {
-        return proxyWpAdmin(event, serverContext)
+        return proxyWpAdmin(event)
       })
     `,
         });
@@ -460,5 +464,84 @@ export function createVinxiCodegen(opts) {
       `;
         },
     });
+    if (opts.serverless) {
+        codegen.registerFile({
+            name: "manifest/routes.ts",
+            generate: async () => {
+                const routeManifest = await project.serverRoutes.get();
+                return code /* ts */ `
+        import { instantiateRouter } from "eddev/server"
+          ${routeManifest.contextFileName
+                    ? code /*ts*/ `
+            import createContext from "../../../${routeManifest.contextFileName}"
+          `
+                    : code /*ts*/ `
+            const createContext = () => ({})
+          `}
+
+          const router = instantiateRouter({${Object.entries(routeManifest.routes).map(([name, route]) => {
+                    const src = "../../../" + route.fileName;
+                    const importStatement = imp(camelCase(name) + "=" + src);
+                    return code `${JSON.stringify(route.prefix)}: ${importStatement},\n`;
+                })}})
+
+          export { createContext, router }
+        `;
+            },
+            subscribe: project.serverRoutes.subscribe,
+        });
+        codegen.registerFile({
+            name: "handler.trpc-api.ts",
+            generate: code /* tsx */ `
+        /// <reference types="vinxi/types/server" />
+        import "./context.js"
+        import { fetchRequestHandler } from "@trpc/server/adapters/fetch"
+        import { eventHandler, getWebRequest } from "vinxi/http"
+        import { createContext, router } from "./manifest/routes.ts"
+        import { parseURL, stringifyParsedURL } from "ufo"
+
+        export default eventHandler({
+          handler: async (event) => {
+            // Update URLs with dots, which tRPC prefers
+            const originalReq = getWebRequest(event)
+            const parsed = parseURL(originalReq.url)
+            parsed.pathname = "/" + parsed.pathname.replace(/(^\\/|\\/$)/g, "").replace(/\\//, ".")
+            const req = new Request(stringifyParsedURL(parsed), originalReq)
+
+            // Handle any early results which are Responses
+            function processEarlyResult(value: any): Response | undefined {
+              if (value instanceof Response) {
+                return value
+              }
+            }
+
+            return new Promise(async (resolve) => {
+              let sent = false
+              const defaultResponse = await fetchRequestHandler({
+                endpoint: "/",
+                req: req,
+                router: router,
+                createContext,
+                onError: (err) => console.error(err),
+                batching: { enabled: false },
+                // If a Response object is returned by a route, it will be sent as the response
+                responseMeta(opts) {
+                  const value = opts?.data?.[0]?.["result"]?.["data"]
+                  const response = processEarlyResult(value)
+                  if (response) {
+                    sent = true
+                    resolve(response)
+                  }
+                  return {}
+                },
+              })
+              if (sent) return
+              resolve(defaultResponse)
+            })
+          },
+        })
+      `,
+        });
+    }
     return codegen;
 }

package/dist/node/graphql/graphql-codegen.d.ts

@@ -31,6 +31,7 @@ export declare class GraphQLGenerator {
     private validateGraphQLFiles;
     private generateTS;
     generateUtilTypes(): Promise<unknown[]>;
+    generateAPITypes(): Promise<unknown[]>;
     /**
      * Saves the schema to a file, for use by the VSCode GraphQL extension
      */

package/dist/node/graphql/graphql-codegen.js

@@ -9,7 +9,7 @@ import { createGraphQLFileLoader } from "./query-files-loader.js";
 import * as typescriptPlugin from "@graphql-codegen/typescript";
 import * as typescriptOperationsPlugin from "@graphql-codegen/typescript-operations";
 import chalk from "chalk";
-import { code } from "ts-poet";
+import { code, imp } from "ts-poet";
 import { highlightCode } from "../utils/highlight-code.js";
 import { createConsole } from "../utils/stateful-log.js";
 import { watchFileTreeForChanges } from "../utils/watch-file-tree.js";
@@ -17,6 +17,7 @@ import pluginFiles from "./plugins/gql-plugin-files.js";
 import pluginNoDuplicates from "./plugins/gql-plugin-no-duplicates.js";
 import pluginQueries from "./plugins/gql-plugin-queries.js";
 import { FSCodegen } from "../utils/fs-codegen.js";
+import { camelCase } from "change-case-all";
 export const graphqlLog = createConsole("GraphQL Codegen", "graphql");
 const console = graphqlLog;
 class GraphQLValidationError {
@@ -153,6 +154,9 @@ export class GraphQLGenerator {
             this.project.blocks.subscribeFuture(() => {
                 this.generateUtilTypes();
             });
+            this.project.serverRoutes.subscribeFuture(() => {
+                this.generateAPITypes();
+            });
             this.listen();
         }
         if (this.opts.optimize) {
@@ -280,6 +284,7 @@ export class GraphQLGenerator {
         };
         const errors = (await Promise.all([
             this.generateUtilTypes(),
+            this.generateAPITypes(),
             this.generateTS("types.graphql.ts", schemaResult.rawSchema, {
                 documents: getDocuments(["queries", "views", "blocks", "fragments"]),
                 hasDocuments: true,
@@ -624,6 +629,42 @@ export class GraphQLGenerator {
         }
         return [];
     }
+    async generateAPITypes() {
+        const filename = join(this.project.rootDir, "types.api.ts");
+        try {
+            const routeManifest = await this.project.serverRoutes.get();
+            const contents = code /*ts*/ `
+        import "eddev/types.app.public";
+        import { InferRPCServerContext, rpc } from "eddev/server"
+        import { finalizeRPCRouter } from "eddev/_internal"
+        ${routeManifest.contextFileName
+                ? code /*ts*/ `
+          import createContext from "./${routeManifest.contextFileName.replace(/\.tsx?$/, "")}"
+        `
+                : code /*ts*/ `
+          const createContext = () => ({})
+        `}
+
+        function createRouter() {
+          return finalizeRPCRouter({${Object.entries(routeManifest.routes).map(([name, route]) => {
+                const src = "./" + route.fileName;
+                const importStatement = imp(camelCase(name) + "=" + src.replace(/\.tsx?$/, ""));
+                return code `${JSON.stringify(route.prefix)}: ${importStatement},\n`;
+            })}})
+        }
+
+        declare global {
+          interface RPCContext extends InferRPCServerContext<typeof createContext> {}
+          interface RPCRouter extends ReturnType<typeof createRouter> {}
+        }
+      `;
+            await fs.writeIfUnchanged(filename, contents.toString());
+        }
+        catch (err) {
+            return [err];
+        }
+        return [];
+    }
     /**
      * Saves the schema to a file, for use by the VSCode GraphQL extension
      */

package/dist/node/project/manifest/routes-manifest.d.ts

@@ -0,0 +1,20 @@
+import { Project } from "../project.js";
+export type RouteManifest = {
+    routes: Record<string, RouteInfo>;
+    contextFileName: string | null;
+    validationMessages: {
+        fieldKey: string;
+        message: string;
+        severity: "error" | "warning";
+    }[];
+    bases: string[];
+};
+type RouteInfo = {
+    kind: "context" | "route";
+    fileName: string;
+    prefix?: string;
+    error?: string;
+};
+export type RouteManifestGenerator = ReturnType<typeof loadRouteManifest>;
+export declare function loadRouteManifest(project: Project): import("./manifest.js").ManifestGenerator<RouteInfo, RouteManifest>;
+export {};

package/dist/node/project/manifest/routes-manifest.js

@@ -0,0 +1,74 @@
+import { cliMode } from "../../cli/cli-mode.js";
+import { createManifestGenerator } from "./manifest.js";
+export function loadRouteManifest(project) {
+    return createManifestGenerator({
+        baseDir: project.rootDir,
+        pattern: ["server/routes/**/*.{ts,tsx}", "server/_context.{ts,tsx}"],
+        watch: cliMode.watch,
+        async generateManifest(entries) {
+            let result = {
+                routes: {},
+                contextFileName: null,
+                validationMessages: [],
+                bases: [],
+            };
+            const bases = new Set();
+            Object.entries(entries)
+                .sort(([b1], [b2]) => {
+                return b1.localeCompare(b2);
+            })
+                .forEach(([key, entry]) => {
+                if (entry.value.kind === "context") {
+                    result.contextFileName = entry.value.fileName;
+                }
+                else if (entry.value.kind === "route") {
+                    const { error: initialError } = entry.value;
+                    const prefix = entry.value.prefix;
+                    result.routes[key] = entry.value;
+                    if (prefix) {
+                        let shouldAdd = true;
+                        bases.forEach((base) => {
+                            if (base.startsWith(prefix)) {
+                                bases.delete(base);
+                            }
+                            else if (prefix.startsWith(base)) {
+                                shouldAdd = false;
+                                return;
+                            }
+                        });
+                        if (shouldAdd) {
+                            bases.add(entry.value.prefix);
+                        }
+                    }
+                    if (initialError) {
+                        result.validationMessages.push({
+                            fieldKey: key,
+                            message: initialError,
+                            severity: "error",
+                        });
+                        return;
+                    }
+                }
+            });
+            result.bases = [...bases].sort().map((base) => "/" + base.replace(/\./g, "/"));
+            return result;
+        },
+        getKey(path) {
+            // Strip the views folder name + extension
+            return path.replace(/\.tsx?$/, "").replace(/^server\/routes\//, "");
+        },
+        async loadValue(fileName, key) {
+            if (fileName.startsWith("server/_context.")) {
+                return {
+                    kind: "context",
+                    fileName,
+                };
+            }
+            return {
+                kind: "route",
+                prefix: key.replace("/index", "").replace(/\//, "."),
+                fileName,
+            };
+        },
+    });
+}

package/dist/node/project/project.d.ts

@@ -1,6 +1,7 @@
 import { EDConfig } from "./config.js";
 import { BlockManifestGenerator } from "./manifest/block-manifest.js";
 import { FieldManifestGenerator } from "./manifest/field-manifest.js";
+import { RouteManifestGenerator } from "./manifest/routes-manifest.js";
 import { ViewManifestGenerator } from "./manifest/view-manifest.js";
 import { WidgetManifestGenerator } from "./manifest/widget-manifest.js";
 export declare const projectLog: import("../utils/stateful-log.js").StatefulLog<Project>;
@@ -24,6 +25,7 @@ export declare class Project {
     views: ViewManifestGenerator;
     fields: FieldManifestGenerator;
     widgets: WidgetManifestGenerator;
+    serverRoutes: RouteManifestGenerator;
     private wp;
     reportPluginCompatibility: boolean;
     private constructor();

package/dist/node/project/project.js

@@ -8,6 +8,7 @@ import { Configurator } from "./config.js";
 import { ProjectEnvUtils } from "./env.js";
 import { loadBlockManifest } from "./manifest/block-manifest.js";
 import { loadFieldManifest } from "./manifest/field-manifest.js";
+import { loadRouteManifest } from "./manifest/routes-manifest.js";
 import { loadViewManifest } from "./manifest/view-manifest.js";
 import { loadWidgetManifest } from "./manifest/widget-manifest.js";
 import { WPInfo } from "./wp-info.js";
@@ -29,6 +30,7 @@ export class Project {
     views;
     fields;
     widgets;
+    serverRoutes;
     wp;
     reportPluginCompatibility = false;
     constructor(opts) {
@@ -39,6 +41,7 @@ export class Project {
         this.views = loadViewManifest(this);
         this.fields = loadFieldManifest(this);
         this.widgets = loadWidgetManifest(this);
+        this.serverRoutes = loadRouteManifest(this);
         this.wp = new WPInfo(this.origin);
     }
     async load() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eddev",
-  "version": "2.0.0-beta.57",
+  "version": "2.0.0-beta.58",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -86,6 +86,9 @@
     "@nozbe/microfuzz": "^1.0.0",
     "@rollup/plugin-replace": "^5.0.5",
     "@tanstack/react-query": "^5.51.23",
+    "@trpc/client": "^11.0.0-rc.608",
+    "@trpc/react-query": "^11.0.0-rc.608",
+    "@trpc/server": "^11.0.0-rc.608",
     "@types/qs": "^6.9.15",
     "@vinxi/react": "^0.2.5",
     "@vitejs/plugin-react": "^4.1.1",
@@ -107,6 +110,7 @@
     "object-code": "^1.3.3",
     "qs": "^6.13.0",
     "react-super-seo": "^1.1.9",
+    "superjson": "^2.2.1",
     "ts-poet": "^6.6.0",
     "ufo": "^1.3.1",
     "undent": "^0.1.0",

package/types.app.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="vite/client" />
 /// <reference types="./types.meta.d.ts" />
 /// <reference types="./types.env.d.ts" />
+import { Router } from "@trpc/server"
 
 declare global {
   interface ViewProps {}
@@ -13,6 +14,7 @@ declare global {
   interface PostMetaTypes {}
 
   interface RPCRouter {}
+  interface RPCContext {}
 
   type AppData = ViewProps["_app"]