@fias/arche-sdk 1.11.0 → 1.13.0

package/dist/hooks.test.js

@@ -608,6 +608,256 @@ describe('SDK hooks', () => {
             // 1 initial + 1 delete + 1 fresh fetch (cache cleared by delete)
             expect(mockBridge.request).toHaveBeenCalledTimes(3);
         });
+        it('write forwards sensitivity / folderPath / replacesDocumentId', async () => {
+            const { useVaultDocuments } = freshHooks();
+            const api = useVaultDocuments();
+            mockBridge.request.mockResolvedValueOnce({ documentId: 'vdoc_w' });
+            await api.write({
+                name: 'sensitive.md',
+                content: '# secret',
+                contentType: 'text/markdown',
+                tags: ['private'],
+                sensitivity: 'confidential',
+                folderPath: '/My-Fias/Arches/arche_test',
+                replacesDocumentId: 'vdoc_prev',
+            });
+            expect(mockBridge.request).toHaveBeenCalledWith('vault_documents_write', {
+                name: 'sensitive.md',
+                content: '# secret',
+                contentType: 'text/markdown',
+                tags: ['private'],
+                sensitivity: 'confidential',
+                folderPath: '/My-Fias/Arches/arche_test',
+                replacesDocumentId: 'vdoc_prev',
+            });
+        });
+        it('search forwards query + options to vault_documents_search', async () => {
+            const { useVaultDocuments } = freshHooks();
+            const api = useVaultDocuments();
+            mockBridge.request.mockResolvedValueOnce({ matches: [] });
+            const res = await api.search('insurance policy', {
+                topK: 5,
+                minSimilarity: 0.7,
+                includeContent: false,
+            });
+            expect(mockBridge.request).toHaveBeenCalledWith('vault_documents_search', {
+                query: 'insurance policy',
+                topK: 5,
+                minSimilarity: 0.7,
+                includeContent: false,
+            });
+            expect(res).toEqual({ matches: [] });
+        });
+        it('attach posts the regarding target to vault_documents_attach', async () => {
+            const { useVaultDocuments } = freshHooks();
+            const api = useVaultDocuments();
+            mockBridge.request.mockResolvedValueOnce({
+                referenceId: 'vdref_xyz',
+                attachedAt: '2026-05-21T00:00:00Z',
+            });
+            const ref = await api.attach('vdoc_a', {
+                regardingType: 'vault_business_contact',
+                regardingId: 'bcon_abc',
+            });
+            expect(mockBridge.request).toHaveBeenCalledWith('vault_documents_attach', {
+                documentId: 'vdoc_a',
+                regardingType: 'vault_business_contact',
+                regardingId: 'bcon_abc',
+            });
+            expect(ref.referenceId).toBe('vdref_xyz');
+        });
+        it('detach posts documentId + referenceId to vault_documents_detach', async () => {
+            const { useVaultDocuments } = freshHooks();
+            const api = useVaultDocuments();
+            mockBridge.request.mockResolvedValueOnce({ success: true });
+            await api.detach('vdoc_a', 'vdref_xyz');
+            expect(mockBridge.request).toHaveBeenCalledWith('vault_documents_detach', {
+                documentId: 'vdoc_a',
+                referenceId: 'vdref_xyz',
+            });
+        });
+        it('uploadInit posts the full param set to vault_documents_upload_init', async () => {
+            const { useVaultDocuments } = freshHooks();
+            const api = useVaultDocuments();
+            mockBridge.request.mockResolvedValueOnce({
+                documentId: 'vdoc_u',
+                uploadUrl: 'https://s3/up',
+                requiredHeaders: { 'Content-Type': 'application/pdf' },
+                uploadUrlExpiresAt: '2026-05-21T00:05:00Z',
+            });
+            const init = await api.uploadInit({
+                name: 'report.pdf',
+                mimeType: 'application/pdf',
+                sizeBytes: 1024,
+                checksumSha256: 'a'.repeat(64),
+                tags: ['report'],
+                sensitivity: 'confidential',
+                folderPath: '/My-Fias/Arches/arche_test',
+                replacesDocumentId: undefined,
+            });
+            expect(mockBridge.request).toHaveBeenCalledWith('vault_documents_upload_init', {
+                name: 'report.pdf',
+                mimeType: 'application/pdf',
+                sizeBytes: 1024,
+                checksumSha256: 'a'.repeat(64),
+                tags: ['report'],
+                sensitivity: 'confidential',
+                folderPath: '/My-Fias/Arches/arche_test',
+                replacesDocumentId: undefined,
+            });
+            expect(init.documentId).toBe('vdoc_u');
+        });
+        it('uploadFinalize posts documentId + checksum to vault_documents_upload_finalize', async () => {
+            const { useVaultDocuments } = freshHooks();
+            const api = useVaultDocuments();
+            mockBridge.request.mockResolvedValueOnce({
+                documentId: 'vdoc_u',
+                status: 'uploaded',
+            });
+            const fin = await api.uploadFinalize({
+                documentId: 'vdoc_u',
+                checksumSha256: 'b'.repeat(64),
+            });
+            expect(mockBridge.request).toHaveBeenCalledWith('vault_documents_upload_finalize', {
+                documentId: 'vdoc_u',
+                checksumSha256: 'b'.repeat(64),
+            });
+            expect(fin.status).toBe('uploaded');
+        });
+        it('upload() orchestrates SHA-256 + presigned PUT + finalize, stripping Content-Length', async () => {
+            const { useVaultDocuments } = freshHooks();
+            const api = useVaultDocuments();
+            // Mock crypto.subtle.digest to return a known 32-byte digest.
+            const fakeDigest = new Uint8Array(32);
+            for (let i = 0; i < 32; i++)
+                fakeDigest[i] = i;
+            const originalCrypto = globalThis.crypto;
+            globalThis.crypto = {
+                subtle: { digest: jest.fn().mockResolvedValue(fakeDigest.buffer) },
+            };
+            // Mock fetch.
+            const fetchMock = jest.fn().mockResolvedValue({ ok: true, status: 200 });
+            const originalFetch = globalThis.fetch;
+            globalThis.fetch = fetchMock;
+            try {
+                mockBridge.request.mockResolvedValueOnce({
+                    documentId: 'vdoc_u',
+                    uploadUrl: 'https://s3/up',
+                    requiredHeaders: {
+                        'Content-Type': 'application/octet-stream',
+                        'Content-Length': '4',
+                        'x-amz-checksum-sha256': 'aaa',
+                        'x-amz-tagging': 'pending=true',
+                    },
+                    uploadUrlExpiresAt: '2026-05-21T00:05:00Z',
+                });
+                mockBridge.request.mockResolvedValueOnce({
+                    documentId: 'vdoc_u',
+                    status: 'uploaded',
+                });
+                const bytes = new Uint8Array([1, 2, 3, 4]);
+                const result = await api.upload(bytes, {
+                    name: 'tiny.bin',
+                    mimeType: 'application/octet-stream',
+                });
+                // SDK rendered the digest as lowercase hex.
+                const expectedHex = Array.from(fakeDigest)
+                    .map((b) => b.toString(16).padStart(2, '0'))
+                    .join('');
+                expect(mockBridge.request).toHaveBeenNthCalledWith(1, 'vault_documents_upload_init', expect.objectContaining({
+                    sizeBytes: 4,
+                    checksumSha256: expectedHex,
+                }));
+                // Browser fetch was called with Content-Length stripped from the
+                // headers (browser auto-computes it from body.byteLength).
+                expect(fetchMock).toHaveBeenCalledTimes(1);
+                const fetchOpts = fetchMock.mock.calls[0][1];
+                const headerKeys = Object.keys(fetchOpts.headers).map((k) => k.toLowerCase());
+                expect(headerKeys).not.toContain('content-length');
+                expect(headerKeys).toContain('content-type');
+                expect(headerKeys).toContain('x-amz-checksum-sha256');
+                // Finalize used the same hex digest.
+                expect(mockBridge.request).toHaveBeenNthCalledWith(2, 'vault_documents_upload_finalize', {
+                    documentId: 'vdoc_u',
+                    checksumSha256: expectedHex,
+                });
+                expect(result.status).toBe('uploaded');
+            }
+            finally {
+                globalThis.crypto = originalCrypto;
+                globalThis.fetch = originalFetch;
+            }
+        });
+        it('upload() throws on non-2xx PUT response', async () => {
+            const { useVaultDocuments } = freshHooks();
+            const api = useVaultDocuments();
+            const fakeDigest = new Uint8Array(32);
+            const originalCrypto = globalThis.crypto;
+            globalThis.crypto = {
+                subtle: { digest: jest.fn().mockResolvedValue(fakeDigest.buffer) },
+            };
+            const fetchMock = jest.fn().mockResolvedValue({
+                ok: false,
+                status: 403,
+                statusText: 'Forbidden',
+                text: () => Promise.resolve('signature mismatch'),
+            });
+            const originalFetch = globalThis.fetch;
+            globalThis.fetch = fetchMock;
+            try {
+                mockBridge.request.mockResolvedValueOnce({
+                    documentId: 'vdoc_u',
+                    uploadUrl: 'https://s3/up',
+                    requiredHeaders: { 'Content-Type': 'application/octet-stream' },
+                    uploadUrlExpiresAt: '2026-05-21T00:05:00Z',
+                });
+                await expect(api.upload(new Uint8Array([1, 2, 3]), {
+                    name: 'x.bin',
+                    mimeType: 'application/octet-stream',
+                })).rejects.toThrow(/403/);
+            }
+            finally {
+                globalThis.crypto = originalCrypto;
+                globalThis.fetch = originalFetch;
+            }
+        });
+        it('upload() accepts a raw ArrayBuffer as well as a Uint8Array', async () => {
+            const { useVaultDocuments } = freshHooks();
+            const api = useVaultDocuments();
+            const fakeDigest = new Uint8Array(32);
+            const originalCrypto = globalThis.crypto;
+            globalThis.crypto = {
+                subtle: { digest: jest.fn().mockResolvedValue(fakeDigest.buffer) },
+            };
+            const fetchMock = jest.fn().mockResolvedValue({ ok: true, status: 200 });
+            const originalFetch = globalThis.fetch;
+            globalThis.fetch = fetchMock;
+            try {
+                mockBridge.request.mockResolvedValueOnce({
+                    documentId: 'vdoc_u',
+                    uploadUrl: 'https://s3/up',
+                    requiredHeaders: {},
+                    uploadUrlExpiresAt: '2026-05-21T00:05:00Z',
+                });
+                mockBridge.request.mockResolvedValueOnce({
+                    documentId: 'vdoc_u',
+                    status: 'uploaded',
+                });
+                const buffer = new ArrayBuffer(8);
+                const view = new Uint8Array(buffer);
+                view.set([1, 2, 3, 4, 5, 6, 7, 8]);
+                const result = await api.upload(buffer, {
+                    name: 'ab.bin',
+                    mimeType: 'application/octet-stream',
+                });
+                expect(result.status).toBe('uploaded');
+                expect(mockBridge.request).toHaveBeenNthCalledWith(1, 'vault_documents_upload_init', expect.objectContaining({ sizeBytes: 8 }));
+            }
+            finally {
+                globalThis.crypto = originalCrypto;
+                globalThis.fetch = originalFetch;
+            }
+        });
     });
     describe('useSurface', () => {
         it('invokes the surface_invoke bridge op with the given surfaceKey', async () => {
@@ -632,5 +882,386 @@ describe('SDK hooks', () => {
             await expect(api.invoke({ text: 'hi' })).rejects.toThrow('rate limited');
         });
     });
+    describe('useImageGeneration', () => {
+        it('returns initial state from useState', () => {
+            const { useImageGeneration } = require('./hooks');
+            const api = useImageGeneration();
+            expect(api.isLoading).toBe(false);
+            expect(api.result).toBeNull();
+            expect(api.error).toBeNull();
+            expect(typeof api.generate).toBe('function');
+        });
+        it('generate calls bridge.request with image_generate + 120s timeout and returns the result', async () => {
+            const { useImageGeneration } = require('./hooks');
+            mockBridge.request.mockResolvedValue({ images: [{ url: 'https://x/img.png' }] });
+            const api = useImageGeneration();
+            const result = await api.generate({ prompt: 'a cat' });
+            expect(mockBridge.request).toHaveBeenCalledWith('image_generate', { prompt: 'a cat' }, 120000);
+            expect(result.images[0].url).toBe('https://x/img.png');
+        });
+        it('rethrows and wraps non-Error rejections', async () => {
+            const { useImageGeneration } = require('./hooks');
+            mockBridge.request.mockRejectedValue('content policy violation');
+            const api = useImageGeneration();
+            await expect(api.generate({ prompt: 'x' })).rejects.toThrow('content policy violation');
+        });
+    });
+    describe('useAudioGeneration', () => {
+        it('returns initial state', () => {
+            const { useAudioGeneration } = require('./hooks');
+            const api = useAudioGeneration();
+            expect(api.isLoading).toBe(false);
+            expect(api.result).toBeNull();
+            expect(api.error).toBeNull();
+        });
+        it('generate calls bridge.request with audio_generate + 180s timeout', async () => {
+            const { useAudioGeneration } = require('./hooks');
+            mockBridge.request.mockResolvedValue({ clips: [{ url: 'https://x/clip.mp3' }] });
+            const api = useAudioGeneration();
+            await api.generate({ prompt: 'lofi beat' });
+            expect(mockBridge.request).toHaveBeenCalledWith('audio_generate', { prompt: 'lofi beat' }, 180000);
+        });
+        it('rethrows bridge errors', async () => {
+            const { useAudioGeneration } = require('./hooks');
+            mockBridge.request.mockRejectedValue(new Error('Lyria timeout'));
+            const api = useAudioGeneration();
+            await expect(api.generate({ prompt: 'x' })).rejects.toThrow('Lyria timeout');
+        });
+    });
+    describe('useBackgroundRemoval', () => {
+        it('returns initial state from useState', () => {
+            const { useBackgroundRemoval } = require('./hooks');
+            const api = useBackgroundRemoval();
+            expect(api.isLoading).toBe(false);
+            expect(api.result).toBeNull();
+            expect(api.error).toBeNull();
+            expect(typeof api.removeBackground).toBe('function');
+        });
+        it('removeBackground calls bridge.request with image_remove_background + 120s timeout and returns the result blob', async () => {
+            const { useBackgroundRemoval } = require('./hooks');
+            const cutout = new Blob([new Uint8Array([9])], { type: 'image/png' });
+            mockBridge.request.mockResolvedValue({ image: cutout });
+            const api = useBackgroundRemoval();
+            const input = new Blob([new Uint8Array([1])], { type: 'image/png' });
+            const result = await api.removeBackground(input);
+            expect(mockBridge.request).toHaveBeenCalledWith('image_remove_background', { image: input }, 120000);
+            expect(result).toBe(cutout);
+        });
+        it('rejects inputs over 25 MiB without calling the bridge', async () => {
+            const { useBackgroundRemoval } = require('./hooks');
+            // 25 MiB + 1 byte. Build a backing buffer (cheap — happy-dom Blob
+            // reads `size` from the constructor input length without
+            // materializing the array contents).
+            const oversized = new Blob([new Uint8Array(25 * 1024 * 1024 + 1)], { type: 'image/png' });
+            const api = useBackgroundRemoval();
+            await expect(api.removeBackground(oversized)).rejects.toThrow('25 MiB');
+            expect(mockBridge.request).not.toHaveBeenCalled();
+        });
+        it('rethrows bridge errors and wraps non-Error rejections', async () => {
+            const { useBackgroundRemoval } = require('./hooks');
+            mockBridge.request.mockRejectedValue('rate limit hit');
+            const api = useBackgroundRemoval();
+            await expect(api.removeBackground(new Blob([new Uint8Array([1])], { type: 'image/png' }))).rejects.toThrow('rate limit hit');
+        });
+    });
+    describe('useFiasDataStore', () => {
+        it('createCollection forwards name + default userScope', async () => {
+            const { useFiasDataStore } = require('./hooks');
+            const ds = useFiasDataStore();
+            mockBridge.request.mockResolvedValueOnce({
+                collection: { name: 'scores', userScope: 'user' },
+            });
+            const coll = await ds.createCollection('scores');
+            expect(mockBridge.request).toHaveBeenCalledWith('data_create_collection', {
+                name: 'scores',
+                userScope: 'user',
+            });
+            expect(coll.name).toBe('scores');
+        });
+        it('createCollection honors an explicit userScope=shared', async () => {
+            const { useFiasDataStore } = require('./hooks');
+            const ds = useFiasDataStore();
+            mockBridge.request.mockResolvedValueOnce({
+                collection: { name: 'global', userScope: 'shared' },
+            });
+            await ds.createCollection('global', { userScope: 'shared' });
+            expect(mockBridge.request).toHaveBeenCalledWith('data_create_collection', {
+                name: 'global',
+                userScope: 'shared',
+            });
+        });
+        it('listCollections returns the array unwrapped from the bridge envelope', async () => {
+            const { useFiasDataStore } = require('./hooks');
+            const ds = useFiasDataStore();
+            mockBridge.request.mockResolvedValueOnce({
+                collections: [{ name: 'a' }, { name: 'b' }],
+            });
+            const list = await ds.listCollections();
+            expect(list).toHaveLength(2);
+            expect(mockBridge.request).toHaveBeenCalledWith('data_list_collections', {});
+        });
+        it('deleteCollection forwards the name', async () => {
+            const { useFiasDataStore } = require('./hooks');
+            const ds = useFiasDataStore();
+            mockBridge.request.mockResolvedValueOnce(undefined);
+            await ds.deleteCollection('scores');
+            expect(mockBridge.request).toHaveBeenCalledWith('data_delete_collection', {
+                name: 'scores',
+            });
+        });
+        it('put forwards collection / key / data', async () => {
+            const { useFiasDataStore } = require('./hooks');
+            const ds = useFiasDataStore();
+            mockBridge.request.mockResolvedValueOnce(undefined);
+            await ds.put('scores', 'level-1', { score: 100 });
+            expect(mockBridge.request).toHaveBeenCalledWith('data_put', {
+                collection: 'scores',
+                key: 'level-1',
+                data: { score: 100 },
+            });
+        });
+        it('get unwraps { data } from the bridge envelope', async () => {
+            const { useFiasDataStore } = require('./hooks');
+            const ds = useFiasDataStore();
+            mockBridge.request.mockResolvedValueOnce({ data: { score: 50 } });
+            const result = await ds.get('scores', 'level-1');
+            expect(result).toEqual({ score: 50 });
+        });
+        it('get returns null when the bridge says data is null', async () => {
+            const { useFiasDataStore } = require('./hooks');
+            const ds = useFiasDataStore();
+            mockBridge.request.mockResolvedValueOnce({ data: null });
+            const result = await ds.get('scores', 'missing');
+            expect(result).toBeNull();
+        });
+        it('query forwards collection + options to data_query', async () => {
+            const { useFiasDataStore } = require('./hooks');
+            const ds = useFiasDataStore();
+            mockBridge.request.mockResolvedValueOnce({ documents: [], nextCursor: null });
+            await ds.query('scores', {
+                filters: [{ field: 'score', op: 'gte', value: 50 }],
+                orderBy: { field: 'score', direction: 'desc' },
+                limit: 10,
+            });
+            expect(mockBridge.request).toHaveBeenCalledWith('data_query', {
+                collection: 'scores',
+                filters: [{ field: 'score', op: 'gte', value: 50 }],
+                orderBy: { field: 'score', direction: 'desc' },
+                limit: 10,
+            });
+        });
+        it('delete forwards collection + key', async () => {
+            const { useFiasDataStore } = require('./hooks');
+            const ds = useFiasDataStore();
+            mockBridge.request.mockResolvedValueOnce(undefined);
+            await ds.delete('scores', 'level-1');
+            expect(mockBridge.request).toHaveBeenCalledWith('data_delete', {
+                collection: 'scores',
+                key: 'level-1',
+            });
+        });
+    });
+    describe('useFiasStore', () => {
+        it('fetches products + entitlements on mount and exposes them', async () => {
+            const { useFiasStore } = require('./hooks');
+            const products = [{ productIdentifier: 'gems_100', type: 'consumable', priceCents: 99 }];
+            const entitlements = [{ productIdentifier: 'premium', isActive: true }];
+            mockBridge.request.mockResolvedValueOnce(products).mockResolvedValueOnce(entitlements);
+            const api = useFiasStore();
+            // Effect kicks the two bridge calls.
+            expect(mockBridge.request).toHaveBeenNthCalledWith(1, 'store_get_products', {});
+            expect(mockBridge.request).toHaveBeenNthCalledWith(2, 'store_get_entitlements', {});
+            expect(typeof api.purchase).toBe('function');
+        });
+        it('hasEntitlement checks productIdentifier + isActive', () => {
+            const { useFiasStore } = require('./hooks');
+            // Default mockBridge.request returns {}; we don't need products/ents
+            // populated to test the predicate — the closure is over `entitlements`
+            // from useState. Default state is []; hasEntitlement returns false.
+            const api = useFiasStore();
+            expect(api.hasEntitlement('anything')).toBe(false);
+        });
+        it('purchase posts productIdentifier + options and returns the result', async () => {
+            const { useFiasStore } = require('./hooks');
+            // First two calls satisfy the mount effect.
+            mockBridge.request
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce({ success: true, purchaseId: 'p_1' });
+            const api = useFiasStore();
+            const result = await api.purchase('gems_100');
+            expect(mockBridge.request).toHaveBeenLastCalledWith('store_purchase', {
+                productIdentifier: 'gems_100',
+            });
+            expect(result.purchaseId).toBe('p_1');
+        });
+        it('purchase forwards options.quantity to the bridge', async () => {
+            const { useFiasStore } = require('./hooks');
+            mockBridge.request
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce({ success: true });
+            const api = useFiasStore();
+            await api.purchase('gems_100', { quantity: 3 });
+            expect(mockBridge.request).toHaveBeenLastCalledWith('store_purchase', {
+                productIdentifier: 'gems_100',
+                quantity: 3,
+            });
+        });
+        it('getPurchaseHistory unwraps { purchases }', async () => {
+            const { useFiasStore } = require('./hooks');
+            mockBridge.request
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce({ purchases: [{ purchaseId: 'p_1' }] });
+            const api = useFiasStore();
+            const history = await api.getPurchaseHistory();
+            expect(history).toHaveLength(1);
+            expect(mockBridge.request).toHaveBeenLastCalledWith('store_get_purchase_history', {});
+        });
+        it('restorePurchases returns the restored entitlements array directly', async () => {
+            const { useFiasStore } = require('./hooks');
+            mockBridge.request
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce([{ productIdentifier: 'premium', isActive: true }]);
+            const api = useFiasStore();
+            const restored = await api.restorePurchases();
+            expect(restored).toHaveLength(1);
+            expect(mockBridge.request).toHaveBeenLastCalledWith('store_restore', {});
+        });
+        it('swallows a mount-time bridge rejection and clears isLoading', async () => {
+            const { useFiasStore } = require('./hooks');
+            mockBridge.request.mockRejectedValue(new Error('network down'));
+            useFiasStore();
+            // Effect rejection is caught — no uncaught promise here. The test
+            // passes if no unhandled rejection is emitted by the test runner.
+            await new Promise((r) => setTimeout(r, 0));
+        });
+    });
+    describe('useFiasNavigation', () => {
+        it('seeds currentPath from bridge.getCurrentPath() and subscribes to updates', () => {
+            mockBridge.getCurrentPath.mockReturnValue('/home');
+            const { useFiasNavigation } = require('./hooks');
+            const api = useFiasNavigation();
+            expect(api.currentPath).toBe('/home');
+            expect(mockBridge.onNavigationUpdate).toHaveBeenCalled();
+        });
+        it('navigateTo dispatches a `navigate` bridge request with the path', async () => {
+            const { useFiasNavigation } = require('./hooks');
+            mockBridge.request.mockResolvedValue(undefined);
+            const api = useFiasNavigation();
+            api.navigateTo('/profile');
+            expect(mockBridge.request).toHaveBeenCalledWith('navigate', { path: '/profile' });
+        });
+        it('cleanup unsubscribes from navigation updates', () => {
+            const unsubscribe = jest.fn();
+            mockBridge.onNavigationUpdate.mockReturnValue(unsubscribe);
+            const { useFiasNavigation } = require('./hooks');
+            useFiasNavigation();
+            // capturedEffectCleanup is set inside the mocked useEffect; trigger it.
+            capturedEffectCleanup?.();
+            expect(unsubscribe).toHaveBeenCalled();
+        });
+    });
+    describe('usePersistentState', () => {
+        it('reads from storage on mount and applies the parsed value', async () => {
+            mockBridge.request.mockResolvedValue({
+                content: JSON.stringify({ score: 50 }),
+                exists: true,
+            });
+            const { usePersistentState } = require('./hooks');
+            const [value, setValue] = usePersistentState('game-state', { score: 0 });
+            expect(value).toEqual({ score: 0 }); // initial (useState returns initial)
+            expect(mockBridge.request).toHaveBeenCalledWith('storage_read', {
+                path: '__state/game-state',
+            });
+            // setValue is exposed regardless of load completion.
+            expect(typeof setValue).toBe('function');
+        });
+        it('tolerates a corrupted JSON read and keeps initial value', async () => {
+            mockBridge.request.mockResolvedValue({
+                content: 'not-valid-json{',
+                exists: true,
+            });
+            const { usePersistentState } = require('./hooks');
+            const [value] = usePersistentState('x', { count: 1 });
+            // initial state from useState (the mocked react.useState returns
+            // the initial value directly).
+            expect(value).toEqual({ count: 1 });
+            await new Promise((r) => setTimeout(r, 0));
+        });
+        it('setValue with a function variant resolves prev from valueRef', () => {
+            mockBridge.request.mockResolvedValue({ content: null, exists: false });
+            const { usePersistentState } = require('./hooks');
+            const [, setValue] = usePersistentState('counter', 0);
+            // Calling setValue with a function should not throw and should
+            // schedule a debounced write. The mocked react.useState's setter
+            // doesn't actually mutate, but the writer.schedule call path runs.
+            setValue((prev) => prev + 5);
+            // No bridge.request call yet — schedule is debounced via setTimeout.
+        });
+    });
+    describe('useStepNavigation', () => {
+        it('returns initial step from the argument', () => {
+            const { useStepNavigation } = require('./hooks');
+            const api = useStepNavigation('step-1');
+            expect(api.currentStep).toBe('step-1');
+            expect(mockBridge.onStepNavigationUpdate).toHaveBeenCalled();
+        });
+        it('defaults currentStep to null when no initial step is given', () => {
+            const { useStepNavigation } = require('./hooks');
+            const api = useStepNavigation();
+            expect(api.currentStep).toBeNull();
+        });
+        it('with persistKey, reads __state/<key> on mount', async () => {
+            mockBridge.request.mockResolvedValue({
+                content: JSON.stringify('step-2'),
+                exists: true,
+            });
+            const { useStepNavigation } = require('./hooks');
+            useStepNavigation(undefined, { persistKey: 'wizard' });
+            expect(mockBridge.request).toHaveBeenCalledWith('storage_read', {
+                path: '__state/wizard',
+            });
+        });
+        it('setCurrentStep updates state and schedules a persistent write when persistKey is set', () => {
+            const { useStepNavigation } = require('./hooks');
+            const api = useStepNavigation(undefined, { persistKey: 'wizard' });
+            api.setCurrentStep('step-3');
+            // No throw — the writer is scheduled internally.
+        });
+        it('setCurrentStep without persistKey does not schedule writes', () => {
+            const { useStepNavigation } = require('./hooks');
+            const api = useStepNavigation('step-a');
+            api.setCurrentStep('step-b');
+        });
+    });
+    describe('useArcheAssets', () => {
+        it('list forwards to arche_assets_list with the cursor/limit options', async () => {
+            const { useArcheAssets } = require('./hooks');
+            mockBridge.request.mockResolvedValueOnce({ entries: [], nextCursor: null });
+            const api = useArcheAssets();
+            await api.list({ limit: 25, cursor: '50' });
+            expect(mockBridge.request).toHaveBeenCalledWith('arche_assets_list', {
+                cursor: '50',
+                limit: 25,
+            });
+        });
+        it('getUrl posts assetId to arche_assets_get_url', async () => {
+            const { useArcheAssets } = require('./hooks');
+            mockBridge.request.mockResolvedValueOnce({
+                assetId: 'aset_1',
+                signedUrl: 'https://x',
+                expiresAt: 1700000000000,
+            });
+            const api = useArcheAssets();
+            const asset = await api.getUrl('aset_1');
+            expect(mockBridge.request).toHaveBeenCalledWith('arche_assets_get_url', {
+                assetId: 'aset_1',
+            });
+            expect(asset.assetId).toBe('aset_1');
+        });
+    });
 });
 //# sourceMappingURL=hooks.test.js.map