Honor liveDebugger.enable: false to match other plugins

The previous commit reduced enablement to `!!config[CONFIG_KEY]`, which
meant `{ liveDebugger: { enable: false } }` silently kept the plugin
enabled. Every other plugin in this repo (`apps`, `error-tracking`,
`metrics`, `output`, `rum`) accepts an explicit `enable: false` — either
directly (`apps`) or implicitly via spread ordering (the rest).

Switch `validate.ts` to the explicit `apps`-style pattern:

    enable: pluginConfig.enable ?? !!config[CONFIG_KEY]

so that:
- omitted `liveDebugger` key            -> disabled
- `liveDebugger: {}`                    -> enabled
- `liveDebugger: { enable: true }`      -> enabled
- `liveDebugger: { enable: false }`     -> disabled

Also add a runtime `typeof enable === 'boolean'` check alongside the
existing boolean-option validations, and re-document `liveDebugger.enable`
in the README to match the `apps` README wording.

Test coverage:
- Restore the "return an empty array when enable is false" test in
  `index.test.ts`.
- Add `enable: false` / `enable: true` cases to `validateOptions` defaults
  tests and a new `invalid enable` describe block covering non-boolean
  inputs. Extend the `multiple errors` aggregate test to include `enable`.

Author: watson

packages/plugins/live-debugger/README.md

@@ -12,6 +12,7 @@ Automatically instrument JavaScript functions at build time to enable Live Debug
 -   [Required peer dependencies](#required-peer-dependencies)
 -   [Configuration](#configuration)
 -   [How it works](#how-it-works)
+    -   [liveDebugger.enable](#livedebuggerenable)
     -   [liveDebugger.include](#livedebuggerinclude)
     -   [liveDebugger.exclude](#livedebuggerexclude)
     -   [liveDebugger.honorSkipComments](#livedebuggerhonorskipcomments)
@@ -115,6 +116,12 @@ const double = (x) => {
 };
 ```
 
+### liveDebugger.enable
+
+> default: `true` when a `liveDebugger` config block is present
+
+Enable or disable the plugin without removing its configuration.
+
 ### liveDebugger.include
 
 > default: `[/\.[jt]sx?$/]`

packages/plugins/live-debugger/src/index.test.ts

@@ -294,6 +294,15 @@ describe('getLiveDebuggerPlugin', () => {
 });
 
 describe('getPlugins', () => {
+    it('should return an empty array when enable is false', () => {
+        const arg = getGetPluginsArg({ liveDebugger: { enable: false } });
+
+        const plugins = getPlugins(arg);
+
+        expect(plugins).toEqual([]);
+        expect(arg.context.inject).not.toHaveBeenCalled();
+    });
+
     it('should return an empty array when liveDebugger config is omitted', () => {
         const arg = getGetPluginsArg();
 

packages/plugins/live-debugger/src/validate.test.ts

@@ -50,6 +50,16 @@ describe('validateOptions', () => {
                     namedOnly: false,
                 } satisfies LiveDebuggerOptionsWithDefaults,
             },
+            {
+                description: 'honor enable: false even when the config key is present',
+                input: makeConfig({ enable: false }),
+                expected: expect.objectContaining({ enable: false }),
+            },
+            {
+                description: 'honor enable: true (redundant but valid)',
+                input: makeConfig({ enable: true }),
+                expected: expect.objectContaining({ enable: true }),
+            },
         ];
 
         test.each(cases)('should $description', ({ input, expected }) => {
@@ -210,6 +220,28 @@ describe('validateOptions', () => {
         });
     });
 
+    describe('invalid enable', () => {
+        const cases = [
+            {
+                description: 'reject enable when a string',
+                input: makeConfig({ enable: 'yes' }),
+            },
+            {
+                description: 'reject enable when a number',
+                input: makeConfig({ enable: 1 }),
+            },
+        ];
+
+        test.each(cases)('should $description', ({ input }) => {
+            expect(() => validateOptions(input, mockLogger)).toThrow(
+                `Invalid configuration for ${PLUGIN_NAME}.`,
+            );
+            expect(mockLogger.error).toHaveBeenCalledWith(
+                expect.stringMatching(/enable.*must be a boolean/),
+            );
+        });
+    });
+
     describe('invalid honorSkipComments', () => {
         const cases = [
             {
@@ -279,6 +311,7 @@ describe('validateOptions', () => {
     describe('multiple errors', () => {
         it('should aggregate all validation errors before throwing', () => {
             const input = makeConfig({
+                enable: 'yes',
                 include: 'bad',
                 exclude: 'bad',
                 honorSkipComments: 42,
@@ -291,6 +324,7 @@ describe('validateOptions', () => {
             );
 
             const errorMessage = (mockLogger.error as jest.Mock).mock.calls[0][0] as string;
+            expect(errorMessage).toMatch(/enable/);
             expect(errorMessage).toMatch(/include/);
             expect(errorMessage).toMatch(/exclude/);
             expect(errorMessage).toMatch(/honorSkipComments/);

packages/plugins/live-debugger/src/validate.ts

@@ -15,6 +15,11 @@ export const validateOptions = (config: Options, log: Logger): LiveDebuggerOptio
     const pluginConfig: LiveDebuggerOptions = config[CONFIG_KEY] || {};
     const errors: string[] = [];
 
+    // Validate enable option
+    if (pluginConfig.enable !== undefined && typeof pluginConfig.enable !== 'boolean') {
+        errors.push(`${red('enable')} must be a boolean`);
+    }
+
     // Validate include option
     if (pluginConfig.include !== undefined) {
         if (!Array.isArray(pluginConfig.include)) {
@@ -80,7 +85,7 @@ export const validateOptions = (config: Options, log: Logger): LiveDebuggerOptio
 
     // Build the final configuration with defaults
     return {
-        enable: !!config[CONFIG_KEY],
+        enable: pluginConfig.enable ?? !!config[CONFIG_KEY],
         include: pluginConfig.include || [/\.[jt]sx?$/], // .js, .jsx, .ts, .tsx
         exclude: pluginConfig.exclude || [
             /\/node_modules\//,