fca-phantom 1.0.0

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "fca-phantom",
+  "version": "1.0.0",
+  "type": "commonjs",
+  "description": "PHANTOM-FCA by SIFAT — a powerful Facebook Chat API (FCA) for Node.js with session revival, E2EE encryption, real-time MQTT messaging, and smart rate control. Fast, reliable, and built to last.",
+  "main": "index.js",
+  "types": "phantom/datastore/models/types/index.d.ts",
+  "files": [
+    "index.js",
+    "phantom/",
+    "LICENSE",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ewr-sifu/phantom-fca.git"
+  },
+  "author": "phantom-fca",
+  "license": "MIT",
+  "keywords": [
+    "phantom",
+    "phantom-fca",
+    "sifu",
+    "sifu-fca",
+    "fca",
+    "fca-unofficial",
+    "sifat",
+    "sdk",
+    "api",
+    "facebook",
+    "messenger",
+    "chat",
+    "bot",
+    "mqtt",
+    "stealth",
+    "anti-suspension",
+    "automation",
+    "session-revival"
+  ],
+  "dependencies": {
+    "axios": "^1.9.0",
+    "axios-cookiejar-support": "^4.0.7",
+    "bluebird": "^3.7.2",
+    "cheerio": "^1.0.0",
+    "deepdash": "^5.3.9",
+    "duplexify": "^4.1.3",
+    "form-data": "^4.0.4",
+    "https-proxy-agent": "^7.0.6",
+    "jsonpath-plus": "^10.3.0",
+    "lodash": "^4.17.21",
+    "mqtt": "^4.3.8",
+    "node-cron": "^3.0.3",
+    "npmlog": "^7.0.1",
+    "sequelize": "^6.37.5",
+    "sqlite3": "^6.0.1",
+    "totp-generator": "^2.0.1",
+    "tough-cookie": "^5.1.2",
+    "undici": "^7.8.0",
+    "uuid": "^11.1.0",
+    "websocket-stream": "^5.5.2",
+    "ws": "^8.18.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.17",
+    "eslint": "^9.26.0",
+    "mocha": "^11.3.0",
+    "prettier": "^3.5.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "test": "echo 'No tests configured yet'",
+    "lint": "eslint phantom/",
+    "format": "prettier --write phantom/**/*.js"
+  },
+  "overrides": {
+    "undici": "^7.8.0",
+    "ws": "^8.18.2",
+    "tough-cookie": "^5.1.2",
+    "glob": "^11.0.2",
+    "prebuild-install": "^7.1.3",
+    "npmlog": "^7.0.1",
+    "are-we-there-yet": "^4.0.2",
+    "gauge": "^5.0.2",
+    "serialize-javascript": "^6.0.2",
+    "cacache": "^18.0.4",
+    "make-fetch-happen": "^13.0.3",
+    "@tootallnate/once": "^3.0.1",
+    "mocha": {
+      "serialize-javascript": "^6.0.2",
+      "debug": "^4.4.0",
+      "diff": "^7.0.0",
+      "js-yaml": "^4.1.0",
+      "minimatch": "^10.0.1",
+      "glob": "^11.0.2"
+    }
+  }
+}

package/phantom/core/builder/bootstrap.js

@@ -0,0 +1,334 @@
+"use strict";
+
+const tools = require("../../datastore/models/matrix/tools");
+const axios  = require("axios");
+const path   = require("path");
+const fs     = require("fs");
+const qs     = require("querystring");
+const { normalizeCookieHeaderString, setJarFromPairs } = require("../../datastore/models/matrix/transform/cookies");
+const { parseRegion, genTotp }                         = require("../../datastore/models/matrix/auth");
+const { generateIdentityByMode, cacheIdentityData }    = require("../../datastore/models/matrix/identity");
+
+async function ignite(creds, cfg, cb, configFn, forgeFn, seedApi, originFn, errNoIdentity) {
+    let ctx = null, coreFuncs = null, api = seedApi;
+    const { phantomBanner } = require("../../datastore/models/matrix/tools");
+    phantomBanner();
+
+    try {
+        const jar  = tools.getJar();
+        tools.log("phantom-fca", "Initializing session...");
+
+        const mode        = cfg.persona || "desktop";
+        const modeSwitched = cfg.cachedPersona && cfg.cachedPersona !== mode;
+
+        if (modeSwitched) {
+            tools.log("phantom-fca", `Identity mode changed ${cfg.cachedPersona} → ${mode}, resetting fingerprint cache`);
+            const desktopKeys = ["cachedUserAgent","cachedSecChUa","cachedSecChUaFullVersionList","cachedSecChUaPlatform","cachedSecChUaPlatformVersion","cachedBrowser"];
+            const androidKeys = ["cachedAndroidUA","cachedAndroidVersion","cachedAndroidDevice","cachedAndroidBuildId","cachedAndroidResolution","cachedAndroidFbav","cachedAndroidFbbv","cachedAndroidLocale","cachedAndroidCarrier"];
+            [...desktopKeys, ...androidKeys, "cachedLocale", "cachedTimezone"].forEach(k => delete cfg[k]);
+        }
+
+        const needsDesktop = mode === "desktop"  && !cfg.cachedUserAgent;
+        const needsAndroid = (mode === "android" || mode === "mobile") && !cfg.cachedAndroidUA;
+
+        if (needsDesktop || needsAndroid) {
+            const identity = generateIdentityByMode(mode, cfg);
+            cacheIdentityData(cfg, identity);
+            cfg.cachedPersona = mode;
+            tools.log("phantom-fca", mode === "desktop"
+                ? `Desktop identity initialized (${identity.browser})`
+                : "Android/Orca mobile identity initialized");
+
+            const { getRandomLocale, getRandomTimezone } = require("../../datastore/models/matrix/headers");
+            if (!cfg.cachedLocale)   cfg.cachedLocale   = getRandomLocale();
+            if (!cfg.cachedTimezone) cfg.cachedTimezone  = getRandomTimezone();
+
+            try {
+                const { globalShield } = require("../../datastore/models/matrix/ghost");
+                globalShield.lockSessionFingerprint(
+                    identity.userAgent || cfg.cachedAndroidUA,
+                    identity.secChUa   || "",
+                    identity.secChUaPlatform || identity.persona || "desktop",
+                    cfg.cachedLocale,
+                    cfg.cachedTimezone
+                );
+            } catch (_) {}
+        } else {
+            tools.log("phantom-fca", mode === "desktop" ? "Using cached desktop identity" : "Using cached Android identity");
+        }
+
+        let sessionCookies = creds.appState;
+
+        if (!sessionCookies && !creds.email && !creds.password) {
+            try {
+                const { hydrateJarFromDB } = require("../../datastore/session");
+                const restored = await hydrateJarFromDB(jar, null);
+                if (restored) tools.log("phantom-fca", "Session restored from persistent store");
+            } catch (e) {
+                tools.warn("phantom-fca", "Could not restore session from store:", e.message);
+            }
+        }
+
+        if (sessionCookies) {
+            let pairs = [];
+            if (Array.isArray(sessionCookies)) {
+                pairs = sessionCookies.map(c => [c.name || c.key, c.value].join("="));
+            } else if (typeof sessionCookies === "string") {
+                pairs = normalizeCookieHeaderString(sessionCookies);
+                if (!pairs.length) pairs = sessionCookies.split(";").map(s => s.trim()).filter(Boolean);
+            } else {
+                throw new Error("Invalid session format. Provide cookie array or cookie string.");
+            }
+            setJarFromPairs(jar, pairs);
+            tools.log("phantom-fca", "Session cookies injected");
+
+        } else if (creds.email && creds.password) {
+            if (creds.totpSecret) tools.log("phantom-fca", "TOTP secret detected");
+
+            const authParams = {
+                access_token: "350685531728|62f8ce9f74b12f84c123cc23437a4a32",
+                format: "json",
+                sdk_version: 2,
+                email:  creds.email,
+                locale: "en_US",
+                password: creds.password,
+                generate_session_cookies: 1,
+                sig: "c1c640010993db92e5afd11634ced864",
+            };
+
+            if (creds.totpSecret) {
+                try {
+                    const otp = await genTotp(creds.totpSecret);
+                    authParams.credentials_type = "two_factor";
+                    authParams.twofactor_code   = otp;
+                    tools.log("phantom-fca", "2FA token generated");
+                } catch (e) {
+                    tools.warn("phantom-fca", "2FA token generation failed:", e.message);
+                }
+            }
+
+            try {
+                const res = await axios.get(`https://api.facebook.com/method/auth.login?${qs.stringify(authParams)}`);
+                if (res.status !== 200) throw new Error("Authentication failed");
+                setJarFromPairs(jar, res.data.session_cookies.map(c => `${c.name}=${c.value}`));
+                tools.log("phantom-fca", "Email/password authentication successful");
+            } catch (e) {
+                throw new Error("Authentication failed — check credentials");
+            }
+
+        } else {
+            throw new Error("No credentials provided. Supply appState cookies or email+password.");
+        }
+
+        if (!api) {
+            api = {
+                setOptions: configFn.bind(null, cfg),
+                getAppState() {
+                    const state  = tools.getAppState(jar);
+                    if (!Array.isArray(state)) return [];
+                    const unique = state.filter((item, i, self) => self.findIndex(t => t.key === item.key) === i);
+                    return unique.length > 0 ? unique : state;
+                },
+            };
+        }
+
+        try { const { globalShield } = require("../../datastore/models/matrix/ghost"); globalShield.resetCircuitBreaker(); globalShield.enableWarmup(); } catch (_) {}
+
+        const pageResp = await tools.get(originFn(), jar, null, cfg, { noRef: true }).then(tools.saveCookies(jar));
+
+        const extractBlobs = (html) => {
+            const blobs = [], re = /<script type="application\/json"[^>]*>(.*?)<\/script>/g;
+            let m;
+            while ((m = re.exec(html)) !== null) { try { blobs.push(JSON.parse(m[1])); } catch (_) {} }
+            return blobs;
+        };
+
+        const netBlobs = extractBlobs(pageResp.body);
+        const [newCtx, newCoreFuncs] = await forgeFn(pageResp.body, jar, netBlobs, cfg, originFn, errNoIdentity);
+        ctx = newCtx;
+        coreFuncs = newCoreFuncs;
+
+        const detectedRegion = parseRegion(pageResp.body);
+        ctx.region = detectedRegion;
+        tools.log("phantom-fca", "Region detected:", detectedRegion);
+
+        try { const { backupAppStateSQL } = require("../../datastore/session"); await backupAppStateSQL(jar, ctx.userID); }
+        catch (e) { tools.warn("phantom-fca", "Session snapshot failed:", e.message); }
+
+        api.message   = new Map();
+        api.timestamp = {};
+
+        const mountDispatch = () => {
+            const dispatchPath = path.join(__dirname, "..", "..", "dispatch");
+            if (!fs.existsSync(dispatchPath)) { tools.error("phantom-fca", "Dispatch directory not found:", dispatchPath); return; }
+            const skipModules = ["deltaProcessor"];
+            fs.readdirSync(dispatchPath)
+                .filter(f => f.endsWith(".js"))
+                .forEach(f => {
+                    const name = path.basename(f, ".js");
+                    if (skipModules.includes(name)) return;
+                    try {
+                        const mod = require(path.join(dispatchPath, f));
+                        if (typeof mod === "function") api[name] = mod(coreFuncs, api, ctx);
+                    } catch (e) {
+                        tools.error("phantom-fca", `Failed to mount dispatch module [${name}]:`, e);
+                    }
+                });
+        };
+
+        api.getCurrentUserID = () => ctx.userID;
+        api.getOptions       = (k) => (k ? cfg[k] : cfg);
+        mountDispatch();
+
+        if (api.nickname && typeof api.nickname === "function") api.changeNickname = api.nickname;
+
+        try {
+            const schema    = require("../../datastore/schema");
+            const threadsDb = require("../../datastore/threads");
+            const usersDb   = require("../../datastore/users");
+            if (typeof schema.syncAll === "function") schema.syncAll().catch(() => {});
+            api.threadData = threadsDb(api);
+            api.userData   = usersDb(api);
+        } catch (e) { tools.warn("phantom-fca", "Data store optional — skipped:", e.message); }
+
+        api.ctx          = ctx;
+        api.defaultFuncs = coreFuncs;
+        api.globalOptions = cfg;
+
+        const { CycleManager } = require("../../datastore/models/matrix/heartbeat");
+        if (api._cycleManager) api._cycleManager.halt();
+        else api._cycleManager = new CycleManager();
+
+        const { globalReviveManager } = require("../../datastore/models/matrix/revive");
+
+        if (cfg.autoReLogin !== false) {
+            globalReviveManager.setCredentials(creds, cfg, cb);
+            tools.log("phantom-fca", "Auto-revive enabled");
+            try { globalReviveManager.updateAppState(api.getAppState()); } catch (_) {}
+
+            api._cycleManager.setExpiryHandler(() => {
+                tools.warn("phantom-fca", "Token cycle expired — triggering revive...");
+                globalReviveManager.handleSessionExpiry(api, originFn(), errNoIdentity);
+            });
+
+            ctx.performAutoLogin = async () => {
+                try { return (await globalReviveManager.handleSessionExpiry(api, originFn(), errNoIdentity)) !== false; }
+                catch (_) { return false; }
+            };
+        }
+
+        api.disconnect = () => {
+            const fn = require("../../dispatch/logout")(coreFuncs, api, ctx);
+            return fn();
+        };
+
+        const shutdownCleanup = () => {
+            tools.log("phantom-fca", "Graceful shutdown in progress...");
+            try { if (api._cycleManager) api._cycleManager.halt(); } catch (_) {}
+            try { globalReviveManager.stopSessionMonitoring(); globalReviveManager.disable(); } catch (_) {}
+            try { if (ctx.mqttClient?.end) ctx.mqttClient.end(true); } catch (_) {}
+            try { if (ctx._emitter) ctx._emitter.removeAllListeners(); } catch (_) {}
+            ["_mqttWatchdog","_autoCycleTimer","_periodicBackupInterval"].forEach(k => { try { if (ctx[k]) clearInterval(ctx[k]); } catch (_) {} });
+            ["_tmsTimeout","_reconnectTimer"].forEach(k => { try { if (ctx[k]) clearTimeout(ctx[k]); } catch (_) {} });
+            tools.log("phantom-fca", "Shutdown complete");
+        };
+
+        if (!process._phantomCleanupRegistered) {
+            process._phantomCleanupRegistered = true;
+            process.on("exit",             () => shutdownCleanup());
+            process.on("SIGINT",           () => { shutdownCleanup(); process.exit(0); });
+            process.on("SIGTERM",          () => { shutdownCleanup(); process.exit(0); });
+            process.on("uncaughtException", (err) => { tools.error("phantom-fca", err.message); shutdownCleanup(); process.exit(1); });
+            process.on("unhandledRejection", (r)  => tools.error("phantom-fca", String(r?.message ?? r)));
+        }
+
+        if (ctx._periodicBackupInterval) clearInterval(ctx._periodicBackupInterval);
+        ctx._periodicBackupInterval = setInterval(async () => {
+            try { const { backupAppStateSQL } = require("../../datastore/session"); await backupAppStateSQL(jar, ctx.userID); } catch (_) {}
+        }, 15 * 60_000);
+        try { ctx._periodicBackupInterval.unref(); } catch (_) {}
+
+        api._cycleManager.startAutoRefresh(ctx, coreFuncs, originFn());
+
+        api.refreshTokens  = () => api._cycleManager.refreshTokens(ctx, coreFuncs, originFn());
+        api.getCycleStatus = () => api._cycleManager.getStatus();
+
+        api.getHealthStatus = () => {
+            let rateStats = null;
+            try { rateStats = require("../../datastore/models/matrix/gate").getRateLimiterStats(); } catch (_) {}
+            return {
+                mqttConnected: !!(ctx.mqttClient?.connected),
+                autoReconnect: !!cfg.autoReconnect,
+                tokenCycle:    {
+                    lastRefresh:  api._cycleManager.lastRefresh,
+                    nextRefresh:  api._cycleManager.getTimeUntilNextRefresh(),
+                    failureCount: api._cycleManager.getFailureCount(),
+                },
+                autoRevive: {
+                    enabled:           globalReviveManager.isEnabled(),
+                    sessionMonitoring: !!globalReviveManager.sessionMonitorInterval,
+                    stats:             globalReviveManager.getStats(),
+                },
+                rateLimiter: rateStats,
+            };
+        };
+
+        api.enableAutoRevive   = (on = true) => on
+            ? globalReviveManager.setCredentials(creds, cfg, cb)
+            : globalReviveManager.disable();
+        api.isAutoReviveActive = () => globalReviveManager.isEnabled();
+
+        api.isSessionAlive = () => new Promise(async (resolve) => {
+            try {
+                const probe = { noRef: true, _skipSessionInspect: true };
+                const r     = await tools.get(
+                    "https://www.facebook.com/ajax/presence/reconnect.php?reason=14&fb_dtsg_ag=&__a=1",
+                    ctx.jar, null, ctx.globalOptions, probe
+                );
+                const html = r.body || "";
+                if (html.includes('<form id="login_form"') || html.includes("id=\"loginbutton\"") ||
+                    html.includes('"login_page"')          || html.includes('action="/login.php')) return resolve(false);
+                if (html.includes('"checkpoint"') && html.includes('"flow_type"')) {
+                    try { const { globalShield } = require("../../datastore/models/matrix/ghost"); globalShield.tripCircuitBreaker("checkpoint_detected", 3600_000); } catch (_) {}
+                    return resolve(false);
+                }
+                resolve(!!(ctx.fb_dtsg && ctx.fb_dtsg.length > 10));
+            } catch (err) {
+                const msg  = err.message || String(err);
+                const code = err.code    || "";
+                const NET  = ["ECONNRESET","ETIMEDOUT","ECONNREFUSED","ENETUNREACH","EHOSTUNREACH","EAI_AGAIN","ENOTFOUND","ESOCKETTIMEDOUT"];
+                if (NET.some(c => code === c || msg.includes(c)) || msg.includes("socket hang up")) {
+                    tools.warn("phantom-fca", "Session probe — transient network issue");
+                    return resolve("network_error");
+                }
+                tools.error("phantom-fca", "Session probe failed:", msg);
+                resolve(false);
+            }
+        });
+
+        api.isSessionValid = api.isSessionAlive;
+
+        if (cfg.autoReLogin !== false) {
+            try { globalReviveManager.startSessionMonitoring(api); tools.log("phantom-fca", "Session watchdog started"); } catch (_) {}
+        }
+
+        try {
+            const { globalShield } = require("../../datastore/models/matrix/ghost");
+            api.shield = {
+                getStatus:    ()  => globalShield.getStatus(),
+                reset:        ()  => globalShield.resetCircuitBreaker(),
+                addDelay:     ()  => globalShield.addSmartDelay(),
+                setDailyLimit:(n) => globalShield.setDailyLimit(n),
+                getBehavior:  ()  => globalShield.getBehaviorProfile(),
+            };
+        } catch (_) {}
+
+        cb(null, api);
+
+    } catch (err) {
+        tools.error("phantom-fca", "Session launch error:", err.message || err);
+        cb(err);
+    }
+}
+
+module.exports = ignite;

package/phantom/core/builder/config.js

@@ -0,0 +1,78 @@
+"use strict";
+
+const tools = require("../../datastore/models/matrix/tools");
+
+/**
+ * Applies runtime configuration overrides to the live options map.
+ *
+ * @param {object} cfg    Current global options reference.
+ * @param {object} [patch] New key/value pairs to apply.
+ * @returns {Promise<void>}
+ */
+async function applyConfig(cfg, patch = {}) {
+    const handlers = {
+        online:             (v) => (cfg.online = Boolean(v)),
+        selfListen:         (v) => (cfg.selfListen = Boolean(v)),
+        selfListenEvent:    (v) => (cfg.selfListenEvent = v),
+        listenEvents:       (v) => (cfg.listenEvents = Boolean(v)),
+        updatePresence:     (v) => (cfg.updatePresence = Boolean(v)),
+        forceLogin:         (v) => (cfg.forceLogin = Boolean(v)),
+        userAgent:          (v) => (cfg.userAgent = v),
+        autoMarkDelivery:   (v) => (cfg.autoMarkDelivery = Boolean(v)),
+        autoMarkRead:       (v) => (cfg.autoMarkRead = Boolean(v)),
+        listenTyping:       (v) => (cfg.listenTyping = Boolean(v)),
+        autoReconnect:      (v) => (cfg.autoReconnect = Boolean(v)),
+        emitReady:          (v) => (cfg.emitReady = Boolean(v)),
+        simulateTyping:     (v) => (cfg.simulateTyping = Boolean(v)),
+        proxy(v) {
+            if (typeof v !== "string") { delete cfg.proxy; tools.setProxy(); }
+            else { cfg.proxy = v; tools.setProxy(v); }
+        },
+        randomUserAgent(v) {
+            cfg.randomUserAgent = Boolean(v);
+            if (v) cfg.userAgent = tools.randomUserAgent();
+        },
+        bypassRegion(v) {
+            cfg.bypassRegion = v ? v.toUpperCase() : v;
+        },
+        maxConcurrentRequests(v) {
+            if (typeof v === "number") {
+                cfg.maxConcurrentRequests = Math.floor(v);
+                tools.configureRateLimiter({ maxConcurrentRequests: cfg.maxConcurrentRequests });
+            }
+        },
+        maxRequestsPerMinute(v) {
+            if (typeof v === "number") {
+                cfg.maxRequestsPerMinute = Math.floor(v);
+                tools.configureRateLimiter({ maxRequestsPerMinute: cfg.maxRequestsPerMinute });
+            }
+        },
+        requestCooldownMs(v) {
+            if (typeof v === "number") {
+                cfg.requestCooldownMs = Math.floor(v);
+                tools.configureRateLimiter({ requestCooldownMs: cfg.requestCooldownMs });
+            }
+        },
+        errorCacheTtlMs(v) {
+            if (typeof v === "number") {
+                cfg.errorCacheTtlMs = Math.floor(v);
+                tools.configureRateLimiter({ errorCacheTtlMs: cfg.errorCacheTtlMs });
+            }
+        },
+        stealthMode(v) {
+            cfg.stealthMode = Boolean(v);
+            if (v) {
+                cfg.updatePresence = false;
+                cfg.online = false;
+                cfg.simulateTyping = false;
+                tools.configureRateLimiter({ maxConcurrentRequests: 2, maxRequestsPerMinute: 60 });
+            }
+        },
+    };
+
+    for (const [key, val] of Object.entries(patch)) {
+        if (handlers[key]) handlers[key](val);
+    }
+}
+
+module.exports = applyConfig;

package/phantom/core/builder/forge.js

@@ -0,0 +1,113 @@
+"use strict";
+
+const tools = require("../../datastore/models/matrix/tools");
+const { SessionStore } = require("../../datastore/models/matrix/store");
+const { globalValidator } = require("../../datastore/models/matrix/validator");
+
+async function forge(pageHtml, cookieJar, netBlobs, cfg, originFn, errMsg) {
+    let accountID;
+    const cookies   = cookieJar.getCookiesSync(originFn());
+    const primary   = cookies.find(c => c.cookieString().startsWith("c_user="));
+    const secondary = cookies.find(c => c.cookieString().startsWith("i_user="));
+    if (!primary && !secondary) throw new Error(errMsg);
+    accountID = secondary?.cookieString().split("=")[1] || primary.cookieString().split("=")[1];
+
+    function scanBlobs(target) {
+        for (const blob of netBlobs) {
+            if (!blob.require) continue;
+            for (const req of blob.require) {
+                if (Array.isArray(req) && req[0] === target && req[2]) return req[2];
+                if (Array.isArray(req) && req[3]?.[0]?.__bbox?.define) {
+                    for (const def of req[3][0].__bbox.define) {
+                        if (Array.isArray(def) && def[0].endsWith(target) && def[2]) return def[2];
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    const dtsgBlob   = scanBlobs("DTSGInitialData");
+    const fb_dtsg    = dtsgBlob?.token ?? tools.getFrom(pageHtml, '"token":"', '"');
+    const lsdBlob    = scanBlobs("LSD");
+    const lsd        = lsdBlob?.token  ?? tools.getFrom(pageHtml, '"LSD",[],{"token":"', '"');
+    const dtsgAgBlob = scanBlobs("DTSGAGInitialData");
+    const fb_dtsg_ag = dtsgAgBlob?.token ?? tools.getFrom(pageHtml, '"DTSGAGInitialData",[],{"token":"', '"');
+
+    const spinR = pageHtml.match(/"__spin_r":(\d+)/)?.[1];
+    const spinB = pageHtml.match(/"__spin_b":"([^"]+)"/)?.[1];
+    const spinT = pageHtml.match(/"__spin_t":(\d+)/)?.[1];
+    const hsi   = pageHtml.match(/"hsi":"(\d+)"/)?.[1];
+    const dyn   = pageHtml.match(/"dyn":"([^"]+)"/)?.[1];
+    const csr   = pageHtml.match(/"csr":"([^"]+)"/)?.[1];
+
+    const tokenBundle = {
+        fb_dtsg,
+        jazoest: `2${Array.from(fb_dtsg || "").reduce((a, b) => a + b.charCodeAt(0), "")}`,
+        lsd,
+        fb_dtsg_ag,
+        __spin_r: spinR,
+        __spin_b: spinB,
+        __spin_t: spinT,
+        hsi,
+        dyn,
+        csr,
+    };
+
+    const mqttDevBlob  = scanBlobs("MqttWebDeviceID");
+    const mqttCfgBlob  = scanBlobs("MqttWebConfig");
+    const userBlob     = scanBlobs("CurrentUserInitialData");
+    const clientID     = mqttDevBlob?.clientID;
+    const mqttAppID    = mqttCfgBlob?.appID;
+    const userAppID    = userBlob?.APP_ID;
+    const primaryAppID = userAppID || mqttAppID;
+    let   mqttEndpoint = mqttCfgBlob?.endpoint;
+
+    let region;
+    if (mqttEndpoint) {
+        try { region = new URL(mqttEndpoint).searchParams.get("region")?.toUpperCase(); } catch (_) {}
+    }
+
+    const irisSeqID = pageHtml.match(/irisSeqID:"(.+?)"/)?.[1] ?? null;
+
+    if (cfg.bypassRegion && mqttEndpoint) {
+        const ep = new URL(mqttEndpoint);
+        ep.searchParams.set("region", cfg.bypassRegion.toLowerCase());
+        mqttEndpoint = ep.toString();
+        region       = cfg.bypassRegion.toUpperCase();
+    }
+
+    const sessionStore = new SessionStore({ maxSize: 500, ttlMs: 5 * 60_000 });
+
+    const ctx = {
+        accountID,
+        userID:           accountID,
+        jar:              cookieJar,
+        clientID,
+        appID:            primaryAppID,
+        mqttAppID,
+        userAppID,
+        globalOptions:    cfg,
+        loggedIn:         true,
+        access_token:     "NONE",
+        clientMutationId: 0,
+        mqttClient:       undefined,
+        lastSeqId:        irisSeqID,
+        syncToken:        undefined,
+        mqttEndpoint,
+        wsReqNumber:      0,
+        wsTaskNumber:     0,
+        reqCallbacks:     {},
+        callback_Task:    {},
+        region,
+        firstListen:      true,
+        cache:            sessionStore,
+        validator:        globalValidator,
+        ...tokenBundle,
+    };
+
+    const coreFuncs = tools.makeDefaults(pageHtml, accountID, ctx);
+    return [ctx, coreFuncs, {}];
+}
+
+module.exports = forge;