@glubean/sdk 0.1.0

package/dist/configure.d.ts

@@ -0,0 +1,141 @@
+/**
+ * File-level configuration for Glubean tests.
+ *
+ * `configure()` lets you declare shared dependencies (vars, secrets, HTTP config)
+ * once at the top of a test file (or in a shared `configure.ts`), eliminating
+ * repetitive `ctx.vars.require()` / `ctx.secrets.require()` calls in every test.
+ *
+ * All returned values are **lazy** — they are not resolved until a test function
+ * actually accesses them at runtime. This means:
+ * - Safe to call at module top-level (scanner won't trigger resolution)
+ * - Safe to share across files via re-exports
+ * - Each test execution gets the correct runtime values
+ *
+ * @example Single file usage
+ * ```ts
+ * import { test, configure } from "@glubean/sdk";
+ *
+ * const { vars, secrets, http } = configure({
+ *   vars: { baseUrl: "BASE_URL" },
+ *   secrets: { apiKey: "API_KEY" },
+ *   http: {
+ *     prefixUrl: "BASE_URL",
+ *     headers: { Authorization: "Bearer {{API_KEY}}" },
+ *   },
+ * });
+ *
+ * export const listUsers = test("list-users", async (ctx) => {
+ *   const res = await http.get("users").json();
+ *   ctx.assert(res.length > 0, "has users");
+ * });
+ * ```
+ *
+ * @example Shared across files (tests/configure.ts)
+ * ```ts
+ * // tests/configure.ts
+ * import { configure } from "@glubean/sdk";
+ * export const { vars, secrets, http } = configure({
+ *   vars: { baseUrl: "BASE_URL" },
+ *   http: { prefixUrl: "BASE_URL" },
+ * });
+ *
+ * // tests/users.test.ts
+ * import { test } from "@glubean/sdk";
+ * import { http } from "./configure.js";
+ *
+ * export const listUsers = test("list-users", async (ctx) => {
+ *   const res = await http.get("users").json();
+ * });
+ * ```
+ *
+ * @module configure
+ */
+import type { ConfigureOptions, ConfigureResult, GlubeanAction, GlubeanEvent, GlubeanRuntime, HttpClient, PluginEntry, PluginFactory, ReservedConfigureKeys, ResolvePlugins } from "./types.js";
+/**
+ * Shape of the runtime context injected by the harness before test execution.
+ * This is the internal shape — the public `GlubeanRuntime` in types.ts adds
+ * helper methods (requireVar, requireSecret, resolveTemplate) for plugins.
+ *
+ * @internal
+ */
+export interface InternalRuntime {
+    vars: Record<string, string>;
+    secrets: Record<string, string>;
+    http: HttpClient;
+    test?: GlubeanRuntime["test"];
+    action?(a: GlubeanAction): void;
+    event?(ev: GlubeanEvent): void;
+    log?(message: string, data?: unknown): void;
+}
+/**
+ * Resolve `{{key}}` template placeholders in a string using runtime vars and secrets.
+ * Secrets take precedence over vars if both have the same key.
+ *
+ * This is used internally by `buildLazyHttp()` and exposed to plugin authors
+ * via `GlubeanRuntime.resolveTemplate()`.
+ */
+export declare function resolveTemplate(template: string, vars: Record<string, string>, secrets: Record<string, string>): string;
+/**
+ * Declare file-level dependencies on vars, secrets, and HTTP configuration.
+ *
+ * Returns lazy accessors that resolve at test runtime, not at import time.
+ * All declared vars and secrets are **required** — missing values cause the test
+ * to fail immediately with a clear error message.
+ *
+ * The returned objects can be shared across files via re-exports.
+ *
+ * @param options Configuration declaring vars, secrets, and HTTP defaults
+ * @returns Lazy accessors for vars, secrets, and a pre-configured HTTP client
+ *
+ * @example Basic usage
+ * ```ts
+ * import { test, configure } from "@glubean/sdk";
+ *
+ * const { vars, http } = configure({
+ *   vars: { baseUrl: "base_url" },
+ *   http: { prefixUrl: "base_url" },
+ * });
+ *
+ * export const listUsers = test("list-users", async (ctx) => {
+ *   const res = await http.get("users").json();
+ *   ctx.log(`Base URL: ${vars.baseUrl}`);
+ * });
+ * ```
+ *
+ * @example Full configuration with secrets
+ * ```ts
+ * const { vars, secrets, http } = configure({
+ *   vars: { baseUrl: "base_url", orgId: "org_id" },
+ *   secrets: { apiKey: "api_key" },
+ *   http: {
+ *     prefixUrl: "base_url",
+ *     headers: { Authorization: "Bearer {{api_key}}" },
+ *   },
+ * });
+ * ```
+ *
+ * @example Shared across test files
+ * ```ts
+ * // tests/configure.ts
+ * export const { vars, secrets, http } = configure({ ... });
+ *
+ * // tests/users.test.ts
+ * import { http, vars } from "./configure.js";
+ * ```
+ */
+export declare function configure<V extends Record<string, string> = Record<string, string>, S extends Record<string, string> = Record<string, string>, P extends Record<string, PluginFactory<any> | PluginEntry<any>> = Record<string, never>>(options: ConfigureOptions & {
+    vars?: {
+        [K in keyof V]: string;
+    };
+    secrets?: {
+        [K in keyof S]: string;
+    };
+    plugins?: P & {
+        [K in ReservedConfigureKeys]?: never;
+    };
+}): ConfigureResult<{
+    [K in keyof V]: string;
+}, {
+    [K in keyof S]: string;
+}> & ResolvePlugins<P>;
+//# sourceMappingURL=configure.d.ts.map

package/dist/configure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../src/configure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,KAAK,EAEV,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,YAAY,EACZ,cAAc,EACd,UAAU,EAGV,WAAW,EACX,aAAa,EAEb,qBAAqB,EACrB,cAAc,EACf,MAAM,YAAY,CAAC;AAMpB;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IAC9B,MAAM,CAAC,CAAC,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAChC,KAAK,CAAC,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAAC;IAC/B,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC7C;AA0GD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,MAAM,CAYR;AA6YD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,SAAS,CACvB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACzD,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAEzD,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CACtE,MAAM,EACN,KAAK,CACN,EAED,OAAO,EAAE,gBAAgB,GAAG;IAC1B,IAAI,CAAC,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM;KAAE,CAAC;IAClC,OAAO,CAAC,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM;KAAE,CAAC;IACrC,OAAO,CAAC,EAAE,CAAC,GAAG;SAAG,CAAC,IAAI,qBAAqB,CAAC,CAAC,EAAE,KAAK;KAAE,CAAC;CACxD,GAEC,eAAe,CACf;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM;CAAE,EAC1B;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM;CAAE,CAC3B,GACC,cAAc,CAAC,CAAC,CAAC,CAuBpB"}

package/dist/configure.js

@@ -0,0 +1,535 @@
+/**
+ * File-level configuration for Glubean tests.
+ *
+ * `configure()` lets you declare shared dependencies (vars, secrets, HTTP config)
+ * once at the top of a test file (or in a shared `configure.ts`), eliminating
+ * repetitive `ctx.vars.require()` / `ctx.secrets.require()` calls in every test.
+ *
+ * All returned values are **lazy** — they are not resolved until a test function
+ * actually accesses them at runtime. This means:
+ * - Safe to call at module top-level (scanner won't trigger resolution)
+ * - Safe to share across files via re-exports
+ * - Each test execution gets the correct runtime values
+ *
+ * @example Single file usage
+ * ```ts
+ * import { test, configure } from "@glubean/sdk";
+ *
+ * const { vars, secrets, http } = configure({
+ *   vars: { baseUrl: "BASE_URL" },
+ *   secrets: { apiKey: "API_KEY" },
+ *   http: {
+ *     prefixUrl: "BASE_URL",
+ *     headers: { Authorization: "Bearer {{API_KEY}}" },
+ *   },
+ * });
+ *
+ * export const listUsers = test("list-users", async (ctx) => {
+ *   const res = await http.get("users").json();
+ *   ctx.assert(res.length > 0, "has users");
+ * });
+ * ```
+ *
+ * @example Shared across files (tests/configure.ts)
+ * ```ts
+ * // tests/configure.ts
+ * import { configure } from "@glubean/sdk";
+ * export const { vars, secrets, http } = configure({
+ *   vars: { baseUrl: "BASE_URL" },
+ *   http: { prefixUrl: "BASE_URL" },
+ * });
+ *
+ * // tests/users.test.ts
+ * import { test } from "@glubean/sdk";
+ * import { http } from "./configure.js";
+ *
+ * export const listUsers = test("list-users", async (ctx) => {
+ *   const res = await http.get("users").json();
+ * });
+ * ```
+ *
+ * @module configure
+ */
+/**
+ * Get the current runtime context from the global slot.
+ * Throws a clear error if accessed outside of test execution (e.g., at scan time).
+ *
+ * @internal
+ */
+function getRuntime() {
+    const runtime = globalThis.__glubeanRuntime;
+    if (!runtime) {
+        throw new Error("configure() values can only be accessed during test execution. " +
+            "Did you try to read a var or secret at module load time? " +
+            "Move the access inside a test function.");
+    }
+    return runtime;
+}
+/**
+ * Require a var from the runtime context.
+ * Throws if the var is missing or empty.
+ *
+ * @internal
+ */
+function requireVar(key) {
+    const runtime = getRuntime();
+    const value = runtime.vars[key];
+    if (value === undefined || value === null || value === "") {
+        throw new Error(`Missing required var: ${key}`);
+    }
+    return value;
+}
+/**
+ * Require a secret from the runtime context.
+ * Throws if the secret is missing or empty.
+ *
+ * @internal
+ */
+function requireSecret(key) {
+    const runtime = getRuntime();
+    const value = runtime.secrets[key];
+    if (value === undefined || value === null || value === "") {
+        throw new Error(`Missing required secret: ${key}`);
+    }
+    return value;
+}
+// =============================================================================
+// Lazy proxy builders
+// =============================================================================
+/**
+ * Regex for `{{key}}` template placeholders in header values.
+ */
+const TEMPLATE_RE = /\{\{([\w-]+)\}\}/g;
+/**
+ * Build a lazy vars accessor object.
+ * Each property is a getter that calls `requireVar()` on access.
+ *
+ * @internal
+ */
+function buildLazyVars(mapping) {
+    const obj = {};
+    for (const [prop, varKey] of Object.entries(mapping)) {
+        Object.defineProperty(obj, prop, {
+            get() {
+                return requireVar(varKey);
+            },
+            enumerable: true,
+            configurable: false,
+        });
+    }
+    return obj;
+}
+/**
+ * Build a lazy secrets accessor object.
+ * Each property is a getter that calls `requireSecret()` on access.
+ *
+ * @internal
+ */
+function buildLazySecrets(mapping) {
+    const obj = {};
+    for (const [prop, secretKey] of Object.entries(mapping)) {
+        Object.defineProperty(obj, prop, {
+            get() {
+                return requireSecret(secretKey);
+            },
+            enumerable: true,
+            configurable: false,
+        });
+    }
+    return obj;
+}
+/**
+ * Resolve `{{key}}` template placeholders in a string using runtime vars and secrets.
+ * Secrets take precedence over vars if both have the same key.
+ *
+ * This is used internally by `buildLazyHttp()` and exposed to plugin authors
+ * via `GlubeanRuntime.resolveTemplate()`.
+ */
+export function resolveTemplate(template, vars, secrets) {
+    return template.replace(TEMPLATE_RE, (_match, key) => {
+        // Try secrets first (more likely for auth headers), then vars
+        const value = secrets[key] ?? vars[key];
+        if (value === undefined || value === null || value === "") {
+            throw new Error(`Missing value for template placeholder "{{${key}}}" in configure() http headers. ` +
+                `Ensure "${key}" is available as a var or secret.`);
+        }
+        return value;
+    });
+}
+/**
+ * Build a lazy HTTP client proxy.
+ * On first method call, resolves the config and creates an extended client.
+ *
+ * @internal
+ */
+function buildLazyHttp(httpOptions) {
+    // Cache the resolved client per runtime identity to avoid re-extending on every call.
+    // Since each test runs in its own subprocess, a WeakMap keyed on runtime object
+    // ensures we get one extended client per test execution.
+    const cache = new WeakMap();
+    function getClient() {
+        const runtime = getRuntime();
+        let client = cache.get(runtime);
+        if (client)
+            return client;
+        // Build ky-compatible options from the configure http config
+        const extendOptions = {};
+        if (httpOptions.prefixUrl) {
+            extendOptions.prefixUrl = requireVar(httpOptions.prefixUrl);
+        }
+        if (httpOptions.headers) {
+            const resolvedHeaders = {};
+            for (const [name, template] of Object.entries(httpOptions.headers)) {
+                resolvedHeaders[name] = resolveTemplate(template, runtime.vars, runtime.secrets);
+            }
+            extendOptions.headers = resolvedHeaders;
+        }
+        if (httpOptions.timeout !== undefined) {
+            extendOptions.timeout = httpOptions.timeout;
+        }
+        if (httpOptions.retry !== undefined) {
+            extendOptions.retry = httpOptions.retry;
+        }
+        if (httpOptions.throwHttpErrors !== undefined) {
+            extendOptions.throwHttpErrors = httpOptions.throwHttpErrors;
+        }
+        if (httpOptions.hooks) {
+            extendOptions.hooks = httpOptions.hooks;
+        }
+        client = runtime.http.extend(extendOptions);
+        cache.set(runtime, client);
+        return client;
+    }
+    // Create a callable proxy that delegates all method calls to the lazily-resolved client.
+    const HTTP_METHODS = [
+        "get",
+        "post",
+        "put",
+        "patch",
+        "delete",
+        "head",
+    ];
+    // The callable function (for `http(url, options)` shorthand)
+    const proxy = function (url, options) {
+        return getClient()(url, options);
+    };
+    // Method shortcuts
+    for (const method of HTTP_METHODS) {
+        proxy[method] = (url, options) => getClient()[method](url, options);
+    }
+    // extend() — returns a new HttpClient that merges options with the resolved base
+    proxy.extend = (options) => getClient().extend(options);
+    return proxy;
+}
+// =============================================================================
+// Lazy plugin builder
+// =============================================================================
+/**
+ * Build lazy property descriptors for plugin factories.
+ * Each plugin is instantiated on first property access with a WeakMap cache
+ * keyed by the internal runtime identity.
+ *
+ * Returns PropertyDescriptorMap (not a ready object) so the caller can use
+ * Object.defineProperties() without triggering getters via spread.
+ *
+ * @internal
+ */
+/** Reserved keys that plugins cannot shadow. */
+const RESERVED_KEYS = new Set(["vars", "secrets", "http"]);
+function normalizePluginEntry(entry) {
+    if ("factory" in entry)
+        return entry;
+    return { factory: entry };
+}
+function toMethodList(value) {
+    if (!value)
+        return [];
+    const list = Array.isArray(value) ? value : [value];
+    return list.map((method) => method.toUpperCase());
+}
+function toUrlString(input) {
+    if (input instanceof Request)
+        return input.url;
+    if (input instanceof URL)
+        return input.toString();
+    return input;
+}
+function toPathname(input) {
+    try {
+        if (input instanceof Request)
+            return new URL(input.url).pathname;
+        if (input instanceof URL)
+            return input.pathname;
+        const isAbsolute = /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(input);
+        const parsed = isAbsolute ? new URL(input) : new URL(input, "http://glubean.local");
+        return parsed.pathname;
+    }
+    catch {
+        return "";
+    }
+}
+function matchesPattern(value, pattern) {
+    if (pattern instanceof RegExp)
+        return pattern.test(value);
+    return value.startsWith(pattern);
+}
+function matchesRequestMatcher(matcher, method, url) {
+    const methods = toMethodList(matcher.method);
+    if (methods.length > 0 && !methods.includes(method)) {
+        return false;
+    }
+    if (matcher.url) {
+        const rawUrl = toUrlString(url);
+        if (!matchesPattern(rawUrl, matcher.url)) {
+            return false;
+        }
+    }
+    if (matcher.path) {
+        const pathname = toPathname(url);
+        if (!matchesPattern(pathname, matcher.path)) {
+            return false;
+        }
+    }
+    return true;
+}
+function evaluateRequestActivation(activation, method, url) {
+    const rules = activation?.requests;
+    if (!rules)
+        return { active: true };
+    const exclude = rules.exclude ?? [];
+    if (exclude.some((matcher) => matchesRequestMatcher(matcher, method, url))) {
+        return {
+            active: false,
+            reason: "request matches activation.requests.exclude",
+        };
+    }
+    const include = rules.include ?? [];
+    if (include.length > 0 && !include.some((matcher) => matchesRequestMatcher(matcher, method, url))) {
+        return {
+            active: false,
+            reason: "request does not match activation.requests.include",
+        };
+    }
+    return { active: true };
+}
+function evaluateTagActivation(activation, runtime) {
+    const rules = activation?.tags;
+    if (!rules)
+        return { active: true };
+    const runtimeTags = new Set(runtime.test?.tags ?? []);
+    const disable = rules.disable ?? [];
+    for (const tag of disable) {
+        if (runtimeTags.has(tag)) {
+            return {
+                active: false,
+                reason: `test tag "${tag}" matches activation.tags.disable`,
+            };
+        }
+    }
+    const enable = rules.enable ?? [];
+    if (enable.length > 0) {
+        const matched = enable.some((tag) => runtimeTags.has(tag));
+        if (!matched) {
+            return {
+                active: false,
+                reason: `current test tags do not match activation.tags.enable (${enable.join(", ")})`,
+            };
+        }
+    }
+    return { active: true };
+}
+function buildActivationAwareHttpClient(pluginName, activation, http) {
+    if (!activation?.requests)
+        return http;
+    function assertRequestActive(method, url) {
+        const decision = evaluateRequestActivation(activation, method, url);
+        if (decision.active)
+            return;
+        throw new Error(`Plugin "${pluginName}" is inactive for request ${method} ${toUrlString(url)}: ${decision.reason}.`);
+    }
+    const METHODS = ["get", "post", "put", "patch", "delete", "head"];
+    const wrapped = function (url, options) {
+        const method = (options?.method ?? (url instanceof Request ? url.method : "GET")).toUpperCase();
+        assertRequestActive(method, url);
+        return http(url, options);
+    };
+    for (const methodName of METHODS) {
+        wrapped[methodName] = (url, options) => {
+            assertRequestActive(methodName.toUpperCase(), url);
+            return http[methodName](url, options);
+        };
+    }
+    wrapped.extend = (options) => buildActivationAwareHttpClient(pluginName, activation, http.extend(options));
+    return wrapped;
+}
+/**
+ * Resolve (or retrieve cached) the real plugin instance for the current runtime.
+ *
+ * @internal
+ */
+function resolvePlugin(name, entry, cache) {
+    const runtime = getRuntime();
+    const tagDecision = evaluateTagActivation(entry.activation, runtime);
+    if (!tagDecision.active) {
+        const testId = runtime.test?.id;
+        throw new Error(`Plugin "${name}" is inactive${testId ? ` for test "${testId}"` : ""}: ${tagDecision.reason}.`);
+    }
+    if (cache.has(runtime))
+        return cache.get(runtime);
+    // Build the augmented runtime that plugins see
+    const noop = () => { };
+    const augmented = {
+        vars: runtime.vars,
+        secrets: runtime.secrets,
+        http: buildActivationAwareHttpClient(name, entry.activation, runtime.http),
+        test: runtime.test,
+        requireVar,
+        requireSecret,
+        resolveTemplate: (template) => resolveTemplate(template, runtime.vars, runtime.secrets),
+        action: runtime.action?.bind(runtime) ?? noop,
+        event: runtime.event?.bind(runtime) ?? noop,
+        log: runtime.log?.bind(runtime) ?? noop,
+    };
+    const instance = entry.factory.create(augmented);
+    cache.set(runtime, instance);
+    return instance;
+}
+/**
+ * Build a Proxy that defers plugin creation until the plugin is actually used.
+ *
+ * This allows `const { chrome } = configure(...)` to work at module top-level —
+ * the destructured value is a transparent Proxy, not the real plugin instance.
+ * The real instance is created lazily on first property access / method call
+ * during test execution.
+ *
+ * @internal
+ */
+function buildLazyPlugin(name, entry) {
+    const cache = new WeakMap();
+    return new Proxy(Object.create(null), {
+        get(_target, prop, receiver) {
+            const instance = resolvePlugin(name, entry, cache);
+            const value = Reflect.get(instance, prop, receiver);
+            return typeof value === "function"
+                ? value.bind(instance)
+                : value;
+        },
+        set(_target, prop, value) {
+            const instance = resolvePlugin(name, entry, cache);
+            return Reflect.set(instance, prop, value);
+        },
+        has(_target, prop) {
+            const instance = resolvePlugin(name, entry, cache);
+            return Reflect.has(instance, prop);
+        },
+        ownKeys() {
+            const instance = resolvePlugin(name, entry, cache);
+            return Reflect.ownKeys(instance);
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            const instance = resolvePlugin(name, entry, cache);
+            return Object.getOwnPropertyDescriptor(instance, prop);
+        },
+    });
+}
+function buildLazyPlugins(plugins) {
+    const result = {};
+    for (const [name, rawEntry] of Object.entries(plugins)) {
+        if (RESERVED_KEYS.has(name)) {
+            throw new Error(`Plugin name "${name}" conflicts with a reserved configure() field. ` +
+                `Choose a different key (reserved: ${[...RESERVED_KEYS].join(", ")}).`);
+        }
+        result[name] = buildLazyPlugin(name, normalizePluginEntry(rawEntry));
+    }
+    return result;
+}
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Declare file-level dependencies on vars, secrets, and HTTP configuration.
+ *
+ * Returns lazy accessors that resolve at test runtime, not at import time.
+ * All declared vars and secrets are **required** — missing values cause the test
+ * to fail immediately with a clear error message.
+ *
+ * The returned objects can be shared across files via re-exports.
+ *
+ * @param options Configuration declaring vars, secrets, and HTTP defaults
+ * @returns Lazy accessors for vars, secrets, and a pre-configured HTTP client
+ *
+ * @example Basic usage
+ * ```ts
+ * import { test, configure } from "@glubean/sdk";
+ *
+ * const { vars, http } = configure({
+ *   vars: { baseUrl: "base_url" },
+ *   http: { prefixUrl: "base_url" },
+ * });
+ *
+ * export const listUsers = test("list-users", async (ctx) => {
+ *   const res = await http.get("users").json();
+ *   ctx.log(`Base URL: ${vars.baseUrl}`);
+ * });
+ * ```
+ *
+ * @example Full configuration with secrets
+ * ```ts
+ * const { vars, secrets, http } = configure({
+ *   vars: { baseUrl: "base_url", orgId: "org_id" },
+ *   secrets: { apiKey: "api_key" },
+ *   http: {
+ *     prefixUrl: "base_url",
+ *     headers: { Authorization: "Bearer {{api_key}}" },
+ *   },
+ * });
+ * ```
+ *
+ * @example Shared across test files
+ * ```ts
+ * // tests/configure.ts
+ * export const { vars, secrets, http } = configure({ ... });
+ *
+ * // tests/users.test.ts
+ * import { http, vars } from "./configure.js";
+ * ```
+ */
+export function configure(options) {
+    const vars = options.vars
+        ? buildLazyVars(options.vars)
+        : {};
+    const secrets = options.secrets
+        ? buildLazySecrets(options.secrets)
+        : {};
+    const http = options.http ? buildLazyHttp(options.http) : buildPassthroughHttp();
+    const base = { vars, secrets, http };
+    if (options.plugins) {
+        Object.assign(base, buildLazyPlugins(options.plugins));
+    }
+    return base;
+}
+/**
+ * Build a passthrough HTTP client that simply delegates to ctx.http.
+ * Used when `configure()` is called without `http` options.
+ *
+ * @internal
+ */
+function buildPassthroughHttp() {
+    const HTTP_METHODS = [
+        "get",
+        "post",
+        "put",
+        "patch",
+        "delete",
+        "head",
+    ];
+    const proxy = function (url, options) {
+        return getRuntime().http(url, options);
+    };
+    for (const method of HTTP_METHODS) {
+        proxy[method] = (url, options) => getRuntime().http[method](url, options);
+    }
+    proxy.extend = (options) => getRuntime().http.extend(options);
+    return proxy;
+}
+//# sourceMappingURL=configure.js.map