backend-manager 5.2.18 → 5.3.0

package/src/manager/libraries/email/generators/newsletter.js

@@ -9,7 +9,9 @@
  *   1. Read newsletter categories from Manager.config.marketing.beehiiv.content.categories
  *   2. Fetch ready sources from parent server (atomic claim via claimFor=brandId)
  *   3. structure.js → AI authors subject, preheader, intro, sections, signoff
- *   4. svg-illustrator.js → AI authors one SVG per section, rasterize to PNG
+ *   4. image-illustrator.js → AI generates one flat-vector PNG per section via
+ *      gpt-image-2 (default). Set content.method.image = 'svg' to use the legacy
+ *      svg-illustrator.js (AI writes an <svg>, resvg rasterizes it) instead.
  *   5. mjml-template.js → compile MJML → email-safe HTML
  *   6. Persist PNGs (caller-provided via opts.persistImage or default no-op)
  *   7. Mark sources as used on parent server
@@ -22,8 +24,19 @@ const fetch = require('wonderful-fetch');
 
 const { filterSources } = require('./lib/filter.js');
 const { generateStructure } = require('./lib/structure.js');
-const { generateSectionImage } = require('./lib/svg-illustrator.js');
+const { generateSectionImage: generateImageSection } = require('./lib/image-illustrator.js');
+const { generateSectionImage: generateSvgSection } = require('./lib/svg-illustrator.js');
 const { renderNewsletter } = require('./lib/mjml-template.js');
+
+// Default illustration method. 'image' = gpt-image-2 flat-vector PNGs (default).
+// 'svg' = legacy AI-authored SVG rasterized via resvg. Selected per-brand via
+// marketing.beehiiv.content.method.image.
+const DEFAULT_IMAGE_METHOD = 'image';
+
+function resolveSectionImageFn(newsletterConfig) {
+  const method = newsletterConfig?.method?.image || DEFAULT_IMAGE_METHOD;
+  return method === 'svg' ? generateSvgSection : generateImageSection;
+}
 const { renderMarkdown } = require('./lib/markdown-renderer.js');
 const { uploadAssets, RAW_BASE } = require('./lib/image-host.js');
 const { buildPublicConfig } = require('../../../routes/brand/get.js');
@@ -165,6 +178,7 @@ async function generate(Manager, assistant, settings, opts = {}) {
       return;
     }
 
+    const generateSectionImage = resolveSectionImageFn(config);
     const images = await Promise.all(
       structure.sections.map((s) => generateSectionImage({
         imagePrompt: s.image_prompt,

package/src/manager/libraries/payment/discount-codes.js

@@ -15,6 +15,7 @@ const DISCOUNT_CODES = {
   'WELCOME15': { percent: 15, duration: 'once' },
   'SAVE10': { percent: 10, duration: 'once' },
   'FLASH20': { percent: 20, duration: 'once' },
+  'GIFT15': { percent: 15, duration: 'once' },
 
   // Email campaigns (used by recurring sale seeds — restricted by audience)
   'UPGRADE15': {

package/src/manager/routes/admin/post/put.js

@@ -91,7 +91,7 @@ async function fetchPost(assistant, url) {
   const fetch = Manager.require('wonderful-fetch');
 
   // Use NEW API format
-  const result = await fetch(`${Manager.project.apiUrl}/backend-manager/content/post`, {
+  const result = await fetch(`${Manager.getApiUrl()}/backend-manager/content/post`, {
     method: 'get',
     response: 'json',
     timeout: 190000,

package/src/manager/routes/handler/post/post.js

@@ -100,7 +100,7 @@ module.exports = async ({ assistant, Manager, user, settings, analytics }) => {
   // Send notification (unless explicitly disabled)
   if (settings.sendNotification !== false) {
     // Use NEW API format
-    await fetch(`${Manager.project.apiUrl}/backend-manager/admin/notification`, {
+    await fetch(`${Manager.getApiUrl()}/backend-manager/admin/notification`, {
       method: 'POST',
       response: 'json',
       headers: {

package/src/manager/routes/payments/intent/processors/test.js

@@ -155,7 +155,7 @@ async function createOneTimeIntent({ uid, orderId, product, productId, confirmat
  * Fire-and-forget webhook to trigger the full pipeline
  */
 function fireWebhook({ event, assistant }) {
-  const webhookUrl = `${assistant.Manager.project.apiUrl}/backend-manager/payments/webhook?processor=test&key=${process.env.BACKEND_MANAGER_WEBHOOK_KEY}`;
+  const webhookUrl = `${assistant.Manager.getApiUrl()}/backend-manager/payments/webhook?processor=test&key=${process.env.BACKEND_MANAGER_WEBHOOK_KEY}`;
   fetch(webhookUrl, {
     method: 'POST',
     response: 'json',

package/src/manager/routes/user/delete.js

@@ -46,7 +46,7 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
   // Sign out of all sessions first
   assistant.log(`Signing out of all sessions for ${uid}...`);
 
-  await fetch(`${Manager.project.apiUrl}/backend-manager/user/sessions`, {
+  await fetch(`${Manager.getApiUrl()}/backend-manager/user/sessions`, {
     method: 'delete',
     timeout: 60000,
     response: 'json',

package/src/manager/routes/user/signup/post.js

@@ -478,9 +478,11 @@ function sendDiscountNudgeEmail(assistant, uid, firstName) {
 
 It's Ian, the founder of **${Manager.config.brand.name}**.
 
-As a thank-you for giving us a try, I'd love to send you a code for a **premium upgrade**. **Just reply to this email** and I'll get one over to you.
+As a thank-you for giving us a try, I'd love to send you a code for a **premium upgrade**.
 
-I read every reply, so if you have any questions, feedback, or there's anything I can help with, this is the place. Looking forward to hearing from you!`,
+**Just reply to this email** and I'll get one over to you.
+
+I read every reply and I'm looking forward to hearing from you!`,
       },
       signoff: {
         type: 'personal',

package/src/test/runner.js

@@ -186,7 +186,7 @@ class TestRunner {
         // the health endpoint re-reads the file as a freshness guard. By
         // construction these are equal — no mismatch warning needed.
         const emulatorExtended = !!response.data?.testExtendedMode;
-        console.log(chalk.gray(`  Mode: ${emulatorExtended ? 'EXTENDED (real APIs)' : 'normal (mocked)'}`));
+        console.log(chalk.gray(`  Mode: ${emulatorExtended ? 'extended (real external APIs)' : 'normal (external APIs skipped)'}`));
 
         return true;
       }
@@ -206,23 +206,32 @@ class TestRunner {
    * Setup test accounts - deletes existing test users and recreates them fresh
    */
   async setupAccounts() {
-    // Ensure meta/stats doc exists (required for on-create batch writes)
+    // Load the optional test/_init.js hooks from BOTH test roots (BEM core +
+    // consumer project): extra `accounts` to create and `setup()` to seed fixtures.
+    const initHooks = this.loadInitHooks();
+
+    // Flush the entire emulator Firestore + delete Auth test users (clean slate).
+    process.stdout.write(chalk.gray('  Wiping emulator + deleting test users... '));
+    const deleteResult = await testAccounts.deleteTestUsers(this.options.admin, initHooks.accounts);
+    console.log(chalk.green(`✓ (${deleteResult.deleted} deleted, ${deleteResult.skipped} skipped)`));
+
+    // Ensure meta/stats doc exists (required for on-create batch writes + the
+    // admin stats route). MUST run AFTER the wipe above — the flush recursively
+    // deletes every collection (including meta/stats), so seeding before it would
+    // be clobbered. Seeding here guarantees a `users` field survives even after
+    // the notification on-write trigger merges in its `notifications` counter.
     process.stdout.write(chalk.gray('  Ensuring meta/stats doc exists... '));
     await this.ensureMetaStats();
     console.log(chalk.green('✓'));
 
-    // Delete existing test user documents to ensure clean state
-    process.stdout.write(chalk.gray('  Deleting existing test users... '));
-    const deleteResult = await testAccounts.deleteTestUsers(this.options.admin);
-    console.log(chalk.green(`✓ (${deleteResult.deleted} deleted, ${deleteResult.skipped} skipped)`));
-
     process.stdout.write(chalk.gray('  Creating test accounts... '));
 
-    // Create fresh test accounts
+    // Create fresh test accounts (built-in + any project-defined via _init.js).
     const result = await testAccounts.createTestAccounts(
       this.options.admin,
       this.options.domain,
-      this.config
+      this.config,
+      initHooks.accounts
     );
 
     if (!result.success) {
@@ -232,8 +241,28 @@ class TestRunner {
 
     console.log(chalk.green(`✓ (${result.created} created)`));
 
-    // Fetch account privateKeys
-    this.accounts = await testAccounts.fetchPrivateKeys(this.options.admin, this.options.domain, this.config);
+    // Fetch account privateKeys (built-in + project-defined).
+    this.accounts = await testAccounts.fetchPrivateKeys(this.options.admin, this.options.domain, this.config, initHooks.accounts);
+
+    // Run custom setup hooks (BEM core first, then consumer). Runs AFTER the
+    // standard test accounts exist and AFTER the clean slate, so they can seed
+    // fixtures (brands, etc.) and reference the created accounts.
+    for (const setup of initHooks.setups) {
+      process.stdout.write(chalk.gray('  Running test/_init.js setup... '));
+      try {
+        await setup({
+          admin: this.options.admin,
+          config: this.config,
+          accounts: this.accounts,
+          Manager: this.config.Manager,
+          assistant: this.config.assistant,
+        });
+        console.log(chalk.green('✓'));
+      } catch (e) {
+        console.log(chalk.red(`✗ (${e.message})`));
+        return false;
+      }
+    }
 
     // Initialize rules testing context for security rules tests
     process.stdout.write(chalk.gray('  Initializing rules testing context... '));
@@ -253,23 +282,30 @@ class TestRunner {
   }
 
   /**
-   * Ensure meta/stats document exists (required for user count increments)
-   * Creates with initial values if missing, does not overwrite existing
+   * Ensure meta/stats document has a baseline `users` counter (required for user
+   * count increments and the admin stats route).
+   *
+   * Uses a MERGE write that always runs — it does NOT early-return when the doc
+   * already exists. The reason: the preceding emulator wipe recursively deletes
+   * the `notifications` collection, which fires the notification on-write *delete*
+   * trigger for each doc. Those triggers merge `{ notifications: increment(-1) }`
+   * into meta/stats and can race ahead of this seed, re-creating the doc as
+   * `{ notifications: { total: -N } }` with NO `users` field. A plain
+   * "create-if-missing" seed would then skip (doc.exists === true) and leave
+   * `users` absent — exactly the bug that made the admin stats tests flaky.
+   *
+   * Merging `{ users: { total: 0 } }` is safe to run unconditionally: it seeds the
+   * baseline without clobbering whatever `notifications` value those triggers land,
+   * and the real user-count increments overwrite total: 0 as accounts are created.
    */
   async ensureMetaStats() {
     const admin = this.options.admin;
     const statsRef = admin.firestore().doc('meta/stats');
 
-    const doc = await statsRef.get();
-    if (doc.exists) {
-      return; // Already exists, don't overwrite
-    }
-
-    // Create initial stats document
     await statsRef.set({
       users: { total: 0 },
       brand: this.options.brand?.id,
-    });
+    }, { merge: true });
   }
 
   /**
@@ -284,6 +320,87 @@ class TestRunner {
     }
   }
 
+  /**
+   * Load a single `test/_init.js` lifecycle hook from a test root.
+   *
+   * The module MUST export a function — `module.exports = (ctx) => ({ ... })` —
+   * called with `{ config, Manager }` and returning the hook object
+   * (`{ accounts, setup }`). This lets a project compute its accounts/fixtures
+   * from config at load time.
+   *
+   * Returns `{}` if the file doesn't exist, isn't a function, or fails to resolve.
+   */
+  loadInit(testDir, label) {
+    const initPath = path.join(testDir, '_init.js');
+
+    if (!jetpack.exists(initPath)) {
+      return {};
+    }
+
+    try {
+      const fn = require(initPath);
+
+      if (typeof fn !== 'function') {
+        console.log(chalk.red(`  ✗ ${label} test/_init.js must export a function: module.exports = (ctx) => ({ ... })`));
+        return {};
+      }
+
+      const mod = fn({ config: this.config, Manager: this.config?.Manager });
+      return mod && typeof mod === 'object' ? mod : {};
+    } catch (e) {
+      console.log(chalk.red(`  ✗ Failed to load ${label} test/_init.js: ${e.message}`));
+      return {};
+    }
+  }
+
+  /**
+   * Load and merge the `test/_init.js` lifecycle hooks from BOTH test roots —
+   * BEM core (`<bem>/test/_init.js`) and the consumer project
+   * (`<projectDir>/test/_init.js`). Same contract for both, so framework and
+   * consumer authors write the identical file shape. Each exports a function
+   * (see loadInit) returning:
+   *   - `accounts` — extra test accounts to create alongside the built-in ones,
+   *     each `{ id, uid, email, properties }` (email may use the `{domain}`
+   *     placeholder). One per lifecycle this project needs to exercise.
+   *   - `async setup({ admin, config, accounts, Manager, assistant })` — seed
+   *     fixtures (brands, etc.) AFTER the clean slate + account creation.
+   *
+   * There is no `cleanup` hook: the entire emulator Firestore is flushed before
+   * every run (deleteTestUsers → flushEmulatorFirestore) and each test cleans up
+   * after itself, so there is nothing project-level to tear down.
+   *
+   * Returns the merged extra `accounts` map (BEM core then consumer; consumer
+   * wins on key collision) and the ordered `setups` runners (BEM core first).
+   */
+  loadInitHooks() {
+    const bemTestsDir = path.resolve(__dirname, '../../test');
+    const projectTestsDir = path.join(this.options.projectDir, 'test');
+
+    const hooks = [
+      this.loadInit(bemTestsDir, 'BEM core'),
+      this.loadInit(projectTestsDir, 'project'),
+    ];
+
+    // Merge extra accounts from both roots. Accept either an array of account
+    // defs or a keyed object; normalize to a keyed object on `id`.
+    const accounts = {};
+    for (const h of hooks) {
+      const list = Array.isArray(h.accounts)
+        ? h.accounts
+        : Object.values(h.accounts || {});
+      for (const account of list) {
+        if (account && account.id) {
+          accounts[account.id] = account;
+        }
+      }
+    }
+
+    return {
+      accounts,
+      setups: hooks.filter((h) => typeof h.setup === 'function').map((h) => h.setup),
+    };
+  }
+
   /**
    * Discover test files in directory
    */
@@ -297,6 +414,11 @@ class TestRunner {
         continue;
       }
 
+      // Skip the _init.js lifecycle hook — it's run by setupAccounts(), not as a test.
+      if (item === '_init.js') {
+        continue;
+      }
+
       // Skip legacy 'functions' directory unless --legacy flag is set
       if (item === 'functions' && !this.options.includeLegacy) {
         continue;

package/src/test/test-accounts.js

@@ -525,14 +525,19 @@ const TEST_ACCOUNTS = {
  * Get all test account definitions with resolved emails and dynamic product IDs
  * @param {string} domain - Domain for email addresses (e.g., 'itwcreativeworks.com')
  * @param {object} [config] - BEM config (used to resolve first paid product)
+ * @param {object} [extraAccounts] - Project-defined accounts from test/_init.js,
+ *   keyed by id, each `{ id, uid, email, properties }`. Merged after the built-in
+ *   accounts; a project account may override a built-in one by reusing its key.
  * @returns {object} Account definitions with resolved emails
  */
-function getAccountDefinitions(domain, config) {
+function getAccountDefinitions(domain, config, extraAccounts) {
   const paidProduct = getFirstPaidProduct(config);
   const accounts = {};
 
-  for (const [key, account] of Object.entries(TEST_ACCOUNTS)) {
-    const properties = JSON.parse(JSON.stringify(account.properties));
+  const all = { ...TEST_ACCOUNTS, ...(extraAccounts || {}) };
+
+  for (const [key, account] of Object.entries(all)) {
+    const properties = JSON.parse(JSON.stringify(account.properties || {}));
 
     // Replace hardcoded 'premium' product with the actual first paid product from config
     if (properties.subscription?.product?.id === 'premium') {
@@ -543,7 +548,7 @@ function getAccountDefinitions(domain, config) {
     accounts[key] = {
       id: account.id,
       uid: account.uid,
-      email: account.email.replace('{domain}', domain),
+      email: (account.email || '').replace('{domain}', domain),
       properties,
     };
   }
@@ -556,10 +561,11 @@ function getAccountDefinitions(domain, config) {
  * @param {object} admin - Firebase admin instance
  * @param {string} domain - Domain for email addresses (e.g., 'itwcreativeworks.com')
  * @param {object} [config] - BEM config (used to resolve first paid product)
+ * @param {object} [extraAccounts] - Project-defined accounts from test/_init.js
  * @returns {Promise<object>} Account credentials with privateKeys
  */
-async function fetchPrivateKeys(admin, domain, config) {
-  const definitions = getAccountDefinitions(domain, config);
+async function fetchPrivateKeys(admin, domain, config, extraAccounts) {
+  const definitions = getAccountDefinitions(domain, config, extraAccounts);
   const accounts = {};
 
   // Fetch all in parallel
@@ -626,50 +632,165 @@ async function fetchPrivateKeys(admin, domain, config) {
 async function createAccount(admin, account) {
   const userRef = admin.firestore().doc(`users/${account.uid}`);
 
-  // Create Firebase Auth user - triggers auth:on-create
-  await admin.auth().createUser({
-    uid: account.uid,
-    email: account.email,
-    password: uuid.v4(),
-    emailVerified: true,
-  });
+  // The Auth user for this UID was just deleted (deleteTestUsers). Its auth:on-delete
+  // trigger deletes the Firestore doc ASYNCHRONOUSLY and the emulator does NOT guarantee
+  // it fires (or finishes) before our subsequent createUser()'s auth:on-create. A stale
+  // on-delete can therefore land AFTER on-create and silently wipe the freshly-written
+  // doc — leaving the account with no api.clientId/privateKey. That intermittent clobber
+  // is what made the account-structure validation (and every downstream auth/payment test)
+  // flaky. We defend with a verify-and-repair retry: create → wait for the on-create write
+  // to be COMPLETE (api keys present, not just metadata.tag) → merge props → re-verify the
+  // keys survived. If a late on-delete clobbered the doc, recreate from scratch.
+  const maxAttempts = 3;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    // Create Firebase Auth user - triggers auth:on-create
+    await admin.auth().createUser({
+      uid: account.uid,
+      email: account.email,
+      password: uuid.v4(),
+      emailVerified: true,
+    }).catch(async (e) => {
+      // A retry may find the Auth user already present (its doc was clobbered, not the
+      // user). Delete it first so the fresh createUser re-fires a clean on-create.
+      if (e.code === 'auth/uid-already-exists') {
+        await admin.auth().deleteUser(account.uid).catch(() => {});
+        await waitForDocGone(userRef);
+        await admin.auth().createUser({
+          uid: account.uid,
+          email: account.email,
+          password: uuid.v4(),
+          emailVerified: true,
+        });
+      } else {
+        throw e;
+      }
+    });
+
+    // Wait for auth:on-create to COMPLETE. Poll on the api keys themselves — the fields the
+    // tests actually require — not just metadata.tag, which on its own doesn't prove the
+    // doc wasn't subsequently clobbered.
+    const ready = await waitForAccountReady(userRef);
+
+    // Merge test-specific properties (roles, subscription, etc.)
+    await userRef.set(account.properties, { merge: true });
+
+    // Re-verify after the merge: a late on-delete could have struck between the poll and
+    // here. If the api keys survived, the account is good. Otherwise loop and recreate.
+    const finalDoc = await userRef.get();
+    const data = finalDoc.data() || {};
+    if (ready && data.api?.clientId && data.api?.privateKey) {
+      return { uid: account.uid, email: account.email };
+    }
+
+    // Clobbered (or never completed). Tear down the Auth user so the next attempt starts
+    // from a clean slate, then retry.
+    if (attempt < maxAttempts) {
+      await admin.auth().deleteUser(account.uid).catch(() => {});
+      await waitForDocGone(userRef);
+    }
+  }
+
+  // Exhausted retries — return anyway so the runner reports the downstream failure with a
+  // meaningful test assertion rather than a setup throw.
+  return { uid: account.uid, email: account.email };
+}
 
-  // Wait for auth:on-create to COMPLETE
-  // We check for metadata.tag which is set at the END of on-create
+/**
+ * Poll until a user doc reflects a COMPLETE auth:on-create write (api keys present).
+ * Returns true if it became ready within the window, false on timeout.
+ */
+async function waitForAccountReady(userRef) {
   const maxWait = 15000;
   const pollInterval = 500;
   let waited = 0;
 
   while (waited < maxWait) {
     const doc = await userRef.get();
-    if (doc.exists && doc.data()?.metadata?.tag === 'auth:on-create') {
-      break;
+    const data = doc.exists ? doc.data() : null;
+    if (
+      data?.metadata?.tag === 'auth:on-create'
+      && data.api?.clientId
+      && data.api?.privateKey
+    ) {
+      return true;
     }
     await new Promise(resolve => setTimeout(resolve, pollInterval));
     waited += pollInterval;
   }
 
-  // Merge test-specific properties (roles, subscription, etc.)
-  await userRef.set(account.properties, { merge: true });
+  return false;
+}
 
-  return { uid: account.uid, email: account.email };
+/**
+ * Poll until a user doc no longer exists (on-delete settled). Bounded; best-effort.
+ */
+async function waitForDocGone(userRef) {
+  const maxWait = 10000;
+  const pollInterval = 200;
+  let waited = 0;
+
+  while (waited < maxWait) {
+    const doc = await userRef.get();
+    if (!doc.exists) {
+      return;
+    }
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+    waited += pollInterval;
+  }
+
+  // Fallback: force-delete the lingering doc so the next create starts clean.
+  await userRef.delete().catch(() => {});
+}
+
+/**
+ * Flush the ENTIRE emulator Firestore — every top-level collection, recursively.
+ *
+ * SAFETY: this is destructive, so it ONLY runs when connected to the Firestore
+ * emulator (`FIRESTORE_EMULATOR_HOST` is set — which the test command always
+ * sets). If that env var is absent, this is a no-op, so it can never wipe a real
+ * project's data. The emulator DB is entirely test data, so a full flush is the
+ * simplest correct "clean slate" — no per-collection allowlist to maintain.
+ *
+ * @param {object} admin - Firebase admin instance
+ */
+async function flushEmulatorFirestore(admin) {
+  if (!process.env.FIRESTORE_EMULATOR_HOST) {
+    // Not pointed at the emulator — refuse to mass-delete. No-op.
+    return;
+  }
+
+  const firestore = admin.firestore();
+  const collections = await firestore.listCollections().catch(() => []);
+
+  await Promise.all(
+    collections.map((collectionRef) => firestore.recursiveDelete(collectionRef).catch(() => {}))
+  );
 }
 
 /**
  * Delete all test users (both Auth and Firestore)
- * Uses TEST_ACCOUNTS as the source of truth for which UIDs to delete
- * Deleting Auth users triggers on-delete which handles Firestore doc + count decrement
- * Waits for Firestore docs to be deleted before returning to ensure clean state
- * Called before test runs to ensure clean state
+ * Uses TEST_ACCOUNTS (+ any project-defined accounts) as the source of truth for
+ * which UIDs to delete. Deleting Auth users triggers on-delete which handles
+ * Firestore doc + count decrement.
+ * Called before test runs to ensure a clean slate. Flushes the ENTIRE emulator
+ * Firestore (the emulator DB is 100% test data — there's nothing to preserve),
+ * then deletes the Auth test users. `test/_init.js`'s `setup()` reseeds fixtures
+ * afterward. Waits for Firestore docs to be deleted before returning.
  * @param {object} admin - Firebase admin instance
+ * @param {object} [extraAccounts] - Project-defined accounts from test/_init.js
  * @returns {Promise<object>} Result with deleted count
  */
-async function deleteTestUsers(admin) {
+async function deleteTestUsers(admin, extraAccounts) {
   const results = { deleted: [], skipped: [], failed: [] };
 
-  // Delete all known test accounts in parallel
+  // Wipe the entire emulator Firestore up front (guarded to emulator-only).
+  await flushEmulatorFirestore(admin);
+
+  // Delete all known test accounts in parallel (built-in + project-defined).
+  const allAccounts = { ...TEST_ACCOUNTS, ...(extraAccounts || {}) };
   await Promise.all(
-    Object.values(TEST_ACCOUNTS).map(async (account) => {
+    Object.values(allAccounts).map(async (account) => {
       try {
         // Delete Firebase Auth user (triggers on-delete which handles Firestore doc + count)
         await admin.auth().deleteUser(account.uid);
@@ -708,81 +829,16 @@ async function deleteTestUsers(admin) {
     })
   );
 
-  // Clean up payment-related collections for test accounts.
-  // Two passes per collection:
-  //   1. owner-keyed: query by owner ∈ test uids (Firestore `in` caps at 30; batch).
-  //   2. id-keyed:    delete any doc whose id starts with the `_test-` prefix.
-  // Pass 2 catches docs that have no owner field (e.g. dispute alerts, raw test webhooks).
-  // All test-fixture IDs MUST start with `_test-` — that's the cleanup contract.
-  const testUids = Object.values(TEST_ACCOUNTS).map(a => a.uid);
-  // Collections that may carry test data tied to a test user (owner-keyed) or
-  // identified solely by an `_test-` doc id prefix (id-keyed). All must be wiped
-  // at the start of every run so a test that died mid-execution leaves no
-  // ghosts. New collections that participate in tests MUST be added here too.
-  const testDataCollections = ['payments-orders', 'payments-webhooks', 'payments-intents', 'payments-disputes'];
-  // Collections that exist solely for tests — wipe in full. All docs in these
-  // collections come from tests, so a single recursive delete handles cleanup.
-  const testOnlyCollections = ['_test', '_test_query'];
-  const UID_BATCH_SIZE = 30;
-  const TEST_ID_PREFIX = '_test-';
-
-  const uidBatches = [];
-  for (let i = 0; i < testUids.length; i += UID_BATCH_SIZE) {
-    uidBatches.push(testUids.slice(i, i + UID_BATCH_SIZE));
+  // Realtime Database: wipe the `_test` namespace in full. (The Firestore-wide
+  // flush already ran in flushEmulatorFirestore() at the start of this function.)
+  // `admin.database()` throws synchronously when no Database URL is configured,
+  // so guard the whole thing — RTDB is optional for a project.
+  try {
+    await admin.database().ref('_test').remove();
+  } catch (e) {
+    // RTDB not configured / no database URL — ignore.
   }
 
-  await Promise.all([
-    // Mixed collections: scoped delete of test data only.
-    ...testDataCollections.map(async (collection) => {
-      // Pass 1 — owner-keyed
-      for (const batch of uidBatches) {
-        try {
-          const snapshot = await admin.firestore().collection(collection)
-            .where('owner', 'in', batch)
-            .get();
-
-          await Promise.all(
-            snapshot.docs.map(doc => doc.ref.delete())
-          );
-        } catch (e) {
-          // Collection may not exist yet, or doesn't carry an owner field — ignore
-        }
-      }
-
-      // Pass 2 — id-keyed (catches ownerless test docs)
-      // documentId() range scan: `_test-` ≤ id < `_test.` (the next ASCII char after `-` is `.`)
-      try {
-        const snapshot = await admin.firestore().collection(collection)
-          .where(admin.firestore.FieldPath.documentId(), '>=', TEST_ID_PREFIX)
-          .where(admin.firestore.FieldPath.documentId(), '<', '_test.')
-          .get();
-
-        await Promise.all(
-          snapshot.docs.map(doc => doc.ref.delete())
-        );
-      } catch (e) {
-        // Collection may not exist yet — ignore
-      }
-    }),
-    // Test-only Firestore collections: wipe in full.
-    ...testOnlyCollections.map(async (collection) => {
-      try {
-        const snapshot = await admin.firestore().collection(collection).get();
-        await Promise.all(snapshot.docs.map(doc => doc.ref.delete()));
-      } catch (e) {
-        // Collection may not exist yet — ignore
-      }
-    }),
-    // Realtime Database: wipe the `_test` namespace in full.
-    (async () => {
-      try {
-        await admin.database().ref('_test').remove();
-      } catch (e) {
-        // RTDB may not be configured for this project — ignore
-      }
-    })(),
-  ]);
-
   return {
     success: results.failed.length === 0,
     deleted: results.deleted.length,
@@ -798,10 +854,11 @@ async function deleteTestUsers(admin) {
  * @param {object} admin - Firebase admin instance
  * @param {string} domain - Domain for email addresses (e.g., 'itwcreativeworks.com')
  * @param {object} [config] - BEM config (used to resolve first paid product)
+ * @param {object} [extraAccounts] - Project-defined accounts from test/_init.js
  * @returns {Promise<object>} Result with created/failed counts
  */
-async function createTestAccounts(admin, domain, config) {
-  const definitions = getAccountDefinitions(domain, config);
+async function createTestAccounts(admin, domain, config, extraAccounts) {
+  const definitions = getAccountDefinitions(domain, config, extraAccounts);
   const results = { created: [], failed: [] };
 
   // Create all accounts in parallel