@omega.js/backend 0.1.0

package/test/cli/cross-platform.test.js

@@ -0,0 +1,168 @@
+/**
+ * Test: the CLI's host assumptions, pinned for a host that is not this one
+ * ([#769](https://github.com/Omega-JS-Stack/omega/issues/769)).
+ *
+ * Every case here used to be a Unix-only line: `sh -c` with no `sh` to run it,
+ * a `--exec` whose hand-quoted path lost its backslashes, an install hint that
+ * told a Windows box to use Homebrew, an `lsof` diagnostic that threw. The
+ * platform is an ARGUMENT throughout, so the Windows branch is proven from a
+ * Mac — nothing here spawns anything, which is the point: what a spawn WOULD
+ * be is decided by pure functions, and those are what a test can hold.
+ *
+ * Run: npx omega test backend:cli/cross-platform
+ */
+const { shellInvocation, pathInvocation } = require('../../dist/cli/utils/spawn-shell.js');
+const { javaInstallHint } = require('../../dist/cli/commands/setup-tests/helpers.js');
+const WatchCommand = require('../../dist/cli/commands/watch.js');
+const BaseCommand = require('../../dist/cli/commands/base-command.js');
+const defineCases = require('../../dist/vendor/devkit/test/define-cases.js');
+
+const { reloadTriggerExec } = WatchCommand;
+
+// A port the OS hands out on demand and releases at once: free by
+// construction at the moment the case reads it.
+function freePort() {
+  return new Promise((resolve, reject) => {
+    const server = require('node:net').createServer();
+    server.unref();
+    server.on('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+  });
+}
+
+// The `node -e "<script>"` half of an --exec line, unwrapped.
+function scriptOf(execLine) {
+  return execLine.slice('node -e "'.length, execLine.lastIndexOf('" && echo'));
+}
+
+module.exports = defineCases({
+  description: 'Cross-platform CLI internals — the shell, the trigger script, the hints, the port probe',
+  type: 'group',
+
+  tests: [
+    {
+      name: 'a-command-line-runs-through-the-hosts-own-shell',
+      async run({ assert }) {
+        assert.deepEqual(
+          shellInvocation('firebase emulators:start --only functions', 'darwin'),
+          ['sh', ['-c', 'firebase emulators:start --only functions']],
+          'unix composes sh -c',
+        );
+        assert.deepEqual(
+          shellInvocation('firebase emulators:start --only functions', 'linux'),
+          ['sh', ['-c', 'firebase emulators:start --only functions']],
+          'linux is the same unix branch',
+        );
+        assert.deepEqual(
+          shellInvocation('firebase emulators:start --only functions', 'win32'),
+          ['cmd.exe', ['/c', 'firebase emulators:start --only functions']],
+          'windows has no sh — cmd.exe /c, and never shell:true (DEP0190)',
+        );
+      },
+    },
+
+    {
+      name: 'a-bare-name-is-resolved-by-the-host-never-by-us',
+      async run({ assert }) {
+        // The whole point of the pair: `commandOnPath` says nodemon EXISTS, and
+        // this says how to run it. On Windows that must go through cmd.exe, the
+        // only thing that applies PATHEXT to a bare name and can execute the
+        // `.cmd` shim npm installed.
+        assert.deepEqual(
+          pathInvocation('nodemon', ['--watch', '/src'], 'darwin'),
+          ['nodemon', ['--watch', '/src']],
+          'unix spawns the name directly — execvp searches PATH, and the child stays the real process',
+        );
+        assert.deepEqual(
+          pathInvocation('nodemon', ['--watch', 'C:\\src'], 'win32'),
+          ['cmd.exe', ['/c', 'nodemon', '--watch', 'C:\\src']],
+          'windows goes through cmd.exe with the args still separate (Node quotes each one)',
+        );
+        assert.deepEqual(
+          pathInvocation('stripe', [], 'win32'),
+          ['cmd.exe', ['/c', 'stripe']],
+          'no args is still the shell branch',
+        );
+      },
+    },
+
+    {
+      name: 'the-reload-trigger-script-survives-a-windows-path',
+      async run({ assert }) {
+        const triggerFile = 'C:\\Users\\ian\\targets\\backend\\dist\\omega-reload-trigger.js';
+        const resetPaths = ['C:\\Users\\ian\\.temp\\dev.log.reset'];
+        const script = scriptOf(reloadTriggerExec({ triggerFile, resetPaths, message: '  x' }));
+
+        // Hand-written quotes made `\U` and `\d` into escape sequences, so node
+        // parsed the path into a different one and the trigger silently missed.
+        // eslint-disable-next-line no-new-func
+        const readBack = new Function(`${script.slice(0, script.indexOf(',fs='))};return f;`)();
+        assert.equal(readBack, triggerFile, 'the path node parses must be the path we meant');
+        assert.equal(script.includes('C:\\\\Users\\\\ian'), true, 'backslashes are escaped in the literal, not lost');
+        assert.equal(script.includes(`'${resetPaths[0]}'`), false, 'the sentinel path is escaped too, not raw');
+      },
+    },
+
+    {
+      name: 'the-reload-trigger-script-still-round-trips-a-unix-path',
+      async run({ assert }) {
+        const triggerFile = '/Users/ian/targets/backend/dist/omega-reload-trigger.js';
+        const line = reloadTriggerExec({
+          triggerFile,
+          resetPaths: ['/Users/ian/.temp/dev.log.reset'],
+          message: '  [@omega.js/backend] Triggered hot reload',
+        });
+        const script = scriptOf(line);
+
+        // eslint-disable-next-line no-new-func
+        const readBack = new Function(`${script.slice(0, script.indexOf(',fs='))};return f;`)();
+        assert.equal(readBack, triggerFile, 'the unix path is unchanged by the escaping');
+        assert.equal(line.endsWith('&& echo "  [@omega.js/backend] Triggered hot reload"'), true, 'the lane keeps its own line');
+        assert.equal(line.includes('touch '), false, 'touch is gone — it bumps mtime, and Firebase reloads on content');
+        assert.equal(line.includes('sleep'), false, 'sleep is a Unix binary; the settle wait is in-process');
+      },
+    },
+
+    {
+      name: 'the-java-hint-names-a-manager-the-host-actually-has',
+      async run({ assert }) {
+        assert.equal(javaInstallHint('darwin'), 'brew install openjdk');
+        assert.equal(javaInstallHint('win32').split('.')[0], 'winget install Microsoft', 'windows opens with winget');
+        assert.equal(javaInstallHint('linux'), 'sudo apt install default-jdk');
+
+        for (const platform of ['win32', 'linux']) {
+          assert.equal(javaInstallHint(platform).includes('brew install'), false, `${platform} has no Homebrew`);
+        }
+
+        // Same rule as the mkcert hint: the head of the line is pasteable, an
+        // alternative follows in a sentence. `(or: choco …)` inside the command
+        // is a command that does not run.
+        for (const platform of ['darwin', 'win32', 'linux']) {
+          const head = javaInstallHint(platform).split('.')[0];
+          assert.equal(/\(or\b|\bor:/.test(head), false, `${platform} splices an alternative into the command`);
+        }
+        assert.equal(/choco install openjdk/.test(javaInstallHint('win32')), true, 'chocolatey is still named');
+      },
+    },
+
+    {
+      name: 'the-port-diagnostic-is-unix-only-and-says-so',
+      async run({ assert }) {
+        const command = new BaseCommand({ firebaseProjectPath: process.cwd(), argv: {}, options: {} });
+
+        // lsof/ps do not exist on Windows. The enrichment answers "nobody to
+        // name" rather than throwing; isPortInUse() is the real check and is
+        // OS-agnostic, so nothing downstream depends on this.
+        // The port is one the OS just handed out and released, never a fixed
+        // number: the run's own emulators bind dynamic ports, and a fixed
+        // "free" port was found held by them.
+        const port = await freePort();
+        assert.equal(command.getProcessesOnPort(port, { platform: 'win32' }), null, 'win32 short-circuits');
+        assert.equal(command.getProcessesOnPort(port, { platform: 'darwin' }), null, 'a free port is null on unix too');
+      },
+    },
+  ],
+});

package/test/cli/custom-project-type.test.js

@@ -0,0 +1,426 @@
+/**
+ * A backend target in CUSTOM-SERVER mode
+ * ([#584](https://github.com/Omega-JS-Stack/omega/issues/584)).
+ *
+ * `targets.backend.projectType: 'custom'` runs the SAME backend — same routes,
+ * same schemas, same auth middleware, same helpers — as an Express app
+ * listening on `PORT` for a container host (Render & co) instead of exporting
+ * Cloud Functions. What it takes away is the FIREBASE lane: no Functions
+ * deploy, no emulator, no emulator test run.
+ *
+ * What these tests hold it to:
+ *   - the project type comes from the brand's omega.json5, not from a flag a
+ *     brand has to remember to pass to `Manager.init()`;
+ *   - a custom boot loads no `firebase-functions`, and every helper the
+ *     framework exposes — the auth middleware included — is there in both modes;
+ *   - the Firebase-only verbs REFUSE, loudly and with the lane that replaces
+ *     each, instead of running `firebase deploy` against a project that has no
+ *     functions in it;
+ *   - `omega setup` scaffolds no Firebase-only artifact — no firebase.json, no
+ *     rules, no indexes — and drops the checks that maintain them, while an
+ *     already-authored one is left alone
+ *     ([#614](https://github.com/Omega-JS-Stack/omega/issues/614));
+ *   - `omega build` is unchanged: a custom backend stages src/ → dist/ like
+ *     any other.
+ *
+ * Real config files on real temp dirs, the real Manager, the real command
+ * classes. The one seam is `powertools.execute` — stubbed to a recorder, so a
+ * deploy that DID reach the shell would be visible instead of running.
+ *
+ * Run: npx omega test backend:cli/custom-project-type
+ */
+const assert = require('node:assert');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const powertools = require('node-powertools');
+const { requiredEnvKeys } = require('../../dist/vendor/config/index.js');
+
+const { resolveProjectType, isCustomProject, FIREBASE_ONLY_VERBS, FIREBASE_ONLY_SCAFFOLD, FIREBASE_ONLY_SETUP_CHECKS } = require('../../dist/cli/utils/project-type.js');
+const BuildCommand = require('../../dist/cli/commands/build.js');
+const DeployCommand = require('../../dist/cli/commands/deploy.js');
+const EmulatorCommand = require('../../dist/cli/commands/emulator.js');
+const ServeCommand = require('../../dist/cli/commands/serve.js');
+const { ensureTarget } = require('../../dist/cli/utils/ensure-target.js');
+const { stageFunctions } = require('../../dist/cli/utils/stage-functions.js');
+const TestCommand = require('../../dist/cli/commands/test.js');
+const { getTests } = require('../../dist/cli/commands/setup-tests/index.js');
+const defineCases = require('../../dist/vendor/devkit/test/define-cases.js');
+
+const MANAGER_PATH = require.resolve('../../dist/manager/index.js');
+
+/**
+ * A backend target on disk: package.json, an authored src/, and a brand
+ * config declaring the project type (omitted = the firebase default).
+ */
+function targetDir({ projectType }) {
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'omega-project-type-')));
+  const backend = projectType ? { projectType } : {};
+
+  fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'fixture-backend', version: '0.0.0' }));
+  fs.mkdirSync(path.join(dir, 'config'));
+  fs.writeFileSync(path.join(dir, 'config', 'omega.json5'), JSON.stringify({
+    brand: { id: 'fixture', name: 'Fixture Brand', url: 'https://fixture.test' },
+    targets: { backend },
+  }));
+  fs.mkdirSync(path.join(dir, 'src'));
+  fs.writeFileSync(path.join(dir, 'src', 'index.js'), '// fixture backend entry\n');
+
+  return dir;
+}
+
+/** A `main` shaped like the CLI's, pointed at a fixture target. */
+function fakeMain(dir, argv = {}) {
+  return {
+    firebaseProjectPath: dir,
+    argv: { _: [], ...argv },
+    options: {},
+    testCount: 0,
+    testTotal: 0,
+  };
+}
+
+/**
+ * Run a command with console.log/error captured and `powertools.execute`
+ * swapped for a recorder — nothing this suite runs may reach a real shell.
+ */
+async function runCommand(CommandClass, dir, argv) {
+  const lines = [];
+  const shell = [];
+  const originalLog = console.log;
+  const originalError = console.error;
+  const originalExecute = powertools.execute;
+  const originalExitCode = process.exitCode;
+
+  console.log = (...args) => lines.push(args.map(String).join(' '));
+  console.error = (...args) => lines.push(args.map(String).join(' '));
+  powertools.execute = async (command) => { shell.push(command); return ''; };
+
+  try {
+    await new CommandClass(fakeMain(dir, argv)).execute();
+    return { output: lines.join('\n'), shell, exitCode: process.exitCode };
+  } finally {
+    console.log = originalLog;
+    console.error = originalError;
+    powertools.execute = originalExecute;
+    process.exitCode = originalExitCode;
+  }
+}
+
+/**
+ * The SCAFFOLD pass every verb runs (#675): ensureTarget() writes the config
+ * artifacts, then the stage builds dist/ — the same pair `ensureStaged()`
+ * makes. The CHECKS need a Firebase CLI and a network; which of them a custom
+ * target even RUNS is its own case below.
+ */
+function runSetupScaffold(dir) {
+  const lines = [];
+  const log = (message) => lines.push(String(message));
+
+  ensureTarget({ projectDir: dir, log });
+  stageFunctions({ projectDir: dir, log });
+
+  return { output: lines.join('\n') };
+}
+
+/** The target checks a target actually runs, by class name, in order. */
+function setupCheckNames(dir) {
+  return getTests({ main: { firebaseProjectPath: dir } }).map((test) => test.constructor.name);
+}
+
+/**
+ * Boot a REAL Manager against a fixture target, with every required env key
+ * present so the #581 boot guard passes, and restore the process env after.
+ */
+function bootManager(dir, options = {}) {
+  const saved = {};
+  for (const name of requiredEnvKeys('backend')) {
+    saved[name] = process.env[name];
+    process.env[name] = process.env[name] || 'fixture-value';
+  }
+
+  delete require.cache[MANAGER_PATH];
+  const FreshManager = require(MANAGER_PATH);
+
+  try {
+    return new FreshManager().init(null, { cwd: dir, log: false, ...options });
+  } finally {
+    for (const [name, value] of Object.entries(saved)) {
+      if (value === undefined) delete process.env[name];
+      else process.env[name] = value;
+    }
+    delete require.cache[MANAGER_PATH];
+  }
+}
+
+// Every helper a consumer's routes reach for through the Manager handle.
+const HELPERS = ['RouteContext', 'User', 'Analytics', 'ApiManager', 'Roles', 'Usage', 'Middleware', 'BackendRouter', 'EventMiddleware', 'Settings', 'Metadata', 'Email', 'AI', 'Utilities'];
+
+module.exports = defineCases({
+  description: "Backend custom-server mode (#584): the config switch, the boot, and the Firebase-only verbs' refusal",
+  type: 'group',
+
+  tests: [
+    {
+      name: 'the project type comes from the brand config, firebase by default',
+
+      run() {
+        const custom = targetDir({ projectType: 'custom' });
+        const firebase = targetDir({ projectType: 'firebase' });
+        const bare = targetDir({});
+
+        try {
+          assert.strictEqual(resolveProjectType(custom), 'custom');
+          assert.strictEqual(resolveProjectType(firebase), 'firebase');
+          assert.strictEqual(resolveProjectType(bare), 'firebase', 'an unset projectType is the Cloud Functions default');
+          assert.strictEqual(isCustomProject(custom), true);
+          assert.strictEqual(isCustomProject(bare), false);
+
+          // No consumer config at all (the framework booting itself) is not a
+          // custom backend — it is no backend target, and firebase is the answer
+          // that changes nothing.
+          assert.strictEqual(resolveProjectType(os.tmpdir()), 'firebase');
+        } finally {
+          for (const dir of [custom, firebase, bare]) fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+
+    {
+      name: 'a custom boot loads no firebase-functions, and every helper still answers',
+
+      run() {
+        const custom = targetDir({ projectType: 'custom' });
+        const firebase = targetDir({});
+
+        try {
+          const customManager = bootManager(custom);
+          assert.strictEqual(customManager.options.projectType, 'custom', 'the config is the switch — no init flag needed');
+          assert.strictEqual(customManager.libraries.functions, null, 'custom mode must not load firebase-functions');
+
+          const firebaseManager = bootManager(firebase);
+          assert.strictEqual(firebaseManager.options.projectType, 'firebase');
+          assert.ok(firebaseManager.libraries.functions, 'firebase mode still loads firebase-functions');
+
+          // The whole point of the mode: the SAME backend, minus the artifact.
+          for (const helper of HELPERS) {
+            assert.strictEqual(typeof customManager[helper], 'function', `${helper}() must work in custom mode`);
+            assert.strictEqual(typeof firebaseManager[helper], 'function', `${helper}() must work in firebase mode`);
+          }
+          assert.ok(customManager.config.brand.id, 'the config still resolves in custom mode');
+        } finally {
+          for (const dir of [custom, firebase]) fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+
+    {
+      name: 'an explicit init option still wins over the config',
+
+      run() {
+        const custom = targetDir({ projectType: 'custom' });
+
+        try {
+          const manager = bootManager(custom, { projectType: 'firebase' });
+          assert.strictEqual(manager.options.projectType, 'firebase', 'an explicit option is the caller saying so');
+          assert.ok(manager.libraries.functions);
+        } finally {
+          fs.rmSync(custom, { recursive: true, force: true });
+        }
+      },
+    },
+
+    {
+      name: 'omega deploy refuses in custom mode — nothing is staged, nothing reaches firebase',
+
+      async run() {
+        const dir = targetDir({ projectType: 'custom' });
+
+        try {
+          const run = await runCommand(DeployCommand, dir);
+
+          assert.deepStrictEqual(run.shell, [], 'a custom backend must never run `firebase deploy`');
+          assert.strictEqual(run.exitCode, 1, 'a refused deploy must fail the process, never read green');
+          assert.match(run.output, /custom/, 'the refusal must name the mode');
+          assert.match(run.output, /deploy/, 'the refusal must name the lane that replaces it');
+          assert.strictEqual(fs.existsSync(path.join(dir, 'dist')), false, 'the refusal comes BEFORE staging');
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+
+    {
+      name: 'every Firebase-only verb refuses in custom mode, each naming its replacement lane',
+
+      async run() {
+        const dir = targetDir({ projectType: 'custom' });
+
+        try {
+          assert.deepStrictEqual(
+            Object.keys(FIREBASE_ONLY_VERBS).sort(),
+            ['deploy', 'emulator', 'serve', 'test'],
+            'the refused verbs live in ONE table',
+          );
+
+          for (const [CommandClass, verb] of [[EmulatorCommand, 'emulator'], [ServeCommand, 'serve'], [TestCommand, 'test']]) {
+            const run = await runCommand(CommandClass, dir);
+
+            assert.deepStrictEqual(run.shell, [], `omega ${verb} must not reach the shell in custom mode`);
+            assert.strictEqual(run.exitCode, 1, `omega ${verb} must fail the process in custom mode`);
+            assert.match(run.output, /custom/, `omega ${verb} must name the mode`);
+            assert.ok(run.output.includes(FIREBASE_ONLY_VERBS[verb]), `omega ${verb} must print its own replacement lane: ${run.output}`);
+          }
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+
+    {
+      name: 'the brand-owned scripts are exactly the ones running a refused verb',
+
+      async run() {
+        // The declaration the manager walk and this framework's own scaffold
+        // both read (#689). It is DERIVED knowledge — a script key is the
+        // brand's in custom mode precisely because the verb it runs refuses —
+        // so it must never drift from the verb table beside it.
+        const { projectScripts, projectScriptsCustomOwned } = require('../../package.json');
+        const verbOf = (command) => (String(command).match(/(?:^|&& )omega (\S+)/) || [])[1];
+
+        for (const key of projectScriptsCustomOwned) {
+          assert.ok(projectScripts[key], `projectScriptsCustomOwned names ${key}, which projectScripts must declare`);
+          assert.ok(FIREBASE_ONLY_VERBS[verbOf(projectScripts[key])],
+            `\`${key}\` is only the brand's because \`omega ${verbOf(projectScripts[key])}\` refuses in custom mode`);
+        }
+
+        for (const [key, command] of Object.entries(projectScripts)) {
+          if (projectScriptsCustomOwned.includes(key)) continue;
+          assert.strictEqual(FIREBASE_ONLY_VERBS[verbOf(command)], undefined,
+            `\`${key}\` runs a verb this mode refuses — it belongs in projectScriptsCustomOwned`);
+        }
+      },
+    },
+
+    {
+      name: 'the verbs scaffold no Firebase-only file on a custom backend',
+
+      async run() {
+        const dir = targetDir({ projectType: 'custom' });
+
+        try {
+          const run = runSetupScaffold(dir);
+
+          for (const file of FIREBASE_ONLY_SCAFFOLD) {
+            assert.strictEqual(fs.existsSync(path.join(dir, file)), false, `a custom backend has no Firebase lane — the scaffold must not write ${file}: ${run.output}`);
+          }
+          assert.strictEqual(fs.existsSync(path.join(dir, 'dist', 'firestore.rules')), false, 'and no compiled rules artifact either — nothing deploys it');
+
+          // What custom mode does NOT take away: the project id, the authored
+          // entry, and the staged output every backend builds.
+          assert.strictEqual(fs.existsSync(path.join(dir, '.firebaserc')), true, 'the project id is still the backend\'s — the admin SDK reads it in both modes');
+          assert.strictEqual(fs.existsSync(path.join(dir, 'src', 'index.js')), true);
+          assert.strictEqual(fs.existsSync(path.join(dir, 'dist', 'index.js')), true);
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+
+    {
+      name: 'a firebase-mode backend scaffolds every one of them, exactly as before',
+
+      async run() {
+        const dir = targetDir({});
+
+        try {
+          const run = runSetupScaffold(dir);
+
+          for (const file of FIREBASE_ONLY_SCAFFOLD) {
+            assert.strictEqual(fs.existsSync(path.join(dir, file)), true, `the default mode is unchanged — ${file} must still be scaffolded: ${run.output}`);
+          }
+          assert.strictEqual(fs.existsSync(path.join(dir, 'dist', 'firestore.rules')), true, 'the stage still compiles the artifact firebase.json points at');
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+
+    {
+      name: 'the scaffold never rewrites what a custom project authored itself',
+
+      async run() {
+        const dir = targetDir({ projectType: 'custom' });
+        const authored = { functions: { source: 'functions' }, hosting: { public: 'public' } };
+        const authoredRules = "rules_version = '2';\nservice cloud.firestore {\n  match /databases/{database}/documents {\n    match /mine/{id} { allow read: if true; }\n  }\n}\n";
+
+        try {
+          // This brand runs custom mode AND keeps a firebase.json of its own
+          // (it deploys rules by hand, say). Skipping is not deleting — and not
+          // migrating it under the brand either.
+          fs.writeFileSync(path.join(dir, 'firebase.json'), JSON.stringify(authored));
+          fs.writeFileSync(path.join(dir, 'firestore.rules'), authoredRules);
+
+          runSetupScaffold(dir);
+
+          assert.deepStrictEqual(JSON.parse(fs.readFileSync(path.join(dir, 'firebase.json'), 'utf8')), authored, 'an authored firebase.json is left exactly as it was');
+          assert.strictEqual(fs.readFileSync(path.join(dir, 'firestore.rules'), 'utf8'), authoredRules);
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+
+    {
+      name: 'the Firebase-only target checks are dropped in custom mode, and only those',
+
+      async run() {
+        const custom = targetDir({ projectType: 'custom' });
+        const firebase = targetDir({});
+
+        try {
+          const full = setupCheckNames(firebase);
+          const kept = setupCheckNames(custom);
+
+          assert.strictEqual(
+            kept.length,
+            full.length - FIREBASE_ONLY_SETUP_CHECKS.length,
+            'every Firebase-only check, and no other, comes off the list',
+          );
+          assert.deepStrictEqual(kept, full.filter((name) => kept.includes(name)), 'the surviving checks keep their order');
+
+          // The two that matter most: one hard-FAILS a custom target ("this is
+          // not a firebase project"), the other writes the emulator config.
+          assert.strictEqual(kept.includes('IsFirebaseProjectTest'), false, 'a custom backend is not a broken Firebase project');
+          assert.strictEqual(kept.includes('EmulatorConfigTest'), false, 'there is no emulator to configure');
+
+          // Everything else is identical in both modes — that is the mode.
+          for (const check of ['OmegaConfigTest', 'GitignoreTest', 'ServiceAccountTest', 'ProjectDirectoriesTest']) {
+            assert.strictEqual(kept.includes(check), true, `${check} is not a Firebase-lane check`);
+          }
+        } finally {
+          for (const dir of [custom, firebase]) fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+
+    {
+      name: 'omega build is unchanged — a custom backend stages src/ into dist/',
+
+      async run() {
+        const dir = targetDir({ projectType: 'custom' });
+
+        try {
+          const run = await runCommand(BuildCommand, dir);
+
+          assert.strictEqual(fs.existsSync(path.join(dir, 'dist', 'index.js')), true, `the authored src/ should be staged: ${run.output}`);
+          assert.strictEqual(fs.existsSync(path.join(dir, 'dist', 'package.json')), true, 'the staged manifest is the build output the manager checks for');
+          assert.notStrictEqual(run.exitCode, 1, 'build is not a Firebase-only verb');
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+  ],
+});