@aglyn/plugins-workflows 1.0.0-beta.143

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

@@ -0,0 +1,952 @@
+/**
+ * @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 { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { checkEntitlement, checkQuota, HOST_EVENT_TYPES, hostEventLabel, hostEventPayloadHint, pluginDocsHelp, runWorkflow, WORKFLOW_MAX_STEPS } from "@aglyn/aglyn";
+/*
+ * The MODULE, not the barrel, for the two PURE helpers — every spec that
+ * renders this card mocks `@aglyn/tenant-feature-instance` wholesale to stage
+ * its Firestore hooks, and a query builder imported through that barrel
+ * disappears under the mock. Neither of these is a hook.
+ */ import { ceilingedWindow, collectionCeiling } from "@aglyn/tenant-feature-instance/hooks/host-collection-queries";
+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 QuotaReadoutComponent from "@aglyn/shared-ui-jsx/components/quota-readout.component";
+import { useSnackbar } from "@aglyn/shared-ui-snackstack";
+import { Timestamp } from "@aglyn/shared-util-timestamp";
+import { Alert, Button, Dialog, DialogActions, DialogContent, DialogTitle, MenuItem, Stack, TextField, Typography } from "@mui/material";
+import { collection, doc, getCountFromServer, setDoc, updateDoc } from "firebase/firestore";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useDuplicateResource, useFirestore, useFirestoreCollection, useHostResourceApi, useUser, writeGuardedBySeed } from "@aglyn/tenant-feature-instance";
+import { AutomationStepFields, defaultStep } from "./automation-step-fields.component.js";
+import { isWorkflowActionStep, validateWorkflowSteps, WORKFLOW_ACTION_STEP_TYPES, workflowFunctionCalls, workflowStepTypeLabel } from "../engine/workflow-steps.js";
+import HostRunHistoryCard from "./host-run-history-card.component.js";
+import { EDITOR_OPTION_CEILING, useAutomationStepPickers } from "./use-automation-step-pickers.js";
+import { listConsoleWidgets } from "@aglyn/aglyn";
+import { fetchWhereUsed, summarizeDependents } from "@aglyn/aglyn/app-utils/where-used";
+import { WORKFLOW_USAGE_ZONE } from "./workflow-zones.js";
+/**
+ * How many workflows the card reads.
+ *
+ * A CEILING, not a page size — see the query, which explains why this list
+ * cannot be paged by the server without making the duplicate-name check lie.
+ */ const WORKFLOW_CEILING = 100;
+/** The "Do" entry for the step kind a workflow has always had: a call. */ const FUNCTION_CALL_KIND = 'functionCall';
+/**
+ * What a step may be (AGL-3105).
+ *
+ * The function call comes first because it is what a workflow was before the
+ * two engines became one, and is still what a new step is. After it comes
+ * every Actions step a SERVER event can run — the client-only interactions
+ * are absent, because a workflow runs where there is no page to run them on.
+ */ const STEP_KINDS = [
+    {
+        value: FUNCTION_CALL_KIND,
+        label: 'Call a function'
+    },
+    ...WORKFLOW_ACTION_STEP_TYPES.map((value)=>({
+            value,
+            label: workflowStepTypeLabel(value)
+        }))
+];
+/**
+ * Workflow builder v1 (AGL-101): pipelines of host-function calls — each
+ * step's argument expressions see host variables and previous step results
+ * (`step1`, or a custom result name). Runs through the pure `runWorkflow`
+ * evaluator; test-run panel included. Plan-gated (`workflows` flag +
+ * `workflowsPerHost` cap, AGL-99); site-event triggers are v2.
+ */ export function HostWorkflowsCard(props) {
+    var _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _runsFor_name;
+    var _draft_trigger, _draft_trigger1, _draft_trigger2;
+    const { hostId } = props;
+    const firestore = useFirestore();
+    const { data: user } = useUser();
+    const createHostResource = useHostResourceApi();
+    const { enqueueSnackbar } = useSnackbar();
+    // Duplicate (AGL-2936): the copy keeps every step and arrives disarmed —
+    // its trigger is cleared — so nothing runs twice until somebody arms it.
+    const duplicate = useDuplicateResource({
+        hostId,
+        onDuplicated: (_kind, copy)=>enqueueSnackbar(`Duplicated as “${copy.name}” — arm its trigger to run it`, {
+                variant: 'success'
+            })
+    });
+    const { confirm } = useConfirmationContext();
+    const { org } = props;
+    /**
+   * The shell's zone renderer, for what other plugins add to a saved workflow's
+   * editor (AGL-2919); `null` outside the console shell.
+   */ const ExtensionZone = useConsoleWidgetSlot();
+    const { data: workflowDocs, status: workflowsStatus, /**
+     * The rows this editor is seeded from are unconfirmed by the server
+     * (AGL-1358). Editing destructures a whole stored workflow into `draft`
+     * and writes `{...definition}` back, so `merge: true` protects nothing.
+     * `trigger` is the field that makes this more than a lost edit: it is
+     * `{event, filter}` or `null` for manual-only, and nothing else on this
+     * card writes it, so a cached seed can re-arm an automation the author
+     * disarmed — or disarm one running on a live site — and revert every
+     * step of the pipeline with it.
+     */ fromCache: workflowsFromCache } = useFirestoreCollection(/*
+     * ORDERED AND CEILINGED, deliberately not paged by the query (AGL-2501) —
+     * the same decision as the logic plugin's two cards, for the same reasons.
+     *
+     * `limit(100)` alone is answered in DOCUMENT-ID order, so the window is a
+     * pseudo-random hundred that the `localeCompare` below arranges
+     * 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 workflow written without one rather than mis-sorting the list, and
+     * `/api/hosts/resources` validates no field for presence while
+     * `IMPORTABLE_FIELDS.workflows` copies one only if the export carried it.
+     *
+     * The QUERY is not paged because `nameTaken` below tests the draft against
+     * these rows: computed variables look their workflow up BY NAME
+     * (AGL-185/AGL-261), so a duplicate silently rebinds a live binding, and a
+     * uniqueness check over a ten-row page would let one through.
+     */ ()=>collectionCeiling(collection(firestore, 'hosts', hostId, 'workflows'), WORKFLOW_CEILING), [
+        firestore,
+        hostId
+    ], {
+        idField: '$id'
+    });
+    const { rows: readWorkflows, truncated: workflowsTruncated } = ceilingedWindow(workflowDocs, WORKFLOW_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 two reads 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 two 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 EDITOR'S WORKING SET, read when the editor opens.
+   *
+   * Nothing outside the dialog reads either of these: the table renders a
+   * workflow's stored step names, and `runWorkflow` is only reachable from the
+   * test-run button inside the dialog. Mounting them unconditionally charges
+   * every visitor to this page two windows to fill a select and seed a
+   * scratchpad most of them never open.
+   *
+   * Ceilinged and ordered for the reason the workflows query above gives: a
+   * bare `limit` is answered in document-id order, so the `localeCompare` on
+   * the options below would arrange a pseudo-random hundred into a convincing
+   * alphabet, and a function past the window could not be picked with nothing
+   * saying why.
+   */ const { data: functionRead } = useFirestoreCollection(()=>editorOpened ? collectionCeiling(collection(firestore, 'hosts', hostId, 'functions'), EDITOR_OPTION_CEILING) : null, [
+        firestore,
+        hostId,
+        editorOpened
+    ], {
+        idField: '$id'
+    });
+    // Memoised so the window keeps one identity while the rows do — the option
+    // list and the two lookup maps below are all built from it.
+    const { rows: functionDocs, truncated: functionsTruncated } = useMemo(()=>ceilingedWindow(functionRead, EDITOR_OPTION_CEILING), [
+        functionRead
+    ]);
+    const { data: variableRead } = useFirestoreCollection(()=>editorOpened ? collectionCeiling(collection(firestore, 'hosts', hostId, 'variables'), EDITOR_OPTION_CEILING) : null, [
+        firestore,
+        hostId,
+        editorOpened
+    ], {
+        idField: '$id'
+    });
+    const { rows: variableDocs, truncated: variablesTruncated } = useMemo(()=>ceilingedWindow(variableRead, EDITOR_OPTION_CEILING), [
+        variableRead
+    ]);
+    /*
+   * What an ACTIONS step can be pointed at, on the same latch (AGL-3105).
+   *
+   * The hook the Actions builder uses, because a workflow step may be any
+   * server-side Actions step and the two editors therefore offer one set of
+   * records. Read on the editor's first open, like the two windows above, so
+   * a reader who never edits a workflow still pays nothing for them.
+   */ const { pickers: stepPickers, truncated: truncatedPickers } = useAutomationStepPickers(hostId, editorOpened);
+    // 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 workflows = useMemo(()=>readWorkflows.filter((workflow)=>!workflow.deletedAt).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 : ''));
+        }), [
+        readWorkflows
+    ]);
+    // The page is a SLICE: the rows are already in hand and `nameTaken` needs
+    // all of them.
+    const [page, setPage] = useState(0);
+    const [pageSize, setPageSize] = useState(TABLE_PAGE_SIZE_DEFAULT);
+    const visibleWorkflows = useMemo(()=>workflows.slice(page * pageSize, page * pageSize + pageSize), [
+        workflows,
+        page,
+        pageSize
+    ]);
+    /**
+   * The workflow HEAD-COUNT is a server aggregate, not the length of the
+   * capped listener (AGL-1716, the AGL-1706 shape).
+   *
+   * The listener is `limit(100)` and `workflows.length` fed
+   * `checkQuota(org, 'workflowsPerHost', …)`, whose bands are 0 / 3 / 25 /
+   * 100 / 250 / 500. The window TIES Business's 100 and hides Scale's 250
+   * and Advanced's 500, so on those plans the gate compared 100 against
+   * hundreds and could never refuse — while `api/hosts/resources` counted
+   * the collection and did. The card offered headroom that did not exist and
+   * then failed the create.
+   *
+   * UNFILTERED, matching that route's plain `collection('workflows').count()`
+   * — its `softDeletes` branch governs only the flat per-host webhook cap, so
+   * soft-deleted workflows have always counted server-side while this card
+   * excluded them. Only a create moves the number, so that is where it is
+   * re-read.
+   */ const [workflowCountEpoch, setWorkflowCountEpoch] = useState(0);
+    const [serverWorkflowCount, setServerWorkflowCount] = useState(null);
+    useEffect(()=>{
+        let active = true;
+        void getCountFromServer(collection(firestore, 'hosts', hostId, 'workflows')).then((snapshot)=>{
+            if (active) setServerWorkflowCount(snapshot.data().count);
+        }).catch(()=>{
+        // Falls back to the loaded rows — a LOWER bound and the prior
+        // behaviour, never 0, which `checkQuota` would answer as "no usage"
+        // on a site that is over its band.
+        });
+        return ()=>{
+            active = false;
+        };
+    }, [
+        firestore,
+        hostId,
+        workflowCountEpoch
+    ]);
+    const workflowCount = serverWorkflowCount != null ? serverWorkflowCount : workflows.length;
+    // Double-keyed by doc id and name (AGL-261): id references are
+    // rename-safe; legacy name references keep resolving.
+    const functions = useMemo(()=>{
+        const map = {};
+        for (const definition of functionDocs != null ? functionDocs : []){
+            if (definition.deletedAt) continue;
+            if (definition.$id) map[definition.$id] = definition;
+            if (definition.name) map[definition.name] = definition;
+        }
+        return map;
+    }, [
+        functionDocs
+    ]);
+    const functionOptions = useMemo(()=>(functionDocs != null ? functionDocs : []).filter((definition)=>!definition.deletedAt && definition.name).map((definition)=>({
+                id: definition.$id,
+                name: definition.name
+            })).sort((a, b)=>a.name.localeCompare(b.name)), [
+        functionDocs
+    ]);
+    const variables = useMemo(()=>{
+        const map = {};
+        for (const variable of variableDocs != null ? variableDocs : []){
+            if (!variable.deletedAt && variable.name) map[variable.name] = variable;
+        }
+        return map;
+    }, [
+        variableDocs
+    ]);
+    // Where-used dialog (AGL-193).
+    const [usage, setUsage] = useState(null);
+    const [usageLoading, setUsageLoading] = useState(null);
+    const [testResult, setTestResult] = useState(null);
+    const [runsFor, setRunsFor] = useState(null);
+    // Case-insensitive uniqueness (AGL-185): workflow names must stay
+    // unambiguous for computed-variable lookups keyed by name.
+    const nameTaken = Boolean(draft && workflows.some((definition)=>{
+        var _definition_name;
+        return String((_definition_name = definition.name) != null ? _definition_name : '').toLowerCase() === draft.name.trim().toLowerCase() && definition.$id !== draft.id;
+    }));
+    const patch = useCallback((updater)=>setDraft((previous)=>previous ? updater(previous) : previous), []);
+    /** The saved workflow 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: 'workflow',
+            id: draftId,
+            name: draftName
+        } : null, // The name the editor opened with: the zone reads the workflow 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
+    ]);
+    const handleAdd = useCallback(()=>{
+        // Feature + cap gate (AGL-99); dark-launch for plan-less workspaces.
+        if (!checkEntitlement(org, 'workflows')) {
+            return void enqueueSnackbar('Workflows require a Starter plan — see Billing to upgrade', {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        // The site's workflows, not this page of them (AGL-1716).
+        const quota = checkQuota(org, 'workflowsPerHost', workflowCount);
+        if (!quota.allowed) {
+            return void enqueueSnackbar(`Workflow limit reached (${quota.limit}) — upgrade in Billing`, {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        setTestResult(null);
+        setDraft({
+            id: null,
+            name: '',
+            steps: [
+                {
+                    functionName: '',
+                    args: [],
+                    resultName: ''
+                }
+            ],
+            returnValue: '',
+            trigger: null
+        });
+    }, [
+        org,
+        workflowCount,
+        enqueueSnackbar
+    ]);
+    /**
+   * Every list the ceiling cut, named — the editor's two and the step
+   * pickers' six, in one notice for the reason the Actions builder gives:
+   * they are one read, and an author told the function list is short learns
+   * nothing from being told again about datasets.
+   */ const shortLists = useMemo(()=>[
+            functionsTruncated ? 'functions' : null,
+            variablesTruncated ? 'variables' : null,
+            ...truncatedPickers
+        ].filter((name)=>name !== null), [
+        functionsTruncated,
+        variablesTruncated,
+        truncatedPickers
+    ]);
+    /**
+   * The first thing wrong with the steps, said the way the editors say it.
+   *
+   * The same check the engine makes of what it is handed: an Actions step is
+   * held to the Actions validator, a call has to name a function, and a step
+   * only a visitor's browser can run is refused. Said while the author is
+   * still in the dialog rather than after a save that stores a step nothing
+   * can run.
+   */ const stepProblem = useMemo(()=>draft ? validateWorkflowSteps(draft.steps) : null, [
+        draft
+    ]);
+    const handleTestRun = useCallback(()=>{
+        if (!draft) return;
+        /*
+     * The FUNCTION CALLS, evaluated. A test run is the pure evaluator, and
+     * an Actions step is not something to evaluate — it sends, writes and
+     * charges. Running one here would perform it against the live site from
+     * a button labelled "Test run", so the calls are evaluated, each keeping
+     * the result name it holds among all the steps, and the rest is left to
+     * the run itself.
+     */ const run = runWorkflow(workflowFunctionCalls(draft), functions, variables);
+        setTestResult(run.ok === false ? `Error: ${run.error}` : `Result: ${String(run.value)} (${Object.entries(run.results).map(([key, value])=>`${key}=${value}`).join(', ')})`);
+    }, [
+        draft,
+        functions,
+        variables
+    ]);
+    const handleSave = useCallback(async ()=>{
+        if (!draft || !draft.name.trim() || nameTaken) return;
+        // The steps are checked at the door, not after the write: a stored step
+        // nothing can run is a run that fails on the site rather than here.
+        if (stepProblem) {
+            return void enqueueSnackbar(stepProblem, {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        const { id: draftId } = draft, definition = _object_without_properties_loose(draft, [
+            "id"
+        ]);
+        const fields = _extends({}, definition, {
+            name: draft.name.trim().slice(0, 60)
+        });
+        try {
+            if (draftId) {
+                /**
+         * Edit stays client-direct (no quota consumed) — and is refused when
+         * its seed was never confirmed by the server (AGL-1358). `fields` is
+         * the whole definition spread out of the listener row, `trigger` and
+         * `steps` included, so `merge: true` has nothing left to protect.
+         *
+         * The guard WRAPS the write. An early return is a shape you can keep
+         * while losing the protection; here the write is only reachable
+         * through the verdict.
+         */ const verdict = await writeGuardedBySeed({
+                    subject: 'workflow',
+                    unreadable: workflowsStatus === 'error',
+                    fromCache: workflowsFromCache
+                }, async ()=>{
+                    await setDoc(doc(firestore, 'hosts', hostId, 'workflows', draftId), _extends({}, fields, {
+                        updatedAt: Timestamp.now()
+                    }), {
+                        merge: true
+                    });
+                });
+                // Before `setDraft(null)`, so a refusal keeps the dialog open with
+                // every step that was built and its test run still on screen.
+                if (!verdict.ok) {
+                    return void enqueueSnackbar(verdict.message, {
+                        variant: 'warning',
+                        persist: false
+                    });
+                }
+            } else {
+                // New workflow rides the quota-enforcing resources API (AGL-473) —
+                // it also re-checks the `workflows` entitlement server-side.
+                await createHostResource({
+                    hostId,
+                    resource: 'workflow',
+                    data: fields
+                });
+                // A create moves the count; the one-shot aggregate below does not
+                // refresh itself the way the listener refreshes the rows.
+                setWorkflowCountEpoch((epoch)=>epoch + 1);
+            }
+            setDraft(null);
+            enqueueSnackbar('Workflow saved', {
+                variant: 'success',
+                persist: false
+            });
+        } catch (error) {
+            var _ref;
+            console.error(error);
+            enqueueSnackbar((_ref = error == null ? void 0 : error.message) != null ? _ref : 'An error has occurred', {
+                variant: 'error',
+                allowDuplicate: true
+            });
+        }
+    }, [
+        draft,
+        nameTaken,
+        stepProblem,
+        firestore,
+        hostId,
+        createHostResource,
+        enqueueSnackbar,
+        workflowsStatus,
+        workflowsFromCache
+    ]);
+    const handleShowUsage = useCallback((workflow)=>async ()=>{
+            setUsageLoading(workflow.$id);
+            const result = await fetchWhereUsed(user, {
+                hostId,
+                kind: 'workflow',
+                id: workflow.$id,
+                name: workflow.name
+            });
+            setUsageLoading(null);
+            // The rows and their deep links are drawn in a zone; with nothing
+            // registered there the answer is still given, in words.
+            if (listConsoleWidgets(WORKFLOW_USAGE_ZONE.id).length === 0) {
+                enqueueSnackbar(result.total ? `"${workflow.name}" computes ${summarizeDependents(result)}` : `"${workflow.name}" is not referenced by anything published`, {
+                    variant: 'info',
+                    persist: false
+                });
+                return;
+            }
+            setUsage({
+                name: workflow.name,
+                result
+            });
+        }, [
+        user,
+        hostId,
+        enqueueSnackbar
+    ]);
+    const handleDelete = useCallback((workflow)=>async ()=>{
+            // Dependents warning (AGL-187): computed variables backed by this
+            // workflow keep their stored fallback value once it is gone.
+            const scan = await fetchWhereUsed(user, {
+                hostId,
+                kind: 'workflow',
+                id: workflow.$id,
+                name: workflow.name
+            });
+            const confirmed = await confirm({
+                title: 'Delete this workflow?',
+                description: scan.total ? `"${workflow.name}" computes ${summarizeDependents(scan)} — ` + 'those variables will fall back to their stored values.' : `"${workflow.name}" will no longer be runnable.`,
+                confirmationText: 'Delete',
+                confirmationButtonProps: {
+                    color: 'error'
+                }
+            }).then(()=>true).catch(()=>false);
+            if (!confirmed) return;
+            await updateDoc(doc(firestore, 'hosts', hostId, 'workflows', workflow.$id), {
+                deletedAt: Timestamp.now()
+            });
+            enqueueSnackbar('Workflow deleted', {
+                variant: 'success',
+                persist: false
+            });
+        }, [
+        user,
+        confirm,
+        firestore,
+        hostId,
+        enqueueSnackbar
+    ]);
+    return /*#__PURE__*/ _jsxs(CardDisplay, {
+        header: 'Workflows',
+        help: pluginDocsHelp('buildAWorkflow', {
+            anchor: '#1-open-the-workflows-page'
+        }),
+        contentGutterX: true,
+        contentGutterY: true,
+        children: [
+            duplicate.dialog,
+            /*#__PURE__*/ _jsxs(Stack, {
+                spacing: 1,
+                children: [
+                    workflows.length === 0 ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: 'Chain your functions into multi-step pipelines — each step ' + 'feeds the next. Site-event triggers are coming next.'
+                    }) : visibleWorkflows.map((workflow)=>{
+                        var _workflow_steps, _workflow_steps1, _workflow_steps2;
+                        var _workflow_trigger;
+                        return /*#__PURE__*/ _jsxs(Stack, {
+                            direction: "row",
+                            spacing: 1,
+                            sx: {
+                                alignItems: 'center'
+                            },
+                            children: [
+                                /*#__PURE__*/ _jsxs(Stack, {
+                                    sx: {
+                                        flex: 1,
+                                        minWidth: 0
+                                    },
+                                    children: [
+                                        /*#__PURE__*/ _jsx(Typography, {
+                                            variant: "body2",
+                                            noWrap: true,
+                                            children: workflow.name
+                                        }),
+                                        /*#__PURE__*/ _jsx(Typography, {
+                                            variant: "caption",
+                                            color: "text.secondary",
+                                            noWrap: true,
+                                            children: `${((_workflow_steps = workflow.steps) != null ? _workflow_steps : []).length} step${((_workflow_steps1 = workflow.steps) != null ? _workflow_steps1 : []).length === 1 ? '' : 's'}${((_workflow_trigger = workflow.trigger) == null ? void 0 : _workflow_trigger.event) ? ` · on ${hostEventLabel(workflow.trigger.event)}` : ''} · ${((_workflow_steps2 = workflow.steps) != null ? _workflow_steps2 : []).map((step)=>step.functionName).join(' → ')}`
+                                        })
+                                    ]
+                                }),
+                                /*#__PURE__*/ _jsx(Button, {
+                                    size: "small",
+                                    disabled: usageLoading === workflow.$id,
+                                    onClick: handleShowUsage(workflow),
+                                    children: usageLoading === workflow.$id ? 'Scanning…' : 'Usage'
+                                }),
+                                /*#__PURE__*/ _jsx(Button, {
+                                    size: "small",
+                                    onClick: ()=>setRunsFor(workflow),
+                                    children: 'Runs'
+                                }),
+                                /*#__PURE__*/ _jsx(Button, {
+                                    size: "small",
+                                    onClick: ()=>{
+                                        var _workflow_name, _workflow_steps, _workflow_returnValue, _workflow_trigger;
+                                        setTestResult(null);
+                                        setDraft({
+                                            id: workflow.$id,
+                                            name: (_workflow_name = workflow.name) != null ? _workflow_name : '',
+                                            steps: (_workflow_steps = workflow.steps) != null ? _workflow_steps : [],
+                                            returnValue: (_workflow_returnValue = workflow.returnValue) != null ? _workflow_returnValue : '',
+                                            trigger: (_workflow_trigger = workflow.trigger) != null ? _workflow_trigger : null
+                                        });
+                                    },
+                                    children: 'Edit'
+                                }),
+                                /*#__PURE__*/ _jsx(Button, {
+                                    size: "small",
+                                    onClick: ()=>{
+                                        var _workflow_name;
+                                        return duplicate.request('workflow', {
+                                            id: workflow.$id,
+                                            name: (_workflow_name = workflow.name) != null ? _workflow_name : ''
+                                        });
+                                    },
+                                    children: 'Duplicate…'
+                                }),
+                                /*#__PURE__*/ _jsx(Button, {
+                                    size: "small",
+                                    color: "error",
+                                    onClick: handleDelete(workflow),
+                                    children: 'Delete'
+                                })
+                            ]
+                        }, workflow.$id);
+                    }),
+                    workflows.length === 0 ? null : /*#__PURE__*/ _jsx(ListPagination, {
+                        page: page,
+                        pageSize: pageSize,
+                        rowCount: visibleWorkflows.length,
+                        // The workflows the card HOLDS. Not `workflowCount`, which is the
+                        // site's total including soft-deleted rows and answers the quota's
+                        // question rather than the reader's.
+                        count: workflows.length,
+                        onPageChange: setPage,
+                        onPageSizeChange: setPageSize
+                    }),
+                    workflowsTruncated ? /*#__PURE__*/ _jsx(Alert, {
+                        severity: "info",
+                        children: `Showing ${WORKFLOW_CEILING} workflows, ordered by id. This site ` + 'has more — the duplicate-name check below only covers the ' + 'ones listed here, so a name may already be taken by one that ' + 'is not.'
+                    }) : null,
+                    /*#__PURE__*/ _jsx(Button, {
+                        size: "small",
+                        color: "primary",
+                        sx: {
+                            alignSelf: 'flex-start'
+                        },
+                        onClick: handleAdd,
+                        children: 'Add workflow'
+                    }),
+                    /*#__PURE__*/ _jsx(QuotaReadoutComponent, {
+                        ready: org != null,
+                        used: workflowCount,
+                        limit: checkQuota(org, 'workflowsPerHost', workflowCount).limit,
+                        noun: "workflow"
+                    })
+                ]
+            }),
+            /*#__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 Workflow' : 'Add Workflow'
+                    }),
+                    /*#__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,
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Name",
+                                helperText: nameTaken ? 'A workflow with this name already exists' : 'Used to identify the workflow',
+                                error: nameTaken,
+                                value: (_ref2 = draft == null ? void 0 : draft.name) != null ? _ref2 : '',
+                                onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                            name: event.target.value
+                                        })),
+                                size: "small",
+                                autoFocus: true,
+                                sx: {
+                                    mt: 1
+                                }
+                            }),
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "overline",
+                                color: "text.secondary",
+                                children: 'Steps'
+                            }),
+                            shortLists.length > 0 ? /*#__PURE__*/ _jsx(Alert, {
+                                severity: "info",
+                                children: `Offering the first ${EDITOR_OPTION_CEILING} ` + `${shortLists.join(', ')} on this site, ordered by id. ` + 'There are more, so the pickers below are short and a test ' + 'run may not resolve every expression.'
+                            }) : null,
+                            ((_ref3 = draft == null ? void 0 : draft.steps) != null ? _ref3 : []).map((step, index)=>{
+                                var _functions_, _call_functionId, _ref, _call_functionId1, _call_resultName, _ref1;
+                                var _functions_call_functionName;
+                                const call = isWorkflowActionStep(step) ? null : step;
+                                const definition = call ? (_functions_ = functions[(_call_functionId = call.functionId) != null ? _call_functionId : '']) != null ? _functions_ : functions[call.functionName] : null;
+                                return /*#__PURE__*/ _jsx(AutomationStepFields, {
+                                    /*
+                 * The editor speaks the Actions vocabulary. A function call
+                 * has no Actions type, so it takes none of those fields and
+                 * renders its own through `fields` instead — which is what
+                 * keeps this one editor rather than two.
+                 */ step: step,
+                                    index: index,
+                                    kind: call ? FUNCTION_CALL_KIND : step.type,
+                                    kinds: STEP_KINDS,
+                                    stepForKind: (value)=>value === FUNCTION_CALL_KIND ? {
+                                            functionName: '',
+                                            args: [],
+                                            resultName: ''
+                                        } : defaultStep(value),
+                                    pickers: stepPickers,
+                                    onSteps: (update)=>patch((previous)=>_extends({}, previous, {
+                                                steps: update(previous.steps)
+                                            })),
+                                    fields: call ? /*#__PURE__*/ _jsxs(Stack, {
+                                        direction: "row",
+                                        spacing: 1,
+                                        sx: {
+                                            alignItems: 'center',
+                                            flex: 1,
+                                            flexWrap: 'wrap'
+                                        },
+                                        children: [
+                                            /*#__PURE__*/ _jsx(TextField, {
+                                                label: "Function",
+                                                // Stored by id (AGL-261); legacy steps carry only the
+                                                // name and resolve through the double-keyed map.
+                                                value: (_ref = (_call_functionId1 = call.functionId) != null ? _call_functionId1 : (_functions_call_functionName = functions[call.functionName]) == null ? void 0 : _functions_call_functionName.$id) != null ? _ref : '',
+                                                onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                            steps: previous.steps.map((s, index2)=>{
+                                                                var _ref;
+                                                                var _functionOptions_find;
+                                                                return index2 === index ? _extends({}, s, {
+                                                                    functionId: event.target.value,
+                                                                    functionName: (_ref = (_functionOptions_find = functionOptions.find((option)=>option.id === event.target.value)) == null ? void 0 : _functionOptions_find.name) != null ? _ref : s.functionName
+                                                                }) : s;
+                                                            })
+                                                        })),
+                                                size: "small",
+                                                select: true,
+                                                sx: {
+                                                    minWidth: 160,
+                                                    flex: 1
+                                                },
+                                                children: functionOptions.map((option)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                                        value: option.id,
+                                                        children: option.name
+                                                    }, option.id))
+                                            }),
+                                            /*#__PURE__*/ _jsx(TextField, {
+                                                label: "Result name",
+                                                placeholder: `step${index + 1}`,
+                                                value: (_call_resultName = call.resultName) != null ? _call_resultName : '',
+                                                onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                            steps: previous.steps.map((s, index2)=>index2 === index ? _extends({}, s, {
+                                                                    resultName: event.target.value.replace(/[^a-zA-Z0-9_]/g, '')
+                                                                }) : s)
+                                                        })),
+                                                size: "small",
+                                                sx: {
+                                                    width: 140
+                                                }
+                                            }),
+                                            ((_ref1 = definition == null ? void 0 : definition.parameters) != null ? _ref1 : []).map((parameter, parameterIndex)=>{
+                                                var _ref;
+                                                var _call_args;
+                                                return /*#__PURE__*/ _jsx(TextField, {
+                                                    label: `${parameter.name} expression`,
+                                                    placeholder: parameterIndex === 0 && index > 0 ? `step${index}` : 'a variable, number, or expression',
+                                                    value: (_ref = (_call_args = call.args) == null ? void 0 : _call_args[parameterIndex]) != null ? _ref : '',
+                                                    onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                                steps: previous.steps.map((s, index2)=>{
+                                                                    var _s_args;
+                                                                    if (index2 !== index) return s;
+                                                                    const args = [
+                                                                        ...(_s_args = s.args) != null ? _s_args : []
+                                                                    ];
+                                                                    args[parameterIndex] = event.target.value;
+                                                                    return _extends({}, s, {
+                                                                        args
+                                                                    });
+                                                                })
+                                                            })),
+                                                    size: "small",
+                                                    sx: {
+                                                        minWidth: 180,
+                                                        flex: 1
+                                                    }
+                                                }, parameter.name);
+                                            })
+                                        ]
+                                    }) : undefined
+                                }, index);
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                sx: {
+                                    alignSelf: 'flex-start'
+                                },
+                                disabled: ((_ref4 = draft == null ? void 0 : draft.steps.length) != null ? _ref4 : 0) >= WORKFLOW_MAX_STEPS,
+                                onClick: ()=>patch((previous)=>_extends({}, previous, {
+                                            steps: [
+                                                ...previous.steps,
+                                                {
+                                                    functionName: '',
+                                                    args: [],
+                                                    resultName: ''
+                                                }
+                                            ]
+                                        })),
+                                children: 'Add step'
+                            }),
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "overline",
+                                color: "text.secondary",
+                                children: 'Trigger'
+                            }),
+                            /*#__PURE__*/ _jsxs(Stack, {
+                                direction: "row",
+                                spacing: 1,
+                                children: [
+                                    /*#__PURE__*/ _jsxs(TextField, {
+                                        label: "Run on event",
+                                        value: (_ref5 = draft == null ? void 0 : (_draft_trigger = draft.trigger) == null ? void 0 : _draft_trigger.event) != null ? _ref5 : '',
+                                        onChange: (event)=>patch((previous)=>{
+                                                var _ref;
+                                                var _previous_trigger;
+                                                return _extends({}, previous, {
+                                                    trigger: event.target.value ? {
+                                                        event: event.target.value,
+                                                        filter: (_ref = (_previous_trigger = previous.trigger) == null ? void 0 : _previous_trigger.filter) != null ? _ref : ''
+                                                    } : null
+                                                });
+                                            }),
+                                        size: "small",
+                                        select: true,
+                                        sx: {
+                                            minWidth: 180
+                                        },
+                                        children: [
+                                            /*#__PURE__*/ _jsx(MenuItem, {
+                                                value: "",
+                                                children: 'Manual only'
+                                            }),
+                                            HOST_EVENT_TYPES.map((eventType)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                                    value: eventType,
+                                                    children: hostEventLabel(eventType)
+                                                }, eventType))
+                                        ]
+                                    }),
+                                    (draft == null ? void 0 : draft.trigger) ? /*#__PURE__*/ _jsx(TextField, {
+                                        label: "Filter (optional)",
+                                        placeholder: 'path == "/pricing"',
+                                        helperText: [
+                                            'Runs only when this expression is truthy.',
+                                            hostEventPayloadHint(draft == null ? void 0 : (_draft_trigger1 = draft.trigger) == null ? void 0 : _draft_trigger1.event)
+                                        ].filter(Boolean).join(' '),
+                                        value: (_ref6 = draft == null ? void 0 : (_draft_trigger2 = draft.trigger) == null ? void 0 : _draft_trigger2.filter) != null ? _ref6 : '',
+                                        onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                                    trigger: previous.trigger ? _extends({}, previous.trigger, {
+                                                        filter: event.target.value
+                                                    }) : previous.trigger
+                                                })),
+                                        size: "small",
+                                        sx: {
+                                            flex: 1
+                                        }
+                                    }) : null
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Return value",
+                                helperText: "A step result name; defaults to the last step",
+                                value: (_ref7 = draft == null ? void 0 : draft.returnValue) != null ? _ref7 : '',
+                                onChange: (event)=>patch((previous)=>_extends({}, previous, {
+                                            returnValue: event.target.value
+                                        })),
+                                size: "small"
+                            }),
+                            /*#__PURE__*/ _jsxs(Stack, {
+                                direction: "row",
+                                spacing: 1,
+                                sx: {
+                                    alignItems: 'center'
+                                },
+                                children: [
+                                    /*#__PURE__*/ _jsx(Button, {
+                                        size: "small",
+                                        color: "primary",
+                                        onClick: handleTestRun,
+                                        children: 'Test run'
+                                    }),
+                                    /*#__PURE__*/ _jsx(Typography, {
+                                        variant: "caption",
+                                        color: "text.secondary",
+                                        children: 'Uses current variable values'
+                                    })
+                                ]
+                            }),
+                            testResult ? /*#__PURE__*/ _jsx(Alert, {
+                                severity: testResult.startsWith('Error') ? 'warning' : 'success',
+                                children: testResult
+                            }) : null
+                        ]
+                    }),
+                    /*#__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()) || nameTaken,
+                                onClick: handleSave,
+                                children: 'Done'
+                            })
+                        ]
+                    })
+                ]
+            }),
+            ExtensionZone ? /*#__PURE__*/ _jsx(ExtensionZone, {
+                slot: WORKFLOW_USAGE_ZONE.id,
+                hostId: hostId,
+                usage: usage,
+                onClose: ()=>setUsage(null)
+            }) : null,
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(runsFor),
+                onClose: ()=>setRunsFor(null),
+                maxWidth: "sm",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: `Runs — ${(_ref8 = runsFor == null ? void 0 : runsFor.name) != null ? _ref8 : ''}`
+                    }),
+                    /*#__PURE__*/ _jsx(DialogContent, {
+                        children: runsFor ? /*#__PURE__*/ _jsx(HostRunHistoryCard, {
+                            hostId: hostId,
+                            orgId: org == null ? void 0 : org.$id,
+                            targetId: runsFor.$id,
+                            targetType: "workflow",
+                            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'
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+HostWorkflowsCard.displayName = 'HostWorkflowsCard';
+export default HostWorkflowsCard;
+
+//# sourceMappingURL=host-workflows-card.component.js.map