@asteby/metacore-runtime-react 9.1.0 → 10.0.0

package/dist/use-org-config-bridge.js

@@ -0,0 +1,50 @@
+// Bridge to `useOrgConfig` from `@asteby/metacore-app-providers` without
+// adding it as a hard dependency of `runtime-react`. The provider package
+// is a peer; in apps that mount it the hook returns the live config, in
+// apps that don't the SDK falls through to a no-op shim that resolves
+// every reference to null. Forms then leave $org.<key> tokens in place
+// rather than crashing — the operator notices the missing config when
+// the validator fails to fire, not at app boot.
+//
+// Why a bridge: runtime-react cannot import `@asteby/metacore-app-providers`
+// directly without inverting the dependency graph (app-providers depends
+// on runtime-react today via peerDependenciesMeta). The shim shape
+// matches `OrgConfigContextValue` so DynamicForm code reads through one
+// stable interface regardless of provider mount.
+const NULL_BRIDGE = {
+    resolveValidator: () => null,
+    available: false,
+};
+let activeBridge = NULL_BRIDGE;
+/**
+ * Apps that consume `runtime-react` AND `@asteby/metacore-app-providers`
+ * call this once near the root (typically inside the OrgConfigProvider
+ * children) so the SDK reads the same resolver. Hosts without an org
+ * provider can ignore this entirely; the SDK's null bridge keeps every
+ * call returning `null` so $org.<key> tokens stay verbatim in the form
+ * — same fallback the kernel uses for unresolved references.
+ */
+export function setOrgConfigBridge(bridge) {
+    activeBridge = bridge ?? NULL_BRIDGE;
+}
+/**
+ * Returns the active bridge. Pure read — no React hook so it can be
+ * called from non-component code (zod schema builders, helpers).
+ */
+export function getOrgConfigBridge() {
+    return activeBridge;
+}
+/**
+ * Resolves a Validation token into the validator identifier the SDK
+ * should apply. Returns the resolved literal when the org config knows
+ * the key, or the original token when it doesn't (so apps can decide).
+ * Plain literals (no `$org.` prefix) pass through.
+ */
+export function resolveValidatorToken(token) {
+    if (!token)
+        return null;
+    if (!token.startsWith('$org.'))
+        return token;
+    const resolved = activeBridge.resolveValidator(token);
+    return resolved ?? token;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asteby/metacore-runtime-react",
-  "version": "9.1.0",
+  "version": "10.0.0",
   "description": "React runtime for metacore hosts — renders addon contributions dynamically",
   "repository": {
     "type": "git",
@@ -32,7 +32,7 @@
     "lucide-react": ">=0.460",
     "date-fns": ">=3",
     "react-day-picker": ">=8",
-    "@asteby/metacore-sdk": "^2.4.0",
+    "@asteby/metacore-sdk": "^2.5.0",
     "@asteby/metacore-ui": "^2.0.0"
   },
   "peerDependenciesMeta": {
@@ -57,10 +57,10 @@
     "react-i18next": "^17.0.0",
     "sonner": "^2.0.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.6.0",
+    "typescript": "^6.0.0",
     "vitest": "^4.0.0",
     "zustand": "^5.0.0",
-    "@asteby/metacore-sdk": "2.4.0",
+    "@asteby/metacore-sdk": "2.5.0",
     "@asteby/metacore-ui": "2.0.0"
   },
   "scripts": {

package/src/__tests__/hotswap-reload-policy.test.ts

@@ -0,0 +1,249 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+    applyHotSwapReload,
+    withVersionParam,
+    clearFederationContainer,
+    shortenHash,
+    type HotSwapReloadConfig,
+    type HotSwapReloadDeps,
+} from '../hotswap-reload-policy'
+import { type AddonManifestChangedMessage } from '../manifest-hotswap-subscriber'
+
+const msg = (
+    addonKey: string,
+    newHash: string | undefined = 'sha256:abcdef1234567890',
+): AddonManifestChangedMessage => ({
+    type: 'ADDON_MANIFEST_CHANGED',
+    payload: { addonKey, newHash },
+})
+
+interface FakeState {
+    map: Record<string, string>
+    deps: HotSwapReloadDeps
+    reload: ReturnType<typeof vi.fn>
+}
+
+function makeFakeState(): FakeState {
+    const reload = vi.fn()
+    const state: FakeState = {
+        map: {},
+        // populated below
+        deps: {} as HotSwapReloadDeps,
+        reload,
+    }
+    state.deps = {
+        setVersionMap: (updater) => {
+            state.map = updater(state.map)
+        },
+        reload,
+    }
+    return state
+}
+
+describe('shortenHash', () => {
+    it('strips the algorithm prefix and truncates to 8 hex chars', () => {
+        expect(shortenHash('sha256:ABCDEF1234567890')).toBe('abcdef12')
+        expect(shortenHash('abcdef1234567890')).toBe('abcdef12')
+    })
+
+    it('returns undefined for missing / empty input', () => {
+        expect(shortenHash(undefined)).toBeUndefined()
+        expect(shortenHash('')).toBeUndefined()
+        expect(shortenHash('sha256:')).toBeUndefined()
+    })
+})
+
+describe('withVersionParam', () => {
+    it('appends ?v=<hash8> to a URL with no query', () => {
+        expect(
+            withVersionParam('/api/addons/pos/frontend/remoteEntry.js', 'sha256:abcdef1234'),
+        ).toBe('/api/addons/pos/frontend/remoteEntry.js?v=abcdef12')
+    })
+
+    it('appends &v=<hash8> when other query params exist', () => {
+        expect(withVersionParam('/r.js?foo=1&bar=2', 'abcdef1234')).toBe(
+            '/r.js?foo=1&bar=2&v=abcdef12',
+        )
+    })
+
+    it('replaces a prior v= entry instead of accumulating', () => {
+        expect(withVersionParam('/r.js?v=oldhash&foo=1', 'newhash99')).toBe(
+            '/r.js?foo=1&v=newhash9',
+        )
+    })
+
+    it('preserves the URL fragment', () => {
+        expect(withVersionParam('/r.js#section', 'abcdef1234')).toBe(
+            '/r.js?v=abcdef12#section',
+        )
+    })
+
+    it('is idempotent for the same hash', () => {
+        const once = withVersionParam('/r.js', 'abcdef1234')
+        const twice = withVersionParam(once, 'abcdef1234')
+        expect(twice).toBe(once)
+    })
+
+    it('returns the URL unchanged for falsy hash', () => {
+        expect(withVersionParam('/r.js', undefined)).toBe('/r.js')
+        expect(withVersionParam('/r.js', '')).toBe('/r.js')
+    })
+})
+
+describe('clearFederationContainer', () => {
+    it('removes the container from window and returns true', () => {
+        // Node test environment — globalThis is functionally `window` here.
+        // We set a property and expect it to be removed.
+        ;(globalThis as Record<string, unknown>).metacore_test_addon = {
+            init: () => {},
+            get: () => {},
+        }
+        // The function checks `typeof window === 'undefined'`. In node env
+        // that's true → returns false. We only assert this code path doesn't
+        // throw and returns a boolean. The window-present case is exercised
+        // indirectly through manual integration in the hot-swap docs.
+        const result = clearFederationContainer('metacore_test_addon')
+        expect(typeof result).toBe('boolean')
+        delete (globalThis as Record<string, unknown>).metacore_test_addon
+    })
+
+    it('returns false when called for an unregistered scope in SSR (no window)', () => {
+        expect(clearFederationContainer('metacore_never_registered')).toBe(false)
+    })
+})
+
+describe('applyHotSwapReload', () => {
+    it('returns "noop" and does not touch the map when addonKey is missing', async () => {
+        const state = makeFakeState()
+        const action = await applyHotSwapReload(
+            {
+                type: 'ADDON_MANIFEST_CHANGED',
+                // @ts-expect-error — exercising the guard
+                payload: {},
+            },
+            {},
+            state.deps,
+        )
+        expect(action).toBe('noop')
+        expect(state.map).toEqual({})
+    })
+
+    it('default strategy rekeys the map with the short hash and fires onSwap("rekey")', async () => {
+        const state = makeFakeState()
+        const onSwap = vi.fn()
+        const action = await applyHotSwapReload(
+            msg('pos', 'sha256:abcdef1234'),
+            { onSwap },
+            state.deps,
+        )
+        expect(action).toBe('rekey')
+        expect(state.map).toEqual({ pos: 'abcdef12' })
+        expect(onSwap).toHaveBeenCalledWith(expect.anything(), 'rekey')
+    })
+
+    it('successive bumps for the same addon update the hash in place', async () => {
+        const state = makeFakeState()
+        await applyHotSwapReload(msg('pos', 'sha256:abcdef1234'), {}, state.deps)
+        await applyHotSwapReload(msg('pos', 'sha256:99999999'), {}, state.deps)
+        expect(state.map).toEqual({ pos: '99999999' })
+    })
+
+    it('bumps for different addons accumulate as independent entries', async () => {
+        const state = makeFakeState()
+        await applyHotSwapReload(msg('pos', 'sha256:aaaaaaaa'), {}, state.deps)
+        await applyHotSwapReload(msg('kitchen', 'sha256:bbbbbbbb'), {}, state.deps)
+        expect(state.map).toEqual({ pos: 'aaaaaaaa', kitchen: 'bbbbbbbb' })
+    })
+
+    it('cancels rekey when onBeforeReload returns false (sync)', async () => {
+        const state = makeFakeState()
+        const onBeforeReload = vi.fn().mockReturnValue(false)
+        const onSwap = vi.fn()
+        const action = await applyHotSwapReload(
+            msg('pos'),
+            { strategy: 'rekey', onBeforeReload, onSwap },
+            state.deps,
+        )
+        expect(action).toBe('cancelled')
+        expect(state.map).toEqual({})
+        expect(onSwap).toHaveBeenCalledWith(expect.anything(), 'cancelled')
+    })
+
+    it('proceeds with rekey when async onBeforeReload resolves true', async () => {
+        const state = makeFakeState()
+        const onBeforeReload = vi.fn().mockResolvedValue(true)
+        const action = await applyHotSwapReload(
+            msg('pos'),
+            { strategy: 'rekey', onBeforeReload },
+            state.deps,
+        )
+        expect(action).toBe('rekey')
+        expect(state.map).toEqual({ pos: 'abcdef12' })
+    })
+
+    it('strategy=manual updates the map and reports "manual" without reloading', async () => {
+        const state = makeFakeState()
+        const onSwap = vi.fn()
+        const action = await applyHotSwapReload(
+            msg('pos'),
+            { strategy: 'manual', onSwap },
+            state.deps,
+        )
+        expect(action).toBe('manual')
+        expect(state.map).toEqual({ pos: 'abcdef12' })
+        expect(state.reload).not.toHaveBeenCalled()
+        expect(onSwap).toHaveBeenCalledWith(expect.anything(), 'manual')
+    })
+
+    it('strategy=page-reload invokes the reload function via microtask', async () => {
+        const state = makeFakeState()
+        const onSwap = vi.fn()
+        const action = await applyHotSwapReload(
+            msg('pos'),
+            { strategy: 'page-reload', onSwap },
+            state.deps,
+        )
+        expect(action).toBe('page-reload')
+        expect(onSwap).toHaveBeenCalledWith(expect.anything(), 'page-reload')
+
+        // Yield to the microtask queue so the deferred reload fires.
+        await Promise.resolve()
+        expect(state.reload).toHaveBeenCalledTimes(1)
+    })
+
+    it('strategy=page-reload + onBeforeReload(false) skips the reload', async () => {
+        const state = makeFakeState()
+        const onBeforeReload = vi.fn().mockReturnValue(false)
+        const onSwap = vi.fn()
+        const action = await applyHotSwapReload(
+            msg('pos'),
+            { strategy: 'page-reload', onBeforeReload, onSwap },
+            state.deps,
+        )
+        expect(action).toBe('cancelled')
+        await Promise.resolve()
+        expect(state.reload).not.toHaveBeenCalled()
+        expect(onSwap).toHaveBeenCalledWith(expect.anything(), 'cancelled')
+    })
+
+    it('skips map update when newHash is missing but still rekeys (no-op effect)', async () => {
+        const state = makeFakeState()
+        const onSwap = vi.fn()
+        // Build a message with an explicitly missing newHash. Going through
+        // `msg(..., undefined)` would trigger the default-value substitution,
+        // so we hand-roll the payload here.
+        const action = await applyHotSwapReload(
+            {
+                type: 'ADDON_MANIFEST_CHANGED',
+                payload: { addonKey: 'pos' },
+            },
+            { onSwap },
+            state.deps,
+        )
+        expect(action).toBe('rekey')
+        // Without a hash, we have nothing to write; the map stays empty
+        // but onSwap still fires for telemetry.
+        expect(state.map).toEqual({})
+        expect(onSwap).toHaveBeenCalledWith(expect.anything(), 'rekey')
+    })
+})

package/src/__tests__/manifest-hotswap-subscriber.test.ts

@@ -0,0 +1,179 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+    ADDON_MANIFEST_CHANGED_TYPE,
+    wireHotSwapInvalidation,
+    type AddonManifestChangedMessage,
+    type ManifestHotSwapClient,
+} from '../manifest-hotswap-subscriber'
+import { useMetadataCache, defaultAddonKeyMatcher } from '../metadata-cache'
+import type { TableMetadata } from '../types'
+
+// Minimal stub TableMetadata; the cache stores values opaquely so the only
+// requirement is the type-shape compiles.
+const fakeMeta = (label: string): TableMetadata => ({ label }) as unknown as TableMetadata
+
+interface FakeClient extends ManifestHotSwapClient {
+    emit: (msg: AddonManifestChangedMessage) => void
+    subscriberCount: () => number
+}
+
+function makeFakeClient(): FakeClient {
+    const subs = new Map<string, Set<(m: AddonManifestChangedMessage) => void>>()
+    return {
+        subscribe(type, handler) {
+            let set = subs.get(type)
+            if (!set) {
+                set = new Set()
+                subs.set(type, set)
+            }
+            set.add(handler)
+            return () => {
+                subs.get(type)?.delete(handler)
+            }
+        },
+        emit(msg) {
+            const set = subs.get(msg.type)
+            if (!set) return
+            for (const h of set) h(msg)
+        },
+        subscriberCount() {
+            return Array.from(subs.values()).reduce((n, s) => n + s.size, 0)
+        },
+    }
+}
+
+describe('manifest-hotswap-subscriber', () => {
+    beforeEach(() => {
+        // Reset the zustand cache between tests so each starts from a
+        // known-empty state. The store persists by default; resetState
+        // here keeps the in-memory copy isolated.
+        useMetadataCache.setState({
+            cache: {},
+            modalCache: {},
+            metadataVersion: 'v-old',
+            prefetched: true,
+        })
+    })
+
+    afterEach(() => {
+        vi.restoreAllMocks()
+    })
+
+    it('emits the topic name the kernel/bridge publishes', () => {
+        expect(ADDON_MANIFEST_CHANGED_TYPE).toBe('ADDON_MANIFEST_CHANGED')
+    })
+
+    it('subscribes to ADDON_MANIFEST_CHANGED and invalidates the named addon on receipt', () => {
+        const cache = useMetadataCache.getState()
+        cache.setMetadata('kitchen_display.tickets', fakeMeta('tickets'))
+        cache.setMetadata('kitchen_display:settings', fakeMeta('settings'))
+        cache.setMetadata('kitchen_display/lines', fakeMeta('lines'))
+        cache.setMetadata('pos.cart', fakeMeta('cart'))
+        cache.setModalMetadata('kitchen_display.printer', fakeMeta('printer'))
+        cache.setModalMetadata('inventory.batch', fakeMeta('batch'))
+
+        const client = makeFakeClient()
+        const unsubscribe = wireHotSwapInvalidation(client)
+        expect(client.subscriberCount()).toBe(1)
+
+        client.emit({
+            type: 'ADDON_MANIFEST_CHANGED',
+            payload: {
+                addonKey: 'kitchen_display',
+                oldHash: 'sha256:aaa',
+                newHash: 'sha256:bbb',
+                version: '1.2.0',
+            },
+        })
+
+        const after = useMetadataCache.getState()
+        // Three table-cache entries scoped to kitchen_display should be gone.
+        expect(after.cache).toEqual({ 'pos.cart': fakeMeta('cart') })
+        // One modal entry gone; the inventory entry stays.
+        expect(after.modalCache).toEqual({ 'inventory.batch': fakeMeta('batch') })
+        // prefetched flipped to false so prefetchAll() can re-run.
+        expect(after.prefetched).toBe(false)
+
+        unsubscribe()
+        expect(client.subscriberCount()).toBe(0)
+    })
+
+    it('invokes the onSwap callback with the message and the removed count', () => {
+        const cache = useMetadataCache.getState()
+        cache.setMetadata('pos.cart', fakeMeta('cart'))
+        cache.setMetadata('pos:lines', fakeMeta('lines'))
+        cache.setMetadata('inventory.batch', fakeMeta('batch'))
+
+        const onSwap = vi.fn()
+        const client = makeFakeClient()
+        wireHotSwapInvalidation(client, { onSwap })
+
+        const message: AddonManifestChangedMessage = {
+            type: 'ADDON_MANIFEST_CHANGED',
+            payload: { addonKey: 'pos', newHash: 'sha256:new' },
+        }
+        client.emit(message)
+
+        expect(onSwap).toHaveBeenCalledTimes(1)
+        expect(onSwap).toHaveBeenCalledWith(message, 2)
+    })
+
+    it('honours a custom matcher when the host uses a different key convention', () => {
+        const cache = useMetadataCache.getState()
+        cache.setMetadata('addons/pos/cart', fakeMeta('cart'))
+        cache.setMetadata('addons/pos/lines', fakeMeta('lines'))
+        cache.setMetadata('addons/inv/batch', fakeMeta('batch'))
+
+        const matcher = (cacheKey: string, addonKey: string) =>
+            cacheKey.startsWith(`addons/${addonKey}/`)
+
+        const client = makeFakeClient()
+        wireHotSwapInvalidation(client, { matcher })
+
+        client.emit({
+            type: 'ADDON_MANIFEST_CHANGED',
+            payload: { addonKey: 'pos' },
+        })
+
+        const after = useMetadataCache.getState()
+        expect(Object.keys(after.cache)).toEqual(['addons/inv/batch'])
+    })
+
+    it('ignores malformed messages (missing addonKey) without throwing', () => {
+        const cache = useMetadataCache.getState()
+        cache.setMetadata('pos.cart', fakeMeta('cart'))
+
+        const client = makeFakeClient()
+        wireHotSwapInvalidation(client)
+
+        expect(() =>
+            client.emit({
+                type: 'ADDON_MANIFEST_CHANGED',
+                // @ts-expect-error — exercising the malformed-payload guard
+                payload: {},
+            }),
+        ).not.toThrow()
+
+        // Cache untouched.
+        expect(useMetadataCache.getState().cache).toEqual({
+            'pos.cart': fakeMeta('cart'),
+        })
+    })
+
+    it('returns a no-op unsubscribe when the client is undefined', () => {
+        const unsubscribe = wireHotSwapInvalidation(undefined)
+        expect(typeof unsubscribe).toBe('function')
+        expect(() => unsubscribe()).not.toThrow()
+    })
+
+    it('default matcher recognises addonKey, prefix., prefix:, prefix/', () => {
+        expect(defaultAddonKeyMatcher('pos', 'pos')).toBe(true)
+        expect(defaultAddonKeyMatcher('pos.cart', 'pos')).toBe(true)
+        expect(defaultAddonKeyMatcher('pos:lines', 'pos')).toBe(true)
+        expect(defaultAddonKeyMatcher('pos/checkout', 'pos')).toBe(true)
+        expect(defaultAddonKeyMatcher('possible.x', 'pos')).toBe(false)
+        expect(defaultAddonKeyMatcher('inventory.cart', 'pos')).toBe(false)
+        expect(defaultAddonKeyMatcher('', 'pos')).toBe(false)
+        expect(defaultAddonKeyMatcher('pos.cart', '')).toBe(false)
+    })
+})

package/src/__tests__/use-options-resolver.test.ts

@@ -0,0 +1,127 @@
+import { afterEach, describe, it, expect, vi } from 'vitest'
+import { projectOption } from '../use-options-resolver'
+import {
+    resolveValidatorToken,
+    setOrgConfigBridge,
+} from '../use-org-config-bridge'
+
+// `useOptionsResolver` itself is a React hook and would need jsdom +
+// react-test-renderer to exercise end-to-end. The bridge tests here
+// pin down the projection layer (the only impure shape conversion the
+// hook performs) so consumers can rely on the v0.9.0 envelope reading
+// without spinning up a renderer.
+
+describe('projectOption', () => {
+    it('mirrors id into value and label into name when missing', () => {
+        const out = projectOption({ id: 'abc', label: 'Hello' })
+        expect(out.id).toBe('abc')
+        expect(out.value).toBe('abc')
+        expect(out.label).toBe('Hello')
+        expect(out.name).toBe('Hello')
+    })
+
+    it('preserves explicit value and name when provided', () => {
+        const out = projectOption({ id: 1, value: 'one', label: 'L', name: 'N' })
+        expect(out.value).toBe('one')
+        expect(out.name).toBe('N')
+    })
+
+    it('coerces label to string from numeric id when none provided', () => {
+        const out = projectOption({ id: 42 })
+        expect(out.label).toBe('42')
+        expect(out.name).toBe('42')
+    })
+
+    it('preserves optional decoration fields', () => {
+        const out = projectOption({
+            id: 'x', label: 'X',
+            description: 'desc', image: '/a.png',
+            color: '#fff', icon: 'IconStar',
+        })
+        expect(out.description).toBe('desc')
+        expect(out.image).toBe('/a.png')
+        expect(out.color).toBe('#fff')
+        expect(out.icon).toBe('IconStar')
+    })
+
+    it('null-safes missing optionals to null', () => {
+        const out = projectOption({ id: 'x', label: 'X' })
+        expect(out.description).toBeNull()
+        expect(out.image).toBeNull()
+        expect(out.color).toBeNull()
+        expect(out.icon).toBeNull()
+    })
+
+    it('survives empty payload (defensive)', () => {
+        const out = projectOption({})
+        expect(out.id).toBe('')
+        expect(out.value).toBe('')
+        expect(out.label).toBe('')
+        expect(out.name).toBe('')
+    })
+})
+
+// The envelope shape the hook expects from the kernel is exercised here
+// with a mocked transport so apps can document the wire contract in a
+// single place. `useOptionsResolver` reads `body.data` for options and
+// `body.meta.{type, count}` for the discriminator — the legacy
+// root-level `body.type` is also accepted for grace-period upgrades.
+describe('options envelope contract', () => {
+    it('v0.9.0 shape carries meta.type and meta.count', () => {
+        const wire = {
+            success: true,
+            data: [
+                { id: '1', label: 'One' },
+                { id: '2', label: 'Two' },
+            ],
+            meta: { type: 'dynamic', count: 2 },
+        }
+        // Smoke-check the projection a real call would do.
+        expect(wire.data.map(projectOption)).toHaveLength(2)
+        expect(wire.meta.type).toBe('dynamic')
+        expect(wire.meta.count).toBe(2)
+    })
+
+    it('legacy shape is identifiable but consumers should migrate', () => {
+        const legacy = {
+            success: true,
+            data: [{ id: '1', label: 'One' }],
+            // root-level type, not under meta — the SDK reads it as a
+            // fallback but logs no warning (kernel ≥ v0.9.0 emits the
+            // canonical shape; older deployments are an interop case).
+            type: 'static',
+        } as any
+        expect(legacy.type).toBe('static')
+        expect(legacy.meta).toBeUndefined()
+    })
+})
+
+// Sanity-check the resolver bridge: when no provider is mounted
+// `resolveValidatorToken` returns the original token. Apps that mount
+// `OrgConfigProvider` swap that for the resolved literal.
+describe('OrgConfigBridge integration', () => {
+    afterEach(() => {
+        // Reset to the null bridge so independent tests do not leak state.
+        setOrgConfigBridge(null)
+    })
+
+    it('resolveValidatorToken passes through plain literals', () => {
+        expect(resolveValidatorToken('mx.rfc')).toBe('mx.rfc')
+        expect(resolveValidatorToken(null)).toBeNull()
+        expect(resolveValidatorToken('')).toBeNull()
+    })
+
+    it('resolveValidatorToken returns the $org reference verbatim when no bridge mounted', () => {
+        // Default null bridge: ref keys resolve to null → token preserved.
+        expect(resolveValidatorToken('$org.tax_id')).toBe('$org.tax_id')
+    })
+
+    it('setOrgConfigBridge swaps the active resolver and survives clearing', () => {
+        const spy = vi.fn((key: string) => (key === '$org.tax_id' ? 'mx.rfc' : null))
+        setOrgConfigBridge({ resolveValidator: spy, available: true })
+        expect(resolveValidatorToken('$org.tax_id')).toBe('mx.rfc')
+        expect(spy).toHaveBeenCalledWith('$org.tax_id')
+        setOrgConfigBridge(null)
+        expect(resolveValidatorToken('$org.tax_id')).toBe('$org.tax_id')
+    })
+})