@btst/stack 1.0.0 → 1.1.0

package/README.md

@@ -1,3 +1,238 @@
-# BETTER STACK
+# @BTST - Better Stack
 
-WIP
+<div align="center">
+
+**Add complete full-stack features to your React app in minutes, not weeks**
+
+[![npm version](https://img.shields.io/npm/v/@btst/stack.svg)](https://www.npmjs.com/package/@btst/stack)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+[📖 Documentation](https://www.btst.ai) • [🐛 Issues](https://github.com/olliethedev/better-stack/issues)
+
+</div>
+
+---
+
+## What Problem Does This Solve?
+
+Your app needs a blog. Or a scheduling system. Or user feedback collection. Or an AI assistant. These are **horizontal features**—capabilities that cut across your entire app, not specific to your core domain.
+
+Building them from scratch means weeks of work: routes, API endpoints, database schemas, authentication, SSR, metadata, hooks, forms, error handling...
+
+Better Stack lets you **add these features in minutes** as composable plugins that work across any React framework.
+
+- **Composable architecture** - Mix and match features like LEGO blocks. Add blog + scheduling + feedback + newsletters, all working together seamlessly
+- **Framework agnostic** - One feature works with Next.js App Router, React Router, TanStack Router, Remix—switch frameworks without rewriting
+- **Plugin overrides** - Leverage framework-specific features via overrides. Use Next.js `Image` and `Link`, React Router's `Link`, or any framework's components
+- **Full-stack in one package** - Each feature includes routes, API endpoints, database schemas, React components, hooks, loaders, and metadata
+- **Zero boilerplate** - No wiring up routes, API handlers, or query clients. Just configure and it works
+- **First-class SSR** - Server-side rendering, data prefetching, and SEO metadata generation built-in
+- **Lifecycle hooks** - Intercept at any point: authorization, data transformation, analytics, caching, webhooks
+- **Horizontal features** - Perfect for blog, scheduling, feedback, newsletters, AI assistants, comments—anything reusable across apps
+
+## What Can You Add?
+
+**Blog** - Content management, editor, drafts, publishing, SEO, RSS feeds
+
+**Scheduling** - Calendar views, time slot booking, availability management, reminders
+
+**Feedback** - In-app feedback widgets, user surveys, bug reporting, feature requests
+
+**Newsletters** - Subscriber management, email campaigns, unsubscribe handling, analytics
+
+**AI Assistant** - Chat interfaces, prompt templates, conversation history, streaming responses
+
+**Comments** - Threaded discussions, moderation, reactions, notifications
+
+And any other horizontal feature your app needs. Each comes with a complete UI, backend, and data layer.
+
+## Installation
+
+```bash
+npm install @btst/stack
+```
+
+For database schema management, install the CLI:
+
+```bash
+npm install -D @btst/cli
+```
+
+The CLI helps generate migrations, Prisma schemas, and other database artifacts from your plugin schemas.
+
+## Quick Example: Add a Blog to Next.js
+
+### 1. Backend API (`lib/better-stack.ts`)
+
+```ts
+import { betterStack } from "@btst/stack"
+import { blogBackendPlugin } from "@btst/stack/plugins/blog/api"
+import { createPrismaAdapter } from "@btst/adapter-prisma"
+
+const { handler, dbSchema } = betterStack({
+  basePath: "/api/data",
+  plugins: {
+    blog: blogBackendPlugin()
+  },
+  adapter: (db) => createPrismaAdapter(db)({})
+})
+
+export { handler, dbSchema }
+```
+
+**Note:** `betterStack()` returns both `handler` and `dbSchema`. The `dbSchema` contains all merged database schemas from your plugins. Use [@btst/cli](https://www.npmjs.com/package/@btst/cli) to generate migrations, Prisma schemas, or other database artifacts from your `dbSchema`.
+
+For example, to generate a Prisma schema from your `dbSchema`:
+
+```bash
+npx @btst/cli generate --orm prisma --config lib/better-db.ts --output prisma/schema.prisma --filter-auth
+```
+
+This reads your `dbSchema` export and generates the corresponding Prisma schema file.
+
+### 2. API Route (`app/api/[[...]]/route.ts`)
+
+```ts
+import { handler } from "@/lib/better-stack"
+
+export const GET = handler
+export const POST = handler
+```
+
+### 3. Client Setup (`lib/better-stack-client.tsx`)
+
+```ts
+import { createStackClient } from "@btst/stack/client"
+import { blogClientPlugin } from "@btst/stack/plugins/blog/client"
+
+export const getStackClient = (queryClient: QueryClient) => {
+  return createStackClient({
+    plugins: {
+      blog: blogClientPlugin({
+        queryClient,
+        apiBaseURL: baseURL,
+        apiBasePath: "/api/data",
+        siteBaseURL: baseURL,
+        siteBasePath: "/pages"
+      })
+    }
+  })
+}
+```
+
+### 4. Page Handler (`app/pages/[[...all]]/page.tsx`)
+
+```ts
+export default async function Page({ params }) {
+  const path = `/${(await params).all?.join("/") || ""}`
+  const stackClient = getStackClient(queryClient)
+  const route = stackClient.router.getRoute(path)
+  
+  if (route?.loader) await route.loader()
+  
+  return (
+    <HydrationBoundary state={dehydrate(queryClient)}>
+      <ClientRouteResolver path={path} />
+    </HydrationBoundary>
+  )
+}
+```
+
+### 5. Layout Provider (`app/pages/[[...all]]/layout.tsx`)
+
+```ts
+import { BetterStackProvider } from "@btst/stack/context"
+import Link from "next/link"
+import Image from "next/image"
+import { useRouter } from "next/navigation"
+
+export default function Layout({ children }) {
+  const router = useRouter()
+  
+  return (
+    <BetterStackProvider
+      basePath="/pages"
+      overrides={{
+        blog: {
+          // Use Next.js optimized Image component
+          Image: (props) => (
+            <Image
+              alt={props.alt || ""}
+              src={props.src || ""}
+              width={400}
+              height={300}
+            />
+          ),
+          // Use Next.js Link for client-side navigation
+          navigate: (path) => router.push(path),
+          refresh: () => router.refresh()
+        }
+      }}
+    >
+      {children}
+    </BetterStackProvider>
+  )
+}
+```
+
+### 6. Sitemap Generation (`app/sitemap.ts`)
+
+```ts
+import type { MetadataRoute } from "next"
+import { QueryClient } from "@tanstack/react-query"
+import { getStackClient } from "@/lib/better-stack-client"
+
+export const dynamic = "force-dynamic"
+
+export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+  const queryClient = new QueryClient()
+  const stackClient = getStackClient(queryClient)
+  const entries = await stackClient.generateSitemap()
+
+  return entries.map((e) => ({
+    url: e.url,
+    lastModified: e.lastModified,
+    changeFrequency: e.changeFrequency,
+    priority: e.priority,
+  }))
+}
+```
+
+**That's it.** Your blog feature is live with:
+- ✅ `/blog` - Post listing page
+- ✅ `/blog/[slug]` - Individual post pages  
+- ✅ `/blog/new` - Create post editor
+- ✅ `/blog/[slug]/edit` - Edit post page
+- ✅ Full CRUD API (`/api/data/blog/*`)
+- ✅ Server-side rendering
+- ✅ Automatic metadata generation
+- ✅ Automatic sitemap generation
+- ✅ React Query hooks (`usePosts`, `usePost`, etc.)
+
+Now add scheduling, feedback, or newsletters the same way. Each feature is independent and composable.
+
+## The Bigger Picture
+
+Better Stack transforms how you think about building apps:
+
+• **Internal teams** - Build shared features once, use across multiple apps. Your marketing team's blog plugin works in the main app, the docs site, and the landing page
+• **Open source** - Share complete features, not just code snippets. Someone can add your newsletter feature to their Next.js app in minutes
+• **Agencies** - Create a library of reusable features. Drop scheduling into client A's app, feedback into client B's app, both using React Router
+• **SaaS platforms** - Offer feature plugins your customers can compose. They pick blog + scheduling + AI assistant, mix and match to build their ideal app
+• **Rapid prototyping** - Add 5 features in an afternoon instead of 5 weeks. Validate ideas faster
+
+Each feature is a complete, self-contained full-stack capability. No configuration files. No code generation. No framework lock-in. Just add it and it works.
+
+## Learn More
+
+For complete documentation, examples, and plugin development guides, visit **[https://www.btst.ai](https://www.btst.ai)**
+
+## Examples
+
+- [Next.js App Router](./examples/nextjs) - Full SSR with App Router
+- [React Router](./examples/react-router) - Client-side routing with React Router
+- [TanStack Router](./examples/tanstack) - Type-safe routing with TanStack Router
+
+## License
+
+MIT © [olliethedev](https://github.com/olliethedev)

package/dist/api/index.cjs

@@ -4,7 +4,7 @@ const betterCall = require('better-call');
 const db = require('@btst/db');
 
 function betterStack(config) {
-  const { plugins, adapter, dbSchema } = config;
+  const { plugins, adapter, dbSchema, basePath } = config;
   const allRoutes = {};
   let betterDbSchema = dbSchema ?? db.defineDb({});
   for (const [pluginKey, plugin] of Object.entries(plugins)) {
@@ -18,7 +18,7 @@ function betterStack(config) {
     }
   }
   const router = betterCall.createRouter(allRoutes, {
-    basePath: "/api"
+    basePath
   });
   return {
     handler: router.handler,

package/dist/api/index.d.cts

@@ -1,5 +1,5 @@
-import { e as PrefixedPluginRoutes, f as BackendLibConfig, g as BackendLib } from '../shared/stack.Dva9muUy.cjs';
-export { B as BackendPlugin } from '../shared/stack.Dva9muUy.cjs';
+import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.ByOugz9d.cjs';
+export { B as BackendPlugin } from '../shared/stack.ByOugz9d.cjs';
 import '@btst/yar';
 import '@btst/db';
 import 'better-call';

package/dist/api/index.d.mts

@@ -1,5 +1,5 @@
-import { e as PrefixedPluginRoutes, f as BackendLibConfig, g as BackendLib } from '../shared/stack.Dva9muUy.mjs';
-export { B as BackendPlugin } from '../shared/stack.Dva9muUy.mjs';
+import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.ByOugz9d.mjs';
+export { B as BackendPlugin } from '../shared/stack.ByOugz9d.mjs';
 import '@btst/yar';
 import '@btst/db';
 import 'better-call';

package/dist/api/index.d.ts

@@ -1,5 +1,5 @@
-import { e as PrefixedPluginRoutes, f as BackendLibConfig, g as BackendLib } from '../shared/stack.Dva9muUy.js';
-export { B as BackendPlugin } from '../shared/stack.Dva9muUy.js';
+import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.ByOugz9d.js';
+export { B as BackendPlugin } from '../shared/stack.ByOugz9d.js';
 import '@btst/yar';
 import '@btst/db';
 import 'better-call';

package/dist/api/index.mjs

@@ -2,7 +2,7 @@ import { createRouter } from 'better-call';
 import { defineDb } from '@btst/db';
 
 function betterStack(config) {
-  const { plugins, adapter, dbSchema } = config;
+  const { plugins, adapter, dbSchema, basePath } = config;
   const allRoutes = {};
   let betterDbSchema = dbSchema ?? defineDb({});
   for (const [pluginKey, plugin] of Object.entries(plugins)) {
@@ -16,7 +16,7 @@ function betterStack(config) {
     }
   }
   const router = createRouter(allRoutes, {
-    basePath: "/api"
+    basePath
   });
   return {
     handler: router.handler,

package/dist/client/components/compose.cjs

@@ -0,0 +1,68 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const errorBoundary = require('./error-boundary.cjs');
+
+function RouteRenderer({
+  router,
+  path,
+  NotFoundComponent,
+  onNotFound,
+  onError,
+  props
+}) {
+  const route = router.getRoute(path);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ComposedRoute,
+    {
+      path,
+      PageComponent: route?.PageComponent,
+      ErrorComponent: route?.ErrorComponent,
+      LoadingComponent: route?.LoadingComponent,
+      onNotFound,
+      NotFoundComponent,
+      onError,
+      props
+    }
+  );
+}
+function ComposedRoute({
+  path,
+  PageComponent,
+  ErrorComponent,
+  LoadingComponent,
+  onNotFound,
+  NotFoundComponent,
+  props,
+  onError
+}) {
+  if (PageComponent) {
+    const content = /* @__PURE__ */ jsxRuntime.jsx(PageComponent, { ...props });
+    const isBrowser = typeof window !== "undefined";
+    const suspenseFallback = isBrowser && LoadingComponent ? /* @__PURE__ */ jsxRuntime.jsx(LoadingComponent, {}) : null;
+    if (ErrorComponent) {
+      return /* @__PURE__ */ jsxRuntime.jsx(React.Suspense, { fallback: suspenseFallback, children: /* @__PURE__ */ jsxRuntime.jsx(
+        errorBoundary.ErrorBoundary,
+        {
+          FallbackComponent: ErrorComponent,
+          resetKeys: [path],
+          onError,
+          children: /* @__PURE__ */ jsxRuntime.jsx(React.Suspense, { fallback: suspenseFallback, children: content }, `inner-${path}`)
+        }
+      ) }, `outer-${path}`);
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(React.Suspense, { fallback: suspenseFallback, children: content }, path);
+  } else {
+    if (onNotFound) {
+      onNotFound();
+    }
+    if (NotFoundComponent) {
+      return /* @__PURE__ */ jsxRuntime.jsx(NotFoundComponent, { message: `Unknown route: ${path}` });
+    }
+  }
+}
+
+exports.ComposedRoute = ComposedRoute;
+exports.RouteRenderer = RouteRenderer;

package/dist/client/components/compose.mjs

@@ -0,0 +1,65 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { Suspense } from 'react';
+import { ErrorBoundary } from './error-boundary.mjs';
+
+function RouteRenderer({
+  router,
+  path,
+  NotFoundComponent,
+  onNotFound,
+  onError,
+  props
+}) {
+  const route = router.getRoute(path);
+  return /* @__PURE__ */ jsx(
+    ComposedRoute,
+    {
+      path,
+      PageComponent: route?.PageComponent,
+      ErrorComponent: route?.ErrorComponent,
+      LoadingComponent: route?.LoadingComponent,
+      onNotFound,
+      NotFoundComponent,
+      onError,
+      props
+    }
+  );
+}
+function ComposedRoute({
+  path,
+  PageComponent,
+  ErrorComponent,
+  LoadingComponent,
+  onNotFound,
+  NotFoundComponent,
+  props,
+  onError
+}) {
+  if (PageComponent) {
+    const content = /* @__PURE__ */ jsx(PageComponent, { ...props });
+    const isBrowser = typeof window !== "undefined";
+    const suspenseFallback = isBrowser && LoadingComponent ? /* @__PURE__ */ jsx(LoadingComponent, {}) : null;
+    if (ErrorComponent) {
+      return /* @__PURE__ */ jsx(Suspense, { fallback: suspenseFallback, children: /* @__PURE__ */ jsx(
+        ErrorBoundary,
+        {
+          FallbackComponent: ErrorComponent,
+          resetKeys: [path],
+          onError,
+          children: /* @__PURE__ */ jsx(Suspense, { fallback: suspenseFallback, children: content }, `inner-${path}`)
+        }
+      ) }, `outer-${path}`);
+    }
+    return /* @__PURE__ */ jsx(Suspense, { fallback: suspenseFallback, children: content }, path);
+  } else {
+    if (onNotFound) {
+      onNotFound();
+    }
+    if (NotFoundComponent) {
+      return /* @__PURE__ */ jsx(NotFoundComponent, { message: `Unknown route: ${path}` });
+    }
+  }
+}
+
+export { ComposedRoute, RouteRenderer };

package/dist/client/components/error-boundary.cjs

@@ -0,0 +1,24 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const reactErrorBoundary = require('react-error-boundary');
+
+function ErrorBoundary({
+  children,
+  FallbackComponent,
+  resetKeys,
+  onError
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactErrorBoundary.ErrorBoundary,
+    {
+      FallbackComponent,
+      onError,
+      resetKeys,
+      children
+    }
+  );
+}
+
+exports.ErrorBoundary = ErrorBoundary;

package/dist/client/components/error-boundary.mjs

@@ -0,0 +1,22 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { ErrorBoundary as ErrorBoundary$1 } from 'react-error-boundary';
+
+function ErrorBoundary({
+  children,
+  FallbackComponent,
+  resetKeys,
+  onError
+}) {
+  return /* @__PURE__ */ jsx(
+    ErrorBoundary$1,
+    {
+      FallbackComponent,
+      onError,
+      resetKeys,
+      children
+    }
+  );
+}
+
+export { ErrorBoundary };

package/dist/client/components/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+const compose = require('./compose.cjs');
+const errorBoundary = require('./error-boundary.cjs');
+
+
+
+exports.ComposedRoute = compose.ComposedRoute;
+exports.RouteRenderer = compose.RouteRenderer;
+exports.ErrorBoundary = errorBoundary.ErrorBoundary;

package/dist/client/components/index.d.cts

@@ -0,0 +1,52 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import react__default, { ErrorInfo } from 'react';
+import { FallbackProps } from 'react-error-boundary';
+export { FallbackProps } from 'react-error-boundary';
+import { createRouter } from '@btst/yar';
+
+/**
+ * Route type with optional components
+ */
+type RouteWithComponents = {
+    PageComponent?: react__default.ComponentType;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent?: react__default.ComponentType;
+} | null | undefined;
+/**
+ * Composes the route content with Suspense and Error Boundary
+ * Resolves the route on the client-side where component references are available
+ *
+ * This is marked "use client" so it can access component references safely
+ */
+declare function RouteRenderer({ router, path, NotFoundComponent, onNotFound, onError, props, }: {
+    router: ReturnType<typeof createRouter>;
+    path: string;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    onNotFound?: () => never;
+    onError: (error: Error, info: ErrorInfo) => void;
+    props?: any;
+}): react_jsx_runtime.JSX.Element;
+declare function ComposedRoute({ path, PageComponent, ErrorComponent, LoadingComponent, onNotFound, NotFoundComponent, props, onError, }: {
+    path: string;
+    PageComponent: react__default.ComponentType<any>;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent: react__default.ComponentType;
+    onNotFound?: () => never;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    props?: any;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element | undefined;
+
+declare function ErrorBoundary({ children, FallbackComponent, resetKeys, onError, }: {
+    children: React.ReactNode;
+    FallbackComponent: React.ComponentType<FallbackProps>;
+    resetKeys?: Array<string | number | boolean | null | undefined>;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element;
+
+export { ComposedRoute, ErrorBoundary, RouteRenderer };
+export type { RouteWithComponents };

package/dist/client/components/index.d.mts

@@ -0,0 +1,52 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import react__default, { ErrorInfo } from 'react';
+import { FallbackProps } from 'react-error-boundary';
+export { FallbackProps } from 'react-error-boundary';
+import { createRouter } from '@btst/yar';
+
+/**
+ * Route type with optional components
+ */
+type RouteWithComponents = {
+    PageComponent?: react__default.ComponentType;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent?: react__default.ComponentType;
+} | null | undefined;
+/**
+ * Composes the route content with Suspense and Error Boundary
+ * Resolves the route on the client-side where component references are available
+ *
+ * This is marked "use client" so it can access component references safely
+ */
+declare function RouteRenderer({ router, path, NotFoundComponent, onNotFound, onError, props, }: {
+    router: ReturnType<typeof createRouter>;
+    path: string;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    onNotFound?: () => never;
+    onError: (error: Error, info: ErrorInfo) => void;
+    props?: any;
+}): react_jsx_runtime.JSX.Element;
+declare function ComposedRoute({ path, PageComponent, ErrorComponent, LoadingComponent, onNotFound, NotFoundComponent, props, onError, }: {
+    path: string;
+    PageComponent: react__default.ComponentType<any>;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent: react__default.ComponentType;
+    onNotFound?: () => never;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    props?: any;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element | undefined;
+
+declare function ErrorBoundary({ children, FallbackComponent, resetKeys, onError, }: {
+    children: React.ReactNode;
+    FallbackComponent: React.ComponentType<FallbackProps>;
+    resetKeys?: Array<string | number | boolean | null | undefined>;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element;
+
+export { ComposedRoute, ErrorBoundary, RouteRenderer };
+export type { RouteWithComponents };

package/dist/client/components/index.d.ts

@@ -0,0 +1,52 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import react__default, { ErrorInfo } from 'react';
+import { FallbackProps } from 'react-error-boundary';
+export { FallbackProps } from 'react-error-boundary';
+import { createRouter } from '@btst/yar';
+
+/**
+ * Route type with optional components
+ */
+type RouteWithComponents = {
+    PageComponent?: react__default.ComponentType;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent?: react__default.ComponentType;
+} | null | undefined;
+/**
+ * Composes the route content with Suspense and Error Boundary
+ * Resolves the route on the client-side where component references are available
+ *
+ * This is marked "use client" so it can access component references safely
+ */
+declare function RouteRenderer({ router, path, NotFoundComponent, onNotFound, onError, props, }: {
+    router: ReturnType<typeof createRouter>;
+    path: string;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    onNotFound?: () => never;
+    onError: (error: Error, info: ErrorInfo) => void;
+    props?: any;
+}): react_jsx_runtime.JSX.Element;
+declare function ComposedRoute({ path, PageComponent, ErrorComponent, LoadingComponent, onNotFound, NotFoundComponent, props, onError, }: {
+    path: string;
+    PageComponent: react__default.ComponentType<any>;
+    ErrorComponent?: react__default.ComponentType<FallbackProps>;
+    LoadingComponent: react__default.ComponentType;
+    onNotFound?: () => never;
+    NotFoundComponent?: react__default.ComponentType<{
+        message: string;
+    }>;
+    props?: any;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element | undefined;
+
+declare function ErrorBoundary({ children, FallbackComponent, resetKeys, onError, }: {
+    children: React.ReactNode;
+    FallbackComponent: React.ComponentType<FallbackProps>;
+    resetKeys?: Array<string | number | boolean | null | undefined>;
+    onError: (error: Error, info: ErrorInfo) => void;
+}): react_jsx_runtime.JSX.Element;
+
+export { ComposedRoute, ErrorBoundary, RouteRenderer };
+export type { RouteWithComponents };

package/dist/client/components/index.mjs

@@ -0,0 +1,2 @@
+export { ComposedRoute, RouteRenderer } from './compose.mjs';
+export { ErrorBoundary } from './error-boundary.mjs';