@omega.js/desktop 0.1.0

package/dist/test/suites/main/menu.test.js

@@ -0,0 +1,419 @@
+// Main-process tests for lib/menu.js — file-based application menu + builder API.
+//
+// In the harness, no consumer src/menu/index.js exists, so menu falls back to
+// the default template. We then exercise the runtime define()/builder API.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'menu (main)',
+  cleanup: (ctx) => {
+    ctx.manager.menu.destroy();
+  },
+  tests: [
+    {
+      name: 'initialize ran (enabled by default)',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.menu._initialized).toBe(true);
+      },
+    },
+    {
+      name: 'no consumer definition file → default template loaded',
+      run: (ctx) => {
+        const items = ctx.manager.menu.getItems();
+        ctx.expect(Array.isArray(items)).toBe(true);
+        ctx.expect(items.length).toBeGreaterThan(0);
+
+        // Find expected top-level entries (some are platform-specific; Edit/View/Window are universal).
+        const labels = items.map((i) => i.label);
+        ctx.expect(labels).toContain('Edit');
+        ctx.expect(labels).toContain('View');
+        ctx.expect(labels).toContain('Window');
+      },
+    },
+    {
+      name: 'default template renders and Menu.setApplicationMenu was called',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.menu.isRendered()).toBe(true);
+        ctx.expect(ctx.manager.menu.getMenu()).toBeTruthy();
+      },
+    },
+    {
+      name: 'macOS: first menu is the app menu (productName)',
+      run: (ctx) => {
+        if (process.platform !== 'darwin') {
+          ctx.skip('macOS-only behavior');
+        }
+        // Menu falls back to brand.name when no productName is configured (lib/menu.js).
+        const productName = ctx.manager.config.app?.productName || ctx.manager.config.brand.name;
+        const items = ctx.manager.menu.getItems();
+        ctx.expect(items[0].label).toBe(productName);
+      },
+    },
+    {
+      name: 'define() runs the builder fn and replaces items',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu }) => {
+          menu.menu('Test', [
+            { label: 'Hello', click: () => {} },
+            { type: 'separator' },
+            { label: 'World', click: () => {} },
+          ]);
+        });
+
+        const items = ctx.manager.menu.getItems();
+        ctx.expect(items.length).toBe(1);
+        ctx.expect(items[0].label).toBe('Test');
+        ctx.expect(Array.isArray(items[0].submenu)).toBe(true);
+        ctx.expect(items[0].submenu.length).toBe(3);
+      },
+    },
+    {
+      name: 'define() throws on non-function input',
+      run: (ctx) => {
+        ctx.expect(() => ctx.manager.menu.define(null)).toThrow(/must be a function/);
+      },
+    },
+    {
+      name: 'menu.menu(label, items) appends a top-level entry',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu }) => {
+          menu.menu('First', [{ label: 'a' }]);
+          menu.menu('Second', [{ label: 'b' }]);
+        });
+        const labels = ctx.manager.menu.getItems().map((i) => i.label);
+        ctx.expect(labels).toEqual(['First', 'Second']);
+      },
+    },
+    {
+      name: 'useDefaults() replaces items with the platform default template',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu }) => {
+          menu.menu('Custom', [{ label: 'x' }]);
+          menu.useDefaults();
+        });
+        const labels = ctx.manager.menu.getItems().map((i) => i.label);
+        ctx.expect(labels).toContain('Edit');
+        ctx.expect(labels).not.toContain('Custom');
+      },
+    },
+    {
+      name: 'clear() empties the items list',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu }) => {
+          menu.menu('A', [{ label: 'a' }]);
+          menu.clear();
+        });
+        ctx.expect(ctx.manager.menu.getItems()).toEqual([]);
+      },
+    },
+    {
+      name: 'append() adds a raw descriptor at top level',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu }) => {
+          menu.append({ label: 'Raw', submenu: [{ label: 'inside' }] });
+        });
+        const items = ctx.manager.menu.getItems();
+        ctx.expect(items.length).toBe(1);
+        ctx.expect(items[0].label).toBe('Raw');
+      },
+    },
+    {
+      name: 'dynamic label functions are evaluated at resolve time',
+      run: (ctx) => {
+        let count = 0;
+        ctx.manager.menu.define(({ menu }) => {
+          menu.menu('Counter', [{ label: () => `Count: ${count}` }]);
+        });
+
+        const item = ctx.manager.menu.getItems()[0].submenu[0];
+        const resolved1 = ctx.manager.menu._resolveItem(item);
+        ctx.expect(resolved1.label).toBe('Count: 0');
+
+        count = 7;
+        const resolved2 = ctx.manager.menu._resolveItem(item);
+        ctx.expect(resolved2.label).toBe('Count: 7');
+      },
+    },
+    {
+      name: 'click handlers are wrapped to catch errors',
+      run: (ctx) => {
+        let called = false;
+        ctx.manager.menu.define(({ menu }) => {
+          menu.menu('M', [
+            { label: 'Boom', click: () => { called = true; throw new Error('boom'); } },
+          ]);
+        });
+        const inner = ctx.manager.menu.getItems()[0].submenu[0];
+        const resolved = ctx.manager.menu._resolveItem(inner);
+        resolved.click(null, null, null);
+        ctx.expect(called).toBe(true);
+      },
+    },
+    {
+      name: 'submenu items are recursively resolved',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu }) => {
+          menu.menu('Top', [
+            {
+              label: 'Parent',
+              submenu: [
+                { label: () => 'Dyn child' },
+                { type: 'separator' },
+              ],
+            },
+          ]);
+        });
+        const top = ctx.manager.menu.getItems()[0];
+        const resolved = ctx.manager.menu._resolveItem(top);
+        ctx.expect(resolved.submenu[0].label).toBe('Parent');
+        ctx.expect(resolved.submenu[0].submenu[0].label).toBe('Dyn child');
+        ctx.expect(resolved.submenu[0].submenu[1].type).toBe('separator');
+      },
+    },
+    {
+      name: 'default template includes platform-appropriate check-for-updates item',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        // Mac → main/check-for-updates; win/linux → help/check-for-updates.
+        const id = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
+        const item = ctx.manager.menu.find(id);
+        ctx.expect(item).toBeTruthy();
+        ctx.expect(typeof item.label).toBe('string');
+        ctx.expect(typeof item.click).toBe('function');
+      },
+    },
+    {
+      name: 'find returns null for unknown id',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.menu.find('does-not-exist')).toBe(null);
+      },
+    },
+    {
+      name: 'update patches label and re-renders',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        const id = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
+        const ok = ctx.manager.menu.update(id, { label: 'PROBE LABEL' });
+        ctx.expect(ok).toBe(true);
+        const item = ctx.manager.menu.find(id);
+        ctx.expect(item.label).toBe('PROBE LABEL');
+      },
+    },
+    {
+      name: 'update returns false for unknown id',
+      run: (ctx) => {
+        const ok = ctx.manager.menu.update('nope', { label: 'nope' });
+        ctx.expect(ok).toBe(false);
+      },
+    },
+    {
+      name: 'remove deletes item from tree',
+      run: (ctx) => {
+        // Recreate the default template so we have the item to remove (previous test may have mutated).
+        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        const id = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
+        ctx.expect(ctx.manager.menu.find(id)).toBeTruthy();
+
+        const removed = ctx.manager.menu.remove(id);
+        ctx.expect(removed).toBe(true);
+        ctx.expect(ctx.manager.menu.find(id)).toBe(null);
+
+        // Restore for subsequent tests.
+        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+      },
+    },
+    {
+      name: 'insertAfter splices in a new sibling by id-path',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        const anchor = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
+        const ok = ctx.manager.menu.insertAfter(anchor, { id: 'main/preferences', label: 'PREF PROBE' });
+        ctx.expect(ok).toBe(true);
+        ctx.expect(ctx.manager.menu.find('main/preferences')).toBeTruthy();
+      },
+    },
+    {
+      name: 'auto-updater status updates the menu item label',
+      run: async (ctx) => {
+        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+
+        // Force a known state and trigger menu update.
+        ctx.manager.autoUpdater._state = {
+          code: 'downloaded', version: '5.0.0', percent: 100, error: null, downloadedAt: Date.now(), lastCheckedAt: null,
+        };
+        ctx.manager.autoUpdater._updateMenuItem();
+
+        const id = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
+        const item = ctx.manager.menu.find(id);
+        ctx.expect(item.label).toContain('Restart to Update');
+        ctx.expect(item.label).toContain('5.0.0');
+        ctx.expect(item.enabled).toBe(true);
+      },
+    },
+    {
+      name: 'auto-updater downloading status disables item',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+
+        ctx.manager.autoUpdater._state = {
+          code: 'downloading', version: '5.0.0', percent: 42, error: null, downloadedAt: null, lastCheckedAt: null,
+        };
+        ctx.manager.autoUpdater._updateMenuItem();
+
+        const id = process.platform === 'darwin' ? 'main/check-for-updates' : 'help/check-for-updates';
+        const item = ctx.manager.menu.find(id);
+        ctx.expect(item.label).toContain('42%');
+        ctx.expect(item.enabled).toBe(false);
+      },
+    },
+    {
+      name: 'consumer function receives manager + menu builder + defaults',
+      run: (ctx) => {
+        let received;
+        ctx.manager.menu.define((arg) => {
+          received = arg;
+          arg.menu.menu('probe', []);
+        });
+        ctx.expect(received.manager).toBe(ctx.manager);
+        ctx.expect(typeof received.menu.menu).toBe('function');
+        ctx.expect(typeof received.menu.useDefaults).toBe('function');
+        ctx.expect(typeof received.menu.clear).toBe('function');
+        ctx.expect(typeof received.menu.append).toBe('function');
+        ctx.expect(typeof received.menu.find).toBe('function');
+        ctx.expect(typeof received.menu.has).toBe('function');
+        ctx.expect(typeof received.menu.insertBefore).toBe('function');
+        ctx.expect(typeof received.menu.appendTo).toBe('function');
+        ctx.expect(Array.isArray(received.defaults)).toBe(true);
+      },
+    },
+    {
+      name: 'menu.has reports presence by id-path',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.expect(ctx.manager.menu.has('edit/copy')).toBe(true);
+        ctx.expect(ctx.manager.menu.has('edit/does-not-exist')).toBe(false);
+      },
+    },
+    {
+      name: 'menu.hide / menu.show toggle visibility by id-path',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.manager.menu.hide('edit/copy');
+        ctx.expect(ctx.manager.menu.find('edit/copy').visible).toBe(false);
+        ctx.manager.menu.show('edit/copy');
+        ctx.expect(ctx.manager.menu.find('edit/copy').visible).toBe(true);
+      },
+    },
+    {
+      name: 'menu.enable toggles enabled by id-path',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        ctx.manager.menu.enable('edit/copy', false);
+        ctx.expect(ctx.manager.menu.find('edit/copy').enabled).toBe(false);
+        ctx.manager.menu.enable('edit/copy');
+        ctx.expect(ctx.manager.menu.find('edit/copy').enabled).toBe(true);
+      },
+    },
+    {
+      name: 'menu.insertBefore splices into a submenu by id-path',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+        const ok = ctx.manager.menu.insertBefore('edit/copy', { id: 'edit/probe', label: 'PROBE' });
+        ctx.expect(ok).toBe(true);
+        // Find the edit submenu and confirm probe is right before copy.
+        const edit = ctx.manager.menu.find('edit');
+        const sub  = edit.submenu;
+        const copyIdx  = sub.findIndex((i) => i.id === 'edit/copy');
+        const probeIdx = sub.findIndex((i) => i.id === 'edit/probe');
+        ctx.expect(probeIdx).toBe(copyIdx - 1);
+      },
+    },
+    {
+      name: 'menu.appendTo pushes into a submenu (creating it if absent)',
+      run: (ctx) => {
+        ctx.manager.menu.define(({ menu: m }) => {
+          m.menu('Tools', []);
+        });
+        const ok = ctx.manager.menu.appendTo('Tools', { id: 'tools/x', label: 'X' });
+        // 'Tools' was added with label='Tools' but no id field — appendTo lookups id-path,
+        // so this should miss. Use a different anchor that has an id.
+        ctx.expect(ok).toBe(false);
+
+        ctx.manager.menu.define(({ menu: m }) => {
+          m.append({ id: 'tools', label: 'Tools', submenu: [] });
+        });
+        const ok2 = ctx.manager.menu.appendTo('tools', { id: 'tools/x', label: 'X' });
+        ctx.expect(ok2).toBe(true);
+        ctx.expect(ctx.manager.menu.find('tools').submenu[0].id).toBe('tools/x');
+      },
+    },
+    {
+      name: 'menu deep-path lookup walks segments (view/developer/toggle-devtools)',
+      run: (ctx) => {
+        // Force isDevelopment() so the dev menu renders.
+        const orig = ctx.manager.isDevelopment;
+        ctx.manager.isDevelopment = () => true;
+        try {
+          ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+          ctx.expect(ctx.manager.menu.has('view/developer')).toBe(true);
+          ctx.expect(ctx.manager.menu.has('view/developer/toggle-devtools')).toBe(true);
+        } finally {
+          ctx.manager.isDevelopment = orig;
+        }
+      },
+    },
+    {
+      name: 'view/developer carries the Simulate update submenu (dev only)',
+      run: (ctx) => {
+        const orig = ctx.manager.isDevelopment;
+        ctx.manager.isDevelopment = () => true;
+        try {
+          ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+          const item = ctx.manager.menu.find('view/developer/simulate-update');
+          ctx.expect(item).toBeTruthy();
+          ctx.expect(item.label).toBe('Simulate update');
+          ctx.expect(item.submenu.map((i) => i.id)).toEqual([
+            'view/developer/simulate-update/available',
+            'view/developer/simulate-update/unavailable',
+            'view/developer/simulate-update/error',
+          ]);
+        } finally {
+          ctx.manager.isDevelopment = orig;
+        }
+
+        ctx.manager.isDevelopment = () => false;
+        try {
+          ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+          ctx.expect(ctx.manager.menu.has('view/developer/simulate-update')).toBe(false);
+        } finally {
+          ctx.manager.isDevelopment = orig;
+        }
+      },
+    },
+    {
+      name: 'menu development top-level appears only in dev mode',
+      run: (ctx) => {
+        const orig = ctx.manager.isDevelopment;
+        ctx.manager.isDevelopment = () => true;
+        try {
+          ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+          ctx.expect(ctx.manager.menu.has('development')).toBe(true);
+          ctx.expect(ctx.manager.menu.has('development/open-logs')).toBe(true);
+        } finally {
+          ctx.manager.isDevelopment = orig;
+        }
+
+        ctx.manager.isDevelopment = () => false;
+        try {
+          ctx.manager.menu.define(({ menu: m }) => m.useDefaults());
+          ctx.expect(ctx.manager.menu.has('development')).toBe(false);
+        } finally {
+          ctx.manager.isDevelopment = orig;
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/main/protocol.test.js

@@ -0,0 +1,77 @@
+// Main-layer tests for lib/protocol.js — single-instance lock + custom URL scheme.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'protocol (main)',
+  tests: [
+    {
+      name: 'protocol module is loaded on the manager',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.protocol).toBeDefined();
+        ctx.expect(ctx.manager.protocol._initialized).toBe(true);
+      },
+    },
+    {
+      name: 'hasSingleInstanceLock returns true (test process owns the lock)',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.protocol.hasSingleInstanceLock()).toBe(true);
+      },
+    },
+    {
+      name: 'getSchemes returns brand.id when configured',
+      run: (ctx) => {
+        const schemes = ctx.manager.protocol.getSchemes();
+        ctx.expect(Array.isArray(schemes)).toBe(true);
+        const brandId = ctx.manager.config?.brand?.id;
+        if (brandId) {
+          ctx.expect(schemes).toContain(brandId);
+        }
+      },
+    },
+    {
+      name: 'getSchemes returns a fresh copy each call (mutation safe)',
+      run: (ctx) => {
+        const a = ctx.manager.protocol.getSchemes();
+        const b = ctx.manager.protocol.getSchemes();
+        ctx.expect(a).not.toBe(b);   // different array instances
+        ctx.expect(a).toEqual(b);    // same contents
+      },
+    },
+    {
+      name: 'isOurScheme matches registered scheme',
+      run: (ctx) => {
+        const brandId = ctx.manager.config?.brand?.id;
+        if (!brandId) return ctx.skip('no brand.id configured');
+        ctx.expect(ctx.manager.protocol.isOurScheme(`${brandId}://auth/token?t=abc`)).toBe(true);
+      },
+    },
+    {
+      name: 'isOurScheme rejects unregistered schemes',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.protocol.isOurScheme('https://example.com')).toBe(false);
+        ctx.expect(ctx.manager.protocol.isOurScheme('imaginary-scheme://x')).toBe(false);
+      },
+    },
+    {
+      name: 'isOurScheme: non-string input returns false (no throw)',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.protocol.isOurScheme(null)).toBe(false);
+        ctx.expect(ctx.manager.protocol.isOurScheme(undefined)).toBe(false);
+        ctx.expect(ctx.manager.protocol.isOurScheme(42)).toBe(false);
+        ctx.expect(ctx.manager.protocol.isOurScheme({})).toBe(false);
+      },
+    },
+    {
+      name: 'initialize is idempotent — re-calling does not change schemes',
+      run: async (ctx) => {
+        const before = ctx.manager.protocol.getSchemes();
+        await ctx.manager.protocol.initialize(ctx.manager);
+        const after = ctx.manager.protocol.getSchemes();
+        ctx.expect(after).toEqual(before);
+      },
+    },
+  ],
+});

package/dist/test/suites/main/remote-config.test.js

@@ -0,0 +1,189 @@
+// Main-layer tests for lib/remote-config.js — fetch + cache + dot-path get +
+// onUpdate listeners + URL derivation from brand.url.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'remote-config (main)',
+  cleanup: (ctx) => {
+    ctx.manager.remoteConfig.shutdown();
+    ctx.manager.storage.set('remoteConfig', null);
+    ctx.manager.remoteConfig.initialize(ctx.manager);
+  },
+  tests: [
+    {
+      name: 'remoteConfig module wired on manager + initialized during boot',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.remoteConfig).toBeDefined();
+        ctx.expect(ctx.manager.remoteConfig._initialized).toBe(true);
+      },
+    },
+    {
+      name: 'URL derived from brand.url (legacy convention path)',
+      run: (ctx) => {
+        // Test config has a brand.url, so we should have a URL set.
+        // (If brand.url is missing in test config, this test verifies the resolution shape.)
+        const u = ctx.manager.remoteConfig._url;
+        ctx.expect(u === null || u.endsWith('/data/resources/main.json')).toBe(true);
+      },
+    },
+    {
+      name: 'URL override: config.remoteConfig.url wins over brand.url',
+      run: async (ctx) => {
+        ctx.manager.remoteConfig.shutdown();
+        const orig = ctx.manager.config.remoteConfig;
+        ctx.manager.config.remoteConfig = { url: 'https://override.example/custom.json' };
+        try {
+          ctx.manager.remoteConfig.initialize(ctx.manager);
+          ctx.expect(ctx.manager.remoteConfig._url).toBe('https://override.example/custom.json');
+        } finally {
+          ctx.manager.remoteConfig.shutdown();
+          ctx.manager.config.remoteConfig = orig;
+          ctx.manager.remoteConfig.initialize(ctx.manager);
+        }
+      },
+    },
+    {
+      name: 'transport gate: non-https URL refused (defaults only), loopback http allowed',
+      run: async (ctx) => {
+        const orig = ctx.manager.config.remoteConfig;
+        try {
+          ctx.manager.remoteConfig.shutdown();
+          ctx.manager.config.remoteConfig = { url: 'http://insecure.example/custom.json' };
+          ctx.manager.remoteConfig.initialize(ctx.manager);
+          ctx.expect(ctx.manager.remoteConfig._url).toBe(null);
+          // Defaults still served — the gate disables the fetch, not the API —
+          // and the renderer IPC handler is registered BEFORE the gate returns
+          // (the preload exposes the invoke unconditionally).
+          ctx.expect(ctx.manager.remoteConfig.get('status')).toBe('online');
+          const viaIpc = await ctx.manager.ipc.invoke('desktop:remote-config:get', 'status');
+          ctx.expect(viaIpc).toBe('online');
+
+          // Unlikely-to-be-listening port — initialize() fires a real fetch.
+          ctx.manager.remoteConfig.shutdown();
+          ctx.manager.config.remoteConfig = { url: 'http://127.0.0.1:59987/custom.json' };
+          ctx.manager.remoteConfig.initialize(ctx.manager);
+          ctx.expect(ctx.manager.remoteConfig._url).toBe('http://127.0.0.1:59987/custom.json');
+        } finally {
+          ctx.manager.remoteConfig.shutdown();
+          ctx.manager.config.remoteConfig = orig;
+          ctx.manager.remoteConfig.initialize(ctx.manager);
+        }
+      },
+    },
+    {
+      name: 'enabled=false: skip everything',
+      run: async (ctx) => {
+        ctx.manager.remoteConfig.shutdown();
+        const orig = ctx.manager.config.remoteConfig;
+        ctx.manager.config.remoteConfig = { enabled: false };
+        try {
+          ctx.manager.remoteConfig.initialize(ctx.manager);
+          ctx.expect(ctx.manager.remoteConfig._enabled).toBe(false);
+          ctx.expect(ctx.manager.remoteConfig._url).toBe(null);
+          ctx.expect(ctx.manager.remoteConfig._intervalId).toBe(null);
+        } finally {
+          ctx.manager.remoteConfig.shutdown();
+          ctx.manager.config.remoteConfig = orig;
+          ctx.manager.remoteConfig.initialize(ctx.manager);
+        }
+      },
+    },
+    {
+      name: 'get() returns cached data after a successful fetch',
+      run: async (ctx) => {
+        // Inject test data via the storage cache + bypass the network.
+        const planted = { status: 'online', versionRequired: '2.0.0' };
+        ctx.manager.remoteConfig._data = planted;
+        const got = ctx.manager.remoteConfig.get();
+        ctx.expect(got.status).toBe('online');
+        ctx.expect(got.versionRequired).toBe('2.0.0');
+      },
+    },
+    {
+      name: 'get() supports dot-path lookup',
+      run: (ctx) => {
+        ctx.manager.remoteConfig._data = {
+          status: 'online',
+          settings: { versionRequired: '1.5.0', nested: { value: 42 } },
+        };
+        ctx.expect(ctx.manager.remoteConfig.get('status')).toBe('online');
+        ctx.expect(ctx.manager.remoteConfig.get('settings.versionRequired')).toBe('1.5.0');
+        ctx.expect(ctx.manager.remoteConfig.get('settings.nested.value')).toBe(42);
+        ctx.expect(ctx.manager.remoteConfig.get('settings.missing')).toBe(undefined);
+        ctx.expect(ctx.manager.remoteConfig.get('totally.absent.path')).toBe(undefined);
+      },
+    },
+    {
+      name: 'get() returns DEFAULTS even before first fetch (so consumers never see undefined at boot)',
+      run: (ctx) => {
+        const orig = ctx.manager.remoteConfig._data;
+        ctx.manager.remoteConfig._data = null;
+        try {
+          const all = ctx.manager.remoteConfig.get();
+          ctx.expect(all.status).toBe('online');
+          ctx.expect(all.versionRequired).toBe('0.0.0');
+          ctx.expect(ctx.manager.remoteConfig.get('status')).toBe('online');
+          ctx.expect(ctx.manager.remoteConfig.get('versionRequired')).toBe('0.0.0');
+        } finally { ctx.manager.remoteConfig._data = orig; }
+      },
+    },
+    {
+      name: 'DEFAULTS export — exposed for consumer reference',
+      run: (ctx) => {
+        const D = ctx.manager.remoteConfig.DEFAULTS;
+        ctx.expect(D).toBeDefined();
+        ctx.expect(D.status).toBe('online');
+        ctx.expect(D.versionRequired).toBe('0.0.0');
+        // Frozen — consumers can't accidentally mutate the shared default.
+        let threw = false;
+        try { D.status = 'tampered'; } catch (_) { threw = true; }
+        // In strict mode this throws; in sloppy it silently fails. Either way
+        // the value should not change.
+        ctx.expect(D.status).toBe('online');
+      },
+    },
+    {
+      name: 'on(update, fn): subscriber fires when _emit is called',
+      run: async (ctx) => {
+        let received = null;
+        const off = ctx.manager.remoteConfig.on('update', (data) => { received = data; });
+        try {
+          ctx.manager.remoteConfig._emit('update', { ping: true });
+          ctx.expect(received).toEqual({ ping: true });
+        } finally { off(); }
+      },
+    },
+    {
+      name: 'on(update, fn): unsubscribe stops further calls',
+      run: (ctx) => {
+        let count = 0;
+        const off = ctx.manager.remoteConfig.on('update', () => { count++; });
+        ctx.manager.remoteConfig._emit('update', {});
+        ctx.expect(count).toBe(1);
+        off();
+        ctx.manager.remoteConfig._emit('update', {});
+        ctx.expect(count).toBe(1);   // unchanged
+      },
+    },
+    {
+      name: 'IPC handler desktop:remote-config:get returns cached data',
+      run: async (ctx) => {
+        ctx.manager.remoteConfig._data = { status: 'online', x: 1 };
+        const result = await ctx.manager.ipc.invoke('desktop:remote-config:get');
+        ctx.expect(result.status).toBe('online');
+        ctx.expect(result.x).toBe(1);
+      },
+    },
+    {
+      name: 'IPC handler desktop:remote-config:get supports dot-path',
+      run: async (ctx) => {
+        ctx.manager.remoteConfig._data = { settings: { versionRequired: '3.1.4' } };
+        const result = await ctx.manager.ipc.invoke('desktop:remote-config:get', 'settings.versionRequired');
+        ctx.expect(result).toBe('3.1.4');
+      },
+    },
+  ],
+});