@sanity/workflow-studio-plugin 0.5.0 → 0.21.0

package/dist/_chunks-es/index.js

@@ -1,37 +1,41 @@
-import { tryParseGdr, resourceFromParsed, latestDeployedDefinitions, gdrRef, isSubjectEntry, isInputSourced, missingRequiredInputs, initialFieldIssues, releaseRef, refKindAcceptsTypes, rejectedRefTypes, ActionDisabledError, MutationGuardDeniedError, errorMessage, findOpenStageEntry, actionRendering, terminalState, ENGINE_API_VERSION, WORKFLOW_INSTANCE_TYPE, WORKFLOW_DEFINITION_TYPE, GUARD_DOC_TYPE, isTodoListEntry, isTodoListItem, isTerminalActivityStatus, describeCondition, sentenceCase, checklistLines, findCurrentActivityEntry, scalarValidationIssues, extractDocumentId, isSingleDocRefEntry, isGdr, resolveFieldEntry, isSingleDocRefKind, isNotesEntry, parseDefinitionSnapshot, StartNotSettledError, StartNotAllowedError, isUnprimed, unboundAllowedReads, explainStartAllowed, evaluateStartFilter, startKindOf, readsRootDocument, instancesQuery, assertReadableModel, isTerminalStage, DEFAULT_TRANSITION_WHEN, isStartableDefinition, acceptsDocumentType, definitionsListGroq, gdrFromResource, instanceWatchesDocument, aclPathForResource, definitionLookupGroq, instanceDocId, documentActionDenials } from "@sanity/workflow-engine";
-
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 
 import { TimelineIcon } from "@sanity/icons/Timeline";
 
 import { Tooltip, Box, Stack, Text, useClickOutsideEvent, Popover, Flex, TextInput, Button, Select, Checkbox, Autocomplete, Card, TextArea, useToast, Dialog, Switch, TextSkeleton, Code, Spinner, useTheme_v2, Badge, MenuButton, Menu, MenuItem, useElementSize, TabList, Tab, TabPanel, MenuDivider } from "@sanity/ui";
 
-import { createContext, useContext, useEffect, useSyncExternalStore, useCallback, useMemo, useRef, useState, Fragment as Fragment$1, createElement, isValidElement, useId, useLayoutEffect, Component, lazy, Suspense } from "react";
+import { editFieldTarget, useWorkflowTelemetry, useRefcountedIds } from "@sanity/workflow-react";
+
+import { createContext, useContext, useEffect, useSyncExternalStore, useCallback, useRef, useMemo, useState, Fragment as Fragment$1, createElement, isValidElement, useId, useLayoutEffect, Component, lazy, Suspense } from "react";
 
 import { usePaneRouter } from "sanity/structure";
 
+import { tryParseGdr, resourceFromParsed, latestDeployedDefinitions, isStartableDefinition, isSubjectEntry, isInputSourced, acceptsDocumentType, missingRequiredInputs, initialFieldIssues, gdrRef, releaseRef, refKindAcceptsTypes, rejectedRefTypes, ActionDisabledError, MutationGuardDeniedError, errorMessage, findOpenStageEntry, actionRendering, terminalState, isTodoListEntry, isTodoListItem, isTerminalActivityStatus, describeCondition, sentenceCase, checklistLines, findCurrentActivityEntry, ENGINE_API_VERSION, WORKFLOW_INSTANCE_TYPE, WORKFLOW_DEFINITION_TYPE, GUARD_DOC_TYPE, scalarValidationIssues, classifyPrincipalId, toBareId, isSingleDocRefEntry, isGdr, resolveFieldEntry, isSingleDocRefKind, isNotesEntry, parseDefinitionSnapshot, instancesQuery, assertReadableModel, projectStartSliceRow, isUnprimed, StartNotSettledError, StartNotAllowedError, humanize, unboundRequirementReads, explainStartRequirement, singleSubjectRequirementRefused, evaluateStartFilter, startKindOf, hasSingleSubjectRequirement, readsRootDocument, isTerminalStage, DEFAULT_TRANSITION_WHEN, latestDefinitionsGroq, gdrFromResource, subscriptionDocumentsForInstance, aclPathForResource, definitionLookupGroq, instanceDocId, documentActionDenials } from "@sanity/workflow-engine";
+
+import { CheckmarkIcon } from "@sanity/icons/Checkmark";
+
+import { CloseIcon } from "@sanity/icons/Close";
+
 import { formatDistanceToNow } from "date-fns/formatDistanceToNow";
 
-import { getPublishedId } from "@sanity/client/csm";
+import { sameAssignee, projectMemberRow, ClearableDatePicker, MemberPicker as MemberPicker$1, AssigneePicker as AssigneePicker$1, MemberAvatar, AssigneeBadges as AssigneeBadges$1, AssigneeBadge as AssigneeBadge$1, ProgressBar, MemberAvatarGroup, clampProgress, progressCaption, DatePicker, roleListLabel } from "@sanity/workflow-components";
+
+import { getPublishedId, getDraftId } from "@sanity/client/csm";
+
+import { defineEvent } from "@sanity/telemetry";
 
 import { useStudioProjectUsers, useStudioObserver, useWorkflowEngine, useWorkflowInstances, useWorkflowSession } from "@sanity/workflow-studio";
 
-import { useCurrentUser, SanityDefaultPreview, Preview, useValuePreview, useClient, useSchema, useWorkspace, TextWithTone, usePerspective, useIsReleaseActive, useActiveReleases, useTemplates, useInitialValueResolverContext, resolveInitialValue, definePlugin, isObjectInputProps } from "sanity";
+import { useCurrentUser, SanityDefaultPreview, Preview, useValuePreview, useClient, useSchema, useWorkspace, TextWithTone, usePerspective, useIsReleaseActive, useDocumentPreviewStore, useActiveReleases, useTemplates, useInitialValueResolverContext, resolveInitialValue, definePlugin, isObjectInputProps } from "sanity";
 
 import { CalendarIcon } from "@sanity/icons/Calendar";
 
-import { ClearableDatePicker, MemberPicker as MemberPicker$1, AssigneePicker as AssigneePicker$1, MemberAvatar, AssigneeBadges as AssigneeBadges$1, AssigneeBadge as AssigneeBadge$1, ProgressBar, MemberAvatarGroup, clampProgress, progressCaption, DatePicker, roleListLabel } from "@sanity/workflow-components";
-
 import { UserIcon } from "@sanity/icons/User";
 
-import { CloseIcon } from "@sanity/icons/Close";
-
 import { SearchIcon } from "@sanity/icons/Search";
 
 import { ChevronRightIcon } from "@sanity/icons/ChevronRight";
 
-import { CheckmarkIcon } from "@sanity/icons/Checkmark";
-
 import { EditIcon } from "@sanity/icons/Edit";
 
 import { randomKey } from "@sanity/util/content";
@@ -70,7 +74,9 @@ import { EllipsisHorizontalIcon } from "@sanity/icons/EllipsisHorizontal";
 
 import { ArrowUpIcon } from "@sanity/icons/ArrowUp";
 
-import { useRefcountedIds } from "@sanity/workflow-react";
+import { of } from "rxjs";
+
+import { switchMap, distinctUntilChanged } from "rxjs/operators";
 
 import { TransferIcon } from "@sanity/icons/Transfer";
 
@@ -87,20 +93,58 @@ function gdrLocality(id, contentResource) {
     };
 }
 
-function mappingsForDocType(mappings, docType) {
-    return mappings.filter(m => m.docType === docType);
+function assertUniqueWorkflowMappings(mappings) {
+    const keys = /* @__PURE__ */ new Set;
+    for (const mapping of mappings) {
+        const key = mappingKey(mapping);
+        if (keys.has(key)) throw new Error(`Duplicate workflow mapping for ${key}`);
+        keys.add(key);
+    }
+}
+
+function discoverWorkflowMappings(args) {
+    assertUniqueWorkflowMappings(args.overrides ?? []);
+    const discovered = latestDeployedDefinitions(args.definitions).flatMap(definition => {
+        if (!isStartableDefinition(definition)) return [];
+        const subject = (definition.fields ?? []).find(isSubjectEntry);
+        if (subject === void 0 || !isInputSourced(subject)) return [];
+        const source = {
+            fields: [ ...definition.fields ?? [] ]
+        };
+        return [ ...args.schemaContentTypes ].filter(docType => acceptsDocumentType(source, docType)).map(docType => ({
+            docType: docType,
+            definition: definition.name,
+            label: definition.title ?? definition.name
+        }));
+    }), byKey = new Map(discovered.map(mapping => [ mappingKey(mapping), mapping ]));
+    for (const override of args.overrides ?? []) {
+        const key = mappingKey(override);
+        byKey.set(key, override);
+    }
+    return [ ...byKey.values() ];
 }
 
-function mappingForDocType(mappings, docType) {
-    return mappingsForDocType(mappings, docType)[0];
+function mappingAutoStartMap(mappings) {
+    const byType = /* @__PURE__ */ Object.create(null);
+    for (const mapping of mappings) {
+        if (!mapping.autoStart) continue;
+        const definitions = byType[mapping.docType] ?? [];
+        byType[mapping.docType] = [ ...definitions, mapping.definition ];
+    }
+    return byType;
+}
+
+function mappingsForDocType(mappings, docType) {
+    return mappings.filter(m => m.docType === docType);
 }
 
 function mappingKey(mapping) {
     return `${mapping.docType}::${mapping.definition}`;
 }
 
-function workflowDocTypes(mappings) {
-    return new Set(mappings.map(m => m.docType));
+function documentSubjectEntry(definition) {
+    const fields = definition.fields ?? [];
+    return fields.find(isSubjectEntry) ?? fields.find(entry => entry.type === "doc.ref" && entry.name === "subject");
 }
 
 function mappingStartBlocks(args) {
@@ -421,7 +465,7 @@ function stateByActivity(instance) {
 }
 
 function evaluationFreshness(args) {
-    return args.evaluation ? args.committed.lastChangedAt > args.evaluation.instance.lastChangedAt ? "stale" : "current" : "pending";
+    return args.evaluation ? Date.parse(args.committed.lastChangedAt) > Date.parse(args.evaluation.instance.lastChangedAt) ? "stale" : "current" : "pending";
 }
 
 function isEvaluationCurrent(args) {
@@ -447,50 +491,6 @@ function isLiveEntry(entry) {
     return terminalState(entry.instance) === "in-flight";
 }
 
-const WORKFLOW_API_VERSION = ENGINE_API_VERSION, WORKFLOW_SYSTEM_TYPES = [ WORKFLOW_INSTANCE_TYPE, WORKFLOW_DEFINITION_TYPE, GUARD_DOC_TYPE ];
-
-function editTargetOf(field) {
-    return {
-        scope: field.scope,
-        field: field.name,
-        ...field.activity ? {
-            activity: field.activity
-        } : {}
-    };
-}
-
-const EMPTY_ENTRIES = [], WorkflowContext = createContext(null);
-
-function useWorkflowContext() {
-    const value = useContext(WorkflowContext);
-    if (!value) throw new Error("useWorkflowContext must render inside the workflow plugin provider");
-    return value;
-}
-
-function useWorkflowsForDocument(rawId) {
-    const {register: register, unregister: unregister, entries: entries} = useWorkflowContext(), docId = rawId ? getPublishedId(rawId) : void 0;
-    useEffect(() => {
-        if (docId) return register(docId), () => unregister(docId);
-    }, [ docId, register, unregister ]);
-    const list = useSyncExternalStore(entries.subscribe, useCallback(() => docId ? entries.getDocument(docId) : EMPTY_ENTRIES, [ entries, docId ]));
-    return {
-        docId: docId,
-        entries: list
-    };
-}
-
-function useHeldWorkflowEntry(instanceId) {
-    const {entries: entries} = useWorkflowContext();
-    return useSyncExternalStore(entries.subscribe, useCallback(() => instanceId ? entries.getInstance(instanceId) : void 0, [ entries, instanceId ]));
-}
-
-function useWorkflowInstanceEntry(instanceId) {
-    const {requestInstance: requestInstance, releaseInstance: releaseInstance} = useWorkflowContext();
-    return useEffect(() => {
-        if (instanceId) return requestInstance(instanceId), () => releaseInstance(instanceId);
-    }, [ instanceId, requestInstance, releaseInstance ]), useHeldWorkflowEntry(instanceId);
-}
-
 const isTodoDone = item => item.status === "done", toggledTodoStatus = item => isTodoDone(item) ? "open" : "done";
 
 function isTodoOverdue(item, today = /* @__PURE__ */ new Date) {
@@ -566,7 +566,7 @@ function buildTickIndex(evaluation) {
 function todoFieldEditability(args) {
     const {evaluation: evaluation, source: source, fieldName: fieldName} = args, match = evaluation?.editableFields.find(f => f.name === fieldName && f.scope === source.scope && (source.scope !== "activity" || f.activity === source.activityName));
     return match ? match.editable ? {
-        editTarget: editTargetOf(match)
+        editTarget: editFieldTarget(match)
     } : match.disabledReason === void 0 ? {} : {
         editDisabledReason: match.disabledReason
     } : {};
@@ -631,8 +631,8 @@ function assigneeMatches(member, who) {
     return member.type === "user" ? member.id === who.userId : who.roles.includes(member.role);
 }
 
-function sameAssignee(a, b) {
-    return a.type === "user" && b.type === "user" ? a.id === b.id : a.type === "role" && b.type === "role" ? a.role === b.role : !1;
+function changedAssignee(current, next) {
+    return next.find(item => !current.some(existing => sameAssignee(item, existing))) ?? current.find(item => !next.some(existing => sameAssignee(item, existing)));
 }
 
 function isAssigneeShape(value) {
@@ -761,13 +761,29 @@ function concludesHere(actionEval, activityName) {
     return changesOwnStatus(actionEval.action, activityName) || actionEval.firing?.exitsStage === !0;
 }
 
-function actionButtonTone(args) {
-    return concludesHere(args.actionEval, args.activityName) ? {
-        mode: "default",
-        tone: actionAdvanceStatus(args.actionEval.action, args.activityName) === "failed" ? "critical" : "default"
-    } : {
-        mode: "ghost",
-        tone: "default"
+const SEMANTIC_FACE = {
+    "decision.accept": {
+        tone: "positive",
+        icon: CheckmarkIcon
+    },
+    "decision.decline": {
+        tone: "caution",
+        icon: CloseIcon
+    }
+};
+
+function actionButtonFace(args) {
+    const mode = concludesHere(args.actionEval, args.activityName) ? "default" : "ghost";
+    if (actionAdvanceStatus(args.actionEval.action, args.activityName) === "failed") return {
+        mode: mode,
+        tone: "critical",
+        icon: void 0
+    };
+    const [semantic] = args.actionEval.semantics ?? [], face = semantic === void 0 ? void 0 : SEMANTIC_FACE[semantic];
+    return {
+        mode: mode,
+        tone: face?.tone ?? "default",
+        icon: face?.icon
     };
 }
 
@@ -991,6 +1007,112 @@ function deriveActivityDetail(args) {
     };
 }
 
+const WORKFLOW_API_VERSION = ENGINE_API_VERSION, WORKFLOW_SYSTEM_TYPES = [ WORKFLOW_INSTANCE_TYPE, WORKFLOW_DEFINITION_TYPE, GUARD_DOC_TYPE ], EMPTY_ENTRIES = [], WorkflowContext = createContext(null);
+
+function useWorkflowContext() {
+    const value = useContext(WorkflowContext);
+    if (!value) throw new Error("useWorkflowContext must render inside the workflow plugin provider");
+    return value;
+}
+
+function useWorkflowsForDocument(rawId) {
+    return useDocumentWorkflowEntries(rawId, !0);
+}
+
+function useCommittedWorkflowsForDocument(rawId) {
+    return useDocumentWorkflowEntries(rawId, !1);
+}
+
+function useDocumentWorkflowEntries(rawId, evaluate) {
+    const {register: register, unregister: unregister, requestEvaluation: requestEvaluation, releaseEvaluation: releaseEvaluation, entries: entries} = useWorkflowContext(), docId = rawId ? getPublishedId(rawId) : void 0;
+    useEffect(() => {
+        if (docId) return register(docId), () => unregister(docId);
+    }, [ docId, register, unregister ]);
+    const list = useSyncExternalStore(entries.subscribe, useCallback(() => docId ? entries.getDocument(docId) : EMPTY_ENTRIES, [ entries, docId ])), evaluationKey = evaluate ? list.map(entry => entry.instance._id).join("\0") : "";
+    return useEffect(() => {
+        if (!evaluate) return;
+        const ids = evaluationKey === "" ? [] : evaluationKey.split("\0");
+        for (const id of ids) requestEvaluation(id);
+        return () => {
+            for (const id of ids) releaseEvaluation(id);
+        };
+    }, [ evaluate, evaluationKey, requestEvaluation, releaseEvaluation ]), {
+        docId: docId,
+        entries: list
+    };
+}
+
+function useHeldWorkflowEntry(instanceId) {
+    const {entries: entries} = useWorkflowContext();
+    return useSyncExternalStore(entries.subscribe, useCallback(() => instanceId ? entries.getInstance(instanceId) : void 0, [ entries, instanceId ]));
+}
+
+function useWorkflowInstanceEntry(instanceId, options = {}) {
+    const {requestInstance: requestInstance, releaseInstance: releaseInstance, requestEvaluation: requestEvaluation, releaseEvaluation: releaseEvaluation} = useWorkflowContext(), evaluate = options.evaluate ?? !0;
+    return useEffect(() => {
+        if (instanceId) return requestInstance(instanceId), () => releaseInstance(instanceId);
+    }, [ instanceId, requestInstance, releaseInstance ]), useEffect(() => {
+        if (!(!instanceId || !evaluate)) return requestEvaluation(instanceId), () => releaseEvaluation(instanceId);
+    }, [ instanceId, evaluate, requestEvaluation, releaseEvaluation ]), useHeldWorkflowEntry(instanceId);
+}
+
+const WorkflowToolOpened = defineEvent({
+    name: "Editorial Workflows Studio Plugin Tool Opened",
+    version: 1,
+    description: "The Workflows tool was opened or its tab was switched"
+}), WorkflowDocumentViewOpened = defineEvent({
+    name: "Editorial Workflows Studio Plugin Document View Opened",
+    version: 1,
+    description: "The Workflows document view was opened or its tab was switched"
+}), WorkflowInstanceDetailViewed = defineEvent({
+    name: "Editorial Workflows Studio Plugin Instance Detail Viewed",
+    version: 1,
+    description: "The Workflows tool's per-instance detail view was opened"
+}), WorkflowFormStripClicked = defineEvent({
+    name: "Editorial Workflows Studio Plugin Form Strip Clicked",
+    version: 1,
+    description: "The form strip's instance line was clicked, opening the document view"
+}), WorkflowStartDialogOpened = defineEvent({
+    name: "Editorial Workflows Studio Plugin Start Dialog Opened",
+    version: 1,
+    description: "The start-workflow dialog was opened"
+}), WorkflowStartDialogSubmitted = defineEvent({
+    name: "Editorial Workflows Studio Plugin Start Dialog Submitted",
+    version: 1,
+    description: "The start-workflow dialog's confirm was pressed"
+}), WorkflowAutoStartRan = defineEvent({
+    name: "Editorial Workflows Studio Plugin Auto Start Ran",
+    version: 1,
+    description: "A fresh document's auto-start ran — one start request per configured workflow"
+}), WorkflowActionControlUsed = defineEvent({
+    name: "Editorial Workflows Studio Plugin Action Control Used",
+    version: 1,
+    description: "An action-firing control was used, attributed to its UI surface"
+}), WorkflowActivityDialogOpened = defineEvent({
+    name: "Editorial Workflows Studio Plugin Activity Dialog Opened",
+    version: 1,
+    description: "The activity detail dialog was opened"
+}), WorkflowTaskFiltersApplied = defineEvent({
+    name: "Editorial Workflows Studio Plugin Task Filters Applied",
+    version: 1,
+    description: "The tool's task-filter menu closed with a changed selection"
+}), WorkflowTodoToggled = defineEvent({
+    name: "Editorial Workflows Studio Plugin Todo Toggled",
+    version: 1,
+    description: "A todo checkbox was toggled, attributed to its UI surface and write seam"
+});
+
+function useLogEventOnMount(event, data) {
+    const telemetry = useWorkflowTelemetry(), logged = useRef(!1);
+    useEffect(() => {
+        logged.current || (logged.current = !0, telemetry.log(event, data));
+    }, [ telemetry, event, data ]);
+}
+
+function LogEventOnMount(props) {
+    return useLogEventOnMount(props.event, props.data), null;
+}
+
 function isEmptyValue(value) {
     return value == null || value === "" || Array.isArray(value) && value.length === 0;
 }
@@ -1022,10 +1144,23 @@ function personActor(user) {
     };
 }
 
+const memberIndexes = /* @__PURE__ */ new WeakMap;
+
+function memberIndex(members) {
+    const cached = memberIndexes.get(members);
+    if (cached) return cached;
+    const created = new Map(members.map(member => [ member.id, member ]));
+    return memberIndexes.set(members, created), created;
+}
+
 const selfUserFor = (id, me) => me != null && me.id === id ? me : void 0;
 
+function globalIdOf(users, projectScopedId) {
+    return users.find(user => user.membership.id === projectScopedId)?.profile?.sanityUserId ?? projectScopedId;
+}
+
 function userDisplayFor(args) {
-    const member = args.members.find(m => m.id === args.id), self = selfUserFor(args.id, args.me);
+    const matchId = args.matchId ?? args.id, member = memberIndex(args.members).get(matchId), self = selfUserFor(matchId, args.me);
     return {
         id: args.id,
         name: member?.displayName ?? self?.name ?? args.id,
@@ -1034,42 +1169,69 @@ function userDisplayFor(args) {
 }
 
 function useUserDisplays(ids) {
-    const {members: members} = useProjectMembers(), me = useCurrentUser();
-    return ids.map(id => userDisplayFor({
+    const {members: members} = useProjectMembers(), {users: users} = useStudioProjectUsers(), meRaw = useCurrentUser(), me = useMemo(() => meRaw === null ? null : {
+        ...meRaw,
+        id: globalIdOf(users, meRaw.id)
+    }, [ meRaw, users ]);
+    return useMemo(() => ids.map(id => userDisplayFor({
         id: id,
         members: members,
-        me: me
-    }));
+        me: me,
+        matchId: globalIdOf(users, id)
+    })), [ ids, me, members, users ]);
 }
 
 function useUserDisplay(id) {
-    const [display] = useUserDisplays([ id ]);
+    const ids = useMemo(() => [ id ], [ id ]), [display] = useUserDisplays(ids);
     return display ?? {
         name: id,
         imageUrl: void 0
     };
 }
 
+const warnedNotMember = /* @__PURE__ */ new Set;
+
+function useBridgedSelf() {
+    const me = useCurrentUser(), {users: users, loading: loading} = useStudioProjectUsers();
+    if (!me || loading) return;
+    const classified = classifyPrincipalId(me.id), id = users.find(user => user.membership.id === me.id)?.profile?.sanityUserId ?? classified.globalId ?? (classified.namespace === "project" ? void 0 : me.id);
+    if (id === void 0) {
+        warnedNotMember.has(me.id) || (warnedNotMember.add(me.id), console.warn(`workflow: the project member directory cannot resolve the logged-in user ("${me.id}") to an account-global identity — the engine stores account-global user ids only, so workflow assignment and authoring controls stay disabled. Typically this user is not a member of this project.`));
+        return;
+    }
+    return {
+        id: id,
+        roles: me.roles ?? []
+    };
+}
+
+function useSelfActor() {
+    const self = useBridgedSelf();
+    return self === void 0 ? void 0 : personActor(self);
+}
+
 function useAssignmentIdentity() {
-    const me = useCurrentUser();
-    if (me) return {
-        userId: me.id,
-        roles: (me.roles ?? []).map(r => r.name)
+    const self = useBridgedSelf();
+    if (self !== void 0) return {
+        userId: self.id,
+        roles: self.roles.map(r => r.name)
     };
 }
 
+const projectMembersByUsers = /* @__PURE__ */ new WeakMap;
+
 function projectMembersFrom(users) {
-    return users.map(({membership: membership, profile: profile}) => ({
-        id: membership.id,
-        displayName: profile?.displayName ?? membership.id,
-        ...profile?.email ? {
-            email: profile.email
-        } : {},
-        ...profile?.imageUrl ? {
-            imageUrl: profile.imageUrl
-        } : {},
-        roles: (membership.roles ?? []).map(role => role.name)
+    const cached = projectMembersByUsers.get(users);
+    if (cached) return cached;
+    const members = users.map(({membership: membership, profile: profile}) => projectMemberRow({
+        membershipId: membership.id,
+        roles: membership.roles,
+        sanityUserId: profile?.sanityUserId,
+        displayName: profile?.displayName,
+        email: profile?.email,
+        imageUrl: profile?.imageUrl ?? void 0
     }));
+    return projectMembersByUsers.set(users, members), members;
 }
 
 function useProjectMembers() {
@@ -1395,12 +1557,12 @@ function MemberPicker({selectedIds: selectedIds, onSelect: onSelect, unassignRow
     });
 }
 
-function AssigneePicker({value: value, onToggle: onToggle}) {
+function AssigneePicker({value: value, onChange: onChange}) {
     const state = useProjectMembers();
     /* @__PURE__ */
     return jsx(AssigneePicker$1, {
         ...state,
-        onToggle: onToggle,
+        onChange: onChange,
         value: value
     });
 }
@@ -1511,7 +1673,7 @@ function DocPicker({value: value, onChange: onChange, types: types, readOnly: re
         children: /* @__PURE__ */ jsx(Box, {
             flex: 1,
             children: /* @__PURE__ */ jsx(PreviewOrId, {
-                id: extractDocumentId(value.id),
+                id: toBareId(value.id),
                 type: value.type
             })
         })
@@ -1607,7 +1769,7 @@ function DocRefsInput({value: value, onChange: onChange, types: types}) {
             /* @__PURE__ */ jsx(Box, {
                 flex: 1,
                 children: /* @__PURE__ */ jsx(PreviewOrId, {
-                    id: extractDocumentId(ref.id),
+                    id: toBareId(ref.id),
                     type: ref.type
                 })
             }), 
@@ -1730,7 +1892,7 @@ function useActionClusterPending() {
 }
 
 function useFireAction(args) {
-    const {instanceId: instanceId, activity: activity, action: action, label: label} = args, {fireActionFor: fireActionFor} = useWorkflowContext(), toast = useClosableToast(), cluster = useActionClusterLock(), [localPending, setLocalPending] = useState(!1), pending = localPending || cluster?.pending === !0;
+    const {instanceId: instanceId, activity: activity, action: action, label: label, surface: surface, viaMenu: viaMenu} = args, {fireActionFor: fireActionFor} = useWorkflowContext(), telemetry = useWorkflowTelemetry(), toast = useClosableToast(), cluster = useActionClusterLock(), [localPending, setLocalPending] = useState(!1), pending = localPending || cluster?.pending === !0;
     return {
         fire: useCallback(async params => {
             if (pending) return !1;
@@ -1745,6 +1907,11 @@ function useFireAction(args) {
                 }), toast.push({
                     status: "success",
                     title: `${label} done`
+                }), telemetry.log(WorkflowActionControlUsed, {
+                    instanceId: instanceId,
+                    surface: surface,
+                    viaMenu: viaMenu,
+                    success: !0
                 }), !0;
             } catch (err) {
                 return console.error(`[workflow-studio-plugin] firing "${action}" on "${activity}" failed:`, err), 
@@ -1752,15 +1919,29 @@ function useFireAction(args) {
                     status: "error",
                     title: `${label} failed`,
                     description: describeError(err)
+                }), telemetry.log(WorkflowActionControlUsed, {
+                    instanceId: instanceId,
+                    surface: surface,
+                    viaMenu: viaMenu,
+                    success: !1
                 }), !1;
             } finally {
                 setLocalPending(!1), cluster?.onFireChange(!1);
             }
-        }, [ fireActionFor, instanceId, activity, action, label, pending, toast, cluster ]),
+        }, [ fireActionFor, instanceId, activity, action, label, pending, toast, cluster, telemetry, surface, viaMenu ]),
         pending: pending
     };
 }
 
+const ACTION_ICON_GAP = 2;
+
+function actionIconProps(icon) {
+    return icon ? {
+        gap: ACTION_ICON_GAP,
+        icon: icon
+    } : {};
+}
+
 function stopRowMouseDown(e) {
     e.preventDefault(), e.stopPropagation();
 }
@@ -1788,18 +1969,21 @@ function RowClickShield({active: active, children: children}) {
     });
 }
 
-function FireButton({instanceId: instanceId, activity: activity, action: action, label: label, mode: mode = "default", chrome: chrome, tone: tone = "default"}) {
+function FireButton({instanceId: instanceId, activity: activity, action: action, label: label, surface: surface, mode: mode = "default", chrome: chrome, tone: tone = "default", icon: icon}) {
     const {fire: fire, pending: pending} = useFireAction({
         instanceId: instanceId,
         activity: activity,
         action: action,
-        label: label
+        label: label,
+        surface: surface,
+        viaMenu: !1
     }), handleClick = e => {
         chrome?.inButtonCard === !0 && e.stopPropagation(), !pending && fire();
     };
     /* @__PURE__ */
     return jsx(Button, {
         fontSize: 1,
+        ...actionIconProps(icon),
         loading: pending,
         mode: chrome?.mode ?? mode,
         onClick: handleClick,
@@ -1813,31 +1997,39 @@ function FireButton({instanceId: instanceId, activity: activity, action: action,
     });
 }
 
-function ActivityActionRow({actionEval: actionEval, instanceId: instanceId, activity: activity, chrome: chrome}) {
+function ActivityActionRow({actionEval: actionEval, instanceId: instanceId, activity: activity, surface: surface, chrome: chrome}) {
     const rowKind = actionRowKind(actionEval);
     return rowKind.kind === "disabled" ? /* @__PURE__ */ jsx(DisabledActionButton, {
         actionEval: actionEval,
+        activity: activity,
         chrome: chrome
     }) : rowKind.kind === "plain" ? /* @__PURE__ */ jsx(PlainActionButton, {
         actionEval: actionEval,
         instanceId: instanceId,
         activity: activity,
-        chrome: chrome
+        chrome: chrome,
+        surface: surface
     }) : /* @__PURE__ */ jsx(ParamsActionButton, {
         actionEval: actionEval,
         instanceId: instanceId,
         activity: activity,
-        chrome: chrome
+        chrome: chrome,
+        surface: surface
     });
 }
 
-function DisabledActionButton({actionEval: actionEval, chrome: chrome}) {
-    const label = actionTriggerLabel(actionEval), button = /* @__PURE__ */ jsx(Button, {
+function DisabledActionButton({actionEval: actionEval, activity: activity, chrome: chrome}) {
+    const label = actionTriggerLabel(actionEval), {tone: tone, icon: icon} = actionButtonFace({
+        actionEval: actionEval,
+        activityName: activity
+    }), button = /* @__PURE__ */ jsx(Button, {
         fontSize: 1,
+        ...actionIconProps(icon),
         mode: chrome?.mode ?? "ghost",
         onClick: e => e.stopPropagation(),
         padding: 2,
         text: label,
+        tone: tone,
         ...spanTriggerProps(chrome),
         disabled: !0
     });
@@ -1847,17 +2039,19 @@ function DisabledActionButton({actionEval: actionEval, chrome: chrome}) {
     }) : button;
 }
 
-function PlainActionButton({actionEval: actionEval, instanceId: instanceId, activity: activity, chrome: chrome}) {
-    const {action: action} = actionEval, label = actionLabel(action), btn = actionButtonTone({
+function PlainActionButton({actionEval: actionEval, instanceId: instanceId, activity: activity, surface: surface, chrome: chrome}) {
+    const {action: action} = actionEval, label = actionLabel(action), btn = actionButtonFace({
         actionEval: actionEval,
         activityName: activity
     }), button = /* @__PURE__ */ jsx(FireButton, {
         action: action.name,
+        icon: btn.icon,
         instanceId: instanceId,
         label: label,
         mode: btn.mode,
         activity: activity,
         chrome: chrome,
+        surface: surface,
         tone: btn.tone
     });
     return action.description ? /* @__PURE__ */ jsx(HoverHint, {
@@ -1866,12 +2060,14 @@ function PlainActionButton({actionEval: actionEval, instanceId: instanceId, acti
     }) : button;
 }
 
-function ParamsActionDialog({actionEval: actionEval, instanceId: instanceId, activity: activity, onClose: onClose}) {
+function ParamsActionDialog({actionEval: actionEval, instanceId: instanceId, activity: activity, surface: surface, viaMenu: viaMenu, onClose: onClose}) {
     const {action: action} = actionEval, label = actionLabel(action), decls = action.params ?? [], [values, setValues] = useState({}), {fire: fire, pending: pending} = useFireAction({
         instanceId: instanceId,
         activity: activity,
         action: action.name,
-        label: label
+        label: label,
+        surface: surface,
+        viaMenu: viaMenu
     }), built = buildParams(decls, values), confirm = async () => {
         await fire(built.params) && onClose();
     };
@@ -1926,8 +2122,8 @@ function ParamsActionDialog({actionEval: actionEval, instanceId: instanceId, act
     });
 }
 
-function ParamsActionButton({actionEval: actionEval, instanceId: instanceId, activity: activity, chrome: chrome}) {
-    const [open, setOpen] = useState(!1), btn = actionButtonTone({
+function ParamsActionButton({actionEval: actionEval, instanceId: instanceId, activity: activity, surface: surface, chrome: chrome}) {
+    const [open, setOpen] = useState(!1), btn = actionButtonFace({
         actionEval: actionEval,
         activityName: activity
     });
@@ -1936,6 +2132,7 @@ function ParamsActionButton({actionEval: actionEval, instanceId: instanceId, act
         children: [ 
         /* @__PURE__ */ jsx(Button, {
             fontSize: 1,
+            ...actionIconProps(btn.icon),
             mode: chrome?.mode ?? btn.mode,
             onClick: e => {
                 chrome?.inButtonCard === !0 && e.stopPropagation(), setOpen(!0);
@@ -1950,7 +2147,9 @@ function ParamsActionButton({actionEval: actionEval, instanceId: instanceId, act
                 actionEval: actionEval,
                 activity: activity,
                 instanceId: instanceId,
-                onClose: () => setOpen(!1)
+                onClose: () => setOpen(!1),
+                surface: surface,
+                viaMenu: !1
             })
         }) : null ]
     });
@@ -2244,27 +2443,10 @@ function useLocalDocRef(gdr) {
 }
 
 function useActualDocType(bareId) {
-    const client = useClient({
-        apiVersion: WORKFLOW_API_VERSION
-    }), [probe, setProbe] = useState();
+    const {actualTypes: actualTypes} = useWorkflowContext();
     return useEffect(() => {
-        if (!bareId) return;
-        let cancelled = !1;
-        return client.fetch("*[_id == $id || _id == $draft || _id in path($version)][0]._type", {
-            id: bareId,
-            draft: `drafts.${bareId}`,
-            version: `versions.*.${bareId}`
-        }, {
-            perspective: "raw"
-        }).then(result => {
-            cancelled || setProbe({
-                id: bareId,
-                value: result
-            });
-        }).catch(() => {}), () => {
-            cancelled = !0;
-        };
-    }, [ client, bareId ]), probe !== void 0 && probe.id === bareId ? probe.value : void 0;
+        if (bareId !== null) return actualTypes.track(bareId);
+    }, [ actualTypes, bareId ]), useSyncExternalStore(actualTypes.subscribe, useCallback(() => bareId === null ? void 0 : actualTypes.read(bareId), [ actualTypes, bareId ]));
 }
 
 function useDocLink(gdr) {
@@ -2761,7 +2943,7 @@ function ReadOnlyDocRefs({entry: entry}) {
             padding: 2,
             radius: 2,
             children: /* @__PURE__ */ jsx(PreviewOrId, {
-                id: extractDocumentId(ref.id),
+                id: toBareId(ref.id),
                 type: ref.type
             })
         }, ref.id))
@@ -2844,7 +3026,7 @@ function useFieldDraft(args) {
 }
 
 function EditableFieldControl({instanceId: instanceId, field: field}) {
-    const {editFieldFor: editFieldFor, previewFieldFor: previewFieldFor, discardFieldPreviewFor: discardFieldPreviewFor} = useWorkflowContext(), me = useCurrentUser(), held = useHeldWorkflowEntry(instanceId), entry = held ? resolveFieldEntry(held.instance, field) : void 0, evaluation = held?.evaluation, target = editTargetOf(field), consequence = fieldConsequence(evaluation, field.name), advanceTo = advanceTargetTitle(evaluation, field.name);
+    const {editFieldFor: editFieldFor, previewFieldFor: previewFieldFor, discardFieldPreviewFor: discardFieldPreviewFor} = useWorkflowContext(), selfActor = useSelfActor(), held = useHeldWorkflowEntry(instanceId), entry = held ? resolveFieldEntry(held.instance, field) : void 0, evaluation = held?.evaluation, target = editFieldTarget(field), consequence = fieldConsequence(evaluation, field.name), advanceTo = advanceTargetTitle(evaluation, field.name);
     /* @__PURE__ */
     return jsx(EditableField, {
         field: field,
@@ -2880,7 +3062,7 @@ function EditableFieldControl({instanceId: instanceId, field: field}) {
             mode: "append",
             value: noteRow({
                 body: body,
-                actor: me ? personActor(me) : void 0,
+                actor: selfActor,
                 at: /* @__PURE__ */ (new Date).toISOString()
             })
         }).then(() => {})
@@ -3015,7 +3197,10 @@ function AssigneeField({field: field, onSave: onSave, onUnset: onUnset}) {
         align: "center",
         children: /* @__PURE__ */ jsx(DismissablePopover, {
             content: /* @__PURE__ */ jsx(AssigneePicker, {
-                onToggle: pickAndClose,
+                onChange: next => {
+                    const changed = changedAssignee(cur ? [ cur ] : [], next);
+                    changed && pickAndClose(changed);
+                },
                 value: cur ? [ cur ] : []
             }),
             onDismiss: () => setOpen(!1),
@@ -3540,11 +3725,11 @@ function AssignActivityControl({instanceId: instanceId, state: state, assigneeId
             setBusy(!0);
             try {
                 selectedIds.has(memberId) ? await editFieldFor(instanceId, {
-                    target: editTargetOf(field),
+                    target: editFieldTarget(field),
                     mode: "set",
                     value: members.filter(m => !(m.type === "user" && m.id === memberId))
                 }) : await editFieldFor(instanceId, {
-                    target: editTargetOf(field),
+                    target: editFieldTarget(field),
                     mode: "append",
                     value: {
                         type: "user",
@@ -3973,8 +4158,8 @@ function TodoItemRowView({breadcrumb: breadcrumb, row: row, onToggle: onToggle,
     });
 }
 
-function TodoItemsList({breadcrumb: breadcrumb, entry: entry, filter: filter}) {
-    const {instance: instance} = entry, definition = useDefinition(entry), {editFieldFor: editFieldFor, fireActionFor: fireActionFor} = useWorkflowContext(), toast = useClosableToast(), [busy, setBusy] = useState(!1), derivation = deriveTodoItems(entry), rows = derivation.rows.filter(row => rowMatches(row, filter)), appendTarget = appendTargetFor(derivation.appendTargets, filter), run = async op => {
+function TodoItemsList({breadcrumb: breadcrumb, entry: entry, filter: filter, surface: surface}) {
+    const {instance: instance} = entry, definition = useDefinition(entry), {editFieldFor: editFieldFor, fireActionFor: fireActionFor} = useWorkflowContext(), telemetry = useWorkflowTelemetry(), toast = useClosableToast(), [busy, setBusy] = useState(!1), derivation = deriveTodoItems(entry), rows = derivation.rows.filter(row => rowMatches(row, filter)), appendTarget = appendTargetFor(derivation.appendTargets, filter), run = async op => {
         if (busy) return !1;
         setBusy(!0);
         try {
@@ -3999,15 +4184,35 @@ function TodoItemsList({breadcrumb: breadcrumb, entry: entry, filter: filter}) {
             mode: "set",
             value: next
         }));
-    }, toggleRow = row => {
-        if (row.editTarget) return patchItem(row, {
-            status: toggledTodoStatus(row.item)
-        });
+    }, toggleRow = async row => {
+        if (busy) return;
+        if (row.editTarget) {
+            const done = !isTodoDone(row.item), success = await patchItem(row, {
+                status: toggledTodoStatus(row.item)
+            }) === !0;
+            telemetry.log(WorkflowTodoToggled, {
+                instanceId: instance._id,
+                surface: surface,
+                via: "field-edit",
+                done: done,
+                success: success
+            });
+            return;
+        }
         const tick = row.tick;
-        return tick && tick.actionEval.allowed && !isTodoDone(row.item) ? run(() => fireActionFor(instance._id, {
-            activity: tick.activity,
-            action: tick.actionEval.action.name
-        })) : Promise.resolve();
+        if (tick && tick.actionEval.allowed && !isTodoDone(row.item)) {
+            const success = await run(() => fireActionFor(instance._id, {
+                activity: tick.activity,
+                action: tick.actionEval.action.name
+            }));
+            telemetry.log(WorkflowTodoToggled, {
+                instanceId: instance._id,
+                surface: surface,
+                via: "action",
+                done: !0,
+                success: success
+            });
+        }
     }, addItem = label => appendTarget ? run(() => editFieldFor(instance._id, {
         target: appendTarget,
         mode: "append",
@@ -4124,26 +4329,39 @@ const ACTIONS_MENU_TRIGGER = {
     padding: 2
 };
 
-function ActionMenuItem({actionEval: actionEval, instanceId: instanceId, activity: activity, onCollectParams: onCollectParams}) {
-    const rowKind = actionRowKind(actionEval), label = actionTriggerLabel(actionEval), {fire: fire, pending: pending} = useFireAction({
+function ActionMenuItem({actionEval: actionEval, instanceId: instanceId, activity: activity, surface: surface, onCollectParams: onCollectParams}) {
+    const rowKind = actionRowKind(actionEval), label = actionTriggerLabel(actionEval), {tone: tone, icon: icon} = actionButtonFace({
+        actionEval: actionEval,
+        activityName: activity
+    }), iconProp = icon ? {
+        icon: icon
+    } : {}, {fire: fire, pending: pending} = useFireAction({
         instanceId: instanceId,
         activity: activity,
         action: actionEval.action.name,
-        label: label
+        label: label,
+        surface: surface,
+        viaMenu: !0
     });
     return rowKind.kind === "disabled" ? /* @__PURE__ */ jsx(MenuItem, {
         disabled: !0,
-        text: label
+        ...iconProp,
+        text: label,
+        tone: tone
     }) : rowKind.kind === "plain" ? /* @__PURE__ */ jsx(MenuItem, {
         disabled: pending,
+        ...iconProp,
         onClick: () => {
             fire();
         },
-        text: label
+        text: label,
+        tone: tone
     }) : /* @__PURE__ */ jsx(MenuItem, {
         disabled: pending,
+        ...iconProp,
         onClick: onCollectParams,
-        text: label
+        text: label,
+        tone: tone
     });
 }
 
@@ -4159,7 +4377,7 @@ function rowShield(menuButton) {
     });
 }
 
-function ActionsMenuButton({actions: actions, instanceId: instanceId, activity: activity, label: label, mode: mode = "ghost", inButtonCard: inButtonCard = !1}) {
+function ActionsMenuButton({actions: actions, instanceId: instanceId, activity: activity, label: label, surface: surface, mode: mode = "ghost", inButtonCard: inButtonCard = !1}) {
     const [paramsAction, setParamsAction] = useState(void 0), clusterPending = useActionClusterPending(), menuId = useId(), menuButton = /* @__PURE__ */ jsx(MenuButton, {
         button: /* @__PURE__ */ jsx(Button, {
             ...ACTIONS_MENU_TRIGGER,
@@ -4178,7 +4396,8 @@ function ActionsMenuButton({actions: actions, instanceId: instanceId, activity:
                 actionEval: a,
                 activity: activity,
                 instanceId: instanceId,
-                onCollectParams: () => setParamsAction(a)
+                onCollectParams: () => setParamsAction(a),
+                surface: surface
             }, a.action.name))
         }),
         popover: {
@@ -4194,7 +4413,9 @@ function ActionsMenuButton({actions: actions, instanceId: instanceId, activity:
                 actionEval: paramsAction,
                 activity: activity,
                 instanceId: instanceId,
-                onClose: () => setParamsAction(void 0)
+                onClose: () => setParamsAction(void 0),
+                surface: surface,
+                viaMenu: !0
             })
         }) : null ]
     });
@@ -4210,7 +4431,8 @@ function TerminalFooter({actions: actions, activity: activity, instanceId: insta
             children: /* @__PURE__ */ jsx(ActivityActionRow, {
                 actionEval: only,
                 activity: activity,
-                instanceId: instanceId
+                instanceId: instanceId,
+                surface: "terminal-footer"
             })
         }) : /* @__PURE__ */ jsx(FittedActions, {
             actions: actions,
@@ -4256,6 +4478,7 @@ function FittedActions({actions: actions, activity: activity, instanceId: instan
         children: [ 
         /* @__PURE__ */ jsx(MeasureRow, {
             actions: actions,
+            activity: activity,
             onElement: setMeasureEl
         }), 
         /* @__PURE__ */ jsxs(FooterRow, {
@@ -4263,19 +4486,21 @@ function FittedActions({actions: actions, activity: activity, instanceId: instan
             children: [ inline === void 0 ? null : actions.slice(0, inline).map(a => /* @__PURE__ */ jsx(ActivityActionRow, {
                 actionEval: a,
                 activity: activity,
-                instanceId: instanceId
+                instanceId: instanceId,
+                surface: "terminal-footer"
             }, a.action.name)), overflow.length > 0 ? /* @__PURE__ */ jsx(ActionsMenuButton, {
                 actions: overflow,
                 activity: activity,
                 instanceId: instanceId,
                 label: MORE_ACTIONS_LABEL,
-                mode: "default"
+                mode: "default",
+                surface: "terminal-footer"
             }) : null ]
         }) ]
     });
 }
 
-function MeasureRow({actions: actions, onElement: onElement}) {
+function MeasureRow({actions: actions, activity: activity, onElement: onElement}) {
     /* @__PURE__ */
     return jsx("div", {
         "aria-hidden": !0,
@@ -4289,12 +4514,20 @@ function MeasureRow({actions: actions, onElement: onElement}) {
                 display: "inline-flex",
                 whiteSpace: "nowrap"
             },
-            children: [ actions.map(a => /* @__PURE__ */ jsx(Button, {
-                as: "span",
-                fontSize: 1,
-                padding: 2,
-                text: actionTriggerLabel(a)
-            }, a.action.name)), 
+            children: [ actions.map(a => {
+                const {icon: icon} = actionButtonFace({
+                    actionEval: a,
+                    activityName: activity
+                });
+                /* @__PURE__ */
+                return jsx(Button, {
+                    as: "span",
+                    fontSize: 1,
+                    ...actionIconProps(icon),
+                    padding: 2,
+                    text: actionTriggerLabel(a)
+                }, a.action.name);
+            }), 
             /* @__PURE__ */ jsx(Button, {
                 ...ACTIONS_MENU_TRIGGER,
                 as: "span",
@@ -4304,7 +4537,7 @@ function MeasureRow({actions: actions, onElement: onElement}) {
     });
 }
 
-function ActivityDetailDialog({entry: entry, activityName: activityName, breadcrumb: breadcrumb, definition: definition, document: document, onClose: onClose}) {
+function ActivityDetailDialog({entry: entry, activityName: activityName, breadcrumb: breadcrumb, definition: definition, document: document, source: source, onClose: onClose}) {
     const detail = deriveActivityDetail({
         entry: entry,
         activityName: activityName
@@ -4326,6 +4559,13 @@ function ActivityDetailDialog({entry: entry, activityName: activityName, breadcr
         onClose: onClose,
         width: 1,
         children: [ 
+        /* @__PURE__ */ jsx(LogEventOnMount, {
+            data: {
+                instanceId: instanceId,
+                source: source
+            },
+            event: WorkflowActivityDialogOpened
+        }), 
         /* @__PURE__ */ jsx(Card, {
             borderBottom: hasBody,
             style: {
@@ -4433,7 +4673,8 @@ function TopActions({detail: detail, definition: definition, instanceId: instanc
         children: [ p.actions.map(a => /* @__PURE__ */ jsx(ActivityActionRow, {
             actionEval: a,
             activity: activityName,
-            instanceId: instanceId
+            instanceId: instanceId,
+            surface: "dialog-strip"
         }, a.action.name)), p.manualTarget ? /* @__PURE__ */ jsx(Button, {
             as: "a",
             fontSize: 1,
@@ -4469,7 +4710,8 @@ function FieldRow({field: field, detail: detail, entry: entry, activityName: act
                 scope: "activity",
                 field: field.name,
                 activity: activityName
-            }
+            },
+            surface: "activity-dialog"
         }) ]
     });
     if (field._type === "assignees") {
@@ -4576,7 +4818,26 @@ function CountedLabel({count: count, label: label}) {
     });
 }
 
-function GroupHeading({count: count, title: title, end: end}) {
+function SpinnerSlot({busy: busy, size: size}) {
+    /* @__PURE__ */
+    return jsx(Flex, {
+        align: "center",
+        flex: "none",
+        justify: "center",
+        style: {
+            width: 19,
+            height: 19
+        },
+        children: busy ? /* @__PURE__ */ jsx(Spinner, {
+            muted: !0,
+            ...size !== void 0 ? {
+                size: size
+            } : {}
+        }) : null
+    });
+}
+
+function GroupHeading({busy: busy, count: count, title: title, end: end}) {
     /* @__PURE__ */
     return jsxs(Flex, {
         align: "center",
@@ -4591,6 +4852,9 @@ function GroupHeading({count: count, title: title, end: end}) {
                 weight: "semibold",
                 children: title
             })
+        }), busy === void 0 ? null : /* @__PURE__ */ jsx(SpinnerSlot, {
+            busy: busy,
+            size: 1
         }), end === void 0 ? null : /* @__PURE__ */ jsxs(Fragment, {
             children: [ 
             /* @__PURE__ */ jsx(Flex, {
@@ -4600,29 +4864,7 @@ function GroupHeading({count: count, title: title, end: end}) {
     });
 }
 
-function CopyDetailsButton({unreadable: unreadable}) {
-    const toast = useClosableToast();
-    /* @__PURE__ */
-    return jsx(Button, {
-        fontSize: 1,
-        mode: "ghost",
-        onClick: () => {
-            navigator.clipboard.writeText(unreadableDocsReport(unreadable)).then(() => toast.push({
-                status: "success",
-                title: "Details copied"
-            }), () => toast.push({
-                status: "error",
-                title: "Could not copy the details"
-            }));
-        },
-        padding: 2,
-        text: "Copy details"
-    });
-}
-
-function UnreadableDocsNote({unreadable: unreadable}) {
-    if (unreadable.length === 0) return null;
-    const label = unreadable.length === 1 ? "1 workflow document isn’t listed — this Studio can’t read it. Share the details with your Studio maintainers." : `${unreadable.length} workflow documents aren’t listed — this Studio can’t read them. Share the details with your Studio maintainers.`;
+function CautionNote({action: action, label: label}) {
     /* @__PURE__ */
     return jsxs(Card, {
         padding: 2,
@@ -4649,35 +4891,64 @@ function UnreadableDocsNote({unreadable: unreadable}) {
                 size: 1,
                 children: label
             }) ]
-        }), 
-        /* @__PURE__ */ jsx(CopyDetailsButton, {
-            unreadable: unreadable
-        }) ]
+        }), action ]
     });
 }
 
-const HEADLINES = {
-    "model-ahead": "Workflow needs a newer engine",
-    "shape-violation": "Unreadable workflow document"
-};
-
-function remediation(invalid) {
-    return invalid.reason === "model-ahead" ? `"${invalid.documentId}" was created by a newer version of the workflow engine than this Studio can read. It needs a plugin update that supports the newer data model — share the details with your Studio maintainers.` : `This version of the Studio can't read "${invalid.documentId}" — it was likely created by a newer or different version of the workflow tooling. Share the details with your Studio maintainers.`;
-}
-
-function InvalidDocNotice({invalid: invalid}) {
+function CopyDetailsButton({unreadable: unreadable}) {
+    const toast = useClosableToast();
     /* @__PURE__ */
-    return jsx(Card, {
-        border: !0,
-        padding: 3,
-        radius: 2,
-        tone: "caution",
-        children: /* @__PURE__ */ jsxs(Stack, {
-            space: 3,
-            children: [ 
-            /* @__PURE__ */ jsx(Text, {
-                size: 1,
-                weight: "medium",
+    return jsx(Button, {
+        fontSize: 1,
+        mode: "ghost",
+        onClick: () => {
+            navigator.clipboard.writeText(unreadableDocsReport(unreadable)).then(() => toast.push({
+                status: "success",
+                title: "Details copied"
+            }), () => toast.push({
+                status: "error",
+                title: "Could not copy the details"
+            }));
+        },
+        padding: 2,
+        text: "Copy details"
+    });
+}
+
+function UnreadableDocsNote({unreadable: unreadable}) {
+    if (unreadable.length === 0) return null;
+    const label = unreadable.length === 1 ? "1 workflow document isn’t listed — this Studio can’t read it. Share the details with your Studio maintainers." : `${unreadable.length} workflow documents aren’t listed — this Studio can’t read them. Share the details with your Studio maintainers.`;
+    /* @__PURE__ */
+    return jsx(CautionNote, {
+        action: /* @__PURE__ */ jsx(CopyDetailsButton, {
+            unreadable: unreadable
+        }),
+        label: label
+    });
+}
+
+const HEADLINES = {
+    "model-ahead": "Workflow needs a newer engine",
+    "shape-violation": "Unreadable workflow document"
+};
+
+function remediation(invalid) {
+    return invalid.reason === "model-ahead" ? `"${invalid.documentId}" was created by a newer version of the workflow engine than this Studio can read. It needs a plugin update that supports the newer data model — share the details with your Studio maintainers.` : `This version of the Studio can't read "${invalid.documentId}" — it was likely created by a newer or different version of the workflow tooling. Share the details with your Studio maintainers.`;
+}
+
+function InvalidDocNotice({invalid: invalid}) {
+    /* @__PURE__ */
+    return jsx(Card, {
+        border: !0,
+        padding: 3,
+        radius: 2,
+        tone: "caution",
+        children: /* @__PURE__ */ jsxs(Stack, {
+            space: 3,
+            children: [ 
+            /* @__PURE__ */ jsx(Text, {
+                size: 1,
+                weight: "medium",
                 children: HEADLINES[invalid.reason]
             }), 
             /* @__PURE__ */ jsx(Text, {
@@ -4713,6 +4984,18 @@ function TabSwitch({ariaControls: ariaControls, idPrefix: idPrefix, options: opt
     });
 }
 
+function useDelayedFlag(active, delayMs) {
+    const [held, setHeld] = useState(!1);
+    return useEffect(() => {
+        if (!active) {
+            setHeld(!1);
+            return;
+        }
+        const timer = setTimeout(() => setHeld(!0), delayMs);
+        return () => clearTimeout(timer);
+    }, [ active, delayMs ]), held && active;
+}
+
 function instanceTitle(instance, definition) {
     return definition?.title ?? instance.definition;
 }
@@ -4962,6 +5245,25 @@ function buildStartRequest(args) {
     };
 }
 
+function sharedPreflightDataset(engine, tag) {
+    let pending;
+    return () => {
+        if (pending !== void 0) return pending;
+        const {query: query, params: params} = instancesQuery({
+            tag: tag,
+            filter: {
+                includeCompleted: !0
+            }
+        });
+        return pending = engine.query({
+            groq: query,
+            params: params
+        }).then(rows => rows.map(assertReadableModel).map(projectStartSliceRow)).finally(() => {
+            pending = void 0;
+        }), pending;
+    };
+}
+
 function findResumeEntry(args) {
     return args.entries.find(e => isUnprimed(e.instance) && e.instance.definition === args.definitionName && (args.heldInstanceId === void 0 || e.instance._id === args.heldInstanceId));
 }
@@ -4977,7 +5279,8 @@ function classifyStartError(err) {
         instance: err.instance,
         description: describeError(err.cause)
     } : err instanceof StartNotAllowedError ? {
-        kind: "not-allowed"
+        kind: "not-allowed",
+        description: err.unmetRequirements.map(requirementCopy).join("; ")
     } : {
         kind: "failed",
         description: describeError(err)
@@ -4990,22 +5293,30 @@ function boundReleaseId(mapping, selectedReleaseId) {
 
 function startGate(args) {
     const {mapping: mapping, mappingIssue: mappingIssue, selectedReleaseId: selectedReleaseId, releaseActive: releaseActive} = args;
-    return mappingIssue !== void 0 ? {
+    if (mappingIssue !== void 0) return {
         blocked: !0,
         tooltip: mappingIssue
-    } : mapping.perspectiveField?.required === !0 && selectedReleaseId === void 0 ? {
+    };
+    if (mapping.perspectiveField?.required === !0 && selectedReleaseId === void 0) return {
         blocked: !0,
         tooltip: "Pick a release in the perspective dropdown first"
-    } : mapping.perspectiveField !== void 0 && selectedReleaseId !== void 0 && !releaseActive ? {
+    };
+    if (mapping.perspectiveField !== void 0 && selectedReleaseId !== void 0 && !releaseActive) return {
         blocked: !0,
         tooltip: `Release "${selectedReleaseId}" is not active — only active releases can host new workflows`
-    } : args.startFilterFailed === !0 ? {
+    };
+    if (args.startFilterFailed === !0) return {
         blocked: !0,
         tooltip: `${mapping.label} can't start for this document right now — the workflow's start condition isn't met`
-    } : args.startAllowedRefused === !0 ? {
-        blocked: !0,
-        tooltip: `${mapping.label} can't be started for this document right now — the workflow doesn't allow another run with these inputs`
-    } : {
+    };
+    if (args.unmetRequirement !== void 0) {
+        const requirement = args.unmetRequirement;
+        return {
+            blocked: !0,
+            tooltip: requirementCopy(requirement)
+        };
+    }
+    return {
         blocked: !1,
         tooltip: void 0
     };
@@ -5028,10 +5339,10 @@ async function preflightFilter(args) {
     });
 }
 
-async function preflightAllowed(args) {
-    const {allowed: allowed, mapping: mapping, fields: fields, scope: scope} = args;
-    return unboundAllowedReads(allowed, fields).length > 0 ? !1 : (await explainStartAllowed({
-        allowed: allowed,
+async function preflightGroqRequirement(args) {
+    const {query: query, mapping: mapping, fields: fields, scope: scope} = args;
+    return unboundRequirementReads(query, fields).length > 0 ? !1 : (await explainStartRequirement({
+        query: query,
         definition: {
             name: mapping.definition
         },
@@ -5040,6 +5351,25 @@ async function preflightAllowed(args) {
     })).outcome === "unsatisfied";
 }
 
+async function preflightSingleSubjectRequirement(args) {
+    const {mapping: mapping, start: start, declaredFields: declaredFields, fields: fields, scope: scope} = args;
+    return singleSubjectRequirementRefused({
+        definition: {
+            name: mapping.definition,
+            ...declaredFields !== void 0 ? {
+                fields: [ ...declaredFields ]
+            } : {},
+            start: start
+        },
+        fields: fields,
+        scope: scope
+    });
+}
+
+function requirementCopy(requirement) {
+    return requirement.description ?? requirement.title ?? humanize(requirement.name);
+}
+
 async function performStart(args) {
     const {mapping: mapping, docId: docId, initialValue: initialValue, selectedReleaseId: selectedReleaseId} = args, releaseId = boundReleaseId(mapping, selectedReleaseId);
     try {
@@ -5066,7 +5396,21 @@ async function performStart(args) {
 }
 
 function useStartVerdicts(args) {
-    const {mapping: mapping, start: start, docId: docId, initialValue: initialValue, selectedReleaseId: selectedReleaseId} = args, skip = args.hidden || args.resumable;
+    const {mapping: mapping, start: start, docId: docId, initialValue: initialValue, selectedReleaseId: selectedReleaseId, entries: entries} = args, {engine: engine, binding: binding} = useWorkflowContext(), fetchDataset = useMemo(() => sharedPreflightDataset(engine, binding.tag), [ engine, binding.tag ]), skip = args.hidden || args.resumable, groqRequirements = useMemo(() => start?.requirements?.filter(requirement => requirement.type === "groq") ?? [], [ start?.requirements ]), refusedGroq = useGroqRequirementVerdicts({
+        mapping: mapping,
+        requirements: groqRequirements,
+        docId: docId,
+        selectedReleaseId: selectedReleaseId,
+        skip: skip,
+        fetchDataset: fetchDataset
+    }), singleSubjectRefused = useSingleSubjectVerdict({
+        mapping: mapping,
+        start: start,
+        docId: docId,
+        selectedReleaseId: selectedReleaseId,
+        entries: entries,
+        skip: skip
+    }), unmetRequirement = start?.requirements?.find(requirement => requirement.type === "singleSubject" ? singleSubjectRefused : refusedGroq.includes(requirement.name));
     return {
         filterFailed: useFilterVerdict({
             mapping: mapping,
@@ -5074,25 +5418,15 @@ function useStartVerdicts(args) {
             docId: docId,
             initialValue: initialValue,
             selectedReleaseId: selectedReleaseId,
-            skip: skip
+            skip: skip,
+            fetchDataset: fetchDataset
         }),
-        allowedRefused: useAllowedVerdict({
-            mapping: mapping,
-            allowed: start?.allowed,
-            docId: docId,
-            selectedReleaseId: selectedReleaseId,
-            skip: skip
-        })
+        unmetRequirement: unmetRequirement
     };
 }
 
 function preflightScope(args) {
-    const {engine: engine, tag: tag, mapping: mapping, contentResource: contentResource, docId: docId} = args, {query: query, params: params} = instancesQuery({
-        tag: tag,
-        filter: {
-            includeCompleted: !0
-        }
-    });
+    const {tag: tag, mapping: mapping, contentResource: contentResource, docId: docId, fetchDataset: fetchDataset} = args;
     return {
         tag: tag,
         now: /* @__PURE__ */ (new Date).toISOString(),
@@ -5101,15 +5435,12 @@ function preflightScope(args) {
             contentResource: contentResource,
             documentId: docId
         }).id,
-        fetchDataset: async () => (await engine.query({
-            groq: query,
-            params: params
-        })).map(assertReadableModel)
+        fetchDataset: fetchDataset
     };
 }
 
 function useFilterVerdict(args) {
-    const {mapping: mapping, filter: filter, docId: docId, initialValue: initialValue, selectedReleaseId: selectedReleaseId, skip: skip} = args, {engine: engine, binding: binding} = useWorkflowContext(), [failed, setFailed] = useState(!1), rootRead = filter !== void 0 && readsRootDocument(filter), candidateValue = rootRead ? initialValue : null;
+    const {mapping: mapping, filter: filter, docId: docId, initialValue: initialValue, selectedReleaseId: selectedReleaseId, skip: skip, fetchDataset: fetchDataset} = args, {binding: binding} = useWorkflowContext(), [failed, setFailed] = useState(!1), rootRead = filter !== void 0 && readsRootDocument(filter), candidateValue = rootRead ? initialValue : null;
     return useEffect(() => {
         if (skip || filter === void 0 || docId === void 0) {
             setFailed(!1);
@@ -5123,57 +5454,112 @@ function useFilterVerdict(args) {
             candidateValue: candidateValue,
             selectedReleaseId: selectedReleaseId,
             scope: preflightScope({
-                engine: engine,
                 tag: binding.tag,
                 mapping: mapping,
                 contentResource: binding.contentResource,
-                docId: docId
+                docId: docId,
+                fetchDataset: fetchDataset
             })
         }).catch(showRowOnError("start.filter", mapping)).then(verdict => {
             cancelled || setFailed(verdict);
         }), () => {
             cancelled = !0;
         };
-    }, [ filter, rootRead, skip, docId, selectedReleaseId, candidateValue, mapping, engine, binding ]), 
+    }, [ filter, rootRead, skip, docId, selectedReleaseId, candidateValue, mapping, binding, fetchDataset ]), 
     failed;
 }
 
-function useAllowedVerdict(args) {
-    const {mapping: mapping, allowed: allowed, docId: docId, selectedReleaseId: selectedReleaseId, skip: skip} = args, {engine: engine, binding: binding, mappingFields: mappingFields} = useWorkflowContext(), [refused, setRefused] = useState(!1);
+function preflightSeedFields(args) {
+    const ctx = {
+        mapping: args.mapping,
+        subjectDocId: args.docId,
+        selectedReleaseId: args.selectedReleaseId,
+        contentResource: args.contentResource,
+        declaredFields: args.declaredFields
+    };
+    return Object.fromEntries(buildStartFields({
+        ctx: ctx,
+        initFields: [],
+        values: {}
+    }).map(field => [ field.name, field.value ]));
+}
+
+function useGroqRequirementVerdicts(args) {
+    const {mapping: mapping, requirements: requirements, docId: docId, selectedReleaseId: selectedReleaseId, skip: skip, fetchDataset: fetchDataset} = args, {binding: binding, mappingFields: mappingFields} = useWorkflowContext(), [refused, setRefused] = useState([]);
     return useEffect(() => {
-        if (skip || allowed === void 0 || docId === void 0) {
-            setRefused(!1);
+        if (skip || requirements.length === 0 || docId === void 0) {
+            setRefused(current => current.length === 0 ? current : []);
             return;
         }
         let cancelled = !1;
-        const ctx = {
+        const fields = preflightSeedFields({
             mapping: mapping,
-            subjectDocId: docId,
+            docId: docId,
             selectedReleaseId: selectedReleaseId,
             contentResource: binding.contentResource,
             declaredFields: mappingFields.get(mappingKey(mapping))
-        }, fields = Object.fromEntries(buildStartFields({
-            ctx: ctx,
-            initFields: [],
-            values: {}
-        }).map(field => [ field.name, field.value ]));
-        return preflightAllowed({
-            allowed: allowed,
+        }), scope = preflightScope({
+            tag: binding.tag,
             mapping: mapping,
-            fields: fields,
+            contentResource: binding.contentResource,
+            docId: docId,
+            fetchDataset: fetchDataset
+        });
+        return Promise.all(requirements.map(async requirement => ({
+            name: requirement.name,
+            refused: await preflightGroqRequirement({
+                query: requirement.query,
+                mapping: mapping,
+                fields: fields,
+                scope: scope
+            }).catch(showRowOnError(`start.requirements.${requirement.name}`, mapping))
+        }))).then(verdicts => {
+            if (!cancelled) {
+                const next = verdicts.filter(verdict => verdict.refused).map(verdict => verdict.name);
+                setRefused(current => current.length === next.length && current.every((name, index) => name === next[index]) ? current : next);
+            }
+        }), () => {
+            cancelled = !0;
+        };
+    }, [ requirements, skip, docId, selectedReleaseId, mapping, binding, mappingFields, fetchDataset ]), 
+    refused;
+}
+
+function useSingleSubjectVerdict(args) {
+    const {mapping: mapping, start: start, docId: docId, selectedReleaseId: selectedReleaseId, entries: entries, skip: skip} = args, {binding: binding, mappingFields: mappingFields} = useWorkflowContext(), [refused, setRefused] = useState(!1), dedupe = start !== void 0 && hasSingleSubjectRequirement({
+        start: start
+    });
+    return useEffect(() => {
+        if (skip || !dedupe || start === void 0 || docId === void 0) {
+            setRefused(!1);
+            return;
+        }
+        let cancelled = !1;
+        const declaredFields = mappingFields.get(mappingKey(mapping));
+        return preflightSingleSubjectRequirement({
+            mapping: mapping,
+            start: start,
+            declaredFields: declaredFields,
+            fields: preflightSeedFields({
+                mapping: mapping,
+                docId: docId,
+                selectedReleaseId: selectedReleaseId,
+                contentResource: binding.contentResource,
+                declaredFields: declaredFields
+            }),
             scope: preflightScope({
-                engine: engine,
                 tag: binding.tag,
                 mapping: mapping,
+                docId: docId,
                 contentResource: binding.contentResource,
-                docId: docId
+                fetchDataset: () => Promise.resolve(entries.map(({instance: instance}) => projectStartSliceRow(instance)))
             })
-        }).catch(showRowOnError("start.allowed", mapping)).then(verdict => {
+        }).catch(showRowOnError("singleSubject requirement", mapping)).then(verdict => {
             cancelled || setRefused(verdict);
         }), () => {
             cancelled = !0;
         };
-    }, [ allowed, skip, docId, selectedReleaseId, mapping, engine, binding, mappingFields ]), 
+    }, [ dedupe, start, skip, docId, selectedReleaseId, entries, mapping, binding, mappingFields ]), 
     refused;
 }
 
@@ -5183,7 +5569,7 @@ function showRowOnError(key, mapping) {
 }
 
 function useStartWorkflow(args) {
-    const {mapping: mapping, docId: docId, initialValue: initialValue} = args, toast = useClosableToast(), {engine: engine, openStartDialog: openStartDialog, mappingIssues: mappingIssues2, mappingStarts: mappingStarts} = useWorkflowContext(), observer = useStudioObserver({
+    const {mapping: mapping, docId: docId, initialValue: initialValue, source: source} = args, toast = useClosableToast(), {engine: engine, openStartDialog: openStartDialog, mappingIssues: mappingIssues2, mappingStarts: mappingStarts} = useWorkflowContext(), observer = useStudioObserver({
         engine: engine
     }), [starting, setStarting] = useState(!1), {selectedReleaseId: selectedReleaseId} = usePerspective(), releaseActive = useIsReleaseActive(), startBlock = mappingStarts.get(mappingKey(mapping)), hidden = startKindOf({
         start: startBlock
@@ -5191,12 +5577,13 @@ function useStartWorkflow(args) {
         entries: entries,
         definitionName: mapping.definition,
         heldInstanceId: void 0
-    }) !== void 0, {filterFailed: filterFailed, allowedRefused: allowedRefused} = useStartVerdicts({
+    }) !== void 0, {filterFailed: filterFailed, unmetRequirement: unmetRequirement} = useStartVerdicts({
         mapping: mapping,
         start: startBlock,
         docId: docId,
         initialValue: initialValue,
         selectedReleaseId: selectedReleaseId,
+        entries: entries,
         hidden: hidden,
         resumable: resumable
     }), {blocked: blocked, tooltip: tooltip} = startGate({
@@ -5205,7 +5592,9 @@ function useStartWorkflow(args) {
         selectedReleaseId: selectedReleaseId,
         releaseActive: releaseActive,
         startFilterFailed: filterFailed,
-        startAllowedRefused: allowedRefused
+        ...unmetRequirement !== void 0 ? {
+            unmetRequirement: unmetRequirement
+        } : {}
     });
     return {
         blocked: blocked,
@@ -5227,7 +5616,10 @@ function useStartWorkflow(args) {
                             title: "Could not persist the document before starting",
                             description: describeError(err)
                         }),
-                        openStartDialog: openStartDialog
+                        openStartDialog: request => openStartDialog({
+                            ...request,
+                            source: source
+                        })
                     });
                 } finally {
                     setStarting(!1);
@@ -5237,11 +5629,12 @@ function useStartWorkflow(args) {
     };
 }
 
-function StartWorkflowButton({mapping: mapping, docId: docId, initialValue: initialValue, mode: mode = "default", label: label, iconOnly: iconOnly = !1, tone: tone = "primary"}) {
+function StartWorkflowButton({mapping: mapping, docId: docId, initialValue: initialValue, source: source, mode: mode = "default", label: label, iconOnly: iconOnly = !1, tone: tone = "primary"}) {
     const {blocked: blocked, tooltip: tooltip, hidden: hidden, starting: starting, start: start} = useStartWorkflow({
         mapping: mapping,
         docId: docId,
-        initialValue: initialValue
+        initialValue: initialValue,
+        source: source
     });
     if (hidden) return null;
     const startLabel = label ?? `Start ${mapping.label}`, button = /* @__PURE__ */ jsx(Button, {
@@ -5274,7 +5667,7 @@ function useStartableMappings(mappings) {
     }) !== "autonomous");
 }
 
-function StartWorkflowControl({mappings: mappings, docId: docId, initialValue: initialValue, label: label, iconOnly: iconOnly = !1, mode: mode = "default", tone: tone = "primary"}) {
+function StartWorkflowControl({mappings: mappings, docId: docId, initialValue: initialValue, source: source, label: label, iconOnly: iconOnly = !1, mode: mode = "default", tone: tone = "primary"}) {
     const menuId = useId(), startable = useStartableMappings(mappings), [first] = startable;
     if (first === void 0) return null;
     if (startable.length === 1) /* @__PURE__ */
@@ -5287,6 +5680,7 @@ function StartWorkflowControl({mappings: mappings, docId: docId, initialValue: i
         },
         mapping: first,
         mode: mode,
+        source: source,
         tone: tone
     });
     const menuLabel = label ?? "Start a workflow";
@@ -5312,7 +5706,8 @@ function StartWorkflowControl({mappings: mappings, docId: docId, initialValue: i
             children: startable.map(mapping => /* @__PURE__ */ jsx(StartWorkflowMenuItem, {
                 docId: docId,
                 initialValue: initialValue,
-                mapping: mapping
+                mapping: mapping,
+                source: source
             }, mappingKey(mapping)))
         }),
         popover: {
@@ -5323,11 +5718,12 @@ function StartWorkflowControl({mappings: mappings, docId: docId, initialValue: i
     });
 }
 
-function StartWorkflowMenuItem({mapping: mapping, docId: docId, initialValue: initialValue}) {
+function StartWorkflowMenuItem({mapping: mapping, docId: docId, initialValue: initialValue, source: source}) {
     const {blocked: blocked, tooltip: tooltip, starting: starting, start: start} = useStartWorkflow({
         mapping: mapping,
         docId: docId,
-        initialValue: initialValue
+        initialValue: initialValue,
+        source: source
     }), item = /* @__PURE__ */ jsx(MenuItem, {
         disabled: blocked || starting || !docId,
         onClick: () => {
@@ -5382,13 +5778,15 @@ function RowTerminalActions({actions: actions, activity: activity, instanceId: i
                 mode: "ghost",
                 inButtonCard: !0
             },
-            instanceId: instanceId
+            instanceId: instanceId,
+            surface: "inline-row"
         }) : /* @__PURE__ */ jsx(ActionsMenuButton, {
             actions: actions,
             activity: activity,
             inButtonCard: !0,
             instanceId: instanceId,
-            label: "Select action"
+            label: "Select action",
+            surface: "inline-row"
         })
     }) : null;
 }
@@ -5486,7 +5884,8 @@ function ForMeList({entry: entry, work: work, identity: identity, onOpenActivity
                 filter: {
                     kind: "mine",
                     identity: identity
-                }
+                },
+                surface: "document-view-for-me"
             }) : null ]
         })
     });
@@ -5551,9 +5950,16 @@ function instanceNotice(entry) {
             size: 1,
             children: "This workflow didn’t finish starting — use Start workflow to continue it"
         })
-    }) : pending ? /* @__PURE__ */ jsx(LoadingRow, {
-        label: "Loading…",
-        padding: 4
+    }) : pending ? /* @__PURE__ */ jsx(WorkRow, {
+        lead: /* @__PURE__ */ jsx(Spinner, {
+            muted: !0,
+            size: 1
+        }),
+        children: /* @__PURE__ */ jsx(Text, {
+            muted: !0,
+            size: 1,
+            children: "Loading…"
+        })
     }) : null;
 }
 
@@ -5688,7 +6094,8 @@ function TodoFieldDialog({entry: entry, scope: scope, field: field, title: title
                     kind: "field",
                     scope: scope,
                     field: field
-                }
+                },
+                surface: "todo-field-dialog"
             })
         })
     });
@@ -5901,7 +6308,7 @@ function PillButton({children: children, pill: pill, hintDisabled: hintDisabled
 }
 
 function useFieldCommit({entry: entry, editability: editability}) {
-    const {editFieldFor: editFieldFor} = useWorkflowContext(), target = editTargetOf(editability);
+    const {editFieldFor: editFieldFor} = useWorkflowContext(), target = editFieldTarget(editability);
     return {
         set: value => editFieldFor(entry.instance._id, {
             target: target,
@@ -6117,8 +6524,9 @@ function AssigneePill({entry: entry, pill: pill, editability: editability}) {
     /* @__PURE__ */
     return jsx(PillPopover, {
         content: /* @__PURE__ */ jsx(AssigneePicker, {
-            onToggle: assignee => {
-                setOpen(!1), pick(assignee);
+            onChange: next => {
+                const changed = changedAssignee(current ? [ current ] : [], next);
+                changed && (setOpen(!1), pick(changed));
             },
             value: current ? [ current ] : []
         }),
@@ -6137,10 +6545,8 @@ function AssigneesPill({entry: entry, pill: pill, editability: editability}) {
     /* @__PURE__ */
     return jsx(PillPopover, {
         content: /* @__PURE__ */ jsx(AssigneePicker, {
-            onToggle: assignee => {
-                if (saving) return;
-                const next = current.some(a => sameAssignee(a, assignee)) ? current.filter(a => !sameAssignee(a, assignee)) : [ ...current, assignee ];
-                save(() => set(next));
+            onChange: next => {
+                saving || save(() => set(next));
             },
             value: current
         }),
@@ -6245,15 +6651,15 @@ function Hairline({weight: weight, style: style}) {
     });
 }
 
-function CollapsibleBand({header: header, children: children, background: background = !1, defaultOpen: defaultOpen = !0, sticky: sticky = !1, title: title}) {
-    const [open, setOpen] = useState(defaultOpen), verb = open ? "Collapse" : "Expand";
+function CollapsibleBand({header: header, children: children, background: background = !1, defaultOpen: defaultOpen = !0, onToggle: onToggle, open: controlledOpen, sticky: sticky = !1, title: title}) {
+    const [heldOpen, setHeldOpen] = useState(defaultOpen), open = controlledOpen ?? heldOpen, toggle = onToggle ?? (() => setHeldOpen(value => !value)), verb = open ? "Collapse" : "Expand";
     /* @__PURE__ */
     return jsxs(Stack, {
         gap: 1,
         children: [ 
         /* @__PURE__ */ jsx(Card, {
             onDoubleClick: event => {
-                event.target instanceof Element && event.target.closest("a, button") || setOpen(v => !v);
+                event.target instanceof Element && event.target.closest("a, button") || toggle();
             },
             padding: 1,
             radius: 3,
@@ -6274,7 +6680,7 @@ function CollapsibleBand({header: header, children: children, background: backgr
                     fontSize: 1,
                     icon: open ? ChevronDownIcon : ChevronRightIcon,
                     mode: "bleed",
-                    onClick: () => setOpen(v => !v),
+                    onClick: toggle,
                     padding: 2
                 }), header ]
             })
@@ -6617,20 +7023,7 @@ function InstanceDebugMenu({entry: entry}) {
 }
 
 function InstanceAccordion({entry: entry, children: children, defaultOpen: defaultOpen}) {
-    const definition = useDefinition(entry), {instance: instance, ready: ready} = entry, settled = !isLiveEntry(entry), title = instanceTitle(instance, definition), badgeTrim = useBadgeCapTrim(), status = /* @__PURE__ */ jsxs(Flex, {
-        align: "center",
-        gap: 2,
-        style: badgeTrim,
-        children: [ 
-        /* @__PURE__ */ jsx(AbortedBadge, {
-            instance: instance
-        }), settled ? null : /* @__PURE__ */ jsx(OlderDefinitionBadge, {
-            instance: instance
-        }), !ready && entry.invalid === void 0 ? /* @__PURE__ */ jsx(Spinner, {
-            muted: !0,
-            size: 1
-        }) : null ]
-    });
+    const definition = useDefinition(entry), {instance: instance} = entry, settled = !isLiveEntry(entry), title = instanceTitle(instance, definition), badgeTrim = useBadgeCapTrim();
     /* @__PURE__ */
     return jsx(CollapsibleBand, {
         defaultOpen: defaultOpen ?? !settled,
@@ -6653,7 +7046,18 @@ function InstanceAccordion({entry: entry, children: children, defaultOpen: defau
                     textOverflow: "ellipsis",
                     weight: "medium",
                     children: title
-                }), status ]
+                }), 
+                /* @__PURE__ */ jsxs(Flex, {
+                    align: "center",
+                    gap: 2,
+                    style: badgeTrim,
+                    children: [ 
+                    /* @__PURE__ */ jsx(AbortedBadge, {
+                        instance: instance
+                    }), settled ? null : /* @__PURE__ */ jsx(OlderDefinitionBadge, {
+                        instance: instance
+                    }) ]
+                }) ]
             }), 
             /* @__PURE__ */ jsx(TrailingHairline, {}), 
             /* @__PURE__ */ jsx(InstanceDebugMenu, {
@@ -6671,7 +7075,7 @@ function InstanceAccordion({entry: entry, children: children, defaultOpen: defau
 }
 
 function PartOfBand({instance: instance}) {
-    const parentRef = instance.ancestors.at(-1), parentId = parentRef ? extractDocumentId(parentRef.id) : null, parentEntry = useWorkflowInstanceEntry(parentId), parentDefinition = useDefinition(parentEntry);
+    const parentRef = instance.ancestors.at(-1), parentId = parentRef ? toBareId(parentRef.id) : null, parentEntry = useWorkflowInstanceEntry(parentId), parentDefinition = useDefinition(parentEntry);
     if (!parentId) return null;
     const title = parentEntry ? instanceTitle(parentEntry.instance, parentDefinition) : parentId;
     /* @__PURE__ */
@@ -7187,7 +7591,12 @@ function StageSection({entry: entry, onOpenActivity: onOpenActivity}) {
 }
 
 const VIEW_TAB_CODEC = workflowsTabCodec([ "overview", "for-me" ]), WorkflowsView = props => {
-    const {documentId: documentId, schemaType: schemaType} = props, {isDocResolved: isDocResolved, mappings: mappings, discoveryInvalid: discoveryInvalid} = useWorkflowContext(), {entries: entries} = useWorkflowsForDocument(documentId), resolved = isDocResolved(documentId), docTypeMappings = mappingsForDocType(mappings, schemaType.name);
+    const {documentId: documentId, schemaType: schemaType} = props, {isDocResolved: isDocResolved, mappings: mappings, discoveryInvalid: discoveryInvalid} = useWorkflowContext(), {entries: entries} = useWorkflowsForDocument(documentId), {view: view} = useWorkflowsTab();
+    useLogEventOnMount(WorkflowDocumentViewOpened, {
+        tab: view,
+        via: "open"
+    });
+    const resolved = isDocResolved(documentId), docTypeMappings = mappingsForDocType(mappings, schemaType.name);
     if (entries.length === 0) return discoveryInvalid !== void 0 ? /* @__PURE__ */ jsx(Box, {
         padding: 4,
         children: /* @__PURE__ */ jsx(InvalidDocNotice, {
@@ -7228,11 +7637,9 @@ const VIEW_TAB_CODEC = workflowsTabCodec([ "overview", "for-me" ]), WorkflowsVie
 };
 
 function DiscoverySpinner() {
-    const [visible, setVisible] = useState(!1);
-    return useEffect(() => {
-        const timer = setTimeout(() => setVisible(!0), 1e3);
-        return () => clearTimeout(timer);
-    }, []), /* @__PURE__ */ jsx(Flex, {
+    const visible = useDelayedFlag(!0, 1e3);
+    /* @__PURE__ */
+    return jsx(Flex, {
         align: "center",
         height: "fill",
         justify: "center",
@@ -7242,7 +7649,7 @@ function DiscoverySpinner() {
     });
 }
 
-const GROUP_GAP = 1;
+const BOOT_CUE_DELAY_MS = 400, GROUP_GAP = 1;
 
 function useWorkflowsTab() {
     const {params: params, setParams: setParams} = usePaneRouter();
@@ -7267,7 +7674,7 @@ function useOpenActivity(entries) {
 }
 
 function WorkflowsPanel({entries: entries, documentId: documentId, docTypeMappings: docTypeMappings, initialValue: initialValue}) {
-    const identity = useAssignmentIdentity(), panelId = useId(), {params: params} = usePaneRouter(), {view: view, setView: setView} = useWorkflowsTab(), {openActivity: openActivity, setOpenActivity: setOpenActivity, dialogEntry: dialogEntry} = useOpenActivity(entries), active = entries.filter(isLiveEntry), finished = entries.filter(e => !isLiveEntry(e)), forMe = forMeWorkOf(active, identity), [landing] = useState(() => focusedLanding(params?.[WORKFLOWS_FOCUS_PARAM], entries.map(e => e.instance._id))), assignedWorkUnknown = active.some(e => e.invalid !== void 0), sectionFor = e => /* @__PURE__ */ jsx(WorkflowInstanceSection, {
+    const identity = useAssignmentIdentity(), panelId = useId(), {params: params} = usePaneRouter(), {view: view, setView: setView} = useWorkflowsTab(), telemetry = useWorkflowTelemetry(), {openActivity: openActivity, setOpenActivity: setOpenActivity, dialogEntry: dialogEntry} = useOpenActivity(entries), active = entries.filter(isLiveEntry), finished = entries.filter(e => !isLiveEntry(e)), forMe = forMeWorkOf(active, identity), [landing] = useState(() => focusedLanding(params?.[WORKFLOWS_FOCUS_PARAM], entries.map(e => e.instance._id))), assignedWorkUnknown = active.some(e => e.invalid !== void 0), booting = useDelayedFlag(active.some(e => !e.ready && e.invalid === void 0), BOOT_CUE_DELAY_MS), sectionFor = e => /* @__PURE__ */ jsx(WorkflowInstanceSection, {
         defaultOpen: landingDefaultOpen(landing, e.instance._id),
         entry: e,
         onOpenActivity: activityName => setOpenActivity({
@@ -7288,6 +7695,7 @@ function WorkflowsPanel({entries: entries, documentId: documentId, docTypeMappin
             padding: 3,
             children: [ 
             /* @__PURE__ */ jsx(GroupHeading, {
+                busy: booting,
                 count: active.length,
                 end: 
                 /* @__PURE__ */ jsx(Box, {
@@ -7300,6 +7708,7 @@ function WorkflowsPanel({entries: entries, documentId: documentId, docTypeMappin
                         initialValue: initialValue,
                         mappings: docTypeMappings,
                         mode: "bleed",
+                        source: "document-view-header",
                         tone: "default"
                     })
                 }),
@@ -7308,7 +7717,12 @@ function WorkflowsPanel({entries: entries, documentId: documentId, docTypeMappin
             /* @__PURE__ */ jsx(TabSwitch, {
                 ariaControls: `${panelId}-panel`,
                 idPrefix: panelId,
-                onSelect: setView,
+                onSelect: next => {
+                    next !== view && telemetry.log(WorkflowDocumentViewOpened, {
+                        tab: next,
+                        via: "tab-switch"
+                    }), setView(next);
+                },
                 options: [ {
                     value: "overview",
                     label: "Overview"
@@ -7382,6 +7796,7 @@ function OverviewEmptyState({mappings: mappings, docId: docId, initialValue: ini
                 label: "Start workflow",
                 mappings: mappings,
                 mode: "ghost",
+                source: "document-view-empty-state",
                 tone: "default"
             })
         },
@@ -7415,7 +7830,8 @@ function SectionActivityDialog({entry: entry, activityName: activityName, onClos
         breadcrumb: instanceBreadcrumb(instance, definition),
         definition: definition,
         entry: entry,
-        onClose: onClose
+        onClose: onClose,
+        source: "document-view"
     });
 }
 
@@ -7423,10 +7839,8 @@ function workflowsView(S) {
     return S.view.component(WorkflowsView).id(WORKFLOWS_VIEW_ID).title("Workflows");
 }
 
-function workflowDefaultDocumentNode(options) {
-    return (S, ctx) => {
-        if (mappingForDocType(options.mappings, ctx.schemaType)) return S.document().views([ S.view.form(), workflowsView(S) ]);
-    };
+function workflowDefaultDocumentNode() {
+    return S => S.document().views([ S.view.form(), workflowsView(S) ]);
 }
 
 function lockTitleFor(args) {
@@ -7439,26 +7853,12 @@ function lockTitleFor(args) {
     return workflows.length === 1 ? `The ${workflowList} workflow is holding this document.` : `The ${workflowList} workflows are holding this document.`;
 }
 
-const EMPTY = {
-    byType: /* @__PURE__ */ new Map,
-    definitions: /* @__PURE__ */ new Map,
-    warnings: []
-};
-
 function resolveAutoStart(args) {
-    const {autoStart: autoStart, context: context, knownDocTypes: knownDocTypes, definitions: definitions} = args;
-    if (autoStart === void 0) return EMPTY;
-    const evaluated = evaluateMap(autoStart, context);
-    if ("warning" in evaluated) return {
-        byType: /* @__PURE__ */ new Map,
-        definitions: /* @__PURE__ */ new Map,
-        warnings: [ evaluated.warning ]
-    };
-    const map = evaluated.map, latestByName = new Map(latestDeployedDefinitions(definitions).map(d => [ d.name, d ])), byType = /* @__PURE__ */ new Map, resolvedDefinitions = /* @__PURE__ */ new Map, warnings = [];
-    for (const [docType, spec] of Object.entries(map)) {
+    const {autoStart: autoStart, knownDocTypes: knownDocTypes, definitions: definitions} = args, latestByName = new Map(latestDeployedDefinitions(definitions).map(d => [ d.name, d ])), byType = /* @__PURE__ */ new Map, resolvedDefinitions = /* @__PURE__ */ new Map, warnings = [];
+    for (const [docType, names] of Object.entries(autoStart)) {
         const entry = resolveEntry({
             docType: docType,
-            spec: spec,
+            names: names,
             knownDocTypes: knownDocTypes,
             latestByName: latestByName
         });
@@ -7474,35 +7874,15 @@ function resolveAutoStart(args) {
     };
 }
 
-function evaluateMap(autoStart, context) {
-    let map;
-    try {
-        map = typeof autoStart == "function" ? autoStart(context) : autoStart;
-    } catch (err) {
-        return {
-            warning: `autoStart: config function threw — ignoring it (${describeError(err)}).`
-        };
-    }
-    return typeof map != "object" || map === null ? {
-        warning: "autoStart: config did not resolve to an object — ignoring it."
-    } : {
-        map: map
-    };
-}
-
-function specNames(spec) {
-    return typeof spec == "string" ? [ spec ] : Array.isArray(spec) ? spec : [];
-}
-
 function resolveEntry(args) {
-    const {docType: docType, spec: spec, knownDocTypes: knownDocTypes, latestByName: latestByName} = args;
+    const {docType: docType, names: names, knownDocTypes: knownDocTypes, latestByName: latestByName} = args;
     if (!knownDocTypes.has(docType)) return {
         valid: [],
         definitions: [],
         warnings: [ `autoStart: no schema type "${docType}" — entry skipped.` ]
     };
     const valid = [], definitions = [], warnings = [];
-    for (const name of specNames(spec)) {
+    for (const name of names) {
         const definition = latestByName.get(name), issue = workflowIssue({
             name: name,
             docType: docType,
@@ -7528,11 +7908,57 @@ function workflowIssue(args) {
     const {name: name, docType: docType, definition: definition} = args;
     if (definition === void 0) return `autoStart: "${docType}" → workflow "${name}" is not deployed — skipped.`;
     if (!isStartableDefinition(definition)) return `autoStart: "${docType}" → workflow "${name}" is spawn-only, not startable — skipped.`;
-    if (!acceptsDocumentType({
-        fields: [ ...definition.fields ?? [] ]
-    }, docType)) return `autoStart: "${docType}" → workflow "${name}" has no subject accepting "${docType}" — skipped.`;
-    const subject = (definition.fields ?? []).find(isSubjectEntry);
-    if (subject !== void 0 && !isInputSourced(subject)) return `autoStart: "${docType}" → workflow "${name}" has a self-filling subject (not caller-provided), so the document can't be its subject — skipped.`;
+    const subject = documentSubjectEntry(definition), acceptsType = subject?.types === void 0 || subject.types.includes(docType);
+    if (subject === void 0 || !acceptsType) return `autoStart: "${docType}" → workflow "${name}" has no document subject accepting "${docType}" — skipped.`;
+    if (!isInputSourced(subject)) return `autoStart: "${docType}" → workflow "${name}" has a self-filling subject (not caller-provided), so the document can't be its subject — skipped.`;
+}
+
+function actualType$(previews, bareId) {
+    return previews.unstable_observeDocumentPairAvailability(bareId).pipe(switchMap(({draft: draft, published: published}) => draft.available ? previews.observeDocumentTypeFromId(getDraftId(bareId)) : published.available ? previews.observeDocumentTypeFromId(bareId) : draft.reason === "PERMISSION_DENIED" || published.reason === "PERMISSION_DENIED" ? of(void 0) : previews.unstable_observeVersionDocumentIds(bareId).pipe(switchMap(([firstVersionId]) => firstVersionId === void 0 ? of(null) : previews.observeDocumentTypeFromId(firstVersionId)))), distinctUntilChanged());
+}
+
+const REBUILD_DELAY_MS = 5e3;
+
+function createActualTypeProbeStore(previews) {
+    const verdicts = /* @__PURE__ */ new Map, live = /* @__PURE__ */ new Map, listeners = /* @__PURE__ */ new Set, notify = () => {
+        for (const listener of [ ...listeners ]) listener();
+    }, start = (bareId, entry) => actualType$(previews, bareId).subscribe({
+        next: value => {
+            verdicts.has(bareId) && verdicts.get(bareId) === value || (verdicts.set(bareId, value), 
+            notify());
+        },
+        error: err => {
+            console.error(`[workflow-studio-plugin] actual-type probe for "${bareId}" failed:`, err), 
+            entry.subscription = void 0, entry.rebuildTimer = setTimeout(() => {
+                entry.rebuildTimer = void 0, !(live.get(bareId) !== entry || entry.count === 0) && (entry.subscription = start(bareId, entry));
+            }, REBUILD_DELAY_MS);
+        }
+    });
+    return {
+        subscribe(listener) {
+            return listeners.add(listener), () => {
+                listeners.delete(listener);
+            };
+        },
+        read: bareId => verdicts.get(bareId),
+        track(bareId) {
+            let entry = live.get(bareId);
+            if (entry === void 0) {
+                const created = {
+                    count: 0,
+                    subscription: void 0,
+                    rebuildTimer: void 0
+                };
+                live.set(bareId, created), created.subscription = start(bareId, created), entry = created;
+            }
+            entry.count += 1;
+            let released = !1;
+            return () => {
+                released || (released = !0, entry.count -= 1, !(entry.count > 0) && (entry.subscription?.unsubscribe(), 
+                entry.rebuildTimer !== void 0 && clearTimeout(entry.rebuildTimer), live.get(bareId) === entry && live.delete(bareId)));
+            };
+        }
+    };
 }
 
 function contentDocumentTypes(schema) {
@@ -7541,7 +7967,7 @@ function contentDocumentTypes(schema) {
 
 async function readDeployedDefinitions(engine) {
     return (await engine.query({
-        groq: definitionsListGroq("desc")
+        groq: latestDefinitionsGroq()
     })).map(assertReadableModel);
 }
 
@@ -7552,20 +7978,31 @@ const EMPTY_SNAPSHOT = {
 };
 
 function useDiscoveryState(args) {
-    const {registered: registered, requested: requested, contentResource: contentResource} = args, watching = registered.length + requested.length > 0, [latest, setLatest] = useState(EMPTY_SNAPSHOT), [resolved, setResolved] = useState(EMPTY_SNAPSHOT), onSnapshot = useCallback(snapshot => {
-        setLatest(snapshot), snapshot.instances !== void 0 && setResolved(snapshot);
-    }, []);
-    useEffect(() => {
-        watching || (setLatest(EMPTY_SNAPSHOT), setResolved(EMPTY_SNAPSHOT));
-    }, [ watching ]);
-    const filter = useMemo(() => ({
-        documents: registered.map(id => gdrFromResource(contentResource, id)),
+    const {observed: observed, requested: requested, contentResource: contentResource} = args, documentWatching = observed.length > 0, requestedWatching = requested.length > 0, documents = useDiscoveryStream(documentWatching), explicit = useDiscoveryStream(requestedWatching), documentFilter = useMemo(() => documentWatching ? {
+        documents: observed.map(id => gdrFromResource(contentResource, id)),
+        includeCompleted: !0
+    } : void 0, [ documentWatching, observed, contentResource ]), requestedFilter = useMemo(() => requestedWatching ? {
         ids: requested,
         includeCompleted: !0
-    }), [ registered, requested, contentResource ]);
+    } : void 0, [ requestedWatching, requested ]), resolved = useMemo(() => mergeResolved(documents.resolved, explicit.resolved), [ documents.resolved, explicit.resolved ]);
     return {
-        watching: watching,
-        filter: filter,
+        documentFilter: documentFilter,
+        requestedFilter: requestedFilter,
+        loading: documents.loading || explicit.loading,
+        invalid: documents.invalid ?? explicit.invalid,
+        resolved: resolved,
+        onDocumentSnapshot: documents.onSnapshot,
+        onRequestedSnapshot: explicit.onSnapshot
+    };
+}
+
+function useDiscoveryStream(watching) {
+    const [latest, setLatest] = useState(EMPTY_SNAPSHOT), [resolved, setResolved] = useState(EMPTY_SNAPSHOT), onSnapshot = useCallback(snapshot => {
+        setLatest(snapshot), snapshot.instances !== void 0 && setResolved(snapshot);
+    }, []);
+    return useEffect(() => {
+        watching || (setLatest(EMPTY_SNAPSHOT), setResolved(EMPTY_SNAPSHOT));
+    }, [ watching ]), {
         loading: watching && latest.instances === void 0 && latest.invalid === void 0,
         invalid: watching ? latest.invalid : void 0,
         resolved: resolved,
@@ -7573,18 +8010,62 @@ function useDiscoveryState(args) {
     };
 }
 
-function indexDiscoveredInstances(args) {
-    const {instances: instances, registered: registered, contentResource: contentResource} = args, ordered = [ ...instances ].sort((a, b) => b.startedAt.localeCompare(a.startedAt)), index = /* @__PURE__ */ new Map;
-    for (const bareId of registered) {
-        const uri = gdrFromResource(contentResource, bareId), watching = ordered.filter(inst => instanceWatchesDocument(inst, uri));
-        watching.length > 0 && index.set(bareId, watching.map(inst => inst._id));
+function mergeResolved(documents, explicit) {
+    const rows = [ ...documents.instances ?? [], ...explicit.instances ?? [] ], freshest = /* @__PURE__ */ new Map;
+    for (const instance of rows) {
+        const current = freshest.get(instance._id);
+        (current === void 0 || Date.parse(instance.lastChangedAt) > Date.parse(current.lastChangedAt)) && freshest.set(instance._id, instance);
     }
+    return {
+        instances: documents.instances === void 0 && explicit.instances === void 0 ? void 0 : [ ...freshest.values() ],
+        invalid: documents.invalid ?? explicit.invalid,
+        registered: documents.registered
+    };
+}
+
+function createDiscoveryIndexer(deriveWatchSet = subscriptionDocumentsForInstance) {
+    const cached = /* @__PURE__ */ new Map;
+    return {
+        index(args) {
+            const liveIds = new Set(args.instances.map(instance => instance._id));
+            for (const id of cached.keys()) liveIds.has(id) || cached.delete(id);
+            const watchedById = /* @__PURE__ */ new Map;
+            for (const instance of args.instances) {
+                let row = cached.get(instance._id);
+                row?.source !== instance && (row = {
+                    source: instance,
+                    globalDocumentIds: [ ...new Set(deriveWatchSet(instance).documents.map(document => document.globalDocumentId)) ]
+                }, cached.set(instance._id, row)), watchedById.set(instance._id, row.globalDocumentIds);
+            }
+            return buildDiscoveryIndex(args, watchedById);
+        }
+    };
+}
+
+function buildDiscoveryIndex(args, watchedById) {
+    const {instances: instances, registered: registered, contentResource: contentResource} = args, ordered = [ ...instances ].sort((a, b) => b.startedAt.localeCompare(a.startedAt)), index = /* @__PURE__ */ new Map, registeredByUri = new Map(registered.map(bareId => [ gdrFromResource(contentResource, bareId), bareId ]));
+    for (const instance of ordered) appendInstanceWatches({
+        index: index,
+        registeredByUri: registeredByUri,
+        instanceId: instance._id,
+        watched: watchedById.get(instance._id) ?? []
+    });
     return {
         instances: new Map(ordered.map(inst => [ inst._id, inst ])),
         index: index
     };
 }
 
+function appendInstanceWatches(args) {
+    const {index: index, registeredByUri: registeredByUri, instanceId: instanceId, watched: watched} = args;
+    for (const uri of watched) {
+        const bareId = registeredByUri.get(uri);
+        if (bareId === void 0) continue;
+        const ids = index.get(bareId);
+        ids === void 0 ? index.set(bareId, [ instanceId ]) : ids.push(instanceId);
+    }
+}
+
 function sameInstance(a, b) {
     return a === b || a._id === b._id && a._rev === b._rev;
 }
@@ -7608,7 +8089,7 @@ function entryOf(inst, report) {
         instance: report?.evaluation?.instance ?? inst,
         committed: inst,
         evaluation: report?.evaluation,
-        ready: report?.ready ?? !1,
+        ready: report?.ready ?? terminalState(inst) !== "in-flight",
         invalid: report?.invalid,
         guards: report?.guards
     };
@@ -7701,7 +8182,19 @@ function createEntriesStore() {
     };
 }
 
-const notReady = (..._args) => Promise.reject(new Error("workflow session not ready yet"));
+function sessionPlan(args) {
+    const demandedIds = new Set(args.demanded), evaluated = [ ...args.discovered.values() ].filter(inst => demandedIds.has(inst._id));
+    return {
+        evaluated: evaluated,
+        guardScope: evaluated.map(inst => inst._id).sort()
+    };
+}
+
+function useDefaultLayout(props) {
+    return useMemo(() => props.renderDefault(props), [ props ]);
+}
+
+const notReady = (..._args) => Promise.reject(new Error("workflow session not ready yet")), NO_REGISTERED_DOCUMENTS = [], DEMAND_RELEASE_GRACE_MS = 500;
 
 function workspaceParts(config) {
     if (!config.projectId || !config.dataset) throw new Error("workflow plugin requires a workspace with projectId and dataset");
@@ -7729,10 +8222,11 @@ class InstanceEvaluatorBoundary extends Component {
 }
 
 function InstanceEvaluator(props) {
-    const {engine: engine, instanceId: instanceId, grantsFromPath: grantsFromPath, onReport: onReport} = props, {evaluation: evaluation, ready: ready, invalid: invalid, guards: guards, fireAction: fireAction, editField: editField, previewField: previewField, discardFieldPreview: discardFieldPreview} = useWorkflowSession({
+    const {engine: engine, instanceId: instanceId, grantsFromPath: grantsFromPath, guardScope: guardScope, onReport: onReport} = props, {evaluation: evaluation, ready: ready, invalid: invalid, guards: guards, fireAction: fireAction, editField: editField, previewField: previewField, discardFieldPreview: discardFieldPreview} = useWorkflowSession({
         engine: engine,
         instanceId: instanceId,
-        grantsFromPath: grantsFromPath
+        grantsFromPath: grantsFromPath,
+        guardScope: guardScope
     });
     return useEffect(() => {
         onReport(instanceId, {
@@ -7775,9 +8269,9 @@ function engineOptionsFrom(config) {
 }
 
 function WorkflowProvider(props) {
-    const {config: config} = props, studioClient = useClient({
+    const {config: config} = props, defaultLayout = useDefaultLayout(props), studioClient = useClient({
         apiVersion: WORKFLOW_API_VERSION
-    }), schema = useSchema(), {name: workspaceName} = useWorkspace(), {projectId: projectId, dataset: contentDataset} = workspaceParts(studioClient.config()), workflowDataset = config.workflowDataset ?? contentDataset, binding = useMemo(() => ({
+    }), schema = useSchema(), {projectId: projectId, dataset: contentDataset} = workspaceParts(studioClient.config()), workflowDataset = config.workflowDataset ?? contentDataset, binding = useMemo(() => ({
         engineResource: {
             type: "dataset",
             id: `${projectId}.${workflowDataset}`
@@ -7795,11 +8289,19 @@ function WorkflowProvider(props) {
     }), grantsFromPath = aclPathForResource({
         type: "dataset",
         id: `${projectId}.${workflowDataset}`
-    }), {ids: registered, acquire: register, release: unregister} = useRefcountedIds(), {ids: requested, acquire: requestInstance, release: releaseInstance} = useRefcountedIds(), [seeded, setSeeded] = useState(/* @__PURE__ */ new Map), seedInstance = useCallback(instance => {
+    }), {ids: registered, acquire: registerActive, release: unregisterActive} = useRefcountedIds(), {ids: observed, acquire: retainRegistration, release: releaseRegistration} = useRefcountedIds({
+        releaseDelayMs: DEMAND_RELEASE_GRACE_MS
+    }), register = useCallback(id => {
+        registerActive(id), retainRegistration(id);
+    }, [ registerActive, retainRegistration ]), unregister = useCallback(id => {
+        unregisterActive(id), releaseRegistration(id);
+    }, [ unregisterActive, releaseRegistration ]), {ids: requested, acquire: requestInstance, release: releaseInstance} = useRefcountedIds(), {ids: evaluationDemand, acquire: requestEvaluation, release: releaseEvaluation} = useRefcountedIds({
+        releaseDelayMs: DEMAND_RELEASE_GRACE_MS
+    }), [seeded, setSeeded] = useState(/* @__PURE__ */ new Map), seedInstance = useCallback(instance => {
         setSeeded(prev => new Map(prev).set(instance._id, instance));
     }, []), [startRequest2, setStartRequest] = useState(void 0), openStartDialog = useCallback(r => setStartRequest(r), []), closeStartDialog = useCallback(() => setStartRequest(void 0), []), [entriesStore] = useState(createEntriesStore);
     useEffect(() => () => entriesStore.dispose(), [ entriesStore ]);
-    const onReport = useCallback((instanceId, report) => {
+    const previewStore = useDocumentPreviewStore(), actualTypes = useMemo(() => createActualTypeProbeStore(previewStore), [ previewStore ]), onReport = useCallback((instanceId, report) => {
         entriesStore.report(instanceId, report);
     }, [ entriesStore ]), drainRef = useRef(void 0), drainCommitted = useCallback(async instanceId => {
         try {
@@ -7846,15 +8348,18 @@ function WorkflowProvider(props) {
         });
     }, [ engine ]);
     drainRef.current = drainEffectsFor;
-    const {watching: watching, filter: filter, loading: loading, invalid: discoveryInvalid, resolved: resolved, onSnapshot: onSnapshot} = useDiscoveryState({
-        registered: registered,
+    const {documentFilter: documentFilter, requestedFilter: requestedFilter, loading: loading, invalid: discoveryInvalid, resolved: resolved, onDocumentSnapshot: onDocumentSnapshot, onRequestedSnapshot: onRequestedSnapshot} = useDiscoveryState({
+        observed: observed,
         requested: requested,
         contentResource: binding.contentResource
-    }), {instances: discovered, index: docIndex} = useMemo(() => indexDiscoveredInstances({
+    }), discoveryIndexer = useMemo(createDiscoveryIndexer, []), {instances: discovered, index: docIndex} = useMemo(() => discoveryIndexer.index({
         instances: resolved.instances ?? [],
         registered: resolved.registered,
         contentResource: binding.contentResource
-    }), [ resolved, binding.contentResource ]), resolvedDocs = useMemo(() => new Set(resolved.registered), [ resolved.registered ]);
+    }), [ discoveryIndexer, resolved, binding.contentResource ]), {evaluated: evaluated, guardScope: guardScope} = useMemo(() => sessionPlan({
+        discovered: discovered,
+        demanded: evaluationDemand
+    }), [ discovered, evaluationDemand ]), resolvedDocs = useMemo(() => new Set(resolved.registered), [ resolved.registered ]);
     useEffect(() => {
         setSeeded(prev => {
             const kept = [ ...prev ].filter(([id]) => !discovered.has(id));
@@ -7867,22 +8372,23 @@ function WorkflowProvider(props) {
             docIndex: docIndex
         });
     }, [ entriesStore, seeded, discovered, docIndex ]);
-    const isDocResolved = useCallback(docId => resolvedDocs.has(docId), [ resolvedDocs ]), schemaContentTypes = useMemo(() => new Set(contentDocumentTypes(schema)), [ schema ]), {issues: issues, starts: starts, fields: fields, latestVersions: latestVersions, autoStartByType: autoStartByType, autoStartDefinitions: autoStartDefinitions} = useDeployedDefinitions({
+    const isDocResolved = useCallback(docId => resolvedDocs.has(docId), [ resolvedDocs ]), schemaContentTypes = useMemo(() => new Set(contentDocumentTypes(schema)), [ schema ]), {mappings: mappings, issues: issues, starts: starts, fields: fields, latestVersions: latestVersions, autoStartByType: autoStartByType, autoStartDefinitions: autoStartDefinitions} = useDeployedDefinitions({
         engine: engine,
-        mappings: config.mappings,
+        overrides: config.mappings,
         contentResource: binding.contentResource,
         schemaContentTypes: schemaContentTypes,
         startRequest: startRequest2,
-        autoStart: config.autoStart,
-        schema: schema,
-        workspaceName: workspaceName
+        schema: schema
     }), value = useMemo(() => ({
         register: register,
         unregister: unregister,
         isDocResolved: isDocResolved,
         entries: entriesStore,
+        actualTypes: actualTypes,
         requestInstance: requestInstance,
         releaseInstance: releaseInstance,
+        requestEvaluation: requestEvaluation,
+        releaseEvaluation: releaseEvaluation,
         seedInstance: seedInstance,
         openStartDialog: openStartDialog,
         closeStartDialog: closeStartDialog,
@@ -7897,7 +8403,7 @@ function WorkflowProvider(props) {
         completeEffectFor: completeEffectFor,
         engine: engine,
         binding: binding,
-        mappings: config.mappings,
+        mappings: mappings,
         mappingIssues: issues,
         mappingStarts: starts,
         mappingFields: fields,
@@ -7905,24 +8411,30 @@ function WorkflowProvider(props) {
         effectHandlers: engine.effectHandlers,
         autoStartByType: autoStartByType,
         autoStartDefinitions: autoStartDefinitions
-    }), [ register, unregister, isDocResolved, entriesStore, requestInstance, releaseInstance, seedInstance, openStartDialog, closeStartDialog, startRequest2, loading, discoveryInvalid, fireActionFor, editFieldFor, previewFieldFor, discardFieldPreviewFor, drainEffectsFor, completeEffectFor, engine, binding, config.mappings, issues, starts, latestVersions, autoStartByType, autoStartDefinitions ]);
+    }), [ register, unregister, isDocResolved, entriesStore, actualTypes, requestInstance, releaseInstance, requestEvaluation, releaseEvaluation, seedInstance, openStartDialog, closeStartDialog, startRequest2, loading, discoveryInvalid, fireActionFor, editFieldFor, previewFieldFor, discardFieldPreviewFor, drainEffectsFor, completeEffectFor, engine, binding, mappings, issues, starts, fields, latestVersions, autoStartByType, autoStartDefinitions ]);
     /* @__PURE__ */
     return jsxs(WorkflowContext.Provider, {
         value: value,
-        children: [ watching ? /* @__PURE__ */ jsx(DiscoverySubscription, {
+        children: [ documentFilter ? /* @__PURE__ */ jsx(DiscoverySubscription, {
             engine: engine,
-            filter: filter,
-            onSnapshot: onSnapshot,
+            filter: documentFilter,
+            onSnapshot: onDocumentSnapshot,
             registered: registered
-        }) : null, [ ...discovered.values() ].map(inst => /* @__PURE__ */ jsx(InstanceEvaluatorBoundary, {
+        }) : null, requestedFilter ? /* @__PURE__ */ jsx(DiscoverySubscription, {
+            engine: engine,
+            filter: requestedFilter,
+            onSnapshot: onRequestedSnapshot,
+            registered: NO_REGISTERED_DOCUMENTS
+        }) : null, evaluated.map(inst => /* @__PURE__ */ jsx(InstanceEvaluatorBoundary, {
             instanceId: inst._id,
             children: /* @__PURE__ */ jsx(InstanceEvaluator, {
                 engine: engine,
                 grantsFromPath: grantsFromPath,
+                guardScope: guardScope,
                 instanceId: inst._id,
                 onReport: onReport
             })
-        }, inst._id)), props.renderDefault(props), props.overlay ]
+        }, inst._id)), defaultLayout, props.overlay ]
     });
 }
 
@@ -7932,14 +8444,25 @@ function sameEntries(a, b) {
     return !0;
 }
 
+function sameMappings(a, b) {
+    return a.length === b.length && a.every((mapping, index) => {
+        const other = b[index];
+        return other !== void 0 && mappingKey(mapping) === mappingKey(other) && mapping.label === other.label && mapping.autoStart === other.autoStart && mapping.initialStateBuilder === other.initialStateBuilder && mapping.contextBuilder === other.contextBuilder && mapping.perspectiveField === other.perspectiveField;
+    });
+}
+
 function useDeployedDefinitions(args) {
-    const {engine: engine, mappings: mappings, contentResource: contentResource, schemaContentTypes: schemaContentTypes, startRequest: startRequest2, autoStart: autoStart, schema: schema, workspaceName: workspaceName} = args, [issues, setIssues] = useState(/* @__PURE__ */ new Map), [starts, setStarts] = useState(/* @__PURE__ */ new Map), [fields, setFields] = useState(/* @__PURE__ */ new Map), [latestVersions, setLatestVersions] = useState(/* @__PURE__ */ new Map), [autoStartByType, setAutoStartByType] = useState(
+    const {engine: engine, overrides: overrides, contentResource: contentResource, schemaContentTypes: schemaContentTypes, startRequest: startRequest2, schema: schema} = args, [mappings, setMappings] = useState([]), [issues, setIssues] = useState(/* @__PURE__ */ new Map), [starts, setStarts] = useState(/* @__PURE__ */ new Map), [fields, setFields] = useState(/* @__PURE__ */ new Map), [latestVersions, setLatestVersions] = useState(/* @__PURE__ */ new Map), [autoStartByType, setAutoStartByType] = useState(
     /* @__PURE__ */ new Map), [autoStartDefinitions, setAutoStartDefinitions] = useState(/* @__PURE__ */ new Map), logged = useRef(/* @__PURE__ */ new Set);
     return useEffect(() => {
         let cancelled = !1;
         return (async () => {
-            const definitions = await readDeployedDefinitions(engine), found = mappingIssues({
-                mappings: mappings,
+            const definitions = await readDeployedDefinitions(engine), effectiveMappings = discoverWorkflowMappings({
+                definitions: definitions,
+                schemaContentTypes: schemaContentTypes,
+                overrides: overrides
+            }), found = mappingIssues({
+                mappings: effectiveMappings,
                 definitions: definitions,
                 contentResource: contentResource,
                 schemaContentTypes: schemaContentTypes
@@ -7949,32 +8472,30 @@ function useDeployedDefinitions(args) {
                 logged.current.has(signature) || (logged.current.add(signature), console.error(`[workflow-studio-plugin] ${message}`));
             }
             const resolvedAutoStart = resolveAutoStart({
-                autoStart: autoStart,
-                context: {
-                    workspaceName: workspaceName,
-                    schema: schema
-                },
+                autoStart: mappingAutoStartMap(effectiveMappings),
                 knownDocTypes: new Set(schema.getTypeNames()),
                 definitions: definitions
             });
             if (logOnce(resolvedAutoStart.warnings, logged.current), cancelled) return;
+            setMappings(prev => sameMappings(prev, effectiveMappings) ? prev : effectiveMappings), 
             setIssues(prev => sameEntries(prev, found) ? prev : found), setStarts(mappingStartBlocks({
-                mappings: mappings,
+                mappings: effectiveMappings,
                 definitions: definitions
             })), setFields(mappingDeclaredFields({
-                mappings: mappings,
+                mappings: effectiveMappings,
                 definitions: definitions
             }));
             const versions = new Map(latestDeployedDefinitions(definitions).map(d => [ d.name, d.version ]));
             setLatestVersions(prev => sameEntries(prev, versions) ? prev : versions), setAutoStartByType(resolvedAutoStart.byType), 
             setAutoStartDefinitions(resolvedAutoStart.definitions);
         })().catch(err => {
-            console.error("[workflow-studio-plugin] mapping validation could not read the deployed definitions — keeping the previous verdicts:", err);
+            console.error("[workflow-studio-plugin] mapping discovery failed — keeping the last resolved workflow state:", err);
         }), () => {
             cancelled = !0;
         };
-    }, [ engine, mappings, contentResource, schemaContentTypes, startRequest2, autoStart, schema, workspaceName ]), 
+    }, [ engine, overrides, contentResource, schemaContentTypes, startRequest2, schema ]), 
     {
+        mappings: mappings,
         issues: issues,
         starts: starts,
         fields: fields,
@@ -8363,12 +8884,12 @@ function DocRefsFieldInput({entry: entry, mappedType: mappedType, value: value,
 }
 
 function NotesStartInput({onChange: onChange}) {
-    const me = useCurrentUser(), [body, setBody] = useState(""), update = next => {
+    const selfActor = useSelfActor(), [body, setBody] = useState(""), update = next => {
         setBody(next);
         const trimmed = next.trim();
         onChange(trimmed === "" ? [] : [ noteRow({
             body: trimmed,
-            actor: me ? personActor(me) : void 0,
+            actor: selfActor,
             at: /* @__PURE__ */ (new Date).toISOString()
         }) ]);
     };
@@ -8577,7 +9098,7 @@ function handleStartError(args) {
         toast.push({
             status: "warning",
             title: `${label} can't be started right now`,
-            description: "The workflow does not allow another run with these inputs."
+            description: outcome.description
         });
         return;
     }
@@ -8589,7 +9110,7 @@ function handleStartError(args) {
 }
 
 function StartWorkflowForm({request: request, onClose: onClose}) {
-    const {definition: definitionName, label: label, mapping: mapping, subjectDocId: subjectDocId} = request, {engine: engine, binding: binding, seedInstance: seedInstance} = useWorkflowContext(), toast = useClosableToast(), {def: definition, error: definitionError} = useLatestDefinition(definitionName), {selectedReleaseId: selectedReleaseId} = usePerspective(), releaseId = boundReleaseId(mapping, selectedReleaseId), [values, setValues] = useState({}), [attempt, setAttempt] = useState(void 0), starting = attempt !== void 0, [heldInstanceId, setHeldInstanceId] = useState(void 0), [startNew, setStartNew] = useState(!1), {entries: entries} = useWorkflowsForDocument(subjectDocId), resumeEntry = presentedResumeEntry({
+    const {definition: definitionName, label: label, mapping: mapping, subjectDocId: subjectDocId} = request, {engine: engine, binding: binding, seedInstance: seedInstance} = useWorkflowContext(), telemetry = useWorkflowTelemetry(), toast = useClosableToast(), {def: definition, error: definitionError} = useLatestDefinition(definitionName), {selectedReleaseId: selectedReleaseId} = usePerspective(), releaseId = boundReleaseId(mapping, selectedReleaseId), [values, setValues] = useState({}), [attempt, setAttempt] = useState(void 0), starting = attempt !== void 0, [heldInstanceId, setHeldInstanceId] = useState(void 0), [startNew, setStartNew] = useState(!1), {entries: entries} = useWorkflowsForDocument(subjectDocId), resumeEntry = presentedResumeEntry({
         entries: entries,
         definitionName: definitionName,
         heldInstanceId: heldInstanceId,
@@ -8612,7 +9133,10 @@ function StartWorkflowForm({request: request, onClose: onClose}) {
             [name]: v
         })), heldInstanceId !== void 0 && declineResume();
     }, onStart = async () => {
-        setAttempt({
+        telemetry.log(WorkflowStartDialogSubmitted, {
+            source: request.source,
+            resumed: resuming
+        }), setAttempt({
             resume: resumeEntry
         });
         const instanceId = resumeEntry?.instance._id ?? heldInstanceId ?? instanceDocId(binding.tag);
@@ -8692,8 +9216,9 @@ function StartWorkflowForm({request: request, onClose: onClose}) {
 }
 
 function StartWorkflowDialog({request: request, onClose: onClose}) {
-    /* @__PURE__ */
-    return jsx(Dialog, {
+    return useLogEventOnMount(WorkflowStartDialogOpened, {
+        source: request.source
+    }), /* @__PURE__ */ jsx(Dialog, {
         header: `Start ${request.label}`,
         id: "start-workflow",
         onClose: onClose,
@@ -8760,7 +9285,7 @@ function isFreshDocument(value) {
 }
 
 function subjectEntry(definition) {
-    return (definition.fields ?? []).find(isSubjectEntry);
+    return documentSubjectEntry(definition);
 }
 
 function autoStartInputs(args) {
@@ -8787,11 +9312,11 @@ function pendingWorkflows(workflows, live) {
 }
 
 function extraRequiredInputs(definition) {
-    const fields = definition.fields ?? [], subjectNames = new Set(fields.filter(isSubjectEntry).map(entry => entry.name)), requiredNames = new Set(missingRequiredInputs({
+    const fields = definition.fields ?? [], subjectName = subjectEntry(definition)?.name, requiredNames = new Set(missingRequiredInputs({
         entryDefs: fields,
         initialFields: []
     }).map(input => input.name));
-    return fields.filter(entry => requiredNames.has(entry.name) && !subjectNames.has(entry.name));
+    return fields.filter(entry => requiredNames.has(entry.name) && entry.name !== subjectName);
 }
 
 function buildAutoStartRequests(args) {
@@ -8832,21 +9357,21 @@ function AutoStartGate(props) {
 }
 
 function AutoStartDriver(props) {
-    const {rawDocId: rawDocId, docType: docType, workflows: workflows, value: value, fallback: fallback} = props, {isDocResolved: isDocResolved, autoStartDefinitions: autoStartDefinitions, engine: engine, binding: binding, seedInstance: seedInstance} = useWorkflowContext(), observer = useStudioObserver({
+    const {rawDocId: rawDocId, docType: docType, workflows: workflows, value: value, fallback: fallback} = props, {isDocResolved: isDocResolved, autoStartDefinitions: autoStartDefinitions, engine: engine, binding: binding, seedInstance: seedInstance} = useWorkflowContext(), telemetry = useWorkflowTelemetry(), observer = useStudioObserver({
         engine: engine
     }), {selectedReleaseId: selectedReleaseId} = usePerspective(), {entries: entries} = useWorkflowsForDocument(rawDocId), docId = getPublishedId(rawDocId), valueRef = useRef(value);
     valueRef.current = value;
     const pending = useMemo(() => pendingWorkflows(workflows, new Set(entries.map(entry => entry.instance.definition))), [ workflows, entries ]), inputs = useMemo(() => autoStartInputs({
         workflows: pending,
         definitions: autoStartDefinitions
-    }), [ pending, autoStartDefinitions ]), pendingRef = useRef(pending);
+    }), [ pending, autoStartDefinitions ]), definitionsResolved = workflows.every(name => autoStartDefinitions.has(name)), pendingRef = useRef(pending);
     pendingRef.current = pending;
     const instanceIds = useRef(/* @__PURE__ */ new Map), instanceIdFor = useCallback(workflow => {
         const held = instanceIds.current.get(workflow);
         if (held !== void 0) return held;
         const id = instanceDocId(binding.tag);
         return instanceIds.current.set(workflow, id), id;
-    }, [ binding.tag ]), [fired, setFired] = useState(!1), [settled, setSettled] = useState(!1), [failure, setFailure] = useState(void 0), firedRef = useRef(!1), startAll = useCallback(async values => {
+    }, [ binding.tag ]), [fired, setFired] = useState(!1), [settled, setSettled] = useState(!1), [failure, setFailure] = useState(void 0), firedRef = useRef(!1), startAll = useCallback(async (values, mode) => {
         if (!firedRef.current) {
             firedRef.current = !0, setFired(!0);
             try {
@@ -8858,20 +9383,25 @@ function AutoStartDriver(props) {
                         releaseId: selectedReleaseId
                     } : {}
                 });
+                const requests = buildAutoStartRequests({
+                    workflows: pendingRef.current,
+                    definitions: autoStartDefinitions,
+                    subject: {
+                        docId: docId,
+                        type: docType
+                    },
+                    contentResource: binding.contentResource,
+                    values: values,
+                    instanceIdFor: instanceIdFor
+                });
+                telemetry.log(WorkflowAutoStartRan, {
+                    mode: mode,
+                    workflowCount: requests.length
+                });
                 const {failure: failure2} = await runStarts({
                     engine: engine,
                     seed: seedInstance,
-                    requests: buildAutoStartRequests({
-                        workflows: pendingRef.current,
-                        definitions: autoStartDefinitions,
-                        subject: {
-                            docId: docId,
-                            type: docType
-                        },
-                        contentResource: binding.contentResource,
-                        values: values,
-                        instanceIdFor: instanceIdFor
-                    })
+                    requests: requests
                 });
                 failure2 !== void 0 && setFailure(failure2);
             } catch (err) {
@@ -8880,17 +9410,17 @@ function AutoStartDriver(props) {
                 setSettled(!0);
             }
         }
-    }, [ autoStartDefinitions, docId, docType, binding, engine, observer, seedInstance, instanceIdFor, selectedReleaseId ]), retry = useCallback(() => {
+    }, [ autoStartDefinitions, docId, docType, binding, engine, observer, seedInstance, instanceIdFor, selectedReleaseId, telemetry ]), retry = useCallback(() => {
         firedRef.current = !1, setFired(!1), setSettled(!1), setFailure(void 0);
     }, []), action = autoStartAction({
-        resolved: isDocResolved(docId),
+        resolved: definitionsResolved && isDocResolved(docId),
         pendingCount: pending.length,
         needsInput: inputs.length > 0,
         fired: fired,
         settled: settled
     });
     return useEffect(() => {
-        action === "silent-start" && startAll({});
+        action === "silent-start" && startAll({}, "silent");
     }, [ action, startAll ]), failure !== void 0 ? /* @__PURE__ */ jsx(AutoStartFailure, {
         message: failure,
         onProceed: () => setFailure(void 0),
@@ -8902,7 +9432,7 @@ function AutoStartDriver(props) {
             docType: docType,
             inputs: inputs,
             onStart: values => {
-                startAll(values);
+                startAll(values, "collect");
             },
             starting: fired,
             workflowCount: pending.length
@@ -9124,7 +9654,9 @@ function finishedLinesOf(entries) {
 }
 
 function WorkflowFormStrip(props) {
-    const {mappings: mappings} = props, {isDocResolved: isDocResolved, discoveryInvalid: discoveryInvalid} = useWorkflowContext(), {docId: docId, entries: entries} = useWorkflowsForDocument(props.value?._id ?? null), {params: params, setParams: setParams} = usePaneRouter(), openWorkflowsView = focusId => setParams(focusedViewParams(params, focusId)), active = entries.filter(isLiveEntry), finished = finishedLinesOf(entries), invalid = surfacedInvalid(discoveryInvalid, entries), resolved = docId !== void 0 && isDocResolved(docId);
+    const {mappings: mappings} = props, {isDocResolved: isDocResolved, discoveryInvalid: discoveryInvalid} = useWorkflowContext(), {docId: docId, entries: entries} = useWorkflowsForDocument(props.value?._id ?? null), {params: params, setParams: setParams} = usePaneRouter(), telemetry = useWorkflowTelemetry(), openWorkflowsView = focusId => {
+        telemetry.log(WorkflowFormStripClicked), setParams(focusedViewParams(params, focusId));
+    }, active = entries.filter(isLiveEntry), finished = finishedLinesOf(entries), invalid = surfacedInvalid(discoveryInvalid, entries), resolved = docId !== void 0 && isDocResolved(docId);
     /* @__PURE__ */
     return jsxs(Stack, {
         gap: 4,
@@ -9158,7 +9690,8 @@ function StripLines({active: active, docId: docId, finished: finished, initialVa
                 initialValue: initialValue,
                 label: "Start workflow",
                 mappings: mappings,
-                mode: "bleed"
+                mode: "bleed",
+                source: "form-strip"
             })
         }) : null ]
     });
@@ -9305,6 +9838,61 @@ function TaskCountSpinner({entry: entry}) {
     });
 }
 
+function stagePillState(instance) {
+    const definition = definitionSnapshotOf(instance), stage = definition?.stages.find(candidate => candidate.name === instance.currentStage), state = terminalState(instance);
+    return {
+        title: stageTitle(definition, instance.currentStage),
+        terminal: stage !== void 0 && isTerminalStage(stage) || state !== "in-flight",
+        state: state,
+        stageKnown: stage !== void 0
+    };
+}
+
+function WorkflowStagePreview(props) {
+    const {mappings: mappings} = useWorkflowContext(), mapped = props.schemaType !== void 0 && mappingsForDocType(mappings, props.schemaType.name).length > 0, {entries: entries} = useCommittedWorkflowsForDocument(mapped ? props._id ?? null : null), lead = entries.find(isLiveEntry) ?? entries[0], extraLive = entries.filter(e => e !== lead && isLiveEntry(e)).length;
+    return props.renderDefault({
+        ...props,
+        status: lead ? /* @__PURE__ */ jsx(StagePill, {
+            entry: lead,
+            extraLive: extraLive
+        }) : props.status
+    });
+}
+
+function StagePill({entry: entry, extraLive: extraLive}) {
+    /* @__PURE__ */
+    return jsxs(Flex, {
+        align: "center",
+        gap: 2,
+        children: [ 
+        /* @__PURE__ */ jsx(LeadBadge, {
+            entry: entry
+        }), extraLive > 0 ? /* @__PURE__ */ jsxs(Badge, {
+            fontSize: 1,
+            mode: "outline",
+            tone: "default",
+            children: [ "+", extraLive ]
+        }) : null ]
+    });
+}
+
+function LeadBadge({entry: entry}) {
+    const {instance: instance} = entry;
+    if (isUnprimed(instance)) /* @__PURE__ */ return jsx(StartIncompleteBadge, {});
+    const pill = stagePillState(instance);
+    /* @__PURE__ */
+    return jsxs(Badge, {
+        fontSize: 1,
+        mode: pill.terminal ? "default" : "outline",
+        tone: pillTone(pill),
+        children: [ pill.title, pill.state === "completed" ? " ✓" : "" ]
+    });
+}
+
+function pillTone(args) {
+    return args.state === "aborted" ? "critical" : args.terminal ? "positive" : args.stageKnown ? "primary" : "default";
+}
+
 function StartWorkflowDialogHost() {
     const {startRequest: startRequest2, closeStartDialog: closeStartDialog} = useWorkflowContext();
     return startRequest2 ? /* @__PURE__ */ jsx(StartWorkflowDialog, {
@@ -9377,7 +9965,8 @@ function withWorkflowLock(Action, guardAction) {
     Locked;
 }
 
-const workflowStudioPlugin = definePlugin(config => ({
+const workflowStudioPlugin = definePlugin(config => (assertUniqueWorkflowMappings(config.mappings ?? []), 
+{
     name: "workflow-studio-plugin",
     tools: prev => [ ...prev, workflowsTool ],
     studio: {
@@ -9391,82 +9980,35 @@ const workflowStudioPlugin = definePlugin(config => ({
     },
     form: {
         components: {
-            input: props => {
-                if (props.id === "root" && isObjectInputProps(props)) {
-                    const docTypeMappings = mappingsForDocType(config.mappings, props.schemaType.name), fallback = docTypeMappings.length > 0 ? /* @__PURE__ */ jsx(WorkflowFormStrip, {
-                        ...props,
-                        mappings: docTypeMappings
-                    }) : props.renderDefault(props);
-                    /* @__PURE__ */
-                    return jsx(AutoStartGate, {
-                        ...props,
-                        fallback: fallback
-                    });
-                }
-                return props.renderDefault(props);
-            }
+            preview: WorkflowStagePreview,
+            input: props => props.id === "root" && isObjectInputProps(props) ? /* @__PURE__ */ jsx(WorkflowRootInput, {
+                ...props
+            }) : props.renderDefault(props)
         }
     },
     document: {
         badges: (prev, ctx) => {
-            if (!mappingForDocType(config.mappings, ctx.schemaType) || !ctx.documentId) return prev;
+            if (!ctx.documentId) return prev;
             const docId = ctx.documentId;
             return [ makeActiveWorkflowsBadge(docId), makePerspectiveBadge(docId), ...prev ];
         },
-        actions: (prev, ctx) => mappingForDocType(config.mappings, ctx.schemaType) ? prev.map(Action => {
+        actions: prev => prev.map(Action => {
             const guardAction = Action.action ? LOCKABLE_ACTIONS.get(Action.action) : void 0;
             return guardAction ? withWorkflowLock(Action, guardAction) : Action;
-        }) : prev
+        })
     }
 }));
 
-function WorkflowStagePreview(props) {
-    const {entries: entries} = useWorkflowsForDocument(props.documentId ?? props._id ?? null), lead = entries.find(isLiveEntry) ?? entries[0], extraLive = entries.filter(e => e !== lead && isLiveEntry(e)).length;
-    return props.renderDefault({
+function WorkflowRootInput(props) {
+    const {mappings: mappings} = useWorkflowContext(), docTypeMappings = mappingsForDocType(mappings, props.schemaType.name), fallback = docTypeMappings.length > 0 ? /* @__PURE__ */ jsx(WorkflowFormStrip, {
         ...props,
-        status: lead ? /* @__PURE__ */ jsx(StagePill, {
-            entry: lead,
-            extraLive: extraLive
-        }) : props.status
-    });
-}
-
-function StagePill({entry: entry, extraLive: extraLive}) {
+        mappings: docTypeMappings
+    }) : props.renderDefault(props);
     /* @__PURE__ */
-    return jsxs(Flex, {
-        align: "center",
-        gap: 2,
-        children: [ 
-        /* @__PURE__ */ jsx(LeadBadge, {
-            entry: entry
-        }), extraLive > 0 ? /* @__PURE__ */ jsxs(Badge, {
-            fontSize: 1,
-            mode: "outline",
-            tone: "default",
-            children: [ "+", extraLive ]
-        }) : null ]
-    });
-}
-
-function LeadBadge({entry: entry}) {
-    const {instance: instance, evaluation: evaluation} = entry;
-    if (isUnprimed(instance)) /* @__PURE__ */ return jsx(StartIncompleteBadge, {});
-    const stage = evaluation?.currentStage?.stage, title = stage?.title ?? stageTitle(definitionSnapshotOf(instance), instance.currentStage), state = terminalState(instance), isTerminal = (stage ? isTerminalStage(stage) : !1) || state !== "in-flight";
-    /* @__PURE__ */
-    return jsxs(Badge, {
-        fontSize: 1,
-        mode: isTerminal ? "default" : "outline",
-        tone: pillTone({
-            state: state,
-            isTerminal: isTerminal,
-            stageKnown: stage !== void 0
-        }),
-        children: [ title, state === "completed" ? " ✓" : "" ]
+    return jsx(AutoStartGate, {
+        ...props,
+        fallback: fallback
     });
 }
 
-function pillTone(args) {
-    return args.state === "aborted" ? "critical" : args.isTerminal ? "positive" : args.stageKnown ? "primary" : "default";
-}
-
-export { AbortedBadge, ActivitiesList, ActivityDetailDialog, ActivityRow, BreadcrumbTail, CollapsibleBand, DismissablePopover, DocPreviewLink, DocRefFace, GroupHeading, HoverHint, InvalidDocNotice, LinkChip, LoadingRow, StageChip, StageFace, StaleLock, TabSwitch, TodoItemsList, TrailingHairline, UnreadableDocsNote, WorkflowStagePreview, activityRowProps, assigneeUserIdsOf, committedRowFace, dateControlKind, dateControlValue, definitionSnapshotOf, describeError, editTargetOf, findActivity, findActivityNode, formatDate, gdrLocality, instanceBreadcrumb, instanceNotice, instanceTitle, isActivityAssignedTo, isEvaluationStale, isOpenActivityStatus, mappingForDocType, openActivityGone, parseDateFieldValue, parseStoredDateValue, readDeployedDefinitions, rowAssignControlState, rowDateControlState, serializeDateFieldValue, stageTitle, stateByActivity, stopRowClick, stopRowMouseDown, useAssignmentIdentity, useDefinition, useProjectMembers, useSaveField, useUserDisplays, useWorkflowContext, useWorkflowInstanceEntry, workflowDefaultDocumentNode, workflowDocTypes, workflowStudioPlugin, workflowsTabCodec, workflowsView };
+export { AbortedBadge, ActivitiesList, ActivityDetailDialog, ActivityRow, BreadcrumbTail, CautionNote, CollapsibleBand, DismissablePopover, DocPreviewLink, DocRefFace, GroupHeading, HoverHint, InvalidDocNotice, LinkChip, LoadingRow, SpinnerSlot, StageChip, StageFace, StaleLock, TabSwitch, TodoItemsList, TrailingHairline, UnreadableDocsNote, WORKFLOW_API_VERSION, WorkflowInstanceDetailViewed, WorkflowTaskFiltersApplied, WorkflowToolOpened, activityRowProps, assigneeUserIdsOf, committedRowFace, dateControlKind, dateControlValue, definitionSnapshotOf, describeError, findActivity, findActivityNode, formatDate, gdrLocality, instanceBreadcrumb, instanceNotice, instanceTitle, isActivityAssignedTo, isEvaluationStale, isOpenActivityStatus, openActivityGone, parseDateFieldValue, parseStoredDateValue, readDeployedDefinitions, rowAssignControlState, rowDateControlState, serializeDateFieldValue, stageTitle, stateByActivity, stopRowClick, stopRowMouseDown, useAssignmentIdentity, useClosableToast, useDefinition, useLogEventOnMount, useProjectMembers, useSaveField, useUserDisplays, useWorkflowContext, useWorkflowInstanceEntry, workflowDefaultDocumentNode, workflowStudioPlugin, workflowsTabCodec, workflowsView };