@rozenite/storage-plugin 2.1.0 → 2.3.0

package/dist/react-native/src/shared/snapshot.js

@@ -0,0 +1,179 @@
+import { DEFAULT_SUPPORTED_TYPES, supportsType, } from './types';
+const PLUGIN_ID = '@rozenite/storage-plugin';
+const SUPPORTED_VERSION = 1;
+class ParseException extends Error {
+    constructor(path, message) {
+        super(message);
+        this.path = path;
+    }
+}
+const describe = (value) => {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+};
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const expectObject = (value, path) => {
+    if (!isPlainObject(value)) {
+        throw new ParseException(path, `Expected object, got ${describe(value)}`);
+    }
+    return value;
+};
+const expectString = (value, path) => {
+    if (typeof value !== 'string') {
+        throw new ParseException(path, `Expected string, got ${describe(value)}`);
+    }
+    return value;
+};
+const expectArray = (value, path) => {
+    if (!Array.isArray(value)) {
+        throw new ParseException(path, `Expected array, got ${describe(value)}`);
+    }
+    return value;
+};
+const expectEntryType = (value, path) => {
+    if (typeof value !== 'string' || !DEFAULT_SUPPORTED_TYPES.includes(value)) {
+        throw new ParseException(path, `Expected one of ${DEFAULT_SUPPORTED_TYPES.join(', ')}, got ${describe(value)}`);
+    }
+    return value;
+};
+const parseCapabilities = (raw, path) => {
+    const obj = expectObject(raw, path);
+    const supported = expectArray(obj.supportedTypes, `${path}.supportedTypes`);
+    const supportedTypes = supported.map((type, index) => expectEntryType(type, `${path}.supportedTypes[${index}]`));
+    return { supportedTypes };
+};
+const parseStorageMeta = (raw) => {
+    const obj = expectObject(raw, 'storage');
+    return {
+        adapterId: expectString(obj.adapterId, 'storage.adapterId'),
+        storageId: expectString(obj.storageId, 'storage.storageId'),
+        adapterName: expectString(obj.adapterName, 'storage.adapterName'),
+        storageName: expectString(obj.storageName, 'storage.storageName'),
+        capabilities: parseCapabilities(obj.capabilities, 'storage.capabilities'),
+    };
+};
+const parseEntry = (raw, path) => {
+    const obj = expectObject(raw, path);
+    const key = expectString(obj.key, `${path}.key`);
+    const type = expectEntryType(obj.type, `${path}.type`);
+    const valuePath = `${path}.value`;
+    switch (type) {
+        case 'string': {
+            const value = obj.value;
+            if (typeof value !== 'string') {
+                throw new ParseException(valuePath, `Expected string for type "string", got ${describe(value)}`);
+            }
+            return { key, type: 'string', value };
+        }
+        case 'number': {
+            const value = obj.value;
+            if (typeof value !== 'number' || !Number.isFinite(value)) {
+                throw new ParseException(valuePath, `Expected finite number for type "number", got ${describe(value)}`);
+            }
+            return { key, type: 'number', value };
+        }
+        case 'boolean': {
+            const value = obj.value;
+            if (typeof value !== 'boolean') {
+                throw new ParseException(valuePath, `Expected boolean for type "boolean", got ${describe(value)}`);
+            }
+            return { key, type: 'boolean', value };
+        }
+        case 'buffer': {
+            const value = obj.value;
+            if (!Array.isArray(value)) {
+                throw new ParseException(valuePath, `Expected number[] for type "buffer", got ${describe(value)}`);
+            }
+            const bytes = value.map((byte, index) => {
+                if (typeof byte !== 'number' || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+                    throw new ParseException(`${valuePath}[${index}]`, `Expected uint8 (integer 0-255), got ${describe(byte)}`);
+                }
+                return byte;
+            });
+            return { key, type: 'buffer', value: bytes };
+        }
+    }
+};
+export const parseSnapshot = (raw) => {
+    try {
+        const root = expectObject(raw, '$');
+        const version = root.version;
+        if (version !== SUPPORTED_VERSION) {
+            throw new ParseException('version', `Unsupported snapshot version: ${describe(version)} (this build supports version ${SUPPORTED_VERSION})`);
+        }
+        const plugin = expectString(root.plugin, 'plugin');
+        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}]`));
+        return {
+            ok: true,
+            snapshot: {
+                version: SUPPORTED_VERSION,
+                plugin,
+                createdAt,
+                storage,
+                entries,
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof ParseException) {
+            return { ok: false, error: { path: error.path, message: error.message } };
+        }
+        throw error;
+    }
+};
+export const buildSnapshot = (args) => ({
+    version: 1,
+    plugin: PLUGIN_ID,
+    createdAt: new Date().toISOString(),
+    storage: {
+        adapterId: args.target.adapterId,
+        storageId: args.target.storageId,
+        adapterName: args.adapterName,
+        storageName: args.storageName,
+        capabilities: args.capabilities,
+    },
+    entries: args.entries,
+});
+export const computePreview = (snapshot, current) => {
+    const newKeys = [];
+    const overwriteKeys = [];
+    const skippedKeys = [];
+    const unsupportedTypes = [];
+    const acceptedEntryIndexes = [];
+    for (const [index, entry] of snapshot.entries.entries()) {
+        if (!supportsType(current.capabilities, entry.type)) {
+            unsupportedTypes.push({ key: entry.key, type: entry.type });
+            continue;
+        }
+        if (current.isBlacklisted(entry.key)) {
+            skippedKeys.push({ key: entry.key, reason: 'blacklist' });
+            continue;
+        }
+        if (current.entryKeys.has(entry.key)) {
+            overwriteKeys.push(entry.key);
+        }
+        else {
+            newKeys.push(entry.key);
+        }
+        acceptedEntryIndexes.push(index);
+        // Duplicate keys are applied in source order, so every accepted duplicate
+        // after the first overwrites the value that preceded it in this import.
+        current.entryKeys.add(entry.key);
+    }
+    const metadataMismatch = snapshot.storage.adapterId !== current.target.adapterId ||
+        snapshot.storage.storageId !== current.target.storageId;
+    return {
+        newKeys,
+        overwriteKeys,
+        skippedKeys,
+        unsupportedTypes,
+        acceptedEntryIndexes,
+        metadataMismatch,
+    };
+};

package/dist/react-native/src/shared/types.d.ts

@@ -0,0 +1,78 @@
+export type StorageEntry = {
+    key: string;
+    type: 'string';
+    value: string;
+} | {
+    key: string;
+    type: 'number';
+    value: number;
+} | {
+    key: string;
+    type: 'boolean';
+    value: boolean;
+} | {
+    key: string;
+    type: 'buffer';
+    value: number[];
+};
+export type StorageEntryType = StorageEntry['type'];
+export type StorageEntryValue = StorageEntry['value'];
+export type StorageEntryPreview = {
+    key: string;
+    type: StorageEntryType;
+    preview: string;
+    valueSize: number;
+    isTruncated: boolean;
+};
+export type StorageCapabilities = {
+    supportedTypes: StorageEntryType[];
+};
+export type StorageDescriptor = {
+    target: StorageTarget;
+    adapterName: string;
+    storageName: string;
+    entryCount: number;
+    capabilities: StorageCapabilities;
+    supportsSubscriptions: boolean;
+};
+export type StorageSubscription = {
+    remove: () => void;
+};
+export type SyncStorage = {
+    kind: 'sync';
+    getAllKeys: () => string[];
+    get: (key: string) => StorageEntry | undefined;
+    set: (entry: StorageEntry) => void;
+    delete: (key: string) => void;
+    clear: () => void;
+    subscribe?: (callback: (key: string) => void) => StorageSubscription;
+};
+export type AsyncStorage = {
+    kind: 'async';
+    getAllKeys: () => Promise<readonly string[]>;
+    get: (key: string) => Promise<StorageEntry | undefined>;
+    set: (entry: StorageEntry) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+    subscribe?: (callback: (key: string) => void) => StorageSubscription;
+};
+export type StorageNode = {
+    id: string;
+    name: string;
+    storage: SyncStorage | AsyncStorage;
+    capabilities: StorageCapabilities;
+    blacklist?: RegExp;
+    shouldFilterKey?: (key: string) => boolean;
+};
+export type StorageAdapter = {
+    id: string;
+    name: string;
+    storages: StorageNode[];
+};
+export type StorageTarget = {
+    adapterId: string;
+    storageId: string;
+};
+export declare const DEFAULT_SUPPORTED_TYPES: StorageEntryType[];
+export declare const getStorageViewId: ({ adapterId, storageId }: StorageTarget) => string;
+export declare const supportsType: (capabilities: StorageCapabilities, type: StorageEntryType) => boolean;

package/dist/react-native/src/shared/types.js

@@ -0,0 +1,8 @@
+export const DEFAULT_SUPPORTED_TYPES = [
+    'string',
+    'number',
+    'boolean',
+    'buffer',
+];
+export const getStorageViewId = ({ adapterId, storageId }) => `${adapterId}:${storageId}`;
+export const supportsType = (capabilities, type) => capabilities.supportedTypes.includes(type);

package/dist/rozenite.json

@@ -1 +1 @@
-{"name":"@rozenite/storage-plugin","version":"2.1.0","description":"Generic Storage Inspector for Rozenite.","panels":[{"name":"Storage","source":"/devtools/panel.html"}]}
+{"name":"@rozenite/storage-plugin","version":"2.3.0","description":"Generic Storage Inspector for Rozenite.","panels":[{"name":"Storage","source":"/devtools/panel.html"}],"integrations":["react-native"]}

package/dist/sdk/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/sdk/sdk.d.ts

@@ -0,0 +1,44 @@
+import { STORAGE_AGENT_ENTRY_TYPES, STORAGE_AGENT_PLUGIN_ID, storageToolDefinitions } from './src/shared/agent-tools.js';
+export { STORAGE_AGENT_ENTRY_TYPES, STORAGE_AGENT_PLUGIN_ID, storageToolDefinitions };
+export declare const storageTools: {
+    readonly listStorages: import("@rozenite/agent-shared").AgentToolDescriptor<undefined, import("./src/shared/agent-tools.js").StorageListStoragesResult>;
+    readonly listEntries: import("@rozenite/agent-shared").AgentToolDescriptor<import("./src/shared/agent-tools.js").StorageListEntriesArgs, import("./src/shared/agent-tools.js").StorageListEntriesResult>;
+    readonly readEntry: import("@rozenite/agent-shared").AgentToolDescriptor<import("./src/shared/agent-tools.js").StorageReadEntryArgs, import("./src/shared/agent-tools.js").StorageReadEntryResult>;
+    readonly createEntry: import("@rozenite/agent-shared").AgentToolDescriptor<(Partial<import("./src/shared/types.js").StorageTarget> & {
+        key: string;
+        type: "string";
+        value: string;
+    }) | (Partial<import("./src/shared/types.js").StorageTarget> & {
+        key: string;
+        type: "number";
+        value: number;
+    }) | (Partial<import("./src/shared/types.js").StorageTarget> & {
+        key: string;
+        type: "boolean";
+        value: boolean;
+    }) | (Partial<import("./src/shared/types.js").StorageTarget> & {
+        key: string;
+        type: "buffer";
+        value: number[];
+    }), import("./src/shared/agent-tools.js").StorageCreateEntryResult>;
+    readonly editEntry: import("@rozenite/agent-shared").AgentToolDescriptor<(Partial<import("./src/shared/types.js").StorageTarget> & {
+        key: string;
+        type: "string";
+        value: string;
+    }) | (Partial<import("./src/shared/types.js").StorageTarget> & {
+        key: string;
+        type: "number";
+        value: number;
+    }) | (Partial<import("./src/shared/types.js").StorageTarget> & {
+        key: string;
+        type: "boolean";
+        value: boolean;
+    }) | (Partial<import("./src/shared/types.js").StorageTarget> & {
+        key: string;
+        type: "buffer";
+        value: number[];
+    }), import("./src/shared/agent-tools.js").StorageEditEntryResult>;
+    readonly removeEntry: import("@rozenite/agent-shared").AgentToolDescriptor<import("./src/shared/agent-tools.js").StorageRemoveEntryArgs, import("./src/shared/agent-tools.js").StorageRemoveEntryResult>;
+};
+export type { StorageCreateEntryArgs, StorageCreateEntryResult, StorageEditEntryArgs, StorageEditEntryResult, StorageListEntriesArgs, StorageListEntriesResult, StorageListStoragesArgs, StorageListStoragesItem, StorageListStoragesResult, StorageReadEntryArgs, StorageReadEntryResult, StorageRemoveEntryArgs, StorageRemoveEntryResult, StorageWriteEntryArgs, } from './src/shared/agent-tools.js';
+export type { StorageAdapter, StorageCapabilities, StorageEntry, StorageEntryType, StorageEntryValue, StorageNode, StorageTarget, } from './src/shared/types.js';

package/dist/sdk/sdk.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageTools = exports.storageToolDefinitions = exports.STORAGE_AGENT_PLUGIN_ID = exports.STORAGE_AGENT_ENTRY_TYPES = void 0;
+const agent_shared_1 = require("@rozenite/agent-shared");
+const agent_tools_js_1 = require("./src/shared/agent-tools.js");
+Object.defineProperty(exports, "STORAGE_AGENT_ENTRY_TYPES", { enumerable: true, get: function () { return agent_tools_js_1.STORAGE_AGENT_ENTRY_TYPES; } });
+Object.defineProperty(exports, "STORAGE_AGENT_PLUGIN_ID", { enumerable: true, get: function () { return agent_tools_js_1.STORAGE_AGENT_PLUGIN_ID; } });
+Object.defineProperty(exports, "storageToolDefinitions", { enumerable: true, get: function () { return agent_tools_js_1.storageToolDefinitions; } });
+exports.storageTools = (0, agent_shared_1.defineAgentToolDescriptors)(agent_tools_js_1.STORAGE_AGENT_PLUGIN_ID, agent_tools_js_1.storageToolDefinitions);

package/dist/sdk/src/shared/agent-tools.d.ts

@@ -0,0 +1,76 @@
+import { type AgentToolContract } from '@rozenite/agent-shared';
+import type { StorageEntry, StorageEntryType, StorageTarget } from './types';
+type StorageSelection = Partial<StorageTarget>;
+export declare const STORAGE_AGENT_PLUGIN_ID = "@rozenite/storage-plugin";
+export declare const STORAGE_AGENT_ENTRY_TYPES: readonly ["string", "number", "boolean", "buffer"];
+export type StorageListStoragesArgs = undefined;
+export type StorageListStoragesItem = {
+    adapterId: string;
+    storageId: string;
+    adapterName: string;
+    storageName: string;
+    supportedTypes: StorageEntryType[];
+};
+export type StorageListStoragesResult = {
+    storages: StorageListStoragesItem[];
+};
+export type StorageListEntriesArgs = StorageSelection & {
+    limit?: number;
+    cursor?: string;
+    /** @deprecated Use the opaque cursor returned by a previous page. */
+    offset?: number;
+};
+export type StorageListEntriesResult = {
+    adapterId: string;
+    storageId: string;
+    total: number;
+    items: Array<{
+        key: string;
+    }>;
+    page: {
+        limit: number;
+        hasMore: boolean;
+        nextCursor?: string;
+    };
+};
+export type StorageReadEntryArgs = StorageSelection & {
+    key: string;
+};
+export type StorageReadEntryResult = {
+    adapterId: string;
+    storageId: string;
+    entry: StorageEntry;
+};
+export type StorageWriteEntryArgs = StorageSelection & StorageEntry;
+export type StorageCreateEntryArgs = StorageWriteEntryArgs;
+export type StorageCreateEntryResult = {
+    adapterId: string;
+    storageId: string;
+    created: true;
+    key: string;
+};
+export type StorageEditEntryArgs = StorageWriteEntryArgs;
+export type StorageEditEntryResult = {
+    adapterId: string;
+    storageId: string;
+    edited: true;
+    key: string;
+};
+export type StorageRemoveEntryArgs = StorageSelection & {
+    key: string;
+};
+export type StorageRemoveEntryResult = {
+    adapterId: string;
+    storageId: string;
+    removed: boolean;
+    key: string;
+};
+export declare const storageToolDefinitions: {
+    readonly listStorages: AgentToolContract<undefined, StorageListStoragesResult>;
+    readonly listEntries: AgentToolContract<StorageListEntriesArgs, StorageListEntriesResult>;
+    readonly readEntry: AgentToolContract<StorageReadEntryArgs, StorageReadEntryResult>;
+    readonly createEntry: AgentToolContract<StorageWriteEntryArgs, StorageCreateEntryResult>;
+    readonly editEntry: AgentToolContract<StorageWriteEntryArgs, StorageEditEntryResult>;
+    readonly removeEntry: AgentToolContract<StorageRemoveEntryArgs, StorageRemoveEntryResult>;
+};
+export {};

package/dist/sdk/src/shared/agent-tools.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageToolDefinitions = exports.STORAGE_AGENT_ENTRY_TYPES = exports.STORAGE_AGENT_PLUGIN_ID = void 0;
+const agent_shared_1 = require("@rozenite/agent-shared");
+const sharedStorageProperties = {
+    adapterId: {
+        type: 'string',
+        description: 'Storage adapter ID. Required when multiple adapters are configured.',
+    },
+    storageId: {
+        type: 'string',
+        description: 'Storage node ID within the adapter. Required when multiple storages are configured.',
+    },
+};
+exports.STORAGE_AGENT_PLUGIN_ID = '@rozenite/storage-plugin';
+exports.STORAGE_AGENT_ENTRY_TYPES = [
+    'string',
+    'number',
+    'boolean',
+    'buffer',
+];
+exports.storageToolDefinitions = {
+    listStorages: (0, agent_shared_1.defineAgentToolContract)({
+        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: (0, agent_shared_1.definePaginatedAgentToolContract)({
+        name: 'list-entries',
+        description: 'List keys in a storage. This call intentionally does not return entry values to keep responses token-efficient.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...sharedStorageProperties,
+                limit: {
+                    type: 'number',
+                    description: 'Pagination size. Defaults to 20 and is capped at 100.',
+                },
+                cursor: {
+                    type: 'string',
+                    description: 'Opaque pagination cursor from a previous list-entries call.',
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Deprecated initial pagination offset. Must be a non-negative integer and cannot be combined with cursor.',
+                },
+            },
+        },
+        pagination: {
+            kind: 'cursor',
+            fields: ['key'],
+            defaultFields: ['key'],
+        },
+    }),
+    readEntry: (0, agent_shared_1.defineAgentToolContract)({
+        name: 'read-entry',
+        description: 'Read a single storage entry value by key.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...sharedStorageProperties,
+                key: { type: 'string', description: 'Entry key.' },
+            },
+            required: ['key'],
+        },
+    }),
+    createEntry: (0, agent_shared_1.defineAgentToolContract)({
+        name: 'create-entry',
+        description: 'Create a new storage entry. Fails if the key already exists.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...sharedStorageProperties,
+                key: { type: 'string', description: 'Entry key.' },
+                type: {
+                    type: 'string',
+                    enum: [...exports.STORAGE_AGENT_ENTRY_TYPES],
+                    description: 'Entry value type. Must be one of the supported types for the target storage (see list-storages).',
+                },
+                value: {
+                    description: 'Entry value matching the provided type.',
+                },
+            },
+            required: ['key', 'type', 'value'],
+        },
+    }),
+    editEntry: (0, agent_shared_1.defineAgentToolContract)({
+        name: 'edit-entry',
+        description: 'Edit an existing storage entry. Fails if the key does not exist.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...sharedStorageProperties,
+                key: { type: 'string', description: 'Entry key.' },
+                type: {
+                    type: 'string',
+                    enum: [...exports.STORAGE_AGENT_ENTRY_TYPES],
+                    description: 'Entry value type. Must be one of the supported types for the target storage (see list-storages).',
+                },
+                value: {
+                    description: 'Entry value matching the provided type.',
+                },
+            },
+            required: ['key', 'type', 'value'],
+        },
+    }),
+    removeEntry: (0, agent_shared_1.defineAgentToolContract)({
+        name: 'remove-entry',
+        description: 'Remove a storage entry by key.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ...sharedStorageProperties,
+                key: { type: 'string', description: 'Entry key.' },
+            },
+            required: ['key'],
+        },
+    }),
+};

package/dist/sdk/src/shared/types.d.ts

@@ -0,0 +1,78 @@
+export type StorageEntry = {
+    key: string;
+    type: 'string';
+    value: string;
+} | {
+    key: string;
+    type: 'number';
+    value: number;
+} | {
+    key: string;
+    type: 'boolean';
+    value: boolean;
+} | {
+    key: string;
+    type: 'buffer';
+    value: number[];
+};
+export type StorageEntryType = StorageEntry['type'];
+export type StorageEntryValue = StorageEntry['value'];
+export type StorageEntryPreview = {
+    key: string;
+    type: StorageEntryType;
+    preview: string;
+    valueSize: number;
+    isTruncated: boolean;
+};
+export type StorageCapabilities = {
+    supportedTypes: StorageEntryType[];
+};
+export type StorageDescriptor = {
+    target: StorageTarget;
+    adapterName: string;
+    storageName: string;
+    entryCount: number;
+    capabilities: StorageCapabilities;
+    supportsSubscriptions: boolean;
+};
+export type StorageSubscription = {
+    remove: () => void;
+};
+export type SyncStorage = {
+    kind: 'sync';
+    getAllKeys: () => string[];
+    get: (key: string) => StorageEntry | undefined;
+    set: (entry: StorageEntry) => void;
+    delete: (key: string) => void;
+    clear: () => void;
+    subscribe?: (callback: (key: string) => void) => StorageSubscription;
+};
+export type AsyncStorage = {
+    kind: 'async';
+    getAllKeys: () => Promise<readonly string[]>;
+    get: (key: string) => Promise<StorageEntry | undefined>;
+    set: (entry: StorageEntry) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+    subscribe?: (callback: (key: string) => void) => StorageSubscription;
+};
+export type StorageNode = {
+    id: string;
+    name: string;
+    storage: SyncStorage | AsyncStorage;
+    capabilities: StorageCapabilities;
+    blacklist?: RegExp;
+    shouldFilterKey?: (key: string) => boolean;
+};
+export type StorageAdapter = {
+    id: string;
+    name: string;
+    storages: StorageNode[];
+};
+export type StorageTarget = {
+    adapterId: string;
+    storageId: string;
+};
+export declare const DEFAULT_SUPPORTED_TYPES: StorageEntryType[];
+export declare const getStorageViewId: ({ adapterId, storageId }: StorageTarget) => string;
+export declare const supportsType: (capabilities: StorageCapabilities, type: StorageEntryType) => boolean;

package/dist/sdk/src/shared/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportsType = exports.getStorageViewId = exports.DEFAULT_SUPPORTED_TYPES = void 0;
+exports.DEFAULT_SUPPORTED_TYPES = [
+    'string',
+    'number',
+    'boolean',
+    'buffer',
+];
+const getStorageViewId = ({ adapterId, storageId }) => `${adapterId}:${storageId}`;
+exports.getStorageViewId = getStorageViewId;
+const supportsType = (capabilities, type) => capabilities.supportedTypes.includes(type);
+exports.supportsType = supportsType;