@burdenoff/fluidgrids-fe-sdk 2026.1108.6 → 2026.1109.2

package/dist/{chunk-LOMLLWHD.js → chunk-SUQVJ2Y7.js}

@@ -1,28 +1,465 @@
-import { AgentsTab } from './chunk-D5Y3DHGJ.js';
+import { AgentsTab } from './chunk-S4A646OO.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-YASVILWQ.js';
-import { LogStreamingTab } from './chunk-POYMF7L6.js';
+import { useResource, fetchPauseRules, FieldError, fetchSearchAttributes, StatusPill, NativeSelect, fetchArchiveSettings, fetchCodecServerSettings, deletePauseRule, createPauseRule, deleteSearchAttribute, createSearchAttribute, saveArchiveSettings, clearArchiveSettings, saveCodecServerSettings } from './chunk-Y6HULMZS.js';
+import { LogStreamingTab } from './chunk-62AXA6DK.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { useFluidGridsFlag, FLUIDGRIDS_FLAGS, usePhaseCFlags, useSaveStatusStore, findSaveConflict, useDurableParityEnabled, useConnections } from './chunk-GI6BQIQA.js';
-import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-AR22A74Y.js';
+import { useFluidGridsFlag, FLUIDGRIDS_FLAGS, usePhaseCFlags, useSaveStatusStore, findSaveConflict, useDurableParityEnabled, useConnections } from './chunk-62DQJ7V7.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-GOZR72NK.js';
+import { useWorkflowDefinitionQuery, useUpdateWorkflowDefinitionMutation, useWorkflowDefinitionsQuery, ManagedAiWorkspacePolicyDocument, UpdateManagedAiWorkspacePolicyDocument, DurableHistoryCapsDocument, UpdateDurableHistoryCapsDocument } from './chunk-ZPPF65KT.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.enabled !== "boolean" || !Number.isSafeInteger(value.revision) || value.revision < 0 || typeof value.requiredConsentVersion !== "string" || !value.requiredConsentVersion || value.requiredConsentVersion.length > 128) {
+    throw new Error("Managed AI policy could not be confirmed.");
+  }
+  return {
+    enforcementActive: value.enforcementActive,
+    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.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
+  ]);
+  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 change = async (enabled) => {
+    if (!policy?.enforcementActive || !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: canManage ? /* @__PURE__ */ jsxs(Fragment, { children: [
+              !policy.enabled && /* @__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(!policy.enabled),
+                  disabled: saving || saveFailed || !policy.enabled && !acknowledged,
+                  children: saving ? tr("fluidgrids.settings.managedAi.saving", "Saving\u2026") : policy.enabled ? tr(
+                    "fluidgrids.settings.managedAi.disable",
+                    "Turn off managed AI"
+                  ) : tr(
+                    "fluidgrids.settings.managedAi.enable",
+                    "Enable managed AI"
+                  )
+                }
+              )
+            ] }) : /* @__PURE__ */ jsx("p", { className: "text-sm text-text-secondary", children: tr(
+              "fluidgrids.settings.managedAi.ownerOnly",
+              "A workspace administrator manages this setting."
+            ) }) })
+          }
+        ),
+        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 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)
+    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."
+    ) });
+  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 +4080,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 +4096,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-HICQ4J4W.js → chunk-SUXYCC3X.js}

@@ -1,4 +1,4 @@
-import { FluidgridsEntityTagsDocument, AvailableFluidgridsTagsDocument, SearchFluidgridsTagsDocument, TagFluidgridsEntityDocument, UntagFluidgridsEntityDocument, ReplaceFluidgridsEntityTagsDocument, CreateFluidgridsTagDocument, DataTablesTagsDocument } from './chunk-GOZR72NK.js';
+import { FluidgridsEntityTagsDocument, AvailableFluidgridsTagsDocument, SearchFluidgridsTagsDocument, TagFluidgridsEntityDocument, UntagFluidgridsEntityDocument, ReplaceFluidgridsEntityTagsDocument, CreateFluidgridsTagDocument, DataTablesTagsDocument } from './chunk-ZPPF65KT.js';
 import { getFluidGridsClient } from './chunk-PDODDDHY.js';
 import { useState, useCallback, useEffect } from 'react';
 

package/dist/{chunk-HQSSW7K3.js → chunk-UKQXYQPG.js}

@@ -1,14 +1,14 @@
-import { CreateWorkflowRefusalDialog, firstWorkflowProgress, GUIDED_TOUR_STATE, builderPathFor } from './chunk-7XW6BC4B.js';
-import { useExecutions } from './chunk-JRR4VKYD.js';
-import { useExportWorkflowAs, WorkflowShareDialog, downloadWorkflowExport, importAcceptAttribute, canEditWorkflow, canShareWorkflow, QuotaExhaustedDialog, importFileKind, parseWorkflowImport, CODE_EXPORT_FORMATS, ImportSourceError, assertImportByteSize, MAX_IMPORT_ARCHIVE_BYTES, readProjectArchive, checkTypeScriptImport, MAX_IMPORT_SOURCE_BYTES, typeScriptModuleFile, typeScriptImportSource, workflowNameFromFile, primaryImportModule } from './chunk-JSJSBB76.js';
+import { CreateWorkflowRefusalDialog, firstWorkflowProgress, GUIDED_TOUR_STATE, builderPathFor } from './chunk-X4HCPG2E.js';
+import { useExecutions } from './chunk-XOP5EU72.js';
+import { useExportWorkflowAs, WorkflowShareDialog, downloadWorkflowExport, importAcceptAttribute, canEditWorkflow, canShareWorkflow, QuotaExhaustedDialog, importFileKind, parseWorkflowImport, CODE_EXPORT_FORMATS, ImportSourceError, assertImportByteSize, MAX_IMPORT_ARCHIVE_BYTES, readProjectArchive, checkTypeScriptImport, MAX_IMPORT_SOURCE_BYTES, typeScriptModuleFile, typeScriptImportSource, workflowNameFromFile, primaryImportModule } from './chunk-BA6WBJIB.js';
 import { workflowsListControls } from './chunk-FNZZ5JJL.js';
-import { useCreateWorkflow, useWorkflowDefinitions, useLazyWorkflowDefinition, useImportWorkflow, usePreviewN8nImport, useDuplicateWorkflow, useDeleteWorkflow } from './chunk-KJB3WZVD.js';
+import { useCreateWorkflow, useWorkflowDefinitions, useLazyWorkflowDefinition, useImportWorkflow, usePreviewN8nImport, useDuplicateWorkflow, useDeleteWorkflow } from './chunk-6ZB7AYSA.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { createThenOpen, FluidGridsContext, useFluidGridsFlag, FLUIDGRIDS_FLAGS, BILLING_PLANS_PATH, isQuotaExhaustedFailure } from './chunk-GI6BQIQA.js';
-import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton, SdkPermissionGate } from './chunk-AR22A74Y.js';
+import { createThenOpen, FluidGridsContext, useFluidGridsFlag, FLUIDGRIDS_FLAGS, BILLING_PLANS_PATH, isQuotaExhaustedFailure } from './chunk-62DQJ7V7.js';
+import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton, SdkPermissionGate } from './chunk-ERT444RG.js';
 import { useFlowStore } from './chunk-X3F5IQBP.js';
-import { WorkflowFoldersDocument, CreateWorkflowFolderDocument, RenameWorkflowFolderDocument, MoveWorkflowFolderDocument, DeleteWorkflowFolderDocument, WorkflowProjectsDocument, CreateWorkflowProjectDocument, RenameWorkflowProjectDocument, DeleteWorkflowProjectDocument, BulkMoveWorkflowsToFolderDocument, BulkAssignWorkflowsToProjectDocument, BulkDeleteWorkflowsDocument } from './chunk-GOZR72NK.js';
+import { WorkflowFoldersDocument, CreateWorkflowFolderDocument, RenameWorkflowFolderDocument, MoveWorkflowFolderDocument, DeleteWorkflowFolderDocument, WorkflowProjectsDocument, CreateWorkflowProjectDocument, RenameWorkflowProjectDocument, DeleteWorkflowProjectDocument, BulkMoveWorkflowsToFolderDocument, BulkAssignWorkflowsToProjectDocument, BulkDeleteWorkflowsDocument } from './chunk-ZPPF65KT.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-PDODDDHY.js';
 import { describeOperationError, throwIfResultError } from './chunk-JKLZ6YZ3.js';

package/dist/{chunk-RNYFPG7R.js → chunk-VD4WCZJX.js}

@@ -1,10 +1,10 @@
-import { validateDateRange, statusCountFilter, STATUS_COUNT_GROUP_BY, statusCountsOf } from './chunk-JRR4VKYD.js';
+import { validateDateRange, statusCountFilter, STATUS_COUNT_GROUP_BY, statusCountsOf } from './chunk-XOP5EU72.js';
 import { isAgentNodeType } from './chunk-WZ3EJVS6.js';
-import { useAvailableTags, formatRunVersion, nodeDisplayTitle } from './chunk-HICQ4J4W.js';
+import { useAvailableTags, formatRunVersion, nodeDisplayTitle } from './chunk-SUXYCC3X.js';
 import { executionsControls } from './chunk-FNZZ5JJL.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
-import { useDurableParityEnabled, formatElapsedMs, runDurationMs, nodeStateDurationMs } from './chunk-GI6BQIQA.js';
-import { SetWorkflowRunVersioningOverrideDocument, WorkflowRunsCountDocument, DurableParityRunFieldsDocument, WorkflowRunPendingDocument, WorkflowRunMetadataDocument } from './chunk-GOZR72NK.js';
+import { useDurableParityEnabled, formatElapsedMs, runDurationMs, nodeStateDurationMs } from './chunk-62DQJ7V7.js';
+import { SetWorkflowRunVersioningOverrideDocument, WorkflowRunsCountDocument, DurableParityRunFieldsDocument, WorkflowRunPendingDocument, WorkflowRunMetadataDocument } from './chunk-ZPPF65KT.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-PDODDDHY.js';
 import { throwIfResultError, describeOperationError } from './chunk-JKLZ6YZ3.js';