@burdenoff/fluidgrids-fe-sdk 2026.1109.8 → 2026.1110.1

package/dist/{chunk-GR3QNLFS.js → chunk-5LUYJTT4.js}

@@ -1,9 +1,9 @@
-import { validateDateRange, statusCountFilter, STATUS_COUNT_GROUP_BY, statusCountsOf } from './chunk-ACME5GOU.js';
-import { isAgentNodeType } from './chunk-WZ3EJVS6.js';
+import { validateDateRange, statusCountFilter, STATUS_COUNT_GROUP_BY, statusCountsOf } from './chunk-JCFFPZAB.js';
 import { useAvailableTags, formatRunVersion, nodeDisplayTitle } from './chunk-DFFQYK2X.js';
 import { executionsControls } from './chunk-FNZZ5JJL.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
-import { useDurableParityEnabled, formatElapsedMs, runDurationMs, nodeStateDurationMs } from './chunk-VYXTP6YF.js';
+import { isAgentNodeType } from './chunk-WZ3EJVS6.js';
+import { useDurableParityEnabled, formatElapsedMs, runDurationMs, nodeStateDurationMs } from './chunk-3OG6EBHP.js';
 import { SetWorkflowRunVersioningOverrideDocument, WorkflowRunsCountDocument, DurableParityRunFieldsDocument, WorkflowRunPendingDocument, WorkflowRunMetadataDocument } from './chunk-VAWYR6P4.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-PDODDDHY.js';

package/dist/{chunk-MSNCU6US.js → chunk-5NFUNLE7.js}

@@ -1,11 +1,11 @@
-import { TEMPLATE_STORE_CATEGORIES, useImportWorkflowTemplate, FlowBuilderPage, useWorkflowTemplates, TemplateCard, useTemplateSubmissions, usePublishToStore } from './chunk-2LERIIZM.js';
-import { QuotaExhaustedDialog } from './chunk-QWDF72GZ.js';
+import { TEMPLATE_STORE_CATEGORIES, useImportWorkflowTemplate, FlowBuilderPage, useWorkflowTemplates, TemplateCard, useTemplateSubmissions, usePublishToStore } from './chunk-ZJU462XH.js';
+import { QuotaExhaustedDialog } from './chunk-Z4MJLIKO.js';
 import { templatesControls } from './chunk-FNZZ5JJL.js';
-import { useWorkflowDefinitions, useDuplicateWorkflow, useLazyWorkflowDefinition } from './chunk-ZXLXZFWO.js';
+import { useWorkflowDefinitions, useDuplicateWorkflow, useLazyWorkflowDefinition } from './chunk-PL2YUQK3.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { BILLING_PLANS_PATH, useFluidGridsAnalytics, emitTemplateUsed, isQuotaExhaustedFailure } from './chunk-VYXTP6YF.js';
 import { SdkPermissionButton, FLUIDGRIDS_PERMISSIONS } from './chunk-ERT444RG.js';
+import { BILLING_PLANS_PATH, useFluidGridsAnalytics, emitTemplateUsed, isQuotaExhaustedFailure } from './chunk-3OG6EBHP.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useEffect, useCallback, useMemo } from 'react';
 import { useParams, useNavigate } from 'react-router';

package/dist/{chunk-G4NAU6FF.js → chunk-6EXTNKOP.js}

@@ -1,12 +1,12 @@
-import { paramsFromOperation } from './chunk-NEB4Y7AX.js';
 import { isGuidedTourIntent, pickGuidedTour, withoutGuidedTourIntent, isCreateIntent, decideMissingWorkflow } from './chunk-NRI7AUBH.js';
 import { registerLiveCanvasHandler } from './chunk-PIKYQE7P.js';
-import { useWorkflowReloadStore, releaseLeaseKeptForReload, useInstalledNodes, buildNodeCheck, FlowBuilderPage, buildRequiredNodeTypes } from './chunk-2LERIIZM.js';
-import { CreateWorkflowRefusalDialog } from './chunk-QWDF72GZ.js';
-import { canvasFromDefinition } from './chunk-5UA262ZO.js';
-import { useLazyWorkflowDefinition, useCreateWorkflow } from './chunk-ZXLXZFWO.js';
-import { refetchStoreNodes, BILLING_PLANS_PATH, ensureNodeConfigsLoaded, codeBuildIdOf, rememberRevision, blankWorkflowCreateInput, classifyCreateRefusal, NODE_CONFIGS, resolveNodeOperation, createConfiguredNode, useSaveStatusStore, workflowFingerprint, registerWorkflowNodeTypes } from './chunk-VYXTP6YF.js';
-import { useFlowStore, mergeStickyNotes } from './chunk-JXCJRBWD.js';
+import { useWorkflowReloadStore, releaseLeaseKeptForReload, useInstalledNodes, buildNodeCheck, FlowBuilderPage, buildRequiredNodeTypes } from './chunk-ZJU462XH.js';
+import { paramsFromOperation } from './chunk-JJYKTBEF.js';
+import { CreateWorkflowRefusalDialog } from './chunk-Z4MJLIKO.js';
+import { canvasFromDefinition } from './chunk-CKF2FBUP.js';
+import { useLazyWorkflowDefinition, useCreateWorkflow } from './chunk-PL2YUQK3.js';
+import { refetchStoreNodes, BILLING_PLANS_PATH, ensureNodeConfigsLoaded, codeBuildIdOf, rememberRevision, blankWorkflowCreateInput, classifyCreateRefusal, NODE_CONFIGS, resolveNodeOperation, createConfiguredNode, useSaveStatusStore, workflowFingerprint, registerWorkflowNodeTypes } from './chunk-3OG6EBHP.js';
+import { useFlowStore, mergeStickyNotes } from './chunk-K2X63CR2.js';
 import { WorkflowDefinitionDocument } from './chunk-VAWYR6P4.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-PDODDDHY.js';

package/dist/{chunk-5UA262ZO.js → chunk-CKF2FBUP.js}

@@ -1,4 +1,4 @@
-import { mergeStickyNotes } from './chunk-JXCJRBWD.js';
+import { mergeStickyNotes } from './chunk-K2X63CR2.js';
 
 // src/builder/live/definition-canvas.ts
 function isRecord(value) {

package/dist/{chunk-3T3C3475.js → chunk-G7UY7DL4.js}

@@ -1,14 +1,15 @@
-import { signalPayloadCard, components_default, payloadFromCardValues, parseRawSignalPayload } from './chunk-VYXTP6YF.js';
+import { signalPayloadCard, payloadFromCardValues, parseRawSignalPayload } from './chunk-3OG6EBHP.js';
 import { TerminateWorkflowRunDocument, WorkflowRunHistoryDocument, RunEventAppendedDocument, DurableRunFieldsDocument, WorkflowRunDeterminismStatusDocument, WorkflowRunStackTraceDocument, SignalWorkflowRunDocument } from './chunk-VAWYR6P4.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient, getFluidGridsClientSafe } from './chunk-PDODDDHY.js';
 import { throwIfResultError, describeOperationError } from './chunk-JKLZ6YZ3.js';
-import { useState, useMemo, useRef, useCallback, useEffect } from 'react';
+import { forwardRef, useRef, useEffect, useImperativeHandle, useState, useMemo, useCallback } from 'react';
 import { Icon } from '@iconify/react';
 import { Button } from '@burdenoff/fe-libs/button';
 import { cn } from '@burdenoff/fe-libs/utils';
 import { jsxs, jsx } from 'react/jsx-runtime';
 import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, Label, Textarea, DialogFooter, Input } from '@burdenoff/fe-libs/ui';
+import * as AdaptiveCards from 'adaptivecards';
 
 // src/modules/executions/utils/run-history.ts
 function isRecord(value) {
@@ -744,6 +745,552 @@ function useRunStackTrace(runId, enabled) {
   }, [refetch]);
   return { trace, loading, error, refetch };
 }
+
+// src/modules/adaptive-cards/components/coerce.ts
+function optionalDeclaration(value) {
+  const declaration = typeof value === "string" ? { type: value } : value;
+  if (!declaration || typeof declaration !== "object" || Array.isArray(declaration))
+    return null;
+  const fields = Object.fromEntries(Object.entries(declaration));
+  if (typeof fields.type !== "string" || !/^(string|boolean|number|integer|array(?:<.+>)?|object|json)$/i.test(
+    fields.type.trim()
+  ))
+    return null;
+  if (Object.hasOwn(fields, "required") && fields.required !== false)
+    return null;
+  return fields;
+}
+function coerceSubmittedDataFromCard(submittedData, cardData, context) {
+  const fieldTypeMap = {};
+  const literalDefaults = /* @__PURE__ */ new Set();
+  const integerFields = /* @__PURE__ */ new Set();
+  function extractInputTypes(elements) {
+    for (const element of elements) {
+      if (element.type?.startsWith("Input") && element.id) {
+        fieldTypeMap[element.id] = element.type;
+        if (element.value !== void 0 && (typeof element.value !== "string" || !element.value.includes("${"))) {
+          literalDefaults.add(element.id);
+        }
+        if (element.type === "Input.Number" && element.isInteger === true) {
+          integerFields.add(element.id);
+        }
+      }
+      if (Array.isArray(element.items)) {
+        extractInputTypes(element.items);
+      }
+      if (Array.isArray(element.columns)) {
+        for (const column of element.columns) {
+          if (column.items) {
+            extractInputTypes(column.items);
+          }
+        }
+      }
+      if (Array.isArray(element.actions)) {
+        extractFromActions(element.actions);
+      }
+    }
+  }
+  function extractFromActions(actions) {
+    for (const action of actions) {
+      const nested = action?.card;
+      if (nested && typeof nested === "object") {
+        if (Array.isArray(nested.body)) {
+          extractInputTypes(nested.body);
+        }
+        if (Array.isArray(nested.actions)) {
+          extractFromActions(nested.actions);
+        }
+      }
+    }
+  }
+  if (Array.isArray(cardData.body)) {
+    extractInputTypes(cardData.body);
+  }
+  if (Array.isArray(cardData.actions)) {
+    extractFromActions(
+      cardData.actions
+    );
+  }
+  const coercedData = {};
+  for (const key in submittedData) {
+    const value = submittedData[key];
+    const type = fieldTypeMap[key];
+    const field = key.replace(/^(?:args\.)?state\./, "");
+    const declaration = optionalDeclaration(context?.inputFields?.[field]);
+    if (context && declaration && !context.changedInputs.has(key)) {
+      const initialKey = [
+        key,
+        field,
+        `args.state.${field}`,
+        `state.${field}`
+      ].find((candidate) => Object.hasOwn(context.initialValues, candidate));
+      if (initialKey !== void 0) {
+        coercedData[key] = context.initialValues[initialKey];
+        continue;
+      }
+      if (Object.hasOwn(declaration, "default")) {
+        coercedData[key] = declaration.default;
+        continue;
+      }
+      if (!literalDefaults.has(key)) continue;
+    }
+    switch (type) {
+      case "Input.Number":
+        if (value === void 0 || value === "") {
+          coercedData[key] = void 0;
+        } else if (integerFields.has(key)) {
+          coercedData[key] = Math.trunc(Number(value));
+        } else {
+          coercedData[key] = Number(value);
+        }
+        break;
+      case "Input.Toggle":
+        coercedData[key] = value === "true" || value === true;
+        break;
+      default:
+        coercedData[key] = value;
+    }
+  }
+  return coercedData;
+}
+function isAdaptiveCard(data) {
+  return data.type === "AdaptiveCard";
+}
+function isCustomFormat(data) {
+  const record = data;
+  return record.type !== "AdaptiveCard" && "inputs" in record;
+}
+function expandTemplate(obj, data) {
+  if (typeof obj === "string") {
+    const singleVarMatch = obj.match(/^\$\{([^}]+)\}$/);
+    if (singleVarMatch) {
+      const key = singleVarMatch[1].trim();
+      const value = data[key];
+      if (value !== void 0 && value !== null) {
+        if (typeof value === "boolean") {
+          return value ? "true" : "false";
+        }
+        return value;
+      }
+      return "";
+    }
+    return obj.replace(/\$\{([^}]+)\}/g, (_match, key) => {
+      const trimmedKey = key.trim();
+      const value = data[trimmedKey];
+      if (value !== void 0 && value !== null) {
+        return String(value);
+      }
+      return "";
+    });
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => expandTemplate(item, data));
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === "defaultValue") {
+        continue;
+      }
+      result[key] = expandTemplate(value, data);
+    }
+    return result;
+  }
+  return obj;
+}
+function applyCustomStyles(container) {
+  const inputStyles = {
+    width: "100%",
+    padding: "0.5rem 0.75rem",
+    fontSize: "0.875rem",
+    lineHeight: "1.5",
+    borderRadius: "0.375rem",
+    border: "1px solid hsl(var(--input))",
+    backgroundColor: "hsl(var(--background))",
+    color: "hsl(var(--foreground))",
+    outline: "none",
+    transition: "border-color 0.2s ease, box-shadow 0.2s ease"
+  };
+  const addInputInteractivity = (input) => {
+    const originalBorder = "1px solid hsl(var(--input))";
+    input.addEventListener("mouseenter", () => {
+      if (document.activeElement !== input) {
+        input.style.borderColor = "hsl(var(--foreground) / 0.3)";
+      }
+    });
+    input.addEventListener("mouseleave", () => {
+      if (document.activeElement !== input) {
+        input.style.border = originalBorder;
+      }
+    });
+    input.addEventListener("focus", () => {
+      input.style.borderColor = "hsl(var(--ring))";
+      input.style.boxShadow = "0 0 0 2px hsl(var(--ring) / 0.2)";
+    });
+    input.addEventListener("blur", () => {
+      input.style.border = originalBorder;
+      input.style.boxShadow = "none";
+    });
+  };
+  const allInputs = container.querySelectorAll(
+    ".ac-textInput, .ac-numberInput, .ac-dateInput, .ac-timeInput"
+  );
+  allInputs.forEach((input) => {
+    Object.assign(input.style, inputStyles);
+    addInputInteractivity(input);
+  });
+  const textareas = container.querySelectorAll(".ac-multiline");
+  textareas.forEach((textarea) => {
+    Object.assign(textarea.style, {
+      ...inputStyles,
+      minHeight: "80px",
+      resize: "vertical"
+    });
+    addInputInteractivity(textarea);
+  });
+  const selects = container.querySelectorAll(
+    ".ac-choiceSetInput-compact, select"
+  );
+  selects.forEach((select) => {
+    Object.assign(select.style, {
+      ...inputStyles,
+      cursor: "pointer",
+      appearance: "none",
+      backgroundImage: `url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 20 20'%3e%3cpath stroke='%236b7280' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.5' d='M6 8l4 4 4-4'/%3e%3c/svg%3e")`,
+      backgroundPosition: "right 0.5rem center",
+      backgroundRepeat: "no-repeat",
+      backgroundSize: "1.5em 1.5em",
+      paddingRight: "2.5rem"
+    });
+    addInputInteractivity(select);
+  });
+  const radioGroups = container.querySelectorAll(
+    ".ac-choiceSetInput-expanded"
+  );
+  radioGroups.forEach((group) => {
+    Object.assign(group.style, {
+      display: "flex",
+      flexDirection: "column",
+      gap: "0.5rem"
+    });
+  });
+  const radios = container.querySelectorAll(
+    'input[type="radio"]'
+  );
+  radios.forEach((radio) => {
+    Object.assign(radio.style, {
+      width: "1rem",
+      height: "1rem",
+      accentColor: "hsl(var(--primary))",
+      cursor: "pointer",
+      transition: "transform 0.1s ease"
+    });
+    radio.addEventListener("mouseenter", () => {
+      radio.style.transform = "scale(1.1)";
+    });
+    radio.addEventListener("mouseleave", () => {
+      radio.style.transform = "scale(1)";
+    });
+    radio.addEventListener("focus", () => {
+      radio.style.outline = "2px solid hsl(var(--ring) / 0.3)";
+      radio.style.outlineOffset = "2px";
+    });
+    radio.addEventListener("blur", () => {
+      radio.style.outline = "none";
+    });
+  });
+  const checkboxes = container.querySelectorAll(
+    'input[type="checkbox"]'
+  );
+  checkboxes.forEach((checkbox) => {
+    Object.assign(checkbox.style, {
+      width: "1rem",
+      height: "1rem",
+      accentColor: "hsl(var(--primary))",
+      cursor: "pointer",
+      transition: "transform 0.1s ease"
+    });
+    checkbox.addEventListener("mouseenter", () => {
+      checkbox.style.transform = "scale(1.1)";
+    });
+    checkbox.addEventListener("mouseleave", () => {
+      checkbox.style.transform = "scale(1)";
+    });
+    checkbox.addEventListener("focus", () => {
+      checkbox.style.outline = "2px solid hsl(var(--ring) / 0.3)";
+      checkbox.style.outlineOffset = "2px";
+    });
+    checkbox.addEventListener("blur", () => {
+      checkbox.style.outline = "none";
+    });
+  });
+  const buttons = container.querySelectorAll(".ac-pushButton");
+  buttons.forEach((button) => {
+    Object.assign(button.style, {
+      padding: "0.5rem 1rem",
+      fontSize: "0.875rem",
+      fontWeight: "500",
+      borderRadius: "0.375rem",
+      border: "none",
+      backgroundColor: "hsl(var(--primary))",
+      color: "hsl(var(--primary-foreground))",
+      cursor: "pointer",
+      transition: "background-color 0.2s ease, transform 0.1s ease, box-shadow 0.2s ease"
+    });
+    button.addEventListener("mouseenter", () => {
+      button.style.backgroundColor = "hsl(var(--primary) / 0.9)";
+      button.style.boxShadow = "0 2px 4px hsl(var(--primary) / 0.3)";
+    });
+    button.addEventListener("mouseleave", () => {
+      button.style.backgroundColor = "hsl(var(--primary))";
+      button.style.boxShadow = "none";
+    });
+    button.addEventListener("focus", () => {
+      button.style.boxShadow = "0 0 0 2px hsl(var(--ring) / 0.3)";
+    });
+    button.addEventListener("blur", () => {
+      button.style.boxShadow = "none";
+    });
+    button.addEventListener("mousedown", () => {
+      button.style.transform = "scale(0.98)";
+    });
+    button.addEventListener("mouseup", () => {
+      button.style.transform = "scale(1)";
+    });
+  });
+  const textBlocks = container.querySelectorAll(".ac-textBlock");
+  textBlocks.forEach((textBlock) => {
+    if (textBlock.closest(".ac-toggleInput") || textBlock.closest(".ac-choiceSetInput-expanded")) {
+      Object.assign(textBlock.style, {
+        fontSize: "0.875rem",
+        fontWeight: "400",
+        color: "hsl(var(--foreground) / 0.8)"
+      });
+    } else {
+      Object.assign(textBlock.style, {
+        fontSize: "0.8125rem",
+        fontWeight: "500",
+        color: "hsl(var(--foreground) / 0.8)",
+        marginBottom: "0.25rem"
+      });
+    }
+  });
+  const actionSets = container.querySelectorAll(".ac-actionSet");
+  actionSets.forEach((actionSet) => {
+    Object.assign(actionSet.style, {
+      marginTop: "0.75rem",
+      paddingTop: "0.75rem",
+      borderTop: "1px solid hsl(var(--border))",
+      gap: "0.5rem"
+    });
+  });
+  const separators = container.querySelectorAll(
+    ".ac-horizontal-separator"
+  );
+  separators.forEach((separator) => {
+    Object.assign(separator.style, {
+      height: "0.5rem"
+    });
+  });
+  const images = container.querySelectorAll(".ac-image img");
+  images.forEach((img) => {
+    Object.assign(img.style, {
+      borderRadius: "0.375rem"
+    });
+  });
+}
+var AdaptiveCardRenderer = forwardRef(function AdaptiveCardRenderer2({ cardData, sampleData, inputFields, onSubmit, onAction, className }, ref) {
+  const cardContainerRef = useRef(null);
+  const adaptiveCardInstanceRef = useRef(
+    null
+  );
+  const initialSampleDataRef = useRef(sampleData);
+  const hasRenderedRef = useRef(false);
+  const submissionContextRef = useRef({ initialValues: {}, changedInputs: /* @__PURE__ */ new Set() });
+  const onSubmitRef = useRef(onSubmit);
+  const onActionRef = useRef(onAction);
+  useEffect(() => {
+    onSubmitRef.current = onSubmit;
+  }, [onSubmit]);
+  useEffect(() => {
+    onActionRef.current = onAction;
+  }, [onAction]);
+  useEffect(() => {
+    initialSampleDataRef.current = sampleData;
+  }, [sampleData]);
+  useEffect(() => {
+    if (!cardData || !cardContainerRef.current) {
+      adaptiveCardInstanceRef.current = null;
+      return;
+    }
+    if (!isAdaptiveCard(cardData)) {
+      console.warn(
+        'AdaptiveCardRenderer: Invalid format. Expected type "AdaptiveCard"'
+      );
+      cardContainerRef.current.innerHTML = "";
+      adaptiveCardInstanceRef.current = null;
+      return;
+    }
+    const adaptiveCard = new AdaptiveCards.AdaptiveCard();
+    adaptiveCard.hostConfig = new AdaptiveCards.HostConfig({
+      fontFamily: "inherit",
+      spacing: {
+        small: 6,
+        default: 10,
+        medium: 14,
+        large: 18,
+        extraLarge: 22,
+        padding: 12
+      },
+      separator: {
+        lineThickness: 1,
+        lineColor: "var(--color-border-default)"
+      },
+      containerStyles: {
+        default: {
+          backgroundColor: "transparent",
+          foregroundColors: {
+            default: {
+              default: "var(--color-text-primary)",
+              subtle: "var(--color-text-muted)"
+            },
+            accent: {
+              default: "var(--color-text-link)",
+              subtle: "var(--color-text-linkHover)"
+            }
+          }
+        }
+      }
+    });
+    let cardToRender = cardData;
+    const defaultValues = cardData.defaultValue;
+    const dataToUse = initialSampleDataRef.current;
+    const mergedData = {
+      ...defaultValues,
+      ...dataToUse
+    };
+    const submissionContext = {
+      inputFields,
+      initialValues: mergedData,
+      changedInputs: /* @__PURE__ */ new Set()
+    };
+    submissionContextRef.current = submissionContext;
+    hasRenderedRef.current = true;
+    cardToRender = expandTemplate(cardData, mergedData);
+    adaptiveCard.parse(cardToRender);
+    adaptiveCardInstanceRef.current = adaptiveCard;
+    if (Object.keys(mergedData).length > 0) {
+      const allInputs = adaptiveCard.getAllInputs();
+      for (const input of allInputs) {
+        if (input.id && mergedData[input.id] !== void 0) {
+          if (!input.value || input.value === "") {
+            input.defaultValue = String(
+              mergedData[input.id]
+            );
+          }
+        }
+      }
+    }
+    adaptiveCard.onExecuteAction = (action) => {
+      if (action instanceof AdaptiveCards.SubmitAction) {
+        const allInputs = adaptiveCard.getAllInputs();
+        const submittedData = {};
+        for (const input of allInputs) {
+          if (input.id) {
+            submittedData[input.id] = input.value;
+          }
+        }
+        const serializedAction = action.toJSON();
+        const actionDefinition = serializedAction && typeof serializedAction === "object" ? Object.fromEntries(Object.entries(serializedAction)) : {};
+        const rawActionData = inputFields ? actionDefinition.data : action.data;
+        const actionData = rawActionData && typeof rawActionData === "object" ? Object.fromEntries(Object.entries(rawActionData)) : {};
+        const parsedData = inputFields ? {
+          ...coerceSubmittedDataFromCard(actionData, cardData),
+          ...coerceSubmittedDataFromCard(
+            submittedData,
+            cardData,
+            submissionContext
+          )
+        } : coerceSubmittedDataFromCard(
+          { ...submittedData, ...actionData },
+          cardData
+        );
+        onSubmitRef.current?.(parsedData);
+      }
+      onActionRef.current?.(action);
+    };
+    const renderedCard = adaptiveCard.render();
+    cardContainerRef.current.innerHTML = "";
+    if (renderedCard) {
+      cardContainerRef.current.appendChild(renderedCard);
+      applyCustomStyles(cardContainerRef.current);
+    }
+    const container = cardContainerRef.current;
+    const markEdited = (event) => {
+      if (!(event.target instanceof Node)) return;
+      for (const input of adaptiveCard.getAllInputs()) {
+        if (input.id && input.renderedElement?.contains(event.target)) {
+          submissionContext.changedInputs.add(input.id);
+        }
+      }
+    };
+    container.addEventListener("input", markEdited, true);
+    container.addEventListener("change", markEdited, true);
+    return () => {
+      container.removeEventListener("input", markEdited, true);
+      container.removeEventListener("change", markEdited, true);
+    };
+  }, [cardData, inputFields]);
+  useImperativeHandle(
+    ref,
+    () => ({
+      validateInputs() {
+        const adaptiveCard = adaptiveCardInstanceRef.current;
+        if (!adaptiveCard) return true;
+        const invalidInputs = adaptiveCard.getAllInputs().filter((input) => !input.validateValue());
+        invalidInputs[0]?.focus();
+        return invalidInputs.length === 0;
+      },
+      collectValues() {
+        const adaptiveCard = adaptiveCardInstanceRef.current;
+        if (!adaptiveCard || !cardData) return {};
+        const collected = {};
+        for (const input of adaptiveCard.getAllInputs()) {
+          if (input.id) {
+            collected[input.id] = input.value;
+          }
+        }
+        return coerceSubmittedDataFromCard(
+          collected,
+          cardData,
+          submissionContextRef.current
+        );
+      }
+    }),
+    [cardData]
+  );
+  if (!cardData) {
+    return null;
+  }
+  if (isCustomFormat(cardData)) {
+    return /* @__PURE__ */ jsxs("div", { className: "p-4 border border-[var(--color-status-warning-border)] rounded bg-[var(--color-status-warning-bg-subtle)] text-sm", children: [
+      /* @__PURE__ */ jsx("p", { className: "font-semibold text-[var(--color-status-warning-text)]", children: "Invalid Adaptive Card Format" }),
+      /* @__PURE__ */ jsx("p", { className: "text-[var(--color-status-warning-text)] mt-1", children: "The adaptive_card is using a custom format. Please update it to use the Microsoft Adaptive Card schema." }),
+      /* @__PURE__ */ jsxs("details", { className: "mt-2", children: [
+        /* @__PURE__ */ jsx("summary", { className: "cursor-pointer text-[var(--color-status-warning-text)]", children: "View current data" }),
+        /* @__PURE__ */ jsx("pre", { className: "mt-2 text-xs overflow-auto max-h-40", children: JSON.stringify(cardData, null, 2) })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: cardContainerRef,
+      className: cn("adaptive-card-container", className)
+    }
+  );
+});
+var components_default = AdaptiveCardRenderer;
 function useOpenSnapshot(open, value) {
   const [snapshot, setSnapshot] = useState(
     () => open ? { value } : null

package/dist/{chunk-ACME5GOU.js → chunk-JCFFPZAB.js}

@@ -1,5 +1,5 @@
 import { REPLAY_WORKFLOW_RUN, RETRY_WORKFLOW_RUNS } from './chunk-5ERAJC2I.js';
-import { useFluidGridsAnalytics, emitRunStarted, openRunQuotaUpgradePrompt } from './chunk-VYXTP6YF.js';
+import { useFluidGridsAnalytics, emitRunStarted, openRunQuotaUpgradePrompt } from './chunk-3OG6EBHP.js';
 import { ExecutionsListDocument, ExecutionDetailDocument, ExecutionStatsDocument, PauseExecutionDocument, ResumeExecutionDocument, CancelExecutionDocument, RetryNodeDocument, TriggerWorkflowDocument, TerminateExecutionDocument } from './chunk-VAWYR6P4.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-PDODDDHY.js';

package/dist/{chunk-TNMXKPJX.js → chunk-JCXNJYDM.js}

@@ -1,9 +1,9 @@
 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-CX3LABFK.js';
+import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-3A2A6IEK.js';
 import { proposalCanvasPath } from './chunk-GLYINMOR.js';
-import { useContinuousOptimisationEnabled } from './chunk-VYXTP6YF.js';
 import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-ERT444RG.js';
+import { useContinuousOptimisationEnabled } from './chunk-3OG6EBHP.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';