@burdenoff/fluidgrids-fe-sdk 2026.1109.1 → 2026.1109.3

package/dist/{chunk-43P7AHQU.js → chunk-XO5ND2HT.js}

@@ -1,28 +1,505 @@
-import { AgentsTab } from './chunk-V3HRW36F.js';
+import { AgentsTab } from './chunk-M2ELYF52.js';
 import { ActionPoliciesTab, checkCodecServerUrl } from './chunk-OJHBCOBA.js';
-import { useResource, fetchPauseRules, FieldError, fetchSearchAttributes, StatusPill, NativeSelect, fetchArchiveSettings, fetchCodecServerSettings, deletePauseRule, createPauseRule, deleteSearchAttribute, createSearchAttribute, saveArchiveSettings, clearArchiveSettings, saveCodecServerSettings } from './chunk-ACNJS4OL.js';
-import { LogStreamingTab } from './chunk-HBMU63XF.js';
+import { useResource, fetchPauseRules, FieldError, fetchSearchAttributes, StatusPill, NativeSelect, fetchArchiveSettings, fetchCodecServerSettings, deletePauseRule, createPauseRule, deleteSearchAttribute, createSearchAttribute, saveArchiveSettings, clearArchiveSettings, saveCodecServerSettings } from './chunk-5YLS3WH5.js';
+import { LogStreamingTab } from './chunk-3CAYQ57D.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { useFluidGridsFlag, FLUIDGRIDS_FLAGS, usePhaseCFlags, useSaveStatusStore, findSaveConflict, useDurableParityEnabled, useConnections } from './chunk-V7MQXTHD.js';
-import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-AR22A74Y.js';
+import { useFluidGridsFlag, FLUIDGRIDS_FLAGS, usePhaseCFlags, useSaveStatusStore, findSaveConflict, useDurableParityEnabled, useConnections } from './chunk-XSUFTJCE.js';
+import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-ERT444RG.js';
 import { useFlowStore } from './chunk-X3F5IQBP.js';
 import { getGlobalStoreClient } from './chunk-TYI2XOSI.js';
-import { useWorkflowDefinitionQuery, useUpdateWorkflowDefinitionMutation, useWorkflowDefinitionsQuery, DurableHistoryCapsDocument, UpdateDurableHistoryCapsDocument } from './chunk-ZGUW4GHR.js';
+import { useWorkflowDefinitionQuery, useUpdateWorkflowDefinitionMutation, useWorkflowDefinitionsQuery, ManagedAiWorkspacePolicyDocument, UpdateManagedAiWorkspacePolicyDocument, DurableHistoryCapsDocument, UpdateDurableHistoryCapsDocument } from './chunk-VAWYR6P4.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-PDODDDHY.js';
 import { throwIfResultError, describeOperationError } from './chunk-JKLZ6YZ3.js';
 import { getFluidGridsConfig } from './chunk-UEG2WC3G.js';
-import { useState, useMemo, useEffect, useCallback } from 'react';
+import { createContext, useState, useMemo, useEffect, useCallback, useContext, useRef, useLayoutEffect } from 'react';
 import { useNavigate, useParams } from 'react-router';
 import { Icon } from '@iconify/react';
 import { Button } from '@burdenoff/fe-libs/button';
 import { Tabs, TabsList, TabsTrigger, TabsContent, Input, Switch, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Label, Card as Card$1, CardHeader, Badge, Checkbox, TooltipProvider, Tooltip, TooltipTrigger, TooltipContent } from '@burdenoff/fe-libs/ui';
 import { toast } from 'sonner';
+import { print } from 'graphql';
+import { getStoredProjectId, getStoredOrganizationId, graphqlFetchPinned, prepareWorkspaceRequest, clearGraphqlFetchResponseCache, getWorkspaceTokenPayload, isWorkspaceTokenValidForContext } from '@burdenoff/fe-libs/shared';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { gql } from '@apollo/client';
 import { resolveExternalGatewayUrls } from '@burdenoff/fe-libs/shared/config';
 import { cn } from '@burdenoff/fe-libs/utils';
 
+var ManagedAiAuthorityContext = createContext(null);
+function useManagedAiPolicyAuthority() {
+  return useContext(ManagedAiAuthorityContext);
+}
+var canonical = {
+  prepare: prepareWorkspaceRequest,
+  send: graphqlFetchPinned,
+  organizationId: getStoredOrganizationId,
+  projectId: getStoredProjectId
+};
+var ManagedAiWorkspaceWideRequired = class extends Error {
+  constructor() {
+    super("Managed AI workspace authority requires workspace-wide context.");
+  }
+};
+function sameScope(a, b) {
+  return b !== null && a.authority === b.authority && a.url === b.url && a.actorId === b.actorId && a.workspaceId === b.workspaceId && a.organizationId === b.organizationId && a.tenantId === b.tenantId && a.projectId === b.projectId && a.authToken === b.authToken && a.workspaceToken === b.workspaceToken;
+}
+function createManagedAiRequest(captured, current, dependencies = canonical) {
+  const scope = Object.freeze({ ...captured });
+  const assertScope = (signal) => {
+    if (signal.aborted) {
+      throw new DOMException("The operation was aborted.", "AbortError");
+    }
+    if (!sameScope(scope, current()) || !scope.authToken || !scope.actorId || !scope.workspaceId || !scope.organizationId || !scope.tenantId) {
+      throw new Error(
+        "Managed AI authority changed. Reload before continuing."
+      );
+    }
+  };
+  return async function request(query, variables, signal) {
+    assertScope(signal);
+    if (scope.projectId) throw new ManagedAiWorkspaceWideRequired();
+    let workspaceToken;
+    let assertWorkspace;
+    const assertCapturedToken = (value) => {
+      const payload = getWorkspaceTokenPayload(value, {
+        validateTenantClaim: true
+      });
+      if (payload?.projectId) throw new ManagedAiWorkspaceWideRequired();
+      if (payload?.sub !== scope.actorId || !isWorkspaceTokenValidForContext(
+        value,
+        {
+          workspaceId: scope.workspaceId,
+          organizationId: scope.organizationId,
+          tenantId: scope.tenantId,
+          workspaceWide: true
+        },
+        3e4
+      ))
+        throw new Error(
+          "Managed AI workspace authority is unavailable. Reload before continuing."
+        );
+    };
+    if (scope.authority === "profile") {
+      if (dependencies.organizationId() !== scope.organizationId)
+        throw new Error(
+          "Managed AI authority changed. Reload before continuing."
+        );
+      if (dependencies.projectId()) throw new ManagedAiWorkspaceWideRequired();
+      const prepared = await dependencies.prepare({
+        url: scope.url,
+        authToken: scope.authToken,
+        actorId: scope.actorId,
+        workspaceId: scope.workspaceId,
+        tenantId: scope.tenantId,
+        workspaceToken: scope.workspaceToken,
+        currentQuery: query,
+        signal
+      });
+      workspaceToken = prepared.workspaceToken;
+      assertWorkspace = () => {
+        prepared.assertCurrent();
+        assertCapturedToken(workspaceToken);
+      };
+    } else if (scope.authority === "provided") {
+      workspaceToken = scope.workspaceToken ?? "";
+      assertWorkspace = () => assertCapturedToken(workspaceToken);
+    } else {
+      throw new Error("Explicit managed AI authority is required.");
+    }
+    assertScope(signal);
+    assertWorkspace();
+    const response = await dependencies.send({
+      gateway: "workspace",
+      baseUrl: scope.url,
+      query,
+      variables,
+      authToken: scope.authToken,
+      workspaceToken,
+      workspaceId: scope.workspaceId,
+      organizationId: scope.organizationId,
+      tenantId: scope.tenantId,
+      projectId: false,
+      signal,
+      suppressGlobalErrorEvent: true,
+      skipAuthRetry: true
+    });
+    assertScope(signal);
+    assertWorkspace();
+    if (response.errors?.length || response.data === null || response.data === void 0) {
+      throw new Error("Managed AI response could not be confirmed.");
+    }
+    return response.data;
+  };
+}
+
+// src/modules/settings/hooks/useManagedAiWorkspacePolicy.ts
+var EMPTY = {
+  authority: null,
+  policy: null,
+  loading: false,
+  error: null,
+  readVersion: 0,
+  workspaceWideRequired: false
+};
+function policyView(value) {
+  if (!value || typeof value.enforcementActive !== "boolean" || typeof value.enrollmentAvailable !== "boolean" || typeof value.enabled !== "boolean" || !Number.isSafeInteger(value.revision) || value.revision < 0 || value.enforcementActive && value.revision < 1 || typeof value.requiredConsentVersion !== "string" || !value.requiredConsentVersion || value.requiredConsentVersion.length > 128) {
+    throw new Error("Managed AI policy could not be confirmed.");
+  }
+  return {
+    enforcementActive: value.enforcementActive,
+    enrollmentAvailable: value.enrollmentAvailable,
+    enabled: value.enabled,
+    revision: value.revision,
+    requiredConsentVersion: value.requiredConsentVersion
+  };
+}
+function useManagedAiWorkspacePolicy(authority, enabled, requestFactory = createManagedAiRequest) {
+  const current = useRef(authority);
+  const pending = useRef(null);
+  const generation = useRef(0);
+  const writing = useRef(null);
+  const [state, setState] = useState(EMPTY);
+  useLayoutEffect(() => {
+    current.current = enabled ? authority : null;
+    return () => {
+      current.current = null;
+      generation.current += 1;
+      writing.current = null;
+      pending.current?.abort();
+    };
+  }, [authority, enabled]);
+  const request = useMemo(
+    () => authority ? requestFactory(authority, () => current.current) : null,
+    [authority, requestFactory]
+  );
+  const reload = useCallback(async () => {
+    if (!authority || !request || !enabled || current.current !== authority)
+      return;
+    pending.current?.abort();
+    const controller = new AbortController();
+    pending.current = controller;
+    const id = ++generation.current;
+    setState((previous) => ({
+      authority,
+      policy: null,
+      loading: true,
+      workspaceWideRequired: false,
+      error: null,
+      readVersion: previous.authority === authority ? previous.readVersion : 0
+    }));
+    clearGraphqlFetchResponseCache();
+    try {
+      const data = await request(
+        print(ManagedAiWorkspacePolicyDocument),
+        {},
+        controller.signal
+      );
+      const policy = policyView(data.workflowWorkspaceAiPolicy);
+      if (id !== generation.current || current.current !== authority || controller.signal.aborted)
+        return;
+      setState((previous) => ({
+        authority,
+        policy,
+        loading: false,
+        workspaceWideRequired: false,
+        error: null,
+        readVersion: previous.readVersion + 1
+      }));
+    } catch (error) {
+      if (id === generation.current && current.current === authority && !controller.signal.aborted) {
+        setState((previous) => ({
+          ...previous,
+          authority,
+          policy: null,
+          loading: false,
+          error: "Managed AI settings could not be confirmed.",
+          workspaceWideRequired: error instanceof ManagedAiWorkspaceWideRequired
+        }));
+      }
+    }
+  }, [authority, enabled, request]);
+  useEffect(() => {
+    void reload();
+    return () => {
+      pending.current?.abort();
+    };
+  }, [reload]);
+  const save = useCallback(
+    async (change) => {
+      if (writing.current !== null || !authority || !request || !enabled || current.current !== authority || state.authority !== authority || !state.policy?.enforcementActive && state.policy?.enrollmentAvailable !== true || state.loading || state.error || change.enabled && change.consentVersion !== state.policy.requiredConsentVersion || change.expectedRevision !== state.policy.revision) {
+        throw new Error(
+          "Reload the current managed AI setting before continuing."
+        );
+      }
+      pending.current?.abort();
+      const controller = new AbortController();
+      pending.current = controller;
+      const id = ++generation.current;
+      writing.current = id;
+      clearGraphqlFetchResponseCache();
+      try {
+        const data = await request(
+          print(UpdateManagedAiWorkspacePolicyDocument),
+          { input: change },
+          controller.signal
+        );
+        const policy = policyView(data.updateWorkflowWorkspaceAiPolicy);
+        if (id !== generation.current || current.current !== authority || controller.signal.aborted || !policy.enforcementActive || policy.enabled !== change.enabled || policy.revision <= change.expectedRevision)
+          throw new Error("Managed AI change could not be confirmed.");
+        setState((previous) => ({
+          ...previous,
+          authority,
+          policy,
+          loading: false,
+          error: null
+        }));
+      } catch (error) {
+        clearGraphqlFetchResponseCache();
+        if (id === generation.current && current.current === authority)
+          setState((previous) => ({
+            ...previous,
+            authority,
+            policy: null,
+            loading: false,
+            error: "Reload to confirm the managed AI setting.",
+            workspaceWideRequired: error instanceof ManagedAiWorkspaceWideRequired
+          }));
+        throw new Error("Managed AI change could not be confirmed.");
+      } finally {
+        if (writing.current === id) writing.current = null;
+      }
+    },
+    [authority, enabled, request, state]
+  );
+  const visible = enabled && authority !== null && state.authority === authority;
+  return {
+    policy: visible ? state.policy : null,
+    loading: enabled && authority !== null && (!visible || state.loading),
+    error: visible ? state.error : null,
+    readVersion: visible ? state.readVersion : 0,
+    workspaceWideRequired: visible && state.workspaceWideRequired,
+    reload,
+    save
+  };
+}
+function ManagedAiPolicyCard(props) {
+  const versionKey = JSON.stringify([
+    props.scopeKey,
+    props.readVersion,
+    props.policy?.revision,
+    props.policy?.requiredConsentVersion,
+    props.policy?.enabled,
+    props.policy?.enforcementActive,
+    props.policy?.enrollmentAvailable
+  ]);
+  return /* @__PURE__ */ jsx(ManagedAiPolicyForm, { ...props }, versionKey);
+}
+function ManagedAiPolicyForm({
+  policy,
+  loading,
+  error,
+  workspaceWideRequired,
+  canManage,
+  reload,
+  save
+}) {
+  const tr = useTr();
+  const [acknowledged, setAcknowledged] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const [saveFailed, setSaveFailed] = useState(false);
+  const activelyEnabled = policy?.enforcementActive === true && policy.enabled;
+  const change = async (enabled) => {
+    if (!policy || !policy.enforcementActive && policy.enrollmentAvailable !== true || !canManage || saving || saveFailed)
+      return;
+    if (enabled && !acknowledged) return;
+    setSaving(true);
+    setSaveFailed(false);
+    try {
+      await save({
+        enabled,
+        expectedRevision: policy.revision,
+        ...enabled ? { consentVersion: policy.requiredConsentVersion } : {}
+      });
+      setAcknowledged(false);
+    } catch {
+      setSaveFailed(true);
+    } finally {
+      setSaving(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "space-y-4 rounded-lg border border-border-default bg-background-secondary p-5",
+      "aria-label": tr("fluidgrids.settings.managedAi.title", "Managed AI"),
+      children: [
+        /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold text-text-primary", children: tr("fluidgrids.settings.managedAi.title", "Managed AI") }),
+        /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr(
+          "fluidgrids.settings.managedAi.disclosure",
+          "Managed AI sends prompts and relevant workflow context to configured external AI providers. Turning it off stops new managed requests; requests already started may finish."
+        ) }),
+        /* @__PURE__ */ jsx(
+          "a",
+          {
+            href: "https://www.fluidgrids.ai/ai-terms",
+            target: "_blank",
+            rel: "noopener noreferrer",
+            className: "text-sm text-text-primary underline underline-offset-4",
+            children: tr("fluidgrids.settings.managedAi.terms", "Read AI Product Terms")
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          ManagedAiPolicyStatus,
+          {
+            policy,
+            loading,
+            error,
+            workspaceWideRequired,
+            children: policy && /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(
+              ManagedAiPolicyControls,
+              {
+                policy,
+                canManage,
+                activelyEnabled,
+                acknowledged,
+                setAcknowledged,
+                saving,
+                saveFailed,
+                change
+              }
+            ) })
+          }
+        ),
+        saveFailed && /* @__PURE__ */ jsx("p", { role: "alert", children: tr(
+          "fluidgrids.settings.managedAi.saveFailed",
+          "The change could not be confirmed. Reload the current setting before trying again."
+        ) }),
+        /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: reload, disabled: loading || saving, children: tr("fluidgrids.settings.managedAi.reload", "Reload current setting") })
+      ]
+    }
+  );
+}
+function ManagedAiPolicyControls({
+  policy,
+  canManage,
+  activelyEnabled,
+  acknowledged,
+  setAcknowledged,
+  saving,
+  saveFailed,
+  change
+}) {
+  const tr = useTr();
+  return canManage ? /* @__PURE__ */ jsxs(Fragment, { children: [
+    !activelyEnabled && /* @__PURE__ */ jsxs("label", { className: "flex items-start gap-3 text-sm text-text-secondary", children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "checkbox",
+          checked: acknowledged,
+          onChange: (event) => setAcknowledged(event.target.checked),
+          disabled: saving || saveFailed
+        }
+      ),
+      tr(
+        "fluidgrids.settings.managedAi.acknowledge",
+        "I reviewed the current AI disclosure and approve managed AI requests for this workspace."
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        onClick: () => void change(!activelyEnabled),
+        disabled: saving || saveFailed || !activelyEnabled && !acknowledged,
+        children: saving ? tr("fluidgrids.settings.managedAi.saving", "Saving\u2026") : activelyEnabled ? tr("fluidgrids.settings.managedAi.disable", "Turn off managed AI") : tr("fluidgrids.settings.managedAi.enable", "Enable managed AI")
+      }
+    ),
+    !policy.enforcementActive && policy.enrollmentAvailable === true && /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "outline",
+        onClick: () => void change(false),
+        disabled: saving || saveFailed,
+        children: tr("fluidgrids.settings.managedAi.disable", "Turn off managed AI")
+      }
+    )
+  ] }) : /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr(
+    "fluidgrids.settings.managedAi.ownerOnly",
+    "A workspace administrator manages this setting."
+  ) });
+}
+function ManagedAiPolicyStatus({
+  policy,
+  loading,
+  error,
+  workspaceWideRequired,
+  children
+}) {
+  const tr = useTr();
+  if (loading)
+    return /* @__PURE__ */ jsx("p", { role: "status", children: tr(
+      "fluidgrids.settings.managedAi.loading",
+      "Loading workspace AI settings\u2026"
+    ) });
+  if (error || !policy)
+    return /* @__PURE__ */ jsx("p", { role: "alert", children: workspaceWideRequired ? tr(
+      "fluidgrids.settings.managedAi.workspaceWideRequired",
+      "Select the workspace without a project, then reload its AI setting."
+    ) : tr(
+      "fluidgrids.settings.managedAi.loadFailed",
+      "Workspace AI settings could not be loaded. Reload before changing approval."
+    ) });
+  if (!policy.enforcementActive && policy.enrollmentAvailable !== true)
+    return /* @__PURE__ */ jsx("p", { role: "status", children: tr(
+      "fluidgrids.settings.managedAi.pending",
+      "Workspace AI controls are not active yet. Existing managed AI behavior is unchanged, and no approval change can be saved."
+    ) });
+  if (!policy.enforcementActive) {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("p", { role: "status", className: "text-sm text-text-secondary", children: tr(
+        "fluidgrids.settings.managedAi.enrollmentAvailable",
+        "Workspace AI controls are available. Existing managed AI behavior continues until an administrator saves a choice. You can turn off new managed requests without approving provider use."
+      ) }),
+      children
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("p", { className: "font-medium text-text-primary", role: "status", children: policy.enabled ? tr(
+      "fluidgrids.settings.managedAi.enabled",
+      "Managed AI is on for this workspace."
+    ) : tr(
+      "fluidgrids.settings.managedAi.disabled",
+      "Managed AI is off for this workspace."
+    ) }),
+    children
+  ] });
+}
+function ManagedAiSettings() {
+  const authority = useManagedAiPolicyAuthority();
+  const read = useFluidGridsPermission(FLUIDGRIDS_PERMISSIONS.WORKFLOW_READ);
+  const manage = useFluidGridsPermission(
+    FLUIDGRIDS_PERMISSIONS.SYSTEM_CONFIG_MANAGE
+  );
+  const state = useManagedAiWorkspacePolicy(authority, read.allowed);
+  if (!authority || !read.allowed) return null;
+  const scopeKey = JSON.stringify([
+    authority.authority,
+    authority.url,
+    authority.actorId,
+    authority.workspaceId,
+    authority.organizationId,
+    authority.tenantId,
+    authority.projectId
+  ]);
+  return /* @__PURE__ */ jsx(
+    ManagedAiPolicyCard,
+    {
+      ...state,
+      scopeKey,
+      canManage: manage.enforced && manage.allowed
+    }
+  );
+}
 function SettingRow({
   label,
   description,
@@ -3643,7 +4120,10 @@ function SettingsPage({
           ]
         }
       ),
-      /* @__PURE__ */ jsx(TabsContent, { value: "general", children: /* @__PURE__ */ jsx(GeneralTab, {}) }),
+      /* @__PURE__ */ jsxs(TabsContent, { value: "general", children: [
+        /* @__PURE__ */ jsx(GeneralTab, {}),
+        /* @__PURE__ */ jsx("div", { className: "mt-6", children: /* @__PURE__ */ jsx(ManagedAiSettings, {}) })
+      ] }),
       /* @__PURE__ */ jsx(TabsContent, { value: "execution", children: /* @__PURE__ */ jsx(ExecutionTab, { workflowKey }) }),
       /* @__PURE__ */ jsx(TabsContent, { value: "run-data", children: /* @__PURE__ */ jsx(RunDataTab, {}) }),
       runControlSettings ? /* @__PURE__ */ jsx(TabsContent, { value: "run-control", children: /* @__PURE__ */ jsx(RunControlTab, { flags: phaseC }) }) : null,
@@ -3656,5 +4136,47 @@ function SettingsPage({
     ] })
   ] });
 }
+function ManagedAiPolicyAuthorityProvider({
+  scope,
+  children
+}) {
+  const {
+    authority,
+    url,
+    actorId,
+    workspaceId,
+    organizationId,
+    tenantId,
+    projectId,
+    authToken,
+    workspaceToken
+  } = scope ?? {};
+  const value = useMemo(() => {
+    if (!authority || !url || !actorId || !workspaceId || !organizationId || !tenantId || !authToken)
+      return null;
+    return Object.freeze({
+      authority,
+      url,
+      actorId,
+      workspaceId,
+      organizationId,
+      tenantId,
+      projectId,
+      authToken,
+      workspaceToken
+    });
+  }, [
+    authority,
+    url,
+    actorId,
+    workspaceId,
+    organizationId,
+    tenantId,
+    projectId,
+    authToken,
+    workspaceToken
+  ]);
+  return /* @__PURE__ */ jsx(ManagedAiAuthorityContext.Provider, { value, children });
+}
 
-export { SettingsPage };
+export { ManagedAiPolicyAuthorityProvider, SettingsPage };

package/dist/{chunk-V7MQXTHD.js → chunk-XSUFTJCE.js}

@@ -1,9 +1,9 @@
-import { SdkPermissionGate, FLUIDGRIDS_PERMISSIONS } from './chunk-AR22A74Y.js';
+import { SdkPermissionGate, FLUIDGRIDS_PERMISSIONS } from './chunk-ERT444RG.js';
 import { useBuilderReadOnly } from './chunk-SDZEAIIE.js';
 import { STICKY_NOTE_TYPE, useFlowStore, resolveOperationName, synchronizeOperationUpdate, isNodeTrigger, resolveOutputHandles, resolveInputHandles, outputHandlesSpacerHeight, WAIT_FOR_SIGNAL_NODE_TYPE, CODE_WORKFLOW_NODE_TYPE, readSignalName, LogicNodeCard, NodeCard, NodeCardHeader, NodeCardBody, InputHandles, OutputHandles, NodeTypeIcon, nodeAccent, readCodeWorkflowState, partitionStickyNotes, interfaceFields, interfaceHandlers } from './chunk-X3F5IQBP.js';
 import { getGlobalStoreClient, createGlobalStoreClient, setGlobalStoreClient, resetGlobalStoreClient } from './chunk-TYI2XOSI.js';
 import { GetMyNodeInstallationsDocument } from './chunk-G77IGC3Y.js';
-import { fetchAllNodeEndpointConfigs, NodeManifestDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, ExecuteStepDocument, TriggerWorkflowDocument, RunFromNodeDocument, ExecutionDetailDocument, WorkflowDefinitionDocument, WorkflowRunDocument } from './chunk-ZGUW4GHR.js';
+import { fetchAllNodeEndpointConfigs, NodeManifestDocument, UpdateWorkflowDefinitionDocument, CreateWorkflowDefinitionDocument, CreateWorkflowVersionDocument, ExecuteStepDocument, TriggerWorkflowDocument, RunFromNodeDocument, ExecutionDetailDocument, WorkflowDefinitionDocument, WorkflowRunDocument } from './chunk-VAWYR6P4.js';
 import { useTr, ENGLISH_FALLBACK_TRANSLATOR, FluidGridsTranslationProvider } from './chunk-UULVIT25.js';
 import { waitForFluidGridsClient, getFluidGridsClient, getFluidGridsClientSafe, createFluidGridsClient, setFluidGridsClient, resetFluidGridsClient } from './chunk-PDODDDHY.js';
 import { throwIfResultError, emitFluidGridsEvent, emitOperationErrorEvent, describeOperationError, emitRunCompletedOnce } from './chunk-JKLZ6YZ3.js';

package/dist/{chunk-R6GXIC2D.js → chunk-ZE7AHJWF.js}

@@ -1,10 +1,10 @@
-import { FailureTriagePanel } from './chunk-I567MFKA.js';
+import { FailureTriagePanel } from './chunk-Q526TUOC.js';
 import { aiSpendPeriod, AI_SPEND_RANGE_DAYS, evidenceFacts, monthlySavingLabel, evidenceWindowDays, shortRunId, DISMISS_REASONS, MAX_DISMISS_NOTE_LENGTH, aiCost, formatTokens, runsOfWorkflowPath } from './chunk-NZAYYUQ4.js';
-import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-HBMU63XF.js';
+import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-3CAYQ57D.js';
 import { proposalCanvasPath } from './chunk-GLYINMOR.js';
-import { useContinuousOptimisationEnabled } from './chunk-V7MQXTHD.js';
-import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-AR22A74Y.js';
-import { SetContinuousOptimisationEnabledDocument, FgRunOptimisationScanDocument, ProposeOptimisationDocument, WorkflowProposalDocument, DismissOptimisationSuggestionDocument, SnoozeOptimisationSuggestionDocument, WorkspaceAiUsageDocument, OptimisationSuggestionsDocument, ContinuousOptimisationSettingsDocument } from './chunk-ZGUW4GHR.js';
+import { useContinuousOptimisationEnabled } from './chunk-XSUFTJCE.js';
+import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-ERT444RG.js';
+import { SetContinuousOptimisationEnabledDocument, FgRunOptimisationScanDocument, ProposeOptimisationDocument, WorkflowProposalDocument, DismissOptimisationSuggestionDocument, SnoozeOptimisationSuggestionDocument, WorkspaceAiUsageDocument, OptimisationSuggestionsDocument, ContinuousOptimisationSettingsDocument } from './chunk-VAWYR6P4.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-PDODDDHY.js';
 import { throwIfResultError } from './chunk-JKLZ6YZ3.js';

package/dist/{chunk-3RZYBITM.js → chunk-ZMEBM2GZ.js}

@@ -1,11 +1,11 @@
-import { useRunStatusCounts, ExecutionStats, ExecutionFilters, ExecutionTable, ExecutionCards, ExecutionTimeline, Pagination, runStatusLabels } from './chunk-BR7MKKPP.js';
-import { useExecutionsWithStore, useExecutionStats, useExecutionActions, useAutoRefresh, searchFilterConflicts, WORKFLOW_ID_MAX_LENGTH, EMPTY_SEARCH_FILTER, buildSearchAttributeFilter, MAX_SEARCH_CONDITIONS, OPERATORS_BY_TYPE } from './chunk-6BO4LPNT.js';
-import { useResource, fetchSearchAttributes, NativeSelect, FieldError, RUN_CONTROL_DIALOG_STYLE, parseJsonInput, JsonField, fetchBatchOperations, StatusPill, fetchBatchOperation, cancelBatchOperation, startBatchTerminate, startBatchExport, startBatchOperation, jsonArg } from './chunk-ACNJS4OL.js';
-import { useWorkflowDefinitions } from './chunk-RIJ7IB5D.js';
+import { useRunStatusCounts, ExecutionStats, ExecutionFilters, ExecutionTable, ExecutionCards, ExecutionTimeline, Pagination, runStatusLabels } from './chunk-EGCUHKON.js';
+import { useExecutionsWithStore, useExecutionStats, useExecutionActions, useAutoRefresh, searchFilterConflicts, WORKFLOW_ID_MAX_LENGTH, EMPTY_SEARCH_FILTER, buildSearchAttributeFilter, MAX_SEARCH_CONDITIONS, OPERATORS_BY_TYPE } from './chunk-OJPRKEP4.js';
+import { useResource, fetchSearchAttributes, NativeSelect, FieldError, RUN_CONTROL_DIALOG_STYLE, parseJsonInput, JsonField, fetchBatchOperations, StatusPill, fetchBatchOperation, cancelBatchOperation, startBatchTerminate, startBatchExport, startBatchOperation, jsonArg } from './chunk-5YLS3WH5.js';
+import { useWorkflowDefinitions } from './chunk-JFUQH6HV.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { useDurableParityEnabled, usePhaseCFlags } from './chunk-V7MQXTHD.js';
-import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-AR22A74Y.js';
-import { WorkflowBatchOperationUpdatedDocument } from './chunk-ZGUW4GHR.js';
+import { useDurableParityEnabled, usePhaseCFlags } from './chunk-XSUFTJCE.js';
+import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-ERT444RG.js';
+import { WorkflowBatchOperationUpdatedDocument } from './chunk-VAWYR6P4.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-PDODDDHY.js';
 import { describeOperationError } from './chunk-JKLZ6YZ3.js';

package/dist/executions.js

@@ -1,32 +1,32 @@
 import './chunk-AD3BXTJS.js';
-export { ExecutionDetailPage } from './chunk-M2MTUG6O.js';
-import './chunk-IOW5LL6I.js';
-export { ExecutionsListPage } from './chunk-3RZYBITM.js';
-import './chunk-BR7MKKPP.js';
-import './chunk-6BO4LPNT.js';
-import './chunk-I567MFKA.js';
+export { ExecutionDetailPage } from './chunk-ODXI4P3V.js';
+import './chunk-MUIVZFIU.js';
+export { ExecutionsListPage } from './chunk-ZMEBM2GZ.js';
+import './chunk-EGCUHKON.js';
+import './chunk-OJPRKEP4.js';
+import './chunk-Q526TUOC.js';
 import './chunk-NZAYYUQ4.js';
 import './chunk-OJHBCOBA.js';
-import './chunk-ACNJS4OL.js';
+import './chunk-5YLS3WH5.js';
 import './chunk-WZ3EJVS6.js';
 import './chunk-5ERAJC2I.js';
-import './chunk-TJKT64AI.js';
+import './chunk-MYE6CMGK.js';
 import './chunk-JDLQ6QIB.js';
-import './chunk-D6NTP4FK.js';
+import './chunk-DFFQYK2X.js';
 import './chunk-Y53CVZVV.js';
 import './chunk-FNZZ5JJL.js';
-import './chunk-RIJ7IB5D.js';
+import './chunk-JFUQH6HV.js';
 import './chunk-PJAWNFJV.js';
 import './chunk-4VJ3MDOV.js';
-import './chunk-W5UXYPBV.js';
-import './chunk-V7MQXTHD.js';
-import './chunk-AR22A74Y.js';
+import './chunk-POCNG3PM.js';
+import './chunk-XSUFTJCE.js';
+import './chunk-ERT444RG.js';
 import './chunk-SDZEAIIE.js';
 import './chunk-X3F5IQBP.js';
 import './chunk-Y7FKJJMF.js';
 import './chunk-TYI2XOSI.js';
 import './chunk-G77IGC3Y.js';
-import './chunk-ZGUW4GHR.js';
+import './chunk-VAWYR6P4.js';
 import './chunk-JL7CASN5.js';
 import './chunk-UULVIT25.js';
 import './chunk-PDODDDHY.js';