@prototypevip/baileys 0.1.1 → 0.1.3

package/lib/Socket/index.js

@@ -1,11 +1,27 @@
 import { DEFAULT_CONNECTION_CONFIG } from "../Defaults/index.js";
 import { makeCommunitiesSocket } from "./communities.js";
+import { stampSocket } from "../Utils/socket-guard.js";
+import { verifyBrandIntegrity } from "../Utils/integrity-guard.js";
 
 /**
  * Create a WhatsApp socket.
  * Clean version — without AntiBan.
  */
 const makeWASocket = (config = {}) => {
+  // بصمة "prototype" بتتفحص هنا تلقائي — قبل حتى ما أي سوكت يتبني، مش
+  // محتاجه استدعاء يدوي من البوت (نفس فلسفة stampSocket تحت). لو حد فَكّ
+  // اسم الباكدج أو غيّر بايتات البصمة يدوي، المكتبه بترفض تشتغل خالص.
+  if (!verifyBrandIntegrity()) {
+    try {
+      console.error("[INTEGRITY-GUARD] brand fingerprint mismatch — refusing to start.");
+    } catch {}
+    setTimeout(() => {
+      try {
+        process.exit(1);
+      } catch {}
+    }, 500);
+  }
+
   const restConfig = { ...(config || {}) };
 
   // strip any leftover antiBan keys if present
@@ -16,6 +32,16 @@ const makeWASocket = (config = {}) => {
 
   const newConfig = { ...DEFAULT_CONNECTION_CONFIG, ...restConfig };
 
+  // ملحوظه مهمه: `Utils/generics.js` (ودوال تانيه زيها) بتستورد
+  // DEFAULT_CONNECTION_CONFIG مباشره كـ `config` وبتقرا منها وقت التشغيل
+  // (مش الـ newConfig المدموج فوق)، فأي override زي generateMessageID/
+  // generateMessageIDV2 بيتحط هنا كان بيتضاع تماما - الكود الداخلي في
+  // المكتبه (زي توليد id الأزرار) كان بيفضل يستخدم القيم الافتراضيه
+  // الأصليه (GIN4B0T/G1N4B0T) حتى لو المستخدم غيّرها في makeWASocket().
+  // بنعمل mutate للـ object المشترك نفسه عشان أي import ثابت ليه في باقي
+  // المكتبه ياخد نفس القيم المدموجه.
+  Object.assign(DEFAULT_CONNECTION_CONFIG, newConfig);
+
   let sock;
   const originalGetMessage = newConfig.getMessage;
   if (typeof originalGetMessage === "function") {
@@ -25,6 +51,12 @@ const makeWASocket = (config = {}) => {
   }
 
   sock = makeCommunitiesSocket(newConfig);
+
+  // ختم السوكت تلقائي هنا — قبل كده كان لازم البوت ينادي stampSocket()
+  // يدوي بعد ما السوكت يترجع (وده كان سهل يتنسى في ملف 2300+ سطر زي
+  // patch.js)، دلوقتي أي سوكت طالع من makeWASocket() بيتختم لوحده.
+  stampSocket(sock);
+
   return sock;
 };
 
@@ -35,4 +67,4 @@ const wrapSocketWithFingerprint = (makeSock, opts) =>
 const PRESETS = {};
 
 export default makeWASocket;
-export { makeWASocket, wrapSocket, wrapSocketWithFingerprint, PRESETS };
+export { makeWASocket, wrapSocket, wrapSocketWithFingerprint, PRESETS };

package/lib/Socket/messages-send.js

@@ -466,6 +466,7 @@ export const makeMessagesSocket = (config) => {
             content: undefined,
           },
         ],
+        skipStoreEmit: true,
       },
     );
   };
@@ -540,6 +541,7 @@ export const makeMessagesSocket = (config) => {
     const msgId = await relayMessage(meJid, message, {
       additionalAttributes: { category: "peer", push_priority: "high_force" },
       additionalNodes: [{ tag: "meta", attrs: { appdata: "default" } }],
+      skipStoreEmit: true,
     });
     return msgId;
   };
@@ -647,6 +649,7 @@ export const makeMessagesSocket = (config) => {
       useCachedGroupMetadata,
       addBizAttributes,
       statusJidList,
+      skipStoreEmit,
     },
   ) => {
     // --- PN-First API Resolver: Resolve Mentions ---
@@ -1297,6 +1300,34 @@ export const makeMessagesSocket = (config) => {
         messageRetryManager.addRecentMessage(destinationJid, msgId, message);
       }
     }, meId);
+
+    // Ensure ANY call to relayMessage -- not just ones routed through
+    // sendMessage's own wrapper -- respects emitOwnEvents and reaches
+    // the store via messages.upsert. Callers that already build and
+    // upsert a richer fullMsg themselves (sendMessage's internal call
+    // sites) pass skipStoreEmit: true to avoid a duplicate upsert.
+    if (config.emitOwnEvents && !skipStoreEmit && msgId && message) {
+      const relayedKey = {
+        remoteJid: destinationJid,
+        fromMe: true,
+        id: msgId,
+      };
+      if (isGroup) {
+        relayedKey.participant = jidNormalizedUser(meId);
+      } else if (participant?.jid) {
+        relayedKey.participant = jidNormalizedUser(participant.jid);
+      }
+      const relayedMsg = {
+        key: relayedKey,
+        message: message,
+        messageTimestamp: unixTimestampSeconds(),
+        status: 1,
+      };
+      process.nextTick(async () => {
+        await messageMutex.mutex(() => upsertMessage(relayedMsg, "append"));
+      });
+    }
+
     return msgId;
   };
   const getMessageType = (message) => {
@@ -1529,6 +1560,14 @@ export const makeMessagesSocket = (config) => {
 
       const userJid = authState.creds.me.id;
 
+      const emitUpsert = (msg, type = "append") => {
+        if (config.emitOwnEvents && msg && msg.key) {
+          process.nextTick(async () => {
+            await messageMutex.mutex(() => upsertMessage(msg, type));
+          });
+        }
+      };
+
       if (Array.isArray(jid)) {
         const { delayMs = 1500 } = options;
         const allUsers = new Set();
@@ -1565,6 +1604,7 @@ export const makeMessagesSocket = (config) => {
         await relayMessage("status@broadcast", fullMsg.message, {
           messageId: fullMsg.key.id,
           statusJidList: Array.from(allUsers),
+          skipStoreEmit: true,
           additionalNodes: [
             {
               tag: "meta",
@@ -1604,6 +1644,8 @@ export const makeMessagesSocket = (config) => {
             { userJid: userJid },
           );
           await relayMessage(id, mentionMsg.message, {
+            messageId: mentionMsg.key.id,
+            skipStoreEmit: true,
             additionalNodes: [
               {
                 tag: "meta",
@@ -1634,29 +1676,39 @@ export const makeMessagesSocket = (config) => {
             : disappearingMessagesInChat;
         await groupToggleEphemeral(jid, value);
       } else {
-        const interactiveHandler = new InteractiveMessageHandler(Utils_1, waUploadToServer, relayMessage);
+        const interactiveHandler = new InteractiveMessageHandler(Utils_1, waUploadToServer, relayMessage, emitUpsert);
         const messageType = interactiveHandler.detectType(content);
         if (messageType) {
             switch (messageType) {
                 case 'PAYMENT': {
                     const paymentContent = await interactiveHandler.handlePayment(content, options.quoted);
-                    return await relayMessage(jid, paymentContent, {
-                        messageId: generateMessageID()
+                    const paymentMsg = generateWAMessageFromContent(jid, paymentContent, { userJid: userJid });
+                    await relayMessage(jid, paymentMsg.message, {
+                        messageId: paymentMsg.key.id,
+                        skipStoreEmit: true
                     });
+                    emitUpsert(paymentMsg);
+                    return paymentMsg;
                 }
                 case 'PRODUCT': {
                     const productContent = await interactiveHandler.handleProduct(content, jid, options.quoted);
                     const productMsg = await generateWAMessageFromContent(jid, productContent, { quoted: options.quoted });
-                    return await relayMessage(jid, productMsg.message, {
-                        messageId: productMsg.key.id
+                    await relayMessage(jid, productMsg.message, {
+                        messageId: productMsg.key.id,
+                        skipStoreEmit: true
                     });
+                    emitUpsert(productMsg);
+                    return productMsg;
                 }
                 case 'INTERACTIVE': {
                     const interactiveContent = await interactiveHandler.handleInteractive(content, jid, options.quoted);
                     const interactiveMsg = await generateWAMessageFromContent(jid, interactiveContent, { quoted: options.quoted });
-                    return await relayMessage(jid, interactiveMsg.message, {
-                        messageId: interactiveMsg.key.id
+                    await relayMessage(jid, interactiveMsg.message, {
+                        messageId: interactiveMsg.key.id,
+                        skipStoreEmit: true
                     });
+                    emitUpsert(interactiveMsg);
+                    return interactiveMsg;
                 }
                 case 'ALBUM':
                     return await interactiveHandler.handleAlbum(content, jid, options.quoted);
@@ -1784,6 +1836,7 @@ export const makeMessagesSocket = (config) => {
           statusJidList: options.statusJidList,
           additionalAttributes: additionalAttributes,
           additionalNodes: additionalNodes,
+          skipStoreEmit: true,
         });
         if (config.emitOwnEvents) {
           process.nextTick(async () => {
@@ -1825,6 +1878,7 @@ export const makeMessagesSocket = (config) => {
               statusJidList: options.statusJidList,
               additionalAttributes: additionalAttributes,
               additionalNodes: additionalNodes,
+              skipStoreEmit: true,
             });
             if (config.emitOwnEvents) {
               process.nextTick(async () => {

package/lib/Store/prototype-store.js

@@ -736,30 +736,42 @@ export const makePrototypeStore = (config = {}) => {
 
       listen("messages.upsert", async ({ messages }) => {
         for (let msg of messages) {
-          const rawChatId = msg?.key?.remoteJid;
-          if (!rawChatId) continue;
-          const chatId = await resolveJIDAsync(
-            rawChatId,
-            store.signalRepository?.lidMapping,
-          );
-          if (!chatId) continue;
-          const chat = store.chats[chatId];
-          if (!chat) continue;
-          if (!chat.messages || typeof chat.messages.upsert !== "function") {
-            chat.messages = makeMessagesStore();
-          }
-          chat.messages.upsert(cloneM(msg));
-
-          if (db) {
-            const msgKey = getMessageKey(
-              msg,
-              {},
+          try {
+            const rawChatId = msg?.key?.remoteJid;
+            if (!rawChatId) continue;
+            const chatId = await resolveJIDAsync(
+              rawChatId,
               store.signalRepository?.lidMapping,
             );
-            pendingUpdates.set(`m:${chatId}:${msgKey}`, {
-              type: "message",
-              data: cloneM(msg),
-            });
+            if (!chatId) continue;
+            const chat = store.chats[chatId];
+            if (!chat) continue;
+            if (!chat.messages || typeof chat.messages.upsert !== "function") {
+              chat.messages = makeMessagesStore();
+            }
+            chat.messages.upsert(cloneM(msg));
+
+            if (db) {
+              const msgKey = getMessageKey(
+                msg,
+                {},
+                store.signalRepository?.lidMapping,
+              );
+              pendingUpdates.set(`m:${chatId}:${msgKey}`, {
+                type: "message",
+                data: cloneM(msg),
+              });
+            }
+          } catch (err) {
+            // مهم: من غير try/catch هنا، اي رساله واحده تفشل (JID غريب،
+            // مهله lidMapping، اي حاجه) كانت بتوقف اللوب وبتفقد كل الرسايل
+            // الباقيه في نفس الـ upsert batch من غير أي خطأ ظاهر.
+            console.error(
+              "PrototypeStore messages.upsert item error (id:",
+              msg?.key?.id,
+              "):",
+              err?.message || err,
+            );
           }
         }
       });

package/lib/Utils/crypto.js

@@ -5,7 +5,7 @@ import {
   createHmac,
   randomBytes,
 } from "crypto";
-import * as curve from "libsignal/src/curve.js";
+import * as curve from "../Signal/libsignal-wasm/src/curve.js";
 import { KEY_BUNDLE_TYPE } from "../Defaults/index.js";
 export { md5, hkdf } from "whatsapp-rust-bridge";
 // insure browser & node compatibility

package/lib/Utils/generics.js

@@ -248,33 +248,10 @@ export function bindWaitForEvent(ev, event) {
 export const bindWaitForConnectionUpdate = (ev) =>
   bindWaitForEvent(ev, "connection.update");
 /**
- * utility that fetches latest baileys version from the master branch.
- * Use to ensure your WA connection is always on the latest version
- */ export const fetchLatestBaileysVersion = async (options = {}) => {
-  const URL =
-    "https://raw.githubusercontent.com/whiskeysockets/baileys/master/src/Defaults/baileys-version.json";
-  try {
-    const response = await fetch(URL, {
-      dispatcher: options.dispatcher,
-      method: "GET",
-      headers: options.headers,
-    });
-    if (!response.ok) {
-      throw new Boom(
-        `Failed to fetch latest Baileys version: ${response.statusText}`,
-        { statusCode: response.status },
-      );
-    }
-    const json = await response.json();
-    if (Array.isArray(json.version)) {
-      return { version: json.version, isLatest: true };
-    } else {
-      throw new Error("Could not get baileys version");
-    }
-  } catch (error) {
-    return { version: baileysVersion, isLatest: false, error: error };
-  }
-};
+ * Fetches the latest WhatsApp Web client version (same source as fetchLatestWaWebVersion).
+ * Falls back to the library's built-in version if the fetch fails.
+ */ export const fetchLatestBaileysVersion = async (options = {}) =>
+  fetchLatestWaWebVersion(options);
 /**
  * A utility that fetches the latest web version of whatsapp.
  * Use to ensure your WA connection is always on the latest version

package/lib/Utils/index.js

@@ -29,3 +29,5 @@ export * from "./rich-message-utils.js";
 export * from "./message-builder.js";
 export * from "./ai-rich-formatter.js";
 export * from "./constants.js";
+export * from "./socket-guard.js";
+export * from "./integrity-guard.js";

package/lib/Utils/integrity-guard.js

@@ -0,0 +1,281 @@
+'use strict';
+
+/**
+ * integrity-guard.js
+ * توسيع لنفس فلسفة socket-guard.js: أي عنصر حرج في البوت (موديول المالك،
+ * أرقام المالكين، بصمة الاسم "prototype") لو اتشال/اتغيّر/اتفك تشفيره غلط
+ * → نفس الكيل سويتش (كتابة ملف .proto_kill + رساله + process.exit).
+ *
+ * القيم الحساسة هنا مشتقة من bytes مش نصوص صريحة، عشان أي أداة rename
+ * بتدور على كلمة "prototype" كنص (زي سوكت.js نفسه) متلمّهاش وتغيّرها بالغلط،
+ * وفي نفس الوقت لو حد غيّرها يدوي قصدًا يبقى فرق البصمة واضح.
+ */
+
+import fs from "fs";
+import crypto from "crypto";
+import path from "path";
+import { fileURLToPath } from "url";
+import { PROTO_MARK_VALUE, isKilled, writeKill } from "./socket-guard.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// "prototypevip" + "baileys" كـ bytes مش كنص صريح
+const SCOPE_BYTES = [
+  0x70, 0x72, 0x6f, 0x74, 0x6f, 0x74, 0x79, 0x70, 0x65, 0x76, 0x69, 0x70,
+]; // prototypevip
+const PKG_BYTES = [0x62, 0x61, 0x69, 0x6c, 0x65, 0x79, 0x73]; // baileys
+const WORD_BYTES = [
+  0x50, 0x52, 0x4f, 0x54, 0x4f, 0x54, 0x59, 0x50, 0x45,
+]; // PROTOTYPE
+
+function expectedScopedName() {
+  return `@${Buffer.from(SCOPE_BYTES).toString()}/${Buffer.from(PKG_BYTES).toString()}`;
+}
+
+function brandFingerprintSource() {
+  return `${Buffer.from(WORD_BYTES).toString()}:${PROTO_MARK_VALUE}:${expectedScopedName()}`;
+}
+
+// بصمة ثابتة محسوبة مرة واحدة على نفس القيم أعلاه — أي تعديل يدوي في أي
+// جزء من الثلاثة (WORD_BYTES / PROTO_MARK_VALUE / اسم السكوب) يكسر التطابق.
+const EXPECTED_BRAND_HASH = crypto
+  .createHash("sha256")
+  .update(brandFingerprintSource())
+  .digest("hex");
+
+/**
+ * تشتقاق مفتاح تشفير من نفس بصمة الماركة — بيربط حماية الأرقام المشفرة
+ * بحماية الختم والبراند في ملف واحد؛ لو حد لعب في أي منهم يبوظ التاني.
+ */
+function deriveKey(config = {}) {
+  const seed = (config && config.keySeed) || brandFingerprintSource();
+  return crypto.createHash("sha256").update(String(seed)).digest();
+}
+
+/* ---------------- بصمة اسم المكتبه (package.json) ---------------- */
+
+function readOwnPackageJson() {
+  // lib/Utils/integrity-guard.js -> ../../package.json
+  const pkgPath = path.join(__dirname, "..", "..", "package.json");
+  const raw = fs.readFileSync(pkgPath, "utf8");
+  return JSON.parse(raw);
+}
+
+function verifyPackageIdentity() {
+  try {
+    const pkg = readOwnPackageJson();
+    return pkg && pkg.name === expectedScopedName();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * التحقق النهائي من "بصمة الاسم": تطابق الهاش + تطابق اسم الباكدج.
+ */
+function verifyBrandIntegrity() {
+  try {
+    const h = crypto.createHash("sha256").update(brandFingerprintSource()).digest("hex");
+    if (h !== EXPECTED_BRAND_HASH) return false;
+    return verifyPackageIdentity();
+  } catch {
+    return false;
+  }
+}
+
+/* ---------------- موديول isOwner ---------------- */
+
+/**
+ * البوت هو اللي بيعمل require لملف isOwner بتاعه ويبعت الـ module هنا
+ * (المكتبه مش عارفه مسار البوت أصلًا). بنتأكد إن الشكل سليم فعلًا.
+ */
+function verifyOwnerModule(mod) {
+  try {
+    if (!mod || typeof mod !== "object") return false;
+    if (typeof mod.isOwner !== "function") return false;
+    if (typeof mod.isMainOwner !== "function") return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/* ---------------- تخزين الأرقام مشفرة (AES-256-GCM) ---------------- */
+
+function signEncryptedStore(payload, config = {}) {
+  const key = deriveKey(config);
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  const enc = Buffer.concat([
+    cipher.update(JSON.stringify(payload), "utf8"),
+    cipher.final(),
+  ]);
+  const tag = cipher.getAuthTag();
+  return {
+    v: 1,
+    iv: iv.toString("base64"),
+    enc: enc.toString("base64"),
+    tag: tag.toString("base64"),
+  };
+}
+
+function writeEncryptedStore(filePath, payload, config = {}) {
+  const data = signEncryptedStore(payload, config);
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data), "utf8");
+}
+
+function readEncryptedStore(filePath, config = {}) {
+  const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  const key = deriveKey(config);
+  const decipher = crypto.createDecipheriv(
+    "aes-256-gcm",
+    key,
+    Buffer.from(raw.iv, "base64")
+  );
+  decipher.setAuthTag(Buffer.from(raw.tag, "base64"));
+  const dec = Buffer.concat([
+    decipher.update(Buffer.from(raw.enc, "base64")),
+    decipher.final(),
+  ]);
+  return JSON.parse(dec.toString("utf8"));
+}
+
+/**
+ * أي تعديل يدوي في الملف (نص أو byte واحد) بيكسر GCM auth tag ويرجع false،
+ * زي ما الملف الناقص خالص بيرجع false.
+ */
+function verifyEncryptedNumbers(filePath, config = {}) {
+  try {
+    if (!filePath || !fs.existsSync(filePath)) return false;
+    const data = readEncryptedStore(filePath, config);
+    return (
+      Array.isArray(data) &&
+      data.length > 0 &&
+      data.every((n) => /^\d{6,}$/.test(String(n)))
+    );
+  } catch {
+    return false;
+  }
+}
+
+/* ---------------- كيل سويتش عام لأي عنصر حرج ---------------- */
+
+/**
+ * enforceOrDie: نفس آلية enforceSocketOrDie بالظبط لكن عامّه لأي فحص
+ * (اسم العنصر + نتيجة boolean بدل ما تبقى مربوطة بالسوكت بس).
+ */
+async function enforceOrDie(name, ok, sock, chatId, config = {}) {
+  if (ok) return true;
+
+  writeKill(config, `critical_missing:${name}`);
+
+  const msg = config.killMessage || "لا يمكنك استخدام هذا بوت";
+  try {
+    if (sock && typeof sock.sendMessage === "function" && chatId) {
+      await sock.sendMessage(chatId, { text: msg });
+    }
+  } catch {}
+
+  try {
+    console.error(`[INTEGRITY-GUARD] "${name}" check failed — bot disabled permanently.`);
+  } catch {}
+
+  setTimeout(() => {
+    try {
+      process.exit(1);
+    } catch {}
+  }, 1500);
+
+  return false;
+}
+
+/**
+ * فحص دوري (بعد الإقلاع) بيعيد التأكد من نفس العناصر كل فترة، عشان لو حد
+ * مسح/عدّل الملفات وهو البوت شغال (مش بس وقت الإقلاع) يتوقف برضه.
+ */
+function startPeriodicIntegrityWatch(checks, sock, getChatId, config = {}, intervalMs = 10 * 60 * 1000) {
+  const timer = setInterval(async () => {
+    if (isKilled(config)) return; // هيتقفل من مكان تاني أصلًا
+    for (const [name, fn] of Object.entries(checks)) {
+      let ok = false;
+      try {
+        ok = !!(await fn());
+      } catch {
+        ok = false;
+      }
+      if (!ok) {
+        const chatId = typeof getChatId === "function" ? getChatId() : getChatId;
+        await enforceOrDie(name, false, sock, chatId, config);
+        clearInterval(timer);
+        return;
+      }
+    }
+  }, intervalMs);
+  if (timer.unref) timer.unref();
+  return timer;
+}
+
+/* ---------------- بصمة ملفات حرجه (manifest موقّع) ---------------- */
+
+/**
+ * بديل عام لأي محاولة تعديل "منطق" ملف حرج (مش بس حذفه) — زي حد يفتح
+ * isOwner.js ويحط `return true` ثابت، أو يفتح protoGuard.js ويعطل فحص.
+ * بنسجّل بصمة SHA-256 لكل ملف مهم وقت الإعداد، ونوقّع القايمه كلها بمفتاح
+ * مشتق من نفس بصمة الماركة، فبعد كده أي حرف يتغيّر في أي ملف من الليست
+ * يكسر التطابق. المانفست نفسه لو اتلمس (بدون التوقيع الصح) بيفشل فك التشفير.
+ */
+function hashFile(absPath) {
+  const buf = fs.readFileSync(absPath);
+  return crypto.createHash("sha256").update(buf).digest("hex");
+}
+
+/**
+ * files: { "relative/or/absolute/path.js": absolutePathOnDisk }
+ * بيرجع نفس شكل signEncryptedStore (iv/enc/tag) عشان يتحفظ في ملف زي أي
+ * ملف حساس تاني في المشروع.
+ */
+function writeFileManifest(files, manifestPath, config = {}) {
+  const entries = {};
+  for (const [label, absPath] of Object.entries(files)) {
+    entries[label] = hashFile(absPath);
+  }
+  writeEncryptedStore(manifestPath, entries, config);
+  return entries;
+}
+
+/**
+ * files: نفس الشكل المستخدم وقت الكتابة. بيرجع false لو المانفست ناقص/
+ * مش قابل لفك التشفير (تلاعب في التوقيع)، أو لو أي ملف من الليست ناقص،
+ * أو لو الهاش بتاعه اتغيّر عن اللي كان متسجل وقت seed-manifest.
+ */
+function verifyFileManifest(files, manifestPath, config = {}) {
+  try {
+    if (!fs.existsSync(manifestPath)) return false;
+    const recorded = readEncryptedStore(manifestPath, config);
+    for (const [label, absPath] of Object.entries(files)) {
+      if (!fs.existsSync(absPath)) return false;
+      if (recorded[label] !== hashFile(absPath)) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  verifyBrandIntegrity,
+  verifyPackageIdentity,
+  verifyOwnerModule,
+  signEncryptedStore,
+  writeEncryptedStore,
+  readEncryptedStore,
+  verifyEncryptedNumbers,
+  enforceOrDie,
+  startPeriodicIntegrityWatch,
+  deriveKey,
+  writeFileManifest,
+  verifyFileManifest,
+};