@omega.js/desktop 0.52.0 → 0.53.0

package/dist/test/suites/main/app-state.test.js

@@ -1,6 +1,6 @@
 // Main-process tests for lib/app-state.js — storage-backed launch flags + crash sentinel.
 //
-// The harness already booted Manager once, which incremented launchCount and seeded
+// The harness already booted omega once, which incremented launchCount and seeded
 // state. We test by calling appState.reset() then re-initializing with crafted
 // storage state to simulate first-launch / repeat-launch / crash-recovery / upgrade.
 
@@ -14,60 +14,60 @@ module.exports = defineCases({
   description: 'app-state (main)',
   cleanup: async (ctx) => {
     // Restore a sane state for any later suites that look at appState.
-    ctx.manager.appState.reset();
+    ctx.omega.appState.reset();
     // Mark _initialized=false so we can re-init cleanly.
-    ctx.manager.appState._initialized = false;
-    await ctx.manager.appState.initialize(ctx.manager);
+    ctx.omega.appState._initialized = false;
+    await ctx.omega.appState.initialize(ctx.omega);
   },
   tests: [
     {
       name: 'initialize ran during boot',
       run: (ctx) => {
-        ctx.expect(ctx.manager.appState._initialized).toBe(true);
+        ctx.expect(ctx.omega.appState._initialized).toBe(true);
       },
     },
     {
       name: 'first launch: flags + counters seeded correctly',
       run: async (ctx) => {
-        ctx.manager.appState.reset();
-        ctx.manager.appState._initialized = false;
-        await ctx.manager.appState.initialize(ctx.manager);
-
-        ctx.expect(ctx.manager.appState.isFirstLaunch()).toBe(true);
-        ctx.expect(ctx.manager.appState.getLaunchCount()).toBe(1);
-        ctx.expect(ctx.manager.appState.getInstalledAt()).toBeInstanceOf(Date);
-        ctx.expect(ctx.manager.appState.getLastLaunchAt()).toBeNull();
-        ctx.expect(ctx.manager.appState.recoveredFromCrash()).toBe(false);
+        ctx.omega.appState.reset();
+        ctx.omega.appState._initialized = false;
+        await ctx.omega.appState.initialize(ctx.omega);
+
+        ctx.expect(ctx.omega.appState.isFirstLaunch()).toBe(true);
+        ctx.expect(ctx.omega.appState.getLaunchCount()).toBe(1);
+        ctx.expect(ctx.omega.appState.getInstalledAt()).toBeInstanceOf(Date);
+        ctx.expect(ctx.omega.appState.getLastLaunchAt()).toBeNull();
+        ctx.expect(ctx.omega.appState.recoveredFromCrash()).toBe(false);
       },
     },
     {
       name: 'second launch: not first, count incremented, lastLaunchAt populated',
       run: async (ctx) => {
-        ctx.manager.appState.reset();
-        ctx.manager.appState._initialized = false;
-        await ctx.manager.appState.initialize(ctx.manager);
+        ctx.omega.appState.reset();
+        ctx.omega.appState._initialized = false;
+        await ctx.omega.appState.initialize(ctx.omega);
 
         // Simulate a graceful quit from the first launch.
-        const after1 = ctx.manager.storage.get(STORAGE_KEY);
+        const after1 = ctx.omega.storage.get(STORAGE_KEY);
         after1.sentinel  = false;
         after1.lastQuitAt = Date.now();
-        ctx.manager.storage.set(STORAGE_KEY, after1);
+        ctx.omega.storage.set(STORAGE_KEY, after1);
 
         // Boot again.
-        ctx.manager.appState._initialized = false;
-        await ctx.manager.appState.initialize(ctx.manager);
+        ctx.omega.appState._initialized = false;
+        await ctx.omega.appState.initialize(ctx.omega);
 
-        ctx.expect(ctx.manager.appState.isFirstLaunch()).toBe(false);
-        ctx.expect(ctx.manager.appState.getLaunchCount()).toBe(2);
-        ctx.expect(ctx.manager.appState.getLastLaunchAt()).toBeInstanceOf(Date);
-        ctx.expect(ctx.manager.appState.recoveredFromCrash()).toBe(false);
+        ctx.expect(ctx.omega.appState.isFirstLaunch()).toBe(false);
+        ctx.expect(ctx.omega.appState.getLaunchCount()).toBe(2);
+        ctx.expect(ctx.omega.appState.getLastLaunchAt()).toBeInstanceOf(Date);
+        ctx.expect(ctx.omega.appState.recoveredFromCrash()).toBe(false);
       },
     },
     {
       name: 'crash detection: previous launch left sentinel and no quit timestamp',
       run: async (ctx) => {
         // Seed storage with a "we were running and never gracefully quit" state.
-        ctx.manager.storage.set(STORAGE_KEY, {
+        ctx.omega.storage.set(STORAGE_KEY, {
           installedAt:  Date.now() - 10000,
           launchCount:  3,
           lastLaunchAt: Date.now() - 1000,
@@ -76,17 +76,17 @@ module.exports = defineCases({
           version:      '1.0.0',
         });
 
-        ctx.manager.appState._initialized = false;
-        await ctx.manager.appState.initialize(ctx.manager);
+        ctx.omega.appState._initialized = false;
+        await ctx.omega.appState.initialize(ctx.omega);
 
-        ctx.expect(ctx.manager.appState.recoveredFromCrash()).toBe(true);
-        ctx.expect(ctx.manager.appState.getLaunchCount()).toBe(4);
+        ctx.expect(ctx.omega.appState.recoveredFromCrash()).toBe(true);
+        ctx.expect(ctx.omega.appState.getLaunchCount()).toBe(4);
       },
     },
     {
       name: 'graceful quit: sentinel cleared on next boot, no crash flag',
       run: async (ctx) => {
-        ctx.manager.storage.set(STORAGE_KEY, {
+        ctx.omega.storage.set(STORAGE_KEY, {
           installedAt:  Date.now() - 10000,
           launchCount:  5,
           lastLaunchAt: Date.now() - 1000,
@@ -95,17 +95,17 @@ module.exports = defineCases({
           version:      '1.0.0',
         });
 
-        ctx.manager.appState._initialized = false;
-        await ctx.manager.appState.initialize(ctx.manager);
+        ctx.omega.appState._initialized = false;
+        await ctx.omega.appState.initialize(ctx.omega);
 
-        ctx.expect(ctx.manager.appState.recoveredFromCrash()).toBe(false);
-        ctx.expect(ctx.manager.appState.getLaunchCount()).toBe(6);
+        ctx.expect(ctx.omega.appState.recoveredFromCrash()).toBe(false);
+        ctx.expect(ctx.omega.appState.getLaunchCount()).toBe(6);
       },
     },
     {
       name: 'version upgrade: previousVersion populated when version changes',
       run: async (ctx) => {
-        ctx.manager.storage.set(STORAGE_KEY, {
+        ctx.omega.storage.set(STORAGE_KEY, {
           installedAt:  Date.now() - 10000,
           launchCount:  10,
           lastLaunchAt: Date.now() - 1000,
@@ -114,19 +114,19 @@ module.exports = defineCases({
           version:      '0.9.0',     // previous version
         });
 
-        // Force the manager's reported version to differ.
-        const origConfig = ctx.manager.config.app;
-        ctx.manager.config.app = { ...origConfig, version: '1.0.0' };
+        // Force the omega instance's reported version to differ.
+        const origConfig = ctx.omega.config.app;
+        ctx.omega.config.app = { ...origConfig, version: '1.0.0' };
 
         try {
-          ctx.manager.appState._initialized = false;
-          await ctx.manager.appState.initialize(ctx.manager);
+          ctx.omega.appState._initialized = false;
+          await ctx.omega.appState.initialize(ctx.omega);
 
-          ctx.expect(ctx.manager.appState.getVersion()).toBe('1.0.0');
-          ctx.expect(ctx.manager.appState.getPreviousVersion()).toBe('0.9.0');
-          ctx.expect(ctx.manager.appState.wasUpgraded()).toBe(true);
+          ctx.expect(ctx.omega.appState.getVersion()).toBe('1.0.0');
+          ctx.expect(ctx.omega.appState.getPreviousVersion()).toBe('0.9.0');
+          ctx.expect(ctx.omega.appState.wasUpgraded()).toBe(true);
         } finally {
-          ctx.manager.config.app = origConfig;
+          ctx.omega.config.app = origConfig;
         }
       },
     },
@@ -134,7 +134,7 @@ module.exports = defineCases({
       name: 'no version change: wasUpgraded false, previousVersion preserved',
       run: async (ctx) => {
         // Seed with a previousVersion that should NOT be overwritten when version doesn't change.
-        ctx.manager.storage.set(STORAGE_KEY, {
+        ctx.omega.storage.set(STORAGE_KEY, {
           installedAt:     Date.now() - 10000,
           launchCount:     20,
           lastLaunchAt:    Date.now() - 1000,
@@ -144,53 +144,53 @@ module.exports = defineCases({
           previousVersion: '0.9.0',
         });
 
-        const origConfig = ctx.manager.config.app;
-        ctx.manager.config.app = { ...origConfig, version: '1.0.0' };
+        const origConfig = ctx.omega.config.app;
+        ctx.omega.config.app = { ...origConfig, version: '1.0.0' };
 
         try {
-          ctx.manager.appState._initialized = false;
-          await ctx.manager.appState.initialize(ctx.manager);
+          ctx.omega.appState._initialized = false;
+          await ctx.omega.appState.initialize(ctx.omega);
 
-          ctx.expect(ctx.manager.appState.wasUpgraded()).toBe(false);
+          ctx.expect(ctx.omega.appState.wasUpgraded()).toBe(false);
           // Should preserve the historical previousVersion rather than nuking it.
-          ctx.expect(ctx.manager.appState.getPreviousVersion()).toBe('0.9.0');
+          ctx.expect(ctx.omega.appState.getPreviousVersion()).toBe('0.9.0');
         } finally {
-          ctx.manager.config.app = origConfig;
+          ctx.omega.config.app = origConfig;
         }
       },
     },
     {
       name: 'launchedFromDeepLink: defaults false, set/cleared via setter',
       run: (ctx) => {
-        ctx.expect(ctx.manager.appState.launchedFromDeepLink()).toBe(false);
-        ctx.manager.appState.setLaunchedFromDeepLink(true);
-        ctx.expect(ctx.manager.appState.launchedFromDeepLink()).toBe(true);
-        ctx.manager.appState.setLaunchedFromDeepLink(false);
-        ctx.expect(ctx.manager.appState.launchedFromDeepLink()).toBe(false);
+        ctx.expect(ctx.omega.appState.launchedFromDeepLink()).toBe(false);
+        ctx.omega.appState.setLaunchedFromDeepLink(true);
+        ctx.expect(ctx.omega.appState.launchedFromDeepLink()).toBe(true);
+        ctx.omega.appState.setLaunchedFromDeepLink(false);
+        ctx.expect(ctx.omega.appState.launchedFromDeepLink()).toBe(false);
       },
     },
     {
       name: 'launchedAtLogin returns a boolean',
       run: (ctx) => {
-        ctx.expect(typeof ctx.manager.appState.launchedAtLogin()).toBe('boolean');
+        ctx.expect(typeof ctx.omega.appState.launchedAtLogin()).toBe('boolean');
       },
     },
     {
       name: 'getLastQuitAt reads live storage (returns null when sentinel is active)',
       run: async (ctx) => {
-        ctx.manager.appState.reset();
-        ctx.manager.appState._initialized = false;
-        await ctx.manager.appState.initialize(ctx.manager);
+        ctx.omega.appState.reset();
+        ctx.omega.appState._initialized = false;
+        await ctx.omega.appState.initialize(ctx.omega);
         // After init, sentinel=true and lastQuitAt=null.
-        ctx.expect(ctx.manager.appState.getLastQuitAt()).toBeNull();
+        ctx.expect(ctx.omega.appState.getLastQuitAt()).toBeNull();
       },
     },
     {
       name: 'reset() wipes persisted state',
       run: (ctx) => {
-        ctx.expect(ctx.manager.storage.has(STORAGE_KEY)).toBe(true);
-        ctx.manager.appState.reset();
-        ctx.expect(ctx.manager.storage.has(STORAGE_KEY)).toBe(false);
+        ctx.expect(ctx.omega.storage.has(STORAGE_KEY)).toBe(true);
+        ctx.omega.appState.reset();
+        ctx.expect(ctx.omega.storage.has(STORAGE_KEY)).toBe(false);
       },
     },
   ],

package/dist/test/suites/main/auth-flow.test.js

@@ -1,7 +1,7 @@
 // Main-process tests for lib/auth-flow.js — the openAuthFlow() sign-in round trip.
 // The dev loopback listener is REAL (http server on 127.0.0.1, real GETs simulate the
 // browser's redirect back); only the pieces that would leave the machine are stubbed
-// (shell.openExternal, omega.handleAuthToken, windows.get's show/focus surface).
+// (shell.openExternal, auth.handleToken, windows.get's show/focus surface).
 
 const http = require('http');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
@@ -25,7 +25,7 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 // getWebsiteUrl(), which since
 // [#834](https://github.com/Omega-JS-Stack/omega/issues/834) answers from the
 // resolved dev map the bundle task bakes (whose floor is @omega.js/config's
-// classic numbers) and throws when an artifact carries none. The harness manager
+// classic numbers) and throws when an artifact carries none. The harness instance
 // loads src/defaults' config, which has no build behind it, so a real dev
 // artifact's block is stated here.
 function stubExternals(ctx) {
@@ -35,23 +35,23 @@ function stubExternals(ctx) {
   const tokens = [];
   const shown = [];
   const origOpen = electron.shell.openExternal;
-  const origHandle = ctx.manager.omega.handleAuthToken;
-  const origShow = ctx.manager.windows.show;
-  const origDev = ctx.manager.config.dev;
+  const origHandle = ctx.omega.auth.handleToken;
+  const origShow = ctx.omega.windows.show;
+  const origDev = ctx.omega.config.dev;
   electron.shell.openExternal = async (url) => { opened.push(url); };
-  ctx.manager.omega.handleAuthToken = (t) => { tokens.push(t); };
-  ctx.manager.windows.show = (name) => { shown.push(name); };
-  ctx.manager.config.dev = { ports: { ...CLASSIC_PORTS } };
+  ctx.omega.auth.handleToken = (t) => { tokens.push(t); };
+  ctx.omega.windows.show = (name) => { shown.push(name); };
+  ctx.omega.config.dev = { ports: { ...CLASSIC_PORTS } };
   return {
     opened,
     tokens,
     shown,
     restore() {
       electron.shell.openExternal = origOpen;
-      ctx.manager.omega.handleAuthToken = origHandle;
-      ctx.manager.windows.show = origShow;
-      if (origDev !== undefined) ctx.manager.config.dev = origDev; else delete ctx.manager.config.dev;
-      ctx.manager.authFlow.cancel();
+      ctx.omega.auth.handleToken = origHandle;
+      ctx.omega.windows.show = origShow;
+      if (origDev !== undefined) ctx.omega.config.dev = origDev; else delete ctx.omega.config.dev;
+      ctx.omega.authFlow.cancel();
     },
   };
 }
@@ -64,7 +64,7 @@ module.exports = defineCases({
     {
       name: 'initialize ran during boot',
       run: (ctx) => {
-        ctx.expect(ctx.manager.authFlow._initialized).toBe(true);
+        ctx.expect(ctx.omega.authFlow._initialized).toBe(true);
       },
     },
     {
@@ -72,7 +72,7 @@ module.exports = defineCases({
       run: async (ctx) => {
         const stubs = stubExternals(ctx);
         try {
-          const { url, port } = await ctx.manager.openAuthFlow();
+          const { url, port } = await ctx.omega.openAuthFlow();
           ctx.expect(typeof port).toBe('number');
           ctx.expect(stubs.opened[0]).toBe(url);
 
@@ -85,19 +85,19 @@ module.exports = defineCases({
           ctx.expect(returnUrl.hostname).toBe('127.0.0.1');
           ctx.expect(Number(returnUrl.port)).toBe(port);
           ctx.expect(returnUrl.pathname).toBe('/auth/token');
-          ctx.expect(returnUrl.searchParams.get('state')).toBe(ctx.manager.authFlow._pending.nonce);
+          ctx.expect(returnUrl.searchParams.get('state')).toBe(ctx.omega.authFlow._pending.nonce);
         } finally {
           stubs.restore();
         }
       },
     },
     {
-      name: 'valid browser return: 200 page, token → handleAuthToken, listener torn down, app surfaced',
+      name: 'valid browser return: 200 page, token → handleToken, listener torn down, app surfaced',
       run: async (ctx) => {
         const stubs = stubExternals(ctx);
         try {
-          const { port } = await ctx.manager.openAuthFlow();
-          const nonce = ctx.manager.authFlow._pending.nonce;
+          const { port } = await ctx.omega.openAuthFlow();
+          const nonce = ctx.omega.authFlow._pending.nonce;
 
           const res = await get(`http://127.0.0.1:${port}/auth/token?authToken=TOK-1&state=${nonce}`);
           ctx.expect(res.status).toBe(200);
@@ -106,7 +106,7 @@ module.exports = defineCases({
           ctx.expect(stubs.shown).toEqual(['main']);
 
           // One-shot: the listener is gone.
-          ctx.expect(ctx.manager.authFlow._pending).toBeNull();
+          ctx.expect(ctx.omega.authFlow._pending).toBeNull();
           let refused = false;
           await get(`http://127.0.0.1:${port}/auth/token?authToken=x&state=${nonce}`).catch(() => { refused = true; });
           ctx.expect(refused).toBe(true);
@@ -116,12 +116,12 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'bad state or missing token: 400, no handleAuthToken, listener SURVIVES for the real return',
+      name: 'bad state or missing token: 400, no handleToken, listener SURVIVES for the real return',
       run: async (ctx) => {
         const stubs = stubExternals(ctx);
         try {
-          const { port } = await ctx.manager.openAuthFlow();
-          const nonce = ctx.manager.authFlow._pending.nonce;
+          const { port } = await ctx.omega.openAuthFlow();
+          const nonce = ctx.omega.authFlow._pending.nonce;
 
           const bad1 = await get(`http://127.0.0.1:${port}/auth/token?authToken=EVIL&state=wrong`);
           ctx.expect(bad1.status).toBe(400);
@@ -145,8 +145,8 @@ module.exports = defineCases({
       run: async (ctx) => {
         const stubs = stubExternals(ctx);
         try {
-          const first = await ctx.manager.openAuthFlow();
-          const second = await ctx.manager.openAuthFlow();
+          const first = await ctx.omega.openAuthFlow();
+          const second = await ctx.omega.openAuthFlow();
 
           // The first port no longer answers (unless the OS re-issued the same port to the
           // second listener, in which case the nonce changed anyway).
@@ -155,7 +155,7 @@ module.exports = defineCases({
             await get(`http://127.0.0.1:${first.port}/auth/token`).catch(() => { refused = true; });
             ctx.expect(refused).toBe(true);
           }
-          ctx.expect(ctx.manager.authFlow._pending.port).toBe(second.port);
+          ctx.expect(ctx.omega.authFlow._pending.port).toBe(second.port);
         } finally {
           stubs.restore();
         }
@@ -166,12 +166,12 @@ module.exports = defineCases({
       run: async (ctx) => {
         const stubs = stubExternals(ctx);
         try {
-          const { port } = await ctx.manager.openAuthFlow({ timeoutMs: 50 });
-          ctx.expect(ctx.manager.authFlow._pending.port).toBe(port);
+          const { port } = await ctx.omega.openAuthFlow({ timeoutMs: 50 });
+          ctx.expect(ctx.omega.authFlow._pending.port).toBe(port);
           await sleep(150);
-          ctx.expect(ctx.manager.authFlow._pending).toBeNull();
-          ctx.manager.authFlow.cancel();
-          ctx.manager.authFlow.cancel();
+          ctx.expect(ctx.omega.authFlow._pending).toBeNull();
+          ctx.omega.authFlow.cancel();
+          ctx.omega.authFlow.cancel();
         } finally {
           stubs.restore();
         }
@@ -181,25 +181,25 @@ module.exports = defineCases({
       name: 'production open(): plain external open of getAuthUrl(), no listener',
       run: async (ctx) => {
         const stubs = stubExternals(ctx);
-        const m = ctx.manager;
-        const origIsProd = m.isProduction;
-        m.config.brand = m.config.brand || {};
-        const origUrl = m.config.brand.url;
-        m.isProduction = () => true;
-        m.config.brand.url = 'https://example.com';
+        const omega = ctx.omega;
+        const origIsProd = omega.isProduction;
+        omega.config.brand = omega.config.brand || {};
+        const origUrl = omega.config.brand.url;
+        omega.isProduction = () => true;
+        omega.config.brand.url = 'https://example.com';
         try {
-          const { url, port } = await m.openAuthFlow();
+          const { url, port } = await omega.openAuthFlow();
           ctx.expect(port).toBeUndefined();
-          ctx.expect(ctx.manager.authFlow._pending).toBeNull();
+          ctx.expect(ctx.omega.authFlow._pending).toBeNull();
           ctx.expect(stubs.opened[0]).toBe(url);
           // Prod URL must ride the custom scheme, not a loopback return.
           const signin = new URL(url);
           const tokenUrl = new URL(signin.searchParams.get('authReturnUrl'));
           const finalHop = tokenUrl.searchParams.get('authReturnUrl');
-          ctx.expect(finalHop).toBe(`${m.config.brand.id}://auth/token`);
+          ctx.expect(finalHop).toBe(`${omega.config.brand.id}://auth/token`);
         } finally {
-          m.isProduction = origIsProd;
-          if (origUrl !== undefined) m.config.brand.url = origUrl; else delete m.config.brand.url;
+          omega.isProduction = origIsProd;
+          if (origUrl !== undefined) omega.config.brand.url = origUrl; else delete omega.config.brand.url;
           stubs.restore();
         }
       },

package/dist/test/suites/main/auth-persistence.test.js

@@ -1,5 +1,5 @@
-// Main-process tests for lib/auth-persistence.js (pluggable session vault) and the
-// bridge's desktop:auth:account-resolved intake (renderer → main plan resolution cache).
+// Main-process tests for lib/auth-persistence.js (pluggable session vault) and
+// lib/auth.js's desktop:auth:account-resolved intake (renderer → main account).
 // The safeStorage strategy runs REAL (OS keychain + real file under userData) when
 // encryption is available in the test environment; adapter logic is covered against
 // a real in-memory strategy either way.
@@ -27,27 +27,27 @@ module.exports = defineCases({
     {
       name: 'resolve(): a test run is none, whatever the config says',
       run: async (ctx) => {
-        const m = ctx.manager;
-        ctx.expect(m.isTesting()).toBe(true);
-        m.config.omega = m.config.omega || {};
-        const orig = m.config.omega.authPersistence;
+        const omega = ctx.omega;
+        ctx.expect(omega.isTesting()).toBe(true);
+        omega.config.omega = omega.config.omega || {};
+        const orig = omega.config.omega.authPersistence;
         try {
           // Unset, and explicitly asking for the vault, both land on none: the harness
           // never signs a real user in, so it never asks the OS keychain
           // ([#907](https://github.com/Omega-JS-Stack/omega/issues/907)).
-          delete m.config.omega.authPersistence;
-          ctx.expect(await authPersistence.resolve(m)).toBeNull();
+          delete omega.config.omega.authPersistence;
+          ctx.expect(await authPersistence.resolve(omega)).toBeNull();
           ctx.expect(authPersistence.getActive()).toBeNull();
 
-          m.config.omega.authPersistence = 'safeStorage';
-          ctx.expect(await authPersistence.resolve(m)).toBeNull();
+          omega.config.omega.authPersistence = 'safeStorage';
+          ctx.expect(await authPersistence.resolve(omega)).toBeNull();
 
-          m.config.omega.authPersistence = 'none';
-          ctx.expect(await authPersistence.resolve(m)).toBeNull();
+          omega.config.omega.authPersistence = 'none';
+          ctx.expect(await authPersistence.resolve(omega)).toBeNull();
         } finally {
-          if (orig !== undefined) m.config.omega.authPersistence = orig;
-          else delete m.config.omega.authPersistence;
-          await authPersistence.resolve(m); // restore the active strategy for later suites
+          if (orig !== undefined) omega.config.omega.authPersistence = orig;
+          else delete omega.config.omega.authPersistence;
+          await authPersistence.resolve(omega); // restore the active strategy for later suites
         }
       },
     },
@@ -58,7 +58,7 @@ module.exports = defineCases({
 
         authPersistence.register('desktop-test-custom', fakeStrategy());
         try {
-          // Selection by config is proven at the build layer, on a production manager:
+          // Selection by config is proven at the build layer, on a production omega instance:
           // under test mode resolve() answers none before it reads a thing.
           ctx.expect(authPersistence._strategies['desktop-test-custom'].name).toBe('desktop-test-custom');
           ctx.expect(await authPersistence._strategies['desktop-test-custom'].available()).toBe(true);
@@ -116,47 +116,58 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'bridge account-resolved intake: uid-guarded, cached, broadcast once per change, cleared on sign-out',
+      name: 'auth account-resolved intake: uid-guarded, lands a User, broadcasts { document } once per change, dropped on sign-out',
       run: async (ctx) => {
-        const m = ctx.manager;
-        const bridge = m.omega;
-        const origAuth = bridge._firebaseAuth;
-        const origBroadcast = m.ipc.broadcast;
+        const omega = ctx.omega;
+        const auth = omega.auth;
+        const origAuth = auth._firebaseAuth;
+        const origBroadcast = omega.ipc.broadcast;
         const broadcasts = [];
-        m.ipc.broadcast = (ch, payload) => { if (ch === 'desktop:auth:plan-changed') broadcasts.push(payload); };
+        omega.ipc.broadcast = (ch, payload) => { if (ch === 'desktop:auth:plan-changed') broadcasts.push(payload); };
+
+        // What a signed-in renderer pushes: its User's stored document (resolved,
+        // metadata stamped) and its identity
+        const { User } = require('../../../vendor/account/index.js');
+        const IDENTITY = { uid: 'u1', email: 'x@y.z', displayName: 'X', photoURL: null, emailVerified: true };
+        const DOCUMENT = new User({ subscription: { product: { id: 'premium' }, status: 'active' }, roles: { betaTester: true } }, IDENTITY).toJSON();
+
         try {
-          // Main signed out → any push is rejected.
-          bridge._firebaseAuth = { currentUser: null };
-          let res = await m.ipc.invoke('desktop:auth:account-resolved', { uid: 'u1', resolved: { plan: 'pro', active: true } });
+          // Main signed out → any push is rejected, `user` stays signed out.
+          auth._firebaseAuth = { currentUser: null };
+          let res = await omega.ipc.invoke('desktop:auth:account-resolved', { uid: 'u1', document: DOCUMENT, identity: IDENTITY });
           ctx.expect(res.accepted).toBe(false);
-          ctx.expect(bridge.getResolvedPlan()).toBeNull();
+          ctx.expect(auth.user.authenticated).toBe(false);
+          ctx.expect(auth.user.plan).toBe('basic');
 
-          // Matching uid → cached + broadcast.
-          bridge._firebaseAuth = { currentUser: { uid: 'u1', email: 'x@y.z' } };
-          res = await m.ipc.invoke('desktop:auth:account-resolved', { uid: 'u1', resolved: { plan: 'pro', active: true }, roles: { betaTester: true } });
+          // Matching uid → main builds its User from the WHOLE document + broadcasts it.
+          auth._firebaseAuth = { currentUser: { uid: 'u1', email: 'x@y.z' } };
+          res = await omega.ipc.invoke('desktop:auth:account-resolved', { uid: 'u1', document: DOCUMENT, identity: IDENTITY });
           ctx.expect(res.accepted).toBe(true);
-          ctx.expect(bridge.getResolvedPlan()).toEqual({ plan: 'pro', active: true });
-          ctx.expect(bridge.getResolvedRoles()).toEqual({ betaTester: true });
+          ctx.expect(auth.user.uid).toBe('u1');
+          ctx.expect(auth.user.plan).toBe('premium');
+          ctx.expect(auth.user.roles.betaTester).toBe(true);
+          ctx.expect(auth.user.profile.displayName).toBe('X');
           ctx.expect(broadcasts.length).toBe(1);
+          ctx.expect(broadcasts[0]).toEqual({ document: auth.user.toJSON() });
 
           // Identical push → accepted but NO second broadcast.
-          await m.ipc.invoke('desktop:auth:account-resolved', { uid: 'u1', resolved: { plan: 'pro', active: true }, roles: { betaTester: true } });
+          await omega.ipc.invoke('desktop:auth:account-resolved', { uid: 'u1', document: DOCUMENT, identity: IDENTITY });
           ctx.expect(broadcasts.length).toBe(1);
 
-          // Mismatched uid (stale renderer) → dropped, cache intact.
-          res = await m.ipc.invoke('desktop:auth:account-resolved', { uid: 'other', resolved: { plan: 'max', active: true } });
+          // Mismatched uid (stale renderer) → dropped, account intact.
+          res = await omega.ipc.invoke('desktop:auth:account-resolved', { uid: 'other', document: { subscription: { product: { id: 'max' }, status: 'active' } } });
           ctx.expect(res.accepted).toBe(false);
-          ctx.expect(bridge.getResolvedPlan()).toEqual({ plan: 'pro', active: true });
+          ctx.expect(auth.user.plan).toBe('premium');
 
-          // Sign-out clears the cache.
-          bridge._handleAuthStateChange(null);
-          ctx.expect(bridge.getResolvedPlan()).toBeNull();
-          ctx.expect(bridge.getResolvedRoles()).toBeNull();
+          // Sign-out drops the account.
+          auth._handleAuthStateChange(null);
+          ctx.expect(auth.user.authenticated).toBe(false);
+          ctx.expect(auth.user.plan).toBe('basic');
         } finally {
-          bridge._firebaseAuth = origAuth;
-          m.ipc.broadcast = origBroadcast;
-          bridge._resolvedPlan = null;
-          bridge._resolvedRoles = null;
+          // A case that failed midway still leaves main signed out for the suites after it
+          if (auth.user.authenticated) auth._handleAuthStateChange(null);
+          auth._firebaseAuth = origAuth;
+          omega.ipc.broadcast = origBroadcast;
         }
       },
     },

package/dist/test/suites/main/{client-bridge.integration.test.js → auth.integration.test.js}

@@ -1,4 +1,4 @@
-// Integration tests for client-bridge — actually hits Firebase.
+// Integration tests for lib/auth.js (`omega.auth`): actually hits Firebase.
 //
 // The SIGN-IN proof lives in #904: web, desktop and extension each sign in as a
 // persona the backend emulator seeds, so this suite no longer mints a custom
@@ -25,32 +25,33 @@ const skipReason = checkSkipReason();
 module.exports = defineCases({
   type: 'suite',
   layer: 'main',
-  description: 'client-bridge (main, integration)',
+  description: 'auth (main, integration)',
   skip: skipReason || false,
   cleanup: async (ctx) => {
     try {
-      await ctx.manager.omega.signOut();
+      await ctx.omega.auth.signOut();
     } catch (e) { /* ignore */ }
   },
   tests: [
     {
       name: 'firebase loaded (cloud.config present in test config)',
       run: (ctx) => {
-        if (!ctx.manager.omega._firebaseAuth) {
+        if (!ctx.omega.auth._firebaseAuth) {
           ctx.skip('cloud.config not set in default config — set one in src/defaults/config/omega.json5 to run');
         }
-        ctx.expect(ctx.manager.omega._firebaseAuth).toBeTruthy();
+        ctx.expect(ctx.omega.auth._firebaseAuth).toBeTruthy();
       },
     },
     {
-      name: 'sign-out clears the current user and broadcasts',
+      name: 'sign-out ends the session, drops the account, and broadcasts',
       run: async (ctx) => {
-        if (!ctx.manager.omega.getCurrentUser()) {
+        if (!ctx.omega.auth._firebaseAuth?.currentUser) {
           ctx.skip('not signed in (previous test may have skipped)');
         }
-        const r = await ctx.manager.omega.signOut();
+        const r = await ctx.omega.auth.signOut();
         ctx.expect(r.success).toBe(true);
-        ctx.expect(ctx.manager.omega.getCurrentUser()).toBeNull();
+        ctx.expect(ctx.omega.auth._firebaseAuth.currentUser).toBeNull();
+        ctx.expect(ctx.omega.auth.user.authenticated).toBe(false);
       },
     },
   ],