@burdenoff/fluidgrids-fe-sdk 2026.1101.1 → 2026.1101.2

package/dist/{chunk-3M36XWAH.js → chunk-IGRIN7NL.js}

@@ -1,7 +1,7 @@
-import { FailureTriagePanel } from './chunk-ALFMJSD6.js';
-import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-RIHYPPMQ.js';
+import { FailureTriagePanel } from './chunk-H7XPXONT.js';
+import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-NLYQ3XDE.js';
 import { proposalCanvasPath } from './chunk-GLYINMOR.js';
-import { useContinuousOptimisationEnabled, throwIfResultError } from './chunk-6ILIBJFH.js';
+import { useContinuousOptimisationEnabled, throwIfResultError } from './chunk-NZJWKVER.js';
 import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-ZUVFD5KV.js';
 import { SetContinuousOptimisationEnabledDocument, FgRunOptimisationScanDocument, ProposeOptimisationDocument, WorkflowProposalDocument, DismissOptimisationSuggestionDocument, SnoozeOptimisationSuggestionDocument, OptimisationSuggestionsDocument, ContinuousOptimisationSettingsDocument } from './chunk-IHEV5HTD.js';
 import { useTr } from './chunk-UULVIT25.js';
@@ -420,12 +420,13 @@ function useContinuousOptimisation(active) {
       if (refetchToken === refetchRef.current) setLoading(false);
     }
   }, [loadSuggestions]);
+  const invalidateLoads = useCallback(() => {
+    loadRef.current += 1;
+  }, []);
   useEffect(() => {
     void refetch();
-    return () => {
-      loadRef.current++;
-    };
-  }, [active, refetch]);
+    return invalidateLoads;
+  }, [active, refetch, invalidateLoads]);
   const setEnabled = useCallback(
     async (enabled) => {
       const load = ++loadRef.current;

package/dist/chunk-JDLQ6QIB.js

@@ -0,0 +1,283 @@
+// src/builder/lib/assert-rules.ts
+var ASSERT_OPERATORS = [
+  {
+    wire: "equals",
+    value: "EQUALS" /* Equals */,
+    operand: "expected",
+    label: "equals"
+  },
+  {
+    wire: "notEquals",
+    value: "NOT_EQUALS" /* NotEquals */,
+    operand: "expected",
+    label: "does not equal"
+  },
+  {
+    wire: "contains",
+    value: "CONTAINS" /* Contains */,
+    operand: "expected",
+    label: "contains"
+  },
+  {
+    wire: "notContains",
+    value: "NOT_CONTAINS" /* NotContains */,
+    operand: "expected",
+    label: "does not contain"
+  },
+  {
+    wire: "matches",
+    value: "MATCHES" /* Matches */,
+    operand: "expected",
+    label: "matches regex"
+  },
+  {
+    wire: "jsonSchema",
+    value: "JSON_SCHEMA" /* JsonSchema */,
+    operand: "expected",
+    label: "matches JSON Schema"
+  },
+  {
+    wire: "between",
+    value: "BETWEEN" /* Between */,
+    operand: "range",
+    label: "is between"
+  },
+  {
+    wire: "itemCount",
+    value: "ITEM_COUNT" /* ItemCount */,
+    operand: "range",
+    label: "has item count"
+  },
+  {
+    wire: "exists",
+    value: "EXISTS" /* Exists */,
+    operand: "none",
+    label: "exists"
+  },
+  {
+    wire: "notExists",
+    value: "NOT_EXISTS" /* NotExists */,
+    operand: "none",
+    label: "does not exist"
+  }
+];
+var MAX_REGEX_LENGTH = 500;
+var MAX_RULES = 50;
+function operatorSpec(value) {
+  if (typeof value !== "string") return null;
+  return ASSERT_OPERATORS.find(
+    (spec) => spec.wire === value || spec.value === value
+  ) ?? null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalNumber(value) {
+  if (value === void 0 || value === null) return void 0;
+  return typeof value === "number" && Number.isFinite(value) ? value : false;
+}
+function normaliseAssertRule(raw, index) {
+  if (!isRecord(raw)) return { problem: { code: "notObject", index } };
+  const spec = operatorSpec(raw.operator);
+  if (!spec)
+    return {
+      problem: {
+        code: "unknownOperator",
+        index,
+        operator: String(raw.operator ?? "")
+      }
+    };
+  const rule = { operator: spec.wire };
+  if (raw.path !== void 0 && raw.path !== null && raw.path !== "") {
+    if (typeof raw.path !== "string")
+      return { problem: { code: "pathInvalid", index } };
+    rule.path = raw.path;
+  }
+  if (raw.message !== void 0 && raw.message !== null && raw.message !== "") {
+    if (typeof raw.message !== "string")
+      return { problem: { code: "messageInvalid", index } };
+    rule.message = raw.message;
+  }
+  if (spec.operand === "expected") {
+    if (!("expected" in raw))
+      return { problem: { code: "expectedRequired", index } };
+    if (spec.wire === "matches") {
+      if (typeof raw.expected !== "string")
+        return { problem: { code: "regexInvalid", index } };
+      if (raw.expected.length > MAX_REGEX_LENGTH)
+        return { problem: { code: "regexTooLong", index } };
+      try {
+        new RegExp(raw.expected);
+      } catch {
+        return { problem: { code: "regexInvalid", index } };
+      }
+    }
+    if (spec.wire === "jsonSchema" && !isRecord(raw.expected))
+      return { problem: { code: "schemaInvalid", index } };
+    rule.expected = raw.expected;
+  }
+  if (spec.operand === "range") {
+    const min = optionalNumber(raw.min);
+    const max = optionalNumber(raw.max);
+    if (min === false || max === false)
+      return { problem: { code: "rangeInvalid", index } };
+    if (min === void 0 && max === void 0)
+      return { problem: { code: "rangeRequired", index } };
+    if (min !== void 0 && max !== void 0 && min > max)
+      return { problem: { code: "rangeInvalid", index } };
+    if (min !== void 0) rule.min = min;
+    if (max !== void 0) rule.max = max;
+  }
+  return { rule };
+}
+function normaliseAssertRules(raw) {
+  if (raw.length === 0) return { problem: { code: "empty" } };
+  if (raw.length > MAX_RULES)
+    return { problem: { code: "tooMany", count: raw.length } };
+  const rules = [];
+  for (const [index, item] of raw.entries()) {
+    const result = normaliseAssertRule(item, index);
+    if ("problem" in result) return result;
+    rules.push(result.rule);
+  }
+  return { rules };
+}
+function describeAssertRuleProblem(problem) {
+  const at = "index" in problem ? `Rule ${problem.index + 1}: ` : "";
+  switch (problem.code) {
+    case "notObject":
+      return {
+        key: "fluidgrids.builder.assertRules.notObject",
+        fallback: `${at}a rule must be an object.`
+      };
+    case "unknownOperator":
+      return {
+        key: "fluidgrids.builder.assertRules.unknownOperator",
+        fallback: `${at}unknown operator "${problem.operator}". Use ${ASSERT_OPERATORS.map((spec) => spec.wire).join(", ")}.`
+      };
+    case "expectedRequired":
+      return {
+        key: "fluidgrids.builder.assertRules.expectedRequired",
+        fallback: `${at}this operator needs an expected value.`
+      };
+    case "rangeRequired":
+      return {
+        key: "fluidgrids.builder.assertRules.rangeRequired",
+        fallback: `${at}set a minimum, a maximum or both.`
+      };
+    case "rangeInvalid":
+      return {
+        key: "fluidgrids.builder.assertRules.rangeInvalid",
+        fallback: `${at}minimum and maximum must be numbers, with the minimum not above the maximum.`
+      };
+    case "regexInvalid":
+      return {
+        key: "fluidgrids.builder.assertRules.regexInvalid",
+        fallback: `${at}the expected value is not a valid regular expression.`
+      };
+    case "regexTooLong":
+      return {
+        key: "fluidgrids.builder.assertRules.regexTooLong",
+        fallback: `${at}a regular expression may have at most ${MAX_REGEX_LENGTH} characters.`
+      };
+    case "schemaInvalid":
+      return {
+        key: "fluidgrids.builder.assertRules.schemaInvalid",
+        fallback: `${at}the expected value must be a JSON Schema object.`
+      };
+    case "pathInvalid":
+      return {
+        key: "fluidgrids.builder.assertRules.pathInvalid",
+        fallback: `${at}the path must be text.`
+      };
+    case "messageInvalid":
+      return {
+        key: "fluidgrids.builder.assertRules.messageInvalid",
+        fallback: `${at}the message must be text.`
+      };
+    case "tooMany":
+      return {
+        key: "fluidgrids.builder.assertRules.tooMany",
+        fallback: `At most ${MAX_RULES} rules (found ${problem.count}).`
+      };
+    case "empty":
+      return {
+        key: "fluidgrids.builder.assertRules.empty",
+        fallback: "Add at least one rule."
+      };
+  }
+}
+function readAssertRulesSetting(value) {
+  if (value === void 0 || value === null || value === "") return [];
+  if (Array.isArray(value)) return value;
+  if (typeof value !== "string") return null;
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function emptyAssertRuleRow() {
+  return {
+    path: "",
+    operator: "equals",
+    expected: "",
+    min: "",
+    max: "",
+    message: ""
+  };
+}
+function rowNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : "";
+}
+function rowExpected(operator, value) {
+  if (value === void 0) return "";
+  if (operator === "matches" && typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function rowsFromRules(rules) {
+  return rules.map((raw) => {
+    const rule = isRecord(raw) ? raw : {};
+    const operator = operatorSpec(rule.operator)?.wire ?? (typeof rule.operator === "string" ? rule.operator : "equals");
+    return {
+      path: typeof rule.path === "string" ? rule.path : "",
+      operator,
+      expected: rowExpected(operator, rule.expected),
+      min: rowNumber(rule.min),
+      max: rowNumber(rule.max),
+      message: typeof rule.message === "string" ? rule.message : ""
+    };
+  });
+}
+function parseExpected(operator, text) {
+  if (operator === "matches") return text;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function parseRowNumber(text) {
+  const trimmed = text.trim();
+  if (trimmed === "") return void 0;
+  const value = Number(trimmed);
+  return Number.isFinite(value) ? value : trimmed;
+}
+function ruleFromRow(row) {
+  const spec = operatorSpec(row.operator);
+  const rule = { operator: row.operator };
+  if (row.path.trim()) rule.path = row.path.trim();
+  if (spec?.operand === "expected" && (row.expected !== "" || spec.wire === "matches"))
+    rule.expected = parseExpected(spec.wire, row.expected);
+  if (spec?.operand === "range") {
+    const min = parseRowNumber(row.min);
+    const max = parseRowNumber(row.max);
+    if (min !== void 0) rule.min = min;
+    if (max !== void 0) rule.max = max;
+  }
+  if (row.message.trim()) rule.message = row.message.trim();
+  return rule;
+}
+
+export { ASSERT_OPERATORS, describeAssertRuleProblem, emptyAssertRuleRow, normaliseAssertRules, operatorSpec, readAssertRulesSetting, rowsFromRules, ruleFromRow };

package/dist/{chunk-AD7BICOT.js → chunk-JKBCLBHY.js}

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

package/dist/{chunk-6JX5UPDW.js → chunk-JNZCXFLD.js}

@@ -1,5 +1,5 @@
 import { historyControls } from './chunk-FNZZ5JJL.js';
-import { useWorkflowDefinitions } from './chunk-SEFOT2LD.js';
+import { useWorkflowDefinitions } from './chunk-LWLHPVIA.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
 import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';

package/dist/{chunk-SEFOT2LD.js → chunk-LWLHPVIA.js}

@@ -1,4 +1,4 @@
-import { useFluidGridsAnalytics, throwIfResultError, emitWorkflowCreated, emitRunStarted, runTriggerFromMode, openRunQuotaUpgradePrompt, emitWorkflowPublished } from './chunk-6ILIBJFH.js';
+import { useFluidGridsAnalytics, throwIfResultError, emitWorkflowCreated, emitRunStarted, runTriggerFromMode, openRunQuotaUpgradePrompt, emitWorkflowPublished } from './chunk-NZJWKVER.js';
 import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';
 import { WorkflowDefinitionsDocument, WorkflowDefinitionDocument, WorkflowVersionsDocument, CreateWorkflowDefinitionDocument, ImportWorkflowDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, DeleteWorkflowDefinitionDocument, DuplicateWorkflowDocument, RestoreWorkflowVersionDocument, TriggerWorkflowDocument, WorkflowRunsDocument, WorkflowRunDocument, DashboardSummaryDocument, ActivateWorkflowDefinitionDocument, DeactivateWorkflowDefinitionDocument } from './chunk-IHEV5HTD.js';
 import { useTr } from './chunk-UULVIT25.js';

package/dist/{chunk-JWROEOG5.js → chunk-LYTR6IQO.js}

@@ -1,47 +1,10 @@
 import { REPLAY_WORKFLOW_RUN, RETRY_WORKFLOW_RUNS } from './chunk-5ERAJC2I.js';
-import { useFluidGridsAnalytics, throwIfResultError, emitRunStarted, openRunQuotaUpgradePrompt } from './chunk-6ILIBJFH.js';
+import { useFluidGridsAnalytics, throwIfResultError, emitRunStarted, openRunQuotaUpgradePrompt } from './chunk-NZJWKVER.js';
 import { useExecutionsStore } from './chunk-6AMNEX2Y.js';
 import { ExecutionsListDocument, ExecutionDetailDocument, ExecutionStatsDocument, PauseExecutionDocument, ResumeExecutionDocument, CancelExecutionDocument, RetryNodeDocument, TriggerWorkflowDocument, TerminateExecutionDocument } from './chunk-IHEV5HTD.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
-import { gql } from '@apollo/client';
-
-gql`
-  subscription NodeStateUpdated($runId: String!) {
-    _empty
-  }
-`;
-gql`
-  subscription WorkflowCompleted($runId: String!) {
-    _empty
-  }
-`;
-gql`
-  subscription WorkflowError($runId: String!) {
-    _empty
-  }
-`;
-gql`
-  subscription ExecutionUpdated($runId: String!) {
-    _empty
-  }
-`;
-gql`
-  subscription ExecutionNodeStateUpdated($runId: String!) {
-    _empty
-  }
-`;
-gql`
-  subscription ExecutionCompleted($runId: String!) {
-    _empty
-  }
-`;
-gql`
-  subscription ExecutionError($runId: String!) {
-    _empty
-  }
-`;
 
 // src/modules/executions/utils/date-range.ts
 function toDate(value) {