@burdenoff/fluidgrids-fe-sdk 2026.1028.7 → 2026.1028.9

package/dist/{chunk-DUXOFCPO.js → chunk-GQQV2L74.js}

@@ -1,4 +1,4 @@
-import { throwIfResultError, describeOperationError } from './chunk-6NUHJPGJ.js';
+import { throwIfResultError, describeOperationError } from './chunk-NVUJFHTQ.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useCallback, useEffect, useMemo } from 'react';

package/dist/{chunk-ZB4BNTWR.js → chunk-KFCCLXZO.js}

@@ -1,10 +1,10 @@
-import { useImportWorkflowTemplate, FlowBuilderPage, useWorkflowTemplates, TemplateCard } from './chunk-XYZKIFXY.js';
-import { QuotaExhaustedDialog } from './chunk-HDUCP6EO.js';
-import { useWorkflowDefinitions, useDuplicateWorkflow } from './chunk-PYCKEQ4W.js';
+import { useImportWorkflowTemplate, FlowBuilderPage, useWorkflowTemplates, TemplateCard } from './chunk-PXIWI7OB.js';
+import { QuotaExhaustedDialog } from './chunk-M62CJVTR.js';
+import { useWorkflowDefinitions, useDuplicateWorkflow } from './chunk-YQZ7HBOJ.js';
 import { templatesControls } from './chunk-D3UWK7GY.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { BILLING_PLANS_PATH, useFluidGridsAnalytics, emitTemplateUsed, isQuotaExhaustedFailure } from './chunk-6NUHJPGJ.js';
+import { BILLING_PLANS_PATH, useFluidGridsAnalytics, emitTemplateUsed, isQuotaExhaustedFailure } from './chunk-NVUJFHTQ.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useEffect, useMemo, useCallback } from 'react';
 import { useParams, useNavigate } from 'react-router';

package/dist/chunk-M62CJVTR.js

@@ -0,0 +1,458 @@
+import { describeOperationError, useFluidGridsAnalytics, emitWorkflowLimitHit, emitUpgradeClicked, WORKFLOWS_QUOTA_NAME, throwIfResultError } from './chunk-NVUJFHTQ.js';
+import { ExportWorkflowCodeDocument } from './chunk-7PBOU7JC.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import JSZip from 'jszip';
+import { AlertDialog, AlertDialogContent, AlertDialogHeader, AlertDialogTitle, AlertDialogDescription, AlertDialogFooter, AlertDialogCancel, AlertDialogAction } from '@burdenoff/fe-libs/ui';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/utils/workflow-transfer.ts
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function collectWorkflowNodeReferences(definition) {
+  const root = asRecord(definition);
+  const data = asRecord(root?.data);
+  const nodes = data?.nodes;
+  if (!Array.isArray(nodes)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const references = [];
+  for (const candidate of nodes) {
+    const node = asRecord(candidate);
+    const nodeData = asRecord(node?.data);
+    const nodeId = typeof node?.id === "string" ? node.id : null;
+    const nodeType = typeof nodeData?.nodeId === "string" ? nodeData.nodeId : node?.type;
+    if (!nodeId || typeof nodeType !== "string") continue;
+    const nodeVersion = typeof nodeData?.nodeVersion === "string" ? nodeData.nodeVersion : null;
+    const key = `${nodeId}:${nodeType}:${nodeVersion ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    references.push({ nodeId, nodeType, nodeVersion });
+  }
+  return references;
+}
+function createWorkflowExportPayload(workflow) {
+  const definitionJson = asRecord(workflow.definitionJson);
+  if (!definitionJson)
+    throw new Error("Workflow definition JSON must be an object");
+  return {
+    format: "fluidgrids.workflow",
+    schemaVersion: 1,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workflowKey: workflow.workflowKey,
+    version: workflow.version,
+    name: workflow.name,
+    description: workflow.description ?? null,
+    definitionJson,
+    context: asRecord(workflow.context),
+    tags: workflow.tags,
+    tagsV2: workflow.tagsV2,
+    icon: workflow.icon ?? null,
+    category: workflow.category ?? null,
+    nodeReferences: collectWorkflowNodeReferences(definitionJson)
+  };
+}
+function downloadBlob(filename, blob) {
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = filename;
+  anchor.click();
+  URL.revokeObjectURL(url);
+}
+function downloadWorkflowExport(workflow) {
+  const payload = createWorkflowExportPayload(workflow);
+  const blob = new Blob([JSON.stringify(payload, null, 2)], {
+    type: "application/json"
+  });
+  downloadBlob(
+    `${workflow.workflowKey}-${workflow.version}.fluidgrids.json`,
+    blob
+  );
+}
+function parseWorkflowImport(raw) {
+  const parsed = JSON.parse(raw);
+  const root = asRecord(parsed);
+  if (!root) throw new Error("Import must contain a JSON object");
+  const definitionJson = asRecord(root.definitionJson) ?? root;
+  const name = typeof root.name === "string" && root.name.trim() ? root.name : "Imported workflow";
+  return {
+    definitionJson,
+    name,
+    workflowKey: typeof root.workflowKey === "string" ? root.workflowKey : void 0,
+    version: typeof root.version === "string" ? root.version : void 0,
+    description: typeof root.description === "string" ? root.description : void 0,
+    context: asRecord(root.context) ?? void 0,
+    tags: Array.isArray(root.tags) && root.tags.every((tag) => typeof tag === "string") ? root.tags : void 0,
+    tagsV2: root.tagsV2,
+    icon: typeof root.icon === "string" ? root.icon : void 0,
+    category: typeof root.category === "string" ? root.category : void 0,
+    nodeReferences: Array.isArray(root.nodeReferences) ? root.nodeReferences : collectWorkflowNodeReferences(definitionJson)
+  };
+}
+var CODE_EXPORT_FORMATS = [
+  "TYPESCRIPT" /* Typescript */,
+  "PYTHON" /* Python */,
+  "JSON" /* Json */
+];
+var LOSSY_ITEM_KINDS = /* @__PURE__ */ new Set([
+  "layout-omitted",
+  "pinned-data-omitted",
+  "roundtrip-mismatch",
+  "lowering-failed"
+]);
+function isLossyFidelityItem(item) {
+  return LOSSY_ITEM_KINDS.has(item.kind);
+}
+function isLosslessReport(fidelity) {
+  return fidelity.level === "LOSSLESS" /* Lossless */;
+}
+function sortFidelityItems(items) {
+  return items.map((item, index) => ({ item, index })).sort((a, b) => {
+    const lossy = Number(isLossyFidelityItem(b.item)) - Number(isLossyFidelityItem(a.item));
+    if (lossy !== 0) return lossy;
+    return a.index - b.index;
+  }).map(({ item }) => item);
+}
+var EXTENSION_OF = {
+  ["TYPESCRIPT" /* Typescript */]: ".ts",
+  ["PYTHON" /* Python */]: ".py",
+  ["JSON" /* Json */]: ".json"
+};
+function isGeneratedClient(path) {
+  return path.startsWith(".fluidgrids/");
+}
+function primaryExportFile(files, format) {
+  const extension = EXTENSION_OF[format];
+  const sidecar = /\.(layout|pinned)\.json$/;
+  return files.find(
+    (file) => !isGeneratedClient(file.path) && file.path.endsWith(extension) && !sidecar.test(file.path)
+  ) ?? files[0] ?? null;
+}
+function orderedExportFiles(files, format) {
+  const primary = primaryExportFile(files, format);
+  if (!primary) return [];
+  return [primary, ...files.filter((file) => file !== primary)];
+}
+function fileBaseName(path) {
+  const parts = path.split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? path;
+}
+function safeSegment(value) {
+  return value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var ARCHIVE_SUFFIX = {
+  ["TYPESCRIPT" /* Typescript */]: "typescript",
+  ["PYTHON" /* Python */]: "python",
+  ["JSON" /* Json */]: "json"
+};
+function exportArchiveName(workflowKey, version, format) {
+  const stem = [safeSegment(workflowKey), safeSegment(version)].filter(Boolean).join("-");
+  return `${stem || "workflow"}.${ARCHIVE_SUFFIX[format]}.zip`;
+}
+function exportFileContent(file) {
+  if (typeof file.content === "string") return file.content;
+  throw new Error(`The export of ${file.path} has no content`);
+}
+async function buildExportDownload(result, format) {
+  const files = orderedExportFiles(result.files, format);
+  if (files.length === 0) throw new Error("The export returned no files");
+  const contents = files.map((file) => ({
+    file,
+    content: exportFileContent(file)
+  }));
+  if (contents.length === 1) {
+    const [{ file, content }] = contents;
+    return {
+      filename: fileBaseName(file.path),
+      blob: new Blob([content], { type: file.contentType || "text/plain" })
+    };
+  }
+  const zip = new JSZip();
+  for (const { file, content } of contents) zip.file(file.path, content);
+  return {
+    filename: exportArchiveName(result.workflowKey, result.version, format),
+    blob: await zip.generateAsync({
+      type: "blob",
+      mimeType: "application/zip"
+    })
+  };
+}
+function importFileKind(name) {
+  const path = name.split(/[?#]/, 1)[0].toLowerCase();
+  if (path.endsWith(".json")) return "json";
+  if (path.endsWith(".ts") && !path.endsWith(".d.ts")) return "typescript";
+  if (path.endsWith(".zip")) return "archive";
+  if (path.endsWith(".py")) return "python";
+  return null;
+}
+function importAcceptAttribute(codeFirst) {
+  return codeFirst ? "application/json,.json,.ts,text/typescript,.zip,application/zip" : "application/json,.json";
+}
+var MAX_IMPORT_SOURCE_BYTES = 1024 * 1024;
+var MAX_IMPORT_SOURCE_FILES = 200;
+var MAX_IMPORT_ARCHIVE_BYTES = 2 * MAX_IMPORT_SOURCE_BYTES;
+var MAX_ARCHIVE_ENTRIES = 1e3;
+var NODE_CLIENTS_PATH = ".fluidgrids/nodes.ts";
+var NODE_CLIENTS_IMPORT = /\bfrom\s*['"][./]*\.fluidgrids\/nodes(?:\.[cm]?[jt]s)?['"]/;
+var SEGMENT = "[A-Za-z0-9_][A-Za-z0-9._-]*";
+var PROJECT_SOURCE_PATH = new RegExp(
+  `^(?:(?:workflows|activities|\\.fluidgrids)/(?:${SEGMENT}/)*${SEGMENT}\\.ts|workflows/(?:${SEGMENT}/)*${SEGMENT}\\.(?:layout|pinned)\\.json)$`
+);
+var PYTHON_MODULE_PATH = new RegExp(
+  `^workflows/(?:${SEGMENT}/)*${SEGMENT}\\.py$`
+);
+var ImportSourceError = class extends Error {
+  constructor(problem) {
+    super(`Import source refused: ${problem.code}`);
+    this.problem = problem;
+    this.name = "ImportSourceError";
+  }
+  problem;
+};
+var encoder = new TextEncoder();
+function utf8Length(value) {
+  return encoder.encode(value).length;
+}
+function isTypeScriptModule(path) {
+  return path.startsWith("workflows/") && path.endsWith(".ts") && !path.endsWith(".d.ts") && !/\.(test|spec)\.ts$/.test(path);
+}
+function assertImportByteSize(bytes, limitBytes) {
+  if (bytes > limitBytes) {
+    throw new ImportSourceError({ code: "too-large", limitBytes });
+  }
+}
+function typeScriptModuleFile(fileName, content) {
+  const stem = safeSegment(fileBaseName(fileName).replace(/\.ts$/i, ""));
+  return { path: `workflows/${stem || "workflow"}.ts`, content };
+}
+function checkTypeScriptImport(files) {
+  if (files.length > MAX_IMPORT_SOURCE_FILES) {
+    throw new ImportSourceError({
+      code: "too-many-files",
+      limit: MAX_IMPORT_SOURCE_FILES
+    });
+  }
+  const bytes = files.reduce((sum, file) => sum + utf8Length(file.content), 0);
+  assertImportByteSize(bytes, MAX_IMPORT_SOURCE_BYTES);
+  const modules = files.filter((file) => isTypeScriptModule(file.path));
+  if (modules.length === 0) throw new ImportSourceError({ code: "no-module" });
+  if (!files.some((file) => file.path === NODE_CLIENTS_PATH)) {
+    const importer = files.find(
+      (file) => file.path.endsWith(".ts") && NODE_CLIENTS_IMPORT.test(file.content)
+    );
+    if (importer) {
+      throw new ImportSourceError({
+        code: "needs-node-clients",
+        path: importer.path
+      });
+    }
+  }
+  return [...files];
+}
+async function readProjectArchive(data) {
+  assertImportByteSize(data.byteLength, MAX_IMPORT_ARCHIVE_BYTES);
+  let zip;
+  try {
+    zip = await JSZip.loadAsync(data);
+  } catch {
+    throw new ImportSourceError({ code: "invalid-archive" });
+  }
+  const entries = Object.values(zip.files).filter((entry) => !entry.dir);
+  if (entries.length > MAX_ARCHIVE_ENTRIES) {
+    throw new ImportSourceError({
+      code: "too-many-files",
+      limit: MAX_IMPORT_SOURCE_FILES
+    });
+  }
+  const root = commonRootFolder(entries.map((entry) => entry.name));
+  const selected = entries.map((entry) => ({ entry, path: entry.name.slice(root.length) })).filter(({ path }) => PROJECT_SOURCE_PATH.test(path)).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  if (selected.length > MAX_IMPORT_SOURCE_FILES) {
+    throw new ImportSourceError({
+      code: "too-many-files",
+      limit: MAX_IMPORT_SOURCE_FILES
+    });
+  }
+  if (!selected.some(({ path }) => isTypeScriptModule(path))) {
+    const python = entries.some(
+      (entry) => PYTHON_MODULE_PATH.test(entry.name.slice(root.length))
+    );
+    throw new ImportSourceError({
+      code: python ? "python-needs-cli" : "no-module"
+    });
+  }
+  const files = [];
+  let bytes = 0;
+  for (const { entry, path } of selected) {
+    const content = await entry.async("string");
+    bytes += utf8Length(content);
+    assertImportByteSize(bytes, MAX_IMPORT_SOURCE_BYTES);
+    files.push({ path, content });
+  }
+  return files;
+}
+function commonRootFolder(names) {
+  const first = names[0];
+  if (!first) return "";
+  const head = first.split("/", 1)[0];
+  if (head === first || head === "workflows" || head === ".fluidgrids")
+    return "";
+  const prefix = `${head}/`;
+  return names.every((name) => name.startsWith(prefix)) ? prefix : "";
+}
+function typeScriptImportSource(files) {
+  return {
+    format: "TYPESCRIPT" /* Typescript */,
+    files: files.map((file) => ({ path: file.path, content: file.content }))
+  };
+}
+function primaryImportModule(files) {
+  return files.find((file) => isTypeScriptModule(file.path)) ?? null;
+}
+function workflowNameFromFile(fileName) {
+  const stem = fileBaseName(fileName).replace(/\.(ts|zip)$/i, "").replace(/[-_.]+/g, " ").trim();
+  if (!stem) return "Imported workflow";
+  return stem.charAt(0).toUpperCase() + stem.slice(1);
+}
+var WORKFLOW_BODY_START = /\(wf\)\s*=>\s*\{|^\s*def\s+\w+\(wf\)\s*:/;
+function lineOfNode(source, nodeId) {
+  const escaped = nodeId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`\\bid\\s*[:=]\\s*["']${escaped}["']`);
+  const lines = source.split("\n");
+  const bodyStart = Math.max(
+    0,
+    lines.findIndex((line) => WORKFLOW_BODY_START.test(line))
+  );
+  for (let index = bodyStart; index < lines.length; index += 1) {
+    if (pattern.test(lines[index])) return index + 1;
+  }
+  return null;
+}
+
+// src/hooks/useWorkflowCodeExport.ts
+async function fetchWorkflowCodeExport(target) {
+  const result = await getFluidGridsClient().query({
+    query: ExportWorkflowCodeDocument,
+    variables: {
+      workflowKey: target.workflowKey,
+      version: target.version || null,
+      // The service defaults (connection ids kept, layout sidecar on, pinned
+      // data off) are what the builder wants, so no options are sent.
+      format: target.format
+    },
+    fetchPolicy: "network-only"
+  });
+  throwIfResultError(result);
+  const exported = result.data?.exportWorkflow;
+  if (!exported) throw new Error("The export returned no result");
+  return exported;
+}
+function useWorkflowCodeExport(target, enabled) {
+  const { workflowKey, version, format } = target;
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const request = useRef(0);
+  const refetch = useCallback(async () => {
+    if (!workflowKey) return;
+    const id = ++request.current;
+    setLoading(true);
+    setError(null);
+    try {
+      const exported = await fetchWorkflowCodeExport({
+        workflowKey,
+        version,
+        format
+      });
+      if (id === request.current) setData(exported);
+    } catch (err) {
+      if (id === request.current) {
+        setData(null);
+        setError(describeOperationError(err, "The export failed"));
+      }
+    } finally {
+      if (id === request.current) setLoading(false);
+    }
+  }, [workflowKey, version, format]);
+  useEffect(() => {
+    if (!enabled) return;
+    setData(null);
+    void refetch();
+  }, [enabled, refetch]);
+  return { data, loading, error, refetch };
+}
+async function downloadWorkflowCodeExport(exported, format, save = downloadBlob) {
+  const { filename, blob } = await buildExportDownload(exported, format);
+  save(filename, blob);
+}
+function useExportWorkflowAs(save = downloadBlob) {
+  const [exporting, setExporting] = useState(null);
+  const exportAs = useCallback(
+    async (target) => {
+      setExporting(target.format);
+      try {
+        const exported = await fetchWorkflowCodeExport(target);
+        await downloadWorkflowCodeExport(exported, target.format, save);
+        return exported;
+      } finally {
+        setExporting(null);
+      }
+    },
+    [save]
+  );
+  return { exportAs, exporting };
+}
+function QuotaExhaustedDialog({
+  open,
+  onOpenChange,
+  onUpgrade,
+  title,
+  description,
+  surface,
+  limitHit = true
+}) {
+  const tr = useTr();
+  const { bus, workspaceId } = useFluidGridsAnalytics();
+  const wasOpen = useRef(false);
+  useEffect(() => {
+    if (open && !wasOpen.current && limitHit) {
+      emitWorkflowLimitHit(bus, { workspaceId, surface });
+    }
+    wasOpen.current = open;
+  }, [open, bus, workspaceId, surface, limitHit]);
+  const handleUpgrade = () => {
+    emitUpgradeClicked(bus, {
+      workspaceId,
+      surface: "quota-dialog",
+      quotaKey: WORKFLOWS_QUOTA_NAME
+    });
+    onUpgrade();
+  };
+  const resolvedTitle = title ?? tr(
+    "fluidgrids.components.quotaExhaustedDialog.title",
+    "Workflow Limit Reached"
+  );
+  const resolvedDescription = description ?? tr(
+    "fluidgrids.components.quotaExhaustedDialog.description",
+    "You've reached the workflow limit for your plan. Upgrade your plan to create more workflows."
+  );
+  return /* @__PURE__ */ jsx(AlertDialog, { open, onOpenChange, children: /* @__PURE__ */ jsxs(AlertDialogContent, { children: [
+    /* @__PURE__ */ jsxs(AlertDialogHeader, { children: [
+      /* @__PURE__ */ jsx(AlertDialogTitle, { children: resolvedTitle }),
+      /* @__PURE__ */ jsx(AlertDialogDescription, { children: resolvedDescription })
+    ] }),
+    /* @__PURE__ */ jsxs(AlertDialogFooter, { children: [
+      /* @__PURE__ */ jsx(AlertDialogCancel, { children: tr(
+        "fluidgrids.components.quotaExhaustedDialog.dismiss",
+        "Dismiss"
+      ) }),
+      /* @__PURE__ */ jsx(AlertDialogAction, { onClick: handleUpgrade, children: tr(
+        "fluidgrids.components.quotaExhaustedDialog.viewPlans",
+        "View plans"
+      ) })
+    ] })
+  ] }) });
+}
+
+export { CODE_EXPORT_FORMATS, ImportSourceError, MAX_IMPORT_ARCHIVE_BYTES, MAX_IMPORT_SOURCE_BYTES, QuotaExhaustedDialog, assertImportByteSize, checkTypeScriptImport, downloadWorkflowCodeExport, downloadWorkflowExport, fileBaseName, importAcceptAttribute, importFileKind, isLosslessReport, isLossyFidelityItem, lineOfNode, orderedExportFiles, parseWorkflowImport, primaryImportModule, readProjectArchive, sortFidelityItems, typeScriptImportSource, typeScriptModuleFile, useExportWorkflowAs, useWorkflowCodeExport, workflowNameFromFile };

package/dist/{chunk-6NUHJPGJ.js → chunk-NVUJFHTQ.js}

@@ -2,7 +2,7 @@ import { cn as cn$1 } from './chunk-JL7CASN5.js';
 import { getGlobalStoreClient, createGlobalStoreClient, setGlobalStoreClient, resetGlobalStoreClient } from './chunk-PXIFUMLA.js';
 import { getFluidGridsConfig, validateTrustedOrigin, resetFluidGridsExecutionState, setFluidGridsConfig, resetFluidGridsConfig } from './chunk-CY6KX4RG.js';
 import { GetMyNodeInstallationsDocument } from './chunk-JUUYPCFY.js';
-import { fetchAllNodeEndpointConfigs, NodeManifestDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, ExecuteStepDocument, TriggerWorkflowDocument, RunFromNodeDocument, ExecutionDetailDocument, WorkflowDefinitionDocument, WorkflowRunDocument } from './chunk-6J4RR46J.js';
+import { fetchAllNodeEndpointConfigs, NodeManifestDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, ExecuteStepDocument, TriggerWorkflowDocument, RunFromNodeDocument, ExecutionDetailDocument, WorkflowDefinitionDocument, WorkflowRunDocument } from './chunk-7PBOU7JC.js';
 import { useTr, ENGLISH_FALLBACK_TRANSLATOR, FluidGridsTranslationProvider } from './chunk-UULVIT25.js';
 import { waitForFluidGridsClient, getFluidGridsClient, getFluidGridsClientSafe, createFluidGridsClient, setFluidGridsClient, resetFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { CombinedGraphQLErrors, ServerError } from '@apollo/client/errors';

package/dist/{chunk-27XYEFCK.js → chunk-OAFNNQN7.js}

@@ -1,4 +1,4 @@
-import { QuotaExhaustedDialog } from './chunk-HDUCP6EO.js';
+import { QuotaExhaustedDialog } from './chunk-M62CJVTR.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { jsx } from 'react/jsx-runtime';
 

package/dist/{chunk-IRKB2GGJ.js → chunk-OYFBLD5F.js}

@@ -1,6 +1,6 @@
-import { FailureTriagePanel } from './chunk-MUOJVRW7.js';
-import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-T7TRJBCG.js';
-import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-6NUHJPGJ.js';
+import { FailureTriagePanel } from './chunk-SQ6VSXFI.js';
+import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-VFPIMW52.js';
+import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-NVUJFHTQ.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useMemo, useEffect } from 'react';
 import { Icon } from '@iconify/react';