@nebulr-group/bridge-svelte 0.6.2 → 0.7.1

package/dist/client/components/sdk-auth/LoginForm.svelte

@@ -237,7 +237,36 @@
   <MfaSetup onError={onError} {messages} />
 
 {:else if currentAuthState === 'tenant-selection'}
-  <TenantSelector onError={onError} />
+  <TenantSelector onError={onError} {messages} />
+
+<!--
+  Settling: the session is real and the host app has not navigated yet.
+
+  This branch is `!== 'unauthenticated'` rather than an explicit list of
+  `authenticated | credentials-validated` on purpose. Those two used to fall
+  through to the credentials form below, so somebody who had just typed their
+  password correctly was shown the password form again — which reads as a
+  refusal, and the reasonable response is to type it again (TBP-635). The window
+  opens when the token exchange resolves and closes only when the consumer's
+  router lands, because LoginForm fires `onLogin` and deliberately does not
+  navigate. Measured at 600ms against a local stack; longer anywhere real.
+
+  Listing the two states would fix the two we know about and leave the next
+  `AuthState` member falling into the same hole. Inverting the test means the
+  credentials form renders ONLY for `unauthenticated`, and anything else lands
+  on a spinner — wrong-but-harmless instead of wrong-and-alarming.
+
+  `login.submitting` is reused rather than given its own key: it already says
+  "Signing in…" in all twelve locales, and a second key rendering the same words
+  would be a translation burden that buys nothing.
+-->
+{:else if currentAuthState !== 'unauthenticated'}
+  <AuthFormWrapper heading={null} class={className} {style} {...rest}>
+    <div class="bridge-auth-settling" data-bridge-auth-settling>
+      <Spinner size={24} />
+      <span>{t('login.submitting')}</span>
+    </div>
+  </AuthFormWrapper>
 
 <!-- Inline forgot password -->
 {:else if step === 'forgot-password'}

package/dist/client/components/sdk-auth/SsoButton.svelte

@@ -1,8 +1,9 @@
 <script lang="ts">
   import type { Snippet } from 'svelte';
   import type { HTMLButtonAttributes } from 'svelte/elements';
-  import type { FederationConnection } from '@nebulr-group/bridge-auth-core';
+  import type { FederationConnection, MessageOverrides } from '@nebulr-group/bridge-auth-core';
   import { getBridgeAuth } from '../../../core/bridge-instance.js';
+  import { getTranslator } from '../../stores/i18n.js';
   import Spinner from './shared/Spinner.svelte';
 
   interface Props extends HTMLButtonAttributes {
@@ -19,6 +20,8 @@
     onSuccess?: () => void;
     onError?: (error: Error) => void;
     icon?: Snippet;
+    /** Per-key copy overrides for this component only (TBP-630). */
+    messages?: MessageOverrides;
   }
 
   let {
@@ -28,13 +31,18 @@
     onSuccess,
     onError,
     icon,
+    messages,
     class: className,
     style,
     ...rest
   }: Props = $props();
 
+  const t = $derived(getTranslator(messages));
+
   let loading = $state(false);
-  let buttonLabel = $derived(label ?? `Continue with ${connection.name}`);
+  // `label` still wins: an app naming its own provider button is voice, not
+  // mechanics, and the catalogue only supplies the default (TBP-634).
+  let buttonLabel = $derived(label ?? t('sso.continueWith', { provider: connection.name }));
 
   async function handleClick() {
     if (loading) return;
@@ -44,13 +52,13 @@
       if (result.type === 'auth_success') {
         onSuccess?.();
       } else if (result.type === 'auth_error') {
-        throw new Error(result.error || 'SSO login failed');
+        throw new Error(result.error || t('sso.error.login'));
       }
       // auth_mfa_required and auth_tenant_selection are handled by authState store
     } catch (err: any) {
       const message = err.message?.includes('popup')
-        ? 'Pop-up was blocked. Please allow pop-ups and try again.'
-        : err.message || 'SSO login failed';
+        ? t('sso.error.popupBlocked')
+        : err.message || t('sso.error.login');
       onError?.(new Error(message));
     } finally {
       loading = false;

package/dist/client/components/sdk-auth/SsoButton.svelte.d.ts

@@ -1,6 +1,6 @@
 import type { Snippet } from 'svelte';
 import type { HTMLButtonAttributes } from 'svelte/elements';
-import type { FederationConnection } from '@nebulr-group/bridge-auth-core';
+import type { FederationConnection, MessageOverrides } from '@nebulr-group/bridge-auth-core';
 interface Props extends HTMLButtonAttributes {
     connection: FederationConnection;
     label?: string;
@@ -15,6 +15,8 @@ interface Props extends HTMLButtonAttributes {
     onSuccess?: () => void;
     onError?: (error: Error) => void;
     icon?: Snippet;
+    /** Per-key copy overrides for this component only (TBP-630). */
+    messages?: MessageOverrides;
 }
 declare const SsoButton: import("svelte").Component<Props, {}, "">;
 type SsoButton = ReturnType<typeof SsoButton>;

package/dist/client/components/sdk-auth/TenantSelector.svelte

@@ -1,8 +1,9 @@
 <script lang="ts">
   import type { Snippet } from 'svelte';
   import type { HTMLAttributes } from 'svelte/elements';
-  import type { TenantUser } from '@nebulr-group/bridge-auth-core';
+  import type { MessageOverrides, TenantUser } from '@nebulr-group/bridge-auth-core';
   import { getBridgeAuth, tenantUsersStore } from '../../../core/bridge-instance.js';
+  import { getTranslator } from '../../stores/i18n.js';
   import AuthFormWrapper from './shared/AuthFormWrapper.svelte';
   import Spinner from './shared/Spinner.svelte';
   import Alert from './shared/Alert.svelte';
@@ -11,17 +12,22 @@
     onSelect?: () => void;
     onError?: (error: Error) => void;
     tenantItem?: Snippet<[TenantUser]>;
+    /** Per-key copy overrides for this component only (TBP-630). */
+    messages?: MessageOverrides;
   }
 
   let {
     onSelect,
     onError,
     tenantItem,
+    messages,
     class: className,
     style,
     ...rest
   }: Props = $props();
 
+  const t = $derived(getTranslator(messages));
+
   let loading = $state(false);
   let selectedId = $state<string | null>(null);
   let error = $state<string | null>(null);
@@ -35,7 +41,7 @@
       await getBridgeAuth().selectTenant(tenantUser.id);
       onSelect?.();
     } catch (err: any) {
-      error = err.message || 'Failed to select workspace.';
+      error = err.message || t('tenant.error.select');
       onError?.(err);
     } finally {
       loading = false;
@@ -44,7 +50,7 @@
   }
 </script>
 
-<AuthFormWrapper heading="Choose a workspace" class={className} {style} {...rest}>
+<AuthFormWrapper heading={t('tenant.chooseHeading')} class={className} {style} {...rest}>
   {#if error}
     <Alert variant="error">{error}</Alert>
   {/if}

package/dist/client/components/sdk-auth/TenantSelector.svelte.d.ts

@@ -1,10 +1,12 @@
 import type { Snippet } from 'svelte';
 import type { HTMLAttributes } from 'svelte/elements';
-import type { TenantUser } from '@nebulr-group/bridge-auth-core';
+import type { MessageOverrides, TenantUser } from '@nebulr-group/bridge-auth-core';
 interface Props extends HTMLAttributes<HTMLDivElement> {
     onSelect?: () => void;
     onError?: (error: Error) => void;
     tenantItem?: Snippet<[TenantUser]>;
+    /** Per-key copy overrides for this component only (TBP-630). */
+    messages?: MessageOverrides;
 }
 declare const TenantSelector: import("svelte").Component<Props, {}, "">;
 type TenantSelector = ReturnType<typeof TenantSelector>;

package/dist/client/components/sdk-auth/WorkspaceSelector.svelte

@@ -1,9 +1,10 @@
 <script lang="ts">
   import type { HTMLAttributes } from 'svelte/elements';
   import type { Snippet } from 'svelte';
-  import type { Workspace } from '@nebulr-group/bridge-auth-core';
+  import type { MessageOverrides, Workspace } from '@nebulr-group/bridge-auth-core';
   import { onMount } from 'svelte';
   import { getBridgeAuth, profileStore } from '../../../core/bridge-instance.js';
+  import { getTranslator } from '../../stores/i18n.js';
   import Spinner from './shared/Spinner.svelte';
   import Alert from './shared/Alert.svelte';
 
@@ -11,17 +12,22 @@
     onSwitch?: () => void;
     onError?: (error: Error) => void;
     workspaceItem?: Snippet<[{ workspace: Workspace; isActive: boolean; isLoading: boolean; onSelect: () => void }]>;
+    /** Per-key copy overrides for this component only (TBP-630). */
+    messages?: MessageOverrides;
   }
 
   let {
     onSwitch,
     onError,
     workspaceItem,
+    messages,
     class: className,
     style,
     ...rest
   }: Props = $props();
 
+  const t = $derived(getTranslator(messages));
+
   let workspaces = $state<Workspace[]>([]);
   let loadError = $state<string | null>(null);
   let loadingList = $state(true);
@@ -34,7 +40,7 @@
     try {
       workspaces = await getBridgeAuth().getWorkspaces();
     } catch (err: any) {
-      loadError = err.message || 'Failed to load workspaces.';
+      loadError = err.message || t('workspace.error.load');
     } finally {
       loadingList = false;
     }
@@ -48,7 +54,7 @@
       await getBridgeAuth().switchWorkspace(workspace.id);
       onSwitch?.();
     } catch (err: any) {
-      switchError = err.message || 'Failed to switch workspace.';
+      switchError = err.message || t('workspace.error.switch');
       onError?.(err);
     } finally {
       switchingId = null;

package/dist/client/components/sdk-auth/WorkspaceSelector.svelte.d.ts

@@ -1,6 +1,6 @@
 import type { HTMLAttributes } from 'svelte/elements';
 import type { Snippet } from 'svelte';
-import type { Workspace } from '@nebulr-group/bridge-auth-core';
+import type { MessageOverrides, Workspace } from '@nebulr-group/bridge-auth-core';
 interface Props extends HTMLAttributes<HTMLDivElement> {
     onSwitch?: () => void;
     onError?: (error: Error) => void;
@@ -10,6 +10,8 @@ interface Props extends HTMLAttributes<HTMLDivElement> {
         isLoading: boolean;
         onSelect: () => void;
     }]>;
+    /** Per-key copy overrides for this component only (TBP-630). */
+    messages?: MessageOverrides;
 }
 declare const WorkspaceSelector: import("svelte").Component<Props, {}, "">;
 type WorkspaceSelector = ReturnType<typeof WorkspaceSelector>;

package/dist/client/components/sdk-auth/login-settling.test.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TBP-635 — LoginForm must never draw the credentials form to somebody who has
+ * already authenticated.
+ *
+ * The top-level branch named `mfa-required`, `mfa-setup-required` and
+ * `tenant-selection`, and let everything else fall through to the password
+ * form. `authenticated` and `credentials-validated` are also "everything else",
+ * so between the token exchange resolving and the host app's router landing —
+ * LoginForm fires `onLogin` and deliberately does not navigate — the component
+ * showed a password field to a user who had just typed their password
+ * correctly. That reads as a refusal. Measured at 600ms against a local stack.
+ *
+ * ## What this file can and cannot prove
+ *
+ * The ticket's suggested test is a MutationObserver recording every DOM batch
+ * during a real login, because a sampling loop can miss the race. This
+ * workspace has no DOM (see auth-form-description.test.ts for why), so that
+ * exact test is not available here and belongs in the Playwright e2e suite.
+ *
+ * What IS available is stronger in the dimension that actually caused the bug.
+ * The defect was not a timing subtlety — it was an unhandled branch. So this
+ * enumerates EVERY member of `AuthState`, read out of auth-core's shipped
+ * type declaration rather than hardcoded, and asserts that exactly one of them
+ * renders a password field. A seventh state added to auth-core tomorrow is
+ * covered the moment it exists, which is the half a race-detector would miss.
+ */
+export {};

package/dist/client/components/sdk-auth/login-settling.test.js

@@ -0,0 +1,219 @@
+/**
+ * TBP-635 — LoginForm must never draw the credentials form to somebody who has
+ * already authenticated.
+ *
+ * The top-level branch named `mfa-required`, `mfa-setup-required` and
+ * `tenant-selection`, and let everything else fall through to the password
+ * form. `authenticated` and `credentials-validated` are also "everything else",
+ * so between the token exchange resolving and the host app's router landing —
+ * LoginForm fires `onLogin` and deliberately does not navigate — the component
+ * showed a password field to a user who had just typed their password
+ * correctly. That reads as a refusal. Measured at 600ms against a local stack.
+ *
+ * ## What this file can and cannot prove
+ *
+ * The ticket's suggested test is a MutationObserver recording every DOM batch
+ * during a real login, because a sampling loop can miss the race. This
+ * workspace has no DOM (see auth-form-description.test.ts for why), so that
+ * exact test is not available here and belongs in the Playwright e2e suite.
+ *
+ * What IS available is stronger in the dimension that actually caused the bug.
+ * The defect was not a timing subtlety — it was an unhandled branch. So this
+ * enumerates EVERY member of `AuthState`, read out of auth-core's shipped
+ * type declaration rather than hardcoded, and asserts that exactly one of them
+ * renders a password field. A seventh state added to auth-core tomorrow is
+ * covered the moment it exists, which is the half a race-detector would miss.
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { createServer } from 'vite';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+import { render } from 'svelte/server';
+import {} from 'svelte';
+import { en, sv } from '@nebulr-group/bridge-auth-core';
+import fs from 'node:fs';
+import path from 'node:path';
+const ROOT = process.cwd();
+const COMPONENT_DIR = 'src/lib/client/components/sdk-auth';
+const SEED_PREFIX = '__seeded-settling-';
+/**
+ * Every `AuthState`, parsed out of the auth-core declaration the package
+ * actually ships.
+ *
+ * Deliberately not a literal list: a hardcoded one would still say six when
+ * auth-core says seven, and the bug being fixed is precisely a state nobody
+ * remembered to handle. Parsing throws rather than returning a short list, so a
+ * refactor that moves the type fails this suite loudly instead of quietly
+ * testing fewer states.
+ */
+function authStates() {
+    // Resolved from the filesystem rather than the module system: the package
+    // exports no `./package.json` subpath, and vitest's module runner supports
+    // neither `require.resolve` nor `import.meta.resolve` here. Both candidate
+    // paths are tried because bun may hoist the dep to the workspace root.
+    const candidates = [
+        path.join(ROOT, 'node_modules/@nebulr-group/bridge-auth-core/dist/types.d.ts'),
+        path.join(ROOT, '../node_modules/@nebulr-group/bridge-auth-core/dist/types.d.ts'),
+    ];
+    const dts = candidates.find((c) => fs.existsSync(c));
+    if (!dts) {
+        throw new Error(`auth-core types.d.ts not found. Looked in:\n  ${candidates.join('\n  ')}`);
+    }
+    const source = fs.readFileSync(dts, 'utf8');
+    const match = source.match(/export type AuthState\s*=([^;]+);/);
+    if (!match) {
+        throw new Error('Could not find `export type AuthState` in auth-core types.d.ts.');
+    }
+    const states = [...match[1].matchAll(/'([^']+)'/g)].map((m) => m[1]);
+    if (states.length < 2) {
+        throw new Error(`Parsed only ${states.length} AuthState members — parser is wrong.`);
+    }
+    return states;
+}
+const STATES = authStates();
+let server;
+const seededPaths = [];
+beforeAll(async () => {
+    for (const f of fs.readdirSync(path.join(ROOT, COMPONENT_DIR))) {
+        if (f.startsWith(SEED_PREFIX))
+            fs.unlinkSync(path.join(ROOT, COMPONENT_DIR, f));
+    }
+    server = await createServer({
+        configFile: false,
+        root: ROOT,
+        logLevel: 'error',
+        server: { middlewareMode: true, hmr: false },
+        plugins: [svelte({ compilerOptions: { dev: false } })],
+    });
+}, 120_000);
+afterAll(async () => {
+    await server?.close();
+    for (const p of seededPaths) {
+        if (fs.existsSync(p))
+            fs.unlinkSync(p);
+    }
+});
+/**
+ * Render LoginForm with `currentAuthState` pinned.
+ *
+ * The seed replaces the one `$derived($authState)` line, so the template — every
+ * branch, the wrapper call, the catalogue lookups — is the real shipped source.
+ * Driving the store itself would need the network and the real state machine,
+ * and would test auth-core's transitions rather than this component's branching,
+ * which is where the defect was.
+ */
+async function renderAtState(state, props = {}) {
+    const file = 'LoginForm.svelte';
+    const from = 'let currentAuthState = $derived($authState);';
+    let source = fs.readFileSync(path.join(ROOT, COMPONENT_DIR, file), 'utf8');
+    if (!source.includes(from)) {
+        throw new Error(`State seed target not found in ${file}:\n  ${from}\n` +
+            'The component was refactored. Update the seed so the test keeps driving ' +
+            'the auth-state branch — do not delete the assertion.');
+    }
+    source = source.replace(from, `let currentAuthState = $state('${state}');`);
+    const name = `${SEED_PREFIX}${process.pid}-${seededPaths.length}-${file}`;
+    const full = path.join(ROOT, COMPONENT_DIR, name);
+    fs.writeFileSync(full, source);
+    seededPaths.push(full);
+    const mod = await server.ssrLoadModule(`/${COMPONENT_DIR}/${name}`);
+    const Component = mod.default;
+    return render(Component, { props }).body;
+}
+async function setLocale(locale) {
+    const mod = await server.ssrLoadModule('/src/lib/client/stores/config.store.ts');
+    mod.bridgeConfig.initConfig({ appId: 'tbp-635-test', locale });
+}
+/** A password field is the thing that must never appear post-auth. */
+function hasPasswordField(html) {
+    return /<input[^>]+type="password"/.test(html);
+}
+function text(html) {
+    return html
+        .replace(/<!--[\s\S]*?-->/g, '')
+        .replace(/<[^>]*>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+// ---------------------------------------------------------------------------
+// 1. The fixture itself
+// ---------------------------------------------------------------------------
+describe('AuthState coverage (TBP-635)', () => {
+    it('reads the real state list out of the shipped auth-core types', () => {
+        // If this drifts, every assertion below silently covers less.
+        expect(STATES).toContain('unauthenticated');
+        expect(STATES).toContain('authenticated');
+        expect(STATES).toContain('credentials-validated');
+        expect(STATES.length).toBeGreaterThanOrEqual(6);
+    });
+});
+// ---------------------------------------------------------------------------
+// 2. The invariant
+// ---------------------------------------------------------------------------
+describe('LoginForm never shows the credentials form post-auth (TBP-635)', () => {
+    it('renders a password field for `unauthenticated` and for nothing else', async () => {
+        await setLocale(undefined);
+        const withPassword = [];
+        for (const state of STATES) {
+            if (hasPasswordField(await renderAtState(state)))
+                withPassword.push(state);
+        }
+        // Both directions. Asserting only "authenticated has no password field"
+        // would pass for a component that rendered nothing at all, ever.
+        expect(withPassword).toEqual(['unauthenticated']);
+    });
+    for (const state of ['authenticated', 'credentials-validated']) {
+        it(`shows the settling card at "${state}"`, async () => {
+            await setLocale(undefined);
+            const html = await renderAtState(state);
+            expect(html).toContain('data-bridge-auth-settling');
+            expect(hasPasswordField(html)).toBe(false);
+            // Not a blank card: an empty box during a pause is its own bad message.
+            expect(text(html)).toContain(en['login.submitting']);
+        });
+    }
+    it('translates the waiting copy', async () => {
+        await setLocale('sv');
+        const html = await renderAtState('authenticated');
+        expect(text(html)).toContain(sv['login.submitting']);
+        expect(text(html)).not.toContain(en['login.submitting']);
+    });
+    it('suppresses the heading while settling, so no stale "Log in" survives', async () => {
+        await setLocale(undefined);
+        const html = await renderAtState('authenticated', { heading: 'Log in to NorthWhistle' });
+        expect(html).not.toContain('Log in to NorthWhistle');
+        expect(html).toContain('data-bridge-auth-settling');
+    });
+    it('still hands the three delegated states to their own components', async () => {
+        // The fix must not have swallowed the branches that already worked — an
+        // over-eager `!== unauthenticated` placed above them would do exactly that.
+        await setLocale(undefined);
+        expect(await renderAtState('tenant-selection')).toContain('bridge-tenant-list');
+        expect(await renderAtState('mfa-required')).toContain(en['mfa.challengeHeading']);
+        expect(await renderAtState('mfa-setup-required')).toContain(en['mfaSetup.heading']);
+    });
+    it('leaves the unauthenticated step machine alone', async () => {
+        await setLocale(undefined);
+        const html = await renderAtState('unauthenticated');
+        expect(hasPasswordField(html)).toBe(true);
+        expect(html).toContain(en['login.submit']);
+        expect(html).not.toContain('data-bridge-auth-settling');
+    });
+});
+// ---------------------------------------------------------------------------
+// 3. onLogin is untouched
+// ---------------------------------------------------------------------------
+describe('onLogin lifecycle is unchanged (TBP-635)', () => {
+    it('still fires from an effect keyed on `authenticated`', () => {
+        // Effects do not run in a server render, so this is asserted on the source.
+        // It is here because the tempting wrong fix for this bug is to move
+        // `onLogin` earlier so the consumer navigates sooner — which would fire it
+        // before the session is real.
+        const source = fs.readFileSync(path.join(ROOT, COMPONENT_DIR, 'LoginForm.svelte'), 'utf8');
+        const effect = source.match(/\$effect\(\(\) => \{[\s\S]*?\}\);/);
+        expect(effect, 'LoginForm no longer has an $effect').not.toBeNull();
+        expect(effect[0]).toContain("currentAuthState === 'authenticated'");
+        expect(effect[0]).toContain('onLogin?.()');
+        // Exactly one call site, so it cannot fire twice.
+        expect(source.match(/onLogin\?\.\(\)/g)).toHaveLength(1);
+    });
+});

package/dist/client/components/sdk-auth/selector-i18n.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/components/sdk-auth/selector-i18n.test.js

@@ -0,0 +1,248 @@
+// TenantSelector, WorkspaceSelector and SsoButton were missed by TBP-630's
+// original i18n sweep and by the TBP-633 port, so they still rendered English
+// in all four UI packages after everything around them had been translated.
+// TenantSelector is the one that stings: it renders MID-LOGIN on the
+// multi-workspace path, putting one English screen between a translated login
+// form and a translated app (TBP-634).
+//
+// HARNESS NOTE — see auth-form-description.test.ts for the full explanation of
+// why these render through Svelte's server renderer rather than a DOM. Short
+// version: this workspace has no DOM implementation, so `mount()` and therefore
+// clicks are unavailable. Two consequences shape this file.
+//
+// 1. Anything reachable at initial render (TenantSelector's heading,
+//    SsoButton's label) is asserted on the REAL rendered markup.
+//
+// 2. The five error strings are only produced inside a catch block a click
+//    would have to reach. Those get two assertions that are weak alone and
+//    strong together:
+//      - a `seeded()` render proving the KEY resolves to real Swedish, and
+//      - a source sweep proving the English literal the handler used to carry
+//        is gone from the file.
+//    Reverting the handler to `'Failed to select workspace.'` puts that exact
+//    string back in the source and fails the sweep. The sweep reads its
+//    forbidden strings out of auth-core's `en` catalogue, so it cannot drift
+//    from what the keys actually say.
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { createServer } from 'vite';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+import { render } from 'svelte/server';
+import {} from 'svelte';
+import { en, sv } from '@nebulr-group/bridge-auth-core';
+import fs from 'node:fs';
+import path from 'node:path';
+const ROOT = process.cwd();
+const COMPONENT_DIR = 'src/lib/client/components/sdk-auth';
+const SEED_PREFIX = '__seeded-i18n-';
+/** The keys TBP-634 added, and which component owns each. */
+const OWNED = {
+    'TenantSelector.svelte': ['tenant.chooseHeading', 'tenant.error.select'],
+    'WorkspaceSelector.svelte': ['workspace.error.load', 'workspace.error.switch'],
+    'SsoButton.svelte': ['sso.continueWith', 'sso.error.popupBlocked', 'sso.error.login'],
+};
+let server;
+const seededPaths = [];
+beforeAll(async () => {
+    for (const f of fs.readdirSync(path.join(ROOT, COMPONENT_DIR))) {
+        if (f.startsWith(SEED_PREFIX))
+            fs.unlinkSync(path.join(ROOT, COMPONENT_DIR, f));
+    }
+    server = await createServer({
+        configFile: false,
+        root: ROOT,
+        logLevel: 'error',
+        server: { middlewareMode: true, hmr: false },
+        plugins: [svelte({ compilerOptions: { dev: false } })],
+    });
+}, 120_000);
+afterAll(async () => {
+    await server?.close();
+    for (const p of seededPaths) {
+        if (fs.existsSync(p))
+            fs.unlinkSync(p);
+    }
+});
+function componentId(file) {
+    return `/${COMPONENT_DIR}/${file}`;
+}
+/** A copy of `file` with initial-state literals replaced, to reach a later view. */
+function seeded(file, seeds) {
+    let source = fs.readFileSync(path.join(ROOT, COMPONENT_DIR, file), 'utf8');
+    for (const [from, to] of seeds) {
+        if (!source.includes(from)) {
+            throw new Error(`State seed target not found in ${file}:\n  ${from}\n` +
+                'The component was refactored. Update the seed so the test keeps ' +
+                'rendering the intended view — do not delete the assertion.');
+        }
+        source = source.replace(from, to);
+    }
+    const name = `${SEED_PREFIX}${process.pid}-${seededPaths.length}-${file}`;
+    const full = path.join(ROOT, COMPONENT_DIR, name);
+    fs.writeFileSync(full, source);
+    seededPaths.push(full);
+    return `/${COMPONENT_DIR}/${name}`;
+}
+async function renderComponent(id, props = {}) {
+    const mod = await server.ssrLoadModule(id);
+    const Component = mod.default;
+    return render(Component, { props }).body;
+}
+/**
+ * Point the shared config store at a locale.
+ *
+ * The components read locale off BridgeConfig rather than taking it as a prop,
+ * so this is how a real app sets it. Loaded through the same Vite module graph
+ * the components resolve, otherwise they would read a different store instance.
+ */
+async function setLocale(locale) {
+    const mod = await server.ssrLoadModule('/src/lib/client/stores/config.store.ts');
+    mod.bridgeConfig.initConfig({ appId: 'tbp-634-test', locale });
+}
+const CONNECTION = { type: 'google', name: 'Google' };
+function text(html) {
+    return html
+        .replace(/<!--[\s\S]*?-->/g, '')
+        .replace(/<[^>]*>/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+// ---------------------------------------------------------------------------
+// 1. What the server renderer can reach directly
+// ---------------------------------------------------------------------------
+describe('TenantSelector heading (TBP-634)', () => {
+    it('renders the English heading when no locale is set', async () => {
+        await setLocale(undefined);
+        const html = await renderComponent(componentId('TenantSelector.svelte'));
+        expect(text(html)).toContain(en['tenant.chooseHeading']);
+    });
+    it('renders the Swedish heading at locale sv', async () => {
+        await setLocale('sv');
+        const html = await renderComponent(componentId('TenantSelector.svelte'));
+        const rendered = text(html);
+        expect(rendered).toContain(sv['tenant.chooseHeading']);
+        // The English must be GONE, not merely joined by the Swedish. A component
+        // that rendered both would satisfy a `toContain` on the Swedish alone.
+        expect(rendered).not.toContain(en['tenant.chooseHeading']);
+    });
+    it('lets a per-component override beat the locale', async () => {
+        await setLocale('sv');
+        const html = await renderComponent(componentId('TenantSelector.svelte'), {
+            messages: { 'tenant.chooseHeading': 'Välj kund' },
+        });
+        const rendered = text(html);
+        expect(rendered).toContain('Välj kund');
+        expect(rendered).not.toContain(sv['tenant.chooseHeading']);
+    });
+    it('never renders the raw key', async () => {
+        for (const locale of ['sv', 'de', 'klingon', undefined]) {
+            await setLocale(locale);
+            const html = await renderComponent(componentId('TenantSelector.svelte'));
+            expect(text(html)).not.toContain('tenant.chooseHeading');
+        }
+    });
+});
+describe('SsoButton label (TBP-634)', () => {
+    it('interpolates the provider name into the localised label', async () => {
+        await setLocale('sv');
+        const html = await renderComponent(componentId('SsoButton.svelte'), {
+            connection: CONNECTION,
+        });
+        const rendered = text(html);
+        expect(rendered).toBe(sv['sso.continueWith'].replace('{provider}', 'Google'));
+        // Placeholder consumed, not printed.
+        expect(rendered).not.toContain('{provider}');
+        expect(rendered).not.toContain(en['sso.continueWith'].replace('{provider}', 'Google'));
+    });
+    it('still lets the app supply its own label — that is voice, not mechanics', async () => {
+        await setLocale('sv');
+        const html = await renderComponent(componentId('SsoButton.svelte'), {
+            connection: CONNECTION,
+            label: 'Logga in med jobbkontot',
+        });
+        expect(text(html)).toBe('Logga in med jobbkontot');
+    });
+    it('falls back to English for an unsupported locale, never to the key', async () => {
+        // Invented, not a real-but-unshipped code: TBP-632 turned 'de' and 'fr'
+        // into shipped locales and broke every test that had borrowed one as its
+        // stand-in for 'unknown'.
+        await setLocale('klingon');
+        const html = await renderComponent(componentId('SsoButton.svelte'), {
+            connection: CONNECTION,
+        });
+        expect(text(html)).toBe(en['sso.continueWith'].replace('{provider}', 'Google'));
+    });
+});
+// ---------------------------------------------------------------------------
+// 2. The error strings, reached by seeding initial state
+// ---------------------------------------------------------------------------
+describe('selector error copy resolves through the catalogue (TBP-634)', () => {
+    const CASES = [
+        {
+            file: 'TenantSelector.svelte',
+            from: 'let error = $state<string | null>(null);',
+            key: 'tenant.error.select',
+        },
+        {
+            file: 'WorkspaceSelector.svelte',
+            from: 'let loadError = $state<string | null>(null);',
+            key: 'workspace.error.load',
+        },
+        {
+            file: 'WorkspaceSelector.svelte',
+            from: 'let switchError = $state<string | null>(null);',
+            key: 'workspace.error.switch',
+        },
+    ];
+    for (const { file, from, key } of CASES) {
+        it(`${file} renders ${key} in Swedish`, async () => {
+            await setLocale('sv');
+            const to = from.replace('(null)', `(t('${key}'))`);
+            const html = await renderComponent(seeded(file, [[from, to]]));
+            const rendered = text(html);
+            expect(rendered).toContain(sv[key]);
+            expect(rendered).not.toContain(en[key]);
+        });
+    }
+});
+// ---------------------------------------------------------------------------
+// 3. Source sweep — the half that survives a reverted handler
+// ---------------------------------------------------------------------------
+describe('no English literal remains in the three components (TBP-634)', () => {
+    for (const [file, keys] of Object.entries(OWNED)) {
+        it(`${file} carries none of its English strings as a literal`, () => {
+            const source = fs.readFileSync(path.join(ROOT, COMPONENT_DIR, file), 'utf8');
+            for (const key of keys) {
+                // Interpolated copy is compared on its literal prefix: the source used
+                // to hold `Continue with ${connection.name}`, which is the catalogue
+                // string with the placeholder swapped for an expression.
+                const needle = en[key].split('{')[0].trim();
+                expect(needle.length, `${key} has no comparable literal prefix`).toBeGreaterThan(4);
+                expect(source, `${file} still contains "${needle}"`).not.toContain(needle);
+            }
+        });
+    }
+    it('the sweep is looking at real files with real content', () => {
+        // Guard against the whole suite passing because a rename made every
+        // readFileSync return something empty or unrelated.
+        for (const file of Object.keys(OWNED)) {
+            const source = fs.readFileSync(path.join(ROOT, COMPONENT_DIR, file), 'utf8');
+            expect(source.length).toBeGreaterThan(500);
+            expect(source).toContain('getTranslator');
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// 4. LoginForm fans `messages` down to TenantSelector
+// ---------------------------------------------------------------------------
+describe('LoginForm → TenantSelector fan-out (TBP-634)', () => {
+    it('passes messages down, the way it already does to MfaChallenge', () => {
+        // Only reachable on the multi-workspace path, which needs auth state a
+        // server render cannot produce — so this is asserted on the template. It is
+        // the easiest of the fan-outs to forget precisely because it so rarely
+        // renders.
+        const source = fs.readFileSync(path.join(ROOT, COMPONENT_DIR, 'LoginForm.svelte'), 'utf8');
+        const tag = source.match(/<TenantSelector[^>]*\/>/);
+        expect(tag, 'LoginForm no longer renders <TenantSelector>').not.toBeNull();
+        expect(tag[0]).toContain('{messages}');
+    });
+});

package/dist/styles.css

@@ -309,6 +309,19 @@
   margin: 0 0 1rem;
 }
 
+/* TBP-635 — the card between a successful sign-in and the host app navigating. */
+.bridge-auth-settling {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.75rem;
+  /* Roughly the height of the credentials form it replaces, so the card does
+     not collapse and then re-expand under the cursor. */
+  min-height: 8rem;
+  color: var(--bridge-muted, #6b7280);
+  font-size: 0.875rem;
+}
+
 .bridge-mfa-help {
   font-size: 0.8125rem;
   color: var(--bridge-muted, #6b7280);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nebulr-group/bridge-svelte",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "description": "Bridge Svelte library, This library helps you to add bridge authentication and feature flags, and payments to your svelte application.",
   "author": "Iman Pouya",
   "license": "MIT",
@@ -56,7 +56,7 @@
     "svelte": "^5.0.0",
     "@sveltejs/kit": "^2.0.0",
     "@stripe/stripe-js": ">=4.0.0",
-    "@nebulr-group/bridge-auth-core": ">=0.5.0 <1.0.0"
+    "@nebulr-group/bridge-auth-core": ">=0.6.0 <1.0.0"
   },
   "peerDependenciesMeta": {
     "@stripe/stripe-js": {
@@ -77,7 +77,7 @@
     "typescript": "^6.0.0",
     "vite": "^6.2.6",
     "vitest": "^4.1.4",
-    "@nebulr-group/bridge-auth-core": "^0.5.0"
+    "@nebulr-group/bridge-auth-core": "^0.6.0"
   },
   "keywords": [
     "svelte",