@aglyn/plugins-workflows 1.0.0-beta.143

package/src/lib/components/host-actions-card.component.js

@@ -0,0 +1,1229 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ACTION_MAX_CONDITIONS, ACTION_MAX_STEPS, checkEntitlement, createResourceUid, CRM_ACTION_RECIPES, ELEMENT_SCOPED_SITE_EVENTS, HOST_ACTION_STEP_LABELS, HOST_EVENT_TYPES, hostActionDocument, hostActionRecipeId, hostEventLabel, hostEventPayloadHint, isSiteEventType, normalizeTriggerConditions, pluginDocsHelp, SITE_EVENT_TYPES, validateHostAction } from "@aglyn/aglyn";
+import { automationPlaceholders, describeAutomationPlaceholder } from "@aglyn/aglyn/app-utils/automation-placeholders";
+import { useConsoleWidgetSlot } from "@aglyn/aglyn/app-utils/console-widget-slot-context";
+import { CardDisplay, useConfirmationContext } from "@aglyn/shared-ui-jsx";
+import { ListPagination } from "@aglyn/shared-ui-jsx/components/list-pagination.component";
+import { TABLE_PAGE_SIZE_DEFAULT } from "@aglyn/shared-ui-jsx/const/table-pagination";
+import { useSnackbar } from "@aglyn/shared-ui-snackstack";
+import { Timestamp } from "@aglyn/shared-util-timestamp";
+import { Alert, Button, Dialog, DialogActions, DialogContent, DialogTitle, IconButton, ListItemText, Menu, MenuItem, Stack, Switch, TextField, Typography } from "@mui/material";
+import { collection, doc, setDoc, updateDoc } from "firebase/firestore";
+import { useCallback, useMemo, useRef, useState } from "react";
+import { ceilingedWindow, collectionCeiling, useFirestore, useFirestoreCollection, useHostResourceApi, writeGuardedBySeed } from "@aglyn/tenant-feature-instance";
+import { AutomationStepFields, defaultStep, placeholderState } from "./automation-step-fields.component.js";
+import HostRunHistoryCard from "./host-run-history-card.component.js";
+import { EDITOR_OPTION_CEILING, useAutomationStepPickers } from "./use-automation-step-pickers.js";
+const CUSTOM_EVENT_VALUE = '__custom__';
+/**
+ * How many action documents the card reads.
+ *
+ * A CEILING, not a page size — see the query, which explains why this one
+ * collection cannot be sliced by the server without making the count beneath
+ * the list a per-page number.
+ *
+ * `ACTIONS_MAX_PER_HOST` is 500, so the ceiling really can bite and the probe
+ * beside it is what says when it has.
+ */ const ACTION_CEILING = 100;
+const EMPTY_CONDITION_ROW = {
+    op: '',
+    field: '',
+    value: ''
+};
+/** Every Actions step, as the builder's "Do" picker offers it. */ const ACTION_STEP_KINDS = Object.entries(HOST_ACTION_STEP_LABELS).map(([value, label])=>({
+        value,
+        label
+    }));
+/**
+ * A stored action — or one a recipe just built — as the editor holds it.
+ *
+ * One conversion for both doors, because they must agree: an action that
+ * round-trips through Edit and one a recipe hands over are the same shape
+ * to the editor, and a field the Edit path hydrated that the recipe path
+ * forgot would be a recipe whose conditions vanished on open. Site events
+ * are first-class (AGL-256/266): their selector/threshold/path config is
+ * kept through an edit. Structured conditions (AGL-557; chained AGL-565)
+ * become rows; a legacy single-condition doc normalizes to one row.
+ */ function draftFromAction(action, id) {
+    var _ref, _action_name, _ref1, _ref2, _ref3, _action_steps, _ref4;
+    var _action_trigger, _action_trigger1, _action_trigger2, _action_trigger3, _action_trigger4, _action_trigger5, _action_trigger6, _action_trigger7, _action_trigger8, _action_trigger9, _action_trigger10, _action_trigger11, _action_trigger12;
+    const builtIn = HOST_EVENT_TYPES.includes((_action_trigger = action.trigger) == null ? void 0 : _action_trigger.event) || isSiteEventType(String((_ref = (_action_trigger1 = action.trigger) == null ? void 0 : _action_trigger1.event) != null ? _ref : ''));
+    const rows = normalizeTriggerConditions(action.trigger).map((condition)=>{
+        var _condition_op, _condition_field, _condition_value;
+        return {
+            op: (_condition_op = condition.op) != null ? _condition_op : '',
+            field: (_condition_field = condition.field) != null ? _condition_field : '',
+            value: (_condition_value = condition.value) != null ? _condition_value : ''
+        };
+    });
+    return {
+        id,
+        name: (_action_name = action.name) != null ? _action_name : '',
+        trigger: _extends({
+            event: builtIn ? action.trigger.event : CUSTOM_EVENT_VALUE,
+            filter: (_ref1 = (_action_trigger2 = action.trigger) == null ? void 0 : _action_trigger2.filter) != null ? _ref1 : '',
+            selector: (_ref2 = (_action_trigger3 = action.trigger) == null ? void 0 : _action_trigger3.selector) != null ? _ref2 : '',
+            threshold: (_action_trigger4 = action.trigger) == null ? void 0 : _action_trigger4.threshold,
+            pathPattern: (_ref3 = (_action_trigger5 = action.trigger) == null ? void 0 : _action_trigger5.pathPattern) != null ? _ref3 : '',
+            oncePerVisitor: ((_action_trigger6 = action.trigger) == null ? void 0 : _action_trigger6.oncePerVisitor) === true,
+            oncePerSession: ((_action_trigger7 = action.trigger) == null ? void 0 : _action_trigger7.oncePerSession) === true,
+            everyTime: ((_action_trigger8 = action.trigger) == null ? void 0 : _action_trigger8.everyTime) === true
+        }, Number((_action_trigger9 = action.trigger) == null ? void 0 : _action_trigger9.cooldownMinutes) >= 1 ? {
+            cooldownMinutes: Number((_action_trigger10 = action.trigger) == null ? void 0 : _action_trigger10.cooldownMinutes)
+        } : {}),
+        steps: (_action_steps = action.steps) != null ? _action_steps : [],
+        enabled: action.enabled !== false,
+        customEvent: builtIn ? '' : (_ref4 = (_action_trigger11 = action.trigger) == null ? void 0 : _action_trigger11.event) != null ? _ref4 : '',
+        conditionRows: rows.length ? rows : [
+            EMPTY_CONDITION_ROW
+        ],
+        conditionCombinator: ((_action_trigger12 = action.trigger) == null ? void 0 : _action_trigger12.combinator) === 'or' ? 'or' : 'and',
+        // A recipe stamps what it builds, and a stored action carries what it
+        // was saved with — one reader for both doors, unknown kept unknown.
+        recipe: hostActionRecipeId(action)
+    };
+}
+/** A trigger bound to one element, which makes the row an interaction. */ const LEAF_SELECTOR = /^\[data-aglyn="leaf:.+"\]$/;
+/**
+ * Actions builder (AGL-148): HubSpot-style enrollment — trigger event →
+ * optional filter → ordered steps (run workflow, site alert, custom
+ * event, dataset append). Runs server-side via runEventActions; paid
+ * feature (`actions` flag, Pro+, `actionRunsPerMonth` metered).
+ */ export function HostActionsCard(props) {
+    var _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _hostEventPayloadHint, _ref6, _ref7, _ref8, _ref9, _ref10, _ref11, _ref12, _ref13, _ref14, _ref15, _ref16, _ref17, _ref18, _ref19, _ref20, _ref21, _runsFor_name;
+    var _CRM_ACTION_RECIPES_find;
+    const { hostId, org } = props;
+    // Org-shared data root (AGL-237). Null until the org lookup settles
+    // (AGL-1061), and for a host with no owning org — the pre-migration host
+    // path is gone (AGL-1050), so the dataset and list pickers stay empty
+    // instead of offering rows from a path nothing else reads.
+    const firestore = useFirestore();
+    // Action creation is server-owned since AGL-2266 (the cap); every other
+    // action write on this surface stays client-direct.
+    const createResource = useHostResourceApi();
+    const { enqueueSnackbar } = useSnackbar();
+    const { confirm } = useConfirmationContext();
+    /**
+   * The shell's zone renderer, for what other plugins add to automations
+   * (AGL-2919); `null` outside the console shell, where there is no workspace
+   * to gate on.
+   */ const ExtensionZone = useConsoleWidgetSlot();
+    const { data: actionDocs, status: actionsStatus, /**
+     * The action rows this card's editor is seeded from are unconfirmed by
+     * the server (AGL-1358). Editing an action copies the whole stored row
+     * into `draft` — name, trigger and every step — and writes all of it
+     * back, so `merge: true` protects nothing and a cached seed reverts a
+     * colleague's newer version of the steps nobody here touched.
+     *
+     * The same shape the interaction builder guards (AGL-1066); this is its
+     * card twin, and it was the one that never got the guard.
+     */ fromCache: actionsFromCache } = useFirestoreCollection(/*
+     * ORDERED AND CEILINGED, deliberately not paged by the query (AGL-2501) —
+     * the same decision as the workflows card beside it.
+     *
+     * `limit(100)` alone is answered in DOCUMENT-ID order, so the window was a
+     * pseudo-random hundred that the `localeCompare` below arranged
+     * alphabetically, and nothing said the list was bounded.
+     *
+     * `collectionCeiling` does not change WHICH hundred — document-id order is
+     * what the bare cap already returned. What it changes is that the order is
+     * NAMED, so the obvious next edit is caught: ordering on `name` would HIDE
+     * every action written without one rather than mis-sorting the list, and
+     * `/api/hosts/resources` validates no field for presence while
+     * `IMPORTABLE_FIELDS.actions` copies one only if the export carried it.
+     *
+     * The QUERY is not paged because this collection holds TWO audiences. A
+     * row whose trigger names a leaf selector is an element interaction, which
+     * belongs to its document and is reported below as a count rather than
+     * listed; the rest are the site's actions. Both partitions are derived
+     * from the rows in hand, so a server page would make "3 interactions are
+     * set up on their own elements" mean "3 on this page" — a count that is a
+     * window length, which is the defect this sweep keeps finding rather than
+     * a shape it should add.
+     */ ()=>collectionCeiling(collection(firestore, 'hosts', hostId, 'actions'), ACTION_CEILING), [
+        firestore,
+        hostId
+    ], {
+        idField: '$id'
+    });
+    const { rows: readActions, truncated: actionsTruncated } = ceilingedWindow(actionDocs, ACTION_CEILING);
+    const [draft, setDraft] = useState(null);
+    /**
+   * The editor has been opened at least once in this session.
+   *
+   * A LATCH rather than `draft` itself, because the pickers below key their
+   * listeners on it. Tracking the dialog would tear those subscriptions down
+   * on Cancel and pay for them again on the next Edit, so a merchant working
+   * through ten actions would buy the same six windows ten times — worse than
+   * the mount-time read this replaces. Latched, a reader who never edits pays
+   * nothing and a reader who edits pays once.
+   */ const [editorOpened, setEditorOpened] = useState(false);
+    if (draft && !editorOpened) setEditorOpened(true);
+    /*
+   * The step editor's six option lists, read on the same latch as the
+   * Workflows builder's — one hook, because the two editors offer one set of
+   * steps and a second copy would be a second read cost to keep in agreement.
+   */ const { pickers: stepPickers, truncated: truncatedPickers } = useAutomationStepPickers(hostId, editorOpened);
+    const liveActions = readActions.filter((action)=>!action.deletedAt);
+    /*
+   * Opens a listed action in the editor, for a widget in the `hostAutomations`
+   * zone — one that drafted an action and offers to open it. Read through a
+   * ref so the callback keeps one identity while the list changes beneath it,
+   * and answers `false` for an id the list has not read yet.
+   */ const listedRef = useRef(liveActions);
+    listedRef.current = liveActions;
+    const openAction = useCallback((actionId)=>{
+        const action = listedRef.current.find((row)=>row.$id === actionId);
+        if (!action) return false;
+        setDraft(draftFromAction(action, action.$id));
+        return true;
+    }, []);
+    /**
+   * Element interactions are not listed here.
+   *
+   * An ACTION is something the SITE does — an order was placed, a form was
+   * submitted. An INTERACTION is something an ELEMENT does, and it belongs to
+   * the document that holds the element: it publishes and rolls back with it,
+   * travels with it, and is deleted with it. This page is the site's
+   * automation list, and a nav menu's hover timing sitting in it beside "when
+   * an order is placed" was the tell that the two had been conflated.
+   *
+   * These rows are the ones written BEFORE the move, still bound by selector.
+   * They keep running and stay editable — on their element, in the besigner,
+   * which is now the only place they appear. Counted rather than hidden
+   * outright, so the page can say where they went instead of appearing to
+   * have lost them.
+   */ const elementScoped = liveActions.filter((action)=>{
+        var _ref;
+        var _action_trigger;
+        return LEAF_SELECTOR.test(String((_ref = action == null ? void 0 : (_action_trigger = action.trigger) == null ? void 0 : _action_trigger.selector) != null ? _ref : ''));
+    });
+    // Sorting is safe here in a way it is not on a paged list: these rows are
+    // the whole collection below the ceiling, not a slice of one.
+    const actions = liveActions.filter((action)=>!elementScoped.includes(action)).sort((a, b)=>{
+        var _a_name, _b_name;
+        return String((_a_name = a.name) != null ? _a_name : '').localeCompare(String((_b_name = b.name) != null ? _b_name : ''));
+    });
+    // The page is a SLICE: the rows are already in hand, and both the element
+    // interaction count and the alphabetical order need all of them.
+    const [page, setPage] = useState(0);
+    const [pageSize, setPageSize] = useState(TABLE_PAGE_SIZE_DEFAULT);
+    const visibleActions = useMemo(()=>actions.slice(page * pageSize, page * pageSize + pageSize), [
+        actions,
+        page,
+        pageSize
+    ]);
+    const patch = useCallback((updater)=>setDraft((previous)=>previous ? updater(previous) : previous), []);
+    /** The saved action the editor has open, as the `automationEditor` zone names it. */ const draftId = (_ref = draft == null ? void 0 : draft.id) != null ? _ref : null;
+    const draftName = (_ref1 = draft == null ? void 0 : draft.name) != null ? _ref1 : '';
+    const editorTarget = useMemo(()=>draftId ? {
+            type: 'action',
+            id: draftId,
+            name: draftName
+        } : null, // The name the editor opened with: the zone reads the automation as it is
+    // stored, so a rename being typed does not make it a different one.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+        draftId
+    ]);
+    /**
+   * Whether this workspace may open the editor at all. One gate for the
+   * blank action and the recipes: a recipe is an action, so the plan that
+   * carries one carries the other, and the refusal reads the same.
+   */ const actionsEntitled = useCallback(()=>{
+        if (checkEntitlement(org, 'actions')) return true;
+        enqueueSnackbar('The actions builder requires a Pro plan — see Billing to upgrade', {
+            variant: 'warning',
+            persist: false
+        });
+        return false;
+    }, [
+        org,
+        enqueueSnackbar
+    ]);
+    const handleAdd = useCallback(()=>{
+        if (!actionsEntitled()) return;
+        setDraft({
+            id: null,
+            name: '',
+            trigger: {
+                event: 'formSubmission',
+                filter: ''
+            },
+            steps: [
+                defaultStep('siteAlert')
+            ],
+            enabled: true,
+            customEvent: '',
+            conditionRows: [
+                EMPTY_CONDITION_ROW
+            ],
+            conditionCombinator: 'and',
+            recipe: null
+        });
+    }, [
+        actionsEntitled
+    ]);
+    /*
+   * THE RECIPES (AGL-2626).
+   *
+   * A recipe opens the editor prefilled and writes nothing: the draft it
+   * builds is the one Save would persist, and until then it is state in
+   * this card and nowhere else. Three recipes open at once; "Tag by form"
+   * needs a form first, and the form is this site's — `hosts/{hostId}/forms`
+   * — so the picker is the one host-scoped piece of the feature, held here
+   * rather than in the catalog.
+   */ const [recipesAnchor, setRecipesAnchor] = useState(null);
+    const [formPickFor, setFormPickFor] = useState(null);
+    const [pickedFormId, setPickedFormId] = useState('');
+    /**
+   * The form picker has been opened at least once — the `editorOpened`
+   * latch's twin, and for the same reason: the forms window is read for
+   * this picker only, and a reader who never opens it pays nothing.
+   */ const [formPickerOpened, setFormPickerOpened] = useState(false);
+    if (formPickFor && !formPickerOpened) setFormPickerOpened(true);
+    const { data: formRead } = useFirestoreCollection(()=>formPickerOpened ? collectionCeiling(collection(firestore, 'hosts', hostId, 'forms'), EDITOR_OPTION_CEILING) : null, [
+        firestore,
+        hostId,
+        formPickerOpened
+    ], {
+        idField: '$id'
+    });
+    const { rows: formDocs, truncated: formsTruncated } = ceilingedWindow(formRead, EDITOR_OPTION_CEILING);
+    // An archived form collects nothing, so a recipe keyed on it would never
+    // fire; the name falls back to the id the way every form list's does.
+    const formOptions = (formDocs != null ? formDocs : []).filter((form)=>!form.archivedAt).map((form)=>{
+        var _form_displayName;
+        return {
+            id: form.$id,
+            name: String((_form_displayName = form.displayName) != null ? _form_displayName : '').trim() || form.$id
+        };
+    }).sort((a, b)=>a.name.localeCompare(b.name));
+    const handleRecipe = useCallback((recipe)=>{
+        setRecipesAnchor(null);
+        if (!actionsEntitled()) return;
+        if (recipe.needs === 'form') {
+            setPickedFormId('');
+            setFormPickFor(recipe);
+            return;
+        }
+        setDraft(draftFromAction(recipe.build(), null));
+    }, [
+        actionsEntitled
+    ]);
+    const handleFormPicked = useCallback(()=>{
+        const recipe = formPickFor;
+        const form = formOptions.find((option)=>option.id === pickedFormId);
+        if (!recipe || !form) return;
+        setFormPickFor(null);
+        setDraft(draftFromAction(recipe.build({
+            form
+        }), null));
+    }, [
+        formPickFor,
+        formOptions,
+        pickedFormId
+    ]);
+    // Run log + test runs (AGL-266).
+    const [runsFor, setRunsFor] = useState(null);
+    const handleTestRun = useCallback(async (action)=>{
+        try {
+            var _action_trigger;
+            const response = await fetch('/api/events/dispatch', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    hostId,
+                    actionId: action.$id,
+                    event: (_action_trigger = action.trigger) == null ? void 0 : _action_trigger.event,
+                    payload: {
+                        path: '/console-test',
+                        test: 'true'
+                    }
+                })
+            });
+            const payload = await response.json().catch(()=>({}));
+            if (!response.ok) {
+                var _ref;
+                return void enqueueSnackbar((_ref = payload == null ? void 0 : payload.error) != null ? _ref : 'Test run failed', {
+                    variant: 'warning',
+                    persist: false
+                });
+            }
+            const alerts = Array.isArray(payload == null ? void 0 : payload.alerts) ? payload.alerts : [];
+            enqueueSnackbar(alerts.length ? `Test ran — first alert: ${alerts[0].message}` : 'Test ran — server steps executed (see Runs)', {
+                variant: 'success',
+                persist: false
+            });
+        } catch (error) {
+            console.error(error);
+            enqueueSnackbar('Test run failed', {
+                variant: 'error'
+            });
+        }
+    }, [
+        hostId,
+        enqueueSnackbar
+    ]);
+    const handleSave = useCallback(async ()=>{
+        var _draft_trigger_filter, _draft_trigger_selector, _draft_trigger_pathPattern;
+        if (!draft) return;
+        const isCustom = draft.trigger.event === CUSTOM_EVENT_VALUE;
+        const candidate = _extends({
+            name: draft.name.trim().slice(0, 60),
+            trigger: _extends({
+                event: isCustom ? draft.customEvent.trim() : draft.trigger.event
+            }, ((_draft_trigger_filter = draft.trigger.filter) == null ? void 0 : _draft_trigger_filter.trim()) ? {
+                filter: draft.trigger.filter.trim()
+            } : {}, ((_draft_trigger_selector = draft.trigger.selector) == null ? void 0 : _draft_trigger_selector.trim()) ? {
+                selector: draft.trigger.selector.trim()
+            } : {}, Number(draft.trigger.threshold) > 0 ? {
+                threshold: Number(draft.trigger.threshold)
+            } : {}, ((_draft_trigger_pathPattern = draft.trigger.pathPattern) == null ? void 0 : _draft_trigger_pathPattern.trim()) ? {
+                pathPattern: draft.trigger.pathPattern.trim()
+            } : {}, draft.trigger.oncePerVisitor === true ? {
+                oncePerVisitor: true
+            } : {}, draft.trigger.oncePerSession === true ? {
+                oncePerSession: true
+            } : {}, Number(draft.trigger.cooldownMinutes) >= 1 ? {
+                cooldownMinutes: Number(draft.trigger.cooldownMinutes)
+            } : {}, draft.trigger.everyTime === true ? {
+                everyTime: true
+            } : {}, draft.conditionRows.some((row)=>row.op) ? {
+                conditions: draft.conditionRows.filter((row)=>row.op).map((row)=>_extends({
+                        field: row.field.trim(),
+                        op: row.op
+                    }, row.op !== 'notEmpty' ? {
+                        value: row.value.trim()
+                    } : {})),
+                combinator: draft.conditionCombinator
+            } : {}),
+            steps: draft.steps,
+            enabled: draft.enabled !== false
+        }, draft.recipe !== undefined ? {
+            recipe: draft.recipe
+        } : {});
+        const problem = validateHostAction(candidate);
+        if (problem) {
+            return void enqueueSnackbar(problem, {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        try {
+            var _draft_id;
+            const id = (_draft_id = draft.id) != null ? _draft_id : createResourceUid();
+            /**
+       * Refuse an EDIT whose seed the server never confirmed (AGL-1358).
+       *
+       * The payload is the whole action. `merge: true` is here so the
+       * frequency caps and conditions can be nulled explicitly, not to
+       * protect untouched fields — there are none, they are all in the
+       * payload. So a cached seed does not lose one edit, it reverts the
+       * trigger and every step to whatever the cache last held, on an
+       * automation that is running on a live site.
+       *
+       * Only the edit path. A NEW action is built from `EMPTY_*` defaults at
+       * a fresh uid and can overwrite nothing; the first snapshot of any
+       * listener is `fromCache: true`, so guarding a create would refuse a
+       * save that was never unsafe.
+       *
+       * The guard WRAPS the write — the interaction builder's early return
+       * is the shape you can keep while losing the protection.
+       */ /**
+       * The action DOCUMENT is created by the server (AGL-2266).
+       *
+       * `hosts/{hostId}/actions` was in none of the host catch-all's exclusion
+       * lists, so any editor could create one client-direct on any plan and
+       * nothing counted them. /api/hosts/resources now owns the create and
+       * holds `ACTIONS_MAX_PER_HOST` from a server read.
+       *
+       * Only the create moves, and it writes a SHELL. The merge-set below is
+       * untouched and still carries the whole candidate — trigger, steps,
+       * conditions, the explicit nulls AGL-274/557 depend on — so no field can
+       * be lost to the route's allow-list, and for an existing action this
+       * path does not run at all.
+       */ if (!draft.id) {
+                try {
+                    var _ref, _candidate_name;
+                    await createResource({
+                        hostId,
+                        resource: 'action',
+                        id,
+                        data: {
+                            name: (_ref = (_candidate_name = candidate.name) != null ? _candidate_name : draft.name) != null ? _ref : 'Untitled action'
+                        }
+                    });
+                } catch (error) {
+                    var _ref1;
+                    return void enqueueSnackbar((_ref1 = error == null ? void 0 : error.message) != null ? _ref1 : 'Could not create the interaction', {
+                        variant: 'error'
+                    });
+                }
+            }
+            const verdict = await writeGuardedBySeed({
+                subject: 'action',
+                unreadable: Boolean(draft.id) && actionsStatus === 'error',
+                fromCache: Boolean(draft.id) && actionsFromCache
+            }, async ()=>{
+                await setDoc(doc(firestore, 'hosts', hostId, 'actions', id), _extends({}, hostActionDocument(candidate), {
+                    updatedAt: Timestamp.now()
+                }, draft.id ? {} : {
+                    createdAt: Timestamp.now()
+                }), {
+                    merge: true
+                });
+            });
+            // A refusal keeps the editor open with everything that was typed.
+            if (!verdict.ok) {
+                return void enqueueSnackbar(verdict.message, {
+                    variant: 'warning',
+                    persist: false
+                });
+            }
+            setDraft(null);
+            enqueueSnackbar('Action saved', {
+                variant: 'success',
+                persist: false
+            });
+        } catch (error) {
+            console.error(error);
+            enqueueSnackbar('An error has occurred', {
+                variant: 'error',
+                allowDuplicate: true
+            });
+        }
+    }, [
+        draft,
+        firestore,
+        createResource,
+        hostId,
+        enqueueSnackbar,
+        actionsFromCache,
+        actionsStatus
+    ]);
+    const handleDelete = useCallback((action)=>async ()=>{
+            const confirmed = await confirm({
+                title: 'Delete this action?',
+                description: `"${action.name}" stops running on its trigger.`,
+                confirmationText: 'Delete',
+                confirmationButtonProps: {
+                    color: 'error'
+                }
+            }).then(()=>true).catch(()=>false);
+            if (!confirmed) return;
+            await updateDoc(doc(firestore, 'hosts', hostId, 'actions', action.$id), {
+                deletedAt: Timestamp.now()
+            });
+        }, [
+        confirm,
+        firestore,
+        hostId
+    ]);
+    const handleToggle = useCallback((action)=>async (event)=>{
+            const enabled = event.target.checked;
+            /*
+       * A placeholder is a value nobody has supplied yet. Switched on, the
+       * step holding it fails every run and a condition holding one never
+       * matches, so turning such an automation on is confirmed, naming what
+       * is still missing.
+       */ const missing = enabled ? automationPlaceholders(action) : [];
+            if (missing.length) {
+                const confirmed = await confirm({
+                    title: 'Switch on with placeholders?',
+                    description: `"${action.name}" still has ${missing.length === 1 ? 'a placeholder' : `${missing.length} placeholders`} ` + `to fill in: ${missing.slice(0, 3).map(describeAutomationPlaceholder).join('; ')}` + `${missing.length > 3 ? '; …' : ''}. Open it with Edit to fill ` + `${missing.length === 1 ? 'it' : 'them'} in first.`,
+                    confirmationText: 'Switch on anyway'
+                }).then(()=>true).catch(()=>false);
+                if (!confirmed) return;
+            }
+            await updateDoc(doc(firestore, 'hosts', hostId, 'actions', action.$id), {
+                enabled
+            });
+        }, [
+        confirm,
+        firestore,
+        hostId
+    ]);
+    return /*#__PURE__*/ _jsxs(CardDisplay, {
+        header: 'Actions',
+        help: pluginDocsHelp('actionsBuilder', {
+            anchor: '#create-an-action'
+        }),
+        contentGutterX: true,
+        contentGutterY: true,
+        children: [
+            /*#__PURE__*/ _jsxs(Stack, {
+                spacing: 1,
+                children: [
+                    /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: 'When a site event fires, run automations in order — trigger a ' + 'workflow, show the visitor an alert, chain a custom event, or ' + 'write to a dataset. Pro plans and up.'
+                    }),
+                    visibleActions.map((action)=>{
+                        var _action_steps, _ref;
+                        var _action_trigger, _action_trigger1;
+                        const missing = automationPlaceholders(action).length;
+                        return /*#__PURE__*/ _jsxs(Stack, {
+                            direction: "row",
+                            spacing: 1,
+                            sx: {
+                                alignItems: 'center'
+                            },
+                            children: [
+                                /*#__PURE__*/ _jsx(Switch, {
+                                    size: "small",
+                                    checked: action.enabled !== false,
+                                    onChange: handleToggle(action)
+                                }),
+                                /*#__PURE__*/ _jsxs(Stack, {
+                                    sx: {
+                                        flex: 1,
+                                        minWidth: 0
+                                    },
+                                    children: [
+                                        /*#__PURE__*/ _jsx(Typography, {
+                                            variant: "body2",
+                                            noWrap: true,
+                                            children: action.name
+                                        }),
+                                        /*#__PURE__*/ _jsx(Typography, {
+                                            variant: "caption",
+                                            color: "text.secondary",
+                                            noWrap: true,
+                                            children: `on ${hostEventLabel((_action_trigger = action.trigger) == null ? void 0 : _action_trigger.event)}` + ` · ${((_action_steps = action.steps) != null ? _action_steps : []).map((step)=>{
+                                                var _HOST_ACTION_STEP_LABELS_step_type;
+                                                return (_HOST_ACTION_STEP_LABELS_step_type = HOST_ACTION_STEP_LABELS[step.type]) != null ? _HOST_ACTION_STEP_LABELS_step_type : step.type;
+                                            }).join(' → ')}`
+                                        }),
+                                        missing ? /*#__PURE__*/ _jsx(Typography, {
+                                            variant: "caption",
+                                            color: "warning.main",
+                                            noWrap: true,
+                                            children: missing === 1 ? '1 placeholder to fill in' : `${missing} placeholders to fill in`
+                                        }) : null
+                                    ]
+                                }),
+                                /*#__PURE__*/ _jsx(Button, {
+                                    size: "small",
+                                    onClick: ()=>setDraft(draftFromAction(action, action.$id)),
+                                    children: 'Edit'
+                                }),
+                                isSiteEventType(String((_ref = (_action_trigger1 = action.trigger) == null ? void 0 : _action_trigger1.event) != null ? _ref : '')) ? // Test run (AGL-266): server steps only, via the dispatch API.
+                                /*#__PURE__*/ _jsx(Button, {
+                                    size: "small",
+                                    onClick: ()=>void handleTestRun(action),
+                                    children: 'Test'
+                                }) : null,
+                                /*#__PURE__*/ _jsx(Button, {
+                                    size: "small",
+                                    onClick: ()=>setRunsFor(action),
+                                    children: 'Runs'
+                                }),
+                                /*#__PURE__*/ _jsx(Button, {
+                                    size: "small",
+                                    color: "error",
+                                    onClick: handleDelete(action),
+                                    children: 'Delete'
+                                })
+                            ]
+                        }, action.$id);
+                    }),
+                    actions.length === 0 ? null : /*#__PURE__*/ _jsx(ListPagination, {
+                        page: page,
+                        pageSize: pageSize,
+                        rowCount: visibleActions.length,
+                        // The actions the card HOLDS, which is what the reader is paging
+                        // through — not the collection, whose other half is the element
+                        // interactions counted below.
+                        count: actions.length,
+                        onPageChange: setPage,
+                        onPageSizeChange: setPageSize
+                    }),
+                    actionsTruncated ? /*#__PURE__*/ _jsx(Alert, {
+                        severity: "info",
+                        children: `Showing the first ${ACTION_CEILING} rows of this site’s ` + 'automations, ordered by id. There are more — both the list ' + 'above and the interaction count below describe only what was ' + 'read.'
+                    }) : null,
+                    /*#__PURE__*/ _jsxs(Stack, {
+                        direction: "row",
+                        spacing: 1,
+                        sx: {
+                            alignSelf: 'flex-start'
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                color: "primary",
+                                onClick: handleAdd,
+                                children: 'Add action'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                color: "primary",
+                                "aria-haspopup": "menu",
+                                "aria-controls": recipesAnchor ? 'host-action-recipes' : undefined,
+                                "aria-expanded": recipesAnchor ? true : undefined,
+                                onClick: (event)=>setRecipesAnchor(event.currentTarget),
+                                children: 'Recipes'
+                            }),
+                            ExtensionZone ? /*#__PURE__*/ _jsx(ExtensionZone, {
+                                slot: "hostAutomations",
+                                hostId: hostId,
+                                orgId: org == null ? void 0 : org.$id,
+                                openAction: openAction
+                            }) : null
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(Menu, {
+                        id: "host-action-recipes",
+                        anchorEl: recipesAnchor,
+                        open: Boolean(recipesAnchor),
+                        onClose: ()=>setRecipesAnchor(null),
+                        children: CRM_ACTION_RECIPES.map((recipe)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                onClick: ()=>handleRecipe(recipe),
+                                children: /*#__PURE__*/ _jsx(ListItemText, {
+                                    primary: recipe.title,
+                                    secondary: recipe.description,
+                                    slotProps: {
+                                        secondary: {
+                                            sx: {
+                                                whiteSpace: 'normal',
+                                                maxWidth: 360
+                                            }
+                                        }
+                                    }
+                                })
+                            }, recipe.id))
+                    }),
+                    elementScoped.length ? /*#__PURE__*/ _jsxs(Typography, {
+                        variant: "caption",
+                        color: "text.secondary",
+                        children: [
+                            elementScoped.length === 1 ? '1 interaction is set up on its own element — ' : `${elementScoped.length} interactions are set up on their own elements — `,
+                            'open the element in the besigner to edit it. Interactions ' + 'belong to the page they are on, so they publish and roll back ' + 'with it.'
+                        ]
+                    }) : null
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(draft),
+                onClose: ()=>setDraft(null),
+                maxWidth: "sm",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: (draft == null ? void 0 : draft.id) ? 'Edit action' : 'Add action'
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 1.5,
+                            pt: 1
+                        },
+                        children: [
+                            ExtensionZone && editorTarget ? /*#__PURE__*/ _jsx(ExtensionZone, {
+                                slot: "automationEditor",
+                                hostId: hostId,
+                                orgId: org == null ? void 0 : org.$id,
+                                target: editorTarget
+                            }) : null,
+                            (draft == null ? void 0 : draft.recipe) ? /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                children: `Started from the “${(_ref2 = (_CRM_ACTION_RECIPES_find = CRM_ACTION_RECIPES.find((recipe)=>recipe.id === draft.recipe)) == null ? void 0 : _CRM_ACTION_RECIPES_find.title) != null ? _ref2 : 'recipe'}” recipe — change anything, then save.`
+                            }) : null,
+                            truncatedPickers.length > 0 ? /*#__PURE__*/ _jsx(Alert, {
+                                severity: "info",
+                                sx: {
+                                    mt: 1
+                                },
+                                children: `Offering the first ${EDITOR_OPTION_CEILING} rows, ordered by ` + `id, for: ${truncatedPickers.join(', ')}. This site has ` + 'more, so a step target may not be listed below.'
+                            }) : null,
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Name",
+                                value: (_ref3 = draft == null ? void 0 : draft.name) != null ? _ref3 : '',
+                                onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                            name: event.target.value
+                                        })),
+                                size: "small",
+                                autoFocus: true,
+                                sx: {
+                                    mt: 1
+                                }
+                            }),
+                            /*#__PURE__*/ _jsxs(Stack, {
+                                direction: "row",
+                                spacing: 1,
+                                children: [
+                                    /*#__PURE__*/ _jsxs(TextField, {
+                                        select: true,
+                                        label: "Trigger event",
+                                        value: (_ref4 = draft == null ? void 0 : draft.trigger.event) != null ? _ref4 : '',
+                                        onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                    trigger: _extends({}, previous.trigger, {
+                                                        event: event.target.value
+                                                    })
+                                                })),
+                                        size: "small",
+                                        sx: {
+                                            minWidth: 180
+                                        },
+                                        children: [
+                                            HOST_EVENT_TYPES.map((eventType)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                                    value: eventType,
+                                                    children: hostEventLabel(eventType)
+                                                }, eventType)),
+                                            SITE_EVENT_TYPES.map((eventType)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                                    value: eventType,
+                                                    children: `${eventType} (on page)`
+                                                }, eventType)),
+                                            /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: CUSTOM_EVENT_VALUE,
+                                                children: 'Custom event…'
+                                            })
+                                        ]
+                                    }),
+                                    (draft == null ? void 0 : draft.trigger.event) === CUSTOM_EVENT_VALUE ? /*#__PURE__*/ _jsx(TextField, {
+                                        label: "Custom event name",
+                                        value: (_ref5 = draft == null ? void 0 : draft.customEvent) != null ? _ref5 : '',
+                                        onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                    customEvent: event.target.value
+                                                })),
+                                        size: "small",
+                                        sx: {
+                                            flex: 1
+                                        }
+                                    }) : /*#__PURE__*/ _jsx(TextField, {
+                                        label: "Filter (optional)",
+                                        placeholder: 'path == "/pricing"',
+                                        // What the expression — and the conditions below — can name
+                                        // for this event; nothing for an event whose payload is not
+                                        // written down, rather than a guess.
+                                        helperText: (_hostEventPayloadHint = hostEventPayloadHint(draft == null ? void 0 : draft.trigger.event)) != null ? _hostEventPayloadHint : undefined,
+                                        value: (_ref6 = draft == null ? void 0 : draft.trigger.filter) != null ? _ref6 : '',
+                                        onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                    trigger: _extends({}, previous.trigger, {
+                                                        filter: event.target.value
+                                                    })
+                                                })),
+                                        size: "small",
+                                        sx: {
+                                            flex: 1
+                                        }
+                                    })
+                                ]
+                            }),
+                            ((_ref7 = draft == null ? void 0 : draft.conditionRows) != null ? _ref7 : []).map((row, index)=>{
+                                var _ref, _ref1;
+                                return /*#__PURE__*/ _jsxs(Stack, {
+                                    direction: "row",
+                                    spacing: 1,
+                                    sx: {
+                                        alignItems: 'center'
+                                    },
+                                    children: [
+                                        index > 0 ? /*#__PURE__*/ _jsx(Typography, {
+                                            variant: "caption",
+                                            color: "text.secondary",
+                                            children: (draft == null ? void 0 : draft.conditionCombinator) === 'or' ? 'or' : 'and'
+                                        }) : null,
+                                        /*#__PURE__*/ _jsxs(TextField, {
+                                            select: true,
+                                            label: index === 0 ? 'Only run when' : 'Condition',
+                                            value: row.op,
+                                            onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                        conditionRows: previous.conditionRows.map((previousRow, index2)=>index2 === index ? _extends({}, previousRow, {
+                                                                op: event.target.value
+                                                            }) : previousRow)
+                                                    })),
+                                            size: "small",
+                                            sx: {
+                                                minWidth: 180
+                                            },
+                                            children: [
+                                                ((_ref = draft == null ? void 0 : draft.conditionRows.length) != null ? _ref : 0) === 1 ? /*#__PURE__*/ _jsx(MenuItem, {
+                                                    value: "",
+                                                    children: 'Always (no condition)'
+                                                }) : null,
+                                                /*#__PURE__*/ _jsx(MenuItem, {
+                                                    value: "notEmpty",
+                                                    children: 'A field is not empty'
+                                                }),
+                                                /*#__PURE__*/ _jsx(MenuItem, {
+                                                    value: "equals",
+                                                    children: 'A field equals…'
+                                                }),
+                                                /*#__PURE__*/ _jsx(MenuItem, {
+                                                    value: "contains",
+                                                    children: 'A field contains…'
+                                                })
+                                            ]
+                                        }),
+                                        row.op ? /*#__PURE__*/ _jsx(TextField, {
+                                            label: "Field",
+                                            placeholder: "subscribe",
+                                            value: row.field,
+                                            onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                        conditionRows: previous.conditionRows.map((previousRow, index2)=>index2 === index ? _extends({}, previousRow, {
+                                                                field: event.target.value
+                                                            }) : previousRow)
+                                                    })),
+                                            size: "small",
+                                            sx: {
+                                                flex: 1
+                                            }
+                                        }) : null,
+                                        row.op === 'equals' || row.op === 'contains' ? /*#__PURE__*/ _jsx(TextField, _extends({
+                                            label: "Value",
+                                            placeholder: "Yes"
+                                        }, placeholderState(row.value, 'Replace the placeholder with the value to match'), {
+                                            value: row.value,
+                                            onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                        conditionRows: previous.conditionRows.map((previousRow, index2)=>index2 === index ? _extends({}, previousRow, {
+                                                                value: event.target.value
+                                                            }) : previousRow)
+                                                    })),
+                                            size: "small",
+                                            sx: {
+                                                flex: 1
+                                            }
+                                        })) : null,
+                                        ((_ref1 = draft == null ? void 0 : draft.conditionRows.length) != null ? _ref1 : 0) > 1 ? /*#__PURE__*/ _jsx(IconButton, {
+                                            size: "small",
+                                            "aria-label": "remove condition",
+                                            onClick: ()=>patch((previous)=>_extends({}, previous, {
+                                                        conditionRows: previous.conditionRows.length > 1 ? previous.conditionRows.filter((_, index2)=>index2 !== index) : [
+                                                            EMPTY_CONDITION_ROW
+                                                        ]
+                                                    })),
+                                            children: '×'
+                                        }) : null
+                                    ]
+                                }, index);
+                            }),
+                            (draft == null ? void 0 : draft.conditionRows.every((row)=>row.op)) ? /*#__PURE__*/ _jsxs(Stack, {
+                                direction: "row",
+                                spacing: 1,
+                                sx: {
+                                    alignItems: 'center'
+                                },
+                                children: [
+                                    /*#__PURE__*/ _jsx(Button, {
+                                        size: "small",
+                                        disabled: ((_ref8 = draft == null ? void 0 : draft.conditionRows.length) != null ? _ref8 : 0) >= ACTION_MAX_CONDITIONS,
+                                        onClick: ()=>patch((previous)=>_extends({}, previous, {
+                                                    conditionRows: [
+                                                        ...previous.conditionRows,
+                                                        // New rows start on the simplest operator so the
+                                                        // field input is immediately visible.
+                                                        {
+                                                            op: 'notEmpty',
+                                                            field: '',
+                                                            value: ''
+                                                        }
+                                                    ]
+                                                })),
+                                        children: 'Add condition'
+                                    }),
+                                    ((_ref9 = draft == null ? void 0 : draft.conditionRows.length) != null ? _ref9 : 0) >= 2 ? // AND/OR combinator (AGL-565); applies to every row.
+                                    /*#__PURE__*/ _jsxs(TextField, {
+                                        select: true,
+                                        label: "Match",
+                                        value: (_ref10 = draft == null ? void 0 : draft.conditionCombinator) != null ? _ref10 : 'and',
+                                        onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                    conditionCombinator: event.target.value
+                                                })),
+                                        size: "small",
+                                        sx: {
+                                            minWidth: 220
+                                        },
+                                        children: [
+                                            /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: "and",
+                                                children: 'All conditions match (AND)'
+                                            }),
+                                            /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: "or",
+                                                children: 'Any condition matches (OR)'
+                                            })
+                                        ]
+                                    }) : null
+                                ]
+                            }) : null,
+                            isSiteEventType((_ref11 = draft == null ? void 0 : draft.trigger.event) != null ? _ref11 : '') ? // Site-event config (AGL-256): what/where the trigger watches.
+                            /*#__PURE__*/ _jsxs(Stack, {
+                                direction: "row",
+                                spacing: 1,
+                                children: [
+                                    ELEMENT_SCOPED_SITE_EVENTS.includes((_ref12 = draft == null ? void 0 : draft.trigger.event) != null ? _ref12 : '') ? /*#__PURE__*/ _jsx(TextField, {
+                                        label: "CSS selector",
+                                        placeholder: "#pricing-table",
+                                        value: (_ref13 = draft == null ? void 0 : draft.trigger.selector) != null ? _ref13 : '',
+                                        onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                    trigger: _extends({}, previous.trigger, {
+                                                        selector: event.target.value
+                                                    })
+                                                })),
+                                        size: "small",
+                                        sx: {
+                                            flex: 1
+                                        }
+                                    }) : null,
+                                    [
+                                        'scrollDepth',
+                                        'timeOnPage'
+                                    ].includes((_ref14 = draft == null ? void 0 : draft.trigger.event) != null ? _ref14 : '') ? /*#__PURE__*/ _jsx(TextField, {
+                                        type: "number",
+                                        label: (draft == null ? void 0 : draft.trigger.event) === 'scrollDepth' ? 'Scroll %' : 'Seconds',
+                                        value: (_ref15 = draft == null ? void 0 : draft.trigger.threshold) != null ? _ref15 : '',
+                                        onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                    trigger: _extends({}, previous.trigger, {
+                                                        threshold: Number(event.target.value)
+                                                    })
+                                                })),
+                                        size: "small",
+                                        sx: {
+                                            width: 120
+                                        }
+                                    }) : null,
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        label: "Only on pages (optional)",
+                                        placeholder: "/pricing or /blog/*",
+                                        value: (_ref16 = draft == null ? void 0 : draft.trigger.pathPattern) != null ? _ref16 : '',
+                                        onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                    trigger: _extends({}, previous.trigger, {
+                                                        pathPattern: event.target.value
+                                                    })
+                                                })),
+                                        size: "small",
+                                        sx: {
+                                            flex: 1
+                                        }
+                                    }),
+                                    /*#__PURE__*/ _jsxs(TextField, {
+                                        select: true,
+                                        label: "Frequency",
+                                        size: "small",
+                                        sx: {
+                                            minWidth: 170
+                                        },
+                                        value: (draft == null ? void 0 : draft.trigger.oncePerVisitor) ? 'visitor' : (draft == null ? void 0 : draft.trigger.oncePerSession) ? 'session' : Number(draft == null ? void 0 : draft.trigger.cooldownMinutes) >= 1 ? 'cooldown' : (draft == null ? void 0 : draft.trigger.everyTime) ? 'every' : '',
+                                        onChange: (event)=>{
+                                            const mode = event.target.value;
+                                            patch((previous)=>_extends({}, previous, {
+                                                    trigger: _extends({}, previous.trigger, {
+                                                        // Every occurrence (AGL-562): repeatable UI
+                                                        // choreography (menu/drawer toggles).
+                                                        everyTime: mode === 'every',
+                                                        oncePerVisitor: mode === 'visitor',
+                                                        oncePerSession: mode === 'session',
+                                                        cooldownMinutes: mode === 'cooldown' ? Number(previous.trigger.cooldownMinutes) >= 1 ? Number(previous.trigger.cooldownMinutes) : 60 : undefined
+                                                    })
+                                                }));
+                                        },
+                                        children: [
+                                            /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: "",
+                                                children: 'Every matching pageview'
+                                            }),
+                                            /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: "every",
+                                                children: 'Every occurrence (repeatable)'
+                                            }),
+                                            /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: "session",
+                                                children: 'Once per session'
+                                            }),
+                                            /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: "visitor",
+                                                children: 'Once per visitor'
+                                            }),
+                                            /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: "cooldown",
+                                                children: 'With a cooldown'
+                                            })
+                                        ]
+                                    }),
+                                    Number(draft == null ? void 0 : draft.trigger.cooldownMinutes) >= 1 && !(draft == null ? void 0 : draft.trigger.oncePerVisitor) && !(draft == null ? void 0 : draft.trigger.oncePerSession) ? /*#__PURE__*/ _jsx(TextField, {
+                                        type: "number",
+                                        label: "Cooldown (minutes)",
+                                        size: "small",
+                                        sx: {
+                                            width: 150
+                                        },
+                                        value: (_ref17 = draft == null ? void 0 : draft.trigger.cooldownMinutes) != null ? _ref17 : 60,
+                                        onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                    trigger: _extends({}, previous.trigger, {
+                                                        cooldownMinutes: Number(event.target.value)
+                                                    })
+                                                }))
+                                    }) : null
+                                ]
+                            }) : null,
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "overline",
+                                color: "text.secondary",
+                                children: 'Steps (run in order)'
+                            }),
+                            ((_ref18 = draft == null ? void 0 : draft.steps) != null ? _ref18 : []).map((step, index)=>/*#__PURE__*/ _jsx(AutomationStepFields, {
+                                    step: step,
+                                    index: index,
+                                    kind: step.type,
+                                    kinds: ACTION_STEP_KINDS,
+                                    stepForKind: (value)=>defaultStep(value),
+                                    pickers: stepPickers,
+                                    onSteps: (update)=>patch((previous)=>_extends({}, previous, {
+                                                steps: update(previous.steps)
+                                            }))
+                                }, index)),
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                sx: {
+                                    alignSelf: 'flex-start'
+                                },
+                                disabled: ((_ref19 = draft == null ? void 0 : draft.steps.length) != null ? _ref19 : 0) >= ACTION_MAX_STEPS,
+                                onClick: ()=>patch((previous)=>_extends({}, previous, {
+                                            steps: [
+                                                ...previous.steps,
+                                                defaultStep('siteAlert')
+                                            ]
+                                        })),
+                                children: 'Add step'
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                onClick: ()=>setDraft(null),
+                                children: 'Cancel'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                disabled: !(draft == null ? void 0 : draft.name.trim()),
+                                onClick: handleSave,
+                                children: 'Save action'
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(formPickFor),
+                onClose: ()=>setFormPickFor(null),
+                maxWidth: "xs",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: (_ref20 = formPickFor == null ? void 0 : formPickFor.title) != null ? _ref20 : ''
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 1.5,
+                            pt: 1
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                children: 'Pick the form whose new contacts get the tag. The action opens ' + 'ready to edit; nothing is saved until you save it.'
+                            }),
+                            formsTruncated ? /*#__PURE__*/ _jsx(Alert, {
+                                severity: "info",
+                                children: `Offering the first ${EDITOR_OPTION_CEILING} forms, ordered by ` + 'id. This site has more, so the form you want may not be listed.'
+                            }) : null,
+                            formOptions.length ? /*#__PURE__*/ _jsx(TextField, {
+                                select: true,
+                                label: "Form",
+                                value: pickedFormId,
+                                onChange: (event)=>setPickedFormId(event.target.value),
+                                size: "small",
+                                sx: {
+                                    mt: 1
+                                },
+                                children: formOptions.map((option)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                        value: option.id,
+                                        children: option.name
+                                    }, option.id))
+                            }) : /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                children: 'This site has no forms yet. Add one in the besigner, then come back.'
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                color: "inherit",
+                                onClick: ()=>setFormPickFor(null),
+                                children: 'Cancel'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                disabled: !pickedFormId,
+                                onClick: handleFormPicked,
+                                children: 'Use recipe'
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(runsFor),
+                onClose: ()=>setRunsFor(null),
+                maxWidth: "sm",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: `Runs — ${(_ref21 = runsFor == null ? void 0 : runsFor.name) != null ? _ref21 : ''}`
+                    }),
+                    /*#__PURE__*/ _jsx(DialogContent, {
+                        children: runsFor ? /*#__PURE__*/ _jsx(HostRunHistoryCard, {
+                            hostId: hostId,
+                            orgId: org == null ? void 0 : org.$id,
+                            targetId: runsFor.$id,
+                            targetType: "action",
+                            targetName: (_runsFor_name = runsFor.name) != null ? _runsFor_name : '',
+                            header: "Recent runs"
+                        }) : null
+                    }),
+                    /*#__PURE__*/ _jsx(DialogActions, {
+                        children: /*#__PURE__*/ _jsx(Button, {
+                            color: "inherit",
+                            onClick: ()=>setRunsFor(null),
+                            children: 'Close'
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+HostActionsCard.displayName = 'HostActionsCard';
+export default HostActionsCard;
+
+//# sourceMappingURL=host-actions-card.component.js.map