device-passport 1.1.0 → 1.2.0

package/dist/shared/device-passport.qL4tjwc0.cjs

@@ -0,0 +1,718 @@
+'use strict';
+
+const cdp = require('./device-passport.D9xW6R0B.cjs');
+const entropy = require('./device-passport.EK4RX7Xd.cjs');
+const memory = require('./device-passport.Cjxlv8xI.cjs');
+
+class DevicePassportInstance {
+  profile;
+  constructor(profile) {
+    if (!profile) {
+      throw new Error("[DevicePassportInstance] Profile cannot be null or undefined");
+    }
+    this.profile = profile;
+  }
+  /**
+   * Factory method to create an instance from a plain DevicePassport object.
+   */
+  static from(profile) {
+    return new DevicePassportInstance(profile);
+  }
+  // ==========================================
+  // Getters for core profile facets
+  // ==========================================
+  get id() {
+    return this.profile.id;
+  }
+  get seed() {
+    return this.profile.seed;
+  }
+  get createdAt() {
+    return this.profile.createdAt;
+  }
+  get browser() {
+    return this.profile.browser;
+  }
+  get os() {
+    return this.profile.os;
+  }
+  get hardware() {
+    return this.profile.hardware;
+  }
+  get locale() {
+    return this.profile.locale;
+  }
+  get headers() {
+    return this.profile.headers;
+  }
+  get clientHints() {
+    return this.profile.clientHints;
+  }
+  get context() {
+    return this.profile.context;
+  }
+  get userAgent() {
+    return this.profile.headers["user-agent"] || this.profile.browser.userAgent;
+  }
+  get timezone() {
+    return this.profile.locale.timezone;
+  }
+  get playwrightContext() {
+    return this.getPlaywrightContext();
+  }
+  get puppeteerArgs() {
+    return this.getPuppeteerArgs();
+  }
+  get evaluation() {
+    return this.profile.evaluation;
+  }
+  // ==========================================
+  // Lightweight HTTP Mode Adapters
+  // ==========================================
+  /**
+   * Returns HTTP headers formatted in strict canonical browser sequence.
+   * Essential for anti-bot evasion against Cloudflare, Akamai, and DataDome.
+   */
+  getHeaders(overrides) {
+    return cdp.formatCanonicalHeaders(this.profile.headers, overrides);
+  }
+  /**
+   * Returns a higher-order fetch function wrapping standard fetch with this passport's canonical persona.
+   */
+  wrapFetch(customFetch) {
+    return cdp.withPassport(this, customFetch);
+  }
+  /**
+   * Alias for wrapFetch.
+   */
+  withPassport(customFetch) {
+    return cdp.withPassport(this, customFetch);
+  }
+  /**
+   * Generates a copy-pasteable cURL command with correct browser headers and User-Agent.
+   */
+  toCurl(url, options) {
+    return cdp.toCurl(this, url, options);
+  }
+  // ==========================================
+  // Heavyweight Browser Automation Adapters
+  // ==========================================
+  /**
+   * Generates Playwright BrowserContext options.
+   * Usage:
+   * ```ts
+   * const context = await browser.newContext(passport.getPlaywrightContext());
+   * ```
+   */
+  getPlaywrightContext() {
+    return cdp.getPlaywrightContext(this.profile);
+  }
+  /**
+   * Returns Puppeteer launch args and page emulation parameters.
+   */
+  getPuppeteerArgs() {
+    return cdp.getPuppeteerArgs(this.profile);
+  }
+  /**
+   * Generates an in-page stealth script to patch runtime JavaScript APIs
+   * (navigator.webdriver, hardwareConcurrency, deviceMemory, WebGL, Client Hints).
+   */
+  getStealthScript() {
+    return cdp.getStealthScript(this.profile);
+  }
+  /**
+   * Injects stealth scripts and extra HTTP headers into a Playwright BrowserContext.
+   */
+  async applyToPlaywright(context) {
+    await cdp.applyToPlaywrightContext(context, this.profile);
+  }
+  /**
+   * Injects stealth scripts and emulation parameters into a Puppeteer Page.
+   */
+  async applyToPuppeteer(page) {
+    await cdp.applyToPuppeteerPage(page, this.profile);
+  }
+  // ==========================================
+  // Consistency & Diagnostics
+  // ==========================================
+  /**
+   * Evaluates cross-layer consistency and Shannon entropy.
+   * Caches the result on `this.profile.evaluation`.
+   */
+  evaluate(forceRecompute = false) {
+    if (this.profile.evaluation && !forceRecompute) {
+      return this.profile.evaluation;
+    }
+    try {
+      const contradictions = entropy.detectAllContradictions(this.profile);
+      let estimatedBits = 48;
+      let collisionRisk = "very_low";
+      try {
+        const entropy$1 = entropy.analyzeHeaderEntropy(this.profile.headers);
+        if (entropy$1) {
+          estimatedBits = entropy$1.estimatedBits;
+          collisionRisk = entropy$1.collisionRisk;
+        }
+      } catch {
+      }
+      const totalPenalty = contradictions.reduce((sum, c) => sum + c.impactPenalty, 0);
+      const overallScore = Math.max(0, Math.min(100, Math.round(100 - totalPenalty)));
+      const status = overallScore >= 90 ? "PASS" : overallScore >= 70 ? "WARN" : "FAIL";
+      const grade = overallScore >= 95 ? "A+" : overallScore >= 85 ? "A" : overallScore >= 70 ? "B" : overallScore >= 50 ? "C" : "F";
+      const checks = [
+        {
+          id: "chk_os_ua_alignment",
+          name: "OS and User-Agent Alignment",
+          category: "os_ua_alignment",
+          passed: !contradictions.some((c) => c.category === "os_browser"),
+          score: contradictions.some((c) => c.category === "os_browser") ? 0 : 100,
+          weight: 1.5,
+          message: contradictions.find((c) => c.category === "os_browser")?.description ?? "User-Agent and Operating System are fully coherent"
+        },
+        {
+          id: "chk_hardware_plausibility",
+          name: "Hardware and GPU Plausibility",
+          category: "hardware_plausibility",
+          passed: !contradictions.some((c) => c.category === "hardware_system"),
+          score: contradictions.some((c) => c.category === "hardware_system") ? 0 : 100,
+          weight: 2,
+          message: contradictions.find((c) => c.category === "hardware_system")?.description ?? "GPU renderer, CPU architecture and RAM are physically plausible"
+        },
+        {
+          id: "chk_geo_locale_coherence",
+          name: "Geo and Locale Coherence",
+          category: "geo_locale_coherence",
+          passed: !contradictions.some((c) => c.category === "geo_chrono"),
+          score: contradictions.some((c) => c.category === "geo_chrono") ? 0 : 100,
+          weight: 1.5,
+          message: contradictions.find((c) => c.category === "geo_chrono")?.description ?? "Timezone, country, and Accept-Language are geographically locked"
+        },
+        {
+          id: "chk_client_hints_entropy",
+          name: "Client Hints RFC 8942 Compliance",
+          category: "client_hints_entropy",
+          passed: !contradictions.some((c) => c.category === "client_hints"),
+          score: contradictions.some((c) => c.category === "client_hints") ? 0 : 100,
+          weight: 1.5,
+          message: contradictions.find((c) => c.category === "client_hints")?.description ?? "User-Agent Client Hints headers strictly match W3C and Chromium freeze specifications"
+        }
+      ];
+      const evaluation = {
+        overallScore,
+        status,
+        grade,
+        checks,
+        entropyAnalysis: {
+          estimatedBits,
+          collisionRisk
+        },
+        evaluatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.profile.evaluation = evaluation;
+      return evaluation;
+    } catch {
+      if (this.profile.evaluation) {
+        return this.profile.evaluation;
+      }
+      const baseline = {
+        overallScore: 100,
+        status: "PASS",
+        grade: "A+",
+        checks: [],
+        evaluatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.profile.evaluation = baseline;
+      return baseline;
+    }
+  }
+  // ==========================================
+  // Serialization
+  // ==========================================
+  /**
+   * Returns the underlying raw DevicePassport data object.
+   */
+  toJSON() {
+    return this.profile;
+  }
+  toString() {
+    const { id, browser, os, locale } = this.profile;
+    return `[DevicePassport ${id} | ${browser?.name ?? "Browser"} ${browser?.version ?? ""} on ${os?.platform ?? "OS"} | ${locale?.language ?? "Locale"}]`;
+  }
+}
+function createPassport(seedOrOptionsOrProfile, extraOptions) {
+  if (seedOrOptionsOrProfile instanceof DevicePassportInstance) {
+    return seedOrOptionsOrProfile;
+  }
+  if (seedOrOptionsOrProfile && typeof seedOrOptionsOrProfile === "object" && "id" in seedOrOptionsOrProfile && "clientHints" in seedOrOptionsOrProfile && "headers" in seedOrOptionsOrProfile) {
+    return new DevicePassportInstance(seedOrOptionsOrProfile);
+  }
+  let options = {};
+  if (typeof seedOrOptionsOrProfile === "string") {
+    options = { ...extraOptions, seed: seedOrOptionsOrProfile };
+  } else if (seedOrOptionsOrProfile && typeof seedOrOptionsOrProfile === "object") {
+    options = { ...seedOrOptionsOrProfile };
+  } else if (extraOptions) {
+    options = { ...extraOptions };
+  }
+  if (options.store && options.seed) {
+    const storage = typeof options.store === "string" ? new memory.JSONFileStorage({ filePath: options.store }) : options.store;
+    const seedKey = String(options.seed);
+    if (storage.hasSync?.(seedKey) && storage.getSync) {
+      const existing = storage.getSync(seedKey);
+      if (existing) return new DevicePassportInstance(existing);
+    }
+    const generated2 = cdp.generatePassport(options);
+    if (storage.setSync) {
+      storage.setSync(seedKey, generated2);
+    } else {
+      storage.set(seedKey, generated2).catch(() => {
+      });
+    }
+    return new DevicePassportInstance(generated2);
+  }
+  const generated = cdp.generatePassport(options);
+  return new DevicePassportInstance(generated);
+}
+
+class PassportManager {
+  storage;
+  defaultGeo;
+  defaultOS;
+  defaultBrowser;
+  generator;
+  constructor(options) {
+    if (typeof options?.store === "string") {
+      this.storage = new memory.JSONFileStorage(options.store);
+    } else if (options?.store && typeof options.store.get === "function") {
+      this.storage = options.store;
+    } else {
+      this.storage = new memory.MemoryStorage();
+    }
+    this.defaultGeo = options?.defaultGeo ?? "US";
+    this.defaultOS = options?.defaultOS;
+    this.defaultBrowser = options?.defaultBrowser;
+    this.generator = options?.generator ?? cdp.generatePassport;
+  }
+  /**
+   * Retrieves an existing sticky passport by seed or deterministically generates
+   * and persists a new one if it does not already exist.
+   *
+   * @param seed Deterministic seed (user ID, account handle, proxy IP, worker slot)
+   * @param options Generator options to use if persona needs to be created
+   */
+  async getPassport(seed, options) {
+    const seedStr = String(seed);
+    const existing = await this.storage.get(seedStr);
+    if (existing) {
+      return new DevicePassportInstance(existing);
+    }
+    const mergedOptions = {
+      seed: seedStr,
+      country: options?.country ?? this.defaultGeo,
+      os: options?.os ?? this.defaultOS,
+      browser: options?.browser ?? this.defaultBrowser,
+      ...options
+    };
+    const profile = this.generator(mergedOptions);
+    await this.storage.set(seedStr, profile);
+    return new DevicePassportInstance(profile);
+  }
+  /**
+   * Synchronous passport retrieval for environments backed by MemoryStorage or JSONFileStorage.
+   */
+  getPassportSync(seed, options) {
+    const seedStr = String(seed);
+    const syncStore = this.storage;
+    if (typeof syncStore.getSync === "function") {
+      const existing = syncStore.getSync(seedStr);
+      if (existing) {
+        return new DevicePassportInstance(existing);
+      }
+      const mergedOptions = {
+        seed: seedStr,
+        country: options?.country ?? this.defaultGeo,
+        os: options?.os ?? this.defaultOS,
+        browser: options?.browser ?? this.defaultBrowser,
+        ...options
+      };
+      const profile = this.generator(mergedOptions);
+      if (typeof syncStore.setSync === "function") {
+        syncStore.setSync(seedStr, profile);
+      }
+      return new DevicePassportInstance(profile);
+    }
+    throw new Error(
+      "[PassportManager] Current storage adapter does not support synchronous operations. Use await manager.getPassport(seed) instead."
+    );
+  }
+  /**
+   * Forces re-generation and overwrite of a passport for the given seed.
+   */
+  async renewPassport(seed, options) {
+    const seedStr = String(seed);
+    const mergedOptions = {
+      seed: seedStr,
+      country: options?.country ?? this.defaultGeo,
+      os: options?.os ?? this.defaultOS,
+      browser: options?.browser ?? this.defaultBrowser,
+      ...options
+    };
+    const profile = this.generator(mergedOptions);
+    await this.storage.set(seedStr, profile);
+    return new DevicePassportInstance(profile);
+  }
+  /**
+   * Check if a passport exists in storage for the given seed.
+   */
+  async hasPassport(seed) {
+    return this.storage.has(String(seed));
+  }
+  /**
+   * Delete a passport from storage.
+   */
+  async deletePassport(seed) {
+    return this.storage.delete(String(seed));
+  }
+  /**
+   * Import an existing passport into storage.
+   */
+  async importPassport(passport) {
+    const raw = passport instanceof DevicePassportInstance ? passport.toJSON() : passport;
+    await this.storage.set(raw.seed, raw);
+    return new DevicePassportInstance(raw);
+  }
+  /**
+   * List all stored seeds.
+   */
+  async listSeeds() {
+    return this.storage.keys();
+  }
+  /**
+   * List all stored passports as DevicePassportInstance objects.
+   */
+  async listPassports() {
+    const keys = await this.storage.keys();
+    const instances = [];
+    for (const key of keys) {
+      const item = await this.storage.get(key);
+      if (item) {
+        instances.push(new DevicePassportInstance(item));
+      }
+    }
+    return instances;
+  }
+  /**
+   * Clear all stored passports.
+   */
+  async clear() {
+    await this.storage.clear();
+  }
+  /**
+   * Return number of stored personas.
+   */
+  async count() {
+    const keys = await this.storage.keys();
+    return keys.length;
+  }
+}
+
+const PROXY_RESOLUTION_NOTE = "ego-lite cannot configure a proxy at the browser layer: CDP has no Browser.setProxySettings and ego-lite exposes no proxy API. Bind this proxy at the system level (OS proxy / TUN / local forwarder in front of the ego-lite process) before launching the session.";
+const PROXY_MISSING_NOTE = "No proxy is declared for this account, so the session will egress directly. ego-lite cannot add a proxy later at the browser layer \u2014 either declare one on the account profile or route the whole ego-lite process through a system-level proxy.";
+function getProfileReadiness(profile) {
+  if (!profile.profileId) {
+    return "missing-profile";
+  }
+  if (!profile.proxy) {
+    return "missing-proxy";
+  }
+  return "ready";
+}
+function buildProxyDeclaration(profile) {
+  if (profile.proxy) {
+    return {
+      bound: true,
+      binding: profile.proxy,
+      resolution: "system-level",
+      note: PROXY_RESOLUTION_NOTE
+    };
+  }
+  return {
+    bound: false,
+    binding: null,
+    resolution: "system-level",
+    note: PROXY_MISSING_NOTE
+  };
+}
+function buildEgoSessionPlan(passport, profile, options = {}) {
+  const cdpPlan = cdp.getCdpPlan(passport, options.sessionId);
+  const readiness = getProfileReadiness(profile);
+  const proxy = buildProxyDeclaration(profile);
+  return {
+    seed: profile.seed,
+    profileId: profile.profileId,
+    taskSpaceName: options.taskSpaceName ?? defaultTaskSpaceName(profile.seed),
+    ...cdpPlan,
+    proxy,
+    readiness,
+    launchable: readiness === "ready"
+  };
+}
+function defaultTaskSpaceName(seed) {
+  return `dp-${seed}`;
+}
+
+class AccountProfileManager {
+  /** Persistent store of account profile records. */
+  storage;
+  /** The passport manager holding the sticky identities. */
+  passportManager;
+  /** The ego-lite bridge, when one was injected. */
+  bridge;
+  constructor(options = {}) {
+    if (typeof options.store === "string") {
+      this.storage = new memory.JSONFileStorage({ filePath: options.store });
+    } else if (options.store && typeof options.store.get === "function") {
+      this.storage = options.store;
+    } else {
+      this.storage = new memory.MemoryStorage();
+    }
+    const passportStore = options.passportStore ?? options.passportOptions?.store;
+    this.passportManager = options.passportManager ?? new PassportManager({
+      ...options.passportOptions,
+      ...passportStore !== void 0 ? { store: passportStore } : {}
+    });
+    this.bridge = options.bridge;
+  }
+  /**
+   * Lists the ego-lite profiles available for binding.
+   *
+   * @throws When no bridge was injected — ego-lite has no "create profile" API,
+   * so a profile must already exist and be listed before it can be bound.
+   */
+  async listEgoProfiles() {
+    if (!this.bridge) {
+      throw new Error(
+        "[ego] no ego-lite bridge available. Inject `bridge` to list profiles; ego-lite has no API for creating profiles."
+      );
+    }
+    return this.bridge.listProfiles();
+  }
+  /**
+   * Returns the stored account profile record for a seed.
+   */
+  async getProfile(seed) {
+    return this.storage.get(String(seed));
+  }
+  /**
+   * Returns the readiness of an account profile.
+   *
+   * `ready` requires both a bound ego-lite profile and a declared proxy.
+   */
+  async getReadiness(seed) {
+    const profile = await this.getProfile(seed);
+    if (!profile) {
+      return "missing-profile";
+    }
+    return getProfileReadiness(profile);
+  }
+  /**
+   * Binds an account to an existing ego-lite profile, and optionally declares its proxy.
+   *
+   * The proxy is only *recorded* here. ego-lite cannot apply it at the browser layer,
+   * so the operator must bind it at the system level before launching a session.
+   *
+   * @param seed The account seed. Doubles as the sticky passport seed.
+   * @param options The profile id to bind and the optional proxy declaration.
+   * @param passportOptions Generator options used when the passport is first created.
+   */
+  async bindProfile(seed, options, passportOptions) {
+    const seedStr = String(seed);
+    if (!options.profileId) {
+      throw new Error("[ego] profileId is required to bind an account profile");
+    }
+    if (this.bridge) {
+      const profiles = await this.bridge.listProfiles();
+      if (!profiles.some((p) => p.id === options.profileId)) {
+        throw new Error(
+          `[ego] profile "${options.profileId}" does not exist in ego-lite. Available profiles: ${profiles.map((p) => p.id).join(", ") || "(none)"}`
+        );
+      }
+    }
+    const existing = await this.storage.get(seedStr);
+    const effectiveProxy = options.proxy !== void 0 ? options.proxy : existing?.proxy ?? null;
+    const passport = await this.passportManager.getPassport(seedStr, {
+      ...passportOptions,
+      ...effectiveProxy?.country ? { geo: effectiveProxy.country } : {}
+    });
+    const proxy = options.proxy !== void 0 ? options.proxy : existing?.proxy ?? null;
+    const record = {
+      seed: seedStr,
+      passportId: passport.id,
+      profileId: options.profileId,
+      proxy: proxy ?? null,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.storage.set(seedStr, record);
+    return record;
+  }
+  /**
+   * Declares (or clears) the proxy binding of an account.
+   *
+   * Passing `null` removes the declaration; the account then reports `missing-proxy`.
+   */
+  async setProxy(seed, proxy) {
+    const seedStr = String(seed);
+    const existing = await this.storage.get(seedStr);
+    if (!existing) {
+      throw new Error(
+        `[ego] no account profile for seed ${seedStr}. Bind a profile before declaring a proxy.`
+      );
+    }
+    const record = {
+      ...existing,
+      proxy: proxy ?? null,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.storage.set(seedStr, record);
+    return record;
+  }
+  /**
+   * Returns the sticky passport instance for an account.
+   */
+  async getPassport(seed, options) {
+    return this.passportManager.getPassport(String(seed), options);
+  }
+  /**
+   * Builds the complete launch plan for one account session.
+   *
+   * The plan carries the CDP command sequence, init scripts, headers, the ego-lite
+   * profile id, and an explicit proxy declaration whose `bound` flag reflects whether
+   * a proxy is actually declared for the account.
+   *
+   * @throws When the account has no bound profile.
+   */
+  async createSessionPlan(seed, options = {}) {
+    const seedStr = String(seed);
+    const profile = await this.storage.get(seedStr);
+    if (!profile) {
+      throw new Error(`[ego] no account profile for seed ${seedStr}`);
+    }
+    const passport = await this.passportManager.getPassport(seedStr, {
+      // The exit IP's country must match the persona's geo context, otherwise the
+      // browser claims one country while the traffic leaves from another — the
+      // classic "geo divergence" that anti-bot classifiers score on.
+      ...profile.proxy?.country ? { geo: profile.proxy.country } : {}
+    });
+    return buildEgoSessionPlan(passport.profile, profile, {
+      taskSpaceName: options.taskSpaceName,
+      sessionId: options.sessionId
+    });
+  }
+  /**
+   * Opens an ego-lite task space bound to the account's profile.
+   *
+   * The task space inherits the profile's cookies and login state; a different
+   * profile is fully isolated from it.
+   *
+   * @returns The task space identifier.
+   * @throws When the account has no bound profile or no bridge was injected.
+   */
+  async openTaskSpace(seed, taskSpaceName) {
+    if (!this.bridge) {
+      throw new Error(
+        "[ego] no ego-lite bridge available. Inject `bridge` to open task spaces."
+      );
+    }
+    const seedStr = String(seed);
+    const profile = await this.storage.get(seedStr);
+    if (!profile) {
+      throw new Error(`[ego] no account profile for seed ${seedStr}`);
+    }
+    const plan = await this.createSessionPlan(seedStr, { taskSpaceName });
+    return this.bridge.createTaskSpace(plan.taskSpaceName, profile.profileId);
+  }
+  /**
+   * Lists every stored account seed.
+   */
+  async listSeeds() {
+    return this.storage.keys();
+  }
+  /**
+   * Removes an account profile record.
+   */
+  async removeProfile(seed) {
+    return this.storage.delete(String(seed));
+  }
+}
+
+function getEgoNativeBridge(scope = globalThis) {
+  if (!scope || typeof scope !== "object") {
+    return null;
+  }
+  const candidate = scope.ego;
+  if (!candidate || typeof candidate !== "object") {
+    return null;
+  }
+  return candidate;
+}
+function createEgoBridge(native = getEgoNativeBridge()) {
+  if (!native) {
+    throw new Error(
+      "[ego] ego-lite native bridge not found. Run inside the ego-browser CLI nodejs heredoc mode."
+    );
+  }
+  return {
+    async listProfiles() {
+      if (typeof native.listProfiles !== "function") {
+        throw new Error("[ego] ego.listProfiles is not available");
+      }
+      const result = await native.listProfiles();
+      const profiles = Array.isArray(result) ? result : result?.profiles;
+      if (!Array.isArray(profiles)) {
+        throw new Error("[ego] ego.listProfiles returned no profiles array");
+      }
+      return profiles;
+    },
+    async createTaskSpace(name, profileId) {
+      if (typeof native.createTaskSpace !== "function") {
+        throw new Error("[ego] ego.createTaskSpace is not available");
+      }
+      const result = await native.createTaskSpace(name, profileId);
+      return normalizeTaskSpaceId(result, name);
+    }
+  };
+}
+function normalizeTaskSpaceId(result, name) {
+  if (typeof result === "string" && result.length > 0) {
+    return result;
+  }
+  if (typeof result === "number" && Number.isFinite(result)) {
+    return String(result);
+  }
+  if (result && typeof result === "object") {
+    const record = result;
+    for (const key of ["taskId", "id", "name"]) {
+      const value = record[key];
+      if (typeof value === "string" && value.length > 0) {
+        return value;
+      }
+      if (typeof value === "number" && Number.isFinite(value)) {
+        return String(value);
+      }
+    }
+  }
+  throw new Error(`[ego] could not resolve task space id for ${name}`);
+}
+
+exports.AccountProfileManager = AccountProfileManager;
+exports.DevicePassportInstance = DevicePassportInstance;
+exports.PROXY_MISSING_NOTE = PROXY_MISSING_NOTE;
+exports.PROXY_RESOLUTION_NOTE = PROXY_RESOLUTION_NOTE;
+exports.PassportManager = PassportManager;
+exports.buildEgoSessionPlan = buildEgoSessionPlan;
+exports.buildProxyDeclaration = buildProxyDeclaration;
+exports.createEgoBridge = createEgoBridge;
+exports.createPassport = createPassport;
+exports.defaultTaskSpaceName = defaultTaskSpaceName;
+exports.getEgoNativeBridge = getEgoNativeBridge;
+exports.getProfileReadiness = getProfileReadiness;