gorsee 0.2.3 → 0.2.5

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,31 @@
+import { jsx } from "./jsx-runtime.js";
+import { enterHydration, exitHydration } 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 insertResult(container, result) {
+  if (result instanceof Node)
+    container.appendChild(result);
+  else if (typeof result === "object" && result !== null && isVNodeLike(result))
+    container.appendChild(jsx(result.type, result.props));
+  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);
+  component();
+  if (exitHydration().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;

package/dist-pkg/runtime/devtools.js

@@ -0,0 +1,132 @@
+import { escapeHTML } from "./html-escape.js";
+import { getHydrationDiagnostics } from "./hydration.js";
+import { getRouterNavigationDiagnostics } from "./router.js";
+import {
+  getReactiveTraceArtifact,
+  REACTIVE_TRACE_SCHEMA_VERSION
+} from "../reactive/diagnostics.js";
+export const RUNTIME_DEVTOOLS_SCHEMA_VERSION = 1;
+function sortTopNodes(trace, limit) {
+  return trace.nodes.map((node) => ({
+    id: node.id,
+    kind: node.kind,
+    label: node.label,
+    score: node.reads + node.writes + node.runs + node.invalidations,
+    reads: node.reads,
+    writes: node.writes,
+    runs: node.runs,
+    invalidations: node.invalidations
+  })).sort((left, right) => right.score - left.score || right.runs - left.runs || left.id - right.id).slice(0, Math.max(1, limit));
+}
+function summarizeRoutes(entries) {
+  return {
+    total: entries.length,
+    pages: entries.filter((entry) => !entry.isApi).length,
+    apis: entries.filter((entry) => entry.isApi).length,
+    loaders: entries.filter((entry) => entry.hasLoader).length,
+    middleware: entries.filter((entry) => entry.hasMiddleware).length
+  };
+}
+function summarizeSnapshot(navigation, hydration, topNodes, recentEvents) {
+  return {
+    navigationState: navigation.navigating ? "navigating" : "idle",
+    activeRoute: navigation.activeNavigation?.url ?? navigation.currentPath,
+    hydrationState: hydration.recoverableMismatch ? "recovering" : "stable",
+    mismatchCount: hydration.mismatches,
+    topReactiveNode: topNodes[0]?.label ?? topNodes[0]?.kind ?? null,
+    recentReactiveEventKinds: recentEvents.slice(-5).map((event) => event.kind)
+  };
+}
+export function createRuntimeDevtoolsSnapshot(options = {}) {
+  const trace = getReactiveTraceArtifact(), maxReactiveEvents = Math.max(1, options.maxReactiveEvents ?? 20), topNodes = sortTopNodes(trace, options.maxTopNodes ?? 5), recentEvents = trace.events.slice(-maxReactiveEvents), navigation = getRouterNavigationDiagnostics(), hydration = getHydrationDiagnostics(), routes = options.routes ? {
+    summary: summarizeRoutes(options.routes),
+    entries: [...options.routes]
+  } : void 0;
+  return {
+    schemaVersion: RUNTIME_DEVTOOLS_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    reactiveTraceSchemaVersion: REACTIVE_TRACE_SCHEMA_VERSION,
+    navigation,
+    hydration,
+    reactive: {
+      snapshot: trace.snapshot,
+      topNodes,
+      recentEvents,
+      trace: options.includeTrace ? trace : void 0
+    },
+    routes,
+    summary: summarizeSnapshot(navigation, hydration, topNodes, recentEvents)
+  };
+}
+function renderKeyValueGrid(entries) {
+  return `<div class="g-devtools-grid">${entries.map((entry) => `<div class="g-devtools-card"><div class="g-devtools-key">${escapeHTML(entry.key)}</div><div class="g-devtools-value">${escapeHTML(entry.value)}</div></div>`).join("")}</div>`;
+}
+export function renderRuntimeDevtoolsHTML(snapshot) {
+  const routeSummary = snapshot.routes ? renderKeyValueGrid([
+    { key: "Routes", value: String(snapshot.routes.summary.total) },
+    { key: "Pages", value: String(snapshot.routes.summary.pages) },
+    { key: "API", value: String(snapshot.routes.summary.apis) },
+    { key: "Loaders", value: String(snapshot.routes.summary.loaders) },
+    { key: "Middleware", value: String(snapshot.routes.summary.middleware) }
+  ]) : "", topNodes = snapshot.reactive.topNodes.length > 0 ? snapshot.reactive.topNodes.map((node) => `<tr><td>${escapeHTML(node.label ?? `#${node.id}`)}</td><td>${escapeHTML(node.kind)}</td><td>${node.score}</td><td>${node.runs}</td><td>${node.invalidations}</td></tr>`).join("") : '<tr><td colspan="5">No reactive activity captured</td></tr>', recentEvents = snapshot.reactive.recentEvents.length > 0 ? snapshot.reactive.recentEvents.map((event) => `<tr><td>${event.seq}</td><td>${escapeHTML(event.kind)}</td><td>${escapeHTML(event.label ?? "-")}</td><td>${escapeHTML(event.reason ?? event.detail ?? "-")}</td></tr>`).join("") : '<tr><td colspan="4">No reactive events captured</td></tr>', routeRows = snapshot.routes?.entries.length ? snapshot.routes.entries.map((route) => `<tr><td>${escapeHTML(route.path)}</td><td>${escapeHTML(route.methods.join(", ") || "GET")}</td><td>${route.isApi ? "API" : "Page"}</td><td>${route.hasLoader ? "Yes" : "-"}</td><td>${route.hasMiddleware ? "Yes" : "-"}</td></tr>`).join("") : "";
+  return `<div class="g-devtools">
+  <style>
+    .g-devtools{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;background:linear-gradient(180deg,#0f172a,#111827);color:#e5eefb;padding:24px;border-radius:18px}
+    .g-devtools h1,.g-devtools h2{margin:0 0 12px}
+    .g-devtools p{margin:0 0 12px;color:#b7c3d9}
+    .g-devtools-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(120px,1fr));gap:10px;margin:12px 0 20px}
+    .g-devtools-card{background:#172033;border:1px solid #30415f;border-radius:12px;padding:12px}
+    .g-devtools-key{font-size:11px;text-transform:uppercase;color:#8ea3c7;margin-bottom:6px}
+    .g-devtools-value{font-size:18px;font-weight:700}
+    .g-devtools-table{width:100%;border-collapse:collapse;margin-top:12px}
+    .g-devtools-table th,.g-devtools-table td{padding:10px;border-bottom:1px solid #24324d;text-align:left;vertical-align:top}
+    .g-devtools-pill{display:inline-block;padding:4px 8px;border-radius:999px;background:#1d4ed833;color:#93c5fd;font-size:12px}
+    .g-devtools-section{margin-top:22px}
+  </style>
+  <h1>Gorsee Runtime Inspector</h1>
+  <p>Path: ${escapeHTML(snapshot.summary.activeRoute || "/")} | Navigation: ${escapeHTML(snapshot.summary.navigationState)} | Hydration: ${escapeHTML(snapshot.summary.hydrationState)}</p>
+  ${renderKeyValueGrid([
+    { key: "Hydration mismatches", value: String(snapshot.hydration.mismatches) },
+    { key: "Signals", value: String(snapshot.reactive.snapshot.signalsCreated) },
+    { key: "Computeds", value: String(snapshot.reactive.snapshot.computedCreated) },
+    { key: "Effects", value: String(snapshot.reactive.snapshot.effectCreated) },
+    { key: "Resources", value: String(snapshot.reactive.snapshot.resourcesCreated) },
+    { key: "Mutations", value: String(snapshot.reactive.snapshot.mutationsCreated) }
+  ])}
+  ${routeSummary}
+  <div class="g-devtools-section">
+    <h2>Top Reactive Nodes</h2>
+    <table class="g-devtools-table">
+      <thead><tr><th>Label</th><th>Kind</th><th>Score</th><th>Runs</th><th>Invalidations</th></tr></thead>
+      <tbody>${topNodes}</tbody>
+    </table>
+  </div>
+  <div class="g-devtools-section">
+    <h2>Recent Reactive Events</h2>
+    <table class="g-devtools-table">
+      <thead><tr><th>#</th><th>Kind</th><th>Label</th><th>Reason</th></tr></thead>
+      <tbody>${recentEvents}</tbody>
+    </table>
+  </div>
+  ${routeRows ? `<div class="g-devtools-section">
+    <h2>Route Tree</h2>
+    <table class="g-devtools-table">
+      <thead><tr><th>Path</th><th>Methods</th><th>Type</th><th>Loader</th><th>Middleware</th></tr></thead>
+      <tbody>${routeRows}</tbody>
+    </table>
+  </div>` : ""}
+</div>`;
+}
+export function renderRuntimeDevtoolsOverlay(snapshot, nonce = "") {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8" />
+  <title>Gorsee Runtime Inspector</title>
+</head>
+<body>
+  ${nonce ? `<script nonce="${escapeHTML(nonce)}"></script>` : ""}
+  ${renderRuntimeDevtoolsHTML(snapshot)}
+</body>
+</html>`;
+}

package/dist-pkg/runtime/error-boundary.d.ts

@@ -0,0 +1,6 @@
+import type { GorseeRenderable } from "./renderable.js";
+export interface ErrorBoundaryProps {
+    fallback: GorseeRenderable | ((error: Error) => GorseeRenderable);
+    children: GorseeRenderable;
+}
+export declare function ErrorBoundary(props: ErrorBoundaryProps): GorseeRenderable;

package/dist-pkg/runtime/error-boundary.js

@@ -0,0 +1,17 @@
+import { createSignal } from "../reactive/signal.js";
+export function ErrorBoundary(props) {
+  const [error, setError] = createSignal(null);
+  try {
+    const children = typeof props.children === "function" ? props.children() : props.children;
+    return () => {
+      const err = error();
+      if (err)
+        return typeof props.fallback === "function" ? props.fallback(err) : props.fallback;
+      return children;
+    };
+  } catch (err) {
+    const errObj = err instanceof Error ? err : Error(String(err));
+    setError(errObj);
+    return typeof props.fallback === "function" ? props.fallback(errObj) : props.fallback;
+  }
+}

package/dist-pkg/runtime/event-replay.d.ts

@@ -0,0 +1,3 @@
+export declare const EVENT_REPLAY_SCRIPT = "<script data-g-event-replay>\n(function(){\n  var Q=[];\n  var E=[\"click\",\"input\",\"change\",\"submit\",\"keydown\",\"keyup\",\"focusin\",\"focusout\"];\n  function capture(e){\n    Q.push({type:e.type,target:e.target,timeStamp:e.timeStamp,\n      detail:e.type===\"input\"?e.target.value:undefined,\n      key:e.key||undefined});\n    if(e.type===\"submit\")e.preventDefault();\n  }\n  E.forEach(function(t){document.addEventListener(t,capture,{capture:true})});\n  window.__gorsee_events={\n    queue:Q,\n    stop:function(){E.forEach(function(t){document.removeEventListener(t,capture,{capture:true})})},\n    replay:function(root){\n      this.stop();\n      Q.forEach(function(ev){\n        if(ev.target&&root.contains(ev.target)){\n          ev.target.dispatchEvent(new Event(ev.type,{bubbles:true}));\n        }\n      });\n      Q.length=0;\n    }\n  };\n})();\n</script>";
+export declare function replayEvents(root: Element): void;
+export declare function stopEventCapture(): void;