@majikah/majik-signature-client 0.2.0 → 0.3.0

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,37 @@
+import 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";
+export declare class MajikSignatureStampManagerError extends Error {
+    cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare class MajikSignatureStampManager {
+    private readonly _cache;
+    private _adapter;
+    constructor(adapter?: MajikSignatureStampStorageAdapter);
+    get adapter(): MajikSignatureStampStorageAdapter;
+    setAdapter(adapter: MajikSignatureStampStorageAdapter): void;
+    hydrate(): Promise<void>;
+    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,159 @@
+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();
+    _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);
+            }
+        }
+    }
+    // ── 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,52 @@
+import type { MajikFileIdentity } 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;
+}
+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 _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;
+    /** Decrypt and return the raw plaintext content bytes (image/audio/video/text). */
+    decryptContent(identity: Pick<MajikFileIdentity, "fingerprint" | "mlKemSecretKey">): Promise<Uint8Array>;
+    toBinaryBytes(): Uint8Array;
+}

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

@@ -0,0 +1,119 @@
+// 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;
+    _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;
+    }
+    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,
+        };
+        return new MajikSignatureStamp(json, binary);
+    }
+    /** 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();
+    }
+    // ── SERIALISATION ───────────────────────────────────────────────────────
+    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,
+        };
+    }
+    static fromJSON(json) {
+        return new MajikSignatureStamp(json, base64ToUint8Array(json.data));
+    }
+    // ── DECRYPT ─────────────────────────────────────────────────────────────
+    /** Decrypt and return the raw plaintext content bytes (image/audio/video/text). */
+    async decryptContent(identity) {
+        if (this._fingerprint !== identity.fingerprint) {
+            throw new Error(`decryptContent: stamp was encrypted under fingerprint "${this._fingerprint}", ` +
+                `but the provided identity has fingerprint "${identity.fingerprint}"`);
+        }
+        return MajikFile.decrypt(this._encryptedBinary, identity);
+    }
+    toBinaryBytes() {
+        return this._encryptedBinary;
+    }
+}

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>;
+}

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

@@ -0,0 +1,32 @@
+export class InMemoryStampstoreAdapter {
+    _store = new Map();
+    async save(item) {
+        this._store.set(item.id, item);
+    }
+    async getById(id) {
+        return this._store.get(id) ?? null;
+    }
+    async list() {
+        return Array.from(this._store.values());
+    }
+    async remove(id) {
+        return this._store.delete(id);
+    }
+    async clear() {
+        this._store.clear();
+    }
+    async count() {
+        return this._store.size;
+    }
+    async exists(id) {
+        return this._store.has(id);
+    }
+    async bulkSave(items) {
+        for (const item of items)
+            this._store.set(item.id, item);
+    }
+    async bulkRemove(ids) {
+        for (const id of ids)
+            this._store.delete(id);
+    }
+}

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

@@ -0,0 +1,18 @@
+import { MajikSignatureStampJSON } from "../../stamp/majik-signature-stamp";
+import { MajikSignatureStampStorageAdapter } from "./_types";
+import { SQLiteDatabase } from "../sql-db-manager";
+import { StorageQuery } from "../storage-adapter";
+export declare class SQLiteStampstoreAdapter implements MajikSignatureStampStorageAdapter {
+    private db;
+    constructor(db: SQLiteDatabase);
+    save(stamp: 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(stamps: MajikSignatureStampJSON[]): Promise<void>;
+    bulkRemove(ids: string[]): Promise<void>;
+    query(query: StorageQuery<MajikSignatureStampJSON>): Promise<MajikSignatureStampJSON[]>;
+}

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

@@ -0,0 +1,99 @@
+import { MAJIKAH_SQL_TABLES } from "../sql-schema";
+export class SQLiteStampstoreAdapter {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async save(stamp) {
+        await this.db.run(`INSERT OR REPLACE INTO ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS}
+       (id, json, kind, name, mime_type, size_bytes, fingerprint, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            stamp.id,
+            JSON.stringify(stamp),
+            stamp.kind,
+            stamp.name,
+            stamp.mimeType,
+            stamp.sizeBytes,
+            stamp.fingerprint,
+            stamp.timestamp,
+            stamp.lastUpdate,
+        ]);
+    }
+    async getById(id) {
+        const row = await this.db.get(`SELECT json FROM ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS} WHERE id = ?`, [id]);
+        return row ? JSON.parse(row.json) : null;
+    }
+    async list() {
+        const rows = await this.db.all(`SELECT json FROM ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS}`);
+        return rows.map((r) => JSON.parse(r.json));
+    }
+    async remove(id) {
+        const exists = await this.exists(id);
+        if (!exists)
+            return false;
+        await this.db.run(`DELETE FROM ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS} WHERE id = ?`, [id]);
+        return true;
+    }
+    async clear() {
+        await this.db.run(`DELETE FROM ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS}`);
+    }
+    async count() {
+        const row = await this.db.get(`SELECT COUNT(*) as n FROM ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS}`);
+        return row?.n ?? 0;
+    }
+    async exists(id) {
+        const row = await this.db.get(`SELECT 1 FROM ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS} WHERE id = ?`, [id]);
+        return !!row;
+    }
+    async bulkSave(stamps) {
+        if (stamps.length === 0)
+            return;
+        await this.db.transaction(async (tx) => {
+            for (const s of stamps) {
+                await tx.run(`INSERT OR REPLACE INTO ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS}
+           (id, json, kind, name, mime_type, size_bytes, fingerprint, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                    s.id,
+                    JSON.stringify(s),
+                    s.kind,
+                    s.name,
+                    s.mimeType,
+                    s.sizeBytes,
+                    s.fingerprint,
+                    s.timestamp,
+                    s.lastUpdate,
+                ]);
+            }
+        });
+    }
+    async bulkRemove(ids) {
+        if (ids.length === 0)
+            return;
+        await this.db.transaction(async (tx) => {
+            for (const id of ids) {
+                await tx.run(`DELETE FROM ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS} WHERE id = ?`, [id]);
+            }
+        });
+    }
+    async query(query) {
+        const clauses = [];
+        const values = [];
+        if (query.where) {
+            for (const [key, value] of Object.entries(query.where)) {
+                clauses.push(`${key} = ?`);
+                values.push(value);
+            }
+        }
+        let sql = `SELECT json FROM ${MAJIKAH_SQL_TABLES.MAJIK_SIGNATURE_STAMPS}`;
+        if (clauses.length > 0)
+            sql += ` WHERE ${clauses.join(" AND ")}`;
+        if (query.orderBy)
+            sql += ` ORDER BY ${String(query.orderBy)} ${query.orderDirection ?? "asc"}`;
+        if (query.limit)
+            sql += ` LIMIT ${query.limit}`;
+        if (query.offset)
+            sql += ` OFFSET ${query.offset}`;
+        const rows = await this.db.all(sql, values);
+        return rows.map((r) => JSON.parse(r.json));
+    }
+}

package/dist/core/types.d.ts

@@ -1,4 +1,5 @@
 import { MajikContactManagerJSON } from "./contacts/types";
+import { MajikSignatureStampJSON } from "./stamp/majik-signature-stamp";
 import { UserAppPreferences } from "./storage";
 export type ISODateString = string;
 export type MajikMessageAccountID = string;
@@ -88,5 +89,6 @@ export interface MajikKeyMetadata {
 }
 export interface AppBackUpData {
     contacts: MajikContactManagerJSON;
+    stamps?: MajikSignatureStampJSON[];
     preferences?: UserAppPreferences;
 }

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from "./core/contacts/majik-contact-groups";
 export * from "./core/crypto/constants";
 export * from "./core/crypto/keystore-manager";
 export * from "./core/storage";
+export * from "./core/stamp/majik-signature-stamp";
 export * from "./core/utils/utilities";
 export * from "./core/identity";
 export { migrateMajikMessageJSON } from "./core/contacts/majik-contact-migration";

package/dist/index.js

@@ -5,6 +5,7 @@ export * from "./core/contacts/majik-contact-groups";
 export * from "./core/crypto/constants";
 export * from "./core/crypto/keystore-manager";
 export * from "./core/storage";
+export * from "./core/stamp/majik-signature-stamp";
 export * from "./core/utils/utilities";
 export * from "./core/identity";
 export { migrateMajikMessageJSON } from "./core/contacts/majik-contact-migration";

package/dist/majik-signature-client.d.ts

@@ -23,10 +23,12 @@ import { MajikContactManager, MajikContactManagerAdapters } from "./core/contact
 import { MajikContactManagerJSON } from "./core/contacts/types";
 import { MajikContact, MajikContactGroup, MajikContactGroupMeta, MajikContactMeta, SerializedMajikContact } from "@majikah/majik-contact";
 import { ClientStateManager } from "./core/client-state-manager";
-import { ClientStateStorageAdapter, MajikKeyStorageAdapter, SQLiteDatabase, UserAppPreferences } from "./core/storage";
+import { ClientStateStorageAdapter, MajikKeyStorageAdapter, MajikSignatureStampStorageAdapter, SQLiteDatabase, UserAppPreferences } from "./core/storage";
 import { AppDataSnapshot, ContactManagerSnapshot } from "./core/backup/types";
 import { MnemonicLanguage } from "@majikah/majik-key/dist/core/crypto/wordlist";
-type MajikSignatureClientEvents = "sign" | "verify" | "unlock" | "lock" | "error" | "new-account" | "new-contact" | "new-contact-group" | "removed-account" | "removed-contact" | "removed-contact-group" | "contact-group-change" | "active-account-change" | "restore-backup";
+import { MajikSignatureStampManager } from "./core/stamp/majik-signature-stamp-manager";
+import { MajikSignatureStamp, MajikSignatureStampJSON, StampAssetKind } from "./core/stamp/majik-signature-stamp";
+type MajikSignatureClientEvents = "sign" | "verify" | "unlock" | "lock" | "error" | "new-stamp" | "removed-stamp" | "new-account" | "new-contact" | "new-contact-group" | "removed-account" | "removed-contact" | "removed-contact-group" | "contact-group-change" | "active-account-change" | "restore-backup";
 type EventCallback = (...args: any[]) => void;
 export interface MajikSignatureClientConfig {
     dbSQL?: SQLiteDatabase;
@@ -46,9 +48,11 @@ export interface MajikSignatureClientConfig {
      * is ignored.
      */
     clientStateManager?: ClientStateManager;
+    stampsManager?: MajikSignatureStampManager;
     adapters?: {
         contacts?: MajikContactManagerAdapters;
         keys?: MajikKeyStorageAdapter;
+        stamps?: MajikSignatureStampStorageAdapter;
         /**
          * Adapter for client-level state (account order, invoice defaults, etc.).
          * Defaults to IDB_ADAPTER_CLIENT_STATE in browser environments.
@@ -79,6 +83,7 @@ export declare class MajikSignatureClient {
     private _db;
     private _contacts;
     private _keys;
+    private _stamps;
     private _state;
     private _ownAccounts;
     private _ownAccountsOrder;
@@ -89,6 +94,8 @@ export declare class MajikSignatureClient {
     get keyManager(): MajikKeyManager;
     /** Expose the client state manager for direct access if needed. */
     get stateManager(): ClientStateManager;
+    /** Expose the stamp manager for direct access if needed. */
+    get stampManager(): MajikSignatureStampManager;
     /**
      * Load all domains from their adapters and restore client state.
      * Call once on startup.
@@ -824,6 +831,19 @@ export declare class MajikSignatureClient {
     isSealed(file: Blob, options?: {
         mimeType?: string;
     }): Promise<boolean>;
+    createStamp(data: Uint8Array | ArrayBuffer, kind: StampAssetKind, name: string, options?: {
+        mimeType?: string;
+        accountId?: string;
+    }): Promise<MajikSignatureStamp>;
+    listStamps(kind?: StampAssetKind): MajikSignatureStamp[];
+    getStamp(id: string): Promise<MajikSignatureStamp | null>;
+    decryptStampContent(id: string, accountId?: string): Promise<Uint8Array>;
+    renameStamp(id: string, newName: string): Promise<MajikSignatureStamp>;
+    replaceStampContent(id: string, data: Uint8Array | ArrayBuffer, options?: {
+        mimeType?: string;
+        accountId?: string;
+    }): Promise<MajikSignatureStamp>;
+    removeStamp(id: string): Promise<boolean>;
     /**
      * Sign an image with dual-layer embedding.
      *
@@ -941,6 +961,12 @@ export declare class MajikSignatureClient {
      * throughout MajikMessage — consistent account/contact resolution in one place.
      */
     private _resolveSignerPublicKeys;
+    /**
+     * Resolve a MajikFileIdentity from an unlocked account, for stamp
+     * encryption/decryption. Requires the account to have ML-KEM keys and
+     * to already be unlocked — call ensureIdentityUnlocked() first if needed.
+     */
+    private _resolveStampIdentity;
     /**
      * Wipe all data from every adapter and reset in-memory state.
      * The client remains usable — call hydrate() or add new accounts after reset.
@@ -948,6 +974,9 @@ export declare class MajikSignatureClient {
     resetData(): Promise<void>;
     private _registerOwnAccount;
     backupContacts(): Promise<Blob>;
+    backupStamps(): Promise<Blob>;
+    private _parseStampsBackup;
+    readStampsBackup(input: Blob | ArrayBufferLike | ArrayBufferView): Promise<MajikSignatureStampJSON[]>;
     backupAppData(): Promise<Blob>;
     /**
      * Parses a contacts backup blob into a ContactManagerSnapshot —
@@ -955,6 +984,9 @@ export declare class MajikSignatureClient {
      * No side-effects; nothing is written to the live store.
      */
     private _parseContactsBackup;
+    restoreStamps(input: Blob | ArrayBufferLike | ArrayBufferView): Promise<{
+        restored: number;
+    }>;
     /**
      * Restores contacts (and optionally groups) from a contacts backup blob.
      *
@@ -979,7 +1011,7 @@ export declare class MajikSignatureClient {
     readContactsBackup(input: Blob | ArrayBufferLike | ArrayBufferView): Promise<ContactManagerSnapshot>;
     /**
      * Restores all data from a full backup blob produced by `backupAppData()`.
-     * Contacts and groups are restored before chatMessages so recipients resolve
+     * Contacts and groups are restored before stamps so recipients resolve
      * correctly.
      */
     restoreAppData(blob: Blob): Promise<{
@@ -990,9 +1022,9 @@ export declare class MajikSignatureClient {
      * Probes the first bytes of a blob and returns which backup type it is,
      * without fully parsing it. Useful for file-picker validation UI.
      *
-     * @returns `"chats" | "contacts" | "appData" | "unknown"`
+     * @returns `"stamps" | "contacts" | "appData" | "unknown"`
      */
-    static probeBackupType(blob: Blob): Promise<"chats" | "contacts" | "appData" | "unknown">;
+    static probeBackupType(blob: Blob): Promise<"stamps" | "contacts" | "appData" | "unknown">;
     /**
      * Parses an app data backup blob into an AppDataSnapshot.
      * No side-effects; nothing is written to the live store.
@@ -1008,6 +1040,7 @@ export declare class MajikSignatureClient {
      * The caller controls exactly which domains are written.
      */
     restoreAppDataSelective(snapshot: AppDataSnapshot, options?: {
+        stamps?: boolean;
         contacts?: boolean;
         groups?: boolean;
         preferences?: boolean;

package/dist/majik-signature-client.js

@@ -19,15 +19,18 @@ import { MajikSignature } from "@majikah/majik-signature";
 import { base64ToUint8Array } from "./core/utils/utilities";
 import { MajikContactManager, } from "./core/contacts/majik-contact-manager";
 import { ClientStateManager } from "./core/client-state-manager";
-import { InMemoryClientStateAdapter, InMemoryKeystoreAdapter, } from "./core/storage";
+import { InMemoryClientStateAdapter, InMemoryKeystoreAdapter, InMemoryStampstoreAdapter, } from "./core/storage";
 import { MajikCompressedJSON } from "@majikah/majik-cjson";
 import { prependMagic, readBackupBlob } from "./core/backup/utils";
-import { MAJIK_MESSAGE_BACKUP_MAGIC, MAJIK_MESSAGE_BACKUP_MAGIC_SIZE, } from "./core/backup/constants";
+import { MAJIK_SIGNATURE_BACKUP_MAGIC, MAJIK_MESSAGE_BACKUP_MAGIC_SIZE, } from "./core/backup/constants";
+import { MajikSignatureStampManager } from "./core/stamp/majik-signature-stamp-manager";
+import { MajikSignatureStamp, } from "./core/stamp/majik-signature-stamp";
 // ─── MajikSignatureClient ─────────────────────────────────────────────────────
 export class MajikSignatureClient {
     _db;
     _contacts;
     _keys;
+    _stamps;
     _state;
     _ownAccounts = new Map();
     _ownAccountsOrder = [];
@@ -41,8 +44,9 @@ export class MajikSignatureClient {
         this._keys =
             config.keyManager ??
                 new MajikKeyManager(config.adapters?.keys ?? new InMemoryKeystoreAdapter());
-        // this._chats =
-        // config.
+        this._stamps =
+            config.stampsManager ??
+                new MajikSignatureStampManager(config.adapters?.stamps ?? new InMemoryStampstoreAdapter());
         this._state =
             config.clientStateManager ??
                 new ClientStateManager(config.adapters?.clientState ?? new InMemoryClientStateAdapter());
@@ -52,6 +56,8 @@ export class MajikSignatureClient {
             "unlock",
             "lock",
             "error",
+            "new-stamp",
+            "removed-stamp",
             "new-account",
             "new-contact",
             "new-contact-group",
@@ -72,6 +78,10 @@ export class MajikSignatureClient {
     get stateManager() {
         return this._state;
     }
+    /** Expose the stamp manager for direct access if needed. */
+    get stampManager() {
+        return this._stamps;
+    }
     // ── Hydration ─────────────────────────────────────────────────────────────
     /**
      * Load all domains from their adapters and restore client state.
@@ -87,6 +97,7 @@ export class MajikSignatureClient {
         await this._keys.hydrate();
         // 2. Contacts + groups
         await this._contacts.hydrate();
+        await this._stamps.hydrate();
         // 4. Client state — account order, app settings, etc.
         await this._state.hydrate();
         // 5. Own accounts — rebuild from keys loaded in step 1
@@ -1642,6 +1653,51 @@ export class MajikSignatureClient {
             throw err;
         }
     }
+    // ── Stamps (encrypted reusable assets — signatures, audio, video, text) ────
+    async createStamp(data, kind, name, options) {
+        try {
+            const identity = this._resolveStampIdentity(options?.accountId);
+            const stamp = await this._stamps.create({
+                data,
+                identity,
+                kind,
+                name,
+                mimeType: options?.mimeType,
+            });
+            this._emit("new-stamp", stamp);
+            return stamp;
+        }
+        catch (err) {
+            this._emit("error", err, { context: "createStamp" });
+            throw err;
+        }
+    }
+    listStamps(kind) {
+        return kind ? this._stamps.listByKind(kind) : this._stamps.list();
+    }
+    async getStamp(id) {
+        return this._stamps.load(id);
+    }
+    async decryptStampContent(id, accountId) {
+        const identity = this._resolveStampIdentity(accountId);
+        return this._stamps.decryptContent(id, identity);
+    }
+    async renameStamp(id, newName) {
+        return this._stamps.rename(id, newName);
+    }
+    async replaceStampContent(id, data, options) {
+        const identity = this._resolveStampIdentity(options?.accountId);
+        const raw = data instanceof Uint8Array ? data : new Uint8Array(data);
+        return this._stamps.replaceContent(id, raw, identity, options?.mimeType);
+    }
+    async removeStamp(id) {
+        const existed = await this._stamps.has(id);
+        if (!existed)
+            return false;
+        await this._stamps.delete(id);
+        this._emit("removed-stamp", id);
+        return true;
+    }
     // ── STAMP (compression-resistant image signing) ───────────────────────────
     //
     // These methods delegate to MajikImageSignature, passing `MajikSignature`
@@ -1815,6 +1871,33 @@ export class MajikSignatureClient {
         }
         return null;
     }
+    /**
+     * Resolve a MajikFileIdentity from an unlocked account, for stamp
+     * encryption/decryption. Requires the account to have ML-KEM keys and
+     * to already be unlocked — call ensureIdentityUnlocked() first if needed.
+     */
+    _resolveStampIdentity(accountId) {
+        const id = accountId ?? this.getActiveAccount()?.id;
+        if (!id)
+            throw new Error("No active account — call setActiveAccount() first");
+        const key = this._keys.get(id);
+        if (!key)
+            throw new Error(`Account not found in keystore: "${id}"`);
+        if (key.isLocked) {
+            throw new Error(`Account "${id}" is locked. Call unlockAccount() before using stamps.`);
+        }
+        const mlKemSecretKey = this._keys.getMlKemSecretKey(id);
+        if (!mlKemSecretKey) {
+            throw new Error(`Account "${id}" has no ML-KEM keys. Re-import via ` +
+                `importAccountFromMnemonicBackup() to enable stamp encryption.`);
+        }
+        return {
+            publicKey: key.publicKeyBase64,
+            fingerprint: key.fingerprint,
+            mlKemPublicKey: key.mlKemPublicKey,
+            mlKemSecretKey,
+        };
+    }
     // ==========================================================================
     // ── RESET ─────────────────────────────────────────────────────────────────
     // ==========================================================================
@@ -1826,6 +1909,7 @@ export class MajikSignatureClient {
         try {
             await this._keys.adapter.clear();
             await this._contacts.clear();
+            await this._stamps.adapter.clear(); // NEW
             await this._state.clear();
             if (this._db) {
                 await this._db.vacuum();
@@ -1834,6 +1918,7 @@ export class MajikSignatureClient {
             this._ownAccounts.clear();
             this._ownAccountsOrder = [];
             this._keys = new MajikKeyManager(this._keys.adapter);
+            this._stamps = new MajikSignatureStampManager(this._stamps.adapter); // NEW
             this._emit("active-account-change", null);
         }
         catch (err) {
@@ -1864,21 +1949,40 @@ export class MajikSignatureClient {
         const managerJSON = await this._contacts.toJSON();
         const cj = MajikCompressedJSON.create(managerJSON);
         const payload = cj.toBinary();
-        const stamped = prependMagic(MAJIK_MESSAGE_BACKUP_MAGIC.contacts, payload);
+        const stamped = prependMagic(MAJIK_SIGNATURE_BACKUP_MAGIC.contacts, payload);
+        return new Blob([stamped], {
+            type: "application/octet-stream",
+        });
+    }
+    async backupStamps() {
+        const stampsJSON = await this._stamps.toJSON();
+        const cj = MajikCompressedJSON.create(stampsJSON);
+        const payload = cj.toBinary();
+        const stamped = prependMagic(MAJIK_SIGNATURE_BACKUP_MAGIC.stamps, payload);
         return new Blob([stamped], {
             type: "application/octet-stream",
         });
     }
+    async _parseStampsBackup(input) {
+        const payload = await readBackupBlob(input, MAJIK_SIGNATURE_BACKUP_MAGIC.stamps, "stamps");
+        const cj = await MajikCompressedJSON.fromMJKCJSON(payload);
+        return cj.payload;
+    }
+    async readStampsBackup(input) {
+        return this._parseStampsBackup(input);
+    }
     async backupAppData() {
         const contactsJSON = await this._contacts.toJSON();
+        const stampsJSON = await this._stamps.toJSON(); // NEW
         const userPref = await this.getUserAppPreferences();
         const backupJSON = {
             contacts: contactsJSON,
+            stamps: stampsJSON, // NEW
             preferences: userPref ?? undefined,
         };
         const cj = MajikCompressedJSON.create(backupJSON);
         const payload = cj.toBinary();
-        const stamped = prependMagic(MAJIK_MESSAGE_BACKUP_MAGIC.appData, payload);
+        const stamped = prependMagic(MAJIK_SIGNATURE_BACKUP_MAGIC.appData, payload);
         return new Blob([stamped], {
             type: "application/octet-stream",
         });
@@ -1893,7 +1997,7 @@ export class MajikSignatureClient {
      * No side-effects; nothing is written to the live store.
      */
     async _parseContactsBackup(input) {
-        const payload = await readBackupBlob(input, MAJIK_MESSAGE_BACKUP_MAGIC.contacts, "contacts");
+        const payload = await readBackupBlob(input, MAJIK_SIGNATURE_BACKUP_MAGIC.contacts, "contacts");
         const cj = await MajikCompressedJSON.fromMJKCJSON(payload);
         const managerJSON = cj.payload;
         // Hydrate a throw-away manager so callers get real instances, not raw JSON
@@ -1904,13 +2008,11 @@ export class MajikSignatureClient {
         return { managerJSON, contacts, groups };
     }
     // ── Public restore (saves to store) ───────────────────────────────────────
-    // async restoreChatMessages(
-    //   input: Blob | ArrayBufferLike | ArrayBufferView,
-    // ): Promise<{ restored: number }> {
-    //   const chatMessages = await this._parseChatMessagesBackup(input);
-    //   await Promise.all(chatMessages.map((inv) => this._chatMessages.save(inv)));
-    //   return { restored: chatMessages.length };
-    // }
+    async restoreStamps(input) {
+        const stampsJSON = await this._parseStampsBackup(input);
+        await Promise.all(stampsJSON.map((json) => this._stamps.save(MajikSignatureStamp.fromJSON(json))));
+        return { restored: stampsJSON.length };
+    }
     /**
      * Restores contacts (and optionally groups) from a contacts backup blob.
      *
@@ -1956,11 +2058,6 @@ export class MajikSignatureClient {
         return { contacts: contactCount, groups: groupCount };
     }
     // ── Public read (no side-effects) ─────────────────────────────────────────
-    // async readInvoicesBackup(
-    //   input: Blob | ArrayBufferLike | ArrayBufferView,
-    // ): Promise<MajikInvoice[]> {
-    //   return this._parseInvoicesBackup(input);
-    // }
     /**
      * Parses a contacts backup without writing anything to the live store.
      * Returns contacts and user-defined groups for the caller to preview.
@@ -1970,11 +2067,11 @@ export class MajikSignatureClient {
     }
     /**
      * Restores all data from a full backup blob produced by `backupAppData()`.
-     * Contacts and groups are restored before chatMessages so recipients resolve
+     * Contacts and groups are restored before stamps so recipients resolve
      * correctly.
      */
     async restoreAppData(blob) {
-        const payload = await readBackupBlob(blob, MAJIK_MESSAGE_BACKUP_MAGIC.appData, "app data");
+        const payload = await readBackupBlob(blob, MAJIK_SIGNATURE_BACKUP_MAGIC.appData, "app data");
         const cj = await MajikCompressedJSON.fromMJKCJSON(payload);
         const data = cj.payload;
         // 1. Contacts
@@ -1998,13 +2095,12 @@ export class MajikSignatureClient {
                 }
             }
         }
-        // 2. Chats
-        // await Promise.all(
-        //   (data.chatMessages ?? []).map((json) => {
-        //     const invoice = MajikInvoice.fromJSON(json);
-        //     return this._chatMessages.save(invoice);
-        //   }),
-        // );
+        // 2. Stamps
+        // inside restoreAppData(), after the contacts/groups block:
+        await Promise.all((data.stamps ?? []).map((json) => {
+            const stamp = MajikSignatureStamp.fromJSON(json);
+            return this._stamps.save(stamp);
+        }));
         if (data.preferences) {
             await this.setUserAppPreferences(data.preferences);
         }
@@ -2017,11 +2113,11 @@ export class MajikSignatureClient {
      * Probes the first bytes of a blob and returns which backup type it is,
      * without fully parsing it. Useful for file-picker validation UI.
      *
-     * @returns `"chats" | "contacts" | "appData" | "unknown"`
+     * @returns `"stamps" | "contacts" | "appData" | "unknown"`
      */
     static async probeBackupType(blob) {
         const header = new Uint8Array(await blob.slice(0, MAJIK_MESSAGE_BACKUP_MAGIC_SIZE).arrayBuffer());
-        for (const [type, magic] of Object.entries(MAJIK_MESSAGE_BACKUP_MAGIC)) {
+        for (const [type, magic] of Object.entries(MAJIK_SIGNATURE_BACKUP_MAGIC)) {
             if (magic.every((byte, i) => header[i] === byte))
                 return type;
         }
@@ -2033,7 +2129,7 @@ export class MajikSignatureClient {
      * No side-effects; nothing is written to the live store.
      */
     async _parseAppDataBackup(input) {
-        const payload = await readBackupBlob(input, MAJIK_MESSAGE_BACKUP_MAGIC.appData, "app data");
+        const payload = await readBackupBlob(input, MAJIK_SIGNATURE_BACKUP_MAGIC.appData, "app data");
         const cj = await MajikCompressedJSON.fromMJKCJSON(payload);
         const data = cj.payload;
         const tempManager = await MajikContactManager.fromJSON(data.contacts);
@@ -2042,8 +2138,8 @@ export class MajikSignatureClient {
         return {
             contacts,
             groups,
+            stamps: data.stamps ?? [], // NEW
             preferences: data.preferences ?? null,
-            // Keep raw manager JSON for the restore path
             _contactsManagerJSON: data.contacts,
         };
     }
@@ -2061,15 +2157,13 @@ export class MajikSignatureClient {
      * The caller controls exactly which domains are written.
      */
     async restoreAppDataSelective(snapshot, options = {}) {
-        const { 
-        // chatMessages: doChatMessages = true,
-        contacts: doContacts = true, groups: doGroups = true, preferences: doPreferences = true, overwriteContacts = true, } = options;
-        let invoiceCount = 0;
+        const { stamps: doStamps = true, contacts: doContacts = true, groups: doGroups = true, preferences: doPreferences = true, overwriteContacts = true, } = options;
+        let stampCount = 0;
         let contactCount = 0;
         let groupCount = 0;
         let defaultsRestored = false;
         let preferencesRestored = false;
-        // 1. Contacts first — chatMessages may reference them
+        // 1. Contacts first
         if (doContacts) {
             for (const contact of snapshot.contacts) {
                 const exists = !!this._contacts.getContact(contact.id);
@@ -2097,20 +2191,18 @@ export class MajikSignatureClient {
                 groupCount++;
             }
         }
-        // 3. Chats
-        // if (doChatMessages) {
-        //   await Promise.all(
-        //     snapshot.chats.map((inv) => this._chatMessages.save(inv)),
-        //   );
-        //   invoiceCount = snapshot.chatMessages.length;
-        // }
+        // 3. Stamps
+        if (doStamps) {
+            await Promise.all(snapshot.stamps.map((json) => this._stamps.save(MajikSignatureStamp.fromJSON(json))));
+            stampCount = snapshot.stamps.length;
+        }
         // 5. App preferences
         if (doPreferences && snapshot.preferences) {
             await this.setUserAppPreferences(snapshot.preferences);
             preferencesRestored = true;
         }
         const restoredData = {
-            chatMessages: invoiceCount,
+            stamps: stampCount,
             contacts: contactCount,
             groups: groupCount,
             invoiceDefaults: defaultsRestored,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@majikah/majik-signature-client",
   "type": "module",
   "description": "Majik Signature Client is a hybrid post-quantum content signing and verification library for the Majikah ecosystem. Built on top of Majik Key, it provides tamper-proof, forgery-resistant digital signatures for any content format — using a dual-algorithm architecture that combines classical Ed25519 with post-quantum ML-DSA-87 (FIPS-204).",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "Apache-2.0",
   "author": "Zelijah",
   "main": "./dist/index.js",
@@ -54,6 +54,7 @@
   "dependencies": {
     "@majikah/majik-cjson": "^0.0.3",
     "@majikah/majik-contact": "^0.0.6",
+    "@majikah/majik-file": "^0.1.7",
     "@majikah/majik-key": "^0.2.12",
     "@majikah/majik-signature": "^0.0.30",
     "@stablelib/ed25519": "^2.1.0",