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

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

@@ -0,0 +1,415 @@
+require('source-map-support').install();
+
+import { AUTOMATED_ACTION_CANCEL_REASONS } from "@tellescope/constants"
+import {
+  assert_checks,
+  Check,
+  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)
+
+/**
+ * Coverage for POST /v1/user-logs/restore-deleted — re-creating a deleted contact, and the records
+ * cascade-deleted with it, by replaying user_logs rows.
+ *
+ * The check that most justifies the handler's shape is B. handleDeletionForDependencies runs BEFORE
+ * the parent `delete` row is inserted, so cascade rows have SMALLER _ids than the parent row. If the
+ * `_id` range is ever written the intuitive way round (forwards from the parent), the contact still
+ * comes back and every "contact restored" check still passes — only the dependent counts go to zero.
+ * B is what fails in that case.
+ *
+ * H is the other half of that: the window is scoped by enduserId, which the delete path stamps on
+ * every cascade row for every model. Deleting contact B's ticket inside the same five-minute window
+ * must not bring it back when contact A is restored.
+ *
+ * The suite MUST poll for audit rows: the delete endpoint responds 204 *before* writing them, so
+ * reading immediately after a delete is a race.
+ *
+ * Restores are deliberately not idempotent in the "refuse if present" sense — they RESUME. D and E
+ * pin that: a second press duplicates nothing, and a dependent deleted since comes back.
+ */
+
+const poll_for = async <T,>(get: () => Promise<T>, done: (v: T) => boolean, attempts = 40): Promise<T> => {
+  let value = await get()
+  for (let i = 0; i < attempts && !done(value); i++) {
+    await new Promise(resolve => setTimeout(resolve, 250))
+    value = await get()
+  }
+  return value
+}
+
+/** The delete endpoint returns before writing its audit rows, so every read of one polls. */
+const poll_for_delete_log = async (sdk: any, resource: string, resourceId: string) => {
+  const log = await poll_for(
+    async () => (
+      await sdk.api.user_logs.getSome({ filter: { resourceId } })
+    ).find((l: any) => l.action === 'delete' && l.resource === resource),
+    l => !!l,
+  )
+  if (!log) throw new Error(`no delete user_log appeared for ${resource} ${resourceId}`)
+  return log
+}
+
+const sum = (counts: Record<string, number> = {}) => Object.values(counts).reduce((a, b) => a + b, 0)
+
+const rejection_of = async (run: () => Promise<any>) => {
+  try {
+    await run()
+    return undefined
+  } catch (err: any) {
+    return err
+  }
+}
+
+export const user_logs_restore_deleted_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
+  let otherTenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+
+  try {
+    ;[tenant, otherTenant] = await Promise.all([
+      setup_isolated_tenant({
+        name: `RestoreDeleted ${RAND()}`,
+        // A non-admin is provisioned deliberately: without one, sdkNonAdmin is an unauthenticated
+        // stub and the permission check (G) would pass for the wrong reason.
+        users: [{ isAdmin: true }, { roles: ['Non-Admin'] }],
+        apiKeys: 0,
+      }),
+      setup_isolated_tenant({ name: `RestoreDeletedOther ${RAND()}`, users: [{ isAdmin: true }], apiKeys: 0 }),
+    ])
+
+    const { sdk, sdkNonAdmin } = tenant
+
+    /* ============================== fixtures ============================== */
+
+    const queue = await sdk.api.ticket_queues.createOne({
+      title: `Restore Queue ${RAND()}`,
+      userIds: [sdk.userInfo.id],
+    })
+
+    const journey = await sdk.api.journeys.createOne({ title: `Restore Journey ${RAND()}` })
+    const step = await sdk.api.automation_steps.createOne({
+      journeyId: journey.id,
+      action: { type: 'setEnduserStatus', info: { status: 'Restored' } },
+      events: [{ type: 'onJourneyStart', info: {} }],
+    })
+
+    const emailA = `restore-a-${RAND()}@example.com`
+    const externalIdA = `restore-ext-${RAND()}`
+
+    const contactA = await sdk.api.endusers.createOne({
+      fname: 'Restore', lname: 'Target', email: emailA, externalId: externalIdA,
+    })
+    const contactB = await sdk.api.endusers.createOne({
+      fname: 'Bystander', lname: 'Contact', email: `restore-b-${RAND()}@example.com`,
+    })
+
+    const noteA = await sdk.api.notes.createOne({ enduserId: contactA.id, text: 'A note that must come back' })
+    const ticketA = await sdk.api.tickets.createOne({
+      title: `Ticket for A ${RAND()}`, enduserId: contactA.id, queueId: queue.id,
+    })
+    const actionA = await sdk.api.automated_actions.createOne({
+      journeyId: journey.id,
+      automationStepId: step.id,
+      enduserId: contactA.id,
+      processAfter: Date.now() + 100000000, // far future: the worker must not process it during the test
+      status: 'active',
+      event: { type: 'onJourneyStart', info: {} },
+      action: { type: 'setEnduserStatus', info: { status: 'Restored' } },
+    })
+    const ticketB = await sdk.api.tickets.createOne({
+      title: `Ticket for B ${RAND()}`, enduserId: contactB.id,
+    })
+
+    // ticket_queues.count is maintained by asynchronous side effects, so every read of it polls
+    const queueCountAfterCreate = (await poll_for(
+      () => sdk.api.ticket_queues.getOne(queue.id),
+      q => (q.count ?? 0) >= 1,
+    )).count ?? 0
+
+    /* ====================== delete A (and one of B's tickets) ====================== */
+
+    // H: deleted INSIDE the same window as A's delete, to prove enduserId scoping
+    await sdk.api.tickets.deleteOne(ticketB.id)
+    await poll_for_delete_log(sdk, 'tickets', ticketB.id)
+
+    await sdk.api.endusers.deleteOne(contactA.id)
+    const deleteLogA = await poll_for_delete_log(sdk, 'endusers', contactA.id)
+
+    const queueCountAfterDelete = (await poll_for(
+      () => sdk.api.ticket_queues.getOne(queue.id),
+      q => (q.count ?? 0) < queueCountAfterCreate,
+    )).count ?? 0
+
+    record(
+      'delete removes the contact and decrements the queue',
+      !(await sdk.api.endusers.getSome({ filter: { } })).some(e => e.id === contactA.id)
+        && queueCountAfterDelete === queueCountAfterCreate - 1,
+      `queue ${queueCountAfterCreate} -> ${queueCountAfterDelete}`,
+    )
+
+    const auditRowsBefore = (await sdk.api.user_logs.getSome({ filter: { resourceId: contactA.id } })).length
+
+    /* ============================== A: the restore ============================== */
+
+    const result = await sdk.api.user_logs.restore_deleted({ userLogId: deleteLogA.id })
+
+    record(
+      'A1: restore returns the contact resource and its original id',
+      result.resource === 'endusers' && result.resourceId === contactA.id,
+      `resource=${result.resource} resourceId=${result.resourceId} (expected ${contactA.id})`,
+    )
+
+    const restoredContact = await sdk.api.endusers.getOne(contactA.id)
+    record(
+      'A2: the contact is back at its original id with its fields intact',
+      restoredContact.id === contactA.id
+        && restoredContact.fname === 'Restore'
+        && restoredContact.lname === 'Target'
+        && restoredContact.email === emailA
+        && restoredContact.externalId === externalIdA,
+      `id=${restoredContact.id} fname=${restoredContact.fname} email=${restoredContact.email} externalId=${restoredContact.externalId}`,
+    )
+
+    record(
+      'A3: the contact keeps its original creation timestamp',
+      new Date(restoredContact.createdAt).getTime() === new Date(contactA.createdAt).getTime(),
+      `restored=${restoredContact.createdAt} original=${contactA.createdAt}`,
+    )
+
+    /* ---- B: the cascade. This is what fails if the _id range runs the wrong way. ---- */
+
+    const dependentModels = Object.keys(result.restoredCounts ?? {}).filter(m => m !== 'endusers')
+    record(
+      'B1: restoredCounts covers at least two dependent models',
+      dependentModels.length >= 2,
+      `restoredCounts=${JSON.stringify(result.restoredCounts)} (the _id range runs BACKWARDS from the parent row)`,
+    )
+
+    const restoredNote = await sdk.api.notes.getOne(noteA.id)
+    const restoredTicket = await sdk.api.tickets.getOne(ticketA.id)
+    record(
+      'B2: dependents come back at their original ids',
+      restoredNote?.id === noteA.id && restoredTicket?.id === ticketA.id,
+      `note=${restoredNote?.id} ticket=${restoredTicket?.id}`,
+    )
+    record(
+      'B3: dependents keep their original authorship and content',
+      restoredNote.creator === noteA.creator
+        && restoredNote.text === 'A note that must come back'
+        && restoredTicket.creator === ticketA.creator
+        && restoredTicket.title === ticketA.title,
+      `note.creator=${restoredNote.creator} (orig ${noteA.creator}); ticket.creator=${restoredTicket.creator} (orig ${ticketA.creator})`,
+    )
+
+    /* ---- C: journey actions come back CANCELLED, never active ---- */
+
+    const expectedCancelReason = AUTOMATED_ACTION_CANCEL_REASONS.indexOf('Restored from Deletion')
+    const restoredAction = await sdk.api.automated_actions.getOne(actionA.id)
+    record(
+      'C: the pending journey action is restored cancelled with the new reason',
+      restoredAction?.status === 'cancelled' && restoredAction?.cancelReason === expectedCancelReason,
+      `status=${restoredAction?.status} cancelReason=${restoredAction?.cancelReason} (expected ${expectedCancelReason})`,
+    )
+
+    /* ---- H: cross-contact isolation ---- */
+
+    const bTicketBack = await rejection_of(() => sdk.api.tickets.getOne(ticketB.id))
+    record(
+      "H: restoring A does not bring back contact B's separately-deleted ticket",
+      bTicketBack !== undefined,
+      `enduserId scoping; getOne(ticketB) ${bTicketBack === undefined ? 'UNEXPECTEDLY SUCCEEDED' : 'rejected as expected'}`,
+    )
+
+    /* ---- queue count round-trips ---- */
+
+    const queueCountAfterRestore = (await poll_for(
+      () => sdk.api.ticket_queues.getOne(queue.id),
+      q => (q.count ?? 0) > queueCountAfterDelete,
+    )).count ?? 0
+    record(
+      'F1: the ticket queue count round-trips on restore',
+      queueCountAfterRestore === queueCountAfterCreate,
+      `${queueCountAfterCreate} -> ${queueCountAfterDelete} -> ${queueCountAfterRestore}`,
+    )
+
+    /* ---- audit: exactly one new row per restore ---- */
+
+    const auditRowsAfter = await poll_for(
+      async () => await sdk.api.user_logs.getSome({ filter: { resourceId: contactA.id } }),
+      rows => rows.length > auditRowsBefore,
+    )
+    const restoreRows = auditRowsAfter.filter(r => r.action === 'create' && r.note === 'Restored from deletion')
+    record(
+      'I1: the restore writes exactly one audit row',
+      auditRowsAfter.length === auditRowsBefore + 1 && restoreRows.length === 1,
+      `rows ${auditRowsBefore} -> ${auditRowsAfter.length}; restore rows=${restoreRows.length}`,
+    )
+    record(
+      'I2: the restore audit row records the source log id and the counts',
+      (restoreRows[0]?.info as any)?.sourceUserLogId === deleteLogA.id
+        && !!(restoreRows[0]?.info as any)?.restoredCounts,
+      `info=${JSON.stringify(restoreRows[0]?.info)?.slice(0, 200)}`,
+    )
+
+    /* ---- D: a second restore resumes, and duplicates nothing ---- */
+
+    const second = await sdk.api.user_logs.restore_deleted({ userLogId: deleteLogA.id })
+    record(
+      'D1: a second restore restores nothing and skips everything',
+      sum(second.restoredCounts) === 0 && sum(second.skippedCounts) > 0,
+      `restored=${JSON.stringify(second.restoredCounts)} skipped=${JSON.stringify(second.skippedCounts)}`,
+    )
+
+    const allContacts = await sdk.api.endusers.getSome({ filter: { } })
+    const allNotes = await sdk.api.notes.getSome({ filter: { enduserId: contactA.id } })
+    record(
+      'D2: a second restore duplicates neither the contact nor its records',
+      allContacts.filter(e => e.id === contactA.id).length === 1 && allNotes.length === 1,
+      `contacts with that id=${allContacts.filter(e => e.id === contactA.id).length} notes=${allNotes.length}`,
+    )
+
+    const queueCountAfterSecond = (await sdk.api.ticket_queues.getOne(queue.id)).count ?? 0
+    record(
+      'F2: a second restore does not inflate the queue count',
+      queueCountAfterSecond === queueCountAfterCreate,
+      `expected ${queueCountAfterCreate}, got ${queueCountAfterSecond}`,
+    )
+
+    /* ---- E: resume brings back a dependent deleted since ---- */
+
+    await sdk.api.notes.deleteOne(noteA.id)
+    await poll_for_delete_log(sdk, 'notes', noteA.id)
+
+    const third = await sdk.api.user_logs.restore_deleted({ userLogId: deleteLogA.id })
+    const noteBackAgain = await sdk.api.notes.getOne(noteA.id)
+    record(
+      'E: a repeat restore brings back exactly the record deleted since',
+      (third.restoredCounts as any)?.notes === 1
+        && sum(third.restoredCounts) === 1
+        && noteBackAgain?.id === noteA.id,
+      `restored=${JSON.stringify(third.restoredCounts)} note back=${noteBackAgain?.id}`,
+    )
+
+    /* ============================== error cases ============================== */
+
+    // G: a non-admin is refused. NOTE: for the default Non-Admin role the role-permission layer fires
+    // FIRST with 403 "Inaccessible" (the role has no user_logs access at all), so the schema's
+    // adminOnly gate — 401 "Admin access only" — is never reached. Both refuse; this asserts only
+    // that the call is rejected, so it stays green whichever of the two gates fires.
+    const nonAdminErr = await rejection_of(() => sdkNonAdmin.api.user_logs.restore_deleted({ userLogId: deleteLogA.id }))
+    record(
+      'G: a non-admin is refused',
+      nonAdminErr !== undefined,
+      `error=${JSON.stringify(nonAdminErr)?.slice(0, 200)}`,
+    )
+
+    // another tenant's log id is not found (indistinguishable from nonexistent)
+    const otherContact = await otherTenant.sdk.api.endusers.createOne({ fname: 'Other', lname: 'Tenant' })
+    await otherTenant.sdk.api.endusers.deleteOne(otherContact.id)
+    const otherLog = await poll_for_delete_log(otherTenant.sdk, 'endusers', otherContact.id)
+
+    const crossTenantErr = await rejection_of(() => sdk.api.user_logs.restore_deleted({ userLogId: otherLog.id }))
+    record(
+      "J1: another tenant's log id is not found",
+      crossTenantErr !== undefined,
+      `error=${JSON.stringify(crossTenantErr)?.slice(0, 200)}`,
+    )
+
+    // a non-delete row is not found
+    const anyCreateRow = (await sdk.api.user_logs.getSome({ filter: { } })).find(l => l.action !== 'delete')
+    const nonDeleteErr = anyCreateRow
+      ? await rejection_of(() => sdk.api.user_logs.restore_deleted({ userLogId: anyCreateRow.id }))
+      : undefined
+    record(
+      'J2: a non-delete audit row is not found',
+      !anyCreateRow || nonDeleteErr !== undefined,
+      anyCreateRow ? `error=${JSON.stringify(nonDeleteErr)?.slice(0, 200)}` : 'no non-delete row available to test',
+    )
+
+    // K: a standalone ticket's delete row is refused as unsupported_resource, a 400 (not a 404)
+    const standaloneTicket = await sdk.api.tickets.createOne({ title: `Standalone ${RAND()}` })
+    await sdk.api.tickets.deleteOne(standaloneTicket.id)
+    const ticketLog = await poll_for_delete_log(sdk, 'tickets', standaloneTicket.id)
+
+    const unsupportedErr: any = await rejection_of(() => sdk.api.user_logs.restore_deleted({ userLogId: ticketLog.id }))
+    record(
+      'K: a non-contact delete row is refused with unsupported_resource',
+      unsupportedErr?.info?.reason === 'unsupported_resource',
+      `error=${JSON.stringify(unsupportedErr)?.slice(0, 300)}`,
+    )
+
+    // L: a merge's delete row carries the Profile merge marker and is refused
+    const mergeSource = await sdk.api.endusers.createOne({ fname: 'Merge', lname: 'Source', email: `merge-src-${RAND()}@example.com` })
+    const mergeDest = await sdk.api.endusers.createOne({ fname: 'Merge', lname: 'Dest', email: `merge-dst-${RAND()}@example.com` })
+    await sdk.api.endusers.merge({ sourceEnduserId: mergeSource.id, destinationEnduserId: mergeDest.id })
+    const mergeLog = await poll_for_delete_log(sdk, 'endusers', mergeSource.id)
+
+    record(
+      "L1: the merge's delete row is marked 'Profile merge'",
+      mergeLog.note === 'Profile merge',
+      `note=${mergeLog.note}`,
+    )
+
+    const mergeErr: any = await rejection_of(() => sdk.api.user_logs.restore_deleted({ userLogId: mergeLog.id }))
+    record(
+      'L2: a merge delete row is refused with merge_row',
+      mergeErr?.info?.reason === 'merge_row',
+      `error=${JSON.stringify(mergeErr)?.slice(0, 300)}`,
+    )
+
+    // M: reusing a deleted contact's email yields unique_conflict
+    const conflictEmail = `restore-conflict-${RAND()}@example.com`
+    const conflictContact = await sdk.api.endusers.createOne({ fname: 'Conflict', lname: 'Target', email: conflictEmail })
+    await sdk.api.endusers.deleteOne(conflictContact.id)
+    const conflictLog = await poll_for_delete_log(sdk, 'endusers', conflictContact.id)
+
+    const replacement = await sdk.api.endusers.createOne({ fname: 'Replacement', lname: 'Contact', email: conflictEmail })
+    const conflictErr: any = await rejection_of(() => sdk.api.user_logs.restore_deleted({ userLogId: conflictLog.id }))
+
+    record(
+      'M1: restoring into a reused email yields unique_conflict',
+      conflictErr?.info?.reason === 'unique_conflict',
+      `error=${JSON.stringify(conflictErr)?.slice(0, 300)}`,
+    )
+
+    const conflictStillGone = await rejection_of(() => sdk.api.endusers.getOne(conflictContact.id))
+    const replacementUntouched = await sdk.api.endusers.getOne(replacement.id)
+    record(
+      'M2: a unique conflict restores nothing and leaves the new contact untouched',
+      conflictStillGone !== undefined && replacementUntouched?.email === conflictEmail,
+      `deleted contact still absent=${conflictStillGone !== undefined}; replacement email=${replacementUntouched?.email}`,
+    )
+  } finally {
+    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand these tenants.
+    for (const t of [tenant, otherTenant]) {
+      if (t) { try { await t.teardown() } catch (e) { console.error('teardown failed', e) } }
+    }
+  }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const user_logs_restore_deleted_tests = async () => {
+  assert_checks('user_logs restore_deleted', await user_logs_restore_deleted_checks())
+}
+
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  user_logs_restore_deleted_tests()
+    .then(() => {
+      console.log("✅ user_logs restore_deleted test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ user_logs restore_deleted test suite failed:", error)
+      process.exit(1)
+    })
+}

package/src/tests/tests.ts

@@ -163,12 +163,18 @@ import { conditional_logic_medication_unit_tests } from "./unit_tests/conditiona
 import { phone_validation_unit_tests } from "./unit_tests/phone_validation.test";
 import { openapi_spec_freshness_unit_tests } from "./unit_tests/openapi_spec_freshness.test";
 import { do_not_send_address_unit_tests } from "./unit_tests/do_not_send_address.test";
+import { trigger_title_partials_unit_tests } from "./unit_tests/trigger_title_partials.test";
+import { trigger_contains_matching_checks } from "./api_tests/trigger_contains_matching.test";
 import { organization_signup_checks } from "./api_tests/organization_signup.test";
 import { add_to_journey_foreign_enduserid_checks } from "./api_tests/security/add-to-journey-foreign-enduserid.test";
 import { tickets_bulk_assign_from_queue_checks } from "./api_tests/tickets_bulk_assign_from_queue.test";
 import { enduser_observations_auto_review_checks } from "./api_tests/enduser_observations_auto_review.test";
 import { file_link_session_confinement_checks } from "./api_tests/security/file-link-session-confinement.test";
+import { appointment_reschedule_ownership_checks } from "./api_tests/security/appointment-reschedule-ownership.test";
+import { load_threads_care_team_checks } from "./api_tests/load_threads_care_team.test";
 import { run_isolated_in_parallel } from "./setup_isolated";
+import { enduser_fields_sync_checks } from "./api_tests/enduser_fields_sync.test";
+import { user_logs_restore_deleted_checks } from "./api_tests/user_logs_restore_deleted.test";
 import { elation_user_id_tests } from "./api_tests/elation_user_id.test";
 import { organization_settings_duplicates_tests } from "./api_tests/organization_settings_duplicates.test";
 import { stedi_approval_tests } from "./api_tests/stedi_approval.test";
@@ -15395,6 +15401,7 @@ const ip_address_form_tests = async () => {
     await phone_validation_unit_tests()
     await openapi_spec_freshness_unit_tests()
     await do_not_send_address_unit_tests()
+    await trigger_title_partials_unit_tests()
     await replace_enduser_template_values_tests()
     await safe_json_parse_template_tests()
     await replace_form_field_template_values_tests()
@@ -15412,6 +15419,11 @@ const ip_address_form_tests = async () => {
       { name: '$JS in stored conditional logic', run: form_logic_js_execution_checks },
       { name: 'Rich Text answers sanitized on write', run: rich_text_answer_sanitized_on_write_checks },
       { name: 'Shared file link session confinement', run: file_link_session_confinement_checks },
+      { name: 'book_appointment reschedule ownership', run: appointment_reschedule_ownership_checks },
+      { name: 'Enduser fields sync schema round-trip', run: enduser_fields_sync_checks },
+      { name: 'Trigger contains title matching', run: trigger_contains_matching_checks },
+      { name: 'user_logs restore_deleted', run: user_logs_restore_deleted_checks },
+      { name: 'Load threads care team', run: load_threads_care_team_checks },
     ])
     await embeddables_auth_token_tests({ sdk, sdkNonAdmin })
     await proxy_image_ssrf_tests({ sdk, sdkNonAdmin })

package/src/tests/unit_tests/trigger_title_partials.test.ts

@@ -0,0 +1,174 @@
+import { title_matches_partials } from "@tellescope/utilities"
+
+/**
+ * Unit coverage for the shared "contains" matcher behind the Problem Created / Order Created title
+ * filters. The backend call sites (enduser_problems.ts, enduser_orders.ts, handle_order_created)
+ * all delegate here, so the semantics are pinned in one place:
+ *
+ *  - each list is OR internally, the two lists AND together
+ *  - the case-sensitive list is `titlePartials`, the case-insensitive one `titlePartialsIgnoreCase`
+ *  - entries are trimmed, and blank-after-trim entries are dropped rather than matching everything
+ *  - no list set (or every entry blank) means "leave blank for all"
+ *  - a missing/empty title never satisfies a non-empty list
+ */
+
+let failures = 0
+let passed = 0
+
+const assert = (name: string, actual: boolean, expected: boolean) => {
+  if (actual === expected) {
+    passed++
+    console.log(`  ✓ ${name}`)
+  } else {
+    failures++
+    console.error(`  ✗ ${name} — expected ${expected}, got ${actual}`)
+  }
+}
+
+const run_unset_tests = () => {
+  console.log("\n[title_matches_partials — unset lists mean no filter]")
+
+  assert("both lists undefined", title_matches_partials('Endometriosis, unspecified'), true)
+  assert("both lists empty arrays", title_matches_partials('Endometriosis', [], []), true)
+  assert("undefined title with no lists set", title_matches_partials(undefined), true)
+  assert("empty title with no lists set", title_matches_partials(''), true)
+  assert("null title with no lists set", title_matches_partials(null), true)
+  assert("all-blank case-sensitive list counts as unset", title_matches_partials('Common cold', ['   ']), true)
+  assert("all-blank case-insensitive list counts as unset", title_matches_partials('Common cold', [], ['', '  ']), true)
+  assert("all-blank lists on an empty title", title_matches_partials('', ['  '], ['\t']), true)
+}
+
+const run_case_sensitive_tests = () => {
+  console.log("\n[title_matches_partials — case sensitive list]")
+
+  assert("substring match", title_matches_partials('Endometriosis, unspecified', ['Endometriosis']), true)
+  assert("prefix fragment match", title_matches_partials('Endometriosis, unspecified', ['Endo']), true)
+  assert("mid-string fragment match", title_matches_partials('Chronic Endometriosis pain', ['metrios']), true)
+  assert("case mismatch does not match", title_matches_partials('Chronic endometriosis pain', ['Endometriosis']), false)
+  assert("uppercase entry does not match lowercase title", title_matches_partials('endometriosis', ['ENDO']), false)
+  assert("exact-equal title matches", title_matches_partials('Endometriosis', ['Endometriosis']), true)
+  assert("unrelated title does not match", title_matches_partials('Common cold', ['Endo']), false)
+
+  // OR within the list
+  assert("OR within list — second entry matches", title_matches_partials('Type 2 Diabetes', ['Endo', 'Diabetes']), true)
+  assert("OR within list — no entry matches", title_matches_partials('Common cold', ['Endo', 'Diabetes']), false)
+}
+
+const run_case_insensitive_tests = () => {
+  console.log("\n[title_matches_partials — case insensitive list]")
+
+  assert("lowercase entry matches capitalized title", title_matches_partials('Semaglutide 0.25mg', [], ['semaglutide']), true)
+  assert("lowercase entry matches uppercase title", title_matches_partials('SEMAGLUTIDE injection', [], ['semaglutide']), true)
+  assert("uppercase entry matches lowercase title", title_matches_partials('semaglutide injection', [], ['SEMAGLUTIDE']), true)
+  assert("mixed-case entry matches", title_matches_partials('Chronic endometriosis pain', [], ['EnDoMeTrIoSiS']), true)
+  assert("unrelated title does not match", title_matches_partials('Tirzepatide 5mg', [], ['semaglutide']), false)
+  assert("OR within list — second entry matches", title_matches_partials('Tirzepatide 5mg', [], ['sema', 'TIRZ']), true)
+}
+
+const run_trimming_tests = () => {
+  console.log("\n[title_matches_partials — trimming and blank entries]")
+
+  assert("padded entry is trimmed before matching", title_matches_partials('Endometriosis, unspecified', ['  Endo  ']), true)
+  assert("padded case-insensitive entry is trimmed", title_matches_partials('SEMAGLUTIDE injection', [], ['  semaglutide  ']), true)
+  assert(
+    "blank sibling entry is ignored, real entry still matches",
+    title_matches_partials('Endometriosis', ['Endo', '   ']),
+    true,
+  )
+  assert(
+    "blank sibling entry does not make a non-matching title match",
+    title_matches_partials('Common cold', ['Endo', '   ']),
+    false,
+  )
+  assert(
+    "a list of only blanks counts as unset rather than as a match-everything entry",
+    title_matches_partials('Common cold', ['', ' ', '\t']),
+    true, // unset — and per the next check it cannot rescue a failing sibling list either
+  )
+  assert(
+    "blank case-sensitive list does not rescue a failing case-insensitive list",
+    title_matches_partials('Common cold', ['  '], ['semaglutide']),
+    false,
+  )
+  assert(
+    "whitespace-only title against a real entry",
+    title_matches_partials('   ', ['Endo']),
+    false,
+  )
+}
+
+const run_both_lists_tests = () => {
+  console.log("\n[title_matches_partials — the two lists AND together]")
+
+  assert(
+    "both lists match",
+    title_matches_partials('Endometriosis, unspecified', ['Endo'], ['unspecified']),
+    true,
+  )
+  assert(
+    "case-sensitive list matches, case-insensitive does not",
+    title_matches_partials('Endometriosis, unspecified', ['Endo'], ['diabetes']),
+    false,
+  )
+  assert(
+    "case-insensitive list matches, case-sensitive does not",
+    title_matches_partials('Endometriosis, unspecified', ['ENDO'], ['endometriosis']),
+    false,
+  )
+  assert(
+    "neither list matches",
+    title_matches_partials('Common cold', ['Endo'], ['semaglutide']),
+    false,
+  )
+  assert(
+    "same fragment in both lists, case differing — case-sensitive one decides",
+    title_matches_partials('chronic endometriosis', ['Endometriosis'], ['endometriosis']),
+    false,
+  )
+}
+
+const run_missing_title_tests = () => {
+  console.log("\n[title_matches_partials — absent or empty title with a filter set]")
+
+  assert("undefined title vs case-sensitive list", title_matches_partials(undefined, ['Endo']), false)
+  assert("undefined title vs case-insensitive list", title_matches_partials(undefined, [], ['endo']), false)
+  assert("null title vs a set list", title_matches_partials(null, ['Endo']), false)
+  assert("empty-string title vs a set list", title_matches_partials('', ['Endo']), false)
+  assert("empty-string title vs both lists set", title_matches_partials('', ['Endo'], ['endo']), false)
+}
+
+const run_literal_matching_tests = () => {
+  console.log("\n[title_matches_partials — entries are literal, never regex]")
+
+  assert("hyphenated fragment matches literally", title_matches_partials('Diabetes Type-2', ['Type-2']), true)
+  assert("dosage fragment matches literally", title_matches_partials('Semaglutide 10mg', ['10mg']), true)
+  assert("dot is not a wildcard", title_matches_partials('Semaglutide 0x25mg', ['0.25']), false)
+  assert("dot matches itself", title_matches_partials('Semaglutide 0.25mg', ['0.25']), true)
+  assert("regex metacharacters are literal", title_matches_partials('Order (urgent)', ['(urgent)']), true)
+  assert("regex alternation is literal, not alternation", title_matches_partials('Endometriosis', ['Endo|Diabetes']), false)
+  assert("star is literal", title_matches_partials('a*b', ['a*b']), true)
+  assert("very long entry simply does not match", title_matches_partials('Endometriosis', ['E'.repeat(250)]), false)
+
+  // non-string entries from bad stored data must not throw
+  assert("non-string entries are ignored, not crashed on", title_matches_partials('Endometriosis', [null as any, 'Endo']), true)
+  assert("only non-string entries counts as unset", title_matches_partials('Common cold', [undefined as any]), true)
+}
+
+const run_all = () => {
+  console.log("Running trigger_title_partials unit tests")
+  run_unset_tests()
+  run_case_sensitive_tests()
+  run_case_insensitive_tests()
+  run_trimming_tests()
+  run_both_lists_tests()
+  run_missing_title_tests()
+  run_literal_matching_tests()
+  console.log(`\nResults: ${passed} passed, ${failures} failed`)
+  if (failures > 0) process.exit(1)
+}
+
+if (require.main === module) {
+  run_all()
+}
+
+export { run_all as trigger_title_partials_unit_tests }