@apifuse/provider-sdk 2.2.0-beta.27 → 2.2.0-beta.28

package/dist/runtime/state.js

@@ -4,7 +4,6 @@ import { ProviderError } from "../errors.js";
 import { createProviderRedisClient, ensureRedisReady, withRedisTimeout, } from "./redis.js";
 const DEFAULT_REDIS_TIMEOUT_MS = 250;
 const REDIS_STATE_PREFIX = "apifuse:provider-state:v2";
-const LEGACY_REDIS_STATE_PREFIX = "apifuse:provider-state:v1";
 const PROVIDER_SCOPE_DISCRIMINATOR = "scope:provider";
 const MISSING_CONNECTION_SCOPE_DISCRIMINATOR = "scope:connection:missing";
 const SET_WITH_QUOTA_SCRIPT = `
@@ -15,7 +14,6 @@ local index_ttl = tonumber(ARGV[4])
 local envelope = ARGV[5]
 
 redis.call("ZREMRANGEBYSCORE", KEYS[2], "-inf", now)
-redis.call("ZREM", KEYS[2], KEYS[3])
 local indexed = redis.call("ZSCORE", KEYS[2], KEYS[1])
 if not indexed and redis.call("ZCARD", KEYS[2]) >= max_entries then
 	return {0, false}
@@ -24,14 +22,10 @@ end
 redis.call("SET", KEYS[1], envelope, "PXAT", expires_at)
 redis.call("ZADD", KEYS[2], expires_at, KEYS[1])
 redis.call("PEXPIRE", KEYS[2], index_ttl)
-if ARGV[6] == "1" then
-	redis.call("SET", KEYS[3], ARGV[7], "PX", index_ttl)
-end
 return {1, envelope}
 `;
 const COMPARE_AND_SET_WITH_QUOTA_SCRIPT = `
 local current = redis.call("GET", KEYS[1])
-local scoped_present = current and true or false
 if current then
 	local ok, decoded = pcall(cjson.decode, current)
 	if ok and type(decoded) == "table" and decoded.deleted == true then
@@ -44,42 +38,6 @@ local max_entries = tonumber(ARGV[3])
 local expires_at = tonumber(ARGV[4])
 local index_ttl = tonumber(ARGV[5])
 local envelope = ARGV[6]
-local allow_legacy_claim = ARGV[7] == "1"
-local legacy_tombstone = ARGV[8]
-
-if not scoped_present then
-	local legacy = redis.call("GET", KEYS[3])
-	if legacy then
-		local ok, decoded = pcall(cjson.decode, legacy)
-		if ok and type(decoded) == "table" and decoded.deleted == true then
-			legacy = false
-		end
-	end
-	if legacy and not allow_legacy_claim then
-		return {-1, false}
-	end
-	if legacy then
-		local legacy_ttl = redis.call("PTTL", KEYS[3])
-		if legacy_ttl == -1 then
-			legacy_ttl = index_ttl
-		elseif legacy_ttl < 1 then
-			legacy_ttl = 1
-		end
-		if legacy_ttl > 0 then
-			redis.call("ZREMRANGEBYSCORE", KEYS[2], "-inf", now)
-			redis.call("ZREM", KEYS[2], KEYS[3])
-			local indexed = redis.call("ZSCORE", KEYS[2], KEYS[1])
-			if not indexed and redis.call("ZCARD", KEYS[2]) >= max_entries then
-				return {0, false}
-			end
-			redis.call("SET", KEYS[1], legacy, "PX", legacy_ttl)
-			redis.call("ZADD", KEYS[2], now + legacy_ttl, KEYS[1])
-			redis.call("PEXPIRE", KEYS[2], index_ttl)
-			redis.call("SET", KEYS[3], legacy_tombstone, "PX", index_ttl)
-			current = legacy
-		end
-	end
-end
 
 local current_version = 0
 local current_decoded = false
@@ -96,7 +54,6 @@ if current_version ~= tonumber(ARGV[1]) then
 end
 
 redis.call("ZREMRANGEBYSCORE", KEYS[2], "-inf", now)
-redis.call("ZREM", KEYS[2], KEYS[3])
 local indexed = redis.call("ZSCORE", KEYS[2], KEYS[1])
 if not indexed and redis.call("ZCARD", KEYS[2]) >= max_entries then
 	return {0, false}
@@ -110,60 +67,13 @@ end
 redis.call("SET", KEYS[1], envelope, "PXAT", expires_at)
 redis.call("ZADD", KEYS[2], expires_at, KEYS[1])
 redis.call("PEXPIRE", KEYS[2], index_ttl)
-if allow_legacy_claim then
-	redis.call("SET", KEYS[3], legacy_tombstone, "PX", index_ttl)
-end
 return {1, envelope}
 `;
 const DELETE_WITH_INDEX_SCRIPT = `
 redis.call("SET", KEYS[1], ARGV[1], "PX", ARGV[2])
-if ARGV[3] == "1" then
-	redis.call("SET", KEYS[3], ARGV[1], "PX", ARGV[2])
-end
-redis.call("ZREM", KEYS[2], KEYS[1], KEYS[3])
+redis.call("ZREM", KEYS[2], KEYS[1])
 return 1
 `;
-// A v1 key has no connection discriminator, so it cannot safely be exposed to
-// every v2 scope. The first concrete connection (or explicit provider scope) to
-// request a key atomically adopts that value and tombstones v1. The missing-
-// connection sentinel never claims legacy state.
-const CLAIM_LEGACY_SCRIPT = `
-local scoped = redis.call("GET", KEYS[1])
-if scoped then
-	return {1, scoped}
-end
-
-local legacy = redis.call("GET", KEYS[3])
-if not legacy then
-	return {1, false}
-end
-local ok, decoded = pcall(cjson.decode, legacy)
-if ok and type(decoded) == "table" and decoded.deleted == true then
-	return {1, false}
-end
-local legacy_ttl = redis.call("PTTL", KEYS[3])
-if legacy_ttl == -1 then
-	legacy_ttl = tonumber(ARGV[3])
-elseif legacy_ttl < 1 then
-	legacy_ttl = 1
-end
-
-local now = tonumber(ARGV[1])
-local max_entries = tonumber(ARGV[2])
-local index_ttl = tonumber(ARGV[3])
-redis.call("ZREMRANGEBYSCORE", KEYS[2], "-inf", now)
-redis.call("ZREM", KEYS[2], KEYS[3])
-local indexed = redis.call("ZSCORE", KEYS[2], KEYS[1])
-if not indexed and redis.call("ZCARD", KEYS[2]) >= max_entries then
-	return {0, false}
-end
-
-redis.call("SET", KEYS[1], legacy, "PX", legacy_ttl)
-redis.call("ZADD", KEYS[2], now + legacy_ttl, KEYS[1])
-redis.call("PEXPIRE", KEYS[2], index_ttl)
-redis.call("SET", KEYS[3], ARGV[4], "PX", index_ttl)
-return {1, legacy}
-`;
 const redisBackends = new Map();
 function getRedisBackend(redisUrl, injectedRedis) {
     const existing = redisBackends.get(redisUrl);
@@ -210,12 +120,6 @@ function providerStatePrefix(providerId, namespace, scopeDiscriminator) {
 function providerStateKey(providerId, namespace, scopeDiscriminator, key) {
     return `${providerStatePrefix(providerId, namespace, scopeDiscriminator)}:${key}`;
 }
-function legacyProviderStatePrefix(providerId, namespace) {
-    return `${LEGACY_REDIS_STATE_PREFIX}:${providerId ?? "default"}:${namespace}`;
-}
-function legacyProviderStateKey(providerId, namespace, key) {
-    return `${legacyProviderStatePrefix(providerId, namespace)}:${key}`;
-}
 function publicStateKey(redisKey, prefixes) {
     for (const prefix of prefixes) {
         const prefixWithSeparator = `${prefix}:`;
@@ -311,9 +215,6 @@ class RedisProviderStateNamespace {
     redisKey(key) {
         return providerStateKey(this.providerId, this.namespaceName, this.scopeDiscriminator, key);
     }
-    legacyRedisKey(key) {
-        return legacyProviderStateKey(this.providerId, this.namespaceName, key);
-    }
     statePrefix() {
         return providerStatePrefix(this.providerId, this.namespaceName, this.scopeDiscriminator);
     }
@@ -324,9 +225,6 @@ class RedisProviderStateNamespace {
         const namespaceIdentity = Buffer.from(providerStatePrefix(this.providerId, this.namespaceName, this.scopeDiscriminator), "utf8").toString("base64url");
         return `${REDIS_STATE_PREFIX}:index:${namespaceIdentity}`;
     }
-    canClaimLegacy() {
-        return this.scopeDiscriminator !== MISSING_CONNECTION_SCOPE_DISCRIMINATOR;
-    }
     async indexedKeys(limit) {
         await requireRedisReady(this.backend.redis);
         const now = Date.now();
@@ -337,15 +235,7 @@ class RedisProviderStateNamespace {
     }
     async readRaw(key) {
         await requireRedisReady(this.backend.redis);
-        if (!this.canClaimLegacy()) {
-            return await withRequiredRedis(() => this.backend.redis.get(this.redisKey(key)));
-        }
-        const tombstone = JSON.stringify({ deleted: true });
-        const result = await withRequiredRedis(() => this.backend.redis.eval(CLAIM_LEGACY_SCRIPT, 3, this.redisKey(key), this.indexKey(), this.legacyRedisKey(key), String(Date.now()), String(this.options.maxEntries), String(parseStateDurationMs(this.options.maxTtl)), tombstone));
-        if (Array.isArray(result) && Number(result[0]) === 0) {
-            throw this.quotaExceeded();
-        }
-        return Array.isArray(result) && typeof result[1] === "string" ? result[1] : null;
+        return await withRequiredRedis(() => this.backend.redis.get(this.redisKey(key)));
     }
     enforceValueSize(value) {
         const bytes = Buffer.byteLength(JSON.stringify(value), "utf8");
@@ -406,7 +296,7 @@ class RedisProviderStateNamespace {
         const timing = this.writeTiming(options?.ttl);
         const envelope = redisEnvelope(value, version, createdAt, timing.expiresAt);
         await requireRedisReady(this.backend.redis);
-        const result = await withRequiredRedis(() => this.backend.redis.eval(SET_WITH_QUOTA_SCRIPT, 3, this.redisKey(key), this.indexKey(), this.legacyRedisKey(key), String(Date.now()), String(this.options.maxEntries), String(timing.expiresAtMs), String(timing.indexTtlMs), JSON.stringify(envelope), this.canClaimLegacy() ? "1" : "0", JSON.stringify({ deleted: true })));
+        const result = await withRequiredRedis(() => this.backend.redis.eval(SET_WITH_QUOTA_SCRIPT, 2, this.redisKey(key), this.indexKey(), String(Date.now()), String(this.options.maxEntries), String(timing.expiresAtMs), String(timing.indexTtlMs), JSON.stringify(envelope)));
         if (!Array.isArray(result) || Number(result[0]) !== 1) {
             throw this.quotaExceeded();
         }
@@ -431,7 +321,7 @@ class RedisProviderStateNamespace {
         const timing = this.writeTiming(options?.ttl);
         const envelope = redisEnvelope(value, expectedVersion + 1, createdAt, timing.expiresAt);
         await requireRedisReady(this.backend.redis);
-        const result = await withRequiredRedis(() => this.backend.redis.eval(COMPARE_AND_SET_WITH_QUOTA_SCRIPT, 3, this.redisKey(key), this.indexKey(), this.legacyRedisKey(key), String(expectedVersion), String(Date.now()), String(this.options.maxEntries), String(timing.expiresAtMs), String(timing.indexTtlMs), JSON.stringify(envelope), this.canClaimLegacy() ? "1" : "0", JSON.stringify({ deleted: true })));
+        const result = await withRequiredRedis(() => this.backend.redis.eval(COMPARE_AND_SET_WITH_QUOTA_SCRIPT, 2, this.redisKey(key), this.indexKey(), String(expectedVersion), String(Date.now()), String(this.options.maxEntries), String(timing.expiresAtMs), String(timing.indexTtlMs), JSON.stringify(envelope)));
         if (Array.isArray(result) && Number(result[0]) === 0) {
             throw this.quotaExceeded();
         }
@@ -449,7 +339,7 @@ class RedisProviderStateNamespace {
     async delete(key) {
         await requireRedisReady(this.backend.redis);
         const tombstone = JSON.stringify({ deleted: true });
-        await withRequiredRedis(() => this.backend.redis.eval(DELETE_WITH_INDEX_SCRIPT, 3, this.redisKey(key), this.indexKey(), this.legacyRedisKey(key), tombstone, String(parseStateDurationMs(this.options.maxTtl)), this.canClaimLegacy() ? "1" : "0"));
+        await withRequiredRedis(() => this.backend.redis.eval(DELETE_WITH_INDEX_SCRIPT, 2, this.redisKey(key), this.indexKey(), tombstone, String(parseStateDurationMs(this.options.maxTtl))));
     }
     async increment(key, field, delta = 1, options) {
         const current = (await this.get(key))?.value ?? {};

package/dist/runtime/stealth-cookies.d.ts

@@ -0,0 +1,20 @@
+import type { CookieJar, StealthCookieStore, StealthCookieStoreV1, StealthSessionCookies } from "../types.js";
+export declare class StealthCookieJar implements CookieJar, StealthSessionCookies {
+    private cookies;
+    private readonly defaultUrl;
+    constructor(cookieStrings: readonly string[], defaultUrl?: string);
+    setFromCookieStrings(cookieStrings: readonly string[], url?: string): void;
+    get(name: string, url?: string): string | undefined;
+    getAll(url?: string): Record<string, string>;
+    has(name: string, url?: string): boolean;
+    toString(url?: string): string;
+    toHeader(url?: string): string;
+    snapshot(): Record<string, string>;
+    restore(cookies: Record<string, string>): void;
+    serialize(): StealthCookieStoreV1;
+    deserialize(state: StealthCookieStore): void;
+    clear(): void;
+    find(predicate: (cookie: string) => boolean, url?: string): string | undefined;
+    private normalizeUrl;
+    private getUniqueCookies;
+}

package/dist/runtime/stealth-cookies.js

@@ -0,0 +1,111 @@
+import { Cookie, CookieJar as ToughCookieJar } from "tough-cookie";
+import { SDKError, StealthCookieStoreVersionError } from "../errors.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+const LEGACY_COOKIE_ORIGIN = "https://legacy-cookie.invalid/";
+export class StealthCookieJar {
+    cookies;
+    defaultUrl;
+    constructor(cookieStrings, defaultUrl = LEGACY_COOKIE_ORIGIN) {
+        this.cookies = new ToughCookieJar(undefined, {
+            allowSecureOnLocal: false,
+            rejectPublicSuffixes: true,
+        });
+        this.defaultUrl = this.normalizeUrl(defaultUrl) ?? LEGACY_COOKIE_ORIGIN;
+        this.setFromCookieStrings(cookieStrings);
+    }
+    setFromCookieStrings(cookieStrings, url = this.defaultUrl) {
+        const cookieUrl = this.normalizeUrl(url);
+        if (!cookieUrl)
+            return;
+        for (const cookieString of cookieStrings) {
+            this.cookies.setCookieSync(cookieString, cookieUrl, { ignoreError: true });
+        }
+    }
+    get(name, url) {
+        return this.getAll(url)[name];
+    }
+    getAll(url) {
+        return Object.fromEntries(this.getUniqueCookies(url ?? this.defaultUrl).map((cookie) => [cookie.key, cookie.value]));
+    }
+    has(name, url) {
+        return Object.hasOwn(this.getAll(url), name);
+    }
+    toString(url) {
+        return this.getUniqueCookies(url ?? this.defaultUrl)
+            .map((cookie) => cookie.cookieString())
+            .join("; ");
+    }
+    toHeader(url) {
+        return this.toString(url);
+    }
+    snapshot() {
+        const entries = [];
+        for (const cookie of this.serialize().jar.cookies) {
+            if (typeof cookie.key === "string" && typeof cookie.value === "string" && cookie.key) {
+                entries.push([cookie.key, cookie.value]);
+            }
+        }
+        return Object.fromEntries(entries);
+    }
+    restore(cookies) {
+        this.clear();
+        for (const [name, value] of Object.entries(cookies)) {
+            if (!name)
+                continue;
+            this.cookies.setCookieSync(new Cookie({ key: name, path: "/", value }), this.defaultUrl, {
+                ignoreError: true,
+            });
+        }
+    }
+    serialize() {
+        const jar = this.cookies.serializeSync();
+        if (!jar) {
+            throw new SDKError("Stealth cookie store could not be serialized", {
+                code: "stealth_cookie_store_serialize_failed",
+            });
+        }
+        return { version: 1, jar };
+    }
+    deserialize(state) {
+        const version = isRecord(state) ? state.version : undefined;
+        if (version !== 1) {
+            throw new StealthCookieStoreVersionError(version);
+        }
+        const restored = ToughCookieJar.deserializeSync(state.jar);
+        Reflect.set(restored, "allowSecureOnLocal", false);
+        this.cookies = restored;
+    }
+    clear() {
+        this.cookies.removeAllCookiesSync();
+    }
+    find(predicate, url) {
+        for (const cookie of this.getUniqueCookies(url ?? this.defaultUrl)) {
+            const cookieString = cookie.cookieString();
+            if (predicate(cookieString))
+                return cookieString;
+        }
+        return undefined;
+    }
+    normalizeUrl(url) {
+        try {
+            return new URL(url).toString();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    getUniqueCookies(url) {
+        const cookieUrl = this.normalizeUrl(url);
+        if (!cookieUrl)
+            return [];
+        const names = new Set();
+        return this.cookies.getCookiesSync(cookieUrl).filter((cookie) => {
+            if (names.has(cookie.key))
+                return false;
+            names.add(cookie.key);
+            return true;
+        });
+    }
+}

package/dist/runtime/stealth.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
-import { Cookie, CookieJar as ToughCookieJar } from "tough-cookie";
 import { DEFAULT_SMARTPROXY_POOL_SIZE, invalidateProxyResolutionCacheAsync, ProxyResolutionError, policyResolvesRegistryVendorChain, resolvePolicyProxyPoolSpan, resolvePolicyTransportAttemptCap, resolveProxyConfigAsync, vendorFromResolvedSource, } from "../config/loader.js";
-import { SDKError, StealthCookieStoreVersionError, TransportError } from "../errors.js";
+import { SDKError, TransportError } from "../errors.js";
 import { getStealthProfile } from "../stealth/profiles.js";
+import { StealthCookieJar } from "./stealth-cookies.js";
 import { createProxyAuthIpDeniedError, createProxyEdgeAuthRejectedError, createProxyEdgeTlsRejectedError, createProxyPoolExhaustedError, createProxyPoolStaleError, isProxyAuthIpDeniedMessage, isProxyEdgeAuthRejectedMessage, isProxyEdgeTlsRejectedResponse, isProxyPoolRefreshableError, isProxyPoolStaleMessage, isProxyPoolStaleStatus, PROXY_EDGE_AUTH_REJECTED_CODE, PROXY_POOL_STALE_CODE, } from "./proxy-errors.js";
 import { computeProxyAttemptIndex, computeProxyTransportRetryDelayMs, createDefaultProxyTransportRetryOptions, normalizeProxyTransportRetryOptions, shouldRetryProxyTransportAttempt, validateUnsafeProxyTransportRetryMethods, } from "./proxy-retry-policy.js";
 import { evaluateRedirectHop, isRedirectStatus, nextRedirectMethod, resolveRedirectUrl, } from "./redirects.js";
@@ -22,6 +22,9 @@ const REDIRECT_BODY_HEADERS = new Set([
     "content-location",
     "content-type",
 ]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
 function sensitiveQueryParamNames(url) {
     const queryStart = url.indexOf("?");
     if (queryStart === -1)
@@ -43,132 +46,6 @@ const REMOVED_CHROME_PROFILE_NAMES = new Set([
     "chrome-130-psk",
     "edge-131",
 ]);
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-const LEGACY_COOKIE_ORIGIN = "https://legacy-cookie.invalid/";
-class CookieJarImpl {
-    cookies;
-    defaultUrl;
-    constructor(cookieStrings, defaultUrl = LEGACY_COOKIE_ORIGIN) {
-        this.cookies = new ToughCookieJar(undefined, {
-            allowSecureOnLocal: false,
-            rejectPublicSuffixes: true,
-        });
-        this.defaultUrl = this.normalizeUrl(defaultUrl) ?? LEGACY_COOKIE_ORIGIN;
-        this.setFromCookieStrings(cookieStrings);
-    }
-    /**
-     * URL-less legacy operations are scoped to this jar's default URL. Session
-     * jars use the client's base URL and response jars use the response URL. A
-     * flat restore has no attributes to recover, so it creates host-only Path=/
-     * cookies for that default URL instead of making them visible to every host.
-     */
-    setFromCookieStrings(cookieStrings, url = this.defaultUrl) {
-        const cookieUrl = this.normalizeUrl(url);
-        if (!cookieUrl)
-            return;
-        for (const cookieString of cookieStrings) {
-            this.cookies.setCookieSync(cookieString, cookieUrl, { ignoreError: true });
-        }
-    }
-    get(name, url) {
-        return this.getAll(url)[name];
-    }
-    getAll(url) {
-        return Object.fromEntries(this.getUniqueCookies(url ?? this.defaultUrl).map((cookie) => [cookie.key, cookie.value]));
-    }
-    has(name, url) {
-        return Object.hasOwn(this.getAll(url), name);
-    }
-    toString(url) {
-        return this.getUniqueCookies(url ?? this.defaultUrl)
-            .map((cookie) => cookie.cookieString())
-            .join("; ");
-    }
-    toHeader(url) {
-        return this.toString(url);
-    }
-    snapshot() {
-        // This compatibility view deliberately enumerates the serialized store,
-        // not getAll(defaultUrl): persistence must include sibling hosts and paths.
-        // Duplicate names still collapse because a flat map cannot represent them.
-        const entries = [];
-        for (const cookie of this.serialize().jar.cookies) {
-            if (typeof cookie.key === "string" && typeof cookie.value === "string" && cookie.key) {
-                entries.push([cookie.key, cookie.value]);
-            }
-        }
-        return Object.fromEntries(entries);
-    }
-    restore(cookies) {
-        this.clear();
-        for (const [name, value] of Object.entries(cookies)) {
-            if (!name)
-                continue;
-            this.cookies.setCookieSync(new Cookie({ key: name, path: "/", value }), this.defaultUrl, {
-                ignoreError: true,
-            });
-        }
-    }
-    serialize() {
-        const jar = this.cookies.serializeSync();
-        if (!jar) {
-            throw new SDKError("Stealth cookie store could not be serialized", {
-                code: "stealth_cookie_store_serialize_failed",
-            });
-        }
-        return { version: 1, jar };
-    }
-    deserialize(state) {
-        const version = isRecord(state) ? state.version : undefined;
-        if (version !== 1) {
-            throw new StealthCookieStoreVersionError(version);
-        }
-        // Deserialize into a new jar first so invalid state cannot partially clear
-        // or replace a live session. tough-cookie restores the cookie attributes and
-        // matching semantics represented in its own serialized format.
-        const restored = ToughCookieJar.deserializeSync(state.jar);
-        // tough-cookie 6 does not include this option in serializeSync(). Preserve
-        // the SDK's stricter setting across restoration.
-        Reflect.set(restored, "allowSecureOnLocal", false);
-        this.cookies = restored;
-    }
-    clear() {
-        this.cookies.removeAllCookiesSync();
-    }
-    find(predicate, url) {
-        for (const cookie of this.getUniqueCookies(url ?? this.defaultUrl)) {
-            const cookieString = cookie.cookieString();
-            if (predicate(cookieString)) {
-                return cookieString;
-            }
-        }
-        return undefined;
-    }
-    normalizeUrl(url) {
-        try {
-            return new URL(url).toString();
-        }
-        catch {
-            return undefined;
-        }
-    }
-    getUniqueCookies(url) {
-        const cookieUrl = this.normalizeUrl(url);
-        if (!cookieUrl)
-            return [];
-        // tough-cookie returns longer (more-specific) paths first. Keeping the
-        // first cookie for each name prevents ambiguous duplicate-name headers.
-        const names = new Set();
-        return this.cookies.getCookiesSync(cookieUrl).filter((cookie) => {
-            if (names.has(cookie.key))
-                return false;
-            names.add(cookie.key);
-            return true;
-        });
-    }
-}
 let wreqModulePromise;
 function getWreqModule() {
     if (!wreqModulePromise) {
@@ -325,7 +202,7 @@ function splitCombinedSetCookieHeader(headerValue) {
 }
 export async function normalizeResponse(response, requestUrl, maxBodyBytes) {
     const headers = Object.fromEntries(response.headers.entries());
-    const cookies = new CookieJarImpl(setCookieHeadersFromResponse(response.headers), response.url ?? requestUrl);
+    const cookies = new StealthCookieJar(setCookieHeadersFromResponse(response.headers), response.url ?? requestUrl);
     const bodyBytes = maxBodyBytes === undefined
         ? await response.arrayBuffer()
         : await readResponseBodyWithLimit(response, maxBodyBytes);
@@ -669,7 +546,7 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
     let closed = false;
     let hasWarnedMissingProxy = false;
     const warn = clientOptions.warn ?? console.warn;
-    const cookieJar = new CookieJarImpl([], baseUrl);
+    const cookieJar = new StealthCookieJar([], baseUrl);
     async function getClientEntry(profileName, proxyUrl, ignoreTlsErrors) {
         if (closed) {
             throw new TransportError("Stealth session is closed", { status: 0 });

package/dist/serve.d.ts

@@ -1 +1 @@
-export { createServerApp, type ServeOptions, serve } from "./server/serve.js";
+export { createServerApp, createServerAppAsync, type ServeOptions, serve, } from "./server/serve.js";

package/dist/serve.js

@@ -1 +1 @@
-export { createServerApp, serve } from "./server/serve.js";
+export { createServerApp, createServerAppAsync, serve, } from "./server/serve.js";

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
-export { createServerApp, ERROR_OBSERVABILITY_HEADER, type ErrorObservabilityDetails, type ProviderServerCloseOptions, type ProviderServerHandle, type ProviderServerLogEvent, type ProviderServerLogger, type ProviderServerOperationExecutor, type ProviderServerOperationExecutorInput, type ProviderServerOptions, type ProviderServerStatefulForwardEnvelope, type ServeOptions, serve, } from "./serve.js";
+export { createServerApp, createServerAppAsync, ERROR_OBSERVABILITY_HEADER, type ErrorObservabilityDetails, type ProviderServerCloseOptions, type ProviderServerHandle, type ProviderServerLogEvent, type ProviderServerLogger, type ProviderServerOperationExecutor, type ProviderServerOperationExecutorInput, type ProviderServerOptions, type ProviderServerStatefulForwardEnvelope, type ServeOptions, serve, } from "./serve.js";
 export { computeSelfTestPlanDigest, createSelfTestApp, createSelfTestAuthFlowInvoke, createSelfTestInvoke, DEFAULT_SELF_TEST_REQUEST_BUDGET_MS, isSelfTestReadOnlyOperation, PROVIDER_RUNTIME_SELF_TEST_REQUEST_BUDGET_MS_ENV, resolveSelfTestPort, SELF_TEST_AUTH_FLOW_MULTI_TURN_SKIP_REASON, SELF_TEST_AUTH_FLOW_REJECTED_SKIP_REASON, SELF_TEST_HEALTHZ_PATH, SELF_TEST_PATH, SELF_TEST_SCHEMA_VERSION, type SelfTestAppOptions, type SelfTestAuthFlowInvoke, type SelfTestAuthFlowRoute, type SelfTestCaseResult, type SelfTestCaseStatus, type SelfTestOperationInvoke, type SelfTestRequest, SelfTestRequestSchema, type SelfTestResponse, } from "./self-test.js";
 export { type InputDateTokenCalendar, resolveHealthCheckInputDateTokens, } from "./self-test-input-tokens.js";
 export { collectSelfTestSensitiveValues, redactSelfTestText, SELF_TEST_MAX_TEXT_LENGTH, SELF_TEST_REDACTED_PLACEHOLDER, } from "./self-test-redaction.js";

package/dist/server/index.js

@@ -1,4 +1,4 @@
-export { createServerApp, ERROR_OBSERVABILITY_HEADER, serve, } from "./serve.js";
+export { createServerApp, createServerAppAsync, ERROR_OBSERVABILITY_HEADER, serve, } from "./serve.js";
 export { computeSelfTestPlanDigest, createSelfTestApp, createSelfTestAuthFlowInvoke, createSelfTestInvoke, DEFAULT_SELF_TEST_REQUEST_BUDGET_MS, isSelfTestReadOnlyOperation, PROVIDER_RUNTIME_SELF_TEST_REQUEST_BUDGET_MS_ENV, resolveSelfTestPort, SELF_TEST_AUTH_FLOW_MULTI_TURN_SKIP_REASON, SELF_TEST_AUTH_FLOW_REJECTED_SKIP_REASON, SELF_TEST_HEALTHZ_PATH, SELF_TEST_PATH, SELF_TEST_SCHEMA_VERSION, SelfTestRequestSchema, } from "./self-test.js";
 export { resolveHealthCheckInputDateTokens, } from "./self-test-input-tokens.js";
 export { collectSelfTestSensitiveValues, redactSelfTestText, SELF_TEST_MAX_TEXT_LENGTH, SELF_TEST_REDACTED_PLACEHOLDER, } from "./self-test-redaction.js";

package/dist/server/self-test.d.ts

@@ -51,11 +51,21 @@ export interface SelfTestResponse {
     result?: SelfTestCaseResult;
     results: SelfTestCaseResult[];
 }
+export interface SelfTestCancellationLogEvent {
+    level: "info";
+    event: "self_test_run_cancelled";
+    providerId: string;
+    requestId: string;
+    operationId: string;
+    caseName: string;
+    reason: string;
+}
 export type SelfTestOperationInvoke = (args: {
     operationId: string;
     input: unknown;
     connection?: OperationConnection;
     requestId: string;
+    signal?: AbortSignal;
 }) => Promise<{
     status: number;
     data: unknown;
@@ -78,6 +88,7 @@ export type SelfTestAuthFlowInvoke = (args: {
     externalRef?: string;
     input?: Record<string, unknown>;
     context?: Record<string, unknown>;
+    signal?: AbortSignal;
 }) => Promise<{
     status: number;
     body: unknown;
@@ -112,6 +123,8 @@ export interface SelfTestAppOptions {
     requestBudgetMs?: number;
     /** Env override for secret collection + budget resolution (tests). */
     env?: Readonly<Record<string, string | undefined>>;
+    /** Structured server logger; defaults to the same JSON console shape as the provider server. */
+    logger?: (event: SelfTestCancellationLogEvent) => void;
 }
 /**
  * Stable sha256 over the provider's declared health plan (operations, case