round-core 0.0.4 → 0.0.6

package/.github/workflows/benchmarks.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Setup Bun
       uses: oven-sh/setup-bun@v1
@@ -38,7 +38,7 @@ jobs:
       run: bun run bench:runtime
 
     - name: Upload Report
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: benchmark-report
         path: benchmarks/reports/build-bench.json

package/README.md

@@ -16,7 +16,7 @@
 npm install round-core
 ```
 
-Instead of a Virtual DOM diff, Round updates the UI by subscribing DOM updates directly to reactive primitives (**signals**). This keeps rendering predictable, small, and fast for interactive apps.
+Instead of a Virtual DOM diff, Round updates the UI by subscribing DOM updates directly to reactive primitives (**signals**) and **bindables**. This keeps rendering predictable, small, and fast for interactive apps.
 
 ## What Round is focused on
 
@@ -93,7 +93,7 @@ This scaffolds a minimal Round app with `src/app.round` and an example `src/coun
 
 ## `.round` files
 
-A `.round` file is a JSX-based component module (ESM) compiled by the Round toolchain.
+A `.round` file is a JSX-based component module (ESM) compiled by the Round toolchain. you can also use .jsx files but you wont get the round JSX superset features like conditional rendering and other features.
 
 Example `src/app.round`:
 
@@ -322,27 +322,55 @@ This compiles roughly to a `.map(...)` under the hood.
 
 ## Routing
 
-Round includes router primitives intended for SPA navigation.
+Round includes router primitives intended for SPA navigation. All route paths must start with a forward slash `/`.
 
-Typical usage:
+### Basic Usage
 
 ```jsx
-import { Route } from 'round-core';
+import { Route, Link } from 'round-core';
 
 export default function App() {
     return (
         <div>
-            <Route route="/" title="Home">
-                <div>Home</div>
+            <nav>
+                <Link href="/">Home</Link>
+                <Link href="/about">About</Link>
+            </nav>
+
+            <Route route="/" title="Home" exact>
+                <div>Welcome Home</div>
             </Route>
             <Route route="/about" title="About">
-                <div>About</div>
+                <div>About Us Content</div>
             </Route>
         </div>
     );
 }
 ```
 
+### Nested Routing and Layouts
+
+Routes can be nested to create hierarchical layouts. Child routes automatically inherit and combine paths with their parents.
+
+- **Prefix Matching**: By default, routes use prefix matching (except for the root `/`). This allows a parent route to stay rendered as a "shell" or layout while its children are visited.
+- **Exact Matching**: Use the `exact` prop to ensure a route only renders when the path matches precisely (default for root `/`).
+
+```jsx
+<Route route="/dashboard" title="Dashboard">
+    <h1>Dashboard Shell</h1>
+
+    {/* This route matches /dashboard/profile */}
+    <Route route="/dashboard/profile">
+        <h2>User Profile</h2>
+    </Route>
+
+    {/* This route matches /dashboard/settings */}
+    <Route route="/dashboard/settings">
+        <h2>Settings</h2>
+    </Route>
+</Route>
+```
+
 ## Suspense and lazy loading
 
 Round supports `Suspense` for promise-based rendering and `lazy()` for code splitting.

package/bun.lock

@@ -4,6 +4,7 @@
     "": {
       "name": "round-core",
       "dependencies": {
+        "happy-dom": "^20.0.11",
         "marked": "^12.0.2",
         "vite": "^5.0.0",
         "vitest": "^1.6.0",
@@ -153,6 +154,8 @@
 
     "@types/node": ["@types/node@25.0.2", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-gWEkeiyYE4vqjON/+Obqcoeffmk0NF15WSBwSs7zwVA2bAbTaE0SJ7P0WNGoJn8uE7fiaV5a7dKYIJriEqOrmA=="],
 
+    "@types/whatwg-mimetype": ["@types/whatwg-mimetype@3.0.2", "", {}, "sha512-c2AKvDT8ToxLIOUlN51gTiHXflsfIFisS4pO7pDPoKouJCESkhZnEy623gwP9laCy5lnLDAw1vAzu2vM2YLOrA=="],
+
     "@vitest/expect": ["@vitest/expect@1.6.1", "", { "dependencies": { "@vitest/spy": "1.6.1", "@vitest/utils": "1.6.1", "chai": "^4.3.10" } }, "sha512-jXL+9+ZNIJKruofqXuuTClf44eSpcHlgj3CiuNihUF3Ioujtmc0zIa3UJOW5RjDK1YLBJZnWBlPuqhYycLioog=="],
 
     "@vitest/runner": ["@vitest/runner@1.6.1", "", { "dependencies": { "@vitest/utils": "1.6.1", "p-limit": "^5.0.0", "pathe": "^1.1.1" } }, "sha512-3nSnYXkVkf3mXFfE7vVyPmi3Sazhb/2cfZGGs0JRzFsPFvAMBEcrweV1V1GsrstdXeKCTXlJbvnQwGWgEIHmOA=="],
@@ -241,6 +244,8 @@
 
     "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
 
+    "happy-dom": ["happy-dom@20.0.11", "", { "dependencies": { "@types/node": "^20.0.0", "@types/whatwg-mimetype": "^3.0.2", "whatwg-mimetype": "^3.0.0" } }, "sha512-QsCdAUHAmiDeKeaNojb1OHOPF7NjcWPBR7obdu3NwH2a/oyQaLg5d0aaCy/9My6CdPChYF07dvz5chaXBGaD4g=="],
+
     "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
 
     "has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="],
@@ -405,10 +410,16 @@
 
     "cssstyle/rrweb-cssom": ["rrweb-cssom@0.8.0", "", {}, "sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw=="],
 
+    "happy-dom/@types/node": ["@types/node@20.19.27", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-N2clP5pJhB2YnZJ3PIHFk5RkygRX5WO/5f0WC08tp0wd+sv0rsJk3MqWn3CbNmT2J505a5336jaQj4ph1AdMug=="],
+
+    "happy-dom/whatwg-mimetype": ["whatwg-mimetype@3.0.0", "", {}, "sha512-nt+N2dzIutVRxARx1nghPKGv1xHikU7HKdfafKkLNLindmPU/ch3U31NOCGGA/dmPcmb1VlofO0vnKAcsm0o/Q=="],
+
     "mlly/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
 
     "npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="],
 
     "pkg-types/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+    "happy-dom/@types/node/undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
   }
 }

package/dist/cli.js

@@ -10,6 +10,19 @@ function onSignal() {
 }
 process.on("SIGINT", onSignal);
 process.on("SIGTERM", onSignal);
+process.on("exit", () => {
+  cleanupTemporaryFiles();
+});
+const temporaryFiles = /* @__PURE__ */ new Set();
+function cleanupTemporaryFiles() {
+  for (const f of temporaryFiles) {
+    try {
+      if (fs.existsSync(f)) fs.unlinkSync(f);
+    } catch {
+    }
+  }
+  temporaryFiles.clear();
+}
 function normalizePath(p) {
   return p.replaceAll("\\", "/");
 }
@@ -122,31 +135,6 @@ function resolveFrom(baseDir, p) {
   if (path.isAbsolute(p)) return p;
   return path.resolve(baseDir, p);
 }
-function ensureIndexHtml(rootDir, entryRel, title = "Round") {
-  const indexPath = path.join(rootDir, "index.html");
-  if (fs.existsSync(indexPath)) return;
-  const entryPath = entryRel.startsWith("/") ? entryRel : `/${entryRel}`;
-  fs.writeFileSync(indexPath, [
-    "<!DOCTYPE html>",
-    '<html lang="en">',
-    "<head>",
-    '    <meta charset="UTF-8" />',
-    '    <meta name="viewport" content="width=device-width, initial-scale=1.0" />',
-    `    <title>${title}</title>`,
-    "</head>",
-    "<body>",
-    '    <div id="app"></div>',
-    '    <script type="module">',
-    "        import { render } from 'round-core';",
-    `        import App from '${entryPath}';`,
-    "",
-    '        render(App, document.getElementById("app"));',
-    "    <\/script>",
-    "</body>",
-    "</html>",
-    ""
-  ].join("\n"), "utf8");
-}
 function parseArgs(argv) {
   const args = { _: [] };
   for (let i = 0; i < argv.length; i++) {
@@ -224,7 +212,6 @@ Usage:
   const pkgPath = path.join(projectDir, "package.json");
   const configPath = path.join(projectDir, "round.config.json");
   const viteConfigPath = path.join(projectDir, "vite.config.js");
-  const indexHtmlPath = path.join(projectDir, "index.html");
   const appRoundPath = path.join(srcDir, "app.round");
   const counterRoundPath = path.join(srcDir, "counter.round");
   writeFileIfMissing(pkgPath, JSON.stringify({
@@ -279,26 +266,6 @@ Usage:
     "});",
     ""
   ].join("\n"));
-  writeFileIfMissing(indexHtmlPath, [
-    "<!DOCTYPE html>",
-    '<html lang="en">',
-    "<head>",
-    '    <meta charset="UTF-8" />',
-    '    <meta name="viewport" content="width=device-width, initial-scale=1.0" />',
-    `    <title>${name}</title>`,
-    "</head>",
-    "<body>",
-    '    <div id="app"></div>',
-    '    <script type="module">',
-    "        import { render } from 'round-core';",
-    "        import App from '/src/app.round';",
-    "",
-    "        render(App, document.getElementById('app'));",
-    "    <\/script>",
-    "</body>",
-    "</html>",
-    ""
-  ].join("\n"));
   writeFileIfMissing(appRoundPath, [
     "import { Route } from 'round-core';",
     'import { Counter } from "./counter"',
@@ -369,6 +336,40 @@ function coerceNumber(v, fallback) {
   const n = Number(v);
   return Number.isFinite(n) ? n : fallback;
 }
+function generateIndexHtml(config) {
+  const name = config?.name ?? "Round";
+  const rawEntry = config?.entry ?? "./src/app.round";
+  let entry = rawEntry;
+  if (entry.startsWith("./")) entry = entry.slice(1);
+  if (!entry.startsWith("/")) entry = "/" + entry;
+  return [
+    "<!DOCTYPE html>",
+    '<html lang="en">',
+    "<head>",
+    '    <meta charset="UTF-8" />',
+    '    <meta name="viewport" content="width=device-width, initial-scale=1.0" />',
+    `    <title>${name}</title>`,
+    "</head>",
+    "<body>",
+    '    <div id="app"></div>',
+    '    <script type="module">',
+    "        import { render } from 'round-core';",
+    `        import App from '${entry}';`,
+    "",
+    "        render(App, document.getElementById('app'));",
+    "    <\/script>",
+    "</body>",
+    "</html>"
+  ].join("\n");
+}
+function writeTemporaryIndex(rootDir, config) {
+  const indexPath = path.resolve(rootDir, "index.html");
+  if (fs.existsSync(indexPath)) return false;
+  const content = generateIndexHtml(config);
+  fs.writeFileSync(indexPath, content, "utf8");
+  temporaryFiles.add(indexPath);
+  return true;
+}
 async function runDev({ rootDir, configPathAbs, config }) {
   const startedAt = Date.now();
   const configDir = path.dirname(configPathAbs);
@@ -376,8 +377,7 @@ async function runDev({ rootDir, configPathAbs, config }) {
   if (!entryAbs || !fs.existsSync(entryAbs)) {
     throw new Error(`Entry not found: ${entryAbs ?? "(missing entry)"} (config: ${configPathAbs})`);
   }
-  const entryRel = normalizePath(path.relative(rootDir, entryAbs));
-  ensureIndexHtml(rootDir, entryRel, config?.name ?? "Round");
+  normalizePath(path.relative(rootDir, entryAbs));
   let viteServer = null;
   let restarting = false;
   let restartTimer = null;
@@ -387,11 +387,11 @@ async function runDev({ rootDir, configPathAbs, config }) {
     if (!entryAbs2 || !fs.existsSync(entryAbs2)) {
       throw new Error(`Entry not found: ${entryAbs2 ?? "(missing entry)"} (config: ${configPathAbs})`);
     }
-    const entryRel2 = normalizePath(path.relative(rootDir, entryAbs2));
-    ensureIndexHtml(rootDir, entryRel2, nextConfig?.name ?? "Round");
+    normalizePath(path.relative(rootDir, entryAbs2));
     const serverPort2 = coerceNumber(nextConfig?.dev?.port, 5173);
     const open2 = Boolean(nextConfig?.dev?.open);
     const base2 = nextConfig?.routing?.base ?? "/";
+    writeTemporaryIndex(rootDir, nextConfig);
     if (showBanner) {
       banner();
       process.stdout.write(`${c("  Config", "gray")}  ${configPathAbs}
@@ -458,10 +458,10 @@ async function runBuild({ rootDir, configPathAbs, config }) {
   if (!entryAbs || !fs.existsSync(entryAbs)) {
     throw new Error(`Entry not found: ${entryAbs ?? "(missing entry)"} (config: ${configPathAbs})`);
   }
-  const entryRel = normalizePath(path.relative(rootDir, entryAbs));
-  ensureIndexHtml(rootDir, entryRel, config?.name ?? "Round");
+  normalizePath(path.relative(rootDir, entryAbs));
   const outDir = config?.output ? resolveFrom(configDir, config.output) : resolveFrom(rootDir, "./dist");
   const base = config?.routing?.base ?? "/";
+  writeTemporaryIndex(rootDir, config);
   banner();
   process.stdout.write(`${c("  Config", "gray")}  ${configPathAbs}
 `);
@@ -497,10 +497,7 @@ async function runPreview({ rootDir, configPathAbs, config }) {
   const base = config?.routing?.base ?? "/";
   const previewPort = coerceNumber(config?.dev?.port, 5173);
   const entryAbs = config?.entry ? resolveFrom(configDir, config.entry) : null;
-  if (entryAbs && fs.existsSync(entryAbs)) {
-    const entryRel = normalizePath(path.relative(rootDir, entryAbs));
-    ensureIndexHtml(rootDir, entryRel, config?.name ?? "Round");
-  }
+  if (entryAbs && fs.existsSync(entryAbs)) ;
   banner();
   process.stdout.write(`${c("Config:", "cyan")} ${configPathAbs}
 `);

package/dist/index.d.ts

@@ -0,0 +1,326 @@
+/**
+ * Round Framework Type Definitions
+ */
+
+export interface RoundSignal<T> {
+    /**
+     * Get or set the current value.
+     */
+    (newValue?: T): T;
+
+    /**
+     * Get the current value (reactive).
+     */
+    value: T;
+
+    /**
+     * Get the current value without tracking dependencies.
+     */
+    peek(): T;
+
+    /**
+     * Creates a transformed view of this signal.
+     */
+    transform<U>(fromInput: (v: U) => T, toOutput: (v: T) => U): RoundSignal<U>;
+
+    /**
+     * Attaches validation logic to the signal.
+     */
+    validate(validator: (next: T, prev: T) => string | boolean | undefined | null, options?: {
+        /** Timing of validation: 'input' (default) or 'blur'. */
+        validateOn?: 'input' | 'blur';
+        /** Whether to run validation immediately on startup. */
+        validateInitial?: boolean;
+    }): RoundSignal<T> & {
+        /** Signal containing the current validation error message. */
+        error: RoundSignal<string | null>;
+        /** Manually trigger validation check. Returns true if valid. */
+        check(): boolean
+    };
+
+    /**
+     * Creates a read/write view of a specific property path.
+     */
+    $pick<K extends keyof T>(path: K): RoundSignal<T[K]>;
+    $pick(path: string | string[]): RoundSignal<any>;
+
+    /**
+     * Internal: marks the signal as bindable for two-way bindings.
+     */
+    bind?: boolean;
+}
+
+/**
+ * Creates a reactive signal.
+ */
+export function signal<T>(initialValue?: T): RoundSignal<T>;
+
+/**
+ * Creates a bindable signal intended for two-way DOM bindings.
+ */
+export function bindable<T>(initialValue?: T): RoundSignal<T>;
+
+/**
+ * Run a function without tracking any signals it reads.
+ * Any signals accessed inside the function will not become dependencies of the current effect.
+ */
+export function untrack<T>(fn: () => T): T;
+
+/**
+ * Create a reactive side-effect that runs whenever its signal dependencies change.
+ */
+export function effect(fn: () => void | (() => void), options?: {
+    /** If false, the effect won't run immediately on creation. Defaults to true. */
+    onLoad?: boolean
+}): () => void;
+
+/**
+ * Create a reactive side-effect with explicit dependencies.
+ */
+export function effect(deps: any[], fn: () => void | (() => void), options?: {
+    /** If false, the effect won't run immediately on creation. Defaults to true. */
+    onLoad?: boolean
+}): () => void;
+
+/**
+ * Create a read-only computed signal derived from other signals.
+ */
+export function derive<T>(fn: () => T): () => T;
+
+/**
+ * Create a read/write view of a specific path within a signal object.
+ */
+export function pick<T = any>(root: RoundSignal<any>, path: string | string[]): RoundSignal<T>;
+
+/**
+ * Store API
+ */
+export interface RoundStore<T> {
+    /**
+     * Access a specific key from the store as a bindable signal.
+     */
+    use<K extends keyof T>(key: K): RoundSignal<T[K]>;
+
+    /**
+     * Update a specific key in the store.
+     */
+    set<K extends keyof T>(key: K, value: T[K]): T[K];
+
+    /**
+     * Batch update multiple keys in the store.
+     */
+    patch(obj: Partial<T>): void;
+
+    /**
+     * Get a snapshot of the current state.
+     */
+    snapshot(options?: {
+        /** If true, the returned values will be reactive signals. */
+        reactive?: boolean
+    }): T;
+
+    /**
+     * Enable persistence for the store.
+     */
+    persist(storageKey: string, options?: {
+        /** The storage implementation (defaults to localStorage). */
+        storage?: Storage;
+        /** Debounce time in milliseconds for writes. */
+        debounce?: number;
+        /** Array of keys to exclude from persistence. */
+        exclude?: string[];
+    }): RoundStore<T>;
+
+    /**
+     * Action methods defined during store creation.
+     */
+    actions: Record<string, Function>;
+}
+
+/**
+ * Create a shared global state store with actions and optional persistence.
+ */
+export function createStore<T, A extends Record<string, (state: T, ...args: any[]) => Partial<T> | void>>(
+    initialState: T,
+    actions?: A
+): RoundStore<T> & { [K in keyof A]: (...args: Parameters<A[K]> extends [any, ...infer P] ? P : never) => any };
+
+/**
+ * Router API
+ */
+export interface RouteProps {
+    /** The path to match. Must start with a forward slash. */
+    route?: string;
+    /** If true, only matches if the path is exactly the same. */
+    exact?: boolean;
+    /** Page title to set in the document header when active. */
+    title?: string;
+    /** Meta description to set in the document header when active. */
+    description?: string;
+    /** Advanced head configuration including links and meta tags. */
+    head?: any;
+    /** Fragment or elements to render when matched. */
+    children?: any;
+}
+
+/**
+ * Define a route that renders its children when the path matches.
+ */
+export function Route(props: RouteProps): any;
+
+/**
+ * An alias for Route, typically used for top-level pages.
+ */
+export function Page(props: RouteProps): any;
+
+export interface LinkProps {
+    /** The destination path. */
+    href: string;
+    /** Alias for href. */
+    to?: string;
+    /** Use SPA navigation (prevents full page reloads). Defaults to true. */
+    spa?: boolean;
+    /** Force a full page reload on navigation. */
+    reload?: boolean;
+    /** Custom click event handler. */
+    onClick?: (e: MouseEvent) => void;
+    /** Link content (text or elements). */
+    children?: any;
+    [key: string]: any;
+}
+
+/**
+ * A standard link component that performs SPA navigation.
+ */
+export function Link(props: LinkProps): any;
+
+/**
+ * Define a fallback component or content for when no routes match.
+ */
+export function NotFound(props: {
+    /** Optional component to render for the 404 state. */
+    component?: any;
+    /** Fallback content. ignored if 'component' is provided. */
+    children?: any
+}): any;
+
+/**
+ * Navigate to a different path programmatically.
+ */
+export function navigate(to: string, options?: {
+    /** If true, replaces the current history entry instead of pushing. */
+    replace?: boolean
+}): void;
+
+/**
+ * Hook to get a reactive function returning the current normalized pathname.
+ */
+export function usePathname(): () => string;
+
+/**
+ * Get the current normalized pathname.
+ */
+export function getPathname(): string;
+
+/**
+ * Hook to get a reactive function returning the current location object.
+ */
+export function useLocation(): () => { pathname: string; search: string; hash: string };
+
+/**
+ * Get the current location object (pathname, search, hash).
+ */
+export function getLocation(): { pathname: string; search: string; hash: string };
+
+/**
+ * Hook to get a reactive function returning whether the current path has no matches.
+ */
+export function useIsNotFound(): () => boolean;
+
+/**
+ * Get whether the current path is NOT matched by any defined route.
+ */
+export function getIsNotFound(): boolean;
+
+/**
+ * DOM & Context API
+ */
+
+/**
+ * Create a DOM element or instance a component.
+ */
+export function createElement(tag: any, props?: any, ...children: any[]): any;
+
+/**
+ * A grouping component that returns its children without a wrapper element.
+ */
+export function Fragment(props: { children?: any }): any;
+
+export interface Context<T> {
+    /** Internal identifier for the context. */
+    id: number;
+    /** Default value used when no Provider is found in the tree. */
+    defaultValue: T;
+    /** Component that provides a value to all its descendants. */
+    Provider: (props: { value: T; children?: any }) => any;
+}
+
+/**
+ * Create a new Context object for sharing state between components.
+ */
+export function createContext<T>(defaultValue?: T): Context<T>;
+
+/**
+ * Read the current value of a context from the component tree.
+ */
+export function readContext<T>(ctx: Context<T>): T;
+
+/**
+ * Returns a reactive function that reads the current context value.
+ */
+export function bindContext<T>(ctx: Context<T>): () => T;
+
+/**
+ * Async & Code Splitting
+ */
+
+/**
+ * Mark a component for lazy loading (code-splitting).
+ * Expects a function returning a dynamic import promise.
+ */
+export function lazy<T>(fn: () => Promise<{ default: T }>): T;
+
+export interface SuspenseProps {
+    /** Content to show while children (e.g. lazy components) are loading. */
+    fallback: any;
+    /** Content that might trigger a loading state. */
+    children?: any;
+}
+
+/**
+ * Component that boundaries async operations and renders a fallback while loading.
+ */
+export function Suspense(props: SuspenseProps): any;
+
+/**
+ * Head Management
+ */
+
+/**
+ * Define static head metadata (titles, meta tags, favicons, etc.).
+ */
+export function startHead(head: any): any;
+
+/**
+ * Markdown
+ */
+
+/**
+ * Component that renders Markdown content into HTML.
+ */
+export function Markdown(props: {
+    /** The markdown string or a function returning it. */
+    content: string | (() => string);
+    /** Remark/Rehype configuration options. */
+    options?: any
+}): any;