@thezelijah/majik-message 1.0.4 → 1.0.6

package/dist/core/compressor/majik-compressor.d.ts

@@ -1,13 +1,14 @@
 type SupportedInput = string | object | ArrayBuffer | Uint8Array;
 export type MajikCompressorType = "str" | "json" | "blob";
+export type CompressionMode = "binary" | "plaintext";
 export declare class MajikCompressor {
     private static PREFIX;
     private static initialized;
     private static ensureInit;
     private static encodeInput;
     private static decodeOutput;
-    static compress(input: SupportedInput, level?: number): Promise<string>;
-    static decompress(compressedStr: string): Promise<string | Record<string, any> | Uint8Array>;
+    static compress(mode: CompressionMode, input: SupportedInput, level?: number): Promise<string>;
+    static decompress(mode: CompressionMode, compressedStr: string): Promise<string | Record<string, any> | Uint8Array>;
     static decompressJSON(compressedStr: string): Promise<Record<string, any>>;
     static decompressString(compressedStr: string): Promise<string>;
     static decompressBlob(compressedStr: string): Promise<Uint8Array>;

package/dist/core/compressor/majik-compressor.js

@@ -1,10 +1,11 @@
 import { init, compress as zstdCompress, decompress as zstdDecompress, } from "@bokuweb/zstd-wasm";
+import { gzipSync, gunzipSync } from "fflate";
 export class MajikCompressor {
     static PREFIX = "mjkcmp";
     static initialized = false;
     static async ensureInit() {
         if (!this.initialized) {
-            await init();
+            await init(); // only init Zstd for binary mode
             this.initialized = true;
         }
     }
@@ -32,37 +33,50 @@ export class MajikCompressor {
         throw new Error(`Unsupported type for decoding: ${type}`);
     }
     // --- Compress input and return string ---
-    static async compress(input, level = 9) {
-        await this.ensureInit();
+    static async compress(mode, input, level = 9) {
         const { type, data } = this.encodeInput(input);
-        const compressed = zstdCompress(data, level); // synchronous
+        let compressed;
+        if (mode === "binary") {
+            await this.ensureInit();
+            compressed = zstdCompress(data, level);
+        }
+        else {
+            // plaintext mode → fflate gzip
+            compressed = gzipSync(data);
+        }
         const b64 = this.uint8ArrayToBase64(compressed);
         return `${this.PREFIX}:${type}:${b64}`;
     }
     // --- Decompress string with prefix ---
-    static async decompress(compressedStr) {
-        await this.ensureInit();
+    static async decompress(mode, compressedStr) {
         if (!compressedStr.startsWith(`${this.PREFIX}:`))
             throw new Error("Invalid MajikCompressor string format");
         const [, type, b64] = compressedStr.split(":", 3);
         const compressedData = this.base64ToUint8Array(b64);
-        const decompressed = zstdDecompress(compressedData); // synchronous
+        let decompressed;
+        if (mode === "binary") {
+            await this.ensureInit();
+            decompressed = zstdDecompress(compressedData);
+        }
+        else {
+            decompressed = gunzipSync(compressedData);
+        }
         return this.decodeOutput(type, decompressed);
     }
     static async decompressJSON(compressedStr) {
-        const result = await this.decompress(compressedStr);
+        const result = await this.decompress("binary", compressedStr);
         if (typeof result === "object" && !(result instanceof Uint8Array))
             return result;
         throw new Error("Decompressed data is not JSON");
     }
     static async decompressString(compressedStr) {
-        const result = await this.decompress(compressedStr);
+        const result = await this.decompress("binary", compressedStr);
         if (typeof result === "string")
             return result;
         throw new Error("Decompressed data is not a string");
     }
     static async decompressBlob(compressedStr) {
-        const result = await this.decompress(compressedStr);
+        const result = await this.decompress("binary", compressedStr);
         if (result instanceof Uint8Array)
             return result;
         throw new Error("Decompressed data is not a blob");

package/dist/core/contacts/majik-contact.d.ts

@@ -1,3 +1,4 @@
+import { MajikMessageIdentityJSON } from "../database/system/identity";
 import { ISODateString } from "../types";
 export type SerializedMajikContact = Omit<MajikContactData, "publicKey"> & {
     publicKeyBase64: string;
@@ -48,6 +49,18 @@ export declare class MajikContact {
     setBlocked(blocked: boolean): this;
     block(): this;
     unblock(): this;
+    /**
+     * Support both CryptoKey and raw-key wrappers (fallbacks when WebCrypto X25519 unsupported)
+     */
+    getPublicKeyBase64(): Promise<string>;
     toJSON(): Promise<SerializedMajikContact>;
+    /**
+     * Reconstruct a MajikContact from its serialized form
+     */
+    static fromJSON(serialized: SerializedMajikContact): MajikContact;
+    /**
+     * Create a new MajikContact from a MajikMessageIdentityJSON
+     */
+    static fromIdentityJSON(identityJSON: MajikMessageIdentityJSON): Promise<MajikContact>;
     static isBlocked(contact: MajikContact): boolean;
 }

package/dist/core/contacts/majik-contact.js

@@ -1,4 +1,4 @@
-import { arrayBufferToBase64 } from "../utils/utilities";
+import { arrayBufferToBase64, base64ToArrayBuffer } from "../utils/utilities";
 /* -------------------------------
  * Errors
  * ------------------------------- */
@@ -103,32 +103,72 @@ export class MajikContact {
             this.setBlocked(false);
         return this;
     }
-    async toJSON() {
-        // Support both CryptoKey and raw-key wrappers (fallbacks when WebCrypto X25519 unsupported)
+    /**
+     * Support both CryptoKey and raw-key wrappers (fallbacks when WebCrypto X25519 unsupported)
+     */
+    async getPublicKeyBase64() {
         try {
             // If it's a CryptoKey, export with SubtleCrypto
             const raw = await crypto.subtle.exportKey("raw", this.publicKey);
-            return {
-                id: this.id,
-                fingerprint: this.fingerprint,
-                meta: { ...this.meta },
-                publicKeyBase64: arrayBufferToBase64(raw),
-            };
+            return arrayBufferToBase64(raw);
         }
         catch (e) {
             // Fallback: publicKey may be a wrapper with `raw` Uint8Array
             const maybe = this.publicKey;
             if (maybe && maybe.raw instanceof Uint8Array) {
-                return {
-                    id: this.id,
-                    fingerprint: this.fingerprint,
-                    meta: { ...this.meta },
-                    publicKeyBase64: arrayBufferToBase64(maybe.raw.buffer),
-                };
+                return arrayBufferToBase64(maybe.raw.buffer);
             }
             throw e;
         }
     }
+    async toJSON() {
+        return {
+            id: this.id,
+            fingerprint: this.fingerprint,
+            meta: { ...this.meta },
+            publicKeyBase64: await this.getPublicKeyBase64(),
+        };
+    }
+    /**
+     * Reconstruct a MajikContact from its serialized form
+     */
+    static fromJSON(serialized) {
+        try {
+            const publicKeyRaw = new Uint8Array(base64ToArrayBuffer(serialized.publicKeyBase64));
+            return new MajikContact({
+                id: serialized.id,
+                fingerprint: serialized.fingerprint,
+                meta: serialized.meta,
+                publicKey: { raw: publicKeyRaw },
+            });
+        }
+        catch (err) {
+            throw new MajikContactError("Failed to deserialize MajikContact", err);
+        }
+    }
+    /**
+     * Create a new MajikContact from a MajikMessageIdentityJSON
+     */
+    static async fromIdentityJSON(identityJSON) {
+        try {
+            const publicKeyRaw = new Uint8Array(base64ToArrayBuffer(identityJSON.public_key));
+            const contactData = {
+                id: identityJSON.id,
+                publicKey: { raw: publicKeyRaw },
+                fingerprint: identityJSON.id,
+                meta: {
+                    label: identityJSON.label,
+                    createdAt: identityJSON.timestamp,
+                    updatedAt: identityJSON.timestamp,
+                    blocked: identityJSON.restricted,
+                },
+            };
+            return new MajikContact(contactData);
+        }
+        catch (err) {
+            throw new MajikContactError("Failed to create MajikContact from MajikMessageIdentityJSON", err);
+        }
+    }
     static isBlocked(contact) {
         return !!contact.meta.blocked;
     }

package/dist/core/database/chat/majik-message-chat.js

@@ -142,7 +142,7 @@ export class MajikMessageChat {
         // Compress the message before storing
         let compressedMessage;
         try {
-            compressedMessage = await MajikCompressor.compress(message.trim());
+            compressedMessage = await MajikCompressor.compress("plaintext", message.trim());
         }
         catch (error) {
             throw new Error(`Failed to compress message: ${error instanceof Error ? error.message : "Unknown error"}`);

package/dist/core/database/system/identity.js

@@ -70,10 +70,11 @@ export class MajikMessageIdentity {
         const generatedID = autogenerateID();
         const timestamp = new Date().toISOString();
         const phash = sha256(`${user.id}:${account.id}:${generatedID}`);
+        const publicKey = account.publicKeyBase64;
         return new MajikMessageIdentity({
             id: generatedID,
             userId: user.id,
-            publicKey: account.id,
+            publicKey: publicKey,
             phash,
             label,
             timestamp,

package/dist/index.d.ts

@@ -13,3 +13,5 @@ export * from "./core/utils/APITranscoder";
 export * from "./core/utils/utilities";
 export * from "./core/database/chat/majik-message-chat";
 export type * from "./core/database/chat/types";
+export * from "./core/database/system/identity";
+export * from "./core/compressor/majik-compressor";

package/dist/index.js

@@ -11,3 +11,5 @@ export * from "./core/scanner/scanner-engine";
 export * from "./core/utils/APITranscoder";
 export * from "./core/utils/utilities";
 export * from "./core/database/chat/majik-message-chat";
+export * from "./core/database/system/identity";
+export * from "./core/compressor/majik-compressor";

package/package.json

@@ -2,7 +2,7 @@
   "name": "@thezelijah/majik-message",
   "type": "module",
   "description": "Encrypt and decrypt messages on any website. Secure chats with keypairs and seed-based accounts. Open source.",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "license": "Apache-2.0",
   "author": "Zelijah",
   "main": "./dist/index.js",
@@ -86,6 +86,7 @@
     "@stablelib/x25519": "^2.0.1",
     "ed2curve": "^0.3.0",
     "fernet": "^0.3.3",
+    "fflate": "^0.8.2",
     "idb": "^8.0.3",
     "nanoid": "^5.1.6"
   },