@burdenoff/fluidgrids-fe-sdk 2026.1028.4 → 2026.1028.5

package/dist/{ExecutionDetailPage-MYBCDBV7.js → ExecutionDetailPage-UFB7VMGE.js}

@@ -1,6 +1,7 @@
-export { ExecutionDetailPage } from './chunk-CPEIOFYR.js';
+export { ExecutionDetailPage } from './chunk-S4VYW4BR.js';
 import './chunk-SSJIK6WS.js';
 import './chunk-UUUDSVC7.js';
+import './chunk-VUVTOUQ5.js';
 import './chunk-5ERAJC2I.js';
 import './chunk-JAKWVVVQ.js';
 import './chunk-QGXA2USP.js';

package/dist/{chunk-CPEIOFYR.js → chunk-S4VYW4BR.js}

@@ -1,5 +1,6 @@
 import { buildNodeDisplayMap, ExecutionStatusBadge, formatRunVersion, NodeTimeline, RunLogViewer } from './chunk-SSJIK6WS.js';
 import { useExecution, useExecutionActions, useAutoRefresh } from './chunk-UUUDSVC7.js';
+import { useRunPolicyDecisions, RunPolicyDecisions } from './chunk-VUVTOUQ5.js';
 import { EntityTagPicker, useWorkflowProposal, WorkflowProposalCard } from './chunk-JAKWVVVQ.js';
 import { throwIfResultError, useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-5LKZ4PNK.js';
 import { getFluidGridsConfig } from './chunk-CY6KX4RG.js';
@@ -952,6 +953,9 @@ function ExecutionDetailPage() {
   } = useRunHumanRequests(runId, {
     pollIntervalMs: runCanChange ? 1e4 : 0
   });
+  const { decisions: policyDecisions, decide: decidePolicyApproval } = useRunPolicyDecisions(runId, {
+    pollIntervalMs: runCanChange ? 1e4 : 0
+  });
   const awaitingPerson = humanRequests.some(
     (request) => request.status === "PENDING"
   );
@@ -1537,6 +1541,17 @@ function ExecutionDetailPage() {
     /* @__PURE__ */ jsx(RunQueuedBanner, { status: execution.status, context: execution.context }),
     /* @__PURE__ */ jsx(RunDataPrunedNotice, { dataPrunedAt: execution.dataPrunedAt }),
     /* @__PURE__ */ jsx(RunHumanRequests, { requests: humanRequests }),
+    /* @__PURE__ */ jsx(
+      RunPolicyDecisions,
+      {
+        decisions: policyDecisions,
+        waiting: execution.status === "WAITING",
+        onDecide: async (id, approve) => {
+          await decidePolicyApproval(id, approve);
+          await Promise.all([refetch(), refetchHumanRequests()]);
+        }
+      }
+    ),
     /* @__PURE__ */ jsx("div", { className: "border-b border-border-secondary mb-6", children: /* @__PURE__ */ jsx("nav", { className: "flex gap-4 -mb-px", children: tabs.map((tab) => /* @__PURE__ */ jsxs(
       "button",
       {

package/dist/chunk-VUVTOUQ5.js

@@ -0,0 +1,1201 @@
+import { throwIfResultError, describeOperationError } from './chunk-5LKZ4PNK.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import { gql } from '@apollo/client';
+import { Button } from '@burdenoff/fe-libs/button';
+import { toast } from 'sonner';
+import { Badge, Label, Input, Switch } from '@burdenoff/fe-libs/ui';
+import { cn } from '@burdenoff/fe-libs/utils';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Icon } from '@iconify/react';
+
+var POLICY_FIELDS = `
+  id
+  name
+  description
+  enabled
+  priority
+  effect
+  matcher { nodeTypes operations connectionProviders workflowTags }
+  condition
+  environments
+  updatedAt
+`;
+var APPROVAL_FIELDS = `
+  id
+  runId
+  nodeId
+  workflowKey
+  policyName
+  nodeType
+  operation
+  environment
+  reason
+  payloadHash
+  status
+  decision
+  expiresAt
+  createdAt
+`;
+var ACTION_POLICIES = gql`
+  query ActionPolicies {
+    actionPolicies {
+      ${POLICY_FIELDS}
+    }
+  }
+`;
+var UPSERT_ACTION_POLICY = gql`
+  mutation UpsertActionPolicy($input: ActionPolicyInput!) {
+    upsertActionPolicy(input: $input) {
+      ${POLICY_FIELDS}
+    }
+  }
+`;
+var DELETE_ACTION_POLICY = gql`
+  mutation DeleteActionPolicy($id: ID!) {
+    deleteActionPolicy(id: $id)
+  }
+`;
+var DRY_RUN_ACTION_POLICY = gql`
+  query DryRunActionPolicy($input: ActionPolicyDryRunInput!) {
+    dryRunActionPolicy(input: $input) {
+      runsScanned
+      actionsEvaluated
+      wouldAllow
+      wouldLog
+      wouldRequireApproval
+      wouldDeny
+      changed
+      runsAffected
+      rows {
+        runId
+        workflowKey
+        runCreatedAt
+        nodeId
+        nodeType
+        operation
+        environment
+        currentEffect
+        effect
+        reason
+        policyName
+        changed
+      }
+    }
+  }
+`;
+var PENDING_APPROVALS = gql`
+  query PendingActionPolicyApprovals($limit: Int) {
+    pendingActionPolicyApprovals(limit: $limit) {
+      ${APPROVAL_FIELDS}
+    }
+  }
+`;
+var DECIDE_APPROVAL = gql`
+  mutation DecideActionPolicyApproval($id: ID!, $approve: Boolean!) {
+    decideActionPolicyApproval(id: $id, approve: $approve) {
+      ${APPROVAL_FIELDS}
+    }
+  }
+`;
+var RUN_DECISIONS = gql`
+  query ActionPolicyDecisions($runId: ID!) {
+    actionPolicyDecisions(runId: $runId) {
+      id
+      nodeId
+      nodeType
+      operation
+      environment
+      effect
+      policyName
+      reason
+      payloadHash
+      approvalRequestId
+      consumedAt
+      createdAt
+    }
+  }
+`;
+function asError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
+function useActionPolicies() {
+  const [policies, setPolicies] = useState([]);
+  const [approvals, setApprovals] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const reload = useCallback(async () => {
+    try {
+      const client = getFluidGridsClient();
+      const [policyResult, approvalResult] = await Promise.all([
+        client.query({
+          query: ACTION_POLICIES,
+          fetchPolicy: "network-only"
+        }),
+        client.query({
+          query: PENDING_APPROVALS,
+          variables: { limit: 50 },
+          fetchPolicy: "network-only"
+        })
+      ]);
+      throwIfResultError(policyResult);
+      throwIfResultError(approvalResult);
+      setPolicies(policyResult.data?.actionPolicies ?? []);
+      setApprovals(approvalResult.data?.pendingActionPolicyApprovals ?? []);
+      setError(null);
+    } catch (err) {
+      setError(asError(err));
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    void reload();
+  }, [reload]);
+  const save = useCallback(
+    async (input) => {
+      const result = await getFluidGridsClient().mutate({ mutation: UPSERT_ACTION_POLICY, variables: { input } });
+      throwIfResultError(result);
+      await reload();
+      return result.data?.upsertActionPolicy ?? null;
+    },
+    [reload]
+  );
+  const remove = useCallback(
+    async (id) => {
+      const result = await getFluidGridsClient().mutate({ mutation: DELETE_ACTION_POLICY, variables: { id } });
+      throwIfResultError(result);
+      await reload();
+    },
+    [reload]
+  );
+  const dryRun = useCallback(
+    async (input) => {
+      const result = await getFluidGridsClient().query({
+        query: DRY_RUN_ACTION_POLICY,
+        variables: { input: { ...input, runLimit: 100 } },
+        fetchPolicy: "network-only"
+      });
+      throwIfResultError(result);
+      const data = result.data?.dryRunActionPolicy;
+      if (!data) throw new Error("No dry-run result returned");
+      return data;
+    },
+    []
+  );
+  const decide = useCallback(
+    async (id, approve) => {
+      const result = await getFluidGridsClient().mutate({ mutation: DECIDE_APPROVAL, variables: { id, approve } });
+      throwIfResultError(result);
+      await reload();
+    },
+    [reload]
+  );
+  return {
+    policies,
+    approvals,
+    loading,
+    error,
+    reload,
+    save,
+    remove,
+    dryRun,
+    decide
+  };
+}
+function useRunPolicyDecisions(runId, options) {
+  const [decisions, setDecisions] = useState([]);
+  const pollIntervalMs = options?.pollIntervalMs ?? 0;
+  const load = useCallback(async () => {
+    if (!runId) return;
+    try {
+      const result = await getFluidGridsClient().query({
+        query: RUN_DECISIONS,
+        variables: { runId },
+        fetchPolicy: "network-only"
+      });
+      throwIfResultError(result);
+      setDecisions(result.data?.actionPolicyDecisions ?? []);
+    } catch {
+      setDecisions([]);
+    }
+  }, [runId]);
+  useEffect(() => {
+    void load();
+    if (!pollIntervalMs) return;
+    const timer = setInterval(() => void load(), pollIntervalMs);
+    return () => clearInterval(timer);
+  }, [load, pollIntervalMs]);
+  const decide = useCallback(
+    async (id, approve) => {
+      const result = await getFluidGridsClient().mutate({
+        mutation: DECIDE_APPROVAL,
+        variables: { id, approve }
+      });
+      throwIfResultError(result);
+      await load();
+    },
+    [load]
+  );
+  return { decisions, reload: load, decide };
+}
+var EFFECT_CLASSES = {
+  ALLOW: "bg-status-success-bg-subtle text-status-success-text border-status-success-border",
+  LOG: "bg-status-info-bg-subtle text-status-info-text border-status-info-border",
+  REQUIRE_APPROVAL: "bg-status-warning-bg-subtle text-status-warning-text border-status-warning-border",
+  DENY: "bg-status-error-bg-subtle text-status-error-text border-status-error-border"
+};
+function effectLabel(effect, tr) {
+  switch (effect) {
+    case "ALLOW":
+      return tr("fluidgrids.actionPolicies.effect.allow", "Allow");
+    case "LOG":
+      return tr("fluidgrids.actionPolicies.effect.log", "Log");
+    case "REQUIRE_APPROVAL":
+      return tr(
+        "fluidgrids.actionPolicies.effect.requireApproval",
+        "Require approval"
+      );
+    default:
+      return tr("fluidgrids.actionPolicies.effect.deny", "Deny");
+  }
+}
+function EffectBadge({
+  effect,
+  className
+}) {
+  const tr = useTr();
+  return /* @__PURE__ */ jsx(
+    Badge,
+    {
+      variant: "outline",
+      className: cn("text-xs", EFFECT_CLASSES[effect], className),
+      children: effectLabel(effect, tr)
+    }
+  );
+}
+function RunPolicyDecisions({
+  decisions,
+  waiting,
+  onDecide
+}) {
+  const tr = useTr();
+  const [busy, setBusy] = useState(null);
+  if (decisions.length === 0) return null;
+  const latestHeld = [...decisions].reverse().find((decision) => decision.effect === "REQUIRE_APPROVAL");
+  const held = waiting && latestHeld?.approvalRequestId && !latestHeld.consumedAt ? latestHeld : null;
+  const decide = async (approve) => {
+    if (!held?.approvalRequestId) return;
+    setBusy(held.approvalRequestId);
+    try {
+      await onDecide(held.approvalRequestId, approve);
+      toast.success(
+        approve ? tr(
+          "fluidgrids.actionPolicies.approved",
+          "Approved \u2014 the run continues"
+        ) : tr(
+          "fluidgrids.actionPolicies.declined",
+          "Declined \u2014 the node fails"
+        )
+      );
+    } catch (err) {
+      toast.error(describeOperationError(err));
+    } finally {
+      setBusy(null);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "mb-6 rounded-lg border border-border-secondary bg-background-secondary p-4",
+      "data-testid": "run-policy-decisions",
+      children: [
+        /* @__PURE__ */ jsx("h3", { className: "mb-2 text-sm font-semibold text-text-primary", children: tr("fluidgrids.actionPolicies.runTitle", "Action policies") }),
+        /* @__PURE__ */ jsx("ul", { className: "space-y-1.5", children: decisions.map((decision) => /* @__PURE__ */ jsxs(
+          "li",
+          {
+            className: "flex flex-wrap items-center gap-2 text-sm text-text-primary",
+            children: [
+              /* @__PURE__ */ jsx(EffectBadge, { effect: decision.effect }),
+              /* @__PURE__ */ jsx("span", { className: "font-medium", children: decision.nodeId }),
+              /* @__PURE__ */ jsxs("span", { className: "text-xs text-text-secondary", children: [
+                decision.policyName ?? tr(
+                  "fluidgrids.actionPolicies.defaultDeny",
+                  "default deny"
+                ),
+                " ",
+                "\xB7 ",
+                decision.reason,
+                " \xB7 ",
+                decision.environment
+              ] })
+            ]
+          },
+          decision.id
+        )) }),
+        held ? /* @__PURE__ */ jsxs("div", { className: "mt-3 flex flex-wrap items-center gap-2", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-xs text-status-warning-text", children: tr(
+            "fluidgrids.actionPolicies.heldHint",
+            "{{node}} is waiting for a workspace admin. Approving runs exactly the held payload.",
+            { node: held.nodeId }
+          ) }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              disabled: busy !== null,
+              onClick: () => decide(true),
+              children: tr("fluidgrids.actionPolicies.approve", "Approve")
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              disabled: busy !== null,
+              onClick: () => decide(false),
+              children: tr("fluidgrids.actionPolicies.decline", "Decline")
+            }
+          )
+        ] }) : null
+      ]
+    }
+  );
+}
+
+// src/modules/action-policies/utils/policy-form.ts
+var POLICY_EFFECTS = [
+  "REQUIRE_APPROVAL",
+  "DENY",
+  "ALLOW",
+  "LOG"
+];
+var POLICY_ENVIRONMENTS = [
+  "DEV",
+  "STAGING",
+  "PROD"
+];
+var CONDITION_OPERATORS = [
+  { value: "gt", label: "is greater than", kind: "number" },
+  { value: "gte", label: "is at least", kind: "number" },
+  { value: "lt", label: "is less than", kind: "number" },
+  { value: "lte", label: "is at most", kind: "number" },
+  { value: "eq", label: "equals", kind: "single" },
+  { value: "neq", label: "does not equal", kind: "single" },
+  { value: "in", label: "is one of", kind: "list" },
+  { value: "not_in", label: "is not one of", kind: "list" },
+  { value: "contains", label: "contains", kind: "single" },
+  { value: "count_gt", label: "has more items than", kind: "number" },
+  { value: "count_gte", label: "has at least \u2026 items", kind: "number" },
+  { value: "count_lt", label: "has fewer items than", kind: "number" },
+  { value: "count_lte", label: "has at most \u2026 items", kind: "number" },
+  { value: "exists", label: "is set", kind: "none" },
+  { value: "not_exists", label: "is not set", kind: "none" }
+];
+var PolicyFormError = class extends Error {
+};
+var OPERATOR_KIND = new Map(
+  CONDITION_OPERATORS.map((operator) => [operator.value, operator.kind])
+);
+function operatorKind(op) {
+  return OPERATOR_KIND.get(op) ?? "single";
+}
+function emptyPolicyForm() {
+  return {
+    name: "",
+    description: "",
+    enabled: true,
+    priority: "100",
+    effect: "REQUIRE_APPROVAL",
+    nodeTypes: "",
+    operations: "",
+    connectionProviders: "",
+    workflowTags: "",
+    environments: ["PROD"],
+    join: "all",
+    rows: []
+  };
+}
+function splitList(text) {
+  return [
+    ...new Set(
+      text.split(",").map((item) => item.trim()).filter(Boolean)
+    )
+  ];
+}
+function parseScalar(text) {
+  const trimmed = text.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null") return null;
+  if (trimmed !== "" && Number.isFinite(Number(trimmed)))
+    return Number(trimmed);
+  return trimmed;
+}
+function formatScalar(value) {
+  if (value === null) return "null";
+  return String(value);
+}
+function rowToLeaf(row, index) {
+  const path = row.path.trim();
+  if (!path)
+    throw new PolicyFormError(`Condition ${index + 1} needs a parameter path`);
+  switch (operatorKind(row.op)) {
+    case "none":
+      return { path, op: row.op };
+    case "number": {
+      const value = Number(row.value.trim());
+      if (row.value.trim() === "" || !Number.isFinite(value))
+        throw new PolicyFormError(`Condition ${index + 1} needs a number`);
+      return { path, op: row.op, value };
+    }
+    case "list": {
+      const values = splitList(row.value).map(parseScalar);
+      if (values.length === 0)
+        throw new PolicyFormError(
+          `Condition ${index + 1} needs at least one value`
+        );
+      return { path, op: row.op, value: values };
+    }
+    default:
+      return { path, op: row.op, value: parseScalar(row.value) };
+  }
+}
+function formToInput(form) {
+  const name = form.name.trim();
+  if (!name) throw new PolicyFormError("Give the policy a name");
+  const priority = Number(form.priority);
+  if (!Number.isInteger(priority) || priority < 0 || priority > 1e5)
+    throw new PolicyFormError("Priority is a whole number from 0 to 100000");
+  const leaves = form.rows.map(rowToLeaf);
+  let condition = null;
+  if (leaves.length === 1) condition = leaves[0];
+  else if (leaves.length > 1) condition = { [form.join]: leaves };
+  return {
+    ...form.id ? { id: form.id } : {},
+    name,
+    description: form.description.trim() || null,
+    enabled: form.enabled,
+    priority,
+    effect: form.effect,
+    matcher: {
+      nodeTypes: splitList(form.nodeTypes),
+      operations: splitList(form.operations),
+      connectionProviders: splitList(form.connectionProviders),
+      workflowTags: splitList(form.workflowTags)
+    },
+    condition,
+    environments: form.environments
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function leafToRow(leaf) {
+  if (!isRecord(leaf) || typeof leaf.path !== "string") return null;
+  const op = String(leaf.op);
+  if (!OPERATOR_KIND.has(op)) return null;
+  const value = Array.isArray(leaf.value) ? leaf.value.map(formatScalar).join(", ") : leaf.value === void 0 ? "" : formatScalar(leaf.value);
+  return { path: leaf.path, op, value };
+}
+function policyToForm(policy) {
+  const base = {
+    id: policy.id,
+    name: policy.name,
+    description: policy.description ?? "",
+    enabled: policy.enabled,
+    priority: String(policy.priority),
+    effect: policy.effect,
+    nodeTypes: policy.matcher.nodeTypes.join(", "),
+    operations: policy.matcher.operations.join(", "),
+    connectionProviders: policy.matcher.connectionProviders.join(", "),
+    workflowTags: policy.matcher.workflowTags.join(", "),
+    environments: policy.environments,
+    join: "all",
+    rows: []
+  };
+  const condition = policy.condition;
+  if (condition === null || condition === void 0)
+    return { ...base, conditionEditable: true };
+  const single = leafToRow(condition);
+  if (single) return { ...base, rows: [single], conditionEditable: true };
+  if (isRecord(condition)) {
+    const join = Array.isArray(condition.all) ? "all" : Array.isArray(condition.any) ? "any" : null;
+    const children = join ? condition[join] : [];
+    const rows = children.map(leafToRow);
+    if (join && rows.every((row) => row !== null))
+      return { ...base, join, rows, conditionEditable: true };
+  }
+  return { ...base, conditionEditable: false };
+}
+function describePolicy(policy) {
+  const scope = [
+    policy.matcher.nodeTypes.length ? `nodes ${policy.matcher.nodeTypes.join(", ")}` : "",
+    policy.matcher.operations.length ? `operations ${policy.matcher.operations.join(", ")}` : "",
+    policy.matcher.connectionProviders.length ? `connections ${policy.matcher.connectionProviders.join(", ")}` : "",
+    policy.matcher.workflowTags.length ? `tagged ${policy.matcher.workflowTags.join(", ")}` : ""
+  ].filter(Boolean);
+  const where = scope.length ? scope.join("; ") : "every outbound action";
+  const env = policy.environments.length ? ` in ${policy.environments.join("/")}` : "";
+  const form = policyToForm(policy);
+  if (!form.conditionEditable) return `${where}${env}, with a custom condition`;
+  if (form.rows.length === 0) return `${where}${env}`;
+  const parts = form.rows.map((row) => {
+    const label = CONDITION_OPERATORS.find((operator) => operator.value === row.op)?.label ?? row.op;
+    return operatorKind(row.op) === "none" ? `${row.path} ${label}` : `${row.path} ${label} ${row.value}`;
+  });
+  return `${where}${env}, when ${parts.join(form.join === "all" ? " and " : " or ")}`;
+}
+function needsAllowFallback(draft, others) {
+  if (draft.effect === "ALLOW" || draft.condition === null) return false;
+  return !others.some(
+    (policy) => policy.enabled && policy.effect === "ALLOW" && (policy.condition === null || policy.condition === void 0)
+  );
+}
+var FIELD = "rounded-md border border-border-secondary bg-background-secondary px-2 py-1.5 text-sm text-text-primary";
+function errorMessage(err) {
+  if (err instanceof PolicyFormError) return err.message;
+  return describeOperationError(err);
+}
+function DryRunSummary({ result }) {
+  const tr = useTr();
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "rounded-md border border-border-secondary bg-background-secondary p-3 space-y-3",
+      "data-testid": "action-policy-dry-run",
+      children: [
+        /* @__PURE__ */ jsx("p", { className: "text-sm text-text-primary", children: tr(
+          "fluidgrids.actionPolicies.dryRun.summary",
+          "Across the last {{runs}} runs, {{actions}} outbound actions were checked: {{approval}} would wait for approval and {{deny}} would be denied ({{affected}} runs affected, {{changed}} decisions change).",
+          {
+            runs: result.runsScanned,
+            actions: result.actionsEvaluated,
+            approval: result.wouldRequireApproval,
+            deny: result.wouldDeny,
+            affected: result.runsAffected,
+            changed: result.changed
+          }
+        ) }),
+        result.rows.length > 0 ? /* @__PURE__ */ jsx("div", { className: "max-h-72 overflow-auto", children: /* @__PURE__ */ jsxs("table", { className: "w-full text-xs", children: [
+          /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { className: "text-left text-text-secondary", children: [
+            /* @__PURE__ */ jsx("th", { className: "py-1 pr-2 font-medium", children: tr("fluidgrids.actionPolicies.dryRun.workflow", "Workflow") }),
+            /* @__PURE__ */ jsx("th", { className: "py-1 pr-2 font-medium", children: tr("fluidgrids.actionPolicies.dryRun.node", "Node") }),
+            /* @__PURE__ */ jsx("th", { className: "py-1 pr-2 font-medium", children: tr("fluidgrids.actionPolicies.dryRun.env", "Env") }),
+            /* @__PURE__ */ jsx("th", { className: "py-1 pr-2 font-medium", children: tr("fluidgrids.actionPolicies.dryRun.now", "Today") }),
+            /* @__PURE__ */ jsx("th", { className: "py-1 font-medium", children: tr("fluidgrids.actionPolicies.dryRun.with", "With draft") })
+          ] }) }),
+          /* @__PURE__ */ jsx("tbody", { children: result.rows.map((row) => /* @__PURE__ */ jsxs(
+            "tr",
+            {
+              className: "border-t border-border-secondary text-text-primary",
+              children: [
+                /* @__PURE__ */ jsxs("td", { className: "py-1 pr-2", children: [
+                  /* @__PURE__ */ jsx("div", { children: row.workflowKey }),
+                  /* @__PURE__ */ jsx("div", { className: "text-text-tertiary", children: new Date(row.runCreatedAt).toLocaleString() })
+                ] }),
+                /* @__PURE__ */ jsxs("td", { className: "py-1 pr-2", children: [
+                  /* @__PURE__ */ jsx("div", { children: row.nodeId }),
+                  /* @__PURE__ */ jsxs("div", { className: "font-mono text-text-tertiary", children: [
+                    row.nodeType,
+                    row.operation ? ` \xB7 ${row.operation}` : ""
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsx("td", { className: "py-1 pr-2", children: row.environment }),
+                /* @__PURE__ */ jsx("td", { className: "py-1 pr-2", children: /* @__PURE__ */ jsx(EffectBadge, { effect: row.currentEffect }) }),
+                /* @__PURE__ */ jsxs("td", { className: "py-1", children: [
+                  /* @__PURE__ */ jsx(EffectBadge, { effect: row.effect }),
+                  row.policyName ? /* @__PURE__ */ jsx("div", { className: "text-text-tertiary", children: row.policyName }) : null
+                ] })
+              ]
+            },
+            `${row.runId}:${row.nodeId}`
+          )) })
+        ] }) }) : /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr(
+          "fluidgrids.actionPolicies.dryRun.nothingBlocked",
+          "Nothing in these runs would be blocked or change."
+        ) })
+      ]
+    }
+  );
+}
+function PolicyEditor({
+  initial,
+  conditionEditable,
+  storedCondition,
+  others,
+  onCancel,
+  onSave,
+  onDryRun
+}) {
+  const tr = useTr();
+  const [form, setForm] = useState(initial);
+  const [busy, setBusy] = useState(false);
+  const keepCondition = !conditionEditable;
+  const fallbackWarning = useMemo(() => {
+    try {
+      const input = formToInput(form);
+      return needsAllowFallback(
+        {
+          effect: input.effect,
+          condition: keepCondition ? storedCondition : input.condition
+        },
+        others
+      );
+    } catch {
+      return false;
+    }
+  }, [form, others, keepCondition, storedCondition]);
+  const run = async (action) => {
+    setBusy(true);
+    try {
+      await action();
+    } catch (err) {
+      toast.error(errorMessage(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+  const setRow = (index, patch) => setForm((current) => ({
+    ...current,
+    rows: current.rows.map(
+      (row, i) => i === index ? { ...row, ...patch } : row
+    )
+  }));
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "rounded-lg border border-border-secondary bg-background-primary p-4 space-y-4",
+      "data-testid": "action-policy-editor",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "grid gap-3 sm:grid-cols-2", children: [
+          /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "policy-name", children: tr("fluidgrids.actionPolicies.name", "Name") }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: "policy-name",
+                value: form.name,
+                maxLength: 200,
+                onChange: (e) => setForm({ ...form, name: e.target.value }),
+                placeholder: tr(
+                  "fluidgrids.actionPolicies.namePlaceholder",
+                  "Payments over 1,000 need approval"
+                )
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-2 gap-3", children: [
+            /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+              /* @__PURE__ */ jsx(Label, { htmlFor: "policy-effect", children: tr("fluidgrids.actionPolicies.effectLabel", "Effect") }),
+              /* @__PURE__ */ jsx(
+                "select",
+                {
+                  id: "policy-effect",
+                  className: `w-full ${FIELD}`,
+                  value: form.effect,
+                  onChange: (e) => setForm({ ...form, effect: e.target.value }),
+                  children: POLICY_EFFECTS.map((effect) => /* @__PURE__ */ jsx("option", { value: effect, children: effectLabel(effect, tr) }, effect))
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+              /* @__PURE__ */ jsx(Label, { htmlFor: "policy-priority", children: tr("fluidgrids.actionPolicies.priority", "Priority") }),
+              /* @__PURE__ */ jsx(
+                Input,
+                {
+                  id: "policy-priority",
+                  inputMode: "numeric",
+                  value: form.priority,
+                  onChange: (e) => setForm({ ...form, priority: e.target.value })
+                }
+              )
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+          /* @__PURE__ */ jsx(Label, { htmlFor: "policy-description", children: tr("fluidgrids.actionPolicies.description", "Description") }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              id: "policy-description",
+              value: form.description,
+              maxLength: 2e3,
+              onChange: (e) => setForm({ ...form, description: e.target.value })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-text-primary", children: tr("fluidgrids.actionPolicies.appliesTo", "Applies to") }),
+          /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.actionPolicies.appliesToHelp",
+            "Comma-separated. Node types and operations accept * and ? wildcards (store/stripe*, internal:http). Leave a field empty to match anything."
+          ) }),
+          /* @__PURE__ */ jsx("div", { className: "grid gap-3 sm:grid-cols-2", children: [
+            ["nodeTypes", "Node types", "store/stripe*, internal:http"],
+            ["operations", "Operations", "refund*, createCharge"],
+            ["connectionProviders", "Connection providers", "stripe"],
+            ["workflowTags", "Workflow tags", "finance"]
+          ].map(([key, label, placeholder]) => /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: `policy-${key}`, children: tr(`fluidgrids.actionPolicies.matcher.${key}`, label) }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: `policy-${key}`,
+                value: form[key],
+                placeholder,
+                onChange: (e) => setForm({ ...form, [key]: e.target.value })
+              }
+            )
+          ] }, key)) }),
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-4 pt-1", children: [
+            /* @__PURE__ */ jsx("span", { className: "text-sm text-text-secondary", children: tr("fluidgrids.actionPolicies.environments", "Environments") }),
+            POLICY_ENVIRONMENTS.map((environment) => /* @__PURE__ */ jsxs(
+              "label",
+              {
+                className: "flex items-center gap-1.5 text-sm text-text-primary",
+                children: [
+                  /* @__PURE__ */ jsx(
+                    "input",
+                    {
+                      type: "checkbox",
+                      checked: form.environments.includes(environment),
+                      onChange: (e) => setForm({
+                        ...form,
+                        environments: e.target.checked ? [...form.environments, environment] : form.environments.filter(
+                          (item) => item !== environment
+                        )
+                      })
+                    }
+                  ),
+                  environment
+                ]
+              },
+              environment
+            )),
+            /* @__PURE__ */ jsx("span", { className: "text-xs text-text-tertiary", children: tr(
+              "fluidgrids.actionPolicies.environmentsHelp",
+              "None checked applies in every environment. Test runs are DEV; triggered and API runs are PROD."
+            ) })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+            /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-text-primary", children: tr("fluidgrids.actionPolicies.condition", "Condition") }),
+            conditionEditable && form.rows.length > 1 ? /* @__PURE__ */ jsxs(
+              "select",
+              {
+                "aria-label": tr(
+                  "fluidgrids.actionPolicies.join",
+                  "Combine conditions"
+                ),
+                className: FIELD,
+                value: form.join,
+                onChange: (e) => setForm({ ...form, join: e.target.value }),
+                children: [
+                  /* @__PURE__ */ jsx("option", { value: "all", children: tr("fluidgrids.actionPolicies.joinAll", "all must hold") }),
+                  /* @__PURE__ */ jsx("option", { value: "any", children: tr("fluidgrids.actionPolicies.joinAny", "any may hold") })
+                ]
+              }
+            ) : null
+          ] }),
+          !conditionEditable ? /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.actionPolicies.customCondition",
+            "This policy has a nested condition saved through the API. It is kept as it is."
+          ) }) : form.rows.length === 0 ? /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: tr(
+            "fluidgrids.actionPolicies.noCondition",
+            "No condition: the policy fires on every action it applies to."
+          ) }) : form.rows.map((row, index) => /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: "flex flex-col gap-2 sm:flex-row sm:items-center",
+              "data-testid": "action-policy-condition-row",
+              children: [
+                /* @__PURE__ */ jsx(
+                  Input,
+                  {
+                    "aria-label": tr(
+                      "fluidgrids.actionPolicies.path",
+                      "Parameter path"
+                    ),
+                    className: "sm:w-56",
+                    value: row.path,
+                    placeholder: "body.amount",
+                    onChange: (e) => setRow(index, { path: e.target.value })
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  "select",
+                  {
+                    "aria-label": tr(
+                      "fluidgrids.actionPolicies.operator",
+                      "Operator"
+                    ),
+                    className: FIELD,
+                    value: row.op,
+                    onChange: (e) => setRow(index, { op: e.target.value }),
+                    children: CONDITION_OPERATORS.map((operator) => /* @__PURE__ */ jsx("option", { value: operator.value, children: tr(
+                      `fluidgrids.actionPolicies.op.${operator.value}`,
+                      operator.label
+                    ) }, operator.value))
+                  }
+                ),
+                operatorKind(row.op) === "none" ? null : /* @__PURE__ */ jsx(
+                  Input,
+                  {
+                    "aria-label": tr("fluidgrids.actionPolicies.value", "Value"),
+                    className: "sm:w-48",
+                    value: row.value,
+                    placeholder: operatorKind(row.op) === "list" ? "usd, eur" : "1000",
+                    onChange: (e) => setRow(index, { value: e.target.value })
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  Button,
+                  {
+                    variant: "ghost",
+                    size: "sm",
+                    "aria-label": tr(
+                      "fluidgrids.actionPolicies.removeCondition",
+                      "Remove condition"
+                    ),
+                    onClick: () => setForm({
+                      ...form,
+                      rows: form.rows.filter((_, i) => i !== index)
+                    }),
+                    children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:close", width: 16 })
+                  }
+                )
+              ]
+            },
+            index
+          )),
+          conditionEditable ? /* @__PURE__ */ jsxs(
+            Button,
+            {
+              variant: "outline",
+              size: "sm",
+              onClick: () => setForm({
+                ...form,
+                rows: [...form.rows, { path: "", op: "gt", value: "" }]
+              }),
+              children: [
+                /* @__PURE__ */ jsx(Icon, { icon: "mdi:plus", width: 16, className: "mr-1" }),
+                tr("fluidgrids.actionPolicies.addCondition", "Add condition")
+              ]
+            }
+          ) : null
+        ] }),
+        fallbackWarning ? /* @__PURE__ */ jsx("p", { className: "rounded-md border border-status-warning-border bg-status-warning-bg-subtle p-2 text-xs text-status-warning-text", children: tr(
+          "fluidgrids.actionPolicies.defaultDenyWarning",
+          "Default deny: actions this policy applies to but whose condition does not hold are denied unless another policy allows them. Add an Allow policy with the same scope and a higher priority number to let the rest through, and check the dry run."
+        ) }) : null,
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center justify-between gap-2", children: [
+          /* @__PURE__ */ jsxs("label", { className: "flex items-center gap-2 text-sm text-text-primary", children: [
+            /* @__PURE__ */ jsx(
+              Switch,
+              {
+                checked: form.enabled,
+                onCheckedChange: (enabled) => setForm({ ...form, enabled })
+              }
+            ),
+            tr("fluidgrids.actionPolicies.enabled", "Enabled")
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap gap-2", children: [
+            /* @__PURE__ */ jsx(Button, { variant: "ghost", onClick: onCancel, disabled: busy, children: tr("fluidgrids.actionPolicies.cancel", "Cancel") }),
+            /* @__PURE__ */ jsxs(
+              Button,
+              {
+                variant: "outline",
+                disabled: busy,
+                onClick: () => run(() => onDryRun(form, keepCondition)),
+                children: [
+                  /* @__PURE__ */ jsx(Icon, { icon: "mdi:test-tube", width: 16, className: "mr-1" }),
+                  tr("fluidgrids.actionPolicies.tryIt", "What would this block?")
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                disabled: busy,
+                onClick: () => run(() => onSave(form, keepCondition)),
+                children: tr("fluidgrids.actionPolicies.save", "Save policy")
+              }
+            )
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+function ApprovalsList({
+  approvals,
+  onDecide
+}) {
+  const tr = useTr();
+  const [busy, setBusy] = useState(null);
+  if (approvals.length === 0) return null;
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", "data-testid": "action-policy-approvals", children: [
+    /* @__PURE__ */ jsx("h3", { className: "text-sm font-semibold text-text-primary", children: tr("fluidgrids.actionPolicies.pendingTitle", "Waiting for approval") }),
+    approvals.map((approval) => /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "flex flex-col gap-2 rounded-md border border-status-warning-border bg-status-warning-bg-subtle p-3 sm:flex-row sm:items-center sm:justify-between",
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "min-w-0 text-sm text-text-primary", children: [
+            /* @__PURE__ */ jsxs("div", { className: "font-medium", children: [
+              approval.workflowKey,
+              " \xB7 ",
+              approval.nodeId
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "text-xs text-text-secondary", children: [
+              approval.policyName ?? "",
+              " \xB7 ",
+              approval.nodeType,
+              approval.operation ? ` \xB7 ${approval.operation}` : "",
+              " \xB7",
+              " ",
+              approval.environment,
+              approval.reason === "PAYLOAD_CHANGED" ? ` \xB7 ${tr("fluidgrids.actionPolicies.payloadChanged", "changed after an earlier approval")}` : ""
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "font-mono text-[10px] text-text-tertiary", children: [
+              tr("fluidgrids.actionPolicies.payload", "Payload"),
+              " ",
+              approval.payloadHash.slice(0, 16)
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                disabled: busy === approval.id,
+                onClick: async () => {
+                  setBusy(approval.id);
+                  try {
+                    await onDecide(approval.id, true);
+                    toast.success(
+                      tr(
+                        "fluidgrids.actionPolicies.approved",
+                        "Approved \u2014 the run continues"
+                      )
+                    );
+                  } catch (err) {
+                    toast.error(errorMessage(err));
+                  } finally {
+                    setBusy(null);
+                  }
+                },
+                children: tr("fluidgrids.actionPolicies.approve", "Approve")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: "outline",
+                disabled: busy === approval.id,
+                onClick: async () => {
+                  setBusy(approval.id);
+                  try {
+                    await onDecide(approval.id, false);
+                    toast.success(
+                      tr(
+                        "fluidgrids.actionPolicies.declined",
+                        "Declined \u2014 the node fails"
+                      )
+                    );
+                  } catch (err) {
+                    toast.error(errorMessage(err));
+                  } finally {
+                    setBusy(null);
+                  }
+                },
+                children: tr("fluidgrids.actionPolicies.decline", "Decline")
+              }
+            )
+          ] })
+        ]
+      },
+      approval.id
+    ))
+  ] });
+}
+function ActionPoliciesTab() {
+  const tr = useTr();
+  const { policies, approvals, loading, error, save, remove, dryRun, decide } = useActionPolicies();
+  const [editing, setEditing] = useState(null);
+  const [preview, setPreview] = useState(null);
+  const [confirmDelete, setConfirmDelete] = useState(null);
+  const toInput = (form, keepCondition) => {
+    const input = formToInput(form);
+    return keepCondition && editing ? { ...input, condition: editing.storedCondition } : input;
+  };
+  const others = policies.filter((policy) => policy.id !== editing?.form.id);
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-6", "data-testid": "action-policies-tab", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between", children: [
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold text-text-primary", children: tr("fluidgrids.actionPolicies.title", "Action policies") }),
+        /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary max-w-2xl", children: tr(
+          "fluidgrids.actionPolicies.subtitle",
+          "Rules every workflow in this workspace follows before it calls the outside world, whoever built it: require approval above a threshold, deny an operation, or log it. Policies are checked in priority order (lowest first). Without a policy that applies, an action runs as before."
+        ) })
+      ] }),
+      !editing ? /* @__PURE__ */ jsxs(
+        Button,
+        {
+          onClick: () => {
+            setPreview(null);
+            setEditing({
+              form: emptyPolicyForm(),
+              conditionEditable: true,
+              storedCondition: null
+            });
+          },
+          children: [
+            /* @__PURE__ */ jsx(Icon, { icon: "mdi:plus", width: 16, className: "mr-1" }),
+            tr("fluidgrids.actionPolicies.add", "Add policy")
+          ]
+        }
+      ) : null
+    ] }),
+    /* @__PURE__ */ jsx(ApprovalsList, { approvals, onDecide: decide }),
+    editing ? /* @__PURE__ */ jsx(
+      PolicyEditor,
+      {
+        initial: editing.form,
+        conditionEditable: editing.conditionEditable,
+        storedCondition: editing.storedCondition,
+        others,
+        onCancel: () => {
+          setEditing(null);
+          setPreview(null);
+        },
+        onDryRun: async (form, keepCondition) => {
+          setPreview(await dryRun({ policy: toInput(form, keepCondition) }));
+        },
+        onSave: async (form, keepCondition) => {
+          await save(toInput(form, keepCondition));
+          toast.success(
+            tr("fluidgrids.actionPolicies.saved", "Policy saved")
+          );
+          setEditing(null);
+          setPreview(null);
+        }
+      },
+      editing.form.id ?? "new"
+    ) : null,
+    preview ? /* @__PURE__ */ jsx(DryRunSummary, { result: preview }) : null,
+    loading ? /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr("fluidgrids.actionPolicies.loading", "Loading policies\u2026") }) : error ? /* @__PURE__ */ jsx("p", { className: "text-sm text-status-error-text", children: describeOperationError(error) }) : policies.length === 0 ? /* @__PURE__ */ jsx(
+      "p",
+      {
+        className: "text-sm text-text-secondary",
+        "data-testid": "action-policies-empty",
+        children: tr(
+          "fluidgrids.actionPolicies.empty",
+          "No policies yet. Every action runs as its workflow says."
+        )
+      }
+    ) : /* @__PURE__ */ jsx("ul", { className: "divide-y divide-border-secondary rounded-lg border border-border-secondary", children: policies.map((policy) => /* @__PURE__ */ jsxs(
+      "li",
+      {
+        className: "flex flex-col gap-2 p-3 sm:flex-row sm:items-center sm:justify-between",
+        "data-testid": "action-policy-row",
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "min-w-0", children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+              /* @__PURE__ */ jsx("span", { className: "font-medium text-text-primary", children: policy.name }),
+              /* @__PURE__ */ jsx(EffectBadge, { effect: policy.effect }),
+              /* @__PURE__ */ jsx(Badge, { variant: "outline", className: "text-xs", children: tr(
+                "fluidgrids.actionPolicies.priorityShort",
+                "#{{priority}}",
+                {
+                  priority: policy.priority
+                }
+              ) }),
+              !policy.enabled ? /* @__PURE__ */ jsx(
+                Badge,
+                {
+                  variant: "outline",
+                  className: "text-xs text-text-tertiary",
+                  children: tr("fluidgrids.actionPolicies.disabled", "Disabled")
+                }
+              ) : null
+            ] }),
+            /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: describePolicy(policy) })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "flex gap-1", children: [
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "ghost",
+                size: "sm",
+                onClick: async () => {
+                  try {
+                    setPreview(await dryRun({ excludePolicyId: policy.id }));
+                  } catch (err) {
+                    toast.error(errorMessage(err));
+                  }
+                },
+                children: tr("fluidgrids.actionPolicies.withoutIt", "Without it")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "ghost",
+                size: "sm",
+                onClick: () => {
+                  const { conditionEditable, ...form } = policyToForm(policy);
+                  setPreview(null);
+                  setEditing({
+                    form,
+                    conditionEditable,
+                    storedCondition: policy.condition ?? null
+                  });
+                },
+                children: tr("fluidgrids.actionPolicies.edit", "Edit")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "ghost",
+                size: "sm",
+                className: "text-destructive",
+                onClick: async () => {
+                  if (confirmDelete !== policy.id) {
+                    setConfirmDelete(policy.id);
+                    return;
+                  }
+                  setConfirmDelete(null);
+                  try {
+                    await remove(policy.id);
+                    toast.success(
+                      tr(
+                        "fluidgrids.actionPolicies.deleted",
+                        "Policy deleted"
+                      )
+                    );
+                  } catch (err) {
+                    toast.error(errorMessage(err));
+                  }
+                },
+                children: confirmDelete === policy.id ? tr(
+                  "fluidgrids.actionPolicies.confirmDelete",
+                  "Confirm delete"
+                ) : tr("fluidgrids.actionPolicies.delete", "Delete")
+              }
+            )
+          ] })
+        ]
+      },
+      policy.id
+    )) })
+  ] });
+}
+
+export { ActionPoliciesTab, RunPolicyDecisions, useRunPolicyDecisions };

package/dist/{chunk-VXLUYQDO.js → chunk-WRMIYMXE.js}

@@ -1,3 +1,4 @@
+import { ActionPoliciesTab } from './chunk-VUVTOUQ5.js';
 import { useFluidGridsFlag, FLUIDGRIDS_FLAGS, LogStreamingTab } from './chunk-LWF5J43N.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
 import { useFlowStore, useSaveStatusStore, useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, throwIfResultError } from './chunk-5LKZ4PNK.js';
@@ -1240,6 +1241,18 @@ function SettingsPage({
               /* @__PURE__ */ jsx(Icon, { icon: "mdi:database-clock-outline", width: 16 }),
               tr("fluidgrids.settings.page.runDataTab", "Run data")
             ] }),
+            /* @__PURE__ */ jsxs(
+              TabsTrigger,
+              {
+                value: "policies",
+                className: "gap-1.5",
+                "data-tour": "fluidgrids-settings-policies-tab",
+                children: [
+                  /* @__PURE__ */ jsx(Icon, { icon: "mdi:shield-check-outline", width: 16 }),
+                  tr("fluidgrids.settings.page.policiesTab", "Policies")
+                ]
+              }
+            ),
             /* @__PURE__ */ jsxs(TabsTrigger, { value: "notifications", className: "gap-1.5", children: [
               /* @__PURE__ */ jsx(Icon, { icon: "mdi:bell-outline", width: 16 }),
               tr("fluidgrids.settings.page.notificationsTab", "Notifications")
@@ -1266,6 +1279,7 @@ function SettingsPage({
       /* @__PURE__ */ jsx(TabsContent, { value: "general", children: /* @__PURE__ */ jsx(GeneralTab, {}) }),
       /* @__PURE__ */ jsx(TabsContent, { value: "execution", children: /* @__PURE__ */ jsx(ExecutionTab, { workflowKey }) }),
       /* @__PURE__ */ jsx(TabsContent, { value: "run-data", children: /* @__PURE__ */ jsx(RunDataTab, {}) }),
+      /* @__PURE__ */ jsx(TabsContent, { value: "policies", children: /* @__PURE__ */ jsx(ActionPoliciesTab, {}) }),
       /* @__PURE__ */ jsx(TabsContent, { value: "notifications", children: /* @__PURE__ */ jsx(NotificationsTab, {}) }),
       logStreamsEnabled ? /* @__PURE__ */ jsx(TabsContent, { value: "log-streaming", children: /* @__PURE__ */ jsx(LogStreamingTab, {}) }) : null,
       /* @__PURE__ */ jsx(TabsContent, { value: "api", children: /* @__PURE__ */ jsx(ApiTab, {}) })

package/dist/executions.js

@@ -1,8 +1,9 @@
 import './chunk-AD3BXTJS.js';
 export { ExecutionsListPage } from './chunk-H7CJXSMI.js';
-export { ExecutionDetailPage } from './chunk-CPEIOFYR.js';
+export { ExecutionDetailPage } from './chunk-S4VYW4BR.js';
 import './chunk-SSJIK6WS.js';
 import './chunk-UUUDSVC7.js';
+import './chunk-VUVTOUQ5.js';
 import './chunk-5ERAJC2I.js';
 import './chunk-JAKWVVVQ.js';
 import './chunk-QGXA2USP.js';

package/dist/index.js

@@ -5,14 +5,15 @@ export { FirstWorkflowChecklist, FirstWorkflowChecklistView, WorkflowsList, useC
 export { CreateWorkflowRefusalDialog, GUIDED_FIRST_WORKFLOW_NAV, GUIDED_FIRST_WORKFLOW_STATE, GUIDED_TOUR_STATE, firstWorkflowProgress, isGuidedTourIntent, pickGuidedTour } from './chunk-CSBKB5EX.js';
 import './chunk-AD3BXTJS.js';
 export { ExecutionsListPage } from './chunk-H7CJXSMI.js';
-import { usePendingHumanRequests, HumanRequestCard } from './chunk-CPEIOFYR.js';
-export { ExecutionDetailPage, HumanRequestCard, RunHumanRequests, usePendingHumanRequests, useRespondToHumanRequest, useRunHumanRequests } from './chunk-CPEIOFYR.js';
+import { usePendingHumanRequests, HumanRequestCard } from './chunk-S4VYW4BR.js';
+export { ExecutionDetailPage, HumanRequestCard, RunHumanRequests, usePendingHumanRequests, useRespondToHumanRequest, useRunHumanRequests } from './chunk-S4VYW4BR.js';
 import { TagFilterSelect } from './chunk-SSJIK6WS.js';
 import './chunk-UUUDSVC7.js';
 export { HistoryPage } from './chunk-Y6YOY33Z.js';
 export { NodesPage, fetchAllNodesWithManifests, useLazyNodeManifest, useNodeEndpoint, useNodeEndpoints, useNodeManifest } from './chunk-AYFKS4MM.js';
 export { DataSinkDashboardPage, ErrorAnalyticsPage, InsightsPage } from './chunk-FOEEDKBP.js';
-export { SettingsPage } from './chunk-VXLUYQDO.js';
+export { SettingsPage } from './chunk-WRMIYMXE.js';
+import './chunk-VUVTOUQ5.js';
 export { FLUIDGRIDS_FLAGS, useDataSinkData, useDataSinks, useFluidGridsFlag, useInsightsData, useLogStreamDestinationActions, useLogStreamDestinations, useRunReplayActions } from './chunk-LWF5J43N.js';
 import './chunk-5ERAJC2I.js';
 import { ThemeProvider, extractTemplateGraph } from './chunk-ZF55RVJ3.js';
@@ -82,7 +83,7 @@ var ExecutionsListPage2 = lazy(
   }))
 );
 var ExecutionDetailPage2 = lazy(
-  () => import('./ExecutionDetailPage-MYBCDBV7.js').then((m) => ({
+  () => import('./ExecutionDetailPage-UFB7VMGE.js').then((m) => ({
     default: m.ExecutionDetailPage
   }))
 );

package/dist/settings.js

@@ -1,4 +1,5 @@
-export { SettingsPage } from './chunk-VXLUYQDO.js';
+export { SettingsPage } from './chunk-WRMIYMXE.js';
+import './chunk-VUVTOUQ5.js';
 import './chunk-LWF5J43N.js';
 import './chunk-5ERAJC2I.js';
 import './chunk-4VJ3MDOV.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/fluidgrids-fe-sdk",
-  "version": "2026.1028.4",
+  "version": "2026.1028.5",
   "description": "FluidGrids Workflow Builder SDK - Embeddable visual workflow automation",
   "type": "module",
   "imports": {