gorsee 0.2.4 → 0.2.6

package/dist-pkg/reactive/resource.d.ts

@@ -0,0 +1,25 @@
+import { type SignalGetter } from "./signal.js";
+export interface ResourceOptions {
+    /** Initial data (skip first fetch) */
+    initialData?: unknown;
+    /** Retry count on failure (default: 0) */
+    retry?: number;
+    /** Retry delay in ms (default: 1000) */
+    retryDelay?: number;
+    /** Cache key for deduplication */
+    key?: string;
+    /** Stale time in ms — refetch after this period */
+    staleTime?: number;
+    /** Optional diagnostics label for reactive tracing */
+    label?: string;
+}
+export interface ResourceState<T> {
+    loading: SignalGetter<boolean>;
+    error: SignalGetter<Error | undefined>;
+    refetch: () => void;
+    mutate: (value: T | undefined | ((prev: T | undefined) => T | undefined)) => void;
+}
+export type ResourceReturn<T> = [SignalGetter<T | undefined>, ResourceState<T>];
+export declare function invalidateResource(key: string): void;
+export declare function invalidateAll(): void;
+export declare function createResource<T>(fetcher: () => Promise<T>, options?: ResourceOptions): ResourceReturn<T>;

package/dist-pkg/reactive/resource.js

@@ -0,0 +1,153 @@
+import { createSignal } from "./signal.js";
+import {
+  trackResourceCreated,
+  trackResourceInvalidation,
+  trackResourceLoadError,
+  trackResourceLoadStart,
+  trackResourceLoadSuccess,
+  trackResourceMutate,
+  trackResourceRefetch
+} from "./diagnostics.js";
+const resourceCache = new Map, resourceCacheEpochs = new Map;
+function getCacheEpoch(key) {
+  return resourceCacheEpochs.get(key) ?? 0;
+}
+function bumpCacheEpoch(key) {
+  const nextEpoch = getCacheEpoch(key) + 1;
+  resourceCacheEpochs.set(key, nextEpoch);
+  return nextEpoch;
+}
+export function invalidateResource(key) {
+  bumpCacheEpoch(key);
+  resourceCache.delete(key);
+  trackResourceInvalidation(key, "resource.invalidate");
+}
+export function invalidateAll() {
+  for (const key of resourceCache.keys()) {
+    bumpCacheEpoch(key);
+    trackResourceInvalidation(key, "resource.invalidateAll");
+  }
+  resourceCache.clear();
+}
+export function createResource(fetcher, options) {
+  const retryCount = options?.retry ?? 0, retryDelay = options?.retryDelay ?? 1000, cacheKey = options?.key, staleTime = options?.staleTime, diagnosticsLabel = options?.label ?? cacheKey, resourceNodeId = trackResourceCreated(diagnosticsLabel, cacheKey), cached = cacheKey ? resourceCache.get(cacheKey) : void 0, hasValidCache = cached && staleTime && Date.now() - cached.fetchedAt < staleTime, initialValue = hasValidCache ? cached.data : options?.initialData, [data, setData] = createSignal(initialValue), [loading, setLoading] = createSignal(!hasValidCache), [error, setError] = createSignal(void 0);
+  let currentLoadId = 0;
+  function writeCachedValue(value) {
+    if (!cacheKey)
+      return;
+    resourceCache.set(cacheKey, {
+      data: value,
+      fetchedAt: Date.now()
+    });
+  }
+  async function fetchWithRetry(attempt) {
+    try {
+      return await fetcher();
+    } catch (err) {
+      if (attempt < retryCount) {
+        await new Promise((r) => setTimeout(r, retryDelay * (attempt + 1)));
+        return fetchWithRetry(attempt + 1);
+      }
+      throw err;
+    }
+  }
+  const load = (forceFresh = !1) => {
+    const loadId = ++currentLoadId;
+    if (cacheKey && !forceFresh) {
+      const entry = resourceCache.get(cacheKey);
+      if (entry?.promise) {
+        const cacheEpoch = getCacheEpoch(cacheKey);
+        trackResourceLoadStart(resourceNodeId, diagnosticsLabel, cacheKey, "deduped");
+        entry.promise.then((result) => {
+          if (loadId !== currentLoadId)
+            return;
+          if (getCacheEpoch(cacheKey) !== cacheEpoch) {
+            setLoading(!1);
+            return;
+          }
+          setData(() => result);
+          setLoading(!1);
+          trackResourceLoadSuccess(resourceNodeId, diagnosticsLabel, cacheKey);
+        }).catch((err) => {
+          if (loadId !== currentLoadId)
+            return;
+          if (getCacheEpoch(cacheKey) !== cacheEpoch) {
+            setLoading(!1);
+            return;
+          }
+          setError(err instanceof Error ? err : Error(String(err)));
+          setLoading(!1);
+          trackResourceLoadError(resourceNodeId, diagnosticsLabel, cacheKey, err instanceof Error ? err.message : String(err));
+        });
+        return;
+      }
+    }
+    const cacheEpoch = cacheKey ? bumpCacheEpoch(cacheKey) : 0;
+    setLoading(!0);
+    setError(void 0);
+    trackResourceLoadStart(resourceNodeId, diagnosticsLabel, cacheKey);
+    const promise = fetchWithRetry(0);
+    if (cacheKey) {
+      const entry = resourceCache.get(cacheKey) ?? { data: void 0, fetchedAt: 0 };
+      entry.promise = promise;
+      resourceCache.set(cacheKey, entry);
+    }
+    promise.then((result) => {
+      if (loadId !== currentLoadId)
+        return;
+      if (cacheKey && getCacheEpoch(cacheKey) !== cacheEpoch) {
+        setLoading(!1);
+        return;
+      }
+      setData(() => result);
+      setLoading(!1);
+      trackResourceLoadSuccess(resourceNodeId, diagnosticsLabel, cacheKey);
+      if (cacheKey)
+        resourceCache.set(cacheKey, { data: result, fetchedAt: Date.now() });
+    }).catch((err) => {
+      if (loadId !== currentLoadId)
+        return;
+      if (cacheKey && getCacheEpoch(cacheKey) !== cacheEpoch) {
+        setLoading(!1);
+        return;
+      }
+      setError(err instanceof Error ? err : Error(String(err)));
+      setLoading(!1);
+      trackResourceLoadError(resourceNodeId, diagnosticsLabel, cacheKey, err instanceof Error ? err.message : String(err));
+      if (cacheKey) {
+        const entry = resourceCache.get(cacheKey);
+        if (entry)
+          entry.promise = void 0;
+      }
+    });
+  };
+  if (!hasValidCache)
+    load();
+  return [
+    data,
+    {
+      loading,
+      error,
+      refetch: () => {
+        trackResourceRefetch(resourceNodeId, diagnosticsLabel, cacheKey);
+        load(!0);
+      },
+      mutate: (value) => {
+        trackResourceMutate(resourceNodeId, diagnosticsLabel, cacheKey);
+        currentLoadId++;
+        if (cacheKey)
+          bumpCacheEpoch(cacheKey);
+        setLoading(!1);
+        setError(void 0);
+        if (typeof value === "function") {
+          const nextValue = value(data());
+          setData(() => nextValue);
+          writeCachedValue(nextValue);
+        } else {
+          setData(() => value);
+          writeCachedValue(value);
+        }
+      }
+    }
+  ];
+}

package/dist-pkg/reactive/signal.d.ts

@@ -0,0 +1,4 @@
+import { type ReactiveDiagnosticOptions } from "./diagnostics.js";
+export type SignalGetter<T> = () => T;
+export type SignalSetter<T> = (value: T | ((prev: T) => T)) => void;
+export declare function createSignal<T>(initialValue: T, options?: ReactiveDiagnosticOptions): [SignalGetter<T>, SignalSetter<T>];

package/dist-pkg/reactive/signal.js

@@ -0,0 +1,17 @@
+import { signal as alienSignal } from "alien-signals";
+import { trackSignalCreated, trackSignalRead, trackSignalWrite } from "./diagnostics.js";
+import { GORSEE_SIGNAL_MARKER } from "../runtime/html-escape.js";
+export function createSignal(initialValue, options = {}) {
+  const s = alienSignal(initialValue), nodeId = trackSignalCreated(options.label), getter = () => {
+    trackSignalRead(nodeId, options.label);
+    return s();
+  };
+  getter[GORSEE_SIGNAL_MARKER] = !0;
+  return [getter, (value) => {
+    trackSignalWrite(nodeId, options.label);
+    if (typeof value === "function")
+      s(value(s()));
+    else
+      s(value);
+  }];
+}

package/dist-pkg/reactive/store.d.ts

@@ -0,0 +1,6 @@
+import { type SignalGetter } from "./signal.js";
+export type Store<T extends Record<string, unknown>> = {
+    readonly [K in keyof T]: SignalGetter<T[K]>;
+};
+export type SetStore<T extends Record<string, unknown>> = <K extends keyof T>(key: K, value: T[K] | ((prev: T[K]) => T[K])) => void;
+export declare function createStore<T extends Record<string, unknown>>(initialValue: T): [Store<T>, SetStore<T>];

package/dist-pkg/reactive/store.js

@@ -0,0 +1,19 @@
+import { createSignal } from "./signal.js";
+export function createStore(initialValue) {
+  const signals = new Map;
+  for (const key of Object.keys(initialValue))
+    signals.set(key, createSignal(initialValue[key]));
+  return [new Proxy({}, {
+    get(_target, prop) {
+      const entry = signals.get(prop);
+      if (!entry)
+        return;
+      return entry[0];
+    }
+  }), (key, value) => {
+    const entry = signals.get(key);
+    if (!entry)
+      return;
+    entry[1](value);
+  }];
+}

package/dist-pkg/router/index.d.ts

@@ -0,0 +1,2 @@
+export { createRouter, type Route } from "./scanner.js";
+export { matchRoute, buildStaticMap, type MatchResult } from "./matcher.js";

package/dist-pkg/router/index.js

@@ -0,0 +1,2 @@
+export { createRouter } from "./scanner.js";
+export { matchRoute, buildStaticMap } from "./matcher.js";

package/dist-pkg/router/matcher.d.ts

@@ -0,0 +1,7 @@
+import type { Route } from "./scanner.js";
+export interface MatchResult {
+    route: Route;
+    params: Record<string, string>;
+}
+export declare function buildStaticMap(routes: Route[]): Map<string, Route>;
+export declare function matchRoute(routes: Route[], pathname: string, staticMap?: Map<string, Route>): MatchResult | null;

package/dist-pkg/router/matcher.js

@@ -0,0 +1,40 @@
+export function buildStaticMap(routes) {
+  const map = new Map;
+  for (const route of routes)
+    if (!route.isDynamic)
+      map.set(route.path, route);
+  return map;
+}
+export function matchRoute(routes, pathname, staticMap) {
+  const normalized = normalizePathname(pathname);
+  if (staticMap) {
+    const staticRoute = staticMap.get(normalized);
+    if (staticRoute)
+      return { route: staticRoute, params: {} };
+  }
+  for (const route of routes) {
+    if (!route.isDynamic && staticMap)
+      continue;
+    const match = route.pattern.exec(normalized);
+    if (!match)
+      continue;
+    const params = {};
+    for (let i = 0;i < route.params.length; i++) {
+      const value = match[i + 1];
+      if (value !== void 0)
+        try {
+          params[route.params[i]] = decodeURIComponent(value);
+        } catch {
+          params[route.params[i]] = value;
+        }
+    }
+    return { route, params };
+  }
+  return null;
+}
+function normalizePathname(pathname) {
+  const normalized = pathname.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+  if (normalized === "/")
+    return "/";
+  return normalized.replace(/\/+$/, "") || "/";
+}

package/dist-pkg/router/scanner.d.ts

@@ -0,0 +1,14 @@
+export interface Route {
+    path: string;
+    pattern: RegExp;
+    filePath: string;
+    isDynamic: boolean;
+    params: string[];
+    layoutPath: string | null;
+    layoutPaths: string[];
+    middlewarePath: string | null;
+    middlewarePaths: string[];
+    errorPath: string | null;
+    loadingPath: string | null;
+}
+export declare function createRouter(routesDir: string): Promise<Route[]>;

package/dist-pkg/router/scanner.js

@@ -0,0 +1,141 @@
+import { readdir, stat } from "node:fs/promises";
+import { join, extname, basename } from "node:path";
+const ROUTE_EXTENSIONS = new Set([".tsx", ".ts", ".jsx", ".js", ".mjs"]), IGNORED_PREFIXES = ["_"];
+function fileToRoutePath(relativePath) {
+  let route = relativePath.replace(/\\/g, "/").replace(/\.(tsx?|jsx?)$/, "");
+  if (route === "index" || route.endsWith("/index"))
+    route = route.slice(0, -5) || "/";
+  if (!route.startsWith("/"))
+    route = "/" + route;
+  if (route.length > 1 && route.endsWith("/"))
+    route = route.slice(0, -1);
+  return route;
+}
+function routeToPattern(routePath) {
+  const params = [], finalRegex = routePath.split("/").map((segment) => {
+    if (!segment)
+      return "";
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      const param = segment.slice(4, -1);
+      params.push(param);
+      return "(?:/(.+))?";
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      const param = segment.slice(1, -1);
+      params.push(param);
+      return "/([^/]+)";
+    }
+    return "/" + segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }).join("") || "/";
+  return {
+    pattern: new RegExp(`^${finalRegex}$`),
+    params
+  };
+}
+async function scanDirectory(dir, basePath, routes, parent) {
+  const layouts = new Map(parent?.layouts), middlewares = new Map(parent?.middlewares);
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return { layouts, middlewares, errors: new Map, loadings: new Map };
+  }
+  entries.sort((a, b) => a.localeCompare(b));
+  const errors = new Map(parent?.errors), loadings = new Map(parent?.loadings);
+  for (const entry of entries) {
+    const fullPath = join(dir, entry), name = basename(entry, extname(entry));
+    if (name === "_layout")
+      layouts.set(basePath || "/", fullPath);
+    if (name === "_middleware")
+      middlewares.set(basePath || "/", fullPath);
+    if (name === "_error")
+      errors.set(basePath || "/", fullPath);
+    if (name === "_loading")
+      loadings.set(basePath || "/", fullPath);
+  }
+  for (const entry of entries) {
+    const fullPath = join(dir, entry), entryStat = await stat(fullPath), name = basename(entry, extname(entry));
+    if (entryStat.isDirectory()) {
+      const subPath = entry.startsWith("(") && entry.endsWith(")") ? basePath : basePath ? `${basePath}/${entry}` : entry, sub = await scanDirectory(fullPath, subPath, routes, { layouts, middlewares, errors, loadings });
+      for (const [k, v] of sub.layouts)
+        layouts.set(k, v);
+      for (const [k, v] of sub.middlewares)
+        middlewares.set(k, v);
+      for (const [k, v] of sub.errors)
+        errors.set(k, v);
+      for (const [k, v] of sub.loadings)
+        loadings.set(k, v);
+      continue;
+    }
+    if (!ROUTE_EXTENSIONS.has(extname(entry)))
+      continue;
+    if (IGNORED_PREFIXES.some((p) => name.startsWith(p)))
+      continue;
+    const relPath = basePath ? `${basePath}/${entry}` : entry, routePath = fileToRoutePath(relPath), { pattern, params } = routeToPattern(routePath), middlewarePaths = [], segments = (basePath || "/").split("/").filter(Boolean), dirs = ["/"];
+    for (let i = 0;i < segments.length; i++)
+      dirs.push(segments.slice(0, i + 1).join("/"));
+    for (const d of dirs) {
+      const mwPath = middlewares.get(d);
+      if (mwPath)
+        middlewarePaths.push(mwPath);
+    }
+    const layoutPaths = [];
+    for (const d of dirs) {
+      const lPath = layouts.get(d);
+      if (lPath)
+        layoutPaths.push(lPath);
+    }
+    let loadingPath = null;
+    for (let i = dirs.length - 1;i >= 0; i--) {
+      const lp = loadings.get(dirs[i]);
+      if (lp) {
+        loadingPath = lp;
+        break;
+      }
+    }
+    let errorPath = null;
+    for (let i = dirs.length - 1;i >= 0; i--) {
+      const ep = errors.get(dirs[i]);
+      if (ep) {
+        errorPath = ep;
+        break;
+      }
+    }
+    routes.push({
+      path: routePath,
+      pattern,
+      filePath: fullPath,
+      isDynamic: params.length > 0,
+      params,
+      layoutPath: layoutPaths[layoutPaths.length - 1] ?? null,
+      layoutPaths,
+      middlewarePath: middlewarePaths[middlewarePaths.length - 1] ?? null,
+      middlewarePaths,
+      errorPath,
+      loadingPath
+    });
+  }
+  return { layouts, middlewares, errors, loadings };
+}
+export async function createRouter(routesDir) {
+  const routes = [];
+  await scanDirectory(routesDir, "", routes);
+  routes.sort((a, b) => {
+    if (a.isDynamic !== b.isDynamic)
+      return a.isDynamic ? 1 : -1;
+    const aCatchAll = a.path.includes("[..."), bCatchAll = b.path.includes("[...");
+    if (aCatchAll !== bCatchAll)
+      return aCatchAll ? 1 : -1;
+    return a.path.localeCompare(b.path);
+  });
+  const seen = new Map;
+  for (const route of routes) {
+    const existing = seen.get(route.path);
+    if (existing)
+      throw Error(`Duplicate route path detected: ${route.path}
+- ${existing}
+- ${route.filePath}`);
+    seen.set(route.path, route.filePath);
+  }
+  return routes;
+}

package/dist-pkg/routes/index.d.ts

@@ -0,0 +1 @@
+export { typedLink, typedNavigate, typedPrefetch, resolveTypedRouteTarget, buildSearchParams, buildTypedPath, createTypedRoute, extractRouteParamKeys, type TypedRouteDefinition, type TypedRouteOptions, type TypedRouteParams, type TypedRouteSearchValue, type TypedRouteTarget, } from "../runtime/typed-routes.js";

package/dist-pkg/routes/index.js

@@ -0,0 +1,10 @@
+export {
+  typedLink,
+  typedNavigate,
+  typedPrefetch,
+  resolveTypedRouteTarget,
+  buildSearchParams,
+  buildTypedPath,
+  createTypedRoute,
+  extractRouteParamKeys
+} from "../runtime/typed-routes.js";

package/dist-pkg/runtime/app-config.d.ts

@@ -0,0 +1,26 @@
+import type { MiddlewareFn } from "../server/middleware.js";
+import { type AIObservabilityConfig } from "../ai/index.js";
+export interface AppConfig {
+    ai?: AIObservabilityConfig;
+    security?: {
+        origin?: string;
+        hosts?: string[];
+        proxy?: {
+            preset?: ProxyPreset;
+            trustForwardedHeaders?: boolean;
+            trustedForwardedHops?: number;
+        };
+        rpc?: {
+            middlewares?: MiddlewareFn[];
+        };
+    };
+}
+export type ProxyPreset = "none" | "reverse-proxy" | "vercel" | "netlify" | "fly" | "cloudflare";
+export declare function loadAppConfig(cwd: string, explicitPath?: string): Promise<AppConfig>;
+export declare function resolveRPCMiddlewares(config: AppConfig, explicitMiddlewares?: MiddlewareFn[]): MiddlewareFn[] | undefined;
+export declare function resolveAIConfig(cwd: string, config: AppConfig, explicitConfig?: AIObservabilityConfig): AIObservabilityConfig | undefined;
+export declare function resolveTrustedOrigin(config: AppConfig, env?: NodeJS.ProcessEnv): string | undefined;
+export declare function resolveTrustForwardedHeaders(config: AppConfig): boolean;
+export declare function resolveTrustedForwardedHops(config: AppConfig): number;
+export declare function resolveTrustedHosts(config: AppConfig): string[];
+export declare function resolveProxyPreset(config: AppConfig): ProxyPreset;

package/dist-pkg/runtime/app-config.js

@@ -0,0 +1,69 @@
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { resolveAIObservabilityConfig } from "../ai/index.js";
+export async function loadAppConfig(cwd, explicitPath) {
+  const candidatePaths = explicitPath ? [explicitPath] : [
+    join(cwd, "app.config.ts"),
+    join(cwd, "app.config.js"),
+    join(cwd, "app.config.mjs")
+  ];
+  for (const configPath of candidatePaths)
+    try {
+      const configStat = await stat(configPath);
+      return (await import(`${pathToFileURL(configPath).href}?t=${configStat.mtimeMs}`)).default ?? {};
+    } catch {
+      continue;
+    }
+  return {};
+}
+export function resolveRPCMiddlewares(config, explicitMiddlewares) {
+  if (explicitMiddlewares && explicitMiddlewares.length > 0)
+    return explicitMiddlewares;
+  const configMiddlewares = config.security?.rpc?.middlewares;
+  return configMiddlewares && configMiddlewares.length > 0 ? configMiddlewares : void 0;
+}
+export function resolveAIConfig(cwd, config, explicitConfig) {
+  const merged = {
+    ...config.ai ?? {},
+    ...explicitConfig ?? {}
+  };
+  if (Object.keys(merged).length === 0)
+    return;
+  return resolveAIObservabilityConfig(cwd, merged);
+}
+export function resolveTrustedOrigin(config, env = process.env) {
+  return config.security?.origin ?? env.APP_ORIGIN;
+}
+export function resolveTrustForwardedHeaders(config) {
+  const explicit = config.security?.proxy?.trustForwardedHeaders;
+  if (typeof explicit === "boolean")
+    return explicit;
+  return getProxyPresetDefaults(resolveProxyPreset(config)).trustForwardedHeaders;
+}
+export function resolveTrustedForwardedHops(config) {
+  const hops = config.security?.proxy?.trustedForwardedHops;
+  if (typeof hops === "number" && Number.isFinite(hops) && hops > 0)
+    return Math.floor(hops);
+  return getProxyPresetDefaults(resolveProxyPreset(config)).trustedForwardedHops;
+}
+export function resolveTrustedHosts(config) {
+  return config.security?.hosts ?? [];
+}
+export function resolveProxyPreset(config) {
+  return config.security?.proxy?.preset ?? "none";
+}
+function getProxyPresetDefaults(preset) {
+  switch (preset) {
+    case "reverse-proxy":
+    case "vercel":
+    case "netlify":
+    case "fly":
+      return { trustForwardedHeaders: !0, trustedForwardedHops: 1 };
+    case "cloudflare":
+      return { trustForwardedHeaders: !1, trustedForwardedHops: 0 };
+    case "none":
+    default:
+      return { trustForwardedHeaders: !1, trustedForwardedHops: 1 };
+  }
+}

package/dist-pkg/runtime/client.d.ts

@@ -0,0 +1,3 @@
+import type { GorseeNode } from "./jsx-runtime.js";
+export declare function render(component: () => GorseeNode, container: Element): void;
+export declare function hydrate(component: () => GorseeNode, container: Element): void;

package/dist-pkg/runtime/client.js

@@ -0,0 +1,42 @@
+import { jsx } from "./jsx-runtime.js";
+import { enterHydration, exitHydration, isHydrating } from "./hydration.js";
+import { replayEvents } from "./event-replay.js";
+import { isRenderableThunk } from "./html-escape.js";
+function isVNodeLike(value) {
+  return typeof value === "object" && value !== null && "type" in value && "props" in value;
+}
+function renderVNodeLike(vnode) {
+  return jsx(vnode.type, vnode.props);
+}
+function insertResult(container, result) {
+  if (result instanceof Node)
+    container.appendChild(result);
+  else if (typeof result === "object" && result !== null && isVNodeLike(result))
+    container.appendChild(renderVNodeLike(result));
+  else if (Array.isArray(result))
+    for (const child of result)
+      insertResult(container, child);
+  else if (isRenderableThunk(result))
+    insertResult(container, result());
+  else if (result != null && typeof result !== "boolean")
+    container.appendChild(document.createTextNode(String(result)));
+}
+export function render(component, container) {
+  container.replaceChildren();
+  insertResult(container, component());
+}
+export function hydrate(component, container) {
+  enterHydration(container);
+  let diagnostics;
+  try {
+    component();
+    diagnostics = exitHydration();
+  } catch (error) {
+    if (isHydrating())
+      exitHydration();
+    throw error;
+  }
+  if (diagnostics.recoverableMismatch)
+    render(component, container);
+  replayEvents(container);
+}

package/dist-pkg/runtime/devtools.d.ts

@@ -0,0 +1,64 @@
+import { type HydrationDiagnostics } from "./hydration.js";
+import { type RouterNavigationDiagnostics } from "./router.js";
+import { REACTIVE_TRACE_SCHEMA_VERSION, type ReactiveDiagnosticEvent, type ReactiveDiagnosticsSnapshot, type ReactiveTraceArtifact } from "../reactive/diagnostics.js";
+export declare const RUNTIME_DEVTOOLS_SCHEMA_VERSION: 1;
+export interface RuntimeDevtoolsRouteEntry {
+    path: string;
+    methods: string[];
+    isApi: boolean;
+    hasLoader: boolean;
+    hasMiddleware: boolean;
+    title?: string;
+}
+export interface RuntimeDevtoolsRouteSummary {
+    total: number;
+    pages: number;
+    apis: number;
+    loaders: number;
+    middleware: number;
+}
+export interface RuntimeDevtoolsTopNode {
+    id: number;
+    kind: ReactiveTraceArtifact["nodes"][number]["kind"];
+    label?: string;
+    score: number;
+    reads: number;
+    writes: number;
+    runs: number;
+    invalidations: number;
+}
+export interface RuntimeDevtoolsSummary {
+    navigationState: "idle" | "navigating";
+    activeRoute: string;
+    hydrationState: "stable" | "recovering";
+    mismatchCount: number;
+    topReactiveNode: string | null;
+    recentReactiveEventKinds: string[];
+}
+export interface RuntimeDevtoolsSnapshot {
+    schemaVersion: typeof RUNTIME_DEVTOOLS_SCHEMA_VERSION;
+    generatedAt: string;
+    reactiveTraceSchemaVersion: typeof REACTIVE_TRACE_SCHEMA_VERSION;
+    navigation: RouterNavigationDiagnostics;
+    hydration: HydrationDiagnostics;
+    reactive: {
+        snapshot: ReactiveDiagnosticsSnapshot;
+        topNodes: RuntimeDevtoolsTopNode[];
+        recentEvents: ReactiveDiagnosticEvent[];
+        trace?: ReactiveTraceArtifact;
+    };
+    routes?: {
+        summary: RuntimeDevtoolsRouteSummary;
+        entries: RuntimeDevtoolsRouteEntry[];
+    };
+    summary: RuntimeDevtoolsSummary;
+}
+export interface RuntimeDevtoolsOptions {
+    includeTrace?: boolean;
+    maxReactiveEvents?: number;
+    maxTopNodes?: number;
+    routes?: RuntimeDevtoolsRouteEntry[];
+}
+export declare function createRuntimeDevtoolsSnapshot(options?: RuntimeDevtoolsOptions): RuntimeDevtoolsSnapshot;
+export declare function renderRuntimeDevtoolsHTML(snapshot: RuntimeDevtoolsSnapshot): string;
+export declare function renderRuntimeDevtoolsOverlay(snapshot: RuntimeDevtoolsSnapshot, nonce?: string): string;