@burdenoff/fluidgrids-fe-sdk 2026.1104.3 → 2026.1105.2

package/dist/{chunk-SS7Y66P5.js → chunk-TCIBTMJI.js}

@@ -1,7 +1,7 @@
-import { throwIfResultError } from './chunk-AAIZ6S6E.js';
-import { RunFailureClustersDocument, DismissRunFailureClusterDocument, RunFailureTriageSettingsDocument, SetRunFailureTriageEnabledDocument, FgTriageFailedRunsDocument } from './chunk-AVHBWJRY.js';
+import { RunFailureClustersDocument, DismissRunFailureClusterDocument, RunFailureTriageSettingsDocument, SetRunFailureTriageEnabledDocument, FgTriageFailedRunsDocument } from './chunk-Z3ABLERJ.js';
 import { useTr } from './chunk-UULVIT25.js';
-import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { getFluidGridsClient } from './chunk-3IXU7WUC.js';
+import { throwIfResultError } from './chunk-US5QSLPV.js';
 import { useState, useCallback, useEffect } from 'react';
 import { Icon } from '@iconify/react';
 import { Button } from '@burdenoff/fe-libs/ui';
@@ -325,4 +325,70 @@ function FailureTriagePanel({
   );
 }
 
-export { BUCKET_LABELS, FailureTriagePanel, OPEN_STATUSES, dismissRunFailureCluster, fetchRunFailureClusters };
+// src/modules/observability/utils.ts
+function percentage(value, total) {
+  if (total <= 0) return 0;
+  return Math.round(value / total * 1e3) / 10;
+}
+function getFailureBreakdown(runs) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    const key = run.errorType || "UNKNOWN";
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([key, count]) => ({ key, count })).sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
+}
+function getTopFailingWorkflows(runs) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const run of runs) {
+    const current = counts.get(run.workflowKey);
+    if (current) {
+      current.count += 1;
+    } else {
+      counts.set(run.workflowKey, {
+        workflowKey: run.workflowKey,
+        label: run.workflow?.name || run.workflowKey,
+        count: 1
+      });
+    }
+  }
+  return [...counts.values()].sort(
+    (a, b) => b.count - a.count || a.label.localeCompare(b.label)
+  );
+}
+function getTopFailingNodes(nodeUsageStats) {
+  return [...nodeUsageStats].filter((stat) => stat.failureCount > 0).sort(
+    (a, b) => b.failureCount - a.failureCount || a.nodeType.localeCompare(b.nodeType)
+  );
+}
+function formatDuration(seconds) {
+  if (seconds === null || seconds === void 0 || !Number.isFinite(seconds)) {
+    return "\u2014";
+  }
+  if (seconds < 1) return `${Math.round(seconds * 1e3)}ms`;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.round(seconds % 60);
+  return `${minutes}m ${remainingSeconds}s`;
+}
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) return "\u2014";
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unit = units[0];
+  for (let i = 1; i < units.length && value >= 1024; i += 1) {
+    value /= 1024;
+    unit = units[i];
+  }
+  return `${value.toFixed(value >= 10 ? 0 : 1)} ${unit}`;
+}
+function prettyJson(value) {
+  try {
+    return JSON.stringify(value, null, 2) ?? "null";
+  } catch {
+    return String(value);
+  }
+}
+
+export { BUCKET_LABELS, FailureTriagePanel, OPEN_STATUSES, dismissRunFailureCluster, fetchRunFailureClusters, formatBytes, formatDuration, getFailureBreakdown, getTopFailingNodes, getTopFailingWorkflows, percentage, prettyJson };

package/dist/{chunk-OMB3WMDQ.js → chunk-TNFBRXU7.js}

@@ -1,13 +1,14 @@
-import { isGuidedTourIntent, pickGuidedTour, withoutGuidedTourIntent, isCreateIntent, CreateWorkflowRefusalDialog, decideMissingWorkflow } from './chunk-TBHAZK52.js';
+import { isGuidedTourIntent, pickGuidedTour, withoutGuidedTourIntent, isCreateIntent, CreateWorkflowRefusalDialog, decideMissingWorkflow } from './chunk-Y6M7K4UG.js';
 import { registerLiveCanvasHandler } from './chunk-PIKYQE7P.js';
-import { useWorkflowReloadStore, releaseLeaseKeptForReload, useInstalledNodes, buildNodeCheck, FlowBuilderPage, buildRequiredNodeTypes } from './chunk-DFIX6YWP.js';
-import { canvasFromDefinition } from './chunk-KHXRYQYP.js';
-import { useLazyWorkflowDefinition, useCreateWorkflow } from './chunk-AFX3EKFN.js';
-import { useFlowStore, refetchStoreNodes, BILLING_PLANS_PATH, codeBuildIdOf, mergeStickyNotes, rememberRevision, blankWorkflowCreateInput, classifyCreateRefusal, useSaveStatusStore, workflowFingerprint, registerWorkflowNodeTypes, throwIfResultError } from './chunk-AAIZ6S6E.js';
-import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
-import { WorkflowDefinitionDocument } from './chunk-AVHBWJRY.js';
+import { useWorkflowReloadStore, releaseLeaseKeptForReload, useInstalledNodes, buildNodeCheck, FlowBuilderPage, buildRequiredNodeTypes } from './chunk-62CCBMDC.js';
+import { canvasFromDefinition } from './chunk-64JN2TVX.js';
+import { useLazyWorkflowDefinition, useCreateWorkflow } from './chunk-QFGZXWTM.js';
+import { useFlowStore, refetchStoreNodes, BILLING_PLANS_PATH, codeBuildIdOf, mergeStickyNotes, rememberRevision, blankWorkflowCreateInput, classifyCreateRefusal, useSaveStatusStore, workflowFingerprint, registerWorkflowNodeTypes } from './chunk-3QCRKKTI.js';
+import { WorkflowDefinitionDocument } from './chunk-Z3ABLERJ.js';
 import { useTr } from './chunk-UULVIT25.js';
-import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { getFluidGridsClient } from './chunk-3IXU7WUC.js';
+import { throwIfResultError } from './chunk-US5QSLPV.js';
+import { getFluidGridsConfig } from './chunk-UEG2WC3G.js';
 import { useLocation, useNavigate, useParams } from 'react-router';
 import { toast } from 'sonner';
 import { Icon } from '@iconify/react';
@@ -792,9 +793,9 @@ function WorkflowItem({
       setInstalling(true);
       setInstallErrors([]);
       try {
-        const { getGlobalStoreClient } = await import('./global-client-O2HCG5CJ.js');
+        const { getGlobalStoreClient } = await import('./global-client-N5EIFW6T.js');
         const { InstallWorkflowNodeDocument } = await import('./global-operations-BZDHTSYP.js');
-        const { getFluidGridsConfig: getFluidGridsConfig2 } = await import('./config-3DBXLCK3.js');
+        const { getFluidGridsConfig: getFluidGridsConfig2 } = await import('./config-66FUPSG5.js');
         const storeClient = getGlobalStoreClient();
         const cfg = getFluidGridsConfig2();
         for (let i = 0; i < nodesToInstall.length; i++) {

package/dist/chunk-UEG2WC3G.js

@@ -0,0 +1,502 @@
+import { create } from 'zustand';
+
+var defaultFilter = {
+  status: "all",
+  workflowKey: "",
+  dateRange: {
+    start: null,
+    end: null,
+    preset: "all"
+  },
+  search: "",
+  triggerType: "all",
+  durationMinSeconds: null,
+  durationMaxSeconds: null,
+  errorType: "all",
+  nodeId: "",
+  tagId: "",
+  workflowId: ""
+};
+var defaultPagination = {
+  page: 1,
+  pageSize: 25,
+  total: 0
+};
+var useExecutionsStore = create((set) => ({
+  // Initial state
+  viewMode: "table",
+  selectedExecution: null,
+  expandedRows: /* @__PURE__ */ new Set(),
+  selection: {
+    runIds: [],
+    allSelected: false
+  },
+  filter: defaultFilter,
+  pagination: defaultPagination,
+  isFilterPanelOpen: false,
+  isDetailsPanelOpen: false,
+  autoRefresh: true,
+  autoRefreshInterval: 5e3,
+  liveRunIds: /* @__PURE__ */ new Set(),
+  // Actions - View
+  setViewMode: (mode) => set({ viewMode: mode }),
+  setSelectedExecution: (execution) => set({
+    selectedExecution: execution,
+    isDetailsPanelOpen: execution !== null
+  }),
+  toggleRowExpanded: (runId) => set((state) => {
+    const newExpanded = new Set(state.expandedRows);
+    if (newExpanded.has(runId)) {
+      newExpanded.delete(runId);
+    } else {
+      newExpanded.add(runId);
+    }
+    return { expandedRows: newExpanded };
+  }),
+  // Actions - Selection
+  setSelection: (selection) => set({ selection }),
+  toggleSelectRun: (runId) => set((state) => {
+    const isSelected = state.selection.runIds.includes(runId);
+    const newRunIds = isSelected ? state.selection.runIds.filter((id) => id !== runId) : [...state.selection.runIds, runId];
+    return {
+      selection: {
+        runIds: newRunIds,
+        allSelected: false
+      }
+    };
+  }),
+  selectAll: (runIds) => set((state) => ({
+    selection: {
+      runIds: state.selection.allSelected ? [] : runIds,
+      allSelected: !state.selection.allSelected
+    }
+  })),
+  clearSelection: () => set({
+    selection: {
+      runIds: [],
+      allSelected: false
+    }
+  }),
+  // Actions - Filter
+  updateFilter: (filterUpdate) => set((state) => ({
+    filter: { ...state.filter, ...filterUpdate },
+    pagination: { ...state.pagination, page: 1 }
+  })),
+  setStatusFilter: (status) => set((state) => ({
+    filter: { ...state.filter, status },
+    pagination: { ...state.pagination, page: 1 }
+  })),
+  setWorkflowFilter: (workflowKey) => set((state) => ({
+    filter: { ...state.filter, workflowKey },
+    pagination: { ...state.pagination, page: 1 }
+  })),
+  setDateRange: (dateRange) => set((state) => ({
+    filter: { ...state.filter, dateRange },
+    pagination: { ...state.pagination, page: 1 }
+  })),
+  setSearchQuery: (search) => set((state) => ({
+    filter: { ...state.filter, search },
+    pagination: { ...state.pagination, page: 1 }
+  })),
+  setTriggerTypeFilter: (triggerType) => set((state) => ({
+    filter: { ...state.filter, triggerType },
+    pagination: { ...state.pagination, page: 1 }
+  })),
+  setDurationFilter: (durationMinSeconds, durationMaxSeconds) => set((state) => ({
+    filter: { ...state.filter, durationMinSeconds, durationMaxSeconds },
+    pagination: { ...state.pagination, page: 1 }
+  })),
+  setErrorTypeFilter: (errorType) => set((state) => ({
+    filter: { ...state.filter, errorType },
+    pagination: { ...state.pagination, page: 1 }
+  })),
+  setNodeFilter: (nodeId) => set((state) => ({
+    filter: { ...state.filter, nodeId },
+    pagination: { ...state.pagination, page: 1 }
+  })),
+  setTagFilter: (tagId) => set((state) => ({
+    filter: { ...state.filter, tagId },
+    pagination: { ...state.pagination, page: 1 }
+  })),
+  setWorkflowIdFilter: (workflowId) => set((state) => ({
+    filter: { ...state.filter, workflowId },
+    pagination: { ...state.pagination, page: 1 }
+  })),
+  resetFilters: () => set({
+    filter: defaultFilter,
+    pagination: { ...defaultPagination }
+  }),
+  // Actions - Pagination
+  setPage: (page) => set((state) => ({
+    pagination: { ...state.pagination, page }
+  })),
+  setPageSize: (pageSize) => set((state) => ({
+    pagination: { ...state.pagination, pageSize, page: 1 }
+  })),
+  setTotal: (total) => set((state) => ({
+    pagination: { ...state.pagination, total }
+  })),
+  // Actions - UI
+  toggleFilterPanel: () => set((state) => ({
+    isFilterPanelOpen: !state.isFilterPanelOpen
+  })),
+  toggleDetailsPanel: () => set((state) => ({
+    isDetailsPanelOpen: !state.isDetailsPanelOpen
+  })),
+  setAutoRefresh: (enabled) => set({ autoRefresh: enabled }),
+  setAutoRefreshInterval: (interval) => set({ autoRefreshInterval: interval }),
+  // Actions - Real-time
+  addLiveRun: (runId) => set((state) => {
+    const newLiveRunIds = new Set(state.liveRunIds);
+    newLiveRunIds.add(runId);
+    return { liveRunIds: newLiveRunIds };
+  }),
+  removeLiveRun: (runId) => set((state) => {
+    const newLiveRunIds = new Set(state.liveRunIds);
+    newLiveRunIds.delete(runId);
+    return { liveRunIds: newLiveRunIds };
+  }),
+  clearLiveRuns: () => set({ liveRunIds: /* @__PURE__ */ new Set() })
+}));
+
+// src/theme/fluidgridsTheme.ts
+var color = (...cssVariables) => ({
+  kind: "color",
+  cssVariables
+});
+var length = (...cssVariables) => ({
+  kind: "length",
+  cssVariables
+});
+var font = (...cssVariables) => ({
+  kind: "font",
+  cssVariables
+});
+var FLUIDGRIDS_THEME_TOKEN_MAP = {
+  "colors.bgCanvas": color("--color-bg-canvas"),
+  "colors.bgSurface": color("--color-bg-surface"),
+  "colors.bgElevated": color("--color-bg-elevated"),
+  "colors.bgSunken": color("--color-bg-sunken"),
+  "colors.textPrimary": color("--color-text-primary"),
+  "colors.textSecondary": color("--color-text-secondary"),
+  "colors.textMuted": color("--color-text-muted"),
+  "colors.borderDefault": color("--color-border-default"),
+  "colors.borderSubtle": color("--color-border-subtle"),
+  "colors.borderStrong": color("--color-border-strong"),
+  "colors.primary": color(
+    "--color-action-primary-bg",
+    "--color-action-primary-border"
+  ),
+  "colors.primaryHover": color("--color-action-primary-bgHover"),
+  "colors.primaryActive": color("--color-action-primary-bgActive"),
+  "colors.primaryText": color("--color-action-primary-text"),
+  "colors.success": color("--color-status-success-bg"),
+  "colors.warning": color("--color-status-warning-bg"),
+  "colors.error": color("--color-status-error-bg"),
+  "colors.info": color("--color-status-info-bg"),
+  "radius.base": length("--radius"),
+  "radius.card": length("--radius-card"),
+  "radius.button": length("--radius-button"),
+  "radius.input": length("--radius-input"),
+  "font.body": font("--font-family-body", "--font-sans"),
+  "font.heading": font("--font-family-heading"),
+  "font.mono": font("--font-family-mono", "--font-mono")
+};
+var MAX_VALUE_LENGTH = 200;
+var FORBIDDEN_VALUE = /[;{}<>\\!@"`]|\/\*|\*\/|url\s*\(|expression\s*\(|image\s*\(|image-set\s*\(|javascript:|@import/i;
+var HEX_COLOR = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var NAMED_COLOR = /^[a-z]{3,30}$/i;
+var COLOR_FUNCTION = /^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color|color-mix)\([a-z0-9#%.,/\s()+-]*\)$/i;
+var CSS_VAR = /^var\(--[a-z0-9-]+\)$/i;
+var LENGTH = /^(?:0|\d*\.?\d+(?:px|rem|em|%|vh|vw|vmin|vmax|ch|ex|pt))$/i;
+var CALC = /^calc\([a-z0-9%.\s()*/+-]*\)$/i;
+var FONT_FAMILY_ITEM = /^(?:[a-z0-9][a-z0-9 _-]*|'[a-z0-9 _-]+')$/i;
+function balancedParentheses(value) {
+  let depth = 0;
+  for (const char of value) {
+    if (char === "(") depth += 1;
+    if (char === ")") depth -= 1;
+    if (depth < 0) return false;
+  }
+  return depth === 0;
+}
+function sanitizeThemeValue(kind, value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > MAX_VALUE_LENGTH) return null;
+  if (FORBIDDEN_VALUE.test(trimmed) || !balancedParentheses(trimmed)) {
+    return null;
+  }
+  if (CSS_VAR.test(trimmed)) return trimmed;
+  switch (kind) {
+    case "color":
+      return HEX_COLOR.test(trimmed) || NAMED_COLOR.test(trimmed) || COLOR_FUNCTION.test(trimmed) ? trimmed : null;
+    case "length":
+      return LENGTH.test(trimmed) || CALC.test(trimmed) ? trimmed : null;
+    case "font": {
+      const items = trimmed.split(",").map((item) => item.trim());
+      return items.every((item) => FONT_FAMILY_ITEM.test(item)) ? items.join(", ") : null;
+    }
+  }
+}
+function warnDropped(key, value) {
+  console.warn(
+    `[FluidGrids SDK] theme token "${key}" ignored: ${JSON.stringify(value)} is not a plain CSS value.`
+  );
+}
+function hexLuminance(value) {
+  if (!HEX_COLOR.test(value)) return null;
+  let hex = value.slice(1);
+  if (hex.length <= 4) {
+    hex = hex.split("").map((digit) => digit + digit).join("");
+  }
+  const channels = [0, 2, 4].map((offset) => {
+    const channel = parseInt(hex.slice(offset, offset + 2), 16) / 255;
+    return channel <= 0.03928 ? channel / 12.92 : Math.pow((channel + 0.055) / 1.055, 2.4);
+  });
+  const [red = 0, green = 0, blue = 0] = channels;
+  return 0.2126 * red + 0.7152 * green + 0.0722 * blue;
+}
+function themeMode(theme) {
+  if (theme === "light" || theme === "dark") return theme;
+  if (theme && typeof theme === "object") {
+    return theme.mode === "light" || theme.mode === "dark" ? theme.mode : void 0;
+  }
+  return void 0;
+}
+function groupEntries(theme, group) {
+  const values = theme[group];
+  if (!values || typeof values !== "object") return [];
+  return Object.entries(values);
+}
+function isTokenKey(key) {
+  return Object.prototype.hasOwnProperty.call(FLUIDGRIDS_THEME_TOKEN_MAP, key);
+}
+function themeToCssVariables(theme) {
+  const variables = {};
+  if (!theme || typeof theme !== "object") return variables;
+  const colors = {};
+  for (const group of ["colors", "radius", "font"]) {
+    for (const [name, raw] of groupEntries(theme, group)) {
+      if (raw === void 0) continue;
+      const key = `${group}.${name}`;
+      if (!isTokenKey(key)) {
+        warnDropped(key, raw);
+        continue;
+      }
+      const mapping = FLUIDGRIDS_THEME_TOKEN_MAP[key];
+      const value = sanitizeThemeValue(mapping.kind, raw);
+      if (value === null) {
+        warnDropped(key, raw);
+        continue;
+      }
+      if (group === "colors") colors[name] = value;
+      for (const cssVariable of mapping.cssVariables) {
+        variables[cssVariable] = value;
+      }
+    }
+  }
+  const primary = colors.primary;
+  if (primary) {
+    if (!colors.primaryHover) {
+      variables["--color-action-primary-bgHover"] = `color-mix(in oklab, ${primary} 84%, var(--palette-black))`;
+    }
+    if (!colors.primaryActive) {
+      variables["--color-action-primary-bgActive"] = `color-mix(in oklab, ${primary} 70%, var(--palette-black))`;
+    }
+    if (!colors.primaryText) {
+      const luminance = hexLuminance(primary);
+      if (luminance !== null) {
+        variables["--color-action-primary-text"] = luminance > 0.4 ? "var(--palette-black)" : "var(--palette-white)";
+      }
+    }
+  }
+  return variables;
+}
+var stack = [];
+var nextId = 1;
+var observer = null;
+var hostVariables = /* @__PURE__ */ new Map();
+var appliedVariables = /* @__PURE__ */ new Map();
+var hostMode = null;
+function readHostMode(root) {
+  return {
+    dataTheme: root.getAttribute("data-theme"),
+    dark: root.classList.contains("dark")
+  };
+}
+function writeMode(root, mode) {
+  if (mode.dataTheme === null) root.removeAttribute("data-theme");
+  else if (root.getAttribute("data-theme") !== mode.dataTheme) {
+    root.setAttribute("data-theme", mode.dataTheme);
+  }
+  if (root.classList.contains("dark") !== mode.dark) {
+    root.classList.toggle("dark", mode.dark);
+  }
+}
+function modeDrifted(root, mode) {
+  return root.getAttribute("data-theme") !== mode || root.classList.contains("dark") !== (mode === "dark");
+}
+function restoreVariable(root, name) {
+  const previous = hostVariables.get(name) ?? "";
+  if (previous) root.style.setProperty(name, previous);
+  else root.style.removeProperty(name);
+  hostVariables.delete(name);
+  appliedVariables.delete(name);
+}
+function forceVariable(root, name, value) {
+  root.style.setProperty(name, value);
+  appliedVariables.set(name, root.style.getPropertyValue(name));
+}
+function reconcileDrift() {
+  const top = stack.at(-1);
+  if (!top || typeof document === "undefined") return;
+  const root = document.documentElement;
+  for (const [name, value] of Object.entries(top.variables)) {
+    const current = root.style.getPropertyValue(name);
+    if (current !== appliedVariables.get(name)) {
+      hostVariables.set(name, current);
+      forceVariable(root, name, value);
+    }
+  }
+  if (top.mode && modeDrifted(root, top.mode)) {
+    hostMode = readHostMode(root);
+    writeMode(root, { dataTheme: top.mode, dark: top.mode === "dark" });
+  }
+}
+function sync() {
+  if (typeof document === "undefined") return;
+  const root = document.documentElement;
+  const top = stack.at(-1);
+  const wanted = top?.variables ?? {};
+  for (const name of [...appliedVariables.keys()]) {
+    if (!(name in wanted)) restoreVariable(root, name);
+  }
+  for (const [name, value] of Object.entries(wanted)) {
+    if (!hostVariables.has(name)) {
+      hostVariables.set(name, root.style.getPropertyValue(name));
+    }
+    if (appliedVariables.get(name) !== value) forceVariable(root, name, value);
+  }
+  if (top?.mode) {
+    if (!hostMode) hostMode = readHostMode(root);
+    writeMode(root, { dataTheme: top.mode, dark: top.mode === "dark" });
+  } else if (hostMode) {
+    writeMode(root, hostMode);
+    hostMode = null;
+  }
+  if (!top) {
+    observer?.disconnect();
+    observer = null;
+    return;
+  }
+  if (!observer && typeof MutationObserver !== "undefined") {
+    observer = new MutationObserver(reconcileDrift);
+    observer.observe(root, {
+      attributes: true,
+      attributeFilter: ["style", "data-theme", "class"]
+    });
+  }
+}
+function applyFluidGridsTheme(theme) {
+  if (typeof document === "undefined") return () => void 0;
+  const entry = {
+    id: nextId++,
+    variables: themeToCssVariables(theme),
+    mode: themeMode(theme)
+  };
+  stack.push(entry);
+  sync();
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    const index = stack.findIndex((active) => active.id === entry.id);
+    if (index >= 0) stack.splice(index, 1);
+    sync();
+  };
+}
+function themeKey(theme) {
+  if (!theme) return "";
+  if (typeof theme === "string") return theme;
+  const sortedGroup = (group) => groupEntries(theme, group).filter(([, value]) => value !== void 0).sort(([a], [b]) => a.localeCompare(b));
+  return JSON.stringify([
+    theme.mode ?? null,
+    sortedGroup("colors"),
+    sortedGroup("radius"),
+    sortedGroup("font")
+  ]);
+}
+
+// src/config/index.ts
+var runtimeConfig = {
+  apiGatewayUrl: "",
+  workspaceId: ""
+};
+var config = new Proxy({}, {
+  get(_, prop) {
+    return runtimeConfig[prop];
+  }
+});
+function getFluidGridsConfig() {
+  return { ...runtimeConfig };
+}
+function setFluidGridsConfig(newConfig) {
+  const previous = runtimeConfig;
+  runtimeConfig = { ...runtimeConfig, ...newConfig };
+  if (previous.authToken !== runtimeConfig.authToken || previous.workspaceToken !== runtimeConfig.workspaceToken) {
+    tokenRevision += 1;
+  }
+  if ("theme" in newConfig) syncConfigTheme(newConfig.theme);
+}
+function resetFluidGridsConfig() {
+  tokenRevision += 1;
+  runtimeConfig = {
+    apiGatewayUrl: "",
+    workspaceId: ""
+  };
+  syncConfigTheme(void 0);
+}
+var tokenRevision = 0;
+function getFluidGridsTokenRevision() {
+  return tokenRevision;
+}
+var configTheme = null;
+function syncConfigTheme(theme) {
+  const key = themeKey(theme);
+  if (configTheme?.key === key) return;
+  const previous = configTheme;
+  configTheme = key ? { key, dispose: applyFluidGridsTheme(theme) } : null;
+  previous?.dispose();
+}
+function normalizeOrigin(origin) {
+  return origin.replace(/\/$/, "");
+}
+function validateTrustedOrigin(trustedOrigins) {
+  if (typeof window === "undefined" || !trustedOrigins?.length) {
+    return;
+  }
+  const currentOrigin = normalizeOrigin(window.location.origin);
+  const allowedOrigins = trustedOrigins.map(normalizeOrigin);
+  if (!allowedOrigins.includes(currentOrigin)) {
+    throw new Error(
+      `FluidGrids SDK blocked untrusted origin: ${currentOrigin}`
+    );
+  }
+}
+function getGraphQLEndpoint(baseUrl) {
+  const url = baseUrl || runtimeConfig.apiGatewayUrl;
+  if (!url) {
+    throw new Error("FluidGrids SDK requires apiGatewayUrl to be configured");
+  }
+  const normalizedBase = url.endsWith("/") ? url.slice(0, -1) : url;
+  if (normalizedBase.endsWith("/graphql")) {
+    return normalizedBase;
+  }
+  return `${normalizedBase}/workspaces/graphql`;
+}
+function resetFluidGridsExecutionState() {
+  useExecutionsStore.setState(useExecutionsStore.getInitialState(), true);
+}
+
+export { FLUIDGRIDS_THEME_TOKEN_MAP, applyFluidGridsTheme, config, getFluidGridsConfig, getFluidGridsTokenRevision, getGraphQLEndpoint, resetFluidGridsConfig, resetFluidGridsExecutionState, sanitizeThemeValue, setFluidGridsConfig, themeKey, themeToCssVariables, useExecutionsStore, validateTrustedOrigin };