@burdenoff/fluidgrids-fe-sdk 2026.1109.6 → 2026.1109.8

package/dist/{chunk-XTNHYVGH.js → chunk-G4NAU6FF.js}

@@ -1,9 +1,11 @@
-import { isGuidedTourIntent, pickGuidedTour, withoutGuidedTourIntent, isCreateIntent, CreateWorkflowRefusalDialog, decideMissingWorkflow } from './chunk-QPNZV7OD.js';
+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-L3UC5E4J.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-K7YFK5K2.js';
-import { refetchStoreNodes, BILLING_PLANS_PATH, codeBuildIdOf, rememberRevision, blankWorkflowCreateInput, classifyCreateRefusal, useSaveStatusStore, workflowFingerprint, registerWorkflowNodeTypes } from './chunk-I6FW4C3B.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 { WorkflowDefinitionDocument } from './chunk-VAWYR6P4.js';
 import { useTr } from './chunk-UULVIT25.js';
@@ -684,6 +686,211 @@ function LoadProblem({
     }
   );
 }
+
+// src/builder/lib/start-node-link.ts
+var START_NODE_PARAM = "startNode";
+var START_OPERATION_PARAM = "startOperation";
+var START_NAME_PARAM = "name";
+var START_FIELD_PREFIX = "set.";
+var MAX_START_NAME_LENGTH = 120;
+var MAX_START_VALUE_LENGTH = 1e3;
+var MAX_START_FIELDS = 20;
+var NODE_TYPE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9:._/@-]{0,159}$/;
+var FIELD_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+var OPERATION_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+var EXPRESSION_MARKERS = /\$\{|\{\{|^=/;
+var TEXT_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "text",
+  "timezone",
+  // TimeCampus Event node: comma-separated time trigger ids (BOFF-10910).
+  "timecampus-time-trigger"
+]);
+var NUMBER_FIELD_TYPES = /* @__PURE__ */ new Set(["number", "integer"]);
+var CHOICE_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "enum",
+  "options",
+  "select",
+  "multiOptions"
+]);
+function hasControlCharacter(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+function isPlainText(value, maxLength) {
+  return value.length > 0 && value.length <= maxLength && !hasControlCharacter(value) && !EXPRESSION_MARKERS.test(value);
+}
+function readStartNodeRequest(search) {
+  const params = new URLSearchParams(search);
+  const nodeType = params.get(START_NODE_PARAM)?.trim() ?? "";
+  if (!NODE_TYPE_PATTERN.test(nodeType)) return null;
+  const rejected = [];
+  const fields = /* @__PURE__ */ Object.create(null);
+  let count = 0;
+  for (const [key, raw] of params) {
+    if (!key.startsWith(START_FIELD_PREFIX)) continue;
+    const field = key.slice(START_FIELD_PREFIX.length);
+    if (!FIELD_NAME_PATTERN.test(field) || Object.hasOwn(fields, field)) {
+      rejected.push({ field: field.slice(0, 64), reason: "unknown-field" });
+      continue;
+    }
+    if (count >= MAX_START_FIELDS) {
+      rejected.push({ field, reason: "too-many" });
+      continue;
+    }
+    fields[field] = raw.trim();
+    count += 1;
+  }
+  const operationRaw = params.get(START_OPERATION_PARAM)?.trim();
+  const operation = operationRaw && OPERATION_PATTERN.test(operationRaw) ? operationRaw : void 0;
+  const nameRaw = params.get(START_NAME_PARAM)?.trim();
+  let name;
+  if (nameRaw) {
+    if (isPlainText(nameRaw, MAX_START_NAME_LENGTH)) name = nameRaw;
+    else rejected.push({ field: START_NAME_PARAM, reason: "invalid-name" });
+  }
+  return {
+    nodeType,
+    ...operation ? { operation } : {},
+    ...name ? { name } : {},
+    fields,
+    rejected
+  };
+}
+function validateStartField(param, raw) {
+  if (!param) return { ok: false, reason: "unknown-field" };
+  if (param.secret) return { ok: false, reason: "secret" };
+  const options = param.options ?? [];
+  if (param.type === "multiOptions") {
+    if (options.length === 0) return { ok: false, reason: "unsupported-type" };
+    const picked = raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+    if (picked.length === 0) return { ok: false, reason: "invalid-value" };
+    const allowed = new Set(options);
+    if (picked.some((part) => !allowed.has(part)))
+      return { ok: false, reason: "not-an-option" };
+    const chosen = new Set(picked);
+    return {
+      ok: true,
+      value: options.filter((option) => chosen.has(option))
+    };
+  }
+  if (options.length > 0 && CHOICE_FIELD_TYPES.has(param.type)) {
+    return options.includes(raw) ? { ok: true, value: raw } : { ok: false, reason: "not-an-option" };
+  }
+  if (NUMBER_FIELD_TYPES.has(param.type)) {
+    if (!/^-?\d+(\.\d+)?$/.test(raw))
+      return { ok: false, reason: "invalid-value" };
+    const value = Number(raw);
+    if (!Number.isFinite(value) || param.type === "integer" && !Number.isInteger(value))
+      return { ok: false, reason: "invalid-value" };
+    return { ok: true, value };
+  }
+  if (param.type === "boolean") {
+    if (raw === "true") return { ok: true, value: true };
+    if (raw === "false") return { ok: true, value: false };
+    return { ok: false, reason: "invalid-value" };
+  }
+  if (TEXT_FIELD_TYPES.has(param.type)) {
+    return isPlainText(raw, MAX_START_VALUE_LENGTH) ? { ok: true, value: raw } : { ok: false, reason: "invalid-value" };
+  }
+  return { ok: false, reason: "unsupported-type" };
+}
+function validateStartFields(params, fields) {
+  const byName = new Map(params.map((param) => [param.name, param]));
+  const state = {};
+  const rejected = [];
+  for (const [field, raw] of Object.entries(fields)) {
+    const result = validateStartField(byName.get(field), raw);
+    if (result.ok) state[field] = result.value;
+    else rejected.push({ field, reason: result.reason });
+  }
+  return { state, rejected };
+}
+function isStartNodeParam(key) {
+  return key === START_NODE_PARAM || key === START_OPERATION_PARAM || key === START_NAME_PARAM || key.startsWith(START_FIELD_PREFIX);
+}
+function startNodeKey(search) {
+  const params = new URLSearchParams(search);
+  const kept = new URLSearchParams();
+  for (const [key, value] of params) {
+    if (isStartNodeParam(key)) kept.append(key, value);
+  }
+  return kept.toString();
+}
+function withoutStartNodeParams(search) {
+  const params = new URLSearchParams(search);
+  for (const key of [...params.keys()]) {
+    if (isStartNodeParam(key)) params.delete(key);
+  }
+  const rest = params.toString();
+  return rest ? `?${rest}` : "";
+}
+function startNodeLink(basePath, request) {
+  const params = new URLSearchParams();
+  params.set(START_NODE_PARAM, request.nodeType);
+  if (request.operation) params.set(START_OPERATION_PARAM, request.operation);
+  if (request.name) params.set(START_NAME_PARAM, request.name);
+  for (const [field, value] of Object.entries(request.fields ?? {})) {
+    params.set(`${START_FIELD_PREFIX}${field}`, value);
+  }
+  const base2 = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+  return `${base2}/new?${params.toString()}`;
+}
+
+// src/builder/app/workflow/work/start-node.ts
+var START_POSITION = { x: 0, y: 0 };
+function recordOf(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : {};
+}
+function buildStartNode(request) {
+  const config = NODE_CONFIGS.find((entry) => entry.type === request.nodeType);
+  if (!config) return { ok: false, reason: "unknown-node" };
+  if (request.operation) {
+    const operations = resolveNodeOperation(
+      void 0,
+      config.operations
+    ).operations;
+    if (!operations.some((op) => op.name === request.operation)) {
+      return { ok: false, reason: "unknown-operation" };
+    }
+  }
+  const node = createConfiguredNode(
+    request.nodeType,
+    START_POSITION,
+    request.operation
+  );
+  const data = recordOf(node.data);
+  const pinned = typeof data.operation_name === "string" && data.operation_name;
+  const rejected = [...request.rejected];
+  if (!pinned) {
+    for (const field of Object.keys(request.fields)) {
+      rejected.push({ field, reason: "unknown-field" });
+    }
+  } else {
+    const { selected } = resolveNodeOperation(data, config.operations);
+    const { state, rejected: refused } = validateStartFields(
+      paramsFromOperation(selected),
+      request.fields
+    );
+    rejected.push(...refused);
+    const args = recordOf(data.args);
+    const current = recordOf(args.state);
+    node.data = {
+      ...data,
+      args: { ...args, state: { ...current, ...state } }
+    };
+  }
+  return {
+    ok: true,
+    node,
+    ...request.name ? { name: request.name } : {},
+    rejected
+  };
+}
 var START_DELAY_MS = 800;
 function StartGuidedTour() {
   const location = useLocation();
@@ -743,6 +950,15 @@ function WorkflowItem({
   const navigate = useNavigate();
   const tr = useTr();
   const location = useLocation();
+  const requestedStartLink = startNodeKey(location.search);
+  const [startLink, setStartLink] = useState({
+    navigation: location.key,
+    link: requestedStartLink
+  });
+  if (requestedStartLink && (requestedStartLink !== startLink.link || location.key !== startLink.navigation)) {
+    setStartLink({ navigation: location.key, link: requestedStartLink });
+  }
+  const consumedStartLinkRef = useRef(null);
   const createIntentRef = useRef(isCreateIntent(location.state));
   useEffect(() => {
     createIntentRef.current = isCreateIntent(location.state);
@@ -784,6 +1000,10 @@ function WorkflowItem({
   useEffect(() => {
     doNodeCheckRef.current = doNodeCheck;
   });
+  const trRef = useRef(tr);
+  useEffect(() => {
+    trRef.current = tr;
+  });
   const handleInstallConfirm = useCallback(async () => {
     if (!pendingWorkflow) return;
     const nodesToInstall = (nodeCheck?.missing ?? []).filter(
@@ -940,10 +1160,53 @@ function WorkflowItem({
             if (mounted) setIsLoading(false);
             return;
           }
-          if (mounted) {
-            setWorkflow(newWorkflow);
-            setIsLoading(false);
+          const startRequest = startLink.link && startLink !== consumedStartLinkRef.current ? readStartNodeRequest(startLink.link) : null;
+          if (startRequest) {
+            await ensureNodeConfigsLoaded();
+            if (!mounted) return;
+            consumedStartLinkRef.current = startLink;
+            const started = buildStartNode(startRequest);
+            window.history.replaceState(
+              window.history.state,
+              "",
+              `${window.location.pathname}${withoutStartNodeParams(window.location.search)}${window.location.hash}`
+            );
+            if (started.ok) {
+              const nodeType = started.node.type ?? startRequest.nodeType;
+              setWorkflow({
+                ...newWorkflow,
+                name: started.name ?? newWorkflow.name,
+                nodes: [started.node],
+                sidebar: {
+                  active: "node-properties",
+                  panels: {
+                    nodeProperties: {
+                      selectedNode: { id: started.node.id, type: nodeType }
+                    }
+                  }
+                }
+              });
+              if (started.rejected.length > 0) {
+                toast.warning(
+                  trRef.current(
+                    "fluidgrids.builder.startNode.partial",
+                    "Some settings from the link were not applied"
+                  ),
+                  {
+                    description: started.rejected.map((entry) => entry.field).join(", ")
+                  }
+                );
+              }
+              return;
+            }
+            toast.error(
+              trRef.current(
+                "fluidgrids.builder.startNode.unavailable",
+                "The node this link starts with is not available in this workspace"
+              )
+            );
           }
+          if (mounted) setWorkflow(newWorkflow);
           return;
         }
         const freshCreate = createIntentRef.current && !creatingRef.current && !fetchedCopy() && !loadRunId;
@@ -1098,7 +1361,8 @@ function WorkflowItem({
     navigate,
     loadRunId,
     retryNonce,
-    reloadNonce
+    reloadNonce,
+    startLink
     // doNodeCheckRef is intentionally omitted — it's a ref (stable by definition)
     // and including doNodeCheck here caused infinite re-runs because installedAppIds
     // produces a new Set reference on every render.
@@ -1283,4 +1547,4 @@ function WorkflowBuilder() {
   );
 }
 
-export { GuidedTourStarter, WorkflowBuilder };
+export { GuidedTourStarter, START_FIELD_PREFIX, START_NAME_PARAM, START_NODE_PARAM, START_OPERATION_PARAM, WorkflowBuilder, readStartNodeRequest, startNodeLink };

package/dist/{chunk-7VT6V5PG.js → chunk-GR3QNLFS.js}

@@ -1,9 +1,9 @@
-import { validateDateRange, statusCountFilter, STATUS_COUNT_GROUP_BY, statusCountsOf } from './chunk-IVAV4Y57.js';
+import { validateDateRange, statusCountFilter, STATUS_COUNT_GROUP_BY, statusCountsOf } from './chunk-ACME5GOU.js';
 import { isAgentNodeType } from './chunk-WZ3EJVS6.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-I6FW4C3B.js';
+import { useDurableParityEnabled, formatElapsedMs, runDurationMs, nodeStateDurationMs } from './chunk-VYXTP6YF.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-4I6BXKKC.js → chunk-MSNCU6US.js}

@@ -1,10 +1,10 @@
-import { TEMPLATE_STORE_CATEGORIES, useImportWorkflowTemplate, FlowBuilderPage, useWorkflowTemplates, TemplateCard, useTemplateSubmissions, usePublishToStore } from './chunk-L3UC5E4J.js';
-import { QuotaExhaustedDialog } from './chunk-5WUX3DET.js';
+import { TEMPLATE_STORE_CATEGORIES, useImportWorkflowTemplate, FlowBuilderPage, useWorkflowTemplates, TemplateCard, useTemplateSubmissions, usePublishToStore } from './chunk-2LERIIZM.js';
+import { QuotaExhaustedDialog } from './chunk-QWDF72GZ.js';
 import { templatesControls } from './chunk-FNZZ5JJL.js';
-import { useWorkflowDefinitions, useDuplicateWorkflow, useLazyWorkflowDefinition } from './chunk-K7YFK5K2.js';
+import { useWorkflowDefinitions, useDuplicateWorkflow, useLazyWorkflowDefinition } from './chunk-ZXLXZFWO.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { BILLING_PLANS_PATH, useFluidGridsAnalytics, emitTemplateUsed, isQuotaExhaustedFailure } from './chunk-I6FW4C3B.js';
+import { BILLING_PLANS_PATH, useFluidGridsAnalytics, emitTemplateUsed, isQuotaExhaustedFailure } from './chunk-VYXTP6YF.js';
 import { SdkPermissionButton, FLUIDGRIDS_PERMISSIONS } from './chunk-ERT444RG.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { useState, useEffect, useCallback, useMemo } from 'react';

package/dist/{chunk-S3ADBQTT.js → chunk-NCXK2AO6.js}

@@ -1,6 +1,6 @@
 import { versionsOfWorkflow, VersionDiffDialog } from './chunk-B3USL2JQ.js';
 import { historyControls } from './chunk-FNZZ5JJL.js';
-import { useWorkflowDefinitions, useRestoreWorkflowVersion } from './chunk-K7YFK5K2.js';
+import { useWorkflowDefinitions, useRestoreWorkflowVersion } from './chunk-ZXLXZFWO.js';
 import { useFluidGridsPageControls } from './chunk-PJAWNFJV.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
 import { useTr } from './chunk-UULVIT25.js';

package/dist/{chunk-7XQI4U5C.js → chunk-NEB4Y7AX.js}

@@ -1,4 +1,4 @@
-import { structuredParameterType, parseParameterValue, liveInternalOperations, resolveNodeOperation, readDisplayOptions, getNodeDetail, useNodeRegistryRevision, fieldsFromIO, pathToExpression, NODE_CONFIGS, resolveUiSpec, fieldsFromValue, declaredOutputFields, subscribeWorkflowSaved } from './chunk-I6FW4C3B.js';
+import { structuredParameterType, parseParameterValue, liveInternalOperations, resolveNodeOperation, readDisplayOptions, getNodeDetail, useNodeRegistryRevision, fieldsFromIO, pathToExpression, NODE_CONFIGS, resolveUiSpec, fieldsFromValue, declaredOutputFields, subscribeWorkflowSaved } from './chunk-VYXTP6YF.js';
 import { useBuilderReadOnly } from './chunk-SDZEAIIE.js';
 import { useFlowStore } from './chunk-JXCJRBWD.js';
 import { EventRegistrationsDocument } from './chunk-VAWYR6P4.js';

package/dist/{chunk-QPNZV7OD.js → chunk-NRI7AUBH.js}

@@ -1,43 +1,3 @@
-import { QuotaExhaustedDialog } from './chunk-5WUX3DET.js';
-import { useTr } from './chunk-UULVIT25.js';
-import { jsx } from 'react/jsx-runtime';
-
-function CreateWorkflowRefusalDialog({
-  refusal,
-  onClose,
-  onUpgrade,
-  surface
-}) {
-  const tr = useTr();
-  const notProvisioned = refusal?.kind === "quota-not-provisioned";
-  const open = refusal?.kind === "quota-exhausted" || refusal?.kind === "quota-not-provisioned";
-  return /* @__PURE__ */ jsx(
-    QuotaExhaustedDialog,
-    {
-      surface,
-      open,
-      limitHit: !notProvisioned,
-      onOpenChange: (next) => {
-        if (!next) onClose();
-      },
-      onUpgrade: () => {
-        onUpgrade();
-        onClose();
-      },
-      ...notProvisioned ? {
-        title: tr(
-          "fluidgrids.components.createRefusal.notProvisionedTitle",
-          "Workflows aren't in this workspace's plan"
-        ),
-        description: tr(
-          "fluidgrids.components.createRefusal.notProvisionedDescription",
-          "This workspace has no plan that includes FluidGrids workflows, so no workflow was created. Choose a plan for this workspace, or ask a workspace admin to add one."
-        )
-      } : {}
-    }
-  );
-}
-
 // src/utils/workflow-open.ts
 var NEW_WORKFLOW_STATE = { createWorkflow: true };
 function isCreateIntent(state) {
@@ -101,4 +61,4 @@ function pickGuidedTour(pageTours, pageId) {
   return playable.find((tour) => tour.pageId === pageId) ?? null;
 }
 
-export { CreateWorkflowRefusalDialog, GUIDED_FIRST_WORKFLOW_NAV, GUIDED_FIRST_WORKFLOW_STATE, GUIDED_TOUR_STATE, builderPathFor, decideMissingWorkflow, firstWorkflowProgress, isCreateIntent, isGuidedTourIntent, pickGuidedTour, withoutGuidedTourIntent };
+export { GUIDED_FIRST_WORKFLOW_NAV, GUIDED_FIRST_WORKFLOW_STATE, GUIDED_TOUR_STATE, builderPathFor, decideMissingWorkflow, firstWorkflowProgress, isCreateIntent, isGuidedTourIntent, pickGuidedTour, withoutGuidedTourIntent };

package/dist/{chunk-XGQLFKRC.js → chunk-QTOPG7SR.js}

@@ -1,5 +1,5 @@
 import { emptyAgentForm, agentToForm, describeRule, formToInput, AgentFormError, DEFAULT_GRANT_DAYS, MAX_GRANT_DAYS, grantDays } from './chunk-WZ3EJVS6.js';
-import { useAgentDefinitions, useAgentDefinitionList, useConnections } from './chunk-I6FW4C3B.js';
+import { useAgentDefinitions, useAgentDefinitionList, useConnections } from './chunk-VYXTP6YF.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { describeOperationError } from './chunk-JKLZ6YZ3.js';
 import { useState, useCallback, useEffect } from 'react';

package/dist/{chunk-5WUX3DET.js → chunk-QWDF72GZ.js}

@@ -1,12 +1,99 @@
-import { useFluidGridsAnalytics, emitWorkflowLimitHit, emitUpgradeClicked, WORKFLOWS_QUOTA_NAME } from './chunk-I6FW4C3B.js';
+import { useFluidGridsAnalytics, emitWorkflowLimitHit, emitUpgradeClicked, WORKFLOWS_QUOTA_NAME } from './chunk-VYXTP6YF.js';
 import { ExportWorkflowCodeDocument, ShareWorkflowDocument, WorkflowSharingDocument } from './chunk-VAWYR6P4.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-PDODDDHY.js';
 import { describeOperationError, throwIfResultError } from './chunk-JKLZ6YZ3.js';
-import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
-import { createSharePrincipalLister, ResourceShareDialog } from '@burdenoff/fe-libs/connections';
-import { jsx, jsxs } from 'react/jsx-runtime';
 import { AlertDialog, AlertDialogContent, AlertDialogHeader, AlertDialogTitle, AlertDialogDescription, AlertDialogFooter, AlertDialogCancel, AlertDialogAction } from '@burdenoff/fe-libs/ui';
+import { useRef, useEffect, useState, useCallback, useMemo } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { createSharePrincipalLister, ResourceShareDialog } from '@burdenoff/fe-libs/connections';
+
+function QuotaExhaustedDialog({
+  open,
+  onOpenChange,
+  onUpgrade,
+  title,
+  description,
+  surface,
+  limitHit = true
+}) {
+  const tr = useTr();
+  const { bus, workspaceId } = useFluidGridsAnalytics();
+  const wasOpen = useRef(false);
+  useEffect(() => {
+    if (open && !wasOpen.current && limitHit) {
+      emitWorkflowLimitHit(bus, { workspaceId, surface });
+    }
+    wasOpen.current = open;
+  }, [open, bus, workspaceId, surface, limitHit]);
+  const handleUpgrade = () => {
+    emitUpgradeClicked(bus, {
+      workspaceId,
+      surface: "quota-dialog",
+      quotaKey: WORKFLOWS_QUOTA_NAME
+    });
+    onUpgrade();
+  };
+  const resolvedTitle = title ?? tr(
+    "fluidgrids.components.quotaExhaustedDialog.title",
+    "Workflow Limit Reached"
+  );
+  const resolvedDescription = description ?? tr(
+    "fluidgrids.components.quotaExhaustedDialog.description",
+    "You've reached the workflow limit for your plan. Upgrade your plan to create more workflows."
+  );
+  return /* @__PURE__ */ jsx(AlertDialog, { open, onOpenChange, children: /* @__PURE__ */ jsxs(AlertDialogContent, { children: [
+    /* @__PURE__ */ jsxs(AlertDialogHeader, { children: [
+      /* @__PURE__ */ jsx(AlertDialogTitle, { children: resolvedTitle }),
+      /* @__PURE__ */ jsx(AlertDialogDescription, { children: resolvedDescription })
+    ] }),
+    /* @__PURE__ */ jsxs(AlertDialogFooter, { children: [
+      /* @__PURE__ */ jsx(AlertDialogCancel, { children: tr(
+        "fluidgrids.components.quotaExhaustedDialog.dismiss",
+        "Dismiss"
+      ) }),
+      /* @__PURE__ */ jsx(AlertDialogAction, { onClick: handleUpgrade, children: tr(
+        "fluidgrids.components.quotaExhaustedDialog.viewPlans",
+        "View plans"
+      ) })
+    ] })
+  ] }) });
+}
+function CreateWorkflowRefusalDialog({
+  refusal,
+  onClose,
+  onUpgrade,
+  surface
+}) {
+  const tr = useTr();
+  const notProvisioned = refusal?.kind === "quota-not-provisioned";
+  const open = refusal?.kind === "quota-exhausted" || refusal?.kind === "quota-not-provisioned";
+  return /* @__PURE__ */ jsx(
+    QuotaExhaustedDialog,
+    {
+      surface,
+      open,
+      limitHit: !notProvisioned,
+      onOpenChange: (next) => {
+        if (!next) onClose();
+      },
+      onUpgrade: () => {
+        onUpgrade();
+        onClose();
+      },
+      ...notProvisioned ? {
+        title: tr(
+          "fluidgrids.components.createRefusal.notProvisionedTitle",
+          "Workflows aren't in this workspace's plan"
+        ),
+        description: tr(
+          "fluidgrids.components.createRefusal.notProvisionedDescription",
+          "This workspace has no plan that includes FluidGrids workflows, so no workflow was created. Choose a plan for this workspace, or ask a workspace admin to add one."
+        )
+      } : {}
+    }
+  );
+}
 
 // src/utils/workflow-transfer.ts
 function asRecord(value) {
@@ -626,56 +713,5 @@ function WorkflowShareDialog({
     }
   );
 }
-function QuotaExhaustedDialog({
-  open,
-  onOpenChange,
-  onUpgrade,
-  title,
-  description,
-  surface,
-  limitHit = true
-}) {
-  const tr = useTr();
-  const { bus, workspaceId } = useFluidGridsAnalytics();
-  const wasOpen = useRef(false);
-  useEffect(() => {
-    if (open && !wasOpen.current && limitHit) {
-      emitWorkflowLimitHit(bus, { workspaceId, surface });
-    }
-    wasOpen.current = open;
-  }, [open, bus, workspaceId, surface, limitHit]);
-  const handleUpgrade = () => {
-    emitUpgradeClicked(bus, {
-      workspaceId,
-      surface: "quota-dialog",
-      quotaKey: WORKFLOWS_QUOTA_NAME
-    });
-    onUpgrade();
-  };
-  const resolvedTitle = title ?? tr(
-    "fluidgrids.components.quotaExhaustedDialog.title",
-    "Workflow Limit Reached"
-  );
-  const resolvedDescription = description ?? tr(
-    "fluidgrids.components.quotaExhaustedDialog.description",
-    "You've reached the workflow limit for your plan. Upgrade your plan to create more workflows."
-  );
-  return /* @__PURE__ */ jsx(AlertDialog, { open, onOpenChange, children: /* @__PURE__ */ jsxs(AlertDialogContent, { children: [
-    /* @__PURE__ */ jsxs(AlertDialogHeader, { children: [
-      /* @__PURE__ */ jsx(AlertDialogTitle, { children: resolvedTitle }),
-      /* @__PURE__ */ jsx(AlertDialogDescription, { children: resolvedDescription })
-    ] }),
-    /* @__PURE__ */ jsxs(AlertDialogFooter, { children: [
-      /* @__PURE__ */ jsx(AlertDialogCancel, { children: tr(
-        "fluidgrids.components.quotaExhaustedDialog.dismiss",
-        "Dismiss"
-      ) }),
-      /* @__PURE__ */ jsx(AlertDialogAction, { onClick: handleUpgrade, children: tr(
-        "fluidgrids.components.quotaExhaustedDialog.viewPlans",
-        "View plans"
-      ) })
-    ] })
-  ] }) });
-}
 
-export { CODE_EXPORT_FORMATS, ImportSourceError, MAX_IMPORT_ARCHIVE_BYTES, MAX_IMPORT_SOURCE_BYTES, QuotaExhaustedDialog, WorkflowShareDialog, assertImportByteSize, canEditWorkflow, canShareWorkflow, checkTypeScriptImport, downloadWorkflowCodeExport, downloadWorkflowExport, fileBaseName, importAcceptAttribute, importFileKind, isLosslessReport, isLossyFidelityItem, lineOfNode, orderedExportFiles, parseWorkflowImport, primaryImportModule, readProjectArchive, sortFidelityItems, typeScriptImportSource, typeScriptModuleFile, useExportWorkflowAs, useWorkflowCodeExport, workflowNameFromFile };
+export { CODE_EXPORT_FORMATS, CreateWorkflowRefusalDialog, ImportSourceError, MAX_IMPORT_ARCHIVE_BYTES, MAX_IMPORT_SOURCE_BYTES, QuotaExhaustedDialog, WorkflowShareDialog, assertImportByteSize, canEditWorkflow, canShareWorkflow, checkTypeScriptImport, downloadWorkflowCodeExport, downloadWorkflowExport, fileBaseName, importAcceptAttribute, importFileKind, isLosslessReport, isLossyFidelityItem, lineOfNode, orderedExportFiles, parseWorkflowImport, primaryImportModule, readProjectArchive, sortFidelityItems, typeScriptImportSource, typeScriptModuleFile, useExportWorkflowAs, useWorkflowCodeExport, workflowNameFromFile };

package/dist/{chunk-GG357Z3E.js → chunk-THIMC2ZD.js}

@@ -1,6 +1,6 @@
-import { useDurableRunFields, useRunHistory, useDeterminismStatus, useRunStackTrace, RunHistoryView, SignalRunDialog, terminateDurableRun } from './chunk-NQ7JQNQ7.js';
-import { useDurableParityRunFields, hasAgentNodeState, agentNodeTraces, orderNodesByExecution, useRunPending, useRunMetadata, ExecutionStatusBadge, NodeTimeline, RunLogViewer, NodeStatusBadge, setRunVersioningOverride } from './chunk-7VT6V5PG.js';
-import { useExecution, useExecutionActions, useAutoRefresh, runChainLinks, shortRunId, callbackTone, parseMetadataDefinition, overrideRequestOf } from './chunk-IVAV4Y57.js';
+import { useDurableRunFields, useRunHistory, useDeterminismStatus, useRunStackTrace, RunHistoryView, SignalRunDialog, terminateDurableRun } from './chunk-3T3C3475.js';
+import { useDurableParityRunFields, hasAgentNodeState, agentNodeTraces, orderNodesByExecution, useRunPending, useRunMetadata, ExecutionStatusBadge, NodeTimeline, RunLogViewer, NodeStatusBadge, setRunVersioningOverride } from './chunk-GR3QNLFS.js';
+import { useExecution, useExecutionActions, useAutoRefresh, runChainLinks, shortRunId, callbackTone, parseMetadataDefinition, overrideRequestOf } from './chunk-ACME5GOU.js';
 import { fetchRunFailureClusters, OPEN_STATUSES, dismissRunFailureCluster, BUCKET_LABELS } from './chunk-Q526TUOC.js';
 import { aiCost, formatTokens, modelLabel } from './chunk-NZAYYUQ4.js';
 import { useRunPolicyDecisions, RunPolicyDecisions, checkCodecServerUrl, containsEncodedPayload, isEncodedPayload, encodedPayloadBytes, decodePayloads, CodecServerError } from './chunk-OJHBCOBA.js';
@@ -8,8 +8,8 @@ import { readTyped, writeTyped, useResource, fetchCodecServerSettings, fetchRunC
 import { EntityTagPicker, canSaveRunAsTestCase, useWorkflowProposal, WorkflowProposalCard, MAX_CASE_NAME, saveRunAsTestCase } from './chunk-MYE6CMGK.js';
 import { buildNodeDisplayMap, formatRunVersion, nodeDisplayTitle } from './chunk-DFFQYK2X.js';
 import { AiCreditBalanceSlot } from './chunk-Y53CVZVV.js';
-import { useWorkflowVersions } from './chunk-K7YFK5K2.js';
-import { useDurableFunctionNodesEnabled, useDurableParityEnabled, usePhaseCFlags, runSignalTargets, canSignalRun, formatElapsedMs, runDurationMs, useWorkflowTestsEnabled, durableInterfaceOf } from './chunk-I6FW4C3B.js';
+import { useWorkflowVersions } from './chunk-ZXLXZFWO.js';
+import { useDurableFunctionNodesEnabled, useDurableParityEnabled, usePhaseCFlags, runSignalTargets, canSignalRun, formatElapsedMs, runDurationMs, useWorkflowTestsEnabled, durableInterfaceOf } from './chunk-VYXTP6YF.js';
 import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS, SdkPermissionButton } from './chunk-ERT444RG.js';
 import { TaskQueuesDocument, TaskQueueStatsDocument, CreateTaskQueueDocument, UpdateTaskQueueDocument, DeleteTaskQueueDocument, RunLogsDocument, RunLogAppendedDocument, ExplainRunDocument, RunAiUsageDocument } from './chunk-VAWYR6P4.js';
 import { useTr } from './chunk-UULVIT25.js';

package/dist/{chunk-GABLFLEM.js → chunk-TKSVFP36.js}

@@ -1,9 +1,9 @@
-import { AgentsTab } from './chunk-XGQLFKRC.js';
+import { AgentsTab } from './chunk-QTOPG7SR.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-5YLS3WH5.js';
-import { LogStreamingTab } from './chunk-2SUZKBHB.js';
+import { LogStreamingTab } from './chunk-CX3LABFK.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { useFluidGridsFlag, FLUIDGRIDS_FLAGS, usePhaseCFlags, useSaveStatusStore, findSaveConflict, useDurableParityEnabled, useConnections } from './chunk-I6FW4C3B.js';
+import { useFluidGridsFlag, FLUIDGRIDS_FLAGS, usePhaseCFlags, useSaveStatusStore, findSaveConflict, useDurableParityEnabled, useConnections } from './chunk-VYXTP6YF.js';
 import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-ERT444RG.js';
 import { useFlowStore } from './chunk-JXCJRBWD.js';
 import { getGlobalStoreClient } from './chunk-TYI2XOSI.js';

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

@@ -1,8 +1,8 @@
 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-2SUZKBHB.js';
+import { useDataSinks, useDataSinkData, useInsightsData, useRunReplayActions } from './chunk-CX3LABFK.js';
 import { proposalCanvasPath } from './chunk-GLYINMOR.js';
-import { useContinuousOptimisationEnabled } from './chunk-I6FW4C3B.js';
+import { useContinuousOptimisationEnabled } from './chunk-VYXTP6YF.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';

package/dist/{chunk-LI7RF5GC.js → chunk-U52PO4QQ.js}

@@ -1,10 +1,10 @@
-import { asRecord, ConditionTreeBuilder, SwitchRulesEditor, casesFromRules, isStringOptionList, optionText, coerceNumber, paramsFromOperation, resolveLoadOptionsSpec, optionListValues, parseMappingValue, optionListText } from './chunk-7XQI4U5C.js';
 import { CodeEditorField, normalizeCodeLanguage } from './chunk-KZCNJAMK.js';
 import { Popover, PopoverTrigger, PopoverContent } from './chunk-GTEBQQ7J.js';
-import { AgentDefinitionSelectField } from './chunk-XGQLFKRC.js';
+import { asRecord, ConditionTreeBuilder, SwitchRulesEditor, casesFromRules, isStringOptionList, optionText, coerceNumber, paramsFromOperation, resolveLoadOptionsSpec, optionListValues, parseMappingValue, optionListText } from './chunk-NEB4Y7AX.js';
+import { AgentDefinitionSelectField } from './chunk-QTOPG7SR.js';
 import { isAgentNodeType } from './chunk-WZ3EJVS6.js';
 import { readAssertRulesSetting, rowsFromRules, normaliseAssertRules, ruleFromRow, describeAssertRuleProblem, operatorSpec, ASSERT_OPERATORS, emptyAssertRuleRow } from './chunk-JDLQ6QIB.js';
-import { isParamVisible, ConnectionSelector, structuredParameterType, useRunGuard, FluidGridsContext, ExpressionEditor, formatParameterValue, parseParameterValue, useFluidGridsAnalytics, openRunQuotaUpgradePrompt } from './chunk-I6FW4C3B.js';
+import { isParamVisible, ConnectionSelector, structuredParameterType, useRunGuard, FluidGridsContext, ExpressionEditor, formatParameterValue, parseParameterValue, useFluidGridsAnalytics, openRunQuotaUpgradePrompt } from './chunk-VYXTP6YF.js';
 import { useBuilderReadOnly } from './chunk-SDZEAIIE.js';
 import { useFlowStore } from './chunk-JXCJRBWD.js';
 import { useRunFromNodeEligibilityQuery, PreviewScheduleDocument, WebhookTestListenerDocument, StopWebhookTestListenerDocument, ListenForWebhookTestEventDocument } from './chunk-VAWYR6P4.js';