@tellescope/sdk 2.0.0-beta.2 → 2.0.0-beta.3

package/src/tests/api_tests/phone_tree_enduser_condition.test.ts

@@ -1,21 +1,29 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
-import {
-  assert,
-  async_test,
-  handleAnyError,
-  log_header,
-} from "@tellescope/testing"
 import { PhoneTreeNode } from "@tellescope/types-models"
-import { setup_tests } from "../setup"
+import {
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
 const SPLIT_NODE_ID = 'enduser-condition-split-node'
 const VIP_NODE_ID = 'vip-play-message-node'
 const ELSE_NODE_ID = 'else-play-message-node'
 
+/** Prefers the error's message, falling back to the raw value — JSON.stringify('') is '""' (truthy),
+ *  so a `|| fallback` on the stringified value would make the fallback unreachable. */
+const error_detail = (e: any) => (
+  typeof e?.message === 'string' && e.message !== ''
+    ? e.message
+    : (e === undefined || e === null ? String(e) : JSON.stringify(e))
+)
+
 const valid_condition_split_nodes: PhoneTreeNode[] = [
   {
     id: SPLIT_NODE_ID,
@@ -51,11 +59,38 @@ const valid_condition_split_nodes: PhoneTreeNode[] = [
   },
 ]
 
-export const phone_tree_enduser_condition_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Phone Tree Enduser Condition Split Tests")
+// Schema coverage for the Enduser Condition Split phone-tree node. Runs on its own provisioned
+// tenant so the phone trees it creates (and deletes) can never collide with another suite's.
+export const phone_tree_enduser_condition_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   const treeIds: string[] = []
+
   try {
+    tenant = await setup_isolated_tenant({
+      name: `PhoneTreeEnduserCondition ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    const expect_rejected = async (label: string, fn: () => Promise<any>) => {
+      try {
+        const unexpected = await fn()
+        record(
+          label,
+          false,
+          `the tree was created (result=${unexpected === undefined ? '(none)' : JSON.stringify(unexpected)});`
+          + ` it must be rejected`,
+        )
+      } catch (e: any) {
+        record(label, true, `rejected with ${error_detail(e)}`)
+      }
+    }
+
     // valid Enduser Condition Split node with On Condition Branch children saves
     const tree = await sdk.api.phone_trees.createOne({
       number: '+15005550006',
@@ -63,18 +98,22 @@ export const phone_tree_enduser_condition_tests = async ({ sdk, sdkNonAdmin } :
       nodes: valid_condition_split_nodes,
     })
     treeIds.push(tree.id)
-    assert(!!tree.id, 'failed to create tree with Enduser Condition Split', 'create tree with Enduser Condition Split')
+    record(
+      'create tree with Enduser Condition Split',
+      !!tree.id,
+      `tree id=${tree.id ? JSON.stringify(tree.id) : '(none)'}`,
+    )
 
     const loaded = await sdk.api.phone_trees.getOne(tree.id)
     const loadedSplit = loaded.nodes.find(n => n.action.type === 'Enduser Condition Split')
-    assert(
+    record(
+      'branches (conditions + catch-all) round-trip on read',
       loadedSplit?.action.type === 'Enduser Condition Split'
       && loadedSplit.action.info.branches.length === 2
       && loadedSplit.action.info.branches[0].name === 'VIP'
       && !!loadedSplit.action.info.branches[0].enduserCondition
       && loadedSplit.action.info.branches[1].enduserCondition === undefined,
-      'branches did not round-trip',
-      'branches (conditions + catch-all) round-trip on read',
+      `split node=${loadedSplit ? JSON.stringify(loadedSplit.action) : '(not found)'}`,
     )
 
     // regression: existing Conditional Split shape is unaffected
@@ -90,10 +129,14 @@ export const phone_tree_enduser_condition_tests = async ({ sdk, sdkNonAdmin } :
       }],
     })
     treeIds.push(conditionalSplitTree.id)
-    assert(!!conditionalSplitTree.id, 'failed to create Conditional Split tree', 'existing Conditional Split still saves (regression)')
+    record(
+      'existing Conditional Split still saves (regression)',
+      !!conditionalSplitTree.id,
+      `tree id=${conditionalSplitTree.id ? JSON.stringify(conditionalSplitTree.id) : '(none)'}`,
+    )
 
     // invalid: enduserCondition must be an object
-    await async_test(
+    await expect_rejected(
       "non-object enduserCondition is rejected",
       () => sdk.api.phone_trees.createOne({
         number: '+15005550006',
@@ -108,11 +151,10 @@ export const phone_tree_enduser_condition_tests = async ({ sdk, sdkNonAdmin } :
           flowchartUI: { x: 0, y: 0 },
         }],
       }).then(t => { treeIds.push(t.id); return t }), // cleanup if it unexpectedly passes
-      handleAnyError,
     )
 
     // invalid: branches must include a name
-    await async_test(
+    await expect_rejected(
       "branch without a name is rejected",
       () => sdk.api.phone_trees.createOne({
         number: '+15005550006',
@@ -127,11 +169,10 @@ export const phone_tree_enduser_condition_tests = async ({ sdk, sdkNonAdmin } :
           flowchartUI: { x: 0, y: 0 },
         }],
       }).then(t => { treeIds.push(t.id); return t }),
-      handleAnyError,
     )
 
     // invalid: On Condition Branch events must include a branch value
-    await async_test(
+    await expect_rejected(
       "On Condition Branch event without branch is rejected",
       () => sdk.api.phone_trees.createOne({
         number: '+15005550006',
@@ -142,27 +183,35 @@ export const phone_tree_enduser_condition_tests = async ({ sdk, sdkNonAdmin } :
             : { ...n, events: [{ type: 'On Condition Branch', parentId: SPLIT_NODE_ID, info: {} as any }] }
         )),
       }).then(t => { treeIds.push(t.id); return t }),
-      handleAnyError,
     )
   } finally {
-    for (const id of treeIds) {
-      await sdk.api.phone_trees.deleteOne(id).catch(console.error)
+    if (tenant) {
+      for (const id of treeIds) {
+        await tenant.sdk.api.phone_trees.deleteOne(id).catch(console.error)
+      }
+      // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
+      try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) }
     }
   }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs. */
+export const phone_tree_enduser_condition_tests = async () => {
+  assert_checks('Phone tree Enduser Condition Split', await phone_tree_enduser_condition_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Phone tree Enduser Condition Split',
+  run: phone_tree_enduser_condition_checks,
 }
 
 // Allow running this test file independently
 if (require.main === module) {
   console.log(`Using API URL: ${host}`)
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
-
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await phone_tree_enduser_condition_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  phone_tree_enduser_condition_tests()
     .then(() => {
       console.log("✅ Phone tree enduser condition test suite completed successfully")
       process.exit(0)

package/src/tests/api_tests/programs.test.ts

@@ -320,6 +320,356 @@ export const programs_checks = async (): Promise<Check[]> => {
       !conditionNonMatching.includes('condition-chf') && conditionNonMatching.includes('condition-any'),
       `tags=${JSON.stringify(conditionNonMatching)}`,
     )
+
+    /* ============ Add / Remove / Update List Item trigger actions ============ */
+
+    // '$exists' is matched by handle_enduser_field_change for ANY truthy value of the field, so this one
+    // trigger is the barrier for every mutation check below, whatever value that check writes. Without a
+    // barrier a "nothing happened" assertion would pass merely by reading before the trigger ran.
+    const MUTATION_FIELD = `ProgramMutation${RAND()}`
+    const PROGRAM = 'CHF'
+
+    await sdk.api.automation_triggers.createOne({
+      event: { type: 'Field Equals', info: { field: MUTATION_FIELD, value: '$exists' } },
+      action: { type: 'Add Tags', info: { tags: ['mutation-any'] } },
+      status: 'Active',
+      title: `Mutation barrier ${RAND()}`,
+    })
+    await sdk.api.automation_triggers.createOne({
+      event: { type: 'Field Equals', info: { field: MUTATION_FIELD, value: 'add' } },
+      action: { type: 'Add List Item', info: { field: 'programs', match: { name: PROGRAM }, values: { status: 'Active' } } },
+      status: 'Active',
+      title: `Add List Item ${RAND()}`,
+    })
+    await sdk.api.automation_triggers.createOne({
+      event: { type: 'Field Equals', info: { field: MUTATION_FIELD, value: 'status' } },
+      action: { type: 'Update List Item', info: { field: 'programs', match: { name: PROGRAM }, values: { status: 'Discharged' } } },
+      status: 'Active',
+      title: `Update List Item ${RAND()}`,
+    })
+    await sdk.api.automation_triggers.createOne({
+      // a BLANK value clears that sub-field, rather than being a no-op — the $unset half of the action
+      event: { type: 'Field Equals', info: { field: MUTATION_FIELD, value: 'clear' } },
+      action: { type: 'Update List Item', info: { field: 'programs', match: { name: PROGRAM }, values: { status: '' } } },
+      status: 'Active',
+      title: `Clear List Item status ${RAND()}`,
+    })
+    await sdk.api.automation_triggers.createOne({
+      event: { type: 'Field Equals', info: { field: MUTATION_FIELD, value: 'remove' } },
+      action: { type: 'Remove List Item', info: { field: 'programs', match: { name: PROGRAM } } },
+      status: 'Active',
+      title: `Remove List Item ${RAND()}`,
+    })
+
+    /**
+     * The sub-fields a mutation may touch are ENDUSER_LIST_FIELD_CONFIG's, checked when the trigger is
+     * SAVED (an automation_triggers constraint, sharing list_item_mutation_error with the editor).
+     *
+     * Rejecting here rather than at fire time is the point: an accepted-but-ignored key leaves a
+     * trigger that looks configured and silently never does what it says. It is also what keeps a
+     * `$`-prefixed or dotted key out of the Mongo paths the action builds from these keys.
+     */
+    const save_trigger_error = async (action: any): Promise<string> => {
+      try {
+        const created = await sdk.api.automation_triggers.createOne({
+          event: { type: 'Field Equals', info: { field: `Never${RAND()}`, value: 'never' } },
+          action, status: 'Inactive', title: `Rejected ${RAND()}`,
+        })
+        // it saved; leave nothing behind for the later checks to trip over
+        await sdk.api.automation_triggers.deleteOne(created.id)
+        return ''
+      } catch (err: any) { return err?.message ?? String(err) }
+    }
+
+    const unknownMatchKey = await save_trigger_error({
+      type: 'Add List Item', info: { field: 'programs', match: { title: PROGRAM } },
+    })
+    const unknownValueKey = await save_trigger_error({
+      type: 'Update List Item', info: { field: 'programs', match: { name: PROGRAM }, values: { deviceIds: 'x' } },
+    })
+    const operatorKey = await save_trigger_error({
+      type: 'Add List Item', info: { field: 'programs', match: { '$where': PROGRAM } },
+    })
+    const emptyMatch = await save_trigger_error({
+      type: 'Remove List Item', info: { field: 'programs', match: {} },
+    })
+    const emptyUpdate = await save_trigger_error({
+      type: 'Update List Item', info: { field: 'programs', match: { name: PROGRAM }, values: {} },
+    })
+    const unknownField = await save_trigger_error({
+      type: 'Add List Item', info: { field: 'diagnoses', match: { code: 'I50' } },
+    })
+    record(
+      'Y: a list mutation naming a sub-field (or field) outside the registry is rejected ON SAVE,'
+      + ' naming the offending key',
+      // the message, not merely "an error": the point of sharing list_item_mutation_error with the
+      // editor is that both reject the same action with the same wording, and a rejection for some
+      // unrelated reason would pass a non-empty check while proving nothing
+      unknownMatchKey.includes('title') && unknownValueKey.includes('deviceIds')
+      && operatorKey.includes('$where') && unknownField.includes('diagnoses'),
+      `match=${JSON.stringify(unknownMatchKey)} values=${JSON.stringify(unknownValueKey)}`
+      + ` operator=${JSON.stringify(operatorKey)} field=${JSON.stringify(unknownField)}`,
+    )
+    record(
+      'Z: a list mutation that matches nothing, or an Update that sets nothing, is rejected ON SAVE',
+      !!emptyMatch && !!emptyUpdate,
+      `emptyMatch=${JSON.stringify(emptyMatch)} emptyUpdate=${JSON.stringify(emptyUpdate)}`,
+    )
+
+    // every check gets its own patient: triggers are throttled to one fire per trigger per enduser per
+    // minute, so reusing one would silently swallow the second fire
+    const fire_mutation = async (value: string, programs?: EnduserProgram[]) => {
+      const enduser = await sdk.api.endusers.createOne({
+        fname: 'Programs', lname: 'Mutation', ...(programs ? { programs } : {}),
+      })
+      // an UPDATE, not a create: the mutation actions are reached through the update path, and Field
+      // Equals on programs (below) is update-only
+      await sdk.api.endusers.updateOne(enduser.id, { fields: { [MUTATION_FIELD]: value } })
+      return enduser.id
+    }
+
+    const programs_once = async (id: string, done: (p: EnduserProgram[]) => boolean, attempts?: number) => (
+      (await poll_for(() => sdk.api.endusers.getOne(id), e => done(e.programs ?? []), attempts)).programs ?? []
+    )
+
+    /**
+     * For the checks that assert NOTHING changed. The barrier tag proves trigger processing happened for
+     * this patient, but the barrier and the mutation are two triggers dispatched from one loop in
+     * whatever order the trigger page came back in, so the tag alone does not prove the mutation already
+     * ran. The extra settle closes that window; the positive checks need none of this, since they poll
+     * for their own effect.
+     */
+    const settled_enduser = async (id: string) => {
+      await poll_for(() => sdk.api.endusers.getOne(id), e => !!e.tags?.includes('mutation-any'))
+      await new Promise(resolve => setTimeout(resolve, 2000))
+      return sdk.api.endusers.getOne(id)
+    }
+
+    const addedId = await fire_mutation('add')
+    const added = await programs_once(addedId, p => p.length > 0)
+    record(
+      'M: Add List Item adds the configured program, with the status the action carries',
+      added.length === 1 && added[0].name === PROGRAM && added[0].status === 'Active',
+      `programs=${JSON.stringify(added)}`,
+    )
+
+    const duplicateId = await fire_mutation('add', [{ name: PROGRAM, status: 'Discharged' }])
+    const afterDuplicate = (await settled_enduser(duplicateId)).programs ?? []
+    record(
+      'N: Add List Item no-ops when the patient is already in that program, and does NOT reset its status',
+      afterDuplicate.length === 1
+      && afterDuplicate[0].name === PROGRAM && afterDuplicate[0].status === 'Discharged',
+      `programs=${JSON.stringify(afterDuplicate)}`,
+    )
+
+    // two entries with the same name: the drawer forbids that, but the API and integrations do not, and
+    // the action is specified to act on EVERY match rather than the first
+    const updatedId = await fire_mutation('status', [
+      { name: PROGRAM, status: 'Active' }, { name: 'Diabetes', status: 'Active' }, { name: PROGRAM },
+    ])
+    const afterUpdate = await programs_once(
+      updatedId, p => p.filter(x => x.name === PROGRAM && x.status === 'Discharged').length === 2,
+    )
+    record(
+      'O: Update List Item sets the status on EVERY entry with that name, and on no other entry',
+      afterUpdate.length === 3
+      && afterUpdate.filter(p => p.name === PROGRAM && p.status === 'Discharged').length === 2
+      && afterUpdate.find(p => p.name === 'Diabetes')?.status === 'Active',
+      `programs=${JSON.stringify(afterUpdate)}`,
+    )
+
+    // the $unset half: a blank value REMOVES the sub-field from every matching entry. Asserted by key
+    // presence, not by value: a status written as '' or null would satisfy `status === undefined` in
+    // some clients and is not what the action is specified to do.
+    const clearedId = await fire_mutation('clear', [
+      { name: PROGRAM, status: 'Active' }, { name: 'Diabetes', status: 'Active' },
+    ])
+    const afterClear = await programs_once(
+      clearedId, p => p.some(x => x.name === PROGRAM && x.status === undefined),
+    )
+    const clearedEntry = afterClear.find(p => p.name === PROGRAM)
+    record(
+      'AA: Update List Item with a blank value CLEARS that sub-field, leaving no key behind',
+      afterClear.length === 2
+      && !!clearedEntry && !('status' in clearedEntry)
+      && afterClear.find(p => p.name === 'Diabetes')?.status === 'Active',
+      `programs=${JSON.stringify(afterClear)}`
+      + ` keys=${JSON.stringify(Object.keys(clearedEntry ?? {}))}`,
+    )
+
+    const removedId = await fire_mutation('remove', [
+      { name: PROGRAM }, { name: 'Diabetes', status: 'Active' }, { name: PROGRAM, status: 'Active' },
+    ])
+    const afterRemove = await programs_once(removedId, p => !p.some(x => x.name === PROGRAM))
+    record(
+      'P: Remove List Item removes EVERY entry with that name, whatever status they hold, and nothing else',
+      afterRemove.length === 1 && afterRemove[0].name === 'Diabetes' && afterRemove[0].status === 'Active',
+      `programs=${JSON.stringify(afterRemove)}`,
+    )
+
+    const noMatchRemoveId = await fire_mutation('remove', [{ name: 'Diabetes', status: 'Active' }])
+    const noMatchUpdateId = await fire_mutation('status', [{ name: 'Diabetes', status: 'Active' }])
+    const afterNoMatchRemove = (await settled_enduser(noMatchRemoveId)).programs ?? []
+    const afterNoMatchUpdate = (await settled_enduser(noMatchUpdateId)).programs ?? []
+    record(
+      'Q: Remove and Update List Item both no-op when no entry carries that name',
+      JSON.stringify(afterNoMatchRemove) === JSON.stringify([{ name: 'Diabetes', status: 'Active' }])
+      && JSON.stringify(afterNoMatchUpdate) === JSON.stringify([{ name: 'Diabetes', status: 'Active' }]),
+      `afterRemove=${JSON.stringify(afterNoMatchRemove)} afterUpdate=${JSON.stringify(afterNoMatchUpdate)}`,
+    )
+
+    /**
+     * The status already being the target one is a no-op too, detected in the $elemMatch filter.
+     *
+     * Read this as documentation of the invariant, NOT as a regression test: rewriting an identical
+     * status leaves a byte-identical record, so this check passes with the $elemMatch reverted to a
+     * plain name match. What the filter actually prevents is an updatedAt bump, a webhook and a
+     * sync_record push, none of which are observable here — updatedAt cannot be the discriminator
+     * because the barrier Add Tags trigger writes to this same patient. The filter's positive
+     * direction, which is what a malformed $elemMatch would break, is covered by check O.
+     */
+    const alreadyDischargedId = await fire_mutation('status', [{ name: PROGRAM, status: 'Discharged' }])
+    const afterAlreadyDischarged = (await settled_enduser(alreadyDischargedId)).programs ?? []
+    record(
+      'X: Update List Item leaves an entry alone when it already carries the target status',
+      JSON.stringify(afterAlreadyDischarged) === JSON.stringify([{ name: PROGRAM, status: 'Discharged' }]),
+      `programs=${JSON.stringify(afterAlreadyDischarged)}`,
+    )
+
+    /* ============ Fields Changed on programs, and the no-cascade rule ============ */
+
+    await sdk.api.automation_triggers.createOne({
+      event: { type: 'Fields Changed', info: { fields: ['programs'] } },
+      action: { type: 'Add Tags', info: { tags: ['programs-fc'] } },
+      status: 'Active',
+      title: `Fields Changed programs ${RAND()}`,
+    })
+
+    const fieldsChangedEnduser = await sdk.api.endusers.createOne({ fname: 'Programs', lname: 'Changed' })
+    await sdk.api.endusers.updateOne(
+      fieldsChangedEnduser.id, { programs: [{ name: PROGRAM }] }, { replaceObjectFields: true },
+    )
+    const fieldsChangedTags = (await poll_for(
+      () => sdk.api.endusers.getOne(fieldsChangedEnduser.id),
+      e => !!e.tags?.includes('programs-fc'),
+    )).tags ?? []
+    record(
+      'R: a Fields Changed trigger on programs fires for a direct staff/API write',
+      fieldsChangedTags.includes('programs-fc'),
+      `tags=${JSON.stringify(fieldsChangedTags)}`,
+    )
+
+    // leaving the LAST program is the case the per-name loop has no name to push for; `programs` must
+    // still reach handle_enduser_field_change or this automation goes quiet exactly when a patient is
+    // removed from their only program
+    const emptiedEnduser = await sdk.api.endusers.createOne({
+      fname: 'Programs', lname: 'Emptied', programs: [{ name: PROGRAM, status: 'Active' }],
+    })
+    await sdk.api.endusers.updateOne(emptiedEnduser.id, { programs: [] }, { replaceObjectFields: true })
+    const emptiedTags = (await poll_for(
+      () => sdk.api.endusers.getOne(emptiedEnduser.id),
+      e => !!e.tags?.includes('programs-fc'),
+    )).tags ?? []
+    record(
+      'W: a Fields Changed trigger on programs still fires when the patient\'s LAST program is removed',
+      emptiedTags.includes('programs-fc'),
+      `tags=${JSON.stringify(emptiedTags)}`
+      + ` programs=${JSON.stringify((await sdk.api.endusers.getOne(emptiedEnduser.id)).programs)}`,
+    )
+
+    // the same trigger must NOT fire for a program written BY a trigger — handleUpdatedRecord is called
+    // with dontUseAutomationTriggers, as Set Fields and Add Tags do
+    const cascadeId = await fire_mutation('add')
+    await programs_once(cascadeId, p => p.some(x => x.name === PROGRAM)) // the trigger's write landed
+    const afterCascade = await settled_enduser(cascadeId)
+    record(
+      'S: a program written by a trigger does NOT re-fire programs automations (no cascade),'
+      + ' while trigger processing demonstrably ran for this patient',
+      !afterCascade.tags?.includes('programs-fc') && !!afterCascade.tags?.includes('mutation-any'),
+      `tags=${JSON.stringify(afterCascade.tags)} programs=${JSON.stringify(afterCascade.programs)}`,
+    )
+
+    /* ============ Field Equals on programs ============ */
+
+    await sdk.api.automation_triggers.createOne({
+      event: { type: 'Field Equals', info: { field: 'programs', value: PROGRAM } },
+      action: { type: 'Add Tags', info: { tags: ['programs-fe'] } },
+      status: 'Active',
+      title: `Field Equals programs ${RAND()}`,
+    })
+
+    const fieldEqualsTags = async (programs: EnduserProgram[], waitFor: string) => {
+      const enduser = await sdk.api.endusers.createOne({ fname: 'Programs', lname: 'FieldEquals' })
+      await sdk.api.endusers.updateOne(enduser.id, { programs }, { replaceObjectFields: true })
+      const after = await poll_for(
+        () => sdk.api.endusers.getOne(enduser.id),
+        e => !!e.tags?.includes(waitFor),
+      )
+      return after.tags ?? []
+    }
+
+    const feMatching = await fieldEqualsTags([{ name: PROGRAM, status: 'Active' }], 'programs-fe')
+    record(
+      'T: Field Equals on programs fires for a patient put into a program of that name',
+      feMatching.includes('programs-fe'),
+      `tags=${JSON.stringify(feMatching)}`,
+    )
+
+    // the Fields Changed trigger above fires for ANY programs write, so it is the barrier here
+    const feNonMatching = await fieldEqualsTags([{ name: 'Diabetes' }], 'programs-fc')
+    await new Promise(resolve => setTimeout(resolve, 2000))
+    record(
+      'U: Field Equals on programs does NOT fire for a different program name,'
+      + ' while the Fields Changed trigger on the same write still does',
+      !feNonMatching.includes('programs-fe') && feNonMatching.includes('programs-fc'),
+      `tags=${JSON.stringify(feNonMatching)}`,
+    )
+
+    /* ============ the bulk-dispatched path ============ */
+
+    /**
+     * Bulk-dispatched events cannot run the list mutations inline — the no-ops are detected in each
+     * record's own update filter, which has no bulk equivalent — so bulk_handle_actions_for_triggers
+     * defers all three types to the single-record path through `delayed_events`. A type missing from that
+     * list is silently dropped AFTER its throttle record is written, which is invisible except here.
+     *
+     * createSome, not createOne: handle_orders_create only takes the bulk branch for more than one
+     * created order; a single create goes to handle_order_status_equals, which is the inline path.
+     *
+     * The deferral is drained by the WORKER, which polls on an 8s+ cadence, so this is much slower than
+     * every other check in this suite and needs a worker running at all.
+     */
+    const BULK_SOURCE = `ProgramBulkSource${RAND()}`
+    const BULK_PROGRAM = 'Bulk Program'
+
+    await sdk.api.automation_triggers.createOne({
+      event: { type: 'Order Status Equals', info: { source: BULK_SOURCE, status: 'shipped' } },
+      action: { type: 'Add List Item', info: { field: 'programs', match: { name: BULK_PROGRAM } } },
+      status: 'Active',
+      title: `Bulk Add List Item ${RAND()}`,
+    })
+
+    const bulkEndusers = [
+      await sdk.api.endusers.createOne({ fname: 'Programs', lname: 'BulkA' }),
+      await sdk.api.endusers.createOne({ fname: 'Programs', lname: 'BulkB' }),
+    ]
+    await sdk.api.enduser_orders.createSome(bulkEndusers.map(e => ({
+      enduserId: e.id,
+      source: BULK_SOURCE,
+      externalId: `ext-${RAND()}`,
+      title: 'Bulk program order',
+      status: 'shipped',
+    })))
+
+    const bulkPrograms = await Promise.all(bulkEndusers.map(e => (
+      programs_once(e.id, p => p.some(x => x.name === BULK_PROGRAM), 240) // up to 60s; worker-paced
+    )))
+    record(
+      'V: an Add List Item action dispatched in bulk is deferred to the single-record path and applied'
+      + ' to every patient in the batch',
+      bulkPrograms.every(p => p.length === 1 && p[0].name === BULK_PROGRAM),
+      `programs=${JSON.stringify(bulkPrograms)} (needs a worker running to drain delayed_events)`,
+    )
   } finally {
     // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
     if (tenant) { try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) } }