chromiumfish 0.1.0 → 0.1.3

package/README.md

@@ -32,9 +32,27 @@ await browser.close();
 | `windowSize` | `[1920, 1080]` | Window dimensions (`null` to omit). |
 | `version` | pinned | Override the browser build version. |
 | `download` | `true` | Auto-download the build if missing. |
+| `timezone` | — | `"auto"` resolves the egress IP's IANA timezone via the downloadable `ip2tz` DB and sets the browser's `TZ`; an IANA string (e.g. `"Europe/Berlin"`) is used verbatim. |
 | `args` | — | Extra Chromium flags. |
 | _...rest_ | — | Forwarded to `chromium.launch()`. |
 
+### IP-to-Timezone
+
+`timezone: "auto"` aligns the browser clock with the egress IP (handy behind a
+proxy). It uses a compact `ip2tz` database downloaded once and cached; you can
+also query it directly:
+
+```ts
+import { lookupTimezone, resolveTimezone } from "chromiumfish";
+
+await lookupTimezone("8.8.8.8");   // -> "America/Los_Angeles"
+await resolveTimezone();           // own egress IP -> timezone
+```
+
+The DB auto-updates: it tracks the `latest` monthly build (cached, re-checked
+weekly), so you get fresh data without upgrading the SDK. Pin a fixed version
+with `CHROMIUMFISH_GEOIP_VERSION=2026.06` for reproducibility.
+
 ## CLI
 
 ```bash
@@ -47,6 +65,14 @@ npx chromiumfish --version
 Builds are cached under `~/.cache/chromiumfish/<version>/` (override with
 `CHROMIUMFISH_CACHE_DIR`). Pin a build with `CHROMIUMFISH_VERSION`.
 
+## Attribution
+
+IP Geolocation by <a href='https://db-ip.com'>DB-IP</a> — the `ip2tz` timezone
+database is derived from [DB-IP City Lite][dbip], used under [CC BY 4.0][ccby].
+
+[dbip]: https://db-ip.com/db/download/ip-to-city-lite
+[ccby]: https://creativecommons.org/licenses/by/4.0/
+
 ## License
 
 MIT © Arman Hossain. See the [repository](https://github.com/arman-bd/chromiumfish).

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { ChromiumFish, buildArgs, BASE_ARGS } from "./launcher.js";
 export type { ChromiumFishOptions } from "./launcher.js";
 export { fetchBrowser, binaryPath, installDir, cacheRoot, platformSlug, findBinary } from "./fetch.js";
-export { SDK_VERSION, DEFAULT_BROWSER_VERSION, RELEASE_REPO, browserVersion, releaseBaseUrl, } from "./version.js";
+export { Ip2TzDB, fetchDb, lookupTimezone, resolveTimezone, resolveVersion as resolveGeoipVersion, egressIp, assetName as ip2tzAssetName, dbPath as ip2tzDbPath, } from "./ip2tz.js";
+export { SDK_VERSION, DEFAULT_BROWSER_VERSION, DEFAULT_GEOIP_VERSION, GEOIP_FALLBACK_VERSION, RELEASE_REPO, browserVersion, releaseBaseUrl, geoipVersion, geoipBaseUrl, } from "./version.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export { ChromiumFish, buildArgs, BASE_ARGS } from "./launcher.js";
 export { fetchBrowser, binaryPath, installDir, cacheRoot, platformSlug, findBinary } from "./fetch.js";
-export { SDK_VERSION, DEFAULT_BROWSER_VERSION, RELEASE_REPO, browserVersion, releaseBaseUrl, } from "./version.js";
+export { Ip2TzDB, fetchDb, lookupTimezone, resolveTimezone, resolveVersion as resolveGeoipVersion, egressIp, assetName as ip2tzAssetName, dbPath as ip2tzDbPath, } from "./ip2tz.js";
+export { SDK_VERSION, DEFAULT_BROWSER_VERSION, DEFAULT_GEOIP_VERSION, GEOIP_FALLBACK_VERSION, RELEASE_REPO, browserVersion, releaseBaseUrl, geoipVersion, geoipBaseUrl, } from "./version.js";

package/dist/ip2tz.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Resolve a configured version (possibly the `"latest"` sentinel) to a concrete
+ * version like `"2026.06"`. Uses a cached pointer while fresh (< TTL); otherwise
+ * fetches the geoip-latest manifest. Falls back to a stale pointer, then to the
+ * compiled-in floor, so resolution never hard-fails offline.
+ */
+export declare function resolveVersion(version?: string, download?: boolean): Promise<string>;
+export declare function assetName(version?: string): string;
+export declare function dbPath(version?: string): string;
+export declare function fetchDb(version?: string, force?: boolean): Promise<string>;
+export declare class Ip2TzDB {
+    private tz;
+    private v4;
+    private v6;
+    private v4Count;
+    private v6Count;
+    readonly buildEpoch: number;
+    constructor(blob: Buffer);
+    static load(file: string): Ip2TzDB;
+    /** Index of the rightmost record whose start <= key (fixed-width BE compare). */
+    private static rightmost;
+    lookup(ip: string): string | null;
+}
+export declare function lookupTimezone(ip: string, version?: string, download?: boolean): Promise<string | null>;
+export declare function egressIp(proxy?: string, timeoutMs?: number): Promise<string | null>;
+export declare function resolveTimezone(opts?: {
+    ip?: string;
+    proxy?: string;
+    version?: string;
+    download?: boolean;
+}): Promise<string | null>;

package/dist/ip2tz.js

@@ -0,0 +1,311 @@
+/**
+ * IP-to-Timezone lookup backed by the downloadable `ip2tz` release asset.
+ *
+ * IP Geolocation by DB-IP (https://db-ip.com), CC BY 4.0.
+ *
+ * The asset is built offline by `packages/geoip/build_ip2tz.py` from DB-IP City
+ * Lite and published to GitHub Releases. At runtime this module downloads it
+ * once (SHA-256 verified, cached next to the browser build), then answers
+ * IP -> IANA timezone with a binary search over the raw record bytes — no
+ * per-call network round trip.
+ *
+ *   import { lookupTimezone, resolveTimezone } from "chromiumfish";
+ *   await lookupTimezone("8.8.8.8");   // -> "America/Los_Angeles"
+ *   await resolveTimezone();           // probe own egress IP -> its timezone
+ *
+ * Binary format is documented in build_ip2tz.py; reader and builder must stay
+ * in lock-step.
+ */
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as https from "node:https";
+import * as path from "node:path";
+import { cacheRoot } from "./fetch.js";
+import { GEOIP_FALLBACK_VERSION, geoipBaseUrl, geoipLatestManifestUrl, geoipVersion } from "./version.js";
+const MAGIC = Buffer.from("IP2TZ\x01", "latin1");
+const V4_REC = 6; // uint32 start + uint16 tz_idx
+const V6_REC = 18; // 16-byte start + uint16 tz_idx
+const EGRESS_PROBE = "https://ipinfo.io/json";
+const LATEST = "latest";
+// Seconds a resolved "latest" pointer is trusted before re-checking the
+// manifest. Override with CHROMIUMFISH_GEOIP_TTL.
+const LATEST_TTL = Number(process.env.CHROMIUMFISH_GEOIP_TTL) || 7 * 24 * 3600;
+function geoipDir() {
+    return path.join(cacheRoot(), "geoip");
+}
+function pointerPath() {
+    return path.join(geoipDir(), "latest.json");
+}
+function readPointer() {
+    try {
+        return JSON.parse(fs.readFileSync(pointerPath(), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function pointerFresh() {
+    try {
+        return Date.now() - fs.statSync(pointerPath()).mtimeMs < LATEST_TTL * 1000;
+    }
+    catch {
+        return false;
+    }
+}
+/** Best-effort resolution with NO network: fresh cached pointer, else floor. */
+function resolveVersionSync(version = geoipVersion()) {
+    if (version !== LATEST)
+        return version;
+    const p = readPointer();
+    if (p?.version && pointerFresh())
+        return p.version;
+    return p?.version || GEOIP_FALLBACK_VERSION;
+}
+/**
+ * Resolve a configured version (possibly the `"latest"` sentinel) to a concrete
+ * version like `"2026.06"`. Uses a cached pointer while fresh (< TTL); otherwise
+ * fetches the geoip-latest manifest. Falls back to a stale pointer, then to the
+ * compiled-in floor, so resolution never hard-fails offline.
+ */
+export async function resolveVersion(version = geoipVersion(), download = true) {
+    if (version !== LATEST)
+        return version;
+    const cached = readPointer();
+    if (cached?.version && pointerFresh())
+        return cached.version;
+    if (download) {
+        try {
+            const manifest = JSON.parse((await get(geoipLatestManifestUrl())).toString("utf8"));
+            if (manifest?.version) {
+                fs.mkdirSync(geoipDir(), { recursive: true });
+                fs.writeFileSync(pointerPath(), JSON.stringify(manifest));
+                return manifest.version;
+            }
+        }
+        catch (e) {
+            process.stderr.write(`[chromiumfish] could not resolve latest ip2tz version: ${e?.message || e}\n`);
+        }
+    }
+    return cached?.version || GEOIP_FALLBACK_VERSION;
+}
+export function assetName(version = geoipVersion()) {
+    return `ip2tz-${resolveVersionSync(version)}.bin`;
+}
+export function dbPath(version = geoipVersion()) {
+    return path.join(geoipDir(), `ip2tz-${resolveVersionSync(version)}.bin`);
+}
+function get(url) {
+    return new Promise((resolve, reject) => {
+        const go = (u) => https
+            .get(u, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                return go(res.headers.location);
+            }
+            if (res.statusCode !== 200) {
+                res.resume();
+                return reject(new Error(`HTTP ${res.statusCode}`));
+            }
+            const chunks = [];
+            res.on("data", (c) => chunks.push(c));
+            res.on("end", () => resolve(Buffer.concat(chunks)));
+        })
+            .on("error", reject);
+        go(url);
+    });
+}
+export async function fetchDb(version = geoipVersion(), force = false) {
+    const v = await resolveVersion(version); // concrete, e.g. "2026.06"
+    const dest = path.join(geoipDir(), `ip2tz-${v}.bin`);
+    if (fs.existsSync(dest) && !force)
+        return dest;
+    const url = `${geoipBaseUrl(v)}/ip2tz-${v}.bin`;
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    process.stderr.write(`[chromiumfish] downloading ${url}\n`);
+    const blob = await get(url);
+    try {
+        const expected = (await get(`${url}.sha256`)).toString("utf8").trim().split(/\s+/)[0];
+        const actual = createHash("sha256").update(blob).digest("hex");
+        if (actual !== expected)
+            throw new Error(`ip2tz checksum mismatch: ${actual} !== ${expected}`);
+    }
+    catch (e) {
+        if (String(e?.message || e).includes("HTTP"))
+            process.stderr.write("[chromiumfish] warning: no ip2tz .sha256 published, skipping verify\n");
+        else
+            throw e;
+    }
+    const tmp = `${dest}.part`;
+    fs.writeFileSync(tmp, blob);
+    fs.renameSync(tmp, dest);
+    return dest;
+}
+export class Ip2TzDB {
+    tz = [];
+    v4;
+    v6;
+    v4Count;
+    v6Count;
+    buildEpoch;
+    constructor(blob) {
+        if (!blob.subarray(0, MAGIC.length).equals(MAGIC))
+            throw new Error("not an ip2tz database (bad magic)");
+        this.buildEpoch = blob.readUInt32BE(6);
+        const tzCount = blob.readUInt16BE(10);
+        this.v4Count = blob.readUInt32BE(12);
+        this.v6Count = blob.readUInt32BE(16);
+        let off = 20;
+        for (let i = 0; i < tzCount; i++) {
+            const len = blob.readUInt8(off);
+            off += 1;
+            this.tz.push(blob.toString("utf8", off, off + len));
+            off += len;
+        }
+        this.v4 = blob.subarray(off, off + this.v4Count * V4_REC);
+        off += this.v4Count * V4_REC;
+        this.v6 = blob.subarray(off, off + this.v6Count * V6_REC);
+    }
+    static load(file) {
+        return new Ip2TzDB(fs.readFileSync(file));
+    }
+    /** Index of the rightmost record whose start <= key (fixed-width BE compare). */
+    static rightmost(block, count, rec, keylen, key) {
+        let lo = 0;
+        let hi = count;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            const base = mid * rec;
+            // block.compare(key, ...) returns sign(record_start - key); advance when
+            // record_start <= key so we land on the rightmost such record.
+            if (block.compare(key, 0, keylen, base, base + keylen) <= 0)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        return lo - 1;
+    }
+    lookup(ip) {
+        const v4 = parseV4(ip);
+        if (v4) {
+            const i = Ip2TzDB.rightmost(this.v4, this.v4Count, V4_REC, 4, v4);
+            if (i < 0)
+                return null;
+            return this.tz[this.v4.readUInt16BE(i * V4_REC + 4)] || null;
+        }
+        const v6 = parseV6(ip);
+        if (v6) {
+            // IPv4-mapped (::ffff:a.b.c.d) lives in the v4 subtree — route it there.
+            const mapped = v6.readBigUInt64BE(0) === 0n && v6.readUInt16BE(8) === 0 && v6.readUInt16BE(10) === 0xffff;
+            if (mapped) {
+                const key = v6.subarray(12, 16);
+                const i = Ip2TzDB.rightmost(this.v4, this.v4Count, V4_REC, 4, key);
+                return i < 0 ? null : this.tz[this.v4.readUInt16BE(i * V4_REC + 4)] || null;
+            }
+            const i = Ip2TzDB.rightmost(this.v6, this.v6Count, V6_REC, 16, v6);
+            if (i < 0)
+                return null;
+            return this.tz[this.v6.readUInt16BE(i * V6_REC + 16)] || null;
+        }
+        return null;
+    }
+}
+/** 4-byte BE buffer for a dotted IPv4, or null. */
+function parseV4(ip) {
+    const m = ip.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+    if (!m)
+        return null;
+    const b = Buffer.alloc(4);
+    for (let i = 0; i < 4; i++) {
+        const n = Number(m[i + 1]);
+        if (n > 255)
+            return null;
+        b[i] = n;
+    }
+    return b;
+}
+/** 16-byte BE buffer for an IPv6 string (handles ::, IPv4-mapped), or null. */
+function parseV6(ip) {
+    if (!ip.includes(":"))
+        return null;
+    // Map ::ffff:1.2.3.4 form by expanding its trailing dotted quad to hex.
+    let s = ip;
+    const dotted = s.match(/(.*:)(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+    if (dotted) {
+        const v4 = parseV4(`${dotted[2]}.${dotted[3]}.${dotted[4]}.${dotted[5]}`);
+        if (!v4)
+            return null;
+        s = dotted[1] + v4.subarray(0, 2).toString("hex") + ":" + v4.subarray(2, 4).toString("hex");
+    }
+    const halves = s.split("::");
+    if (halves.length > 2)
+        return null;
+    const head = halves[0] ? halves[0].split(":") : [];
+    const tail = halves.length === 2 && halves[1] ? halves[1].split(":") : [];
+    const fill = 8 - head.length - tail.length;
+    if (fill < 0 || (halves.length === 1 && head.length !== 8))
+        return null;
+    const groups = [...head, ...Array(halves.length === 2 ? fill : 0).fill("0"), ...tail];
+    if (groups.length !== 8)
+        return null;
+    const b = Buffer.alloc(16);
+    for (let i = 0; i < 8; i++) {
+        const n = parseInt(groups[i] || "0", 16);
+        if (Number.isNaN(n) || n > 0xffff)
+            return null;
+        b.writeUInt16BE(n, i * 2);
+    }
+    return b;
+}
+let cached = null;
+async function getDb(version = geoipVersion(), download = true) {
+    if (cached)
+        return cached;
+    const v = await resolveVersion(version, download);
+    let p = path.join(geoipDir(), `ip2tz-${v}.bin`);
+    if (!fs.existsSync(p)) {
+        if (!download)
+            throw new Error("ip2tz DB not installed. Call fetchDb().");
+        p = await fetchDb(v);
+    }
+    cached = Ip2TzDB.load(p);
+    return cached;
+}
+export async function lookupTimezone(ip, version = geoipVersion(), download = true) {
+    return (await getDb(version, download)).lookup(ip);
+}
+export function egressIp(proxy, timeoutMs = 8000) {
+    // Note: proxy support for the probe would require an https-proxy agent; when
+    // a proxy is configured we currently probe direct and rely on the caller to
+    // pass an explicit IP if egress differs.
+    void proxy;
+    return new Promise((resolve) => {
+        const req = https.get(EGRESS_PROBE, { headers: { "User-Agent": "chromiumfish" } }, (res) => {
+            let data = "";
+            res.setEncoding("utf8");
+            res.on("data", (c) => (data += c));
+            res.on("end", () => {
+                try {
+                    resolve(JSON.parse(data).ip || null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on("error", () => resolve(null));
+        req.setTimeout(timeoutMs, () => {
+            req.destroy();
+            resolve(null);
+        });
+    });
+}
+export async function resolveTimezone(opts = {}) {
+    const { proxy, version = geoipVersion(), download = true } = opts;
+    let ip = opts.ip;
+    if (!ip) {
+        ip = (await egressIp(proxy)) || undefined;
+        if (!ip)
+            return null;
+    }
+    return lookupTimezone(ip, version, download);
+}

package/dist/launcher.d.ts

@@ -16,6 +16,12 @@ export interface ChromiumFishOptions extends Omit<LaunchOptions, "executablePath
     version?: string;
     /** Auto-download the build if missing. Defaults to true. */
     download?: boolean;
+    /**
+     * Timezone handling. `"auto"` probes the egress IP and resolves it against
+     * the downloadable ip2tz DB; an IANA string (e.g. `"Europe/Berlin"`) is used
+     * verbatim; omit to leave the timezone untouched.
+     */
+    timezone?: string;
 }
 export declare function buildArgs(opts: ChromiumFishOptions): string[];
 /**

package/dist/launcher.js

@@ -1,5 +1,6 @@
 import { chromium } from "playwright-core";
 import { binaryPath } from "./fetch.js";
+import { resolveTimezone } from "./ip2tz.js";
 /**
  * Flags that keep the GPU-less / SwiftShader path working and the persona
  * engine happy. Mirrors the production launch_lean.sh defaults (minus anything
@@ -13,6 +14,17 @@ export const BASE_ARGS = [
     "--use-angle=swiftshader",
     "--enable-unsafe-swiftshader",
 ];
+/** Flatten a Playwright proxy option into a probe URL, or undefined. */
+function proxyToUrl(proxy) {
+    if (!proxy?.server)
+        return undefined;
+    const { server, username, password } = proxy;
+    if (username && server.includes("://")) {
+        const [scheme, host] = server.split("://", 2);
+        return `${scheme}://${username}:${password ?? ""}@${host}`;
+    }
+    return server;
+}
 export function buildArgs(opts) {
     const args = [...BASE_ARGS];
     if (opts.personaSeed !== undefined)
@@ -31,12 +43,28 @@ export function buildArgs(opts) {
  *   const browser = await ChromiumFish({ personaSeed: 27182, headless: true });
  */
 export async function ChromiumFish(opts = {}) {
-    const { personaSeed, headless = true, windowSize, version, download = true, args, ...launch } = opts;
+    const { personaSeed, headless = true, windowSize, version, download = true, timezone, args, ...launch } = opts;
     const executablePath = await binaryPath(version, download);
+    // Resolve the timezone before launch: "auto" -> egress IP via the ip2tz DB,
+    // an IANA string -> used as-is. Inject as the TZ env var so Chromium's ICU
+    // adopts it at process init (the production timezone source of truth).
+    let tz = null;
+    if (timezone) {
+        tz = timezone === "auto" ? await resolveTimezone({ proxy: proxyToUrl(launch.proxy), download }) : timezone;
+    }
+    let env = launch.env;
+    if (tz) {
+        env = {
+            ...process.env,
+            ...(launch.env ?? {}),
+            TZ: tz,
+        };
+    }
     return chromium.launch({
         executablePath,
         headless,
         args: buildArgs({ personaSeed, windowSize, args }),
         ...launch,
+        ...(env ? { env } : {}),
     });
 }

package/dist/version.d.ts

@@ -6,10 +6,29 @@
  * SDK downloads by default; override it with `CHROMIUMFISH_VERSION`.
  */
 /** SDK package version (kept in sync with package.json). */
-export declare const SDK_VERSION = "0.1.0";
+export declare const SDK_VERSION = "0.1.3";
 /** Default ChromiumFish browser build to fetch. Matches src/chrome/VERSION. */
 export declare const DEFAULT_BROWSER_VERSION = "150.0.7844";
 /** Public repo hosting the release assets. */
 export declare const RELEASE_REPO = "arman-bd/chromiumfish";
+/**
+ * IP-to-Timezone database, built by `packages/geoip/build_ip2tz.py`.
+ * IP Geolocation by DB-IP (https://db-ip.com), CC BY 4.0.
+ *
+ * Default `"latest"` auto-tracks the newest monthly build: the SDK reads a small
+ * pointer (the `geoip-latest` release manifest) to discover the current concrete
+ * version, so no SDK republish is needed when a new DB ships. Pin a specific
+ * version with `CHROMIUMFISH_GEOIP_VERSION` (e.g. `"2026.06"`) for reproducibility.
+ */
+export declare const DEFAULT_GEOIP_VERSION = "latest";
+/**
+ * Concrete version used when `"latest"` cannot be resolved (offline + no cached
+ * pointer). Bump occasionally so the offline floor stays recent.
+ */
+export declare const GEOIP_FALLBACK_VERSION = "2026.06";
 export declare function browserVersion(): string;
 export declare function releaseBaseUrl(version?: string): string;
+export declare function geoipVersion(): string;
+export declare function geoipBaseUrl(version?: string): string;
+/** Stable URL of the pointer that names the current concrete DB version. */
+export declare function geoipLatestManifestUrl(): string;

package/dist/version.js

@@ -6,14 +6,39 @@
  * SDK downloads by default; override it with `CHROMIUMFISH_VERSION`.
  */
 /** SDK package version (kept in sync with package.json). */
-export const SDK_VERSION = "0.1.0";
+export const SDK_VERSION = "0.1.3";
 /** Default ChromiumFish browser build to fetch. Matches src/chrome/VERSION. */
 export const DEFAULT_BROWSER_VERSION = "150.0.7844";
 /** Public repo hosting the release assets. */
 export const RELEASE_REPO = "arman-bd/chromiumfish";
+/**
+ * IP-to-Timezone database, built by `packages/geoip/build_ip2tz.py`.
+ * IP Geolocation by DB-IP (https://db-ip.com), CC BY 4.0.
+ *
+ * Default `"latest"` auto-tracks the newest monthly build: the SDK reads a small
+ * pointer (the `geoip-latest` release manifest) to discover the current concrete
+ * version, so no SDK republish is needed when a new DB ships. Pin a specific
+ * version with `CHROMIUMFISH_GEOIP_VERSION` (e.g. `"2026.06"`) for reproducibility.
+ */
+export const DEFAULT_GEOIP_VERSION = "latest";
+/**
+ * Concrete version used when `"latest"` cannot be resolved (offline + no cached
+ * pointer). Bump occasionally so the offline floor stays recent.
+ */
+export const GEOIP_FALLBACK_VERSION = "2026.06";
 export function browserVersion() {
     return process.env.CHROMIUMFISH_VERSION || DEFAULT_BROWSER_VERSION;
 }
 export function releaseBaseUrl(version = browserVersion()) {
     return `https://github.com/${RELEASE_REPO}/releases/download/v${version}`;
 }
+export function geoipVersion() {
+    return process.env.CHROMIUMFISH_GEOIP_VERSION || DEFAULT_GEOIP_VERSION;
+}
+export function geoipBaseUrl(version = geoipVersion()) {
+    return `https://github.com/${RELEASE_REPO}/releases/download/geoip-${version}`;
+}
+/** Stable URL of the pointer that names the current concrete DB version. */
+export function geoipLatestManifestUrl() {
+    return `https://github.com/${RELEASE_REPO}/releases/download/geoip-latest/latest.json`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chromiumfish",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Stealth Chromium build with a drop-in Playwright harness — fetches and launches the ChromiumFish browser.",
   "type": "module",
   "main": "./dist/index.js",