@rozenite/storage-plugin 2.0.0 → 2.1.0

package/src/shared/messaging.ts

@@ -1,9 +1,4 @@
-import type {
-  StorageDescriptor,
-  StorageEntry,
-  StorageEntryPreview,
-  StorageTarget,
-} from './types';
+import type { StorageDescriptor, StorageEntry, StorageEntryPreview, StorageTarget } from './types';
 import type { ImportPreview, StorageSnapshotV1 } from './snapshot';
 
 export type StorageSetEntryEvent = {
@@ -23,11 +18,7 @@ export type StoragePurgeEvent = {
   target: StorageTarget;
 };
 
-export type StorageInvalidationOperation =
-  | 'set'
-  | 'delete'
-  | 'import'
-  | 'purge';
+export type StorageInvalidationOperation = 'set' | 'delete' | 'import' | 'purge';
 
 export type StorageInvalidatedEvent = {
   type: 'storage-invalidated';
@@ -35,6 +26,18 @@ export type StorageInvalidatedEvent = {
   /** Native subscriptions only expose a key, not the operation. */
   key?: string;
   operation?: StorageInvalidationOperation;
+  /** Updated entry count for the storage after the invalidation. */
+  entryCount: number;
+};
+
+/**
+ * Announced by the device once it is listening for panel requests. The panel is
+ * recreated on every app reload and asks for storages immediately, which can
+ * land before the app's React tree has mounted the plugin; this lets the panel
+ * ask again instead of waiting forever on a dropped request.
+ */
+export type StorageDeviceReadyEvent = {
+  type: 'device-ready';
 };
 
 export type StorageDiscoverStoragesRequestEvent = {
@@ -156,6 +159,7 @@ export type StorageEvent =
   | StorageDeleteEntryEvent
   | StoragePurgeEvent
   | StorageInvalidatedEvent
+  | StorageDeviceReadyEvent
   | StorageDiscoverStoragesRequestEvent
   | StorageDiscoverStoragesResponseEvent
   | StorageListEntryPreviewsRequestEvent

package/src/shared/snapshot.ts

@@ -48,10 +48,7 @@ const describe = (value: unknown): string => {
 const isPlainObject = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value);
 
-const expectObject = (
-  value: unknown,
-  path: string,
-): Record<string, unknown> => {
+const expectObject = (value: unknown, path: string): Record<string, unknown> => {
   if (!isPlainObject(value)) {
     throw new ParseException(path, `Expected object, got ${describe(value)}`);
   }
@@ -73,10 +70,7 @@ const expectArray = (value: unknown, path: string): unknown[] => {
 };
 
 const expectEntryType = (value: unknown, path: string): StorageEntryType => {
-  if (
-    typeof value !== 'string' ||
-    !DEFAULT_SUPPORTED_TYPES.includes(value as StorageEntryType)
-  ) {
+  if (typeof value !== 'string' || !DEFAULT_SUPPORTED_TYPES.includes(value as StorageEntryType)) {
     throw new ParseException(
       path,
       `Expected one of ${DEFAULT_SUPPORTED_TYPES.join(', ')}, got ${describe(value)}`,
@@ -151,12 +145,7 @@ const parseEntry = (raw: unknown, path: string): StorageEntry => {
         );
       }
       const bytes = value.map((byte, index) => {
-        if (
-          typeof byte !== 'number' ||
-          !Number.isInteger(byte) ||
-          byte < 0 ||
-          byte > 255
-        ) {
+        if (typeof byte !== 'number' || !Number.isInteger(byte) || byte < 0 || byte > 255) {
           throw new ParseException(
             `${valuePath}[${index}]`,
             `Expected uint8 (integer 0-255), got ${describe(byte)}`,
@@ -183,9 +172,7 @@ export const parseSnapshot = (raw: unknown): ParseResult => {
     const createdAt = expectString(root.createdAt, 'createdAt');
     const storage = parseStorageMeta(root.storage);
     const rawEntries = expectArray(root.entries, 'entries');
-    const entries = rawEntries.map((entry, index) =>
-      parseEntry(entry, `entries[${index}]`),
-    );
+    const entries = rawEntries.map((entry, index) => parseEntry(entry, `entries[${index}]`));
     return {
       ok: true,
       snapshot: {

package/src/shared/types.ts

@@ -80,7 +80,5 @@ export const DEFAULT_SUPPORTED_TYPES: StorageEntryType[] = [
 export const getStorageViewId = ({ adapterId, storageId }: StorageTarget) =>
   `${adapterId}:${storageId}`;
 
-export const supportsType = (
-  capabilities: StorageCapabilities,
-  type: StorageEntryType,
-) => capabilities.supportedTypes.includes(type);
+export const supportsType = (capabilities: StorageCapabilities, type: StorageEntryType) =>
+  capabilities.supportedTypes.includes(type);

package/src/ui/__tests__/binary-value-editor-state.test.ts

@@ -1,10 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import {
-  initialState,
-  reduce,
-  validate,
-  type EditorState,
-} from '../binary-value-editor-state';
+import { initialState, reduce, validate, type EditorState } from '../binary-value-editor-state';
 
 const hexState = (bytes?: number[]): EditorState =>
   initialState({ initialBytes: bytes, mode: 'hex' });
@@ -29,9 +24,7 @@ describe('initialState', () => {
   });
 
   it('encodes initial bytes as base64 when mode is base64', () => {
-    expect(
-      initialState({ initialBytes: [0x48, 0x69], mode: 'base64' }),
-    ).toEqual({
+    expect(initialState({ initialBytes: [0x48, 0x69], mode: 'base64' })).toEqual({
       mode: 'base64',
       text: 'SGk=',
       bytes: [0x48, 0x69],
@@ -101,13 +94,12 @@ describe('reduce: set-text', () => {
 
 describe('reduce: normalize-paste', () => {
   it('rewrites pasted hexdump into canonical grouped hex', () => {
-    const pasted =
-      '00000000  89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52  |.PNG........IHDR|';
+    const pasted = '00000000  89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52  |.PNG........IHDR|';
     const next = reduce(hexState(), { type: 'normalize-paste', text: pasted });
     expect(next.text).toBe('89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52');
     expect(next.bytes).toEqual([
-      0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
-      0x49, 0x48, 0x44, 0x52,
+      0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44,
+      0x52,
     ]);
     expect(next.error).toBeNull();
   });
@@ -178,9 +170,7 @@ describe('reduce: switch-mode', () => {
 
 describe('reduce: replace-bytes', () => {
   it('formats fetched bytes after the editor has had a chance to paint', () => {
-    expect(
-      reduce(hexState(), { type: 'replace-bytes', bytes: [0x48, 0x69] }),
-    ).toEqual({
+    expect(reduce(hexState(), { type: 'replace-bytes', bytes: [0x48, 0x69] })).toEqual({
       mode: 'hex',
       text: '48 69',
       bytes: [0x48, 0x69],

package/src/ui/__tests__/binary.test.ts

@@ -26,8 +26,8 @@ describe('bytesToGroupedHex', () => {
   it('inserts a double-space gap between bytes 8 and 9', () => {
     expect(
       bytesToGroupedHex([
-        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
-        0x49, 0x48, 0x44, 0x52,
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44,
+        0x52,
       ]),
     ).toBe('89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52');
   });
@@ -44,17 +44,7 @@ describe('bytesToGroupedHex', () => {
 
 describe('bytesToHexdump', () => {
   it('renders offset, grouped hex, and ASCII column', () => {
-    const bytes = [
-      ...PNG_SIGNATURE,
-      0x00,
-      0x00,
-      0x00,
-      0x0d,
-      0x49,
-      0x48,
-      0x44,
-      0x52,
-    ];
+    const bytes = [...PNG_SIGNATURE, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52];
     expect(bytesToHexdump(bytes)).toBe(
       '00000000  89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52  |.PNG........IHDR|',
     );
@@ -71,9 +61,7 @@ describe('bytesToHexdump', () => {
     const bytes = [0x41, 0x42, 0x43];
     const line = bytesToHexdump(bytes);
     // Hex section width must be exactly 48 chars before the "  |..." block.
-    expect(line).toBe(
-      '00000000  41 42 43                                          |ABC|',
-    );
+    expect(line).toBe('00000000  41 42 43                                          |ABC|');
   });
 
   it('renders non-printable bytes as dots in the ASCII column', () => {
@@ -159,21 +147,15 @@ describe('compactBufferPreview', () => {
   });
 
   it('omits the ellipsis when the buffer fits within maxBytes', () => {
-    expect(compactBufferPreview([0x89, 0x50, 0x4e, 0x47])).toBe(
-      '89 50 4E 47 4 B',
-    );
+    expect(compactBufferPreview([0x89, 0x50, 0x4e, 0x47])).toBe('89 50 4E 47 4 B');
   });
 
   it('includes an ellipsis when truncated', () => {
-    expect(compactBufferPreview(new Array(128).fill(0xab))).toBe(
-      'AB AB AB AB AB AB AB AB … 128 B',
-    );
+    expect(compactBufferPreview(new Array(128).fill(0xab))).toBe('AB AB AB AB AB AB AB AB … 128 B');
   });
 
   it('respects a custom maxBytes', () => {
-    expect(compactBufferPreview([0x01, 0x02, 0x03], { maxBytes: 2 })).toBe(
-      '01 02 … 3 B',
-    );
+    expect(compactBufferPreview([0x01, 0x02, 0x03], { maxBytes: 2 })).toBe('01 02 … 3 B');
   });
 });
 
@@ -194,14 +176,12 @@ describe('hexInputToBytes', () => {
 
   it('parses multiline grouped hex', () => {
     expect(
-      hexInputToBytes(
-        '89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52\n00 00 00 20 00 00 00 20',
-      ),
+      hexInputToBytes('89 50 4E 47 0D 0A 1A 0A  00 00 00 0D 49 48 44 52\n00 00 00 20 00 00 00 20'),
     ).toEqual({
       ok: true,
       value: [
-        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
-        0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44,
+        0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
       ],
     });
   });
@@ -214,9 +194,9 @@ describe('hexInputToBytes', () => {
     expect(hexInputToBytes(pasted)).toEqual({
       ok: true,
       value: [
-        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
-        0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20,
-        0x08, 0x06, 0x00, 0x00, 0x00, 0x73, 0x7a, 0x7a,
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44,
+        0x52, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x08, 0x06, 0x00, 0x00, 0x00, 0x73,
+        0x7a, 0x7a,
       ],
     });
   });

package/src/ui/__tests__/large-value-viewer.test.tsx

@@ -2,10 +2,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { cleanup, render, screen } from '@testing-library/react';
 import '@testing-library/jest-dom/vitest';
-import {
-  TEXT_CHUNK_SIZE,
-  VIRTUALIZED_TEXT_THRESHOLD,
-} from '../large-value-viewer-state';
+import { TEXT_CHUNK_SIZE, VIRTUALIZED_TEXT_THRESHOLD } from '../large-value-viewer-state';
 
 vi.mock('react-virtuoso', async () => {
   const React = await import('react');
@@ -31,9 +28,7 @@ describe('large value viewers', () => {
     const { container } = render(<TextValueViewer value={value} />);
 
     expect(screen.getByTestId('virtuoso')).toBeInTheDocument();
-    expect(
-      container.querySelectorAll('[data-testid="virtuoso"] > div'),
-    ).toHaveLength(4);
+    expect(container.querySelectorAll('[data-testid="virtuoso"] > div')).toHaveLength(4);
     expect(container.textContent).toHaveLength(TEXT_CHUNK_SIZE * 4 + 1);
     expect(container.textContent).not.toBe(value);
   });
@@ -43,18 +38,14 @@ describe('large value viewers', () => {
     const { container } = render(<HexdumpValueViewer bytes={bytes} />);
 
     expect(screen.getByTestId('virtuoso')).toBeInTheDocument();
-    expect(
-      container.querySelectorAll('[data-testid="virtuoso"] > div'),
-    ).toHaveLength(4);
+    expect(container.querySelectorAll('[data-testid="virtuoso"] > div')).toHaveLength(4);
     expect(container.textContent).toContain('00000000');
     expect(container.textContent).not.toContain('00003e70');
   });
 
   it('drops virtualized value markup when its detail interaction closes', () => {
     const { container, unmount } = render(
-      <TextValueViewer
-        value={'x'.repeat(VIRTUALIZED_TEXT_THRESHOLD + TEXT_CHUNK_SIZE)}
-      />,
+      <TextValueViewer value={'x'.repeat(VIRTUALIZED_TEXT_THRESHOLD + TEXT_CHUNK_SIZE)} />,
     );
 
     unmount();

package/src/ui/__tests__/panel.test.tsx

@@ -24,9 +24,7 @@ const mocks = vi.hoisted(() => {
   });
   return {
     client: { send, onMessage, request },
-    searchChange: undefined as
-      | ((event: React.ChangeEvent<HTMLInputElement>) => void)
-      | undefined,
+    searchChange: undefined as ((event: React.ChangeEvent<HTMLInputElement>) => void) | undefined,
     sortKey: undefined as (() => void) | undefined,
     emit: (type: keyof StorageEventMap, payload: unknown) =>
       listeners.get(type)?.forEach((listener) => listener(payload)),
@@ -46,9 +44,7 @@ vi.mock('@rozenite/plugin-bridge', () => ({
 }));
 vi.mock('@rozenite/ui', async () => {
   const React = await import('react');
-  const PassThrough = ({ children }: { children?: ReactNode }) => (
-    <>{children}</>
-  );
+  const PassThrough = ({ children }: { children?: ReactNode }) => <>{children}</>;
   const PluginShell = Object.assign(PassThrough, { Body: PassThrough });
   const Split = Object.assign(PassThrough, {
     Pane: PassThrough,
@@ -87,25 +83,16 @@ vi.mock('@rozenite/ui', async () => {
       'aria-label'?: string;
       title?: string;
     }) => (
-      <button
-        onClick={onClick}
-        disabled={disabled}
-        aria-label={ariaLabel}
-        title={title}
-      >
+      <button onClick={onClick} disabled={disabled} aria-label={ariaLabel} title={title}>
         {children}
       </button>
     ),
   });
   return {
     Badge: PassThrough,
-    Button: ({
-      children,
-      onClick,
-    }: {
-      children?: ReactNode;
-      onClick?: () => void;
-    }) => <button onClick={onClick}>{children}</button>,
+    Button: ({ children, onClick }: { children?: ReactNode; onClick?: () => void }) => (
+      <button onClick={onClick}>{children}</button>
+    ),
     ConfirmDialog: () => null,
     EmptyState: () => <div />,
     PluginShell,
@@ -131,9 +118,7 @@ vi.mock('@rozenite/ui', async () => {
       data: { key: string }[];
       onEndReached?: () => void;
       onRowClick?: (entry: { key: string }) => void;
-      onSortingChange?: (
-        updater: (current: SortingItem[]) => SortingItem[],
-      ) => void;
+      onSortingChange?: (updater: (current: SortingItem[]) => SortingItem[]) => void;
     }) => {
       mocks.sortKey = () => {
         onSortingChange?.((current) => {
@@ -201,10 +186,10 @@ const renderPanel = async () => {
   await act(async () => root.render(<StoragePanel />));
   return { root, container };
 };
+const discoveryRequests = () =>
+  mocks.client.send.mock.calls.filter(([type]) => type === 'discover-storages');
 const discover = async () => {
-  const request = mocks.client.send.mock.calls.find(
-    ([type]) => type === 'discover-storages',
-  )?.[1];
+  const request = discoveryRequests().at(-1)?.[1];
   await act(async () =>
     mocks.emit('storage-descriptors', {
       type: 'storage-descriptors',
@@ -219,11 +204,7 @@ describe('StoragePanel preview query cutover', () => {
     mocks.reset();
     globalThis.IS_REACT_ACT_ENVIRONMENT = true;
     mocks.client.request.mockImplementation(
-      ({
-        payload,
-      }: {
-        payload: { type: string; cursor?: string; key?: string };
-      }) => {
+      ({ payload }: { payload: { type: string; cursor?: string; key?: string } }) => {
         if (payload.type === 'list-entry-previews')
           return Promise.resolve(previewResponse(payload.cursor));
         if (payload.type === 'get-entry')
@@ -253,9 +234,7 @@ describe('StoragePanel preview query cutover', () => {
     await discover();
     expect(container.textContent).toContain('1');
     await act(async () => {
-      await vi.waitFor(() =>
-        expect(mocks.client.request).toHaveBeenCalledTimes(1),
-      );
+      await vi.waitFor(() => expect(mocks.client.request).toHaveBeenCalledTimes(1));
       await vi.waitFor(() =>
         expect(
           Array.from(container.querySelectorAll('button')).some(
@@ -271,14 +250,11 @@ describe('StoragePanel preview query cutover', () => {
       edge?.click();
       edge?.click();
     });
-    await vi.waitFor(() =>
-      expect(mocks.client.request).toHaveBeenCalledTimes(2),
-    );
-    expect(
-      mocks.client.request.mock.calls.map(
-        ([options]) => options.payload.cursor,
-      ),
-    ).toEqual([undefined, 'next']);
+    await vi.waitFor(() => expect(mocks.client.request).toHaveBeenCalledTimes(2));
+    expect(mocks.client.request.mock.calls.map(([options]) => options.payload.cursor)).toEqual([
+      undefined,
+      'next',
+    ]);
     await act(async () => root.unmount());
   });
 
@@ -295,9 +271,7 @@ describe('StoragePanel preview query cutover', () => {
       } as React.ChangeEvent<HTMLInputElement>);
       vi.advanceTimersByTime(250);
     });
-    await vi.waitFor(() =>
-      expect(mocks.client.request).toHaveBeenCalledTimes(2),
-    );
+    await vi.waitFor(() => expect(mocks.client.request).toHaveBeenCalledTimes(2));
     expect(mocks.client.request.mock.calls[1][0].payload).toMatchObject({
       cursor: undefined,
       search: 'needle',
@@ -317,25 +291,19 @@ describe('StoragePanel preview query cutover', () => {
     };
 
     await act(async () => sortKey());
-    await vi.waitFor(() =>
-      expect(mocks.client.request).toHaveBeenCalledTimes(2),
-    );
+    await vi.waitFor(() => expect(mocks.client.request).toHaveBeenCalledTimes(2));
     expect(mocks.client.request.mock.calls[1][0].payload).toMatchObject({
       keySortDirection: 'descending',
     });
 
     await act(async () => sortKey());
-    await vi.waitFor(() =>
-      expect(mocks.client.request).toHaveBeenCalledTimes(3),
-    );
+    await vi.waitFor(() => expect(mocks.client.request).toHaveBeenCalledTimes(3));
     expect(mocks.client.request.mock.calls[2][0].payload).toMatchObject({
       keySortDirection: 'ascending',
     });
 
     await act(async () => sortKey());
-    await vi.waitFor(() =>
-      expect(mocks.client.request).toHaveBeenCalledTimes(4),
-    );
+    await vi.waitFor(() => expect(mocks.client.request).toHaveBeenCalledTimes(4));
     expect(mocks.client.request.mock.calls[3][0].payload).toMatchObject({
       keySortDirection: 'descending',
     });
@@ -368,17 +336,11 @@ describe('StoragePanel preview query cutover', () => {
     });
     await act(async () =>
       Array.from(container.querySelectorAll('button'))
-        .find(
-          (button) => button.getAttribute('aria-label') === 'Refresh storage',
-        )
+        .find((button) => button.getAttribute('aria-label') === 'Refresh storage')
         ?.click(),
     );
-    await vi.waitFor(() =>
-      expect(mocks.client.request).toHaveBeenCalledTimes(2),
-    );
-    expect(
-      mocks.client.request.mock.calls[1][0].payload.cursor,
-    ).toBeUndefined();
+    await vi.waitFor(() => expect(mocks.client.request).toHaveBeenCalledTimes(2));
+    expect(mocks.client.request.mock.calls[1][0].payload.cursor).toBeUndefined();
     await act(async () => root.unmount());
   });
 
@@ -386,9 +348,7 @@ describe('StoragePanel preview query cutover', () => {
     const { root } = await renderPanel();
     await discover();
     await act(async () => {
-      await vi.waitFor(() =>
-        expect(mocks.client.request).toHaveBeenCalledTimes(1),
-      );
+      await vi.waitFor(() => expect(mocks.client.request).toHaveBeenCalledTimes(1));
       mocks.emit('storage-invalidated', {
         type: 'storage-invalidated',
         target,
@@ -401,9 +361,22 @@ describe('StoragePanel preview query cutover', () => {
         key: 'next',
       });
     });
-    await vi.waitFor(() =>
-      expect(mocks.client.request).toHaveBeenCalledTimes(2),
-    );
+    await vi.waitFor(() => expect(mocks.client.request).toHaveBeenCalledTimes(2));
+    await act(async () => root.unmount());
+  });
+
+  // The panel is recreated on every app reload and asks for storages before the
+  // app's React tree has mounted the plugin, so its first request is dropped.
+  it('runs discovery again when the device announces itself', async () => {
+    const { root, container } = await renderPanel();
+    expect(discoveryRequests()).toHaveLength(1);
+    expect(container.textContent).toContain('Waiting for storages');
+
+    await act(async () => mocks.emit('device-ready', { type: 'device-ready' }));
+    expect(discoveryRequests()).toHaveLength(2);
+    await discover();
+
+    expect(container.textContent).toContain('First');
     await act(async () => root.unmount());
   });
 });

package/src/ui/__tests__/storage-groups.test.ts

@@ -23,10 +23,7 @@ describe('buildStorageSidebarGroups', () => {
     const snapshots = new Map([
       ['mmkv:default', entry('mmkv', 'default', 'MMKV', 'default', 3)],
       ['mmkv:user', entry('mmkv', 'user', 'MMKV', 'user', 1)],
-      [
-        'async-storage:default',
-        entry('async-storage', 'default', 'AsyncStorage', 'default', 5),
-      ],
+      ['async-storage:default', entry('async-storage', 'default', 'AsyncStorage', 'default', 5)],
     ]);
 
     expect(buildStorageSidebarGroups(snapshots)).toEqual([

package/src/ui/__tests__/type-conversion.test.ts

@@ -25,13 +25,9 @@ describe('convertValue', () => {
     });
 
     it('UTF-8 encodes a string to a byte array', () => {
-      expect(convertValue('string', 'buffer', 'hello')).toEqual([
-        0x68, 0x65, 0x6c, 0x6c, 0x6f,
-      ]);
+      expect(convertValue('string', 'buffer', 'hello')).toEqual([0x68, 0x65, 0x6c, 0x6c, 0x6f]);
       // 'é' is two bytes in UTF-8: 0xC3 0xA9.
-      expect(convertValue('string', 'buffer', 'café')).toEqual([
-        0x63, 0x61, 0x66, 0xc3, 0xa9,
-      ]);
+      expect(convertValue('string', 'buffer', 'café')).toEqual([0x63, 0x61, 0x66, 0xc3, 0xa9]);
       expect(convertValue('string', 'buffer', '')).toEqual([]);
     });
   });
@@ -66,20 +62,14 @@ describe('convertValue', () => {
     });
 
     it('encodes the literal "true" / "false" bytes for buffer conversion', () => {
-      expect(convertValue('boolean', 'buffer', true)).toEqual([
-        0x74, 0x72, 0x75, 0x65,
-      ]);
-      expect(convertValue('boolean', 'buffer', false)).toEqual([
-        0x66, 0x61, 0x6c, 0x73, 0x65,
-      ]);
+      expect(convertValue('boolean', 'buffer', true)).toEqual([0x74, 0x72, 0x75, 0x65]);
+      expect(convertValue('boolean', 'buffer', false)).toEqual([0x66, 0x61, 0x6c, 0x73, 0x65]);
     });
   });
 
   describe('from buffer', () => {
     it('UTF-8 decodes bytes back to a string (the headline round-trip)', () => {
-      expect(
-        convertValue('buffer', 'string', [0x68, 0x65, 0x6c, 0x6c, 0x6f]),
-      ).toBe('hello');
+      expect(convertValue('buffer', 'string', [0x68, 0x65, 0x6c, 0x6c, 0x6f])).toBe('hello');
     });
 
     it('returns an empty string when bytes are not valid UTF-8', () => {
@@ -88,19 +78,13 @@ describe('convertValue', () => {
 
     it('decodes then parses to number, falls back to 0 on failure', () => {
       expect(convertValue('buffer', 'number', [0x34, 0x32])).toBe(42); // "42"
-      expect(
-        convertValue('buffer', 'number', [0x68, 0x65, 0x6c, 0x6c, 0x6f]),
-      ).toBe(0); // "hello" → NaN → 0
+      expect(convertValue('buffer', 'number', [0x68, 0x65, 0x6c, 0x6c, 0x6f])).toBe(0); // "hello" → NaN → 0
       expect(convertValue('buffer', 'number', [0xff])).toBe(0); // invalid UTF-8 → 0
     });
 
     it('decodes then matches "true" for boolean conversion', () => {
-      expect(convertValue('buffer', 'boolean', [0x74, 0x72, 0x75, 0x65])).toBe(
-        true,
-      );
-      expect(
-        convertValue('buffer', 'boolean', [0x66, 0x61, 0x6c, 0x73, 0x65]),
-      ).toBe(false);
+      expect(convertValue('buffer', 'boolean', [0x74, 0x72, 0x75, 0x65])).toBe(true);
+      expect(convertValue('buffer', 'boolean', [0x66, 0x61, 0x6c, 0x73, 0x65])).toBe(false);
       expect(convertValue('buffer', 'boolean', [0xff])).toBe(false);
     });
   });