backend-manager 5.2.18 → 5.3.0

package/src/utils/merge-line-files.js

@@ -61,8 +61,10 @@ function mergeLineBasedFiles(existingContent, newContent, fileName) {
           continue;
         }
         if (existingCustomKeys.has(key)) {
-          // Key the user moved to custom — leave it in custom; emit empty default value.
-          emit(line);
+          // The framework newly adopted a key the user had in their Custom section.
+          // Promote it UP into Default with the user's value, and drop the Custom copy
+          // (handled below) so the key isn't duplicated / left empty.
+          emit(findKeyLine(existingCustom, key));
           continue;
         }
       }
@@ -97,10 +99,19 @@ function mergeLineBasedFiles(existingContent, newContent, fileName) {
     }
   }
 
-  // The user's Custom section is preserved verbatim — except .env values get
-  // normalized to double-quoted form so the file's quoting style is consistent.
+  // The user's Custom section is preserved — except (a) .env values get normalized
+  // to double-quoted form for consistent quoting, and (b) any key the framework just
+  // adopted into its Default section is dropped here, since it was promoted UP into
+  // Default above (otherwise the key would appear in both sections).
   const finalCustom = isEnvFile
-    ? existingCustom.map((line) => normalizeEnvLine(line))
+    ? existingCustom
+        .filter((line) => {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith('#')) return true;
+          const key = trimmed.split('=')[0].trim();
+          return !(key && newDefaultKeys.has(key));
+        })
+        .map((line) => normalizeEnvLine(line))
     : existingCustom;
 
   const result = [];

package/templates/_.env

@@ -34,6 +34,7 @@ SENDGRID_API_KEY=""
 BEEHIIV_API_KEY=""
 ZEROBOUNCE_API_KEY=""
 UNSUBSCRIBE_HMAC_KEY=""
+APOLLO_API_KEY=""
 
 # ========== Custom Values ==========
 # Add your custom environment variables below this line

package/test/events/payments/journey-payments-cancel-endpoint.js

@@ -14,10 +14,14 @@ module.exports = {
   tests: [
     {
       name: 'setup-paid-subscription',
-      async run({ accounts, firestore, assert, state, config, http, waitFor }) {
+      async run({ accounts, firestore, assert, state, config, http, waitFor, skip }) {
         const uid = accounts['journey-payments-cancel-route'].uid;
+        // Resolve first paid product from config. If the brand has none configured,
+        // skip the entire journey — this is a config-gap, not a code failure.
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
-        assert.ok(paidProduct, 'Config should have at least one paid product');
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         state.uid = uid;
         state.paidProductId = paidProduct.id;

package/test/events/payments/journey-payments-cancel.js

@@ -13,12 +13,15 @@ module.exports = {
   tests: [
     {
       name: 'setup-paid-subscription',
-      async run({ accounts, firestore, assert, state, config, http, waitFor }) {
+      async run({ accounts, firestore, assert, state, config, http, waitFor, skip }) {
         const uid = accounts['journey-payments-cancel'].uid;
 
-        // Resolve first paid product from config
+        // Resolve first paid product from config. If the brand has none configured,
+        // skip the entire journey — this is a config-gap, not a code failure.
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
-        assert.ok(paidProduct, 'Config should have at least one paid product');
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         state.uid = uid;
         state.paidProductId = paidProduct.id;

package/test/events/payments/journey-payments-failure.js

@@ -16,12 +16,15 @@ module.exports = {
   tests: [
     {
       name: 'setup-paid-subscription',
-      async run({ accounts, firestore, assert, state, config, http, waitFor }) {
+      async run({ accounts, firestore, assert, state, config, http, waitFor, skip }) {
         const uid = accounts['journey-payments-failure'].uid;
 
-        // Resolve first paid subscription product
+        // Resolve first paid subscription product. If the brand has none configured,
+        // skip the entire journey — this is a config-gap, not a code failure.
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.type === 'subscription' && p.prices);
-        assert.ok(paidProduct, 'Config should have at least one paid subscription product');
+        if (!paidProduct) {
+          skip('No paid subscription product configured in this brand');
+        }
 
         state.uid = uid;
         state.paidProductId = paidProduct.id;

package/test/events/payments/journey-payments-plan-change.js

@@ -13,12 +13,15 @@ module.exports = {
   tests: [
     {
       name: 'setup-paid-subscription',
-      async run({ accounts, firestore, assert, state, config, http, waitFor }) {
+      async run({ accounts, firestore, assert, state, config, http, waitFor, skip }) {
         const uid = accounts['journey-payments-plan-change'].uid;
 
-        // Resolve two distinct paid subscription products from config
+        // Resolve two distinct paid subscription products from config. If the brand
+        // has fewer than two, skip the journey — this is a config-gap, not a code failure.
         const paidProducts = config.payment.products.filter(p => p.id !== 'basic' && p.type === 'subscription' && p.prices);
-        assert.ok(paidProducts.length >= 2, 'Config should have at least two paid subscription products');
+        if (paidProducts.length < 2) {
+          skip('Fewer than two paid subscription products configured in this brand');
+        }
 
         const productA = paidProducts[0];
         const productB = paidProducts[1];

package/test/events/payments/journey-payments-refund-webhook.js

@@ -18,11 +18,15 @@ module.exports = {
   tests: [
     {
       name: 'setup-paid-subscription',
-      async run({ accounts, firestore, assert, state, config, http, waitFor }) {
+      async run({ accounts, firestore, assert, state, config, http, waitFor, skip }) {
         const uid = accounts['journey-payments-refund-webhook'].uid;
 
+        // Resolve a paid product with a monthly price. If the brand has none configured,
+        // skip the entire journey — this is a config-gap, not a code failure.
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices?.monthly);
-        assert.ok(paidProduct, 'Config should have at least one paid product with monthly price');
+        if (!paidProduct) {
+          skip('No paid product with monthly price configured in this brand');
+        }
 
         state.uid = uid;
         state.paidProductId = paidProduct.id;

package/test/events/payments/journey-payments-suspend.js

@@ -13,12 +13,15 @@ module.exports = {
   tests: [
     {
       name: 'setup-paid-subscription',
-      async run({ accounts, firestore, assert, state, config, http, waitFor }) {
+      async run({ accounts, firestore, assert, state, config, http, waitFor, skip }) {
         const uid = accounts['journey-payments-suspend'].uid;
 
-        // Resolve first paid product from config
+        // Resolve first paid product from config. If the brand has none configured,
+        // skip the entire journey — this is a config-gap, not a code failure.
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
-        assert.ok(paidProduct, 'Config should have at least one paid product');
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         state.uid = uid;
         state.paidProductId = paidProduct.id;

package/test/events/payments/journey-payments-trial-cancel.js

@@ -16,7 +16,7 @@ module.exports = {
   tests: [
     {
       name: 'verify-starts-as-basic',
-      async run({ accounts, firestore, assert, state, config }) {
+      async run({ accounts, firestore, assert, state, config, skip }) {
         const uid = accounts['journey-payments-trial-cancel'].uid;
         const userDoc = await firestore.get(`users/${uid}`);
 
@@ -24,9 +24,12 @@ module.exports = {
         assert.equal(userDoc.subscription?.product?.id, 'basic', 'Should start as basic');
         assert.equal(userDoc.subscription?.trial?.claimed, false, 'Trial should not be claimed');
 
-        // Resolve first paid product with trial from config
+        // Resolve first paid product with trial from config. If the brand has none
+        // configured, skip the entire journey — this is a config-gap, not a code failure.
         const trialProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices && p.trial?.days);
-        assert.ok(trialProduct, 'Config should have at least one paid product with trial');
+        if (!trialProduct) {
+          skip('No paid product with trial configured in this brand');
+        }
 
         state.uid = uid;
         state.paidProductId = trialProduct.id;

package/test/events/payments/journey-payments-trial.js

@@ -13,7 +13,7 @@ module.exports = {
   tests: [
     {
       name: 'verify-starts-as-basic',
-      async run({ accounts, firestore, assert, state, config }) {
+      async run({ accounts, firestore, assert, state, config, skip }) {
         const uid = accounts['journey-payments-trial'].uid;
         const userDoc = await firestore.get(`users/${uid}`);
 
@@ -21,9 +21,15 @@ module.exports = {
         assert.equal(userDoc.subscription?.product?.id, 'basic', 'Should start as basic');
         assert.equal(userDoc.subscription?.trial?.claimed, false, 'Trial should not be claimed');
 
-        // Resolve first paid product from config
-        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
-        assert.ok(paidProduct, 'Config should have at least one paid product');
+        // Resolve first paid product WITH a trial from config. The test processor
+        // only creates a trialing subscription when product.trial.days > 0, so a
+        // brand whose paid products all have trial.days: 0 (e.g. trials disabled)
+        // has nothing to exercise here — skip the journey. This is a config-gap,
+        // not a code failure, and mirrors journey-payments-trial-cancel.js.
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices && p.trial?.days);
+        if (!paidProduct) {
+          skip('No paid product with trial configured in this brand');
+        }
 
         state.uid = uid;
         state.paidProductId = paidProduct.id;

package/test/events/payments/journey-payments-uid-resolution.js

@@ -21,11 +21,15 @@ module.exports = {
   tests: [
     {
       name: 'setup-paid-subscription',
-      async run({ accounts, firestore, assert, state, config, http, waitFor }) {
+      async run({ accounts, firestore, assert, state, config, http, waitFor, skip }) {
         const uid = accounts['journey-payments-uid-resolution'].uid;
 
+        // Resolve a paid product with a monthly price. If the brand has none configured,
+        // skip the entire journey — this is a config-gap, not a code failure.
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices?.monthly);
-        assert.ok(paidProduct, 'Config should have at least one paid product with monthly price');
+        if (!paidProduct) {
+          skip('No paid product with monthly price configured in this brand');
+        }
 
         state.uid = uid;
         state.paidProductId = paidProduct.id;

package/test/events/payments/journey-payments-upgrade.js

@@ -13,7 +13,7 @@ module.exports = {
   tests: [
     {
       name: 'verify-starts-as-basic',
-      async run({ accounts, firestore, assert, state, config }) {
+      async run({ accounts, firestore, assert, state, config, skip }) {
         const uid = accounts['journey-payments-upgrade'].uid;
         const userDoc = await firestore.get(`users/${uid}`);
 
@@ -21,9 +21,12 @@ module.exports = {
         assert.equal(userDoc.subscription?.product?.id, 'basic', 'Should start as basic');
         assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
 
-        // Resolve first paid product from config
+        // Resolve first paid product from config. If the brand has none configured,
+        // skip the entire journey — this is a config-gap, not a code failure.
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
-        assert.ok(paidProduct, 'Config should have at least one paid product');
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
 
         state.uid = uid;
         state.paidProductId = paidProduct.id;

package/test/helpers/content/ghostii-blocks.js

@@ -0,0 +1,134 @@
+/**
+ * Test: content/ghostii.blocksToPost()
+ * Unit tests for the Ghostii-JSON → BEM-post transform.
+ *
+ * Run: npx mgr test helpers/content/ghostii-blocks
+ *
+ * Ghostii is unopinionated about BEM: its /write/article response is a generic
+ * block array ([{ name, content }], name ∈ heading-1..6/image/paragraph/blockquote/list).
+ * blocksToPost() is the SSOT that turns those blocks into what admin/post wants —
+ * title + header image as SEPARATE fields, body = content only.
+ *
+ * Pure function (no I/O) → required directly and called with plain inputs. NOT a mock.
+ *
+ * Contract:
+ *   - title          ← first heading-1 block, leading markdown `#` stripped
+ *   - headerImageUrl ← first image block's URL (from `![alt](url)`)
+ *   - body           ← every remaining block, joined with blank lines, trimmed
+ *   - the title block and the header-image block are EXCLUDED from body
+ *   - section images (non-first image blocks) STAY in the body
+ *   - non-array / empty input → all empty strings
+ */
+const { blocksToPost } = require('../../../src/manager/libraries/content/ghostii.js');
+
+module.exports = {
+  description: 'content/ghostii.blocksToPost()',
+  type: 'group',
+
+  tests: [
+    {
+      name: 'extracts-title-from-heading-1-stripping-marker',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-1', content: '# My Great Article' },
+          { name: 'paragraph', content: 'Body.' },
+        ]);
+        assert.equal(result.title, 'My Great Article');
+      },
+    },
+
+    {
+      name: 'extracts-header-image-url-from-first-image-block',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-1', content: '# Title' },
+          { name: 'image', content: '![Title](https://images.unsplash.com/photo-abc?w=1080)' },
+          { name: 'paragraph', content: 'Body.' },
+        ]);
+        assert.equal(result.headerImageUrl, 'https://images.unsplash.com/photo-abc?w=1080');
+      },
+    },
+
+    {
+      name: 'body-excludes-title-and-header-image',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-1', content: '# Title' },
+          { name: 'image', content: '![Title](https://img/header.jpg)' },
+          { name: 'heading-2', content: '## First Section' },
+          { name: 'paragraph', content: 'First paragraph.' },
+        ]);
+        assert.equal(result.body, '## First Section\n\nFirst paragraph.', 'body is content only');
+        assert.notMatch(result.body, /^#\s/m, 'no H1 title in body');
+        assert.notMatch(result.body, /^!\[Title\]\(https:\/\/img\/header\.jpg\)/m, 'no header image in body');
+      },
+    },
+
+    {
+      name: 'keeps-section-images-in-body',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-1', content: '# Title' },
+          { name: 'image', content: '![Title](https://img/header.jpg)' },
+          { name: 'heading-2', content: '## Section' },
+          { name: 'paragraph', content: 'Text.' },
+          { name: 'image', content: '![Section](https://img/section.jpg)' },
+          { name: 'paragraph', content: 'More text.' },
+        ]);
+        // Only the FIRST image is the header; later images belong to the body.
+        assert.ok(result.body.includes('![Section](https://img/section.jpg)'), 'section image stays in body');
+        assert.equal((result.body.match(/!\[/g) || []).length, 1, 'exactly one (section) image in body');
+      },
+    },
+
+    {
+      name: 'preserves-blockquotes-and-lists-in-body',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-1', content: '# Title' },
+          { name: 'heading-2', content: '## Section' },
+          { name: 'blockquote', content: '> A pithy quote.' },
+          { name: 'list', content: '- one\n- two' },
+        ]);
+        assert.ok(result.body.includes('> A pithy quote.'), 'blockquote kept');
+        assert.ok(result.body.includes('- one\n- two'), 'list kept');
+      },
+    },
+
+    {
+      name: 'handles-missing-heading-1-and-image-gracefully',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'heading-2', content: '## Only Section' },
+          { name: 'paragraph', content: 'Text.' },
+        ]);
+        assert.equal(result.title, '', 'no title when no heading-1');
+        assert.equal(result.headerImageUrl, '', 'no header image when no image block');
+        assert.equal(result.body, '## Only Section\n\nText.', 'body is all blocks when nothing excluded');
+      },
+    },
+
+    {
+      name: 'uses-only-the-first-image-as-header',
+      async run({ assert }) {
+        const result = blocksToPost([
+          { name: 'image', content: '![first](https://img/first.jpg)' },
+          { name: 'paragraph', content: 'Text.' },
+          { name: 'image', content: '![second](https://img/second.jpg)' },
+        ]);
+        assert.equal(result.headerImageUrl, 'https://img/first.jpg', 'first image is the header');
+        assert.ok(result.body.includes('https://img/second.jpg'), 'second image stays in body');
+        assert.ok(!result.body.includes('https://img/first.jpg'), 'first image not in body');
+      },
+    },
+
+    {
+      name: 'non-array-or-empty-input-returns-empty-strings',
+      async run({ assert }) {
+        assert.deepEqual(blocksToPost([]), { title: '', headerImageUrl: '', body: '' }, 'empty array');
+        assert.deepEqual(blocksToPost(null), { title: '', headerImageUrl: '', body: '' }, 'null');
+        assert.deepEqual(blocksToPost(undefined), { title: '', headerImageUrl: '', body: '' }, 'undefined');
+      },
+    },
+  ],
+};

package/test/helpers/environment.js

@@ -0,0 +1,230 @@
+/**
+ * Test: environment detection + URL helpers
+ * Covers the Manager's getEnvironment() SSOT, the derived is*() checks, the URL
+ * builders (getApiUrl / getFunctionsUrl / getWebsiteUrl + parent variants), and the
+ * assistant→Manager forwarding.
+ *
+ * Run: npx mgr test bem:helpers/environment
+ *
+ * Contract (see docs/environment-detection.md):
+ *   - getEnvironment() is the SINGLE SOURCE OF TRUTH — the only reader of the raw env
+ *     vars (BEM_TESTING / ENVIRONMENT / FUNCTIONS_EMULATOR / TERM_PROGRAM). Returns
+ *     exactly ONE of 'development' | 'testing' | 'production' (testing wins).
+ *   - isDevelopment()/isProduction()/isTesting() DERIVE from getEnvironment() — they
+ *     never read raw signals, so they can NEVER disagree with it. Exactly one is true.
+ *   - getApiUrl/getFunctionsUrl/getWebsiteUrl resolve LOCAL in dev OR testing, prod
+ *     otherwise. The parent helpers ALWAYS return the live URL (no localhost).
+ *   - The assistant forwards each method to its Manager (identical results).
+ */
+
+// Run a thunk with the env-detection vars cleared, restoring them afterward. These are
+// the only inputs getEnvironment() reads, so clearing them gives a clean slate per case.
+function withEnv(overrides, fn) {
+  const KEYS = ['BEM_TESTING', 'ENVIRONMENT', 'FUNCTIONS_EMULATOR', 'TERM_PROGRAM'];
+  const saved = {};
+  for (const k of KEYS) saved[k] = process.env[k];
+  try {
+    for (const k of KEYS) delete process.env[k];
+    for (const k of Object.keys(overrides)) process.env[k] = overrides[k];
+    return fn();
+  } finally {
+    for (const k of KEYS) {
+      if (saved[k] === undefined) delete process.env[k];
+      else process.env[k] = saved[k];
+    }
+  }
+}
+
+module.exports = {
+  description: 'Environment detection + URL helpers',
+  type: 'group',
+
+  tests: [
+    // ─── getEnvironment() resolution + precedence ───
+
+    {
+      name: 'getEnvironment: testing wins over everything (BEM_TESTING=true)',
+      async run({ Manager, assert }) {
+        withEnv({ BEM_TESTING: 'true', ENVIRONMENT: 'production' }, () => {
+          assert.equal(Manager.getEnvironment(), 'testing');
+        });
+      },
+    },
+    {
+      name: 'getEnvironment: production when ENVIRONMENT=production (not testing)',
+      async run({ Manager, assert }) {
+        withEnv({ ENVIRONMENT: 'production' }, () => {
+          assert.equal(Manager.getEnvironment(), 'production');
+        });
+      },
+    },
+    {
+      name: 'getEnvironment: development when ENVIRONMENT=development',
+      async run({ Manager, assert }) {
+        withEnv({ ENVIRONMENT: 'development' }, () => {
+          assert.equal(Manager.getEnvironment(), 'development');
+        });
+      },
+    },
+    {
+      name: 'getEnvironment: development when FUNCTIONS_EMULATOR is set',
+      async run({ Manager, assert }) {
+        withEnv({ FUNCTIONS_EMULATOR: 'true' }, () => {
+          assert.equal(Manager.getEnvironment(), 'development');
+        });
+      },
+    },
+    {
+      name: 'getEnvironment: defaults to production with no signal (deployed function)',
+      async run({ Manager, assert }) {
+        withEnv({}, () => {
+          assert.equal(Manager.getEnvironment(), 'production');
+        });
+      },
+    },
+
+    // ─── The KEY invariant: is*() derive from getEnvironment() and can NEVER disagree ───
+
+    {
+      name: 'invariant: is*() exactly matches getEnvironment() across every scenario',
+      async run({ Manager, assert }) {
+        const scenarios = [
+          { env: { BEM_TESTING: 'true', ENVIRONMENT: 'production' }, expect: 'testing' },
+          { env: { ENVIRONMENT: 'production' },                     expect: 'production' },
+          { env: { ENVIRONMENT: 'development' },                    expect: 'development' },
+          { env: { FUNCTIONS_EMULATOR: 'true' },                    expect: 'development' },
+          { env: {},                                                expect: 'production' },
+        ];
+        for (const s of scenarios) {
+          withEnv(s.env, () => {
+            const e = Manager.getEnvironment();
+            assert.equal(e, s.expect, `getEnvironment for ${JSON.stringify(s.env)}`);
+            // Each is*() must equal (getEnvironment() === its value) — no independent reads.
+            assert.equal(Manager.isDevelopment(), e === 'development', `isDevelopment for ${e}`);
+            assert.equal(Manager.isTesting(),     e === 'testing',     `isTesting for ${e}`);
+            assert.equal(Manager.isProduction(),  e === 'production',  `isProduction for ${e}`);
+          });
+        }
+      },
+    },
+    {
+      name: 'invariant: exactly one of is*() is true in every scenario (mutually exclusive)',
+      async run({ Manager, assert }) {
+        const envs = [
+          { BEM_TESTING: 'true' },
+          { ENVIRONMENT: 'production' },
+          { ENVIRONMENT: 'development' },
+          { FUNCTIONS_EMULATOR: 'true' },
+          {},
+        ];
+        for (const env of envs) {
+          withEnv(env, () => {
+            const trueCount = [Manager.isDevelopment(), Manager.isTesting(), Manager.isProduction()]
+              .filter(Boolean).length;
+            assert.equal(trueCount, 1, `exactly one true for ${JSON.stringify(env)}`);
+          });
+        }
+      },
+    },
+    {
+      name: 'isProduction is a real positive check (NOT just !isDevelopment) — false in testing',
+      async run({ Manager, assert }) {
+        withEnv({ BEM_TESTING: 'true' }, () => {
+          assert.equal(Manager.isDevelopment(), false, 'isDevelopment false in testing');
+          assert.equal(Manager.isProduction(),  false, 'isProduction false in testing');
+          assert.equal(Manager.isTesting(),     true,  'isTesting true in testing');
+        });
+      },
+    },
+
+    // ─── assistant forwards to the Manager (identical results) ───
+
+    {
+      name: 'assistant forwards getEnvironment()/is*() to the Manager (identical)',
+      async run({ Manager, assistant, assert }) {
+        const cases = [
+          { BEM_TESTING: 'true' },
+          { ENVIRONMENT: 'production' },
+          { ENVIRONMENT: 'development' },
+        ];
+        for (const env of cases) {
+          withEnv(env, () => {
+            assert.equal(assistant.getEnvironment(), Manager.getEnvironment(), 'getEnvironment forward');
+            assert.equal(assistant.isDevelopment(), Manager.isDevelopment(), 'isDevelopment forward');
+            assert.equal(assistant.isTesting(),     Manager.isTesting(),     'isTesting forward');
+            assert.equal(assistant.isProduction(),  Manager.isProduction(),  'isProduction forward');
+          });
+        }
+      },
+    },
+
+    // ─── URL helpers: local in dev/testing, production otherwise ───
+
+    {
+      name: 'getApiUrl: localhost in development AND testing, prod otherwise',
+      async run({ Manager, assert }) {
+        withEnv({ FUNCTIONS_EMULATOR: 'true' }, () => {
+          assert.equal(Manager.getApiUrl(), 'http://localhost:5002', 'dev → localhost');
+        });
+        withEnv({ BEM_TESTING: 'true' }, () => {
+          assert.equal(Manager.getApiUrl(), 'http://localhost:5002', 'testing → localhost');
+        });
+        withEnv({ ENVIRONMENT: 'production' }, () => {
+          assert.match(Manager.getApiUrl(), /^https:\/\/api\./, 'prod → api.<domain>');
+        });
+      },
+    },
+    {
+      name: 'getApiUrl: explicit env arg overrides current environment',
+      async run({ Manager, assert }) {
+        // Under the test harness we're in 'testing', but an explicit arg forces the mapping.
+        assert.equal(Manager.getApiUrl('development'), 'http://localhost:5002', "arg 'development' → localhost");
+        assert.match(Manager.getApiUrl('production'), /^https:\/\/api\./, "arg 'production' → prod");
+      },
+    },
+    {
+      name: 'getFunctionsUrl: localhost in development AND testing, cloudfunctions otherwise',
+      async run({ Manager, assert }) {
+        withEnv({ FUNCTIONS_EMULATOR: 'true' }, () => {
+          assert.match(Manager.getFunctionsUrl(), /^http:\/\/localhost:5001\//, 'dev → localhost:5001');
+        });
+        withEnv({ BEM_TESTING: 'true' }, () => {
+          assert.match(Manager.getFunctionsUrl(), /^http:\/\/localhost:5001\//, 'testing → localhost:5001');
+        });
+        withEnv({ ENVIRONMENT: 'production' }, () => {
+          assert.match(Manager.getFunctionsUrl(), /cloudfunctions\.net$/, 'prod → cloudfunctions.net');
+        });
+      },
+    },
+    {
+      name: 'getWebsiteUrl: localhost:4000 in development AND testing, brand.url otherwise',
+      async run({ Manager, assert }) {
+        withEnv({ FUNCTIONS_EMULATOR: 'true' }, () => {
+          assert.equal(Manager.getWebsiteUrl(), 'https://localhost:4000', 'dev → localhost:4000');
+        });
+        withEnv({ BEM_TESTING: 'true' }, () => {
+          assert.equal(Manager.getWebsiteUrl(), 'https://localhost:4000', 'testing → localhost:4000');
+        });
+        withEnv({ ENVIRONMENT: 'production' }, () => {
+          const url = Manager.getWebsiteUrl();
+          assert.equal(url.startsWith('https://localhost'), false, 'prod → NOT localhost');
+        });
+      },
+    },
+
+    // ─── Parent helpers ALWAYS resolve live (never localhost), even in dev/testing ───
+
+    {
+      name: 'getParentApiUrl / getParentUrl never redirect to localhost (always live)',
+      async run({ Manager, assert }) {
+        // Even under the test harness ('testing'), the parent is a real remote server.
+        const parentUrl = Manager.getParentUrl();
+        const parentApi = Manager.getParentApiUrl();
+        assert.equal((parentUrl || '').includes('localhost'), false, 'getParentUrl not localhost');
+        assert.equal((parentApi || '').includes('localhost'), false, 'getParentApiUrl not localhost');
+        // When set, the parent API URL carries the api. subdomain.
+        if (parentApi) assert.match(parentApi, /^https:\/\/api\./, 'parent api uses api. subdomain');
+      },
+    },
+  ],
+};