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

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

@@ -1,14 +1,16 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
 import {
-  assert,
-  log_header,
-} from "@tellescope/testing"
-import { setup_tests } from "../setup"
+  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)
+
 // Modular test for the translations framework.
 // Validates that a model's `translations` field (nested { field: { language: text } }) is accepted by
 // schema validation, persists, and accumulates multiple languages (uses phone_calls as the MVP model).
@@ -17,61 +19,82 @@ const host = process.env.API_URL || 'http://localhost:8080' as const
 // That path consumes AI credits and belongs in an eval, not a regularly-run test. The endpoint itself is
 // already covered by the AI Summary feature, and the translation-specific logic (the system-prompt
 // builder in @tellescope/utilities) is a pure function verified at compile time.
-export const translations_tests = async ({ sdk } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Translations Framework Tests")
+export const translations_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
 
-  const enduser = await sdk.api.endusers.createOne({ fname: 'Translation', lname: 'Tester' })
-  let callId: string | undefined
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
-    const call = await sdk.api.phone_calls.createOne({
-      enduserId: enduser.id,
-      inbound: true,
-      userId: sdk.userInfo.id,
-      transcription: 'Hola, por favor devuélvame la llamada cuando pueda.',
+    tenant = await setup_isolated_tenant({
+      name: `Translations ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
     })
-    callId = call.id
+    const { sdk } = tenant
+
+    const enduser = await sdk.api.endusers.createOne({ fname: 'Translation', lname: 'Tester' })
+    let callId: string | undefined
+
+    try {
+      const call = await sdk.api.phone_calls.createOne({
+        enduserId: enduser.id,
+        inbound: true,
+        userId: sdk.userInfo.id,
+        transcription: 'Hola, por favor devuélvame la llamada cuando pueda.',
+      })
+      callId = call.id
 
-    // --- 1. translations field accepted + persisted ---
-    const translations = { transcription: { en: 'Hi, please call me back when you can.' } }
-    await sdk.api.phone_calls.updateOne(call.id, { translations }, { replaceObjectFields: true })
+      // --- 1. translations field accepted + persisted ---
+      const translations = { transcription: { en: 'Hi, please call me back when you can.' } }
+      await sdk.api.phone_calls.updateOne(call.id, { translations }, { replaceObjectFields: true })
 
-    const updated = await sdk.api.phone_calls.getOne(call.id)
-    assert(
-      updated.translations?.transcription?.en === translations.transcription.en,
-      `translations not persisted: ${JSON.stringify(updated.translations)}`,
-      'translations field persisted correctly',
-    )
+      const updated = await sdk.api.phone_calls.getOne(call.id)
+      record(
+        'translations field persisted correctly',
+        updated.translations?.transcription?.en === translations.transcription.en,
+        `translations=${updated.translations ? JSON.stringify(updated.translations) : '(none)'}`
+        + ` (want transcription.en=${JSON.stringify(translations.transcription.en)})`,
+      )
 
-    // add a second language and confirm accumulation (full merged object written by convention)
-    const merged = {
-      ...updated.translations,
-      transcription: { ...updated.translations?.transcription, es: 'Hola de nuevo.' },
+      // add a second language and confirm accumulation (full merged object written by convention)
+      const merged = {
+        ...updated.translations,
+        transcription: { ...updated.translations?.transcription, es: 'Hola de nuevo.' },
+      }
+      await sdk.api.phone_calls.updateOne(call.id, { translations: merged }, { replaceObjectFields: true })
+      const updated2 = await sdk.api.phone_calls.getOne(call.id)
+      record(
+        'multiple language translations accumulate under one field',
+        !!updated2.translations?.transcription?.en && !!updated2.translations?.transcription?.es,
+        `translations=${updated2.translations ? JSON.stringify(updated2.translations) : '(none)'} (want both transcription.en and transcription.es)`,
+      )
+    } finally {
+      // per-record cleanup is kept even though teardown subsumes it, so the body stays runnable
+      // against any tenant
+      if (callId) await sdk.api.phone_calls.deleteOne(callId).catch(() => {})
+      await sdk.api.endusers.deleteOne(enduser.id).catch(() => {})
     }
-    await sdk.api.phone_calls.updateOne(call.id, { translations: merged }, { replaceObjectFields: true })
-    const updated2 = await sdk.api.phone_calls.getOne(call.id)
-    assert(
-      !!updated2.translations?.transcription?.en && !!updated2.translations?.transcription?.es,
-      `translations did not accumulate: ${JSON.stringify(updated2.translations)}`,
-      'multiple language translations accumulate under one field',
-    )
   } finally {
-    if (callId) await sdk.api.phone_calls.deleteOne(callId).catch(() => {})
-    await sdk.api.endusers.deleteOne(enduser.id).catch(() => {})
+    // 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) } }
   }
+
+  return checks
 }
 
-// Allow running this test file independently
-if (require.main === module) {
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
+/** Asserting wrapper, for standalone runs. */
+export const translations_tests = async () => {
+  assert_checks('Translations', await translations_checks())
+}
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await translations_tests({ sdk, sdkNonAdmin })
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Translations', run: translations_checks }
 
-  runTests()
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  translations_tests()
     .then(() => {
       console.log("✅ Translations test suite completed successfully")
       process.exit(0)

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

@@ -4,6 +4,7 @@ import {
   assert_checks,
   Check,
   setup_isolated_tenant,
+  IsolatedSuite,
 } from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
@@ -330,6 +331,9 @@ export const trigger_contains_matching_tests = async () => {
   assert_checks('Trigger contains title matching', await trigger_contains_matching_checks())
 }
 
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Trigger contains title matching', run: trigger_contains_matching_checks }
+
 // Allow running this test file independently
 if (require.main === module) {
   console.log(`🌐 Using API URL: ${host}`)

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

@@ -1,305 +1,247 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
+import { poll_for_results } from "@tellescope/testing"
 import {
-  async_test,
-  log_header,
-} from "@tellescope/testing"
-import { setup_tests } from "../setup"
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
-// Test function that can be called independently
-export const trigger_set_fields_date_difference_tests = async ({ sdk } : { sdk: Session }) => {
-  log_header("Trigger Set Fields Date Difference Tests")
-
-  // Test resource tracking
-  let testEnduser: any
-  let triggerId: string | undefined
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * "Set Fields" / "Date Difference" action coverage, fired from a Field Equals trigger: two custom
+ * fields (ISO and MM-DD-YYYY), a field against `$now`, and two hardcoded date strings.
+ *
+ * Runs on its own provisioned tenant: the Field Equals triggers it installs are org-wide, so on the
+ * shared organization they evaluated every enduser-field update any concurrently running suite made
+ * (and wrote `daysBetween` / `daysSinceStart` / `hardcodedDays` onto their patients). It never calls
+ * `sdk.reset_db()`, which clears throttle namespaces shared with other suites.
+ *
+ * The three triggers each fire against the SAME enduser, which is safe because the one-fire-per-
+ * minute throttle is per trigger per enduser, and only one of them is active at a time.
+ *
+ * Records are not deleted individually: the tenant teardown in the `finally` removes everything it
+ * owns.
+ */
+export const trigger_set_fields_date_difference_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
 
   try {
+    tenant = await setup_isolated_tenant({
+      name: `Set Fields date difference ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    /** Polls up to ~10s for the trigger to write `field`, and returns its value (undefined on timeout). */
+    const await_field = async (enduserId: string, field: string) => {
+      const enduser = await poll_for_results(
+        () => sdk.api.endusers.getOne(enduserId),
+        e => e.fields?.[field] !== undefined,
+        { interval: 1000, iterations: 10 },
+      )
+      return enduser.fields?.[field]
+    }
+
     // Test 1: Setup - Create enduser with date fields
-    await async_test(
+    const testEnduser = await sdk.api.endusers.createOne({
+      fields: {
+        startDate: '2024-01-15T10:00:00Z', // ISO format
+        endDate: '01-25-2024', // MM-DD-YYYY format (10 days after startDate)
+      }
+    })
+    record(
       'setup - create test enduser with date fields',
-      async () => {
-        testEnduser = await sdk.api.endusers.createOne({
-          fields: {
-            startDate: '2024-01-15T10:00:00Z', // ISO format
-            endDate: '01-25-2024', // MM-DD-YYYY format (10 days after startDate)
-          }
-        })
-
-        return !!testEnduser.id && !!testEnduser.fields?.startDate && !!testEnduser.fields?.endDate
-      },
-      { onResult: (result) => result === true }
+      !!testEnduser.id && !!testEnduser.fields?.startDate && !!testEnduser.fields?.endDate,
+      `id=${testEnduser.id} fields=${JSON.stringify(testEnduser.fields)}`,
     )
 
     // Test 2: Create trigger with Date Difference - ISO to MM-DD-YYYY
-    await async_test(
-      'create trigger - date difference between two custom fields',
-      async () => {
-        const trigger = await sdk.api.automation_triggers.createOne({
-          title: `Date Difference Test ${Date.now()}`,
-          status: 'Active',
-          event: {
-            type: 'Field Equals',
-            info: {
-              field: 'triggerTest',
-              value: 'calculate-days'
-            }
-          },
-          action: {
-            type: 'Set Fields',
-            info: {
-              fields: [{
-                name: 'daysBetween',
-                type: 'Date Difference',
-                value: '', // Not used for Date Difference type
-                dateDifferenceOptions: {
-                  date1: 'startDate', // Reference to field containing ISO string
-                  date2: 'endDate', // Reference to field containing MM-DD-YYYY
-                }
-              }]
-            }
-          }
-        })
-        triggerId = trigger.id
-        return !!trigger.id
+    const trigger1 = await sdk.api.automation_triggers.createOne({
+      title: `Date Difference Test ${Date.now()}`,
+      status: 'Active',
+      event: {
+        type: 'Field Equals',
+        info: {
+          field: 'triggerTest',
+          value: 'calculate-days'
+        }
       },
-      { onResult: (result) => result === true }
+      action: {
+        type: 'Set Fields',
+        info: {
+          fields: [{
+            name: 'daysBetween',
+            type: 'Date Difference',
+            value: '', // Not used for Date Difference type
+            dateDifferenceOptions: {
+              date1: 'startDate', // Reference to field containing ISO string
+              date2: 'endDate', // Reference to field containing MM-DD-YYYY
+            }
+          }]
+        }
+      }
+    })
+    record(
+      'create trigger - date difference between two custom fields',
+      !!trigger1.id,
+      `triggerId=${trigger1.id}`,
     )
 
     // Test 3: Trigger the action and verify calculation
-    await async_test(
-      'trigger action - verify date difference is calculated correctly',
-      async () => {
-        await sdk.api.endusers.updateOne(testEnduser.id, {
-          fields: {
-            ...testEnduser.fields,
-            triggerTest: 'calculate-days'
-          }
-        })
-
-        // Wait up to 10 seconds for trigger to process
-        for (let i = 0; i < 10; i++) {
-          await new Promise(resolve => setTimeout(resolve, 1000))
-
-          const updatedEnduser = await sdk.api.endusers.getOne(testEnduser.id)
-
-          if (updatedEnduser.fields?.daysBetween !== undefined) {
-            console.log(`✓ Found daysBetween field after ${i + 1} seconds: ${updatedEnduser.fields.daysBetween}`)
-
-            // Should be 10 days between 2024-01-15 and 2024-01-25
-            const daysBetween = Number(updatedEnduser.fields.daysBetween)
-            if (daysBetween === 10) {
-              console.log(`✓ Date difference calculated correctly: ${daysBetween} days`)
-              return true
-            } else {
-              console.log(`❌ Unexpected date difference: ${daysBetween} (expected 10)`)
-              return false
-            }
-          }
-        }
+    await sdk.api.endusers.updateOne(testEnduser.id, {
+      fields: {
+        ...testEnduser.fields,
+        triggerTest: 'calculate-days'
+      }
+    })
 
-        console.log(`❌ daysBetween field not set after 10 seconds`)
-        return false
-      },
-      { onResult: (result) => result === true }
+    const daysBetweenRaw = await await_field(testEnduser.id, 'daysBetween')
+    // Should be 10 days between 2024-01-15 and 2024-01-25
+    record(
+      'trigger action - verify date difference is calculated correctly',
+      Number(daysBetweenRaw) === 10,
+      daysBetweenRaw === undefined
+        ? 'daysBetween was not set within 10 seconds'
+        : `daysBetween=${daysBetweenRaw} (expected 10)`,
     )
 
+    await sdk.api.automation_triggers.deleteOne(trigger1.id)
+
     // Test 4: Test with $now
-    await async_test(
-      'create trigger - date difference with $now',
-      async () => {
-        // Delete previous trigger
-        if (triggerId) {
-          await sdk.api.automation_triggers.deleteOne(triggerId)
+    const trigger2 = await sdk.api.automation_triggers.createOne({
+      title: `Date Difference $now Test ${Date.now()}`,
+      status: 'Active',
+      event: {
+        type: 'Field Equals',
+        info: {
+          field: 'triggerTest2',
+          value: 'calculate-days-now'
         }
-
-        const trigger = await sdk.api.automation_triggers.createOne({
-          title: `Date Difference $now Test ${Date.now()}`,
-          status: 'Active',
-          event: {
-            type: 'Field Equals',
-            info: {
-              field: 'triggerTest2',
-              value: 'calculate-days-now'
-            }
-          },
-          action: {
-            type: 'Set Fields',
-            info: {
-              fields: [{
-                name: 'daysSinceStart',
-                type: 'Date Difference',
-                value: '',
-                dateDifferenceOptions: {
-                  date1: 'startDate',
-                  date2: '$now',
-                }
-              }]
-            }
-          }
-        })
-        triggerId = trigger.id
-        return !!trigger.id
       },
-      { onResult: (result) => result === true }
+      action: {
+        type: 'Set Fields',
+        info: {
+          fields: [{
+            name: 'daysSinceStart',
+            type: 'Date Difference',
+            value: '',
+            dateDifferenceOptions: {
+              date1: 'startDate',
+              date2: '$now',
+            }
+          }]
+        }
+      }
+    })
+    record(
+      'create trigger - date difference with $now',
+      !!trigger2.id,
+      `triggerId=${trigger2.id}`,
     )
 
     // Test 5: Trigger with $now and verify
-    await async_test(
-      'trigger action - verify $now works correctly',
-      async () => {
-        await sdk.api.endusers.updateOne(testEnduser.id, {
-          fields: {
-            ...testEnduser.fields,
-            triggerTest2: 'calculate-days-now'
-          }
-        })
-
-        // Wait up to 10 seconds for trigger to process
-        for (let i = 0; i < 10; i++) {
-          await new Promise(resolve => setTimeout(resolve, 1000))
-
-          const updatedEnduser = await sdk.api.endusers.getOne(testEnduser.id)
-
-          if (updatedEnduser.fields?.daysSinceStart !== undefined) {
-            const daysSinceStart = Number(updatedEnduser.fields.daysSinceStart)
-            console.log(`✓ Found daysSinceStart field after ${i + 1} seconds: ${daysSinceStart}`)
-
-            // Should be approximately 680+ days from 2024-01-15 to 2025-09-30 (current test date)
-            // We'll accept any reasonable value > 600 days
-            if (daysSinceStart > 600) {
-              console.log(`✓ Date difference with $now calculated correctly: ${daysSinceStart} days`)
-              return true
-            } else {
-              console.log(`❌ Unexpected date difference with $now: ${daysSinceStart}`)
-              return false
-            }
-          }
-        }
+    await sdk.api.endusers.updateOne(testEnduser.id, {
+      fields: {
+        ...testEnduser.fields,
+        triggerTest2: 'calculate-days-now'
+      }
+    })
 
-        console.log(`❌ daysSinceStart field not set after 10 seconds`)
-        return false
-      },
-      { onResult: (result) => result === true }
+    const daysSinceStartRaw = await await_field(testEnduser.id, 'daysSinceStart')
+    // 2024-01-15 is more than 600 days before any date this suite can run on
+    record(
+      'trigger action - verify $now works correctly',
+      Number(daysSinceStartRaw) > 600,
+      daysSinceStartRaw === undefined
+        ? 'daysSinceStart was not set within 10 seconds'
+        : `daysSinceStart=${daysSinceStartRaw} (expected > 600, measured from 2024-01-15)`,
     )
 
+    await sdk.api.automation_triggers.deleteOne(trigger2.id)
+
     // Test 6: Test with hardcoded date strings
-    await async_test(
-      'create trigger - date difference with hardcoded dates',
-      async () => {
-        // Delete previous trigger
-        if (triggerId) {
-          await sdk.api.automation_triggers.deleteOne(triggerId)
+    const trigger3 = await sdk.api.automation_triggers.createOne({
+      title: `Date Difference Hardcoded Test ${Date.now()}`,
+      status: 'Active',
+      event: {
+        type: 'Field Equals',
+        info: {
+          field: 'triggerTest3',
+          value: 'calculate-days-hardcoded'
         }
-
-        const trigger = await sdk.api.automation_triggers.createOne({
-          title: `Date Difference Hardcoded Test ${Date.now()}`,
-          status: 'Active',
-          event: {
-            type: 'Field Equals',
-            info: {
-              field: 'triggerTest3',
-              value: 'calculate-days-hardcoded'
-            }
-          },
-          action: {
-            type: 'Set Fields',
-            info: {
-              fields: [{
-                name: 'hardcodedDays',
-                type: 'Date Difference',
-                value: '',
-                dateDifferenceOptions: {
-                  date1: '2024-01-01T00:00:00Z', // ISO string
-                  date2: '01-31-2024', // MM-DD-YYYY (30 days later)
-                }
-              }]
-            }
-          }
-        })
-        triggerId = trigger.id
-        return !!trigger.id
       },
-      { onResult: (result) => result === true }
+      action: {
+        type: 'Set Fields',
+        info: {
+          fields: [{
+            name: 'hardcodedDays',
+            type: 'Date Difference',
+            value: '',
+            dateDifferenceOptions: {
+              date1: '2024-01-01T00:00:00Z', // ISO string
+              date2: '01-31-2024', // MM-DD-YYYY (30 days later)
+            }
+          }]
+        }
+      }
+    })
+    record(
+      'create trigger - date difference with hardcoded dates',
+      !!trigger3.id,
+      `triggerId=${trigger3.id}`,
     )
 
     // Test 7: Trigger with hardcoded dates and verify
-    await async_test(
-      'trigger action - verify hardcoded dates work correctly',
-      async () => {
-        await sdk.api.endusers.updateOne(testEnduser.id, {
-          fields: {
-            ...testEnduser.fields,
-            triggerTest3: 'calculate-days-hardcoded'
-          }
-        })
-
-        // Wait up to 10 seconds for trigger to process
-        for (let i = 0; i < 10; i++) {
-          await new Promise(resolve => setTimeout(resolve, 1000))
-
-          const updatedEnduser = await sdk.api.endusers.getOne(testEnduser.id)
-
-          if (updatedEnduser.fields?.hardcodedDays !== undefined) {
-            const hardcodedDays = Number(updatedEnduser.fields.hardcodedDays)
-            console.log(`✓ Found hardcodedDays field after ${i + 1} seconds: ${hardcodedDays}`)
-
-            // Should be 30 days between 2024-01-01 and 2024-01-31
-            if (hardcodedDays === 30) {
-              console.log(`✓ Date difference with hardcoded dates calculated correctly: ${hardcodedDays} days`)
-              return true
-            } else {
-              console.log(`❌ Unexpected date difference: ${hardcodedDays} (expected 30)`)
-              return false
-            }
-          }
-        }
+    await sdk.api.endusers.updateOne(testEnduser.id, {
+      fields: {
+        ...testEnduser.fields,
+        triggerTest3: 'calculate-days-hardcoded'
+      }
+    })
 
-        console.log(`❌ hardcodedDays field not set after 10 seconds`)
-        return false
-      },
-      { onResult: (result) => result === true }
+    const hardcodedDaysRaw = await await_field(testEnduser.id, 'hardcodedDays')
+    // Should be 30 days between 2024-01-01 and 2024-01-31
+    record(
+      'trigger action - verify hardcoded dates work correctly',
+      Number(hardcodedDaysRaw) === 30,
+      hardcodedDaysRaw === undefined
+        ? 'hardcodedDays was not set within 10 seconds'
+        : `hardcodedDays=${hardcodedDaysRaw} (expected 30)`,
     )
 
-    console.log("✅ All trigger set fields date difference tests passed!")
-
-  } catch (error) {
-    console.error('Test execution error:', error)
-    throw error
+    await sdk.api.automation_triggers.deleteOne(trigger3.id)
   } finally {
-    // Cleanup
-    console.log("🧹 Cleaning up test resources...")
+    // 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) } }
+  }
 
-    try {
-      if (triggerId) {
-        await sdk.api.automation_triggers.deleteOne(triggerId)
-      }
+  return checks
+}
 
-      if (testEnduser?.id) {
-        await sdk.api.endusers.deleteOne(testEnduser.id)
-      }
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const trigger_set_fields_date_difference_tests = async () => {
+  assert_checks('Set Fields date difference', await trigger_set_fields_date_difference_checks())
+}
 
-    } catch (cleanupError) {
-      console.error('Cleanup error (non-fatal):', cleanupError)
-    }
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Set Fields date difference',
+  run: trigger_set_fields_date_difference_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 trigger_set_fields_date_difference_tests({ sdk })
-  }
-
-  runTests()
+  trigger_set_fields_date_difference_tests()
     .then(() => {
       console.log("✅ Trigger set fields date difference test suite completed successfully")
       process.exit(0)
@@ -308,4 +250,4 @@ if (require.main === module) {
       console.error("❌ Trigger set fields date difference test suite failed:", error)
       process.exit(1)
     })
-}
+}