@harborclient/sdk 0.4.3

package/dist/signing/testFixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testFixtures.d.ts","sourceRoot":"","sources":["../../src/signing/testFixtures.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,eAAe,CASvD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,SAA4B,GAAG;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CA0BA"}

package/dist/signing/testFixtures.js

@@ -0,0 +1,41 @@
+import { generateKeyPairSync } from 'node:crypto';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Generates an Ed25519 PEM key pair for tests.
+ */
+export function createTestSigningKeys() {
+    const pair = generateKeyPairSync('ed25519', {
+        publicKeyEncoding: { type: 'spki', format: 'pem' },
+        privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+    });
+    return {
+        privateKeyPem: pair.privateKey,
+        publicKeyPem: pair.publicKey
+    };
+}
+/**
+ * Creates a minimal plugin directory suitable for signing tests.
+ *
+ * @param pluginId - Plugin manifest id.
+ */
+export function createTestPluginDir(pluginId = 'com.example.test-plugin') {
+    const pluginDir = mkdtempSync(join(tmpdir(), 'hc-plugin-sign-'));
+    mkdirSync(join(pluginDir, 'dist'), { recursive: true });
+    writeFileSync(join(pluginDir, 'manifest.json'), JSON.stringify({
+        id: pluginId,
+        name: 'Test Plugin',
+        version: '1.0.0',
+        engines: { harborclient: '>=1.0.0' },
+        renderer: 'dist/renderer.js',
+        permissions: ['ui']
+    }, null, 2));
+    writeFileSync(join(pluginDir, 'dist', 'renderer.js'), 'export function activate() {}');
+    return {
+        pluginDir,
+        cleanup: () => {
+            rmSync(pluginDir, { recursive: true, force: true });
+        }
+    };
+}

package/dist/signing/types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Filename written at the plugin root when a package is signed.
+ */
+export declare const PLUGIN_SIGNATURE_FILENAME = "signature.json";
+/**
+ * Supported plugin signature schema version.
+ */
+export declare const PLUGIN_SIGNATURE_SCHEMA_VERSION = 1;
+/**
+ * Signature algorithm stored in signature.json.
+ */
+export declare const PLUGIN_SIGNATURE_ALGORITHM: "Ed25519";
+/**
+ * One hashed file entry in a plugin signature inventory.
+ */
+export interface PluginFileHash {
+    path: string;
+    sha256: string;
+}
+/**
+ * Parsed plugin signature.json on disk (excluding runtime-only fields).
+ */
+export interface PluginSignatureFile {
+    schemaVersion: typeof PLUGIN_SIGNATURE_SCHEMA_VERSION;
+    pluginId: string;
+    pluginVersion: string;
+    algorithm: typeof PLUGIN_SIGNATURE_ALGORITHM;
+    keyId?: string;
+    files: PluginFileHash[];
+    signature: string;
+}
+/**
+ * Payload signed by Ed25519 before the signature field is attached.
+ */
+export interface PluginSignaturePayload {
+    schemaVersion: typeof PLUGIN_SIGNATURE_SCHEMA_VERSION;
+    pluginId: string;
+    pluginVersion: string;
+    algorithm: typeof PLUGIN_SIGNATURE_ALGORITHM;
+    keyId?: string;
+    files: PluginFileHash[];
+}
+/**
+ * Result of verifying a plugin signature.
+ */
+export type PluginVerifyStatus = 'valid' | 'unsigned' | 'invalid';
+/**
+ * Options for {@link signPlugin}.
+ */
+export interface SignPluginOptions {
+    /** Absolute or relative path to the plugin root directory. */
+    pluginDir: string;
+    /** PEM-encoded Ed25519 private key. */
+    privateKeyPem: string;
+    /** Optional label stored in signature.json to identify the signing key. */
+    keyId?: string;
+    /** Override path for signature.json (default: `<pluginDir>/signature.json`). */
+    signaturePath?: string;
+}
+/**
+ * Result returned after writing a plugin signature file.
+ */
+export interface SignPluginResult {
+    signaturePath: string;
+    signature: PluginSignatureFile;
+}
+/**
+ * Options for {@link verifyPlugin}.
+ */
+export interface VerifyPluginOptions {
+    /** Absolute or relative path to the plugin root directory. */
+    pluginDir: string;
+    /** PEM-encoded Ed25519 public keys trusted for verification. */
+    trustedPublicKeysPem: string[];
+    /** Override path for signature.json (default: `<pluginDir>/signature.json`). */
+    signaturePath?: string;
+}
+/**
+ * Result returned after verifying a plugin signature.
+ */
+export interface VerifyPluginResult {
+    status: PluginVerifyStatus;
+    signature?: PluginSignatureFile;
+    keyId?: string;
+    error?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/signing/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/signing/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,yBAAyB,mBAAmB,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,+BAA+B,IAAI,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAG,SAAkB,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,OAAO,+BAA+B,CAAC;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,OAAO,0BAA0B,CAAC;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,OAAO,+BAA+B,CAAC;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,OAAO,0BAA0B,CAAC;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,cAAc,EAAE,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,mBAAmB,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,gFAAgF;IAChF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB"}

package/dist/signing/types.js

@@ -0,0 +1,12 @@
+/**
+ * Filename written at the plugin root when a package is signed.
+ */
+export const PLUGIN_SIGNATURE_FILENAME = 'signature.json';
+/**
+ * Supported plugin signature schema version.
+ */
+export const PLUGIN_SIGNATURE_SCHEMA_VERSION = 1;
+/**
+ * Signature algorithm stored in signature.json.
+ */
+export const PLUGIN_SIGNATURE_ALGORITHM = 'Ed25519';

package/dist/signing/verify.d.ts

@@ -0,0 +1,17 @@
+import type { PluginSignatureFile, VerifyPluginOptions, VerifyPluginResult } from './types.js';
+/**
+ * Reads signature.json from a plugin directory when present.
+ *
+ * @param pluginDir - Plugin root directory.
+ * @returns Parsed signature file or null when signature.json is absent.
+ * @throws When signature.json exists but is invalid JSON or shape.
+ */
+export declare function readPluginSignature(pluginDir: string): PluginSignatureFile | null;
+/**
+ * Verifies a plugin signature against trusted public keys and on-disk file hashes.
+ *
+ * @param options - Plugin directory and trusted public key options.
+ * @returns Verification status with optional error detail.
+ */
+export declare function verifyPlugin(options: VerifyPluginOptions): Promise<VerifyPluginResult>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/signing/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../src/signing/verify.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE/F;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAcjF;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA0F5F"}

package/dist/signing/verify.js

@@ -0,0 +1,129 @@
+import { createPublicKey, verify } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { buildSignaturePayload, canonicalizeSignaturePayload, parsePluginSignatureFile } from './canonical.js';
+import { assertPluginDirectory, collectPluginFiles } from './inventory.js';
+import { readPluginManifestIdentity } from './manifest.js';
+import { PLUGIN_SIGNATURE_FILENAME } from './types.js';
+/**
+ * Reads signature.json from a plugin directory when present.
+ *
+ * @param pluginDir - Plugin root directory.
+ * @returns Parsed signature file or null when signature.json is absent.
+ * @throws When signature.json exists but is invalid JSON or shape.
+ */
+export function readPluginSignature(pluginDir) {
+    const signaturePath = resolve(pluginDir, PLUGIN_SIGNATURE_FILENAME);
+    if (!existsSync(signaturePath)) {
+        return null;
+    }
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(signaturePath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`Plugin signature is not valid JSON: ${signaturePath}`, { cause: error });
+    }
+    return parsePluginSignatureFile(raw);
+}
+/**
+ * Verifies a plugin signature against trusted public keys and on-disk file hashes.
+ *
+ * @param options - Plugin directory and trusted public key options.
+ * @returns Verification status with optional error detail.
+ */
+export async function verifyPlugin(options) {
+    const pluginDir = resolve(options.pluginDir);
+    assertPluginDirectory(pluginDir);
+    const signaturePath = resolve(options.signaturePath ?? resolve(pluginDir, PLUGIN_SIGNATURE_FILENAME));
+    if (!existsSync(signaturePath)) {
+        return { status: 'unsigned' };
+    }
+    let signature;
+    try {
+        const raw = JSON.parse(readFileSync(signaturePath, 'utf8'));
+        signature = parsePluginSignatureFile(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { status: 'invalid', error: message };
+    }
+    let manifestIdentity;
+    try {
+        manifestIdentity = readPluginManifestIdentity(pluginDir);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { status: 'invalid', signature, error: message };
+    }
+    if (signature.pluginId !== manifestIdentity.id) {
+        return {
+            status: 'invalid',
+            signature,
+            error: `Signature pluginId "${signature.pluginId}" does not match manifest id "${manifestIdentity.id}".`
+        };
+    }
+    if (signature.pluginVersion !== manifestIdentity.version) {
+        return {
+            status: 'invalid',
+            signature,
+            error: `Signature pluginVersion "${signature.pluginVersion}" does not match manifest version "${manifestIdentity.version}".`
+        };
+    }
+    const currentFiles = collectPluginFiles(pluginDir);
+    if (!fileInventoriesMatch(signature.files, currentFiles)) {
+        return {
+            status: 'invalid',
+            signature,
+            error: 'Plugin files do not match the signed inventory.'
+        };
+    }
+    const payload = buildSignaturePayload(signature.pluginId, signature.pluginVersion, signature.files, signature.keyId);
+    const payloadBytes = canonicalizeSignaturePayload(payload);
+    const signatureBytes = new Uint8Array(Buffer.from(signature.signature, 'base64'));
+    if (options.trustedPublicKeysPem.length === 0) {
+        return {
+            status: 'invalid',
+            signature,
+            error: 'At least one trusted public key is required for verification.'
+        };
+    }
+    for (const publicKeyPem of options.trustedPublicKeysPem) {
+        try {
+            const publicKey = createPublicKey(publicKeyPem);
+            if (verify(null, new Uint8Array(payloadBytes), publicKey, signatureBytes)) {
+                return {
+                    status: 'valid',
+                    signature,
+                    keyId: signature.keyId
+                };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return {
+        status: 'invalid',
+        signature,
+        error: 'Plugin signature failed verification against all trusted public keys.'
+    };
+}
+/**
+ * Returns true when two plugin inventories contain identical path/hash pairs.
+ *
+ * @param signedFiles - File inventory stored in signature.json.
+ * @param currentFiles - File inventory computed from disk.
+ */
+function fileInventoriesMatch(signedFiles, currentFiles) {
+    if (signedFiles.length !== currentFiles.length) {
+        return false;
+    }
+    for (let index = 0; index < signedFiles.length; index += 1) {
+        if (signedFiles[index].path !== currentFiles[index].path ||
+            signedFiles[index].sha256 !== currentFiles[index].sha256) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/storage/cappedList.d.ts

@@ -0,0 +1,55 @@
+import type { PluginStorage } from '../types.js';
+/**
+ * Options for {@link mergeById}.
+ */
+export interface MergeByIdOptions<T> {
+    /**
+     * Maximum number of entries to retain after merging.
+     */
+    cap: number;
+    /**
+     * Returns the stable id used for deduplication.
+     */
+    idOf: (entry: T) => string;
+}
+/**
+ * Merges pending entries ahead of existing ones, deduping by id and capping length.
+ *
+ * @param pending - New entries to prepend (newest first).
+ * @param existing - Previously stored entries (newest first).
+ * @param options - Cap and id selector.
+ */
+export declare function mergeById<T>(pending: T[], existing: T[], options: MergeByIdOptions<T>): T[];
+/**
+ * Options for {@link createCappedList}.
+ */
+export interface CreateCappedListOptions<T> {
+    /**
+     * Plugin storage backing the list.
+     */
+    storage: PluginStorage;
+    /**
+     * Storage key within the plugin namespace.
+     */
+    key: string;
+    /**
+     * Maximum number of entries to persist.
+     */
+    cap: number;
+    /**
+     * Returns the stable id used for deduplication.
+     */
+    idOf: (entry: T) => string;
+}
+/**
+ * Persistent capped list helper with atomic read-modify-write semantics.
+ *
+ * @param options - Storage, key, cap, and id selector.
+ */
+export declare function createCappedList<T>(options: CreateCappedListOptions<T>): {
+    load: () => Promise<T[]>;
+    merge: (pending: T[]) => Promise<T[] | null>;
+    save: (entries: T[]) => Promise<void>;
+    clear: () => Promise<void>;
+};
+//# sourceMappingURL=cappedList.d.ts.map

package/dist/storage/cappedList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cappedList.d.ts","sourceRoot":"","sources":["../../src/storage/cappedList.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAkB3F;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC;;OAEG;IACH,OAAO,EAAE,aAAa,CAAC;IAEvB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;CAC5B;AAkCD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAAG;IACxE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IACzB,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;IAC7C,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B,CA0CA"}

package/dist/storage/cappedList.js

@@ -0,0 +1,102 @@
+/**
+ * Merges pending entries ahead of existing ones, deduping by id and capping length.
+ *
+ * @param pending - New entries to prepend (newest first).
+ * @param existing - Previously stored entries (newest first).
+ * @param options - Cap and id selector.
+ */
+export function mergeById(pending, existing, options) {
+    if (pending.length === 0) {
+        return existing.slice(0, options.cap);
+    }
+    const seen = new Set();
+    const merged = [];
+    for (const entry of [...pending, ...existing]) {
+        const id = options.idOf(entry);
+        if (seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        merged.push(entry);
+        if (merged.length >= options.cap) {
+            break;
+        }
+    }
+    return merged;
+}
+/**
+ * Serialized read-modify-write queue keyed by storage key.
+ */
+const writeQueues = new Map();
+/**
+ * Enqueues one storage mutation so concurrent callers cannot interleave get/set.
+ *
+ * @param key - Storage key used as the queue id.
+ * @param operation - Read-modify-write work to serialize.
+ */
+async function enqueueStorageWrite(key, operation) {
+    const previous = writeQueues.get(key) ?? Promise.resolve();
+    let resolveDone;
+    const done = new Promise((resolve) => {
+        resolveDone = resolve;
+    });
+    writeQueues.set(key, previous.then(() => done));
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        resolveDone();
+        if (writeQueues.get(key) === done) {
+            writeQueues.delete(key);
+        }
+    }
+}
+/**
+ * Persistent capped list helper with atomic read-modify-write semantics.
+ *
+ * @param options - Storage, key, cap, and id selector.
+ */
+export function createCappedList(options) {
+    const queueKey = options.key;
+    return {
+        load: async () => {
+            const saved = await options.storage.get(options.key);
+            return Array.isArray(saved) ? saved.slice(0, options.cap) : [];
+        },
+        merge: async (pending) => {
+            if (pending.length === 0) {
+                return null;
+            }
+            return enqueueStorageWrite(queueKey, async () => {
+                const existing = await options.storage.get(options.key);
+                const current = Array.isArray(existing) ? existing : [];
+                const merged = mergeById(pending, current, options);
+                if (merged.length === current.length) {
+                    let unchanged = true;
+                    for (let index = 0; index < merged.length; index += 1) {
+                        if (options.idOf(merged[index]) !== options.idOf(current[index])) {
+                            unchanged = false;
+                            break;
+                        }
+                    }
+                    if (unchanged) {
+                        return null;
+                    }
+                }
+                await options.storage.set(options.key, merged);
+                return merged;
+            });
+        },
+        save: async (entries) => {
+            await enqueueStorageWrite(queueKey, async () => {
+                await options.storage.set(options.key, entries.slice(0, options.cap));
+            });
+        },
+        clear: async () => {
+            await enqueueStorageWrite(queueKey, async () => {
+                await options.storage.set(options.key, []);
+            });
+        }
+    };
+}

package/dist/storage/cappedList.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cappedList.test.d.ts.map

package/dist/storage/cappedList.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cappedList.test.d.ts","sourceRoot":"","sources":["../../src/storage/cappedList.test.ts"],"names":[],"mappings":""}

package/dist/storage/cappedList.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, it } from '@jest/globals';
+import { mergeById } from './cappedList.js';
+describe('mergeById', () => {
+    it('dedupes and caps newest-first', () => {
+        const merged = mergeById([{ id: 'b' }, { id: 'a' }], [{ id: 'a' }, { id: 'c' }], {
+            cap: 3,
+            idOf: (entry) => entry.id
+        });
+        expect(merged.map((entry) => entry.id)).toEqual(['b', 'a', 'c']);
+    });
+});

package/dist/storage/index.d.ts

@@ -0,0 +1,2 @@
+export { createCappedList, mergeById, type CreateCappedListOptions, type MergeByIdOptions } from './cappedList.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,SAAS,EACT,KAAK,uBAAuB,EAC5B,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAC"}

package/dist/storage/index.js

@@ -0,0 +1 @@
+export { createCappedList, mergeById } from './cappedList.js';