eddev 2.0.0-beta.56 → 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/blocks/editor/installGutenbergHooks.js

@@ -74,15 +74,18 @@ export function installEDGutenbergHooks() {
                     ;
                     wp.data.dispatch("core/block-editor").setTemplateValidity(true);
                 }, []);
-                const children = wp.data.useSelect((select) => {
-                    const { getBlock, getBlockOrder } = select("core/block-editor");
+                const { children, index } = wp.data.useSelect((select) => {
+                    const { getBlock, getBlockOrder, getBlockIndex } = select("core/block-editor");
                     const innerBlockIDs = getBlockOrder(props.clientId);
                     const children = innerBlockIDs.map((id) => {
                         return getBlock(id);
                     });
-                    return children;
+                    return {
+                        children,
+                        index: getBlockIndex(props.clientId),
+                    };
                 }, []);
-                return (_jsx(BlockContext.Provider, { value: { name, props }, children: _jsx(InlineEditingContextProvider, { values: props.attributes.inline || {}, innerBlocks: children, block: [name, props], index: -1, onChange: (attrs) => {
+                return (_jsx(BlockContext.Provider, { value: { name, props }, children: _jsx(InlineEditingContextProvider, { values: props.attributes.inline || {}, innerBlocks: children, block: [name, props], index: index ?? -1, onChange: (attrs) => {
                             props.setAttributes({ ...props.attributes, inline: attrs });
                         }, insertBlocksAfter: props.insertBlocksAfter, children: edit.call(self, props) }) }));
             };

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.56";
+export declare const VERSION = "2.0.0-beta.58";