@solarisdk/browser 0.1.4 → 0.1.6

package/dist/captcha.d.ts

@@ -0,0 +1,66 @@
+export interface CaptchaFailure {
+    code: string;
+    message: string;
+    retryable: boolean;
+    nextAction: "retry_fresh_challenge" | "manual" | "stop";
+    vendorErrorCode?: string;
+}
+export interface CaptchaStatus {
+    id: string;
+    provider: string;
+    vendor: string;
+    url: string;
+    stage: "detected" | "solving" | "vendor_solved" | "applied" | "failed" | "cancelled";
+    startedAt: number;
+    updatedAt: number;
+    durationMs: number;
+    websiteVerification: "unknown" | "accepted" | "rejected" | "timed_out";
+    verificationSource?: "client";
+    error?: CaptchaFailure;
+}
+export declare class CaptchaError extends Error {
+    readonly failure: CaptchaFailure;
+    readonly status?: CaptchaStatus | undefined;
+    constructor(failure: CaptchaFailure, status?: CaptchaStatus | undefined);
+}
+interface CaptchaTransport {
+    send(method: string, params?: Record<string, unknown>): Promise<any>;
+    on(event: string, listener: (status: CaptchaStatus) => void): unknown;
+    off(event: string, listener: (status: CaptchaStatus) => void): unknown;
+}
+/** Session outcome polling or an existing raw-CDP transport. No token is exposed. */
+export declare class CaptchaObserver {
+    private readonly transport;
+    private readonly disconnect;
+    private readonly history;
+    private readonly listeners;
+    private closed;
+    private readonly waits;
+    private readonly receive;
+    private constructor();
+    /** Poll over the public session API, without creating another browser
+     * connection. Works for both Playwright wire and raw-CDP task clients. */
+    static forSession(client: {
+        request(method: string, path: string, body?: unknown): Promise<Response>;
+    }, sessionId: string): Promise<CaptchaObserver>;
+    /** Also accepts an existing raw-CDP transport; useful for other agents. */
+    static attach(transport: CaptchaTransport, disconnect?: () => Promise<void>): Promise<CaptchaObserver>;
+    onStatus(listener: (status: CaptchaStatus) => void): () => void;
+    statuses(): Promise<CaptchaStatus[]>;
+    reportVerification(attemptId: string, accepted: boolean): Promise<boolean>;
+    /** Resolves only after the caller's website-specific verifier returns true.
+     * Await this before resuming the agent. Manual recovery runs at most once
+     * per attempt and shares the same deadline; it never refreshes/re-bills
+     * automatically. A rejected/expired token requires a fresh challenge. */
+    waitForVerification(options: {
+        verify: () => Promise<boolean>;
+        /** Scope multi-widget/tab sessions to the challenge being verified. */
+        attemptId?: string;
+        provider?: string;
+        timeoutMs?: number;
+        onManualRequired?: (status: CaptchaStatus, signal: AbortSignal) => Promise<void>;
+        signal?: AbortSignal;
+    }): Promise<CaptchaStatus>;
+    close(): Promise<void>;
+}
+export {};

package/dist/captcha.js

@@ -0,0 +1,229 @@
+export class CaptchaError extends Error {
+    failure;
+    status;
+    constructor(failure, status) {
+        super(`${failure.code}: ${failure.message}`);
+        this.failure = failure;
+        this.status = status;
+        this.name = "CaptchaError";
+    }
+}
+function timeoutFailure() {
+    return new CaptchaError({ code: "TIMEOUT", message: "CAPTCHA verification did not finish before the deadline",
+        retryable: false, nextAction: "manual" });
+}
+/** Session outcome polling or an existing raw-CDP transport. No token is exposed. */
+export class CaptchaObserver {
+    transport;
+    disconnect;
+    history = new Map();
+    listeners = new Set();
+    closed = false;
+    waits = new Set();
+    receive = (status) => {
+        if (this.closed)
+            return;
+        const previous = this.history.get(status.id);
+        if (previous) {
+            if (status.updatedAt < previous.updatedAt)
+                return;
+            // A delayed HTTP snapshot may arrive after a terminal CDP event.
+            // The server never reopens an attempt after application/failure.
+            const terminal = ["applied", "failed", "cancelled"].includes(previous.stage);
+            if (terminal && status.stage !== previous.stage)
+                return;
+            const rank = { detected: 0, solving: 1, vendor_solved: 2, applied: 3, failed: 3, cancelled: 3 };
+            if (status.updatedAt === previous.updatedAt && rank[status.stage] < rank[previous.stage])
+                return;
+            if (previous.verificationSource === "client" && previous.websiteVerification !== "unknown" &&
+                (status.websiteVerification === "unknown" || previous.websiteVerification !== "timed_out" && status.websiteVerification !== previous.websiteVerification))
+                return;
+            if (JSON.stringify(previous) === JSON.stringify(status))
+                return;
+        }
+        this.history.set(status.id, structuredClone(status));
+        if (this.history.size > 64)
+            this.history.delete(this.history.keys().next().value);
+        for (const listener of this.listeners) {
+            try {
+                listener(structuredClone(status));
+            }
+            catch { }
+        }
+    };
+    constructor(transport, disconnect) {
+        this.transport = transport;
+        this.disconnect = disconnect;
+    }
+    /** Poll over the public session API, without creating another browser
+     * connection. Works for both Playwright wire and raw-CDP task clients. */
+    static async forSession(client, sessionId) {
+        const prefix = `/sessions/${encodeURIComponent(sessionId)}/captcha`;
+        const transport = {
+            on() { }, off() { },
+            async send(method, params) {
+                if (method === "Solari.enableCaptchaEvents")
+                    return {};
+                const response = await client.request(method === "Solari.getCaptchaStatus" ? "GET" : "POST", prefix + (method === "Solari.getCaptchaStatus" ? "" : "/verification"), params);
+                if (!response.ok)
+                    throw new CaptchaError({ code: "STATUS_UNAVAILABLE",
+                        message: `CAPTCHA status HTTP ${response.status}`, retryable: response.status >= 500, nextAction: "stop" });
+                return response.json();
+            },
+        };
+        const observer = await CaptchaObserver.attach(transport);
+        await observer.statuses();
+        return observer;
+    }
+    /** Also accepts an existing raw-CDP transport; useful for other agents. */
+    static async attach(transport, disconnect = async () => { }) {
+        const observer = new CaptchaObserver(transport, disconnect);
+        transport.on("Solari.captchaStatusChanged", observer.receive);
+        try {
+            await transport.send("Solari.enableCaptchaEvents", { includeStatus: true });
+        }
+        catch (error) {
+            transport.off("Solari.captchaStatusChanged", observer.receive);
+            throw error;
+        }
+        return observer;
+    }
+    onStatus(listener) {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    async statuses() {
+        if (this.closed)
+            throw new Error("CAPTCHA observer is closed");
+        const result = await this.transport.send("Solari.getCaptchaStatus");
+        for (const status of result.attempts ?? [])
+            this.receive(status);
+        return [...this.history.values()].sort((a, b) => a.startedAt - b.startedAt).map(status => structuredClone(status));
+    }
+    async reportVerification(attemptId, accepted) {
+        if (this.closed)
+            throw new Error("CAPTCHA observer is closed");
+        const result = await this.transport.send("Solari.reportCaptchaVerification", { attemptId, accepted });
+        return result.recorded === true;
+    }
+    /** Resolves only after the caller's website-specific verifier returns true.
+     * Await this before resuming the agent. Manual recovery runs at most once
+     * per attempt and shares the same deadline; it never refreshes/re-bills
+     * automatically. A rejected/expired token requires a fresh challenge. */
+    async waitForVerification(options) {
+        const timeoutMs = options.timeoutMs ?? 300_000;
+        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+            throw new Error("timeoutMs must be positive");
+        const controller = new AbortController();
+        this.waits.add(controller);
+        const deadline = Date.now() + timeoutMs;
+        const timer = setTimeout(() => controller.abort(timeoutFailure()), timeoutMs);
+        const abort = () => controller.abort(options.signal?.reason ?? new Error("CAPTCHA wait aborted"));
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+        const manual = new Set();
+        let lastAttempt;
+        // Start lazily: a cancelled deadline must not initiate another request,
+        // verifier, manual callback or an unobserved rejected promise.
+        const bounded = (operation) => new Promise((resolve, reject) => {
+            if (controller.signal.aborted) {
+                reject(controller.signal.reason);
+                return;
+            }
+            const fail = () => reject(controller.signal.reason);
+            controller.signal.addEventListener("abort", fail, { once: true });
+            try {
+                operation().then(resolve, reject).finally(() => controller.signal.removeEventListener("abort", fail));
+            }
+            catch (error) {
+                controller.signal.removeEventListener("abort", fail);
+                reject(error);
+            }
+        });
+        const selected = (statuses) => statuses.filter(status => (!options.attemptId || status.id === options.attemptId) &&
+            (!options.provider || status.provider === options.provider));
+        const active = (statuses) => statuses.some(status => ["detected", "solving", "vendor_solved"].includes(status.stage));
+        const latestOf = (statuses) => statuses.filter(status => status.stage !== "cancelled").at(-1);
+        const stillCurrent = (statuses, id) => !active(statuses) && latestOf(statuses)?.id === id && latestOf(statuses)?.websiteVerification !== "rejected";
+        const pollDelay = () => bounded(() => new Promise(resolve => setTimeout(resolve, 250)));
+        try {
+            while (Date.now() < deadline) {
+                if (this.closed)
+                    throw new Error("CAPTCHA observer is closed");
+                const statuses = selected(await bounded(() => this.statuses()));
+                const latest = latestOf(statuses);
+                lastAttempt = latest;
+                if (!active(statuses) && latest) {
+                    if (latest.websiteVerification === "rejected")
+                        throw new CaptchaError({
+                            code: "WEBSITE_REJECTED", message: "The website rejected CAPTCHA verification",
+                            retryable: true, nextAction: "retry_fresh_challenge",
+                        }, latest);
+                    if (await bounded(() => options.verify())) {
+                        // The verifier and the report are asynchronous. A new
+                        // challenge may have started during either operation.
+                        const beforeReport = selected(await bounded(() => this.statuses()));
+                        lastAttempt = latestOf(beforeReport);
+                        if (!stillCurrent(beforeReport, latest.id)) {
+                            await pollDelay();
+                            continue;
+                        }
+                        const result = await bounded(() => this.transport.send("Solari.reportCaptchaVerification", { attemptId: latest.id, accepted: true }));
+                        if (!result.recorded)
+                            throw new Error("CAPTCHA verification could not be recorded for this attempt");
+                        const afterReport = selected(await bounded(() => this.statuses()));
+                        lastAttempt = latestOf(afterReport);
+                        if (!stillCurrent(afterReport, latest.id)) {
+                            await pollDelay();
+                            continue;
+                        }
+                        return { ...latestOf(afterReport), websiteVerification: "accepted", verificationSource: "client" };
+                    }
+                    if (latest.stage === "failed") {
+                        if (!options.onManualRequired || latest.error?.nextAction === "stop")
+                            throw new CaptchaError(latest.error ?? { code: "UNKNOWN", message: "CAPTCHA solving failed", retryable: false, nextAction: "manual" }, latest);
+                        if (!manual.has(latest.id)) {
+                            const beforeHandoff = selected(await bounded(() => this.statuses()));
+                            lastAttempt = latestOf(beforeHandoff);
+                            if (!stillCurrent(beforeHandoff, latest.id)) {
+                                await pollDelay();
+                                continue;
+                            }
+                            manual.add(latest.id);
+                            await bounded(() => options.onManualRequired(latest, controller.signal));
+                        }
+                    }
+                }
+                await pollDelay();
+            }
+            throw timeoutFailure();
+        }
+        catch (error) {
+            if (error instanceof CaptchaError && error.failure.code === "TIMEOUT" && lastAttempt?.stage === "applied") {
+                let reportTimer;
+                await Promise.race([
+                    this.transport.send("Solari.reportCaptchaVerification", { attemptId: lastAttempt.id, outcome: "timed_out" }).catch(() => { }),
+                    new Promise(resolve => { reportTimer = setTimeout(resolve, 1_000); }),
+                ]).finally(() => clearTimeout(reportTimer));
+            }
+            throw error;
+        }
+        finally {
+            this.waits.delete(controller);
+            clearTimeout(timer);
+            options.signal?.removeEventListener("abort", abort);
+        }
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.listeners.clear();
+        for (const wait of this.waits)
+            wait.abort(new Error("CAPTCHA observer is closed"));
+        this.waits.clear();
+        this.transport.off("Solari.captchaStatusChanged", this.receive);
+        await this.disconnect();
+    }
+}

package/dist/index.d.ts

@@ -130,7 +130,20 @@ export interface LaunchOptions extends CreateSessionOptions {
     /** Hard upper bound on the post-connect probe in ms. Default 2000. */
     probeTimeoutMs?: number;
 }
-export type SolariErrorCode = "FeatureRequiresPlan" | "ConcurrencyLimitExceeded" | "PlanLimitExceeded" | "BrowserUnhealthy" | "InvalidSessionId";
+export type SolariErrorCode = "FeatureRequiresPlan" | "ConcurrencyLimitExceeded" | "PlanLimitExceeded" | "BrowserUnhealthy" | "InvalidSessionId"
+/** A proxy tier you explicitly requested cannot be served right now (503). No session was created. */
+ | "ProxyTierUnavailable";
+/** Supported egress countries and residential-proxy status, from
+ *  {@link Solari.proxy}.countries() (`GET /proxy/countries`). */
+export interface ProxyCountries {
+    /** Whether RESIDENTIAL managed-proxy credentials are configured on the
+     *  gateway. Reflects only the residential tier — the static/mobile tiers
+     *  have separate credentials this flag does not report, so `true` is not a
+     *  guarantee that `tier: "mobile"` will resolve. */
+    enabled: boolean;
+    /** Supported ISO-3166-1 alpha-2 egress countries (lowercase, sorted). */
+    countries: string[];
+}
 export declare class SolariError extends Error {
     readonly status?: number | undefined;
     readonly cause?: unknown | undefined;
@@ -150,6 +163,14 @@ declare class ProfilesResource {
         sizeBytes: number;
     }>;
 }
+declare class ProxyResource {
+    private readonly client;
+    constructor(client: Solari);
+    /** `GET /proxy/countries` — the egress countries this gateway supports and
+     *  whether residential proxy credentials are configured. Matches the Go/Rust
+     *  `proxy.countries()` and C++ `proxyCountries()`. */
+    countries(): Promise<ProxyCountries>;
+}
 declare class SessionsResource {
     private readonly client;
     constructor(client: Solari);
@@ -165,12 +186,13 @@ declare class SessionsResource {
 export declare class Solari {
     readonly sessions: SessionsResource;
     readonly profiles: ProfilesResource;
+    readonly proxy: ProxyResource;
     private readonly apiKey;
     private readonly baseUrl;
     private readonly maxAttempts;
     private readonly backoffMs;
     private readonly timeoutMs;
-    private readonly proxy;
+    private readonly localProxy;
     constructor(opts: SolariOptions);
     close(): Promise<void>;
     /**
@@ -189,5 +211,7 @@ export declare class Solari {
     private _probeBrowserHealth;
     _wrapSessionEndpoint(sessionId: string, upstreamEndpoint: string, kind?: ProxyKind): Promise<string>;
     _unregisterSession(sessionId: string): void;
-    request(method: string, path: string, body?: unknown): Promise<Response>;
+    request(method: string, path: string, body?: unknown, opts?: {
+        idempotencyKey?: string;
+    }): Promise<Response>;
 }

package/dist/index.js

@@ -54,8 +54,74 @@ const DEFAULT_REGION = "us-west";
 const DEFAULT_MAX_ATTEMPTS = 2;
 const DEFAULT_BACKOFF_MS = 500;
 const DEFAULT_TIMEOUT_MS = 90_000;
+// 507 is in the list although THIS gateway does not emit one (censused
+// 2026-09-22: browser emits 501/502/503 only). It is here so the client is
+// right on its own terms: the desktop gateway's InsufficientCapacity 507 is
+// transient, and a client's correctness must not depend on which gateway
+// build it reaches. Inert today, and deliberately so — do not delete it as
+// dead code.
 function isRetryableStatus(status) {
-    return status === 502 || status === 503 || status === 504;
+    return status === 502 || status === 503 || status === 504 || status === 507;
+}
+// Methods that are safe to send twice. The gateway issues no Idempotency-Key
+// for the browser API, so the `retryable` hint is honoured ONLY here: a
+// re-sent POST /sessions could leave a second live session behind.
+function isIdempotentMethod(method) {
+    const m = method.toUpperCase();
+    return m === "GET" || m === "HEAD" || m === "DELETE" || m === "PUT";
+}
+// Is THIS REQUEST safe to send again? Deliberately a per-request question, not
+// a per-method one. A POST is not idempotent by verb, but a POST carrying an
+// Idempotency-Key is safe to replay because the server answers the second copy
+// from the first one's result instead of creating twice.
+//
+// This is what the old comment here was waiting for. It read: "The browser API
+// issues no Idempotency-Key, so the `retryable` hint is honoured ONLY for
+// idempotent methods: a re-sent POST /sessions could leave a second live
+// session behind." That reason is being removed, not worked around.
+function isSafeToReplay(method, idempotencyKey) {
+    return isIdempotentMethod(method) || idempotencyKey !== undefined;
+}
+// A key must identify the CALL, not the attempt: minted once by the caller and
+// reused by every retry of that call. Minting per attempt would make each retry
+// a fresh create and defeat the whole mechanism.
+function newIdempotencyKey() {
+    const c = typeof globalThis.crypto !== "undefined" ? globalThis.crypto : undefined;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    // Pre-19 Node / older browsers: not a v4 UUID, just unique enough to key on.
+    return `slr-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 14)}`;
+}
+// The gateway can mark a response retryable on a status that is NOT in the
+// 5xx allowlist — today `404 ReplayPending`, where the recording upload is
+// still in flight. Honour that hint rather than flattening it into a
+// terminal error.
+//
+// The body is read from a CLONE: the caller still owns the original and
+// parses `code` out of it, and a Response body can only be consumed once.
+async function responseSaysRetryable(res) {
+    try {
+        const body = (await res.clone().json());
+        return body?.retryable === true;
+    }
+    catch {
+        // Non-JSON or already-consumed body: no hint, not retryable.
+        return false;
+    }
+}
+// A few 503s are answers, not outages: retrying cannot change them, and swallowing the body would hide the
+// code from the caller. `ProxyTierUnavailable` (explicitly requested proxy tier not servable) is one.
+const TERMINAL_503_CODES = new Set(["ProxyTierUnavailable"]);
+async function responseIsTerminal503(res) {
+    if (res.status !== 503)
+        return false;
+    try {
+        const body = (await res.clone().json());
+        return typeof body?.code === "string" && TERMINAL_503_CODES.has(body.code);
+    }
+    catch {
+        return false;
+    }
 }
 function isRetryableError(_err) {
     return true;
@@ -186,6 +252,23 @@ async function releaseRejection(res) {
         return null;
     return { body, code };
 }
+class ProxyResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** `GET /proxy/countries` — the egress countries this gateway supports and
+     *  whether residential proxy credentials are configured. Matches the Go/Rust
+     *  `proxy.countries()` and C++ `proxyCountries()`. */
+    async countries() {
+        const res = await this.client.request("GET", "/proxy/countries");
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new SolariError(`Solari GET /proxy/countries failed: ${res.status} ${body}`, res.status);
+        }
+        return (await res.json());
+    }
+}
 class SessionsResource {
     client;
     constructor(client) {
@@ -203,7 +286,10 @@ class SessionsResource {
             body.captcha = true;
         if (options?.proxy !== undefined)
             body.proxy = options.proxy;
-        const res = await this.client.request("POST", "/sessions", Object.keys(body).length ? body : undefined);
+        // A create allocates a slot and launches a browser before it can answer,
+        // so a response lost after that point makes a retry a SECOND session.
+        // The key lets the gateway answer the retry from the first result.
+        const res = await this.client.request("POST", "/sessions", Object.keys(body).length ? body : undefined, { idempotencyKey: newIdempotencyKey() });
         if (!res.ok) {
             const text = await res.text().catch(() => "");
             let code;
@@ -296,12 +382,13 @@ class SessionsResource {
 export class Solari {
     sessions;
     profiles;
+    proxy;
     apiKey;
     baseUrl;
     maxAttempts;
     backoffMs;
     timeoutMs;
-    proxy = new LocalProxy();
+    localProxy = new LocalProxy();
     constructor(opts) {
         if (!opts.apiKey) {
             throw new SolariError("Solari: apiKey is required");
@@ -318,9 +405,10 @@ export class Solari {
         this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         this.sessions = new SessionsResource(this);
         this.profiles = new ProfilesResource(this);
+        this.proxy = new ProxyResource(this);
     }
     async close() {
-        await this.proxy.stop();
+        await this.localProxy.stop();
     }
     /**
      * Create a session and return a connected browser.
@@ -365,6 +453,17 @@ export class Solari {
                 // pre-creates one when a proxy was requested, so on a plain
                 // launch() browser.contexts() was empty and contexts()[0]
                 // undefined — which the SDK's own docs pointed callers at.
+                //
+                // DELIBERATE DOUBLE-SEED (audit-profiles-not-applied): the pool
+                // now ALSO seeds browser.contexts()[0] server-side whenever
+                // storageStateUrl is present, so a published build of this SDK
+                // talking to a fixed gateway seeds the same profile twice (one
+                // extra GCS fetch, harmless). DO NOT remove this seed on the
+                // assumption the server already did it — this SDK version may
+                // be talking to an OLDER gateway that doesn't carry the
+                // server-side fix, and the server has no way to tell the SDK
+                // whether it already seeded. Version skew means the SDK must
+                // assume the server did nothing.
                 const ctxOptions = {};
                 const tz = session.proxy?.timezoneId;
                 if (tz)
@@ -443,18 +542,23 @@ export class Solari {
         catch (e) {
             throw new SolariError(`Solari: invalid upstream ${kind}Endpoint: ${upstreamEndpoint}`, undefined, e);
         }
-        await this.proxy.start();
-        this.proxy.register(sessionId, upstream, kind);
-        return this.proxy.getLocalEndpoint(sessionId, kind);
+        await this.localProxy.start();
+        this.localProxy.register(sessionId, upstream, kind);
+        return this.localProxy.getLocalEndpoint(sessionId, kind);
     }
     _unregisterSession(sessionId) {
-        this.proxy.unregister(sessionId);
+        this.localProxy.unregister(sessionId);
     }
-    async request(method, path, body) {
+    async request(method, path, body, opts) {
         const url = `${this.baseUrl}${path}`;
+        // Built ONCE, outside the retry loop, so every attempt of this call
+        // carries the same key. See newIdempotencyKey.
         const headers = {
             Authorization: `Bearer ${this.apiKey}`,
             "Content-Type": "application/json",
+            ...(opts?.idempotencyKey
+                ? { "Idempotency-Key": opts.idempotencyKey }
+                : {}),
         };
         const payload = body === undefined ? undefined : JSON.stringify(body);
         let lastErr;
@@ -471,7 +575,10 @@ export class Solari {
                 clearTimeout(timer);
                 if (res.ok)
                     return res;
-                if (!isRetryableStatus(res.status))
+                const retryThis = (isRetryableStatus(res.status) && !(await responseIsTerminal503(res))) ||
+                    (isSafeToReplay(method, opts?.idempotencyKey) &&
+                        (await responseSaysRetryable(res)));
+                if (!retryThis)
                     return res;
                 await res.text().catch(() => { });
                 lastErr = new SolariError(`Solari ${method} ${path}: ${res.status}`, res.status);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solarisdk/browser",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Official client SDK for Solari Browser.",
   "license": "Apache-2.0",
   "type": "module",
@@ -36,6 +36,8 @@
   },
   "scripts": {
     "build": "tsc",
+    "typecheck": "node ../scripts/typecheck-guard.mjs 2 -- tsc --noEmit",
+    "test": "tsc && node --test test/*.test.mjs",
     "prepublishOnly": "node ../scripts/check-sdk-version-pin.mjs && tsc"
   },
   "dependencies": {