@testmuai/playwright-bindings 0.1.1

package/dist/vars.js

@@ -0,0 +1,656 @@
+/**
+ * Variable resolution for testmu.
+ *
+ * v(template) resolves {{...}} and ${...} placeholders:
+ * - Pure {{x}} → direct lookup from userStore (type-preserving); unresolved → ""
+ * - Embedded "prefix {{x}} suffix" → string interpolation; unresolved → ""
+ * - ${x} → testParams lookup, then userStore fallback (type-preserving when pure)
+ * - Non-string / non-template values → returned as-is
+ *
+ * vAsync(template) additionally resolves:
+ * - {{global.X}} → ATMS API or TESTMU_VAR_X env fallback
+ * - {{environment.X}} → ATMS API (with ENVIRONMENT_ID) or TESTMU_VAR_X env fallback
+ * - {{secrets.cat.KEY}} → process.env[KEY]
+ * - {{smart.X}} → local computation (no HTTP)
+ * - plain {{x}} / ${x} → delegates to sync v()
+ */
+import { authenticator } from "otplib";
+import { fetchWithAuth, ltAuthHeader } from "./http.js";
+import { _registerConfigureHook } from "./configure.js";
+// ---------------------------------------------------------------------------
+// Internal stores (module-level singletons, reset via _resetStore())
+// ---------------------------------------------------------------------------
+const userStore = new Map();
+const testParamsStore = new Map();
+const globalVariables = [];
+// ---------------------------------------------------------------------------
+// Regex — non-greedy, matches Python's re.compile(r"\{\{(.+?)\}\}")
+// ---------------------------------------------------------------------------
+const MUSTACHE_RE = /\{\{(.+?)\}\}/;
+const MUSTACHE_RE_G = /\{\{(.+?)\}\}/g;
+const DOLLAR_RE = /\$\{(.+?)\}/;
+const DOLLAR_RE_G = /\$\{(.+?)\}/g;
+// Matches a single bracket segment like "[0]" or a mixed segment like "key[0]"
+const BRACKET_RE = /^(\w+)\[(\d+)\]$/;
+const BRACKET_ONLY_RE = /^\[(\d+)\]$/;
+function applyTransform(value, t) {
+    switch (t) {
+        case "upper":
+            return String(value).toUpperCase();
+        case "lower":
+            return String(value).toLowerCase();
+        case "trim":
+            return String(value).trim();
+        case "str":
+            return String(value);
+        case "int": {
+            const n = Number(value);
+            if (!Number.isInteger(n) || isNaN(n))
+                throw new Error(`int transform: '${value}' is not an integer`);
+            return n;
+        }
+        case "float": {
+            const n = Number(value);
+            if (isNaN(n))
+                throw new Error(`float transform: '${value}' is not a number`);
+            return n;
+        }
+        // matches Python: str(value).lower() in ("true", "1", "yes")
+        case "bool": {
+            if (typeof value === "boolean")
+                return value;
+            return ["true", "1", "yes"].includes(String(value).toLowerCase());
+        }
+    }
+}
+/** Store a variable value into the given scope (default: user variables). */
+export function setVar(name, value, opts = {}) {
+    const scope = opts.scope ?? "user";
+    if (scope === "testParams") {
+        testParamsStore.set(name, value);
+    }
+    else {
+        userStore.set(name, value);
+    }
+}
+/** Reset all stores (for testing). */
+export function _resetStore() {
+    userStore.clear();
+    testParamsStore.clear();
+    globalVariables.length = 0;
+}
+/** Expose globalVariables for later tasks. */
+export function _getGlobalVariables() {
+    return globalVariables;
+}
+/** Return the user variable store as a plain object (for executeJs injection). */
+export function _getUserStore() {
+    return Object.fromEntries(userStore);
+}
+/** Append a global variable entry (called by configure() in Task 15). */
+export function _addGlobalVariable(g) {
+    globalVariables.push(g);
+}
+/**
+ * Resolve a template value.
+ *
+ * - Non-string → returned as-is.
+ * - No {{...}} or ${...} → returned as-is.
+ * - Pure {{x}} → type-preserving lookup; unresolved → "".
+ * - Pure ${x} → testParams then userStore lookup; unresolved → "".
+ * - Embedded (contains other text) → string interpolation; unresolved → "".
+ */
+export function v(template, opts = {}) {
+    // Non-string: pass through unchanged (JS idiom — differs from Python's None→"")
+    if (typeof template !== "string")
+        return template;
+    // Fast-path: no template patterns at all
+    if (!MUSTACHE_RE.test(template) && !DOLLAR_RE.test(template)) {
+        return template;
+    }
+    let result;
+    // Pure {{x}} — type-preserving; unresolved → ""
+    const pureMustacheName = extractPure(template, MUSTACHE_RE);
+    if (pureMustacheName !== null) {
+        const smart = maybeSmart(pureMustacheName);
+        result = smart.isSmart ? smart.value : resolveUserName(pureMustacheName);
+        return (opts.transform ? applyTransform(result, opts.transform) : result);
+    }
+    // Pure ${x} — type-preserving; unresolved → ""
+    const pureDollarName = extractPure(template, DOLLAR_RE);
+    if (pureDollarName !== null) {
+        result = lookupTestParams(pureDollarName);
+        return (opts.transform ? applyTransform(result, opts.transform) : result);
+    }
+    // Embedded template — string interpolation
+    let out = template.replace(MUSTACHE_RE_G, (_m, name) => {
+        const trimmed = name.trim();
+        const smart = maybeSmart(trimmed);
+        if (smart.isSmart)
+            return smart.value;
+        const val = resolveUserName(trimmed);
+        return val === "" ? "" : String(val);
+    });
+    out = out.replace(DOLLAR_RE_G, (_m, name) => {
+        const val = lookupTestParams(name.trim());
+        return val === "" ? "" : String(val);
+    });
+    result = out;
+    return (opts.transform ? applyTransform(result, opts.transform) : result);
+}
+// ---------------------------------------------------------------------------
+// Dot-path / bracket traversal helpers
+// ---------------------------------------------------------------------------
+/** Sentinel that means "key not found" — distinct from a stored undefined/null. */
+const MISSING = Symbol("testmu-missing");
+/**
+ * If val is a JSON-string that parses to a dict or list, return the parsed value.
+ * Otherwise return val unchanged. Mirrors Python's _parse_if_string.
+ */
+function parseIfJsonString(val) {
+    if (typeof val !== "string")
+        return val;
+    const s = val.trim();
+    if (s.startsWith("{") || s.startsWith("[")) {
+        try {
+            const parsed = JSON.parse(s);
+            if (typeof parsed === "object" && parsed !== null)
+                return parsed;
+        }
+        catch {
+            // not valid JSON — leave as string
+        }
+    }
+    return val;
+}
+/**
+ * Walk into `obj` using a dot/bracket path string.
+ *
+ * Examples:
+ *   "address.city"      on { address: { city: "Paris" } }  → "Paris"
+ *   "[1].id"            on [{ id: 1 }, { id: 2 }]          → 2
+ *   "users[0].name"     on { users: [{ name: "A" }] }       → "A"
+ *
+ * Returns MISSING when the path cannot be fully navigated.
+ * Parses JSON strings at each step before descending.
+ */
+function applyPath(value, path) {
+    const rawSegments = path.split(".");
+    const segments = rawSegments.filter((s) => s.length > 0);
+    let obj = parseIfJsonString(value);
+    for (const seg of segments) {
+        obj = parseIfJsonString(obj);
+        if (obj === null || obj === undefined)
+            return MISSING;
+        // Bracket-only segment: "[N]"
+        const bracketOnly = BRACKET_ONLY_RE.exec(seg);
+        if (bracketOnly) {
+            const idx = Number(bracketOnly[1]);
+            if (!Array.isArray(obj))
+                return MISSING;
+            if (idx < 0 || idx >= obj.length)
+                return MISSING;
+            obj = obj[idx];
+            continue;
+        }
+        // Mixed segment: "key[N]"
+        const mixed = BRACKET_RE.exec(seg);
+        if (mixed) {
+            const key = mixed[1];
+            const idx = Number(mixed[2]);
+            if (typeof obj !== "object" || Array.isArray(obj))
+                return MISSING;
+            const record = obj;
+            if (key === undefined || !(key in record))
+                return MISSING;
+            const inner = parseIfJsonString(record[key]);
+            if (!Array.isArray(inner))
+                return MISSING;
+            if (idx < 0 || idx >= inner.length)
+                return MISSING;
+            obj = inner[idx];
+            continue;
+        }
+        // Plain key or integer index
+        if (Array.isArray(obj)) {
+            const idx = Number(seg);
+            if (!Number.isInteger(idx) || isNaN(idx))
+                return MISSING;
+            if (idx < 0 || idx >= obj.length)
+                return MISSING;
+            obj = obj[idx];
+        }
+        else if (typeof obj === "object") {
+            const record = obj;
+            if (!(seg in record))
+                return MISSING;
+            obj = record[seg];
+        }
+        else {
+            return MISSING;
+        }
+    }
+    return obj;
+}
+/**
+ * Resolve a variable name that may contain dot-paths or bracket notation.
+ *
+ * Matches Python's _resolve_single for plain variables:
+ *   1. If name contains "." or "[", attempt dot-path traversal first:
+ *      - Extract root key (before first "." or "[")
+ *      - If root exists in store, traverse the rest of the path
+ *      - If traversal fails (MISSING), fall back to flat key lookup
+ *   2. Otherwise, direct flat key lookup.
+ *
+ * Returns the resolved value or "" when nothing found.
+ */
+function resolveUserName(name) {
+    const hasDot = name.includes(".");
+    const hasBracket = name.includes("[");
+    if (hasDot || hasBracket) {
+        // Extract root: everything before the first "." or "["
+        const firstDot = name.indexOf(".");
+        const firstBracket = name.indexOf("[");
+        let splitAt;
+        if (firstDot === -1)
+            splitAt = firstBracket;
+        else if (firstBracket === -1)
+            splitAt = firstDot;
+        else
+            splitAt = Math.min(firstDot, firstBracket);
+        const rootKey = name.slice(0, splitAt);
+        // Rest starts after "." or at "["; we pass the remainder including any "[" on the root
+        const afterRoot = name.slice(splitAt);
+        // Strip leading "." to get the path to pass to applyPath
+        const rest = afterRoot.startsWith(".") ? afterRoot.slice(1) : afterRoot;
+        if (userStore.has(rootKey) && rest.length > 0) {
+            const rootVal = userStore.get(rootKey);
+            const walked = applyPath(rootVal, rest);
+            if (walked !== MISSING)
+                return walked;
+        }
+    }
+    // Flat key lookup (also the fallback when root is absent or traversal fails)
+    if (userStore.has(name))
+        return userStore.get(name);
+    return "";
+}
+// ---------------------------------------------------------------------------
+// Smart variables — {{smart.X}} — computed, matching Python _resolve_smart
+// ---------------------------------------------------------------------------
+const MONTH_NAMES = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December",
+];
+// JS getDay(): Sunday=0..Saturday=6
+const DAY_NAMES = [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday",
+];
+// Python: ascii_letters + digits (a-z A-Z 0-9)
+const ALPHANUM = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+// Python: ascii_lowercase + digits
+const LOWERDIG = "abcdefghijklmnopqrstuvwxyz0123456789";
+function pad2(n) {
+    return n < 10 ? `0${n}` : String(n);
+}
+function fmtDate(d) {
+    return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+}
+function randInt(lo, hi) {
+    return Math.floor(Math.random() * (hi - lo + 1)) + lo;
+}
+function randStr(len, chars) {
+    let s = "";
+    for (let i = 0; i < len; i++)
+        s += chars[randInt(0, chars.length - 1)];
+    return s;
+}
+function startOfWeek(d) {
+    // Python: now - timedelta(days=now.weekday()); weekday() is Mon=0..Sun=6
+    const jsDow = d.getDay(); // Sun=0..Sat=6
+    const pyDow = jsDow === 0 ? 6 : jsDow - 1; // Mon=0..Sun=6
+    const r = new Date(d);
+    r.setDate(d.getDate() - pyDow);
+    return r;
+}
+function endOfWeek(d) {
+    const jsDow = d.getDay();
+    const pyDow = jsDow === 0 ? 6 : jsDow - 1;
+    const r = new Date(d);
+    r.setDate(d.getDate() + (6 - pyDow));
+    return r;
+}
+function daysInMonth(year, month0) {
+    // month0 is 0-indexed; new Date(y, m+1, 0) gives last day of month m
+    return new Date(year, month0 + 1, 0).getDate();
+}
+function computeSmartVariable(name) {
+    const now = new Date();
+    switch (name) {
+        // Date/time (Python strftime format strings)
+        case "current_date":
+            return fmtDate(now); // %Y-%m-%d
+        case "current_day":
+            return DAY_NAMES[now.getDay()]; // %A  e.g. "Monday"
+        case "current_month_number":
+            return pad2(now.getMonth() + 1); // %m  e.g. "03"
+        case "current_year":
+            return String(now.getFullYear()); // %Y
+        case "current_month":
+            return MONTH_NAMES[now.getMonth()]; // %B  e.g. "March"
+        case "current_hour":
+            return pad2(now.getHours()); // %H
+        case "current_minute":
+            return pad2(now.getMinutes()); // %M
+        case "current_timestamp":
+            return `${fmtDate(now)} ${pad2(now.getHours())}:${pad2(now.getMinutes())}:${pad2(now.getSeconds())}`; // %Y-%m-%d %H:%M:%S
+        case "current_timezone":
+            return Intl.DateTimeFormat().resolvedOptions().timeZone; // time.strftime("%Z")
+        // Date arithmetic
+        case "next_day": {
+            const d = new Date(now);
+            d.setDate(d.getDate() + 1);
+            return fmtDate(d);
+        }
+        case "previous_day": {
+            const d = new Date(now);
+            d.setDate(d.getDate() - 1);
+            return fmtDate(d);
+        }
+        case "start_of_week":
+            return fmtDate(startOfWeek(now));
+        case "end_of_week":
+            return fmtDate(endOfWeek(now));
+        case "start_of_month":
+            return fmtDate(new Date(now.getFullYear(), now.getMonth(), 1));
+        case "end_of_month":
+            return fmtDate(new Date(now.getFullYear(), now.getMonth(), daysInMonth(now.getFullYear(), now.getMonth())));
+        // Random (Python-exact ranges)
+        case "random_int":
+            return String(randInt(100, 999)); // randint(100, 999)
+        case "random_float":
+            return String(Math.round((Math.random() * 99 + 1) * 100) / 100); // round(uniform(1,100), 2)
+        case "random_string_8":
+            return randStr(8, ALPHANUM);
+        case "random_string_56":
+            return randStr(56, ALPHANUM);
+        case "random_email":
+            return `${randStr(10, LOWERDIG)}@example.com`;
+        case "random_phone":
+            return String(randInt(1_000_000_000, 9_999_999_999)); // randint(1e9, 9.999...e9)
+        // Static geo (exact literals from Python)
+        case "latitude":
+            return "13.2257";
+        case "longitude":
+            return "77.5750";
+        case "country":
+            return "India";
+        case "city":
+            return "Doddaballapura";
+        case "ip_address":
+            return "143.110.182.88";
+        // Env-backed system info (Python: os.getenv("LT_USERNAME", ""), etc.)
+        case "user_name":
+            return process.env["LT_USERNAME"] ?? "";
+        case "os_type":
+        // falls through
+        case "os":
+            return process.env["smart_os"] ?? "";
+        case "os_version":
+            return process.env["smart_os_version"] ?? "";
+        case "browser_name":
+            return process.env["smart_browser_name"] ?? "";
+        case "browser_version":
+            return process.env["smart_browser_version"] ?? "";
+        default:
+            return "";
+    }
+}
+/** If name starts with "smart.", compute the smart variable. */
+function maybeSmart(name) {
+    if (!name.startsWith("smart."))
+        return { isSmart: false };
+    return {
+        isSmart: true,
+        value: computeSmartVariable(name.slice("smart.".length)),
+    };
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * If `template` is exactly one placeholder matching `re`, return the captured
+ * group (trimmed). Otherwise return null.
+ *
+ * Uses an anchored regex so "{{a}} {{b}}" is NOT considered pure.
+ *
+ * noUncheckedIndexedAccess: m[1] is string|undefined — use `m[1] ?? null`.
+ */
+function extractPure(template, re) {
+    const anchored = new RegExp(`^${re.source}$`);
+    const m = template.match(anchored);
+    if (!m)
+        return null;
+    const captured = m[1];
+    return captured !== undefined ? captured.trim() : null;
+}
+/** Look up a name from userStore. Returns "" if not found. */
+function lookupUser(name) {
+    if (userStore.has(name))
+        return userStore.get(name);
+    return "";
+}
+/**
+ * Look up a name from testParamsStore, falling back to userStore.
+ * Returns "" if not found in either (matches Python: _test_params.get(name, _variable_store.get(name, ""))).
+ */
+function lookupTestParams(name) {
+    if (testParamsStore.has(name))
+        return testParamsStore.get(name);
+    if (userStore.has(name))
+        return userStore.get(name);
+    return "";
+}
+/**
+ * GET {ATMS_URL}/api/v1/variables/{name}?environment_id={id}
+ *
+ * Matches Python _atms_get_variable: always includes environment_id (0 for global).
+ * Response: resp.json()["data"] — then .value from that dict.
+ * ATMS_URL has no default (empty string if unset) — mirrors Python.
+ */
+async function atmsGetVariable(name, environmentId = 0) {
+    const base = (process.env["ATMS_URL"] ?? "").replace(/\/$/, "");
+    const url = `${base}/api/v1/variables/${encodeURIComponent(name)}?environment_id=${environmentId}`;
+    const resp = await fetchWithAuth(url, { method: "GET" });
+    if (!resp.ok)
+        throw new Error(`ATMS variable fetch failed for '${name}': ${resp.status}`);
+    const body = (await resp.json());
+    return body.data.value;
+}
+/**
+ * Resolve a special async variable prefix: global., environment., secrets.
+ * Throws a descriptive error when resolution fails.
+ */
+async function resolveSpecialAsync(name) {
+    // {{global.X}} → ATMS (environment_id=0) or TESTMU_VAR_X fallback
+    if (name.startsWith("global.")) {
+        const varName = name.slice("global.".length);
+        if (!ltAuthHeader()) {
+            const envVal = process.env[`TESTMU_VAR_${varName}`];
+            if (envVal === undefined) {
+                throw new Error(`Cannot resolve {{global.${varName}}}: no LT credentials and no TESTMU_VAR_${varName} env var set`);
+            }
+            return envVal;
+        }
+        try {
+            return await atmsGetVariable(varName, 0);
+        }
+        catch (err) {
+            const envVal = process.env[`TESTMU_VAR_${varName}`];
+            if (envVal !== undefined)
+                return envVal;
+            throw new Error(`Cannot resolve {{global.${varName}}}: ATMS failed and no TESTMU_VAR_${varName} env var set`);
+        }
+    }
+    // {{environment.X}} → ATMS with ENVIRONMENT_ID or TESTMU_VAR_X fallback
+    if (name.startsWith("environment.")) {
+        const varName = name.slice("environment.".length);
+        if (!ltAuthHeader()) {
+            const envVal = process.env[`TESTMU_VAR_${varName}`];
+            if (envVal === undefined) {
+                throw new Error(`Cannot resolve {{environment.${varName}}}: no LT credentials and no TESTMU_VAR_${varName} env var set`);
+            }
+            return envVal;
+        }
+        try {
+            const envId = parseInt(process.env["ENVIRONMENT_ID"] ?? "0", 10);
+            return await atmsGetVariable(varName, envId);
+        }
+        catch (err) {
+            const envVal = process.env[`TESTMU_VAR_${varName}`];
+            if (envVal !== undefined)
+                return envVal;
+            throw new Error(`Cannot resolve {{environment.${varName}}}: ATMS failed and no TESTMU_VAR_${varName} env var set`);
+        }
+    }
+    // {{secrets.cat.KEY}} → process.env[KEY]
+    if (name.startsWith("secrets.")) {
+        const parts = name.split(".");
+        const key = parts[parts.length - 1];
+        if (!key)
+            throw new Error(`Invalid secrets path: ${name}`);
+        const val = process.env[key];
+        if (val === undefined)
+            throw new Error(`Cannot resolve {{${name}}}: env var '${key}' not set`);
+        return val;
+    }
+    // {{totp.X}} → ATMS seed + otplib generate, or TESTMU_TOTP_X env fallback (also a seed)
+    if (name.startsWith("totp.")) {
+        const varName = name.slice("totp.".length);
+        let seed;
+        if (!ltAuthHeader()) {
+            const envVal = process.env[`TESTMU_TOTP_${varName}`];
+            if (envVal === undefined) {
+                throw new Error(`Cannot resolve {{totp.${varName}}}: no LT credentials and no TESTMU_TOTP_${varName} env var set`);
+            }
+            seed = envVal;
+        }
+        else {
+            // GET {ATMS_URL}/api/v1/variables/totp/{name} — resp.json()["data"] is the seed string
+            const base = (process.env["ATMS_URL"] ?? "").replace(/\/$/, "");
+            const url = `${base}/api/v1/variables/totp/${encodeURIComponent(varName)}`;
+            const resp = await fetchWithAuth(url, { method: "GET" });
+            if (!resp.ok)
+                throw new Error(`TOTP seed fetch failed for '${varName}': ${resp.status}`);
+            const body = (await resp.json());
+            seed = body.data;
+        }
+        return authenticator.generate(seed);
+    }
+    throw new Error(`Unknown special variable prefix: ${name}`);
+}
+/**
+ * Async variable resolution — extends v() with HTTP-backed lookups.
+ *
+ * - {{global.X}} → ATMS or TESTMU_VAR_X fallback
+ * - {{environment.X}} → ATMS (with ENVIRONMENT_ID) or TESTMU_VAR_X fallback
+ * - {{secrets.cat.KEY}} → process.env[KEY]
+ * - {{smart.X}} → local computation (no HTTP)
+ * - plain {{x}} / ${x} → delegates to sync v()
+ */
+export async function vAsync(template, opts = {}) {
+    if (typeof template !== "string")
+        return template;
+    let result;
+    // Pure single-placeholder: {{name}}
+    const pureName = extractPure(template, MUSTACHE_RE);
+    if (pureName !== null) {
+        if (pureName.startsWith("smart.")) {
+            result = computeSmartVariable(pureName.slice("smart.".length));
+        }
+        else if (pureName.startsWith("global.") ||
+            pureName.startsWith("environment.") ||
+            pureName.startsWith("secrets.") ||
+            pureName.startsWith("totp.")) {
+            result = await resolveSpecialAsync(pureName);
+        }
+        else {
+            // Delegate to sync v() for plain variables (without transform — apply below)
+            result = v(template);
+        }
+        return (opts.transform ? applyTransform(result, opts.transform) : result);
+    }
+    // Pure ${x} — delegate sync (without transform — apply below)
+    const pureDollar = extractPure(template, DOLLAR_RE);
+    if (pureDollar !== null) {
+        result = v(template);
+        return (opts.transform ? applyTransform(result, opts.transform) : result);
+    }
+    // Embedded template — resolve {{...}} placeholders asynchronously
+    if (!MUSTACHE_RE.test(template) && !DOLLAR_RE.test(template)) {
+        return template;
+    }
+    const matches = [...template.matchAll(MUSTACHE_RE_G)];
+    const replacements = [];
+    for (const match of matches) {
+        const inner = (match[1] ?? "").trim();
+        if (inner.startsWith("smart.")) {
+            replacements.push(computeSmartVariable(inner.slice("smart.".length)));
+        }
+        else if (inner.startsWith("global.") ||
+            inner.startsWith("environment.") ||
+            inner.startsWith("secrets.") ||
+            inner.startsWith("totp.")) {
+            replacements.push(await resolveSpecialAsync(inner));
+        }
+        else {
+            const sync = v(`{{${inner}}}`);
+            replacements.push(sync === "" ? "" : String(sync));
+        }
+    }
+    let out = template;
+    for (let i = 0; i < matches.length; i++) {
+        out = out.replace(matches[i][0], replacements[i]);
+    }
+    // ${...} through sync path
+    out = out.replace(DOLLAR_RE_G, (_m, name) => {
+        const val = lookupTestParams(name.trim());
+        return val === "" ? "" : String(val);
+    });
+    result = out;
+    return (opts.transform ? applyTransform(result, opts.transform) : result);
+}
+// ---------------------------------------------------------------------------
+// configure() → vars store wiring (registered once at module load)
+// ---------------------------------------------------------------------------
+_registerConfigureHook((opts) => {
+    if (opts.variables) {
+        for (const [k, val] of Object.entries(opts.variables))
+            setVar(k, val);
+    }
+    if (opts.testParams) {
+        for (const [k, val] of Object.entries(opts.testParams))
+            setVar(k, val, { scope: "testParams" });
+    }
+    if (opts.globalVariables) {
+        for (const g of opts.globalVariables)
+            _addGlobalVariable(g);
+    }
+});
+//# sourceMappingURL=vars.js.map