@clusterenvision/ui-framework 1.0.0

package/dist/runtime/adapters/vue.d.cts

@@ -0,0 +1,37 @@
+import { C as ComponentFactory } from '../../component-BVzvepw9.cjs';
+import '../../types-C4RXXKfk.cjs';
+import '../../tracing-DGdvMCEl.cjs';
+import 'node:fs';
+import '../../router-YnpW_sIK.cjs';
+import '../../browser-signals-07qodpYT.cjs';
+import '../../lib/theme.cjs';
+
+interface VueInterop {
+  h: (...args: unknown[]) => unknown;
+  ref: <T>(value: T | null) => { value: T | null };
+  onMounted: (callback: () => void) => void;
+  onBeforeUnmount: (callback: () => void) => void;
+  watch: (
+    source: () => unknown,
+    callback: (value: unknown) => void,
+    options?: { deep?: boolean },
+  ) => void;
+}
+
+interface VueAdapterOptions {
+  hostElement?: string;
+  displayName?: string;
+}
+
+type VueAdapterComponent<Props extends Record<string, unknown>> = {
+  name?: string;
+  setup: (props: Props, ctx: { slots?: { default?: () => unknown } }) => () => unknown;
+};
+
+declare function createVueAdapter<Props extends Record<string, unknown>>(
+  factory: ComponentFactory<Props>,
+  vue: VueInterop,
+  options?: VueAdapterOptions,
+): VueAdapterComponent<Props>;
+
+export { type VueAdapterComponent, type VueAdapterOptions, type VueInterop, createVueAdapter };

package/dist/runtime/adapters/vue.d.ts

@@ -0,0 +1,37 @@
+import { C as ComponentFactory } from '../../component-wTxZ2BPD.js';
+import '../../types-C4RXXKfk.js';
+import '../../tracing-DGdvMCEl.js';
+import 'node:fs';
+import '../../router-B9kms5XQ.js';
+import '../../browser-signals-07qodpYT.js';
+import '../../lib/theme.js';
+
+interface VueInterop {
+  h: (...args: unknown[]) => unknown;
+  ref: <T>(value: T | null) => { value: T | null };
+  onMounted: (callback: () => void) => void;
+  onBeforeUnmount: (callback: () => void) => void;
+  watch: (
+    source: () => unknown,
+    callback: (value: unknown) => void,
+    options?: { deep?: boolean },
+  ) => void;
+}
+
+interface VueAdapterOptions {
+  hostElement?: string;
+  displayName?: string;
+}
+
+type VueAdapterComponent<Props extends Record<string, unknown>> = {
+  name?: string;
+  setup: (props: Props, ctx: { slots?: { default?: () => unknown } }) => () => unknown;
+};
+
+declare function createVueAdapter<Props extends Record<string, unknown>>(
+  factory: ComponentFactory<Props>,
+  vue: VueInterop,
+  options?: VueAdapterOptions,
+): VueAdapterComponent<Props>;
+
+export { type VueAdapterComponent, type VueAdapterOptions, type VueInterop, createVueAdapter };

package/dist/runtime/adapters/vue.js

@@ -0,0 +1,42 @@
+// src/runtime/adapters/vue.ts
+function createVueAdapter(factory, vue, options = {}) {
+  const hostTag = options.hostElement ?? "div";
+  const component = {
+    name: options.displayName,
+    setup(props, ctx) {
+      const hostRef = vue.ref(null);
+      let instance = null;
+      vue.onMounted(() => {
+        if (!hostRef.value) {
+          return;
+        }
+        instance = factory.mount({
+          target: hostRef.value,
+          props
+        });
+      });
+      vue.watch(
+        () => props,
+        (next) => {
+          if (instance) {
+            instance.updateProps(next);
+          }
+        },
+        { deep: true }
+      );
+      vue.onBeforeUnmount(() => {
+        instance?.destroy();
+        instance = null;
+      });
+      return () => {
+        const slot = ctx.slots?.default;
+        return vue.h(hostTag, { ref: hostRef }, slot ? slot() : null);
+      };
+    }
+  };
+  return component;
+}
+
+export { createVueAdapter };
+//# sourceMappingURL=vue.js.map
+//# sourceMappingURL=vue.js.map

package/dist/runtime/adapters/vue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/runtime/adapters/vue.ts"],"names":[],"mappings":";AAwBO,SAAS,gBAAA,CACd,OAAA,EACA,GAAA,EACA,OAAA,GAA6B,EAAC,EACF;AAC5B,EAAA,MAAM,OAAA,GAAU,QAAQ,WAAA,IAAe,KAAA;AAEvC,EAAA,MAAM,SAAA,GAAwC;AAAA,IAC5C,MAAM,OAAA,CAAQ,WAAA;AAAA,IACd,KAAA,CAAM,OAAO,GAAA,EAAK;AAChB,MAAA,MAAM,OAAA,GAAU,GAAA,CAAI,GAAA,CAAoB,IAAI,CAAA;AAC5C,MAAA,IAAI,QAAA,GAA4C,IAAA;AAEhD,MAAA,GAAA,CAAI,UAAU,MAAM;AAClB,QAAA,IAAI,CAAC,QAAQ,KAAA,EAAO;AAClB,UAAA;AAAA,QACF;AACA,QAAA,QAAA,GAAW,QAAQ,KAAA,CAAM;AAAA,UACvB,QAAQ,OAAA,CAAQ,KAAA;AAAA,UAChB;AAAA,SACD,CAAA;AAAA,MACH,CAAC,CAAA;AAED,MAAA,GAAA,CAAI,KAAA;AAAA,QACF,MAAM,KAAA;AAAA,QACN,CAAA,IAAA,KAAQ;AACN,UAAA,IAAI,QAAA,EAAU;AACZ,YAAA,QAAA,CAAS,YAAY,IAAa,CAAA;AAAA,UACpC;AAAA,QACF,CAAA;AAAA,QACA,EAAE,MAAM,IAAA;AAAK,OACf;AAEA,MAAA,GAAA,CAAI,gBAAgB,MAAM;AACxB,QAAA,QAAA,EAAU,OAAA,EAAQ;AAClB,QAAA,QAAA,GAAW,IAAA;AAAA,MACb,CAAC,CAAA;AAED,MAAA,OAAO,MAAM;AACX,QAAA,MAAM,IAAA,GAAO,IAAI,KAAA,EAAO,OAAA;AACxB,QAAA,OAAO,GAAA,CAAI,CAAA,CAAE,OAAA,EAAS,EAAE,GAAA,EAAK,SAAQ,EAAG,IAAA,GAAO,IAAA,EAAK,GAAI,IAAI,CAAA;AAAA,MAC9D,CAAA;AAAA,IACF;AAAA,GACF;AAEA,EAAA,OAAO,SAAA;AACT","file":"vue.js","sourcesContent":["import type { ComponentFactory, ComponentInstance } from '../component.js';\n\nexport interface VueInterop {\n  h: (...args: unknown[]) => unknown;\n  ref: <T>(value: T | null) => { value: T | null };\n  onMounted: (callback: () => void) => void;\n  onBeforeUnmount: (callback: () => void) => void;\n  watch: (\n    source: () => unknown,\n    callback: (value: unknown) => void,\n    options?: { deep?: boolean },\n  ) => void;\n}\n\nexport interface VueAdapterOptions {\n  hostElement?: string;\n  displayName?: string;\n}\n\nexport interface VueAdapterComponent<Props extends Record<string, unknown>> {\n  name?: string;\n  setup: (props: Props, ctx: { slots?: { default?: () => unknown } }) => () => unknown;\n}\n\nexport function createVueAdapter<Props extends Record<string, unknown>>(\n  factory: ComponentFactory<Props>,\n  vue: VueInterop,\n  options: VueAdapterOptions = {},\n): VueAdapterComponent<Props> {\n  const hostTag = options.hostElement ?? 'div';\n\n  const component: VueAdapterComponent<Props> = {\n    name: options.displayName,\n    setup(props, ctx) {\n      const hostRef = vue.ref<Element | null>(null);\n      let instance: ComponentInstance<Props> | null = null;\n\n      vue.onMounted(() => {\n        if (!hostRef.value) {\n          return;\n        }\n        instance = factory.mount({\n          target: hostRef.value,\n          props,\n        });\n      });\n\n      vue.watch(\n        () => props,\n        next => {\n          if (instance) {\n            instance.updateProps(next as Props);\n          }\n        },\n        { deep: true },\n      );\n\n      vue.onBeforeUnmount(() => {\n        instance?.destroy();\n        instance = null;\n      });\n\n      return () => {\n        const slot = ctx.slots?.default;\n        return vue.h(hostTag, { ref: hostRef }, slot ? slot() : null);\n      };\n    },\n  };\n\n  return component;\n}\n"]}

package/dist/runtime/components/ai-assistant.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var chunk6BYWFGQY_cjs = require('../../chunk-6BYWFGQY.cjs');
+require('../../chunk-W3LNNY3U.cjs');
+require('../../chunk-PVZVFICK.cjs');
+require('../../chunk-IRBUKIRF.cjs');
+require('../../chunk-FFCZSYC7.cjs');
+require('../../chunk-EFOOXCY7.cjs');
+require('../../chunk-VHUXNDW2.cjs');
+
+
+
+Object.defineProperty(exports, "AiAssistantPanel", {
+  enumerable: true,
+  get: function () { return chunk6BYWFGQY_cjs.AiAssistantPanel; }
+});
+//# sourceMappingURL=ai-assistant.cjs.map
+//# sourceMappingURL=ai-assistant.cjs.map

package/dist/runtime/components/ai-assistant.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"ai-assistant.cjs"}

package/dist/runtime/components/ai-assistant.d.cts

@@ -0,0 +1,8 @@
+import '../../component-BVzvepw9.cjs';
+export { A as AiAssistantPanel, a as AiAssistantPanelProps } from '../../ai-assistant-EobSUV70.cjs';
+import '../../types-C4RXXKfk.cjs';
+import '../../tracing-DGdvMCEl.cjs';
+import 'node:fs';
+import '../../router-YnpW_sIK.cjs';
+import '../../browser-signals-07qodpYT.cjs';
+import '../../lib/theme.cjs';

package/dist/runtime/components/ai-assistant.d.ts

@@ -0,0 +1,8 @@
+import '../../component-wTxZ2BPD.js';
+export { A as AiAssistantPanel, a as AiAssistantPanelProps } from '../../ai-assistant-Db002XYC.js';
+import '../../types-C4RXXKfk.js';
+import '../../tracing-DGdvMCEl.js';
+import 'node:fs';
+import '../../router-B9kms5XQ.js';
+import '../../browser-signals-07qodpYT.js';
+import '../../lib/theme.js';

package/dist/runtime/components/ai-assistant.js

@@ -0,0 +1,9 @@
+export { AiAssistantPanel } from '../../chunk-T6T7QE4J.js';
+import '../../chunk-CHLDE4JQ.js';
+import '../../chunk-Q3KH6HMU.js';
+import '../../chunk-IHAMVLRY.js';
+import '../../chunk-BBAUALNU.js';
+import '../../chunk-D3H5CGVD.js';
+import '../../chunk-PFBEIFVS.js';
+//# sourceMappingURL=ai-assistant.js.map
+//# sourceMappingURL=ai-assistant.js.map

package/dist/runtime/components/ai-assistant.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"ai-assistant.js"}

package/dist/runtime/components/ai-summary-card.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var chunkCXTAUXLG_cjs = require('../../chunk-CXTAUXLG.cjs');
+require('../../chunk-W3LNNY3U.cjs');
+require('../../chunk-PVZVFICK.cjs');
+require('../../chunk-IRBUKIRF.cjs');
+require('../../chunk-FFCZSYC7.cjs');
+require('../../chunk-EFOOXCY7.cjs');
+require('../../chunk-VHUXNDW2.cjs');
+
+
+
+Object.defineProperty(exports, "AiSummaryCard", {
+  enumerable: true,
+  get: function () { return chunkCXTAUXLG_cjs.AiSummaryCard; }
+});
+//# sourceMappingURL=ai-summary-card.cjs.map
+//# sourceMappingURL=ai-summary-card.cjs.map

package/dist/runtime/components/ai-summary-card.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"ai-summary-card.cjs"}

package/dist/runtime/components/ai-summary-card.d.cts

@@ -0,0 +1,19 @@
+import { C as ComponentFactory } from '../../component-BVzvepw9.cjs';
+import '../../types-C4RXXKfk.cjs';
+import '../../tracing-DGdvMCEl.cjs';
+import 'node:fs';
+import '../../router-YnpW_sIK.cjs';
+import '../../browser-signals-07qodpYT.cjs';
+import '../../lib/theme.cjs';
+
+interface AiSummaryCardProps extends Record<string, unknown> {
+    eyebrow?: string;
+    title: string;
+    summary: string;
+    highlights?: string[];
+    sentiment?: 'positive' | 'warning' | 'critical';
+    updatedAt?: string;
+}
+declare const AiSummaryCard: ComponentFactory<AiSummaryCardProps>;
+
+export { AiSummaryCard, type AiSummaryCardProps };

package/dist/runtime/components/ai-summary-card.d.ts

@@ -0,0 +1,19 @@
+import { C as ComponentFactory } from '../../component-wTxZ2BPD.js';
+import '../../types-C4RXXKfk.js';
+import '../../tracing-DGdvMCEl.js';
+import 'node:fs';
+import '../../router-B9kms5XQ.js';
+import '../../browser-signals-07qodpYT.js';
+import '../../lib/theme.js';
+
+interface AiSummaryCardProps extends Record<string, unknown> {
+    eyebrow?: string;
+    title: string;
+    summary: string;
+    highlights?: string[];
+    sentiment?: 'positive' | 'warning' | 'critical';
+    updatedAt?: string;
+}
+declare const AiSummaryCard: ComponentFactory<AiSummaryCardProps>;
+
+export { AiSummaryCard, type AiSummaryCardProps };

package/dist/runtime/components/ai-summary-card.js

@@ -0,0 +1,9 @@
+export { AiSummaryCard } from '../../chunk-V6JCOBGY.js';
+import '../../chunk-CHLDE4JQ.js';
+import '../../chunk-Q3KH6HMU.js';
+import '../../chunk-IHAMVLRY.js';
+import '../../chunk-BBAUALNU.js';
+import '../../chunk-D3H5CGVD.js';
+import '../../chunk-PFBEIFVS.js';
+//# sourceMappingURL=ai-summary-card.js.map
+//# sourceMappingURL=ai-summary-card.js.map

package/dist/runtime/components/ai-summary-card.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"ai-summary-card.js"}

package/dist/runtime/router.cjs

@@ -0,0 +1,429 @@
+'use strict';
+
+var chunkKPG5HAHK_cjs = require('../chunk-KPG5HAHK.cjs');
+var chunkZWUA2LPB_cjs = require('../chunk-ZWUA2LPB.cjs');
+var chunkEFOOXCY7_cjs = require('../chunk-EFOOXCY7.cjs');
+var chunkVHUXNDW2_cjs = require('../chunk-VHUXNDW2.cjs');
+
+// src/runtime/router.ts
+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 = chunkZWUA2LPB_cjs.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 = chunkVHUXNDW2_cjs.signal(initialPath);
+  const currentMatchSignal = chunkVHUXNDW2_cjs.signal(resolveMatch(initialPath));
+  function resolveMatch(path) {
+    for (const node of flattened) {
+      const params = chunkZWUA2LPB_cjs.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: chunkZWUA2LPB_cjs.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: chunkZWUA2LPB_cjs.getRouteId(route),
+              path: fullPath,
+              layoutIndex: index,
+              params
+            })
+          )
+        );
+      });
+    });
+    return states;
+  }
+  function createFallbackMatch(route, requestedPath, reason, error, errorMessage) {
+    const normalizedPath = chunkZWUA2LPB_cjs.normalizePathname(requestedPath);
+    const params = chunkZWUA2LPB_cjs.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: chunkZWUA2LPB_cjs.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 {
+          chunkKPG5HAHK_cjs.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;
+      }
+      chunkKPG5HAHK_cjs.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 () => chunkKPG5HAHK_cjs.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 = chunkKPG5HAHK_cjs.captureRuntimeError(error, info);
+        if (!handled) {
+          throw error;
+        }
+        return void 0;
+      });
+    }
+    return result;
+  } catch (error) {
+    const handled = chunkKPG5HAHK_cjs.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 updateRouteDataCache(match, result) {
+  if (result.handled) {
+    chunkEFOOXCY7_cjs.cacheRouteDataResult(match, result);
+    return;
+  }
+  chunkEFOOXCY7_cjs.clearRouteDataResult(match);
+}
+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;
+}
+
+exports.allowNavigation = allowNavigation;
+exports.createRouter = createRouter;
+exports.errorNavigation = errorNavigation;
+exports.prefetchRoute = prefetchRoute;
+exports.redirectNavigation = redirectNavigation;
+exports.runRouteAction = runRouteAction;
+exports.runRouteLoader = runRouteLoader;
+//# sourceMappingURL=router.cjs.map
+//# sourceMappingURL=router.cjs.map