@majikah/majik-signature-client 0.2.0 → 0.3.1

package/dist/core/backup/constants.d.ts

@@ -6,14 +6,14 @@
  *   MJKC = MajiK Contacts
  *   MJKA = MajiK App-data
  */
-export declare const MAJIK_MESSAGE_BACKUP_MAGIC: {
-    readonly chats: Uint8Array;
+export declare const MAJIK_SIGNATURE_BACKUP_MAGIC: {
+    readonly stamps: Uint8Array;
     readonly contacts: Uint8Array;
     readonly appData: Uint8Array;
 };
 /** The union of valid magic-byte headers. */
-export type MajikMessageBackupMagic = (typeof MAJIK_MESSAGE_BACKUP_MAGIC)[keyof typeof MAJIK_MESSAGE_BACKUP_MAGIC];
+export type MajikMessageBackupMagic = (typeof MAJIK_SIGNATURE_BACKUP_MAGIC)[keyof typeof MAJIK_SIGNATURE_BACKUP_MAGIC];
 /** Which backup type a file contains, as a discriminant string. */
-export type MajikMessageBackupType = keyof typeof MAJIK_MESSAGE_BACKUP_MAGIC;
+export type MajikMessageBackupType = keyof typeof MAJIK_SIGNATURE_BACKUP_MAGIC;
 /** Byte length of every backup file header (4-byte tag + 2-byte version). */
 export declare const MAJIK_MESSAGE_BACKUP_MAGIC_SIZE = 6;

package/dist/core/backup/constants.js

@@ -6,8 +6,15 @@
  *   MJKC = MajiK Contacts
  *   MJKA = MajiK App-data
  */
-export const MAJIK_MESSAGE_BACKUP_MAGIC = {
-    chats: new Uint8Array([0x4d, 0x4a, 0x4b, 0x49, 0x00, 0x01]), // "MJKI" v1
+export const MAJIK_SIGNATURE_BACKUP_MAGIC = {
+    stamps: new Uint8Array([
+        0x53,
+        0x54,
+        0x4d,
+        0x50, // "STMP"
+        0x00,
+        0x01, // Version 1
+    ]),
     contacts: new Uint8Array([0x4d, 0x4a, 0x4b, 0x43, 0x00, 0x01]), // "MJKC" v1
     appData: new Uint8Array([0x4d, 0x4a, 0x4b, 0x41, 0x00, 0x01]), // "MJKA" v1
 };

package/dist/core/backup/types.d.ts

@@ -1,6 +1,7 @@
 import { MajikContact, MajikContactGroup } from "@majikah/majik-contact";
 import { MajikContactManagerJSON } from "../contacts/types";
 import { UserAppPreferences } from "../storage";
+import { MajikSignatureStampJSON } from "../stamp/majik-signature-stamp";
 export interface ContactManagerSnapshot {
     /** Raw JSON payload — used internally by restoreContacts for bulk writes */
     managerJSON: MajikContactManagerJSON;
@@ -12,7 +13,7 @@ export interface ContactManagerSnapshot {
 export interface AppDataSnapshot {
     contacts: MajikContact[];
     groups: MajikContactGroup[];
+    stamps: MajikSignatureStampJSON[];
     preferences: UserAppPreferences | null;
-    /** @internal Raw manager JSON — used by restoreAppDataSelective, not for display */
     _contactsManagerJSON: MajikContactManagerJSON;
 }

package/dist/core/client-state-manager.js

@@ -226,4 +226,9 @@ export const DEFAULT_USER_APP_PREFERENCES = {
     privacy: {
         shareAnalytics: true,
     },
+    security: {
+        key: {
+            autoLockOnMinimize: false,
+        },
+    },
 };

package/dist/core/stamp/majik-signature-stamp-manager.d.ts

@@ -0,0 +1,57 @@
+import { type BatchLockResult, type MajikFileIdentity } from "@majikah/majik-file";
+import { MajikSignatureStamp, MajikSignatureStampJSON, StampAssetKind, CreateStampOptions } from "./majik-signature-stamp";
+import { StorageQuery } from "../storage/storage-adapter";
+import { MajikSignatureStampStorageAdapter } from "../storage";
+import { MajikKey } from "@majikah/majik-key";
+export declare class MajikSignatureStampManagerError extends Error {
+    cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare class MajikSignatureStampManager {
+    private readonly _cache;
+    private _decryptErrors;
+    private _adapter;
+    constructor(adapter?: MajikSignatureStampStorageAdapter);
+    get adapter(): MajikSignatureStampStorageAdapter;
+    setAdapter(adapter: MajikSignatureStampStorageAdapter): void;
+    hydrate(): Promise<void>;
+    /**
+     * Hydrate every stamp for `fingerprint`. If `key` is given (must be
+     * unlocked, matching that fingerprint), each stamp is decrypted so its
+     * plaintext is ready for preview. Stamps that fail to decrypt are
+     * silently excluded from the cache — never a hard throw. Reasons are
+     * kept in getDecryptError() for optional diagnostics.
+     *
+     * NOTE: this intentionally does NOT call MajikFile.batchDecrypt() —
+     * that method gates on MajikFile.canDecrypt(), which currently compares
+     * key.fingerprint against a list of public keys and will reject every
+     * file. Once that's fixed upstream, this can call batchDecrypt() directly
+     * instead of looping decryptHydrate() manually.
+     */
+    hydrateForFingerprint(fingerprint: string, key?: MajikKey): Promise<void>;
+    getDecryptError(id: string): string | undefined;
+    /** Wipe decrypted plaintext from every currently cached stamp's MajikFile.
+     *  MajikFile.batchLock() has no canDecrypt-style gate, safe to use as-is. */
+    lockAll(): BatchLockResult;
+    toJSON(): Promise<MajikSignatureStampJSON[]>;
+    bulkRestoreFromJSON(data: MajikSignatureStampJSON[]): Promise<void>;
+    static fromJSON(data: MajikSignatureStampJSON[], adapter?: MajikSignatureStampStorageAdapter): Promise<MajikSignatureStampManager>;
+    private _persist;
+    create(options: CreateStampOptions): Promise<MajikSignatureStamp>;
+    save(stamp: MajikSignatureStamp): Promise<void>;
+    load(id: string): Promise<MajikSignatureStamp | null>;
+    getStampOrThrow(id: string): Promise<MajikSignatureStamp>;
+    loadAll(): Promise<MajikSignatureStamp[]>;
+    delete(id: string): Promise<void>;
+    has(id: string): Promise<boolean>;
+    get(id: string): MajikSignatureStamp | undefined;
+    list(): MajikSignatureStamp[];
+    listByKind(kind: StampAssetKind): MajikSignatureStamp[];
+    listByFingerprint(fingerprint: string): MajikSignatureStamp[];
+    query(query: StorageQuery<MajikSignatureStampJSON>): Promise<MajikSignatureStampJSON[]>;
+    rename(id: string, newName: string): Promise<MajikSignatureStamp>;
+    /** Write-once at the MajikFile layer — id is preserved explicitly. */
+    replaceContent(id: string, rawBytes: Uint8Array, identity: MajikFileIdentity, mimeType?: string): Promise<MajikSignatureStamp>;
+    decryptContent(id: string, identity: Pick<MajikFileIdentity, "fingerprint" | "mlKemSecretKey">): Promise<Uint8Array>;
+    bulkRemove(ids: string[]): Promise<void>;
+}

package/dist/core/stamp/majik-signature-stamp-manager.js

@@ -0,0 +1,216 @@
+import { MajikFile, } from "@majikah/majik-file";
+import { MajikSignatureStamp, } from "./majik-signature-stamp";
+import { InMemoryStampstoreAdapter, } from "../storage";
+export class MajikSignatureStampManagerError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = "MajikSignatureStampManagerError";
+        this.cause = cause;
+    }
+}
+export class MajikSignatureStampManager {
+    _cache = new Map();
+    _decryptErrors = new Map();
+    _adapter;
+    constructor(adapter) {
+        this._adapter = adapter ?? new InMemoryStampstoreAdapter();
+    }
+    get adapter() {
+        return this._adapter;
+    }
+    setAdapter(adapter) {
+        this._adapter = adapter;
+    }
+    // ── Hydration ─────────────────────────────────────────────────────────
+    async hydrate() {
+        this._cache.clear();
+        const all = await this._adapter.list();
+        for (const json of all) {
+            try {
+                const stamp = MajikSignatureStamp.fromJSON(json);
+                this._cache.set(stamp.id, stamp);
+            }
+            catch (err) {
+                console.warn(`MajikSignatureStampManager.hydrate: skipping malformed stamp "${json?.id}":`, err);
+            }
+        }
+    }
+    /**
+     * Hydrate every stamp for `fingerprint`. If `key` is given (must be
+     * unlocked, matching that fingerprint), each stamp is decrypted so its
+     * plaintext is ready for preview. Stamps that fail to decrypt are
+     * silently excluded from the cache — never a hard throw. Reasons are
+     * kept in getDecryptError() for optional diagnostics.
+     *
+     * NOTE: this intentionally does NOT call MajikFile.batchDecrypt() —
+     * that method gates on MajikFile.canDecrypt(), which currently compares
+     * key.fingerprint against a list of public keys and will reject every
+     * file. Once that's fixed upstream, this can call batchDecrypt() directly
+     * instead of looping decryptHydrate() manually.
+     */
+    async hydrateForFingerprint(fingerprint, key) {
+        this._cache.clear();
+        this._decryptErrors.clear();
+        const rows = this._adapter.query
+            ? await this._adapter.query({ where: { fingerprint } })
+            : (await this._adapter.list()).filter((r) => r.fingerprint === fingerprint);
+        const stamps = [];
+        for (const json of rows) {
+            try {
+                stamps.push(MajikSignatureStamp.fromJSON(json));
+            }
+            catch (err) {
+                console.warn(`hydrateForFingerprint: skipping malformed stamp "${json?.id}":`, err);
+            }
+        }
+        if (!key) {
+            for (const s of stamps)
+                this._cache.set(s.id, s);
+            return;
+        }
+        const results = await Promise.allSettled(stamps.map((stamp) => stamp.toMajikFile().decryptHydrate(key)));
+        results.forEach((result, i) => {
+            const stamp = stamps[i];
+            if (result.status === "fulfilled") {
+                this._cache.set(stamp.id, stamp);
+            }
+            else {
+                this._decryptErrors.set(stamp.id, result.reason instanceof Error
+                    ? result.reason.message
+                    : String(result.reason));
+            }
+        });
+    }
+    getDecryptError(id) {
+        return this._decryptErrors.get(id);
+    }
+    /** Wipe decrypted plaintext from every currently cached stamp's MajikFile.
+     *  MajikFile.batchLock() has no canDecrypt-style gate, safe to use as-is. */
+    lockAll() {
+        const files = this.list().map((s) => s.toMajikFile());
+        return MajikFile.batchLock(files);
+    }
+    // ── Serialization ─────────────────────────────────────────────────────
+    async toJSON() {
+        return this._adapter.list();
+    }
+    async bulkRestoreFromJSON(data) {
+        if (!Array.isArray(data)) {
+            throw new MajikSignatureStampManagerError("bulkRestoreFromJSON: expected MajikSignatureStampJSON[]");
+        }
+        await this._adapter.bulkSave(data);
+        await this.hydrate();
+    }
+    static async fromJSON(data, adapter) {
+        const manager = new MajikSignatureStampManager(adapter);
+        await manager.bulkRestoreFromJSON(data);
+        return manager;
+    }
+    async _persist(stamp) {
+        await this._adapter.save(stamp.toJSON());
+    }
+    // ── Core CRUD ───────────────────────────────────────────────────────────
+    async create(options) {
+        const stamp = await MajikSignatureStamp.create(options);
+        await this._persist(stamp);
+        this._cache.set(stamp.id, stamp);
+        return stamp;
+    }
+    async save(stamp) {
+        await this._persist(stamp);
+        this._cache.set(stamp.id, stamp);
+    }
+    async load(id) {
+        const cached = this._cache.get(id);
+        if (cached)
+            return cached;
+        const json = await this._adapter.getById(id);
+        if (!json)
+            return null;
+        const stamp = MajikSignatureStamp.fromJSON(json);
+        this._cache.set(stamp.id, stamp);
+        return stamp;
+    }
+    async getStampOrThrow(id) {
+        const stamp = await this.load(id);
+        if (!stamp)
+            throw new MajikSignatureStampManagerError(`Stamp not found: ${id}`);
+        return stamp;
+    }
+    async loadAll() {
+        const all = await this._adapter.list();
+        for (const json of all) {
+            if (!this._cache.has(json.id)) {
+                try {
+                    const stamp = MajikSignatureStamp.fromJSON(json);
+                    this._cache.set(stamp.id, stamp);
+                }
+                catch (err) {
+                    console.warn(`MajikSignatureStampManager.loadAll: skipping malformed stamp "${json?.id}":`, err);
+                }
+            }
+        }
+        return [...this._cache.values()];
+    }
+    async delete(id) {
+        await this._adapter.remove(id);
+        this._cache.delete(id);
+    }
+    async has(id) {
+        if (this._cache.has(id))
+            return true;
+        return this._adapter.exists(id);
+    }
+    get(id) {
+        return this._cache.get(id);
+    }
+    list() {
+        return [...this._cache.values()];
+    }
+    listByKind(kind) {
+        return this.list().filter((s) => s.kind === kind);
+    }
+    listByFingerprint(fingerprint) {
+        return this.list().filter((s) => s.fingerprint === fingerprint);
+    }
+    async query(query) {
+        if (!this._adapter.query) {
+            throw new MajikSignatureStampManagerError("query: current adapter does not support query()");
+        }
+        return this._adapter.query(query);
+    }
+    // ── Mutations ───────────────────────────────────────────────────────────
+    async rename(id, newName) {
+        const stamp = await this.getStampOrThrow(id);
+        stamp.rename(newName);
+        await this._persist(stamp);
+        return stamp;
+    }
+    /** Write-once at the MajikFile layer — id is preserved explicitly. */
+    async replaceContent(id, rawBytes, identity, mimeType) {
+        const existing = await this.getStampOrThrow(id);
+        const replacement = await MajikSignatureStamp.create({
+            id: existing.id,
+            data: rawBytes,
+            identity,
+            kind: existing.kind,
+            name: existing.name,
+            mimeType: mimeType ?? existing.mimeType ?? undefined,
+        });
+        await this._persist(replacement);
+        this._cache.set(replacement.id, replacement);
+        return replacement;
+    }
+    async decryptContent(id, identity) {
+        const stamp = await this.getStampOrThrow(id);
+        return stamp.decryptContent(identity);
+    }
+    async bulkRemove(ids) {
+        if (ids.length === 0)
+            return;
+        await this._adapter.bulkRemove(ids);
+        for (const id of ids)
+            this._cache.delete(id);
+    }
+}

package/dist/core/stamp/majik-signature-stamp.d.ts

@@ -0,0 +1,64 @@
+import { MajikFile } from "@majikah/majik-file";
+import type { MajikFileDecryptIdentity, MajikFileIdentity, MajikFileJSON } from "@majikah/majik-file";
+export type StampAssetKind = "image" | "audio" | "video" | "text";
+export interface MajikSignatureStampJSON {
+    id: string;
+    kind: StampAssetKind;
+    name: string;
+    mimeType: string | null;
+    sizeBytes: number;
+    fingerprint: string;
+    data: string;
+    timestamp: string;
+    lastUpdate: string;
+    /** Full MajikFile metadata — required to reconstruct a working MajikFile
+     *  instance via MajikFile.fromJSON() for decryptHydrate()/secureLock(). */
+    fileJson: MajikFileJSON;
+}
+export interface CreateStampOptions {
+    data: Uint8Array | ArrayBuffer;
+    identity: MajikFileIdentity;
+    kind: StampAssetKind;
+    name: string;
+    mimeType?: string;
+    /** Pass the existing id back in when replacing content on a stamp that
+     *  already exists — MajikFile is write-once, so this is a *new* encrypted
+     *  artifact under the hood, but the id stays stable for the caller. */
+    id?: string;
+}
+export declare class MajikSignatureStamp {
+    private readonly _id;
+    private readonly _kind;
+    private _name;
+    private readonly _mimeType;
+    private readonly _sizeBytes;
+    private readonly _fingerprint;
+    private readonly _timestamp;
+    private readonly _fileJson;
+    private _file;
+    private _lastUpdate;
+    private _encryptedBinary;
+    private constructor();
+    get id(): string;
+    get kind(): StampAssetKind;
+    get name(): string;
+    get mimeType(): string | null;
+    get sizeBytes(): number;
+    get fingerprint(): string;
+    get timestamp(): string;
+    get lastUpdate(): string;
+    static create(options: CreateStampOptions): Promise<MajikSignatureStamp>;
+    /** Plaintext-only rename — no re-encryption, no MajikFile involvement. */
+    rename(newName: string): void;
+    toJSON(): MajikSignatureStampJSON;
+    static fromJSON(json: MajikSignatureStampJSON): MajikSignatureStamp;
+    /** Reconstruct (or return the cached) MajikFile backing this stamp. */
+    toMajikFile(): MajikFile;
+    /** Cached decrypted bytes, if hydrateForFingerprint()/decryptHydrate() has
+     *  already run for this stamp this session. Undefined otherwise, or after
+     *  a lock. */
+    get decryptedBytes(): Uint8Array | undefined;
+    /** Accepts a full MajikKey OR a bare {fingerprint, mlKemSecretKey} —
+     *  matches MajikFile's own MajikFileDecryptIdentity shape. */
+    decryptContent(identity: MajikFileDecryptIdentity): Promise<Uint8Array>;
+}

package/dist/core/stamp/majik-signature-stamp.js

@@ -0,0 +1,131 @@
+// majik-signature-stamp.ts
+import { MajikFile } from "@majikah/majik-file";
+import { arrayToBase64, base64ToUint8Array } from "../utils/utilities";
+export class MajikSignatureStamp {
+    _id;
+    _kind;
+    _name;
+    _mimeType;
+    _sizeBytes;
+    _fingerprint;
+    _timestamp;
+    _fileJson;
+    _file = null; // reconstructed lazily, cached per instance
+    _lastUpdate;
+    _encryptedBinary; // the .mjkb bytes — never the plaintext
+    constructor(json, binary) {
+        this._id = json.id;
+        this._kind = json.kind;
+        this._name = json.name;
+        this._mimeType = json.mimeType;
+        this._sizeBytes = json.sizeBytes;
+        this._fingerprint = json.fingerprint;
+        this._timestamp = json.timestamp;
+        this._lastUpdate = json.lastUpdate;
+        this._encryptedBinary = binary;
+        this._fileJson = json.fileJson;
+    }
+    get id() {
+        return this._id;
+    }
+    get kind() {
+        return this._kind;
+    }
+    get name() {
+        return this._name;
+    }
+    get mimeType() {
+        return this._mimeType;
+    }
+    get sizeBytes() {
+        return this._sizeBytes;
+    }
+    get fingerprint() {
+        return this._fingerprint;
+    }
+    get timestamp() {
+        return this._timestamp;
+    }
+    get lastUpdate() {
+        return this._lastUpdate;
+    }
+    // ── CREATE ──────────────────────────────────────────────────────────────
+    static async create(options) {
+        const { data, identity, kind, name, mimeType, id } = options;
+        if (!data)
+            throw new Error("MajikSignatureStamp.create: data is required");
+        if (!identity)
+            throw new Error("MajikSignatureStamp.create: identity is required");
+        if (!name?.trim())
+            throw new Error("MajikSignatureStamp.create: name is required");
+        const file = await MajikFile.create({
+            id,
+            data,
+            identity,
+            context: "user_upload",
+            originalName: name,
+            mimeType,
+            userId: identity.fingerprint,
+        });
+        const fileJson = file.toJSON();
+        const now = new Date().toISOString();
+        const binary = file.toBinaryBytes();
+        const json = {
+            id: fileJson.id,
+            kind,
+            name,
+            mimeType: fileJson.mime_type,
+            sizeBytes: fileJson.size_original,
+            fingerprint: identity.fingerprint,
+            data: arrayToBase64(binary),
+            timestamp: fileJson.timestamp ?? now,
+            lastUpdate: fileJson.last_update ?? now,
+            fileJson,
+        };
+        const instance = new MajikSignatureStamp(json, binary);
+        instance._file = file; // reuse — already fully constructed, no need to refetch
+        return instance;
+    }
+    /** Plaintext-only rename — no re-encryption, no MajikFile involvement. */
+    rename(newName) {
+        if (!newName?.trim())
+            throw new Error("rename: name must be non-empty");
+        this._name = newName.trim();
+        this._lastUpdate = new Date().toISOString();
+    }
+    toJSON() {
+        return {
+            id: this._id,
+            kind: this._kind,
+            name: this._name,
+            mimeType: this._mimeType,
+            sizeBytes: this._sizeBytes,
+            fingerprint: this._fingerprint,
+            data: arrayToBase64(this._encryptedBinary),
+            timestamp: this._timestamp,
+            lastUpdate: this._lastUpdate,
+            fileJson: this._fileJson,
+        };
+    }
+    static fromJSON(json) {
+        return new MajikSignatureStamp(json, base64ToUint8Array(json.data));
+    }
+    /** Reconstruct (or return the cached) MajikFile backing this stamp. */
+    toMajikFile() {
+        if (!this._file) {
+            this._file = MajikFile.fromJSON(this._fileJson, this._encryptedBinary);
+        }
+        return this._file;
+    }
+    /** Cached decrypted bytes, if hydrateForFingerprint()/decryptHydrate() has
+     *  already run for this stamp this session. Undefined otherwise, or after
+     *  a lock. */
+    get decryptedBytes() {
+        return this._file?.hasDecryptedFile ? this._file.decryptedFile : undefined;
+    }
+    /** Accepts a full MajikKey OR a bare {fingerprint, mlKemSecretKey} —
+     *  matches MajikFile's own MajikFileDecryptIdentity shape. */
+    async decryptContent(identity) {
+        return MajikFile.decrypt(this._encryptedBinary, identity);
+    }
+}

package/dist/core/storage/client-state/_types.d.ts

@@ -33,6 +33,7 @@ export interface UserAppPreferences {
     general: GeneralPreferences;
     signing: SigningPreferences;
     privacy: PrivacyPreferences;
+    security: SecurityPreferences;
 }
 export interface GeneralPreferences {
     history?: HistoryPreferences;
@@ -47,6 +48,13 @@ export interface SigningPreferences {
 export interface PrivacyPreferences {
     shareAnalytics?: boolean;
 }
+export interface SecurityPreferences {
+    key?: KeyPreferences;
+}
+export interface KeyPreferences {
+    autoLockOnMinimize?: boolean;
+    autoLockInterval?: number;
+}
 /**
  * Pluggable persistence backend for client-level state.
  *

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

@@ -18,3 +18,7 @@ export * from "./keystore/adapter-idb";
 export * from "./keystore/adapter-sql";
 export * from "./keystore/adapter-memory";
 export type * from "./keystore/_types";
+export * from "./stamps/adapter-idb";
+export * from "./stamps/adapter-sql";
+export * from "./stamps/adapter-memory";
+export type * from "./stamps/_types";

package/dist/core/storage/index.js

@@ -14,3 +14,6 @@ export * from "./contact-directory/groups/adapter-memory";
 export * from "./keystore/adapter-idb";
 export * from "./keystore/adapter-sql";
 export * from "./keystore/adapter-memory";
+export * from "./stamps/adapter-idb";
+export * from "./stamps/adapter-sql";
+export * from "./stamps/adapter-memory";

package/dist/core/storage/sql-schema.d.ts

@@ -9,6 +9,7 @@ export declare const MAJIKAH_SQL_TABLES: {
     readonly MAJIK_KEYS: "majik_keys";
     readonly MAJIK_CONTACTS: "majik_contacts";
     readonly MAJIK_CONTACT_GROUPS: "majik_contact_groups";
+    readonly MAJIK_SIGNATURE_STAMPS: "majik_signature_stamps";
 };
 export type MajikahSQLTable = (typeof MAJIKAH_SQL_TABLES)[keyof typeof MAJIKAH_SQL_TABLES];
 export declare function buildSchemaSQL(schemas: MajikahSQLSchema[]): MajikahSQLSchema;
@@ -16,5 +17,6 @@ export declare const MAJIKAH_SQL_SCHEMA_MAJIK_CLIENT_STATE: MajikahSQLSchema;
 export declare const MAJIKAH_SQL_SCHEMA_MAJIK_KEYS: MajikahSQLSchema;
 export declare const MAJIKAH_SQL_SCHEMA_MAJIK_CONTACTS: MajikahSQLSchema;
 export declare const MAJIKAH_SQL_SCHEMA_MAJIK_CONTACT_GROUPS: MajikahSQLSchema;
+export declare const MAJIKAH_SQL_SCHEMA_MAJIK_SIGNATURE_STAMPS: MajikahSQLSchema;
 export declare const MAJIKAH_SQL_SCHEMA_FULL: MajikahSQLSchema;
 export {};

package/dist/core/storage/sql-schema.js

@@ -8,6 +8,7 @@ export const MAJIKAH_SQL_TABLES = {
     MAJIK_KEYS: "majik_keys",
     MAJIK_CONTACTS: "majik_contacts",
     MAJIK_CONTACT_GROUPS: "majik_contact_groups",
+    MAJIK_SIGNATURE_STAMPS: "majik_signature_stamps",
 };
 function normalizeSQL(sql) {
     return sql
@@ -76,9 +77,35 @@ CREATE TABLE IF NOT EXISTS ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS} (
 CREATE INDEX IF NOT EXISTS idx_majik_contact_groups_created_at
 ON ${MAJIKAH_SQL_TABLES.MAJIK_CONTACT_GROUPS}(created_at);
 `;
+export const MAJIKAH_SQL_SCHEMA_MAJIK_SIGNATURE_STAMPS = `
+CREATE TABLE IF NOT EXISTS ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS} (
+  id TEXT PRIMARY KEY,
+  json TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  name TEXT NOT NULL,
+  mime_type TEXT,
+  size_bytes INTEGER NOT NULL,
+  fingerprint TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_majik_signature_stamps_kind
+ON ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS}(kind);
+
+CREATE INDEX IF NOT EXISTS idx_majik_signature_stamps_fingerprint
+ON ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS}(fingerprint);
+
+CREATE INDEX IF NOT EXISTS idx_majik_signature_stamps_updated_at
+ON ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS}(updated_at);
+
+CREATE INDEX IF NOT EXISTS idx_majik_signature_stamps_fingerprint_kind
+ON ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS}(fingerprint, kind);
+`;
 export const MAJIKAH_SQL_SCHEMA_FULL = buildSchemaSQL([
     MAJIKAH_SQL_SCHEMA_MAJIK_CLIENT_STATE,
     MAJIKAH_SQL_SCHEMA_MAJIK_KEYS,
     MAJIKAH_SQL_SCHEMA_MAJIK_CONTACTS,
     MAJIKAH_SQL_SCHEMA_MAJIK_CONTACT_GROUPS,
+    MAJIKAH_SQL_SCHEMA_MAJIK_SIGNATURE_STAMPS,
 ]);

package/dist/core/storage/stamps/_types.d.ts

@@ -0,0 +1,3 @@
+import { MajikSignatureStampJSON } from "../../stamp/majik-signature-stamp";
+import { MajikStorageAdapter } from "../storage-adapter";
+export type MajikSignatureStampStorageAdapter = MajikStorageAdapter<MajikSignatureStampJSON>;

package/dist/core/storage/stamps/_types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/storage/stamps/adapter-idb.d.ts

@@ -0,0 +1,3 @@
+import { MajikSignatureStampJSON } from "../../stamp/majik-signature-stamp";
+import { IDBGenericAdapter } from "../idb-adapter";
+export declare const IDB_ADAPTER_STAMPSTORE: IDBGenericAdapter<MajikSignatureStampJSON>;

package/dist/core/storage/stamps/adapter-idb.js

@@ -0,0 +1,5 @@
+import { IDBGenericAdapter } from "../idb-adapter";
+const IDB_DB_NAME = "majik-signature-stamps";
+const IDB_STORE_NAME = "stamps";
+const IDB_VERSION = 1;
+export const IDB_ADAPTER_STAMPSTORE = new IDBGenericAdapter(IDB_DB_NAME, IDB_STORE_NAME, IDB_VERSION);

package/dist/core/storage/stamps/adapter-memory.d.ts

@@ -0,0 +1,14 @@
+import { MajikSignatureStampJSON } from "../../stamp/majik-signature-stamp";
+import { MajikSignatureStampStorageAdapter } from "./_types";
+export declare class InMemoryStampstoreAdapter implements MajikSignatureStampStorageAdapter {
+    private _store;
+    save(item: MajikSignatureStampJSON): Promise<void>;
+    getById(id: string): Promise<MajikSignatureStampJSON | null>;
+    list(): Promise<MajikSignatureStampJSON[]>;
+    remove(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+    exists(id: string): Promise<boolean>;
+    bulkSave(items: MajikSignatureStampJSON[]): Promise<void>;
+    bulkRemove(ids: string[]): Promise<void>;
+}