@rozenite/storage-plugin 2.0.0 → 2.2.0

package/src/react-native/useRozeniteStoragePlugin.ts

@@ -26,9 +26,7 @@ export type RozeniteStoragePluginOptions = {
   storages: StorageAdapter[];
 };
 
-export const useRozeniteStoragePlugin = ({
-  storages,
-}: RozeniteStoragePluginOptions) => {
+export const useRozeniteStoragePlugin = ({ storages }: RozeniteStoragePluginOptions) => {
   const views = useMemo(() => createStorageViews(storages), [storages]);
 
   useStorageAgentTools(views);
@@ -45,16 +43,23 @@ export const useRozeniteStoragePlugin = ({
     const viewSubscriptions: { remove: () => void }[] = [];
     let disposed = false;
 
-    const sendInvalidation = (
+    const sendInvalidation = async (
       target: StorageSetEntryEvent['target'],
       key?: string,
       operation?: StorageInvalidationOperation,
     ) => {
+      const view = views.find(
+        (candidate) =>
+          candidate.target.adapterId === target.adapterId &&
+          candidate.target.storageId === target.storageId,
+      );
+      const entryCount = view ? (await view.getAllKeys()).length : 0;
       client.send('storage-invalidated', {
         type: 'storage-invalidated',
         target,
         key,
         operation,
+        entryCount,
       });
     };
 
@@ -70,7 +75,7 @@ export const useRozeniteStoragePlugin = ({
             }
 
             const subscription = await watch((key) => {
-              sendInvalidation(view.target, key);
+              void sendInvalidation(view.target, key);
             });
 
             if (disposed) {
@@ -89,94 +94,82 @@ export const useRozeniteStoragePlugin = ({
     );
 
     const messageSubscriptions = [
-      client.onMessage(
-        'set-entry',
-        async ({ target, entry }: StorageSetEntryEvent) => {
-          const view = views.find(
-            (candidate) =>
-              candidate.target.adapterId === target.adapterId &&
-              candidate.target.storageId === target.storageId,
+      client.onMessage('set-entry', async ({ target, entry }: StorageSetEntryEvent) => {
+        const view = views.find(
+          (candidate) =>
+            candidate.target.adapterId === target.adapterId &&
+            candidate.target.storageId === target.storageId,
+        );
+
+        if (!view) {
+          console.warn(
+            `[Rozenite] Storage Plugin: Storage target not found for ${target.adapterId}/${target.storageId}`,
           );
-
-          if (!view) {
-            console.warn(
-              `[Rozenite] Storage Plugin: Storage target not found for ${target.adapterId}/${target.storageId}`,
-            );
-            return;
-          }
-
-          try {
-            await view.set(entry);
-            sendInvalidation(view.target, entry.key, 'set');
-          } catch (error) {
-            console.warn(
-              `[Rozenite] Storage Plugin: Failed to set entry in ${target.adapterId}/${target.storageId}.`,
-              error,
-            );
-          }
-        },
-      ),
-      client.onMessage(
-        'delete-entry',
-        async ({ target, key }: StorageDeleteEntryEvent) => {
-          const view = views.find(
-            (candidate) =>
-              candidate.target.adapterId === target.adapterId &&
-              candidate.target.storageId === target.storageId,
+          return;
+        }
+
+        try {
+          await view.set(entry);
+          await sendInvalidation(view.target, entry.key, 'set');
+        } catch (error) {
+          console.warn(
+            `[Rozenite] Storage Plugin: Failed to set entry in ${target.adapterId}/${target.storageId}.`,
+            error,
           );
-
-          if (!view) {
-            console.warn(
-              `[Rozenite] Storage Plugin: Storage target not found for ${target.adapterId}/${target.storageId}`,
-            );
-            return;
-          }
-
-          try {
-            await view.delete(key);
-            sendInvalidation(view.target, key, 'delete');
-          } catch (error) {
-            console.warn(
-              `[Rozenite] Storage Plugin: Failed to delete entry in ${target.adapterId}/${target.storageId}.`,
-              error,
-            );
-          }
-        },
-      ),
-      client.onMessage(
-        'purge-storage',
-        async ({ target }: StoragePurgeEvent) => {
-          const view = views.find(
-            (candidate) =>
-              candidate.target.adapterId === target.adapterId &&
-              candidate.target.storageId === target.storageId,
+        }
+      }),
+      client.onMessage('delete-entry', async ({ target, key }: StorageDeleteEntryEvent) => {
+        const view = views.find(
+          (candidate) =>
+            candidate.target.adapterId === target.adapterId &&
+            candidate.target.storageId === target.storageId,
+        );
+
+        if (!view) {
+          console.warn(
+            `[Rozenite] Storage Plugin: Storage target not found for ${target.adapterId}/${target.storageId}`,
           );
-
-          if (!view) {
-            console.warn(
-              `[Rozenite] Storage Plugin: Storage target not found for ${target.adapterId}/${target.storageId}`,
-            );
-            return;
-          }
-
-          try {
-            await view.purge();
-            sendInvalidation(view.target, undefined, 'purge');
-          } catch (error) {
-            console.warn(
-              `[Rozenite] Storage Plugin: Failed to purge storage in ${target.adapterId}/${target.storageId}.`,
-              error,
-            );
-          }
-        },
-      ),
-      client.onMessage(
-        'discover-storages',
-        async (event: StorageDiscoverStoragesRequestEvent) => {
-          const response = await handleStorageDiscoveryRequest(views, event);
-          client.send(response.type, response);
-        },
-      ),
+          return;
+        }
+
+        try {
+          await view.delete(key);
+          await sendInvalidation(view.target, key, 'delete');
+        } catch (error) {
+          console.warn(
+            `[Rozenite] Storage Plugin: Failed to delete entry in ${target.adapterId}/${target.storageId}.`,
+            error,
+          );
+        }
+      }),
+      client.onMessage('purge-storage', async ({ target }: StoragePurgeEvent) => {
+        const view = views.find(
+          (candidate) =>
+            candidate.target.adapterId === target.adapterId &&
+            candidate.target.storageId === target.storageId,
+        );
+
+        if (!view) {
+          console.warn(
+            `[Rozenite] Storage Plugin: Storage target not found for ${target.adapterId}/${target.storageId}`,
+          );
+          return;
+        }
+
+        try {
+          await view.purge();
+          await sendInvalidation(view.target, undefined, 'purge');
+        } catch (error) {
+          console.warn(
+            `[Rozenite] Storage Plugin: Failed to purge storage in ${target.adapterId}/${target.storageId}.`,
+            error,
+          );
+        }
+      }),
+      client.onMessage('discover-storages', async (event: StorageDiscoverStoragesRequestEvent) => {
+        const response = await handleStorageDiscoveryRequest(views, event);
+        client.send(response.type, response);
+      }),
       client.onMessage(
         'list-entry-previews',
         async (event: StorageListEntryPreviewsRequestEvent) => {
@@ -184,37 +177,32 @@ export const useRozeniteStoragePlugin = ({
           client.send(response.type, response);
         },
       ),
-      client.onMessage(
-        'get-entry',
-        async (event: StorageGetEntryRequestEvent) => {
-          const response = await handleFullEntryRequest(views, event);
-          client.send(response.type, response);
-        },
-      ),
-      client.onMessage(
-        'export-snapshot',
-        async (event: StorageExportSnapshotRequestEvent) => {
-          const response = await handleExportSnapshotRequest(views, event);
-          client.send(response.type, response);
-        },
-      ),
-      client.onMessage(
-        'preview-import',
-        async (event: StorageImportPreviewRequestEvent) => {
-          const response = await handleImportPreviewRequest(views, event);
-          client.send(response.type, response);
-        },
-      ),
-      client.onMessage(
-        'import-entries',
-        async (event: StorageImportEntriesEvent) => {
-          await handleImportEntries(views, event, (out) => {
-            client.send(out.type, out);
-          });
-        },
-      ),
+      client.onMessage('get-entry', async (event: StorageGetEntryRequestEvent) => {
+        const response = await handleFullEntryRequest(views, event);
+        client.send(response.type, response);
+      }),
+      client.onMessage('export-snapshot', async (event: StorageExportSnapshotRequestEvent) => {
+        const response = await handleExportSnapshotRequest(views, event);
+        client.send(response.type, response);
+      }),
+      client.onMessage('preview-import', async (event: StorageImportPreviewRequestEvent) => {
+        const response = await handleImportPreviewRequest(views, event);
+        client.send(response.type, response);
+      }),
+      client.onMessage('import-entries', async (event: StorageImportEntriesEvent) => {
+        await handleImportEntries(views, event, (out) => {
+          client.send(out.type, out);
+        });
+      }),
     ];
 
+    // Sent last, so a panel that reacts to it is guaranteed to find the
+    // handlers above already listening. The panel is recreated on every app
+    // reload and asks for storages as soon as it boots, which usually beats the
+    // app's React tree to the punch; without this the panel's only request is
+    // dropped and it waits for storages forever.
+    client.send('device-ready', { type: 'device-ready' });
+
     return () => {
       disposed = true;
       viewSubscriptions.forEach((subscription) => subscription.remove());

package/src/react-native/useStorageAgentTools.ts

@@ -13,10 +13,7 @@ import type {
 } from '../shared/types';
 import type { StorageView } from './storage-view';
 
-const parseValueForType = (
-  type: StorageEntryType,
-  value: unknown,
-): StorageEntryValue => {
+const parseValueForType = (type: StorageEntryType, value: unknown): StorageEntryValue => {
   if (type === 'string') {
     if (typeof value !== 'string') {
       throw new Error('Expected string value for type=string');
@@ -45,8 +42,7 @@ const parseValueForType = (
   return value as number[];
 };
 
-const formatViewRef = (view: StorageView) =>
-  `${view.target.adapterId}/${view.target.storageId}`;
+const formatViewRef = (view: StorageView) => `${view.target.adapterId}/${view.target.storageId}`;
 
 const isSameTarget = (left: StorageTarget, right: StorageTarget) =>
   left.adapterId === right.adapterId && left.storageId === right.storageId;
@@ -68,10 +64,8 @@ const decodeCursor = (value: string): ListEntriesCursor => {
       cursor == null ||
       Array.isArray(cursor) ||
       (cursor as { version?: unknown }).version !== 1 ||
-      typeof (cursor as { target?: { adapterId?: unknown } }).target
-        ?.adapterId !== 'string' ||
-      typeof (cursor as { target?: { storageId?: unknown } }).target
-        ?.storageId !== 'string' ||
+      typeof (cursor as { target?: { adapterId?: unknown } }).target?.adapterId !== 'string' ||
+      typeof (cursor as { target?: { storageId?: unknown } }).target?.storageId !== 'string' ||
       !Number.isSafeInteger((cursor as { offset?: unknown }).offset) ||
       (cursor as { offset: number }).offset < 0
     ) {
@@ -112,11 +106,7 @@ const sanitizeOffset = (offset: number | undefined) => {
   return offset;
 };
 
-const resolveStorage = (
-  views: readonly StorageView[],
-  adapterId?: string,
-  storageId?: string,
-) => {
+const resolveStorage = (views: readonly StorageView[], adapterId?: string, storageId?: string) => {
   if (views.length === 0) {
     throw new Error('No storages are registered.');
   }
@@ -158,16 +148,12 @@ const resolveStorage = (
   return views[0]!;
 };
 
-const listStorageKeys = async (
-  view: StorageView,
-  input: StorageListEntriesArgs,
-) => {
+const listStorageKeys = async (view: StorageView, input: StorageListEntriesArgs) => {
   const limit = sanitizeLimit(input.limit);
   if (input.cursor !== undefined && input.offset !== undefined) {
     throw new Error('Provide either cursor or offset, not both.');
   }
-  const cursor =
-    input.cursor === undefined ? undefined : decodeCursor(input.cursor);
+  const cursor = input.cursor === undefined ? undefined : decodeCursor(input.cursor);
   if (cursor && !isSameTarget(cursor.target, view.target)) {
     throw new Error(
       'Cursor does not match the requested storage. Run list-entries again without a cursor to restart pagination.',
@@ -228,9 +214,7 @@ export const createStorageAgentHandlers = (views: readonly StorageView[]) => ({
     const entry = await view.get(key);
 
     if (!entry) {
-      throw new Error(
-        `Key "${key}" not found in storage "${formatViewRef(view)}".`,
-      );
+      throw new Error(`Key "${key}" not found in storage "${formatViewRef(view)}".`);
     }
 
     return {

package/src/shared/__tests__/entry-preview.test.ts

@@ -7,9 +7,7 @@ import {
 
 describe('toStorageEntryPreview', () => {
   it('represents empty and boundary-sized strings completely', () => {
-    expect(
-      toStorageEntryPreview({ key: 'empty', type: 'string', value: '' }),
-    ).toEqual({
+    expect(toStorageEntryPreview({ key: 'empty', type: 'string', value: '' })).toEqual({
       key: 'empty',
       type: 'string',
       preview: '',
@@ -18,9 +16,7 @@ describe('toStorageEntryPreview', () => {
     });
 
     const value = 'a'.repeat(MAX_STRING_PREVIEW_CODE_POINTS);
-    expect(
-      toStorageEntryPreview({ key: 'boundary', type: 'string', value }),
-    ).toEqual({
+    expect(toStorageEntryPreview({ key: 'boundary', type: 'string', value })).toEqual({
       key: 'boundary',
       type: 'string',
       preview: value,
@@ -32,9 +28,7 @@ describe('toStorageEntryPreview', () => {
   it('truncates an oversized string at the fixed code-point boundary', () => {
     const value = `${'a'.repeat(MAX_STRING_PREVIEW_CODE_POINTS)}z`;
 
-    expect(
-      toStorageEntryPreview({ key: 'long', type: 'string', value }),
-    ).toEqual({
+    expect(toStorageEntryPreview({ key: 'long', type: 'string', value })).toEqual({
       key: 'long',
       type: 'string',
       preview: 'a'.repeat(MAX_STRING_PREVIEW_CODE_POINTS),
@@ -46,9 +40,7 @@ describe('toStorageEntryPreview', () => {
   it('does not split Unicode code points while preserving string length', () => {
     const value = `${'😀'.repeat(MAX_STRING_PREVIEW_CODE_POINTS)}!`;
 
-    expect(
-      toStorageEntryPreview({ key: 'emoji', type: 'string', value }),
-    ).toEqual({
+    expect(toStorageEntryPreview({ key: 'emoji', type: 'string', value })).toEqual({
       key: 'emoji',
       type: 'string',
       preview: '😀'.repeat(MAX_STRING_PREVIEW_CODE_POINTS),
@@ -58,18 +50,14 @@ describe('toStorageEntryPreview', () => {
   });
 
   it('formats primitive values completely', () => {
-    expect(
-      toStorageEntryPreview({ key: 'count', type: 'number', value: 42 }),
-    ).toEqual({
+    expect(toStorageEntryPreview({ key: 'count', type: 'number', value: 42 })).toEqual({
       key: 'count',
       type: 'number',
       preview: '42',
       valueSize: 2,
       isTruncated: false,
     });
-    expect(
-      toStorageEntryPreview({ key: 'enabled', type: 'boolean', value: false }),
-    ).toEqual({
+    expect(toStorageEntryPreview({ key: 'enabled', type: 'boolean', value: false })).toEqual({
       key: 'enabled',
       type: 'boolean',
       preview: 'false',
@@ -79,9 +67,7 @@ describe('toStorageEntryPreview', () => {
   });
 
   it('formats empty and boundary-sized buffers as hexadecimal', () => {
-    expect(
-      toStorageEntryPreview({ key: 'empty', type: 'buffer', value: [] }),
-    ).toEqual({
+    expect(toStorageEntryPreview({ key: 'empty', type: 'buffer', value: [] })).toEqual({
       key: 'empty',
       type: 'buffer',
       preview: '',
@@ -90,9 +76,7 @@ describe('toStorageEntryPreview', () => {
     });
 
     const value = new Array(MAX_BUFFER_PREVIEW_BYTES).fill(0xab);
-    expect(
-      toStorageEntryPreview({ key: 'boundary', type: 'buffer', value }),
-    ).toEqual({
+    expect(toStorageEntryPreview({ key: 'boundary', type: 'buffer', value })).toEqual({
       key: 'boundary',
       type: 'buffer',
       preview: new Array(MAX_BUFFER_PREVIEW_BYTES).fill('AB').join(' '),
@@ -104,9 +88,7 @@ describe('toStorageEntryPreview', () => {
   it('truncates oversized buffers at the fixed byte boundary', () => {
     const value = [...new Array(MAX_BUFFER_PREVIEW_BYTES).fill(0xab), 0xcd];
 
-    expect(
-      toStorageEntryPreview({ key: 'long', type: 'buffer', value }),
-    ).toEqual({
+    expect(toStorageEntryPreview({ key: 'long', type: 'buffer', value })).toEqual({
       key: 'long',
       type: 'buffer',
       preview: new Array(MAX_BUFFER_PREVIEW_BYTES).fill('AB').join(' '),

package/src/shared/__tests__/snapshot.test.ts

@@ -1,19 +1,8 @@
 import { describe, expect, it } from 'vitest';
-import {
-  buildSnapshot,
-  computePreview,
-  parseSnapshot,
-  type StorageSnapshotV1,
-} from '../snapshot';
-import type {
-  StorageCapabilities,
-  StorageEntry,
-  StorageTarget,
-} from '../types';
-
-const validSnapshot = (
-  overrides: Partial<StorageSnapshotV1> = {},
-): StorageSnapshotV1 => ({
+import { buildSnapshot, computePreview, parseSnapshot, type StorageSnapshotV1 } from '../snapshot';
+import type { StorageCapabilities, StorageEntry, StorageTarget } from '../types';
+
+const validSnapshot = (overrides: Partial<StorageSnapshotV1> = {}): StorageSnapshotV1 => ({
   version: 1,
   plugin: '@rozenite/storage-plugin',
   createdAt: '2026-05-11T12:00:00.000Z',
@@ -125,16 +114,13 @@ describe('parseSnapshot', () => {
       const result = parseSnapshot(input);
       expect(result.ok).toBe(false);
       if (!result.ok) {
-        expect(result.error.path).toBe(
-          'storage.capabilities.supportedTypes[1]',
-        );
+        expect(result.error.path).toBe('storage.capabilities.supportedTypes[1]');
       }
     });
   });
 
   describe('per-entry rejections', () => {
-    const withEntry = (entry: unknown) =>
-      parseSnapshot({ ...validSnapshot(), entries: [entry] });
+    const withEntry = (entry: unknown) => parseSnapshot({ ...validSnapshot(), entries: [entry] });
 
     it('rejects entry missing key', () => {
       const result = withEntry({ type: 'string', value: 'x' });
@@ -217,9 +203,7 @@ describe('buildSnapshot', () => {
     const capabilities: StorageCapabilities = {
       supportedTypes: ['string', 'number'],
     };
-    const entries: StorageEntry[] = [
-      { key: 'token', type: 'string', value: 'abc' },
-    ];
+    const entries: StorageEntry[] = [{ key: 'token', type: 'string', value: 'abc' }];
 
     const result = buildSnapshot({
       target,
@@ -280,9 +264,7 @@ describe('computePreview', () => {
       entryKeys: new Set(),
       isBlacklisted: (key) => key.startsWith('__'),
     });
-    expect(preview.skippedKeys).toEqual([
-      { key: '__internal', reason: 'blacklist' },
-    ]);
+    expect(preview.skippedKeys).toEqual([{ key: '__internal', reason: 'blacklist' }]);
     expect(preview.newKeys).toEqual(['visible']);
   });
 
@@ -320,12 +302,8 @@ describe('computePreview', () => {
       entryKeys: new Set(['existing']),
       isBlacklisted: (key) => key.startsWith('__'),
     });
-    expect(preview.unsupportedTypes).toEqual([
-      { key: '__blocked', type: 'buffer' },
-    ]);
-    expect(preview.skippedKeys).toEqual([
-      { key: '__skipped', reason: 'blacklist' },
-    ]);
+    expect(preview.unsupportedTypes).toEqual([{ key: '__blocked', type: 'buffer' }]);
+    expect(preview.skippedKeys).toEqual([{ key: '__skipped', reason: 'blacklist' }]);
     expect(preview.overwriteKeys).toEqual(['existing']);
     expect(preview.newKeys).toEqual(['fresh']);
   });

package/src/shared/agent-tools.ts

@@ -11,8 +11,7 @@ type StorageSelection = Partial<StorageTarget>;
 const sharedStorageProperties = {
   adapterId: {
     type: 'string',
-    description:
-      'Storage adapter ID. Required when multiple adapters are configured.',
+    description: 'Storage adapter ID. Required when multiple adapters are configured.',
   },
   storageId: {
     type: 'string',
@@ -105,19 +104,13 @@ export type StorageRemoveEntryResult = {
 };
 
 export const storageToolDefinitions = {
-  listStorages: defineAgentToolContract<
-    StorageListStoragesArgs,
-    StorageListStoragesResult
-  >({
+  listStorages: defineAgentToolContract<StorageListStoragesArgs, StorageListStoragesResult>({
     name: 'list-storages',
     description:
       'List all storage adapters and their storage nodes currently available on the device, including supported entry types. Entry counts are omitted to avoid enumerating every storage.',
     inputSchema: { type: 'object', properties: {} },
   }),
-  listEntries: definePaginatedAgentToolContract<
-    StorageListEntriesArgs,
-    StorageListEntriesResult
-  >({
+  listEntries: definePaginatedAgentToolContract<StorageListEntriesArgs, StorageListEntriesResult>({
     name: 'list-entries',
     description:
       'List keys in a storage. This call intentionally does not return entry values to keep responses token-efficient.',
@@ -131,8 +124,7 @@ export const storageToolDefinitions = {
         },
         cursor: {
           type: 'string',
-          description:
-            'Opaque pagination cursor from a previous list-entries call.',
+          description: 'Opaque pagination cursor from a previous list-entries call.',
         },
         offset: {
           type: 'number',
@@ -147,10 +139,7 @@ export const storageToolDefinitions = {
       defaultFields: ['key'],
     },
   }),
-  readEntry: defineAgentToolContract<
-    StorageReadEntryArgs,
-    StorageReadEntryResult
-  >({
+  readEntry: defineAgentToolContract<StorageReadEntryArgs, StorageReadEntryResult>({
     name: 'read-entry',
     description: 'Read a single storage entry value by key.',
     inputSchema: {
@@ -162,10 +151,7 @@ export const storageToolDefinitions = {
       required: ['key'],
     },
   }),
-  createEntry: defineAgentToolContract<
-    StorageCreateEntryArgs,
-    StorageCreateEntryResult
-  >({
+  createEntry: defineAgentToolContract<StorageCreateEntryArgs, StorageCreateEntryResult>({
     name: 'create-entry',
     description: 'Create a new storage entry. Fails if the key already exists.',
     inputSchema: {
@@ -186,13 +172,9 @@ export const storageToolDefinitions = {
       required: ['key', 'type', 'value'],
     },
   }),
-  editEntry: defineAgentToolContract<
-    StorageEditEntryArgs,
-    StorageEditEntryResult
-  >({
+  editEntry: defineAgentToolContract<StorageEditEntryArgs, StorageEditEntryResult>({
     name: 'edit-entry',
-    description:
-      'Edit an existing storage entry. Fails if the key does not exist.',
+    description: 'Edit an existing storage entry. Fails if the key does not exist.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -211,10 +193,7 @@ export const storageToolDefinitions = {
       required: ['key', 'type', 'value'],
     },
   }),
-  removeEntry: defineAgentToolContract<
-    StorageRemoveEntryArgs,
-    StorageRemoveEntryResult
-  >({
+  removeEntry: defineAgentToolContract<StorageRemoveEntryArgs, StorageRemoveEntryResult>({
     name: 'remove-entry',
     description: 'Remove a storage entry by key.',
     inputSchema: {

package/src/shared/entry-preview.ts

@@ -3,12 +3,9 @@ import type { StorageEntry, StorageEntryPreview } from './types';
 export const MAX_STRING_PREVIEW_CODE_POINTS = 256;
 export const MAX_BUFFER_PREVIEW_BYTES = 16;
 
-const toHexPair = (byte: number): string =>
-  byte.toString(16).toUpperCase().padStart(2, '0');
+const toHexPair = (byte: number): string => byte.toString(16).toUpperCase().padStart(2, '0');
 
-const truncateString = (
-  value: string,
-): Pick<StorageEntryPreview, 'preview' | 'isTruncated'> => {
+const truncateString = (value: string): Pick<StorageEntryPreview, 'preview' | 'isTruncated'> => {
   let preview = '';
   let codePointCount = 0;
 
@@ -24,9 +21,7 @@ const truncateString = (
   return { preview, isTruncated: false };
 };
 
-export const toStorageEntryPreview = (
-  entry: StorageEntry,
-): StorageEntryPreview => {
+export const toStorageEntryPreview = (entry: StorageEntry): StorageEntryPreview => {
   if (entry.type === 'string') {
     return {
       key: entry.key,