@clusterenvision/ui-framework 1.0.0

package/dist/index.js

@@ -0,0 +1,772 @@
+export { ConsoleLogger, ConsoleWorkflowLogger, ConsoleWorkflowTraceSink, DATABASE_TASK, DELAY_TASK, DatabaseWorkflowStore, DefaultApprovalResolver, DefaultBackgroundRunner, FileWorkflowTraceSink, FunctionalDatabaseProvider, HTTP_TASK, InMemoryDatabaseRegistry, InMemorySchedulerService, InMemoryWorkflowStore, ManualOverrideApprovalResolver, MetricsConsoleEmitter, MongoWorkflowStore, NoopWorkflowTraceSink, PolicyApprovalResolver, QueueBackgroundRunner, RecordingWorkflowTraceSink, RuleBasedPolicyEngine, SCHEDULE_TASK, SystemTimeService, WorkflowBuilder, WorkflowRuntime, WorkflowStepBuilder, WorkflowTraceExporterSink, actorFromAuth0Claims, actorFromAzureAdClaims, actorFromCognitoClaims, actorFromOidcClaims, buildPolicyRequest, createAzureQueueDriver, createBullMqDriver, createDatabaseTaskHandler, createDefaultTaskMap, createDelayTaskHandler, createDrizzleProvider, createFetchHttpExecutor, createHttpTaskHandler, createMongoProvider, createMySqlProvider, createPostgresProvider, createPrismaProvider, createRestDatabaseProvider, createScheduleTaskHandler, createSqlDatabaseProvider, createSqliteProvider, createSqsDriver, createStartWorkflowMiddleware, createStepMiddleware, createSupabaseProvider, createWorkflow, databaseTask, delayTask, httpTask, multiStepApprovalResolver, registerDefaultDatabaseProviders, requireActorRoles, requireActorScopes, runAuthMiddleware, scheduleTask, task, visualSchemaToWorkflow, workflowFromJson, workflowToVisualSchema } from './chunk-3ZBRNFEE.js';
+export { buildHydrationDomDiff, buildHydrationSummary, buildRouteTree, buildSignalsGraph, calculateRetryDelay, classifyError, createAiSession, createAngularAdapter, createDevtoolsDashboard, createFormController, createFormWizard, createHttpAiProvider, createHydrationReplayPanel, createHydrationReplaySession, createMockAiProvider, createReactAdapter, createResource, createResourceCache, createRouterInspector, createRouterInspectorPanel, createRuntimeDiagnosticsStore, createSignalsInspector, createSignalsInspectorPanel, createVueAdapter, getHydrationDomPayload, getHydrationReports, getResourceCache, invalidateResource, isResourceExpired, isResourceStale, normalizeResourceKey } from './chunk-4HRORR2Q.js';
+export { AiAssistantPanel } from './chunk-T6T7QE4J.js';
+export { AiSummaryCard } from './chunk-V6JCOBGY.js';
+import { defineComponent, renderComponent } from './chunk-CHLDE4JQ.js';
+export { Injector, createInjector, defineComponent, renderComponent, renderTemplateToStream, renderTemplateToString, useLocation, useNavigate, useRouteData, useRouteMatch, useRouteParams, useRouter, withRouterContext } from './chunk-CHLDE4JQ.js';
+import './chunk-Q3KH6HMU.js';
+export { buildRuntimeChromeTraceDocument } from './chunk-ZUWSU4OA.js';
+import './chunk-IHAMVLRY.js';
+import './chunk-BBAUALNU.js';
+import { withRuntimeErrorBoundary, captureRuntimeError } from './chunk-DQBX75NJ.js';
+export { captureRuntimeError, popRuntimeErrorBoundary, pushRuntimeErrorBoundary, withRuntimeErrorBoundary } from './chunk-DQBX75NJ.js';
+import { flattenRoutes, matchRoute, getRouteId, normalizePathname, emitRuntimeErrorReport } from './chunk-SA5UD5B6.js';
+export { addRuntimeErrorReporter, clearRuntimeErrorReporters, emitRuntimeErrorReport, getRuntimeErrorReporters, registerRuntimeErrorReporters } from './chunk-SA5UD5B6.js';
+import { cacheRouteDataResult, clearRouteDataResult } from './chunk-D3H5CGVD.js';
+import { signal } from './chunk-PFBEIFVS.js';
+export { Effect, Signal, batch, clearSignalsInspectorRegistry, computed, effect, getSignalsInspectorSnapshot, signal } from './chunk-PFBEIFVS.js';
+export { NoopRuntimeTraceSink, RuntimeTraceExporterSink, getCurrentRuntimeTraceSink, hasRuntimeTraceSink, nextRuntimeTraceId, recordRuntimeTrace, setRuntimeTraceSink, withRuntimeTraceSink } from './chunk-D2USIT6V.js';
+export { JsonlTraceExporter, OtlpHttpTraceExporter } from './chunk-DRPG2DFX.js';
+import http from 'http';
+import { URL as URL$1 } from 'url';
+import { promises } from 'fs';
+
+// src/runtime/router.js
+var CONTINUE_NAVIGATION = { type: "continue" };
+var MAX_GUARD_REDIRECTS = 8;
+function allowNavigation() {
+  return CONTINUE_NAVIGATION;
+}
+function redirectNavigation(to, options) {
+  return { type: "redirect", to, options };
+}
+function errorNavigation(error, info) {
+  return { type: "error", error, info: info ?? null };
+}
+function createRouter(input) {
+  const options = normalizeRouterOptions(input);
+  const flattened = flattenRoutes(options.routes);
+  const notFoundRoute = normalizeFallbackRoute(options.notFoundRoute, "not-found", "*");
+  const errorRoute = normalizeFallbackRoute(options.errorRoute, "error", "/__error");
+  const initialPath = typeof window !== "undefined" ? window.location.pathname : "/";
+  const currentPath = signal(initialPath);
+  const currentMatchSignal = signal(resolveMatch(initialPath));
+  function resolveMatch(path) {
+    for (const node of flattened) {
+      const params = matchRoute(path, node.fullPath);
+      if (params) {
+        return instantiateMatch(node, params);
+      }
+    }
+    if (notFoundRoute) {
+      return createFallbackMatch(notFoundRoute, path, "not-found");
+    }
+    return null;
+  }
+  function instantiateMatch(node, params) {
+    const layouts = collectLayouts(node.branch, node.fullPath, params);
+    const routeBoundary = createRouterBoundaryState("route", normalizeBoundaryConfig("route", node.route.boundary, {
+      routeId: getRouteId(node.route),
+      path: node.fullPath,
+      params
+    }));
+    return {
+      route: node.route,
+      params,
+      fullPath: node.fullPath,
+      layouts,
+      boundary: routeBoundary
+    };
+  }
+  function collectLayouts(branch, fullPath, params) {
+    const states = [];
+    branch.forEach((route) => {
+      (route.layouts ?? []).forEach((layout, index) => {
+        states.push(createRouterBoundaryState("layout", normalizeBoundaryConfig("layout", layout, {
+          routeId: getRouteId(route),
+          path: fullPath,
+          layoutIndex: index,
+          params
+        })));
+      });
+    });
+    return states;
+  }
+  function createFallbackMatch(route, requestedPath, reason, error, errorMessage) {
+    const normalizedPath = normalizePathname(requestedPath);
+    const params = matchRoute(normalizedPath, route.path) ?? {};
+    const statusCode = reason === "not-found" ? 404 : 500;
+    const boundaryConfig = {
+      ...route.boundary ?? {},
+      attributes: {
+        ...route.boundary?.attributes ?? {},
+        requestedPath: normalizedPath,
+        statusCode,
+        reason,
+        errorMessage: errorMessage ?? error?.message
+      }
+    };
+    const layouts = collectLayouts([route], normalizedPath, params);
+    const routeBoundary = createRouterBoundaryState("route", normalizeBoundaryConfig("route", boundaryConfig, {
+      routeId: getRouteId(route),
+      path: normalizedPath,
+      params
+    }));
+    return {
+      route,
+      params,
+      fullPath: normalizedPath,
+      layouts,
+      boundary: routeBoundary
+    };
+  }
+  function match(path) {
+    const resolved = resolveMatch(path ?? currentPath());
+    if (path === void 0) {
+      currentMatchSignal.set(resolved);
+    }
+    return resolved;
+  }
+  function navigate(path, options2) {
+    return runNavigation(path, options2, 0);
+  }
+  function onPopState() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const nextPath = window.location.pathname;
+    runNavigation(nextPath, { replace: true }, 0);
+  }
+  const start = () => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    window.addEventListener("popstate", onPopState);
+  };
+  const dispose = () => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    window.removeEventListener("popstate", onPopState);
+  };
+  function runNavigation(path, options2, depth) {
+    const resolved = resolveMatch(path);
+    if (!resolved) {
+      applyHistory(path, options2);
+      currentPath.set(path);
+      currentMatchSignal.set(null);
+      return null;
+    }
+    const guardResult = runRouteGuards(resolved);
+    if (guardResult.type === "redirect") {
+      if (depth >= MAX_GUARD_REDIRECTS) {
+        throw new Error("Router redirect loop detected.");
+      }
+      const nextOptions = { ...options2, ...guardResult.options, replace: true };
+      return runNavigation(guardResult.to, nextOptions, depth + 1);
+    }
+    if (guardResult.type === "error") {
+      const info = guardResult.info ?? createGuardErrorInfo(resolved);
+      const rawMessage = guardResult.error.message;
+      if (errorRoute) {
+        try {
+          captureRuntimeError(guardResult.error, info);
+        } catch {
+        }
+        const errorMatch = createFallbackMatch(errorRoute, path, "error", guardResult.error, rawMessage);
+        applyHistory(path, options2);
+        currentPath.set(path);
+        currentMatchSignal.set(errorMatch);
+        return errorMatch;
+      }
+      captureRuntimeError(guardResult.error, info);
+      return currentMatchSignal();
+    }
+    applyHistory(path, options2);
+    currentPath.set(path);
+    currentMatchSignal.set(resolved);
+    return resolved;
+  }
+  function applyHistory(path, options2) {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const historyState = options2?.state ?? {};
+    if (options2?.replace) {
+      window.history.replaceState(historyState, "", path);
+    } else {
+      window.history.pushState(historyState, "", path);
+    }
+  }
+  function runRouteGuards(match2) {
+    const guards = match2.route.guards ?? [];
+    for (const guard of guards) {
+      const result = guard({ match: match2, params: match2.params }) ?? CONTINUE_NAVIGATION;
+      if (result.type !== "continue") {
+        return result;
+      }
+    }
+    return CONTINUE_NAVIGATION;
+  }
+  function createGuardErrorInfo(match2) {
+    return {
+      phase: "navigation",
+      componentName: match2.boundary.definition.componentName,
+      componentInstanceId: match2.boundary.id,
+      templateId: match2.boundary.definition.templateId,
+      attributes: {
+        routeId: match2.route.id ?? match2.fullPath,
+        fullPath: match2.fullPath
+      }
+    };
+  }
+  return {
+    currentPath,
+    currentMatch: currentMatchSignal,
+    navigate,
+    match,
+    start,
+    dispose
+  };
+}
+function normalizeRouterOptions(input) {
+  if (Array.isArray(input)) {
+    return { routes: input };
+  }
+  return input;
+}
+function normalizeFallbackRoute(route, fallbackId, fallbackPath) {
+  if (!route) {
+    return void 0;
+  }
+  return {
+    ...route,
+    id: route.id ?? fallbackId,
+    path: route.path ?? fallbackPath
+  };
+}
+async function runRouteLoader(match, args) {
+  const result = await executeRouteHandler("loader", match.route.loader, match, args);
+  updateRouteDataCache(match, result);
+  return result;
+}
+async function runRouteAction(match, args) {
+  const result = await executeRouteHandler("action", match.route.action, match, args);
+  updateRouteDataCache(match, result);
+  return result;
+}
+async function prefetchRoute(match, options) {
+  await Promise.resolve(match.route.component());
+  if (options?.loadData) {
+    await runRouteLoader(match, options.loaderArgs);
+  }
+}
+function normalizeBoundaryConfig(kind, config, context) {
+  const layoutSuffix = typeof context.layoutIndex === "number" ? `:${String(context.layoutIndex)}` : "";
+  const fallbackId = `${kind}:${context.routeId}${layoutSuffix}`;
+  const componentName = config?.componentName ?? config?.name ?? context.routeId;
+  const attributes = {
+    ...config?.attributes ?? {},
+    routeId: context.routeId,
+    path: context.path,
+    layoutIndex: context.layoutIndex,
+    params: context.params ? { ...context.params } : void 0
+  };
+  return {
+    ...config,
+    id: config?.id ?? fallbackId,
+    name: config?.name ?? componentName,
+    componentName,
+    attributes
+  };
+}
+function createRouterBoundaryState(kind, definition) {
+  const state = {
+    id: definition.id,
+    kind,
+    definition,
+    boundary: {
+      id: definition.id,
+      handle(error, info) {
+        state.error = error;
+        state.info = info;
+        if (definition.onError) {
+          try {
+            const handled = definition.onError(error, info);
+            if (handled === false) {
+              return false;
+            }
+          } catch (hookError) {
+            state.error = hookError instanceof Error ? hookError : new Error(String(hookError));
+            state.info = info;
+          }
+        }
+        return true;
+      }
+    },
+    error: null,
+    info: null,
+    reset() {
+      state.error = null;
+      state.info = null;
+    }
+  };
+  return state;
+}
+async function executeRouteHandler(kind, handler, match, args) {
+  const startedAt = Date.now();
+  if (!handler) {
+    return {
+      handled: true,
+      startedAt,
+      endedAt: startedAt,
+      durationMs: 0
+    };
+  }
+  const normalizedArgs = normalizeHandlerArgs(match, args);
+  const boundaries = [...match.layouts, match.boundary];
+  boundaries.forEach((boundary) => {
+    boundary.reset();
+  });
+  try {
+    const data = await runWithBoundaries(boundaries, () => invokeRouteHandler(handler, kind, match, normalizedArgs));
+    const boundaryError = firstErroredBoundary(boundaries);
+    const endedAt = Date.now();
+    if (boundaryError) {
+      return {
+        handled: true,
+        error: boundaryError.error ?? void 0,
+        info: boundaryError.info ?? null,
+        startedAt,
+        endedAt,
+        durationMs: endedAt - startedAt
+      };
+    }
+    return {
+      handled: true,
+      data,
+      info: null,
+      startedAt,
+      endedAt,
+      durationMs: endedAt - startedAt
+    };
+  } catch (error) {
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    const endedAt = Date.now();
+    return {
+      handled: false,
+      error: normalized,
+      info: null,
+      startedAt,
+      endedAt,
+      durationMs: endedAt - startedAt
+    };
+  }
+}
+function normalizeHandlerArgs(match, args) {
+  return {
+    params: args?.params ?? match.params,
+    request: args?.request,
+    signal: args?.signal,
+    context: args?.context
+  };
+}
+function runWithBoundaries(boundaries, run) {
+  return boundaries.reduceRight((next, boundary) => {
+    return () => withRuntimeErrorBoundary(boundary.boundary, next);
+  }, run)();
+}
+function invokeRouteHandler(handler, kind, match, args) {
+  const phase = kind === "loader" ? "loader" : "action";
+  const info = createHandlerErrorInfo(phase, match, args);
+  try {
+    const result = handler(args);
+    if (isPromiseLike(result)) {
+      return result.catch((error) => {
+        const handled = captureRuntimeError(error, info);
+        if (!handled) {
+          throw error;
+        }
+        return void 0;
+      });
+    }
+    return result;
+  } catch (error) {
+    const handled = captureRuntimeError(error, info);
+    if (!handled) {
+      throw error;
+    }
+    return void 0;
+  }
+}
+function createHandlerErrorInfo(phase, match, args) {
+  const attributes = {
+    ...match.boundary.definition.attributes,
+    params: args.params,
+    requestMethod: args.request?.method,
+    layoutStack: match.layouts.map((layout) => layout.definition.id)
+  };
+  return {
+    phase,
+    componentName: match.boundary.definition.componentName,
+    componentInstanceId: match.boundary.id,
+    templateId: match.boundary.definition.templateId,
+    attributes
+  };
+}
+function firstErroredBoundary(boundaries) {
+  for (let i = boundaries.length - 1; i >= 0; i -= 1) {
+    if (boundaries[i].error) {
+      return boundaries[i];
+    }
+  }
+  return void 0;
+}
+function isPromiseLike(value) {
+  return Boolean(value) && typeof value === "object" && "then" in value;
+}
+function updateRouteDataCache(match, result) {
+  if (result.handled) {
+    cacheRouteDataResult(match, result);
+    return;
+  }
+  clearRouteDataResult(match);
+}
+
+// src/runtime/router-provider.js
+function renderRouterApp(component, options) {
+  return renderComponent(component, options);
+}
+function createHttpApp() {
+  const middlewares = [];
+  const runMiddlewares = async (ctx, index = 0) => {
+    if (index >= middlewares.length) {
+      return;
+    }
+    const next = () => {
+      return runMiddlewares(ctx, index + 1);
+    };
+    await middlewares[index](ctx, next);
+  };
+  return {
+    use(middleware) {
+      middlewares.push(middleware);
+      return this;
+    },
+    handle(req, res) {
+      const host = req.headers.host ?? "localhost";
+      const url = new URL$1(req.url ?? "/", `http://${host}`);
+      const ctx = { req, res, url, state: {} };
+      runMiddlewares(ctx).catch((err) => {
+        res.statusCode = 500;
+        res.end(err instanceof Error ? err.message : "Unknown error");
+      });
+    },
+    listen(port) {
+      const server = http.createServer((req, res) => this.handle(req, res));
+      return new Promise((resolve) => {
+        server.listen(port, () => resolve(server));
+      });
+    }
+  };
+}
+function json(handler) {
+  return async (ctx, next) => {
+    if (ctx.req.method === "GET") {
+      ctx.data = await handler(ctx);
+      ctx.res.setHeader("Content-Type", "application/json");
+      ctx.res.end(JSON.stringify(ctx.data));
+      return;
+    }
+    await next();
+  };
+}
+function serveStatic(root) {
+  return async (ctx, next) => {
+    if (ctx.req.method !== "GET") {
+      await next();
+      return;
+    }
+    const host = ctx.req.headers.host ?? "localhost";
+    const path = new URL$1(ctx.req.url ?? "/", `http://${host}`).pathname;
+    const filePath = new URL$1(path === "/" ? "/index.html" : path, `file://${root}`);
+    try {
+      const data = await promises.readFile(filePath);
+      ctx.res.end(data);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        await next();
+        return;
+      }
+      throw error;
+    }
+  };
+}
+
+// src/runtime/ssr-app.js
+var DEFAULT_TEMPLATE = "<!doctype html><html><head><!--ce-ui-head--><!--ce-ui-assets--></head><body><!--ce-ui-app--></body></html>";
+function renderAssetTags(manifest) {
+  if (!manifest) {
+    return "";
+  }
+  const styles = (manifest.styles ?? []).map((href) => `<link rel="stylesheet" href="${href}">`).join("");
+  const preloads = (manifest.preloads ?? []).map((href) => `<link rel="preload" href="${href}" as="script">`).join("");
+  const scripts = (manifest.scripts ?? []).map((src) => `<script type="module" src="${src}"></script>`).join("");
+  const hydrate = (manifest.hydrate ?? []).map((src) => `<script type="module" data-ce-hydrate src="${src}"></script>`).join("");
+  return `${preloads}${styles}${scripts}${hydrate}`;
+}
+function renderHtmlDocument(options) {
+  const template = options.template ?? DEFAULT_TEMPLATE;
+  const head = options.head ?? "";
+  const assets = renderAssetTags(options.manifest);
+  const htmlAttrs = options.htmlAttributes ? ` ${options.htmlAttributes}` : "";
+  const bodyAttrs = options.bodyAttributes ? ` ${options.bodyAttributes}` : "";
+  return applyTemplate(template, {
+    head,
+    assets,
+    body: options.body,
+    htmlAttributes: htmlAttrs,
+    bodyAttributes: bodyAttrs
+  });
+}
+function isAsyncIterable(value) {
+  return Boolean(value) && typeof value === "object" && Symbol.asyncIterator in value;
+}
+function createNodeSsrMiddleware(options) {
+  return async (ctx, next) => {
+    if (ctx.req.method !== "GET") {
+      await next();
+      return;
+    }
+    const bodyResult = await options.render(ctx);
+    ctx.res.statusCode = options.status ?? 200;
+    ctx.res.setHeader("Content-Type", "text/html; charset=utf-8");
+    if (options.headers) {
+      Object.entries(options.headers).forEach(([key, value]) => ctx.res.setHeader(key, value));
+    }
+    if (isAsyncIterable(bodyResult)) {
+      const shell = renderHtmlShell({
+        template: options.template,
+        head: options.head,
+        manifest: options.manifest
+      });
+      ctx.res.write(shell.start);
+      for await (const chunk of bodyResult) {
+        ctx.res.write(chunk);
+      }
+      ctx.res.end(shell.end);
+      return;
+    }
+    const html = renderHtmlDocument({
+      template: options.template,
+      head: options.head,
+      body: bodyResult,
+      manifest: options.manifest
+    });
+    ctx.res.end(html);
+  };
+}
+function createEdgeSsrHandler(options) {
+  return async (request) => {
+    const url = new URL(request.url);
+    const bodyResult = await options.render({ request, url });
+    const headers = new Headers(options.headers);
+    if (!headers.has("Content-Type")) {
+      headers.set("Content-Type", "text/html; charset=utf-8");
+    }
+    if (isAsyncIterable(bodyResult)) {
+      const shell = renderHtmlShell({
+        template: options.template,
+        head: options.head,
+        manifest: options.manifest
+      });
+      const encoder = new TextEncoder();
+      const stream = new ReadableStream({
+        async start(controller) {
+          controller.enqueue(encoder.encode(shell.start));
+          for await (const chunk of bodyResult) {
+            controller.enqueue(encoder.encode(chunk));
+          }
+          controller.enqueue(encoder.encode(shell.end));
+          controller.close();
+        }
+      });
+      return new Response(stream, { status: options.status ?? 200, headers });
+    }
+    const html = renderHtmlDocument({
+      template: options.template,
+      head: options.head,
+      body: bodyResult,
+      manifest: options.manifest
+    });
+    return new Response(html, { status: options.status ?? 200, headers });
+  };
+}
+function renderHtmlShell(options) {
+  const template = options.template ?? DEFAULT_TEMPLATE;
+  const head = options.head ?? "";
+  const assets = renderAssetTags(options.manifest);
+  const resolved = applyTemplate(template, {
+    head,
+    assets,
+    body: "<!--ce-ui-app-->",
+    htmlAttributes: "",
+    bodyAttributes: ""
+  });
+  const marker = "<!--ce-ui-app-->";
+  const index = resolved.indexOf(marker);
+  if (index === -1) {
+    return { start: resolved, end: "" };
+  }
+  return {
+    start: resolved.slice(0, index),
+    end: resolved.slice(index + marker.length)
+  };
+}
+function applyTemplate(template, payload) {
+  if (template.includes("<html") || template.includes("<body")) {
+    return template.replace("<html", `<html${payload.htmlAttributes}`).replace("<body", `<body${payload.bodyAttributes}`).replace("<!--ce-ui-head-->", payload.head).replace("<!--ce-ui-assets-->", payload.assets).replace("<!--ce-ui-app-->", payload.body);
+  }
+  return template.replace("<!--ce-ui-head-->", payload.head).replace("<!--ce-ui-assets-->", payload.assets).replace("<!--ce-ui-app-->", payload.body);
+}
+function useErrorBoundary(handler) {
+  {
+    throw new Error("useErrorBoundary() can only be used while executing a component setup function.");
+  }
+}
+
+// src/runtime/error-boundary.ts
+var ErrorBoundary = defineComponent({
+  name: "ErrorBoundary",
+  template: `
+    <div ce:if="!hasError()" class="ce-error-boundary__content">
+      <slot></slot>
+    </div>
+    <div ce:if="hasError()" class="ce-error-boundary__fallback">
+      <slot name="fallback">
+        <section class="ce-error-boundary__panel">
+          <p class="ce-error-boundary__title">Something went wrong.</p>
+          <pre>{{ errorMessage() }}</pre>
+          <button type="button" on:click="reset" class="ce-error-boundary__reset">Try again</button>
+        </section>
+      </slot>
+    </div>
+  `,
+  styles: [
+    `.ce-error-boundary__fallback {
+        display: block;
+      }
+      .ce-error-boundary__panel {
+        border: 1px dashed var(--ce-border, #f87171);
+        padding: 1rem;
+        border-radius: 0.75rem;
+        background: rgba(248, 113, 113, 0.08);
+        color: inherit;
+      }
+      .ce-error-boundary__title {
+        font-weight: 600;
+        margin: 0 0 0.5rem;
+      }
+      .ce-error-boundary__panel pre {
+        margin: 0 0 0.75rem;
+        padding: 0.5rem;
+        background: rgba(15, 23, 42, 0.65);
+        border-radius: 0.5rem;
+        font-size: 0.85rem;
+        line-height: 1.4;
+        white-space: pre-wrap;
+      }
+      .ce-error-boundary__reset {
+        display: inline-flex;
+        align-items: center;
+        padding: 0.35rem 0.75rem;
+        border-radius: 0.5rem;
+        border: 0;
+        cursor: pointer;
+        background: var(--ce-primary, #2563eb);
+        color: var(--ce-on-primary, #f8fafc);
+      }`
+  ],
+  setup({ props, emit }) {
+    const boundary = useErrorBoundary();
+    const hasError = () => Boolean(boundary.error());
+    const errorMessage = () => boundary.error()?.message ?? "Unknown error";
+    const reset = () => {
+      boundary.reset();
+    };
+    return {
+      hasError,
+      error: boundary.error,
+      info: boundary.info,
+      errorMessage,
+      reset
+    };
+  }
+});
+
+// src/runtime/hydration-diagnostics.js
+var inspectedTargets = /* @__PURE__ */ new WeakSet();
+function ensureHydrationConsistency(target, context) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  if (inspectedTargets.has(target)) {
+    return;
+  }
+  inspectedTargets.add(target);
+  if (!hasServerDom(target)) {
+    return;
+  }
+  const serverDom = snapshotDom(target);
+  reportHydrationMismatch({
+    templateId: context.templateId,
+    componentName: context.componentName,
+    componentInstanceId: context.componentInstanceId,
+    reason: "Detected existing server-rendered DOM before client render. Hydration support is not enabled yet.",
+    receivedDom: serverDom,
+    attributes: {
+      serverDomLength: serverDom.length
+    }
+  });
+  clearNode(target);
+}
+function reportHydrationMismatch(details) {
+  const error = new Error(`[hydration] ${details.reason}`);
+  const info = {
+    phase: "hydration",
+    componentName: details.componentName,
+    componentInstanceId: details.componentInstanceId,
+    templateId: details.templateId,
+    attributes: {
+      ...details.attributes ?? {},
+      expectedDom: details.expectedDom,
+      receivedDom: details.receivedDom,
+      timestamp: Date.now()
+    }
+  };
+  emitRuntimeErrorReport({
+    error,
+    info,
+    handled: true
+  });
+  if (typeof console !== "undefined") {
+    console.warn("[ce-ui] hydration mismatch detected", {
+      reason: details.reason,
+      templateId: details.templateId,
+      componentName: details.componentName
+    });
+  }
+}
+function snapshotDom(node) {
+  if (node instanceof Element) {
+    return node.innerHTML;
+  }
+  if (node instanceof DocumentFragment) {
+    const div = document.createElement("div");
+    div.appendChild(node.cloneNode(true));
+    return div.innerHTML;
+  }
+  return node.textContent ?? "";
+}
+function hasServerDom(target) {
+  return "childNodes" in target && target.childNodes.length > 0;
+}
+function clearNode(target) {
+  while (target.firstChild) {
+    target.removeChild(target.firstChild);
+  }
+}
+
+export { ErrorBoundary, allowNavigation, createEdgeSsrHandler, createHttpApp, createNodeSsrMiddleware, createRouter, ensureHydrationConsistency, errorNavigation, json, prefetchRoute, redirectNavigation, renderAssetTags, renderHtmlDocument, renderRouterApp, reportHydrationMismatch, runRouteAction, runRouteLoader, serveStatic, snapshotDom };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map