withruntime 0.11.2 → 0.12.0

package/dist/products/billing.d.ts

@@ -24,6 +24,39 @@ export type Topup = {
         }[];
     }[];
 };
+/** Auto top-up: when credit falls below `below`, the saved card is charged
+ *  `amount` plus tax, within `monthlyLimit` a calendar month (UTC). Each
+ *  automatic top-up adds 5% more as credit, and while it is on the account
+ *  may run 200 sandboxes at once. Dollars are numbers in whole cents. */
+export type AutoTopUp = {
+    /** Charging now. */
+    enabled: boolean;
+    /** Asked to turn on; turns on once a person saves a card at `saveCardAt`. */
+    waitingForCard: boolean;
+    below: number | null;
+    amount: number | null;
+    monthlyLimit: number | null;
+    /** Dollars added this month, a charge in flight included. */
+    thisMonth: number;
+    card: boolean;
+    /** Why it turned itself off; null while on. */
+    offReason: "declined" | "authentication_required" | "card_removed" | "no_address" | "blocked" | "failed" | null;
+    offAt: string | null;
+    /** Where a person saves the card, while none is saved. */
+    saveCardAt: string | null;
+};
+/** A figure left out keeps the one saved, or takes its default. */
+export type AutoTopUpInput = {
+    enabled: boolean;
+    /** Charge when credit falls below this: $10 at least, and the default. */
+    below?: number;
+    /** Each time, before tax: $20 (the default) to $10,000, and at most $500
+     *  in an account's first week. */
+    amount?: number;
+    /** The most a calendar month (UTC): $100 at least and at least `amount`;
+     *  $500 by default. */
+    monthlyLimit?: number;
+};
 export declare function billing(t: Transport): {
     /** Open a stablecoin top-up of `usd` dollars ($10 to $10,000). Pass the
      *  same `idempotencyKey` when retrying to get the same top-up back. */
@@ -32,4 +65,12 @@ export declare function billing(t: Transport): {
     }, options?: RequestOptions) => Promise<Topup>;
     /** Read a top-up: whether its payment has arrived. */
     topupStatus: (purchaseId: string, options?: RequestOptions) => Promise<Topup>;
+    /** Auto top-up's settings. A person saves its card on the website. */
+    autoTopUp: {
+        get: (options?: RequestOptions) => Promise<AutoTopUp>;
+        /** Set the three figures, and turn it on (once a card is saved) or keep it off. */
+        set: (input: AutoTopUpInput, options?: RequestOptions) => Promise<AutoTopUp>;
+        /** Turn it off. The figures and the card are kept; running sandboxes are never stopped. */
+        off: (options?: RequestOptions) => Promise<AutoTopUp>;
+    };
 };

package/dist/products/billing.js

@@ -9,5 +9,18 @@ export function billing(t) {
             path: `/v1/billing/topups/${encodeURIComponent(purchaseId)}`,
             ...options,
         }),
+        /** Auto top-up's settings. A person saves its card on the website. */
+        autoTopUp: {
+            get: (options) => t.json({ method: "GET", path: "/v1/billing/auto-top-up", ...options }),
+            /** Set the three figures, and turn it on (once a card is saved) or keep it off. */
+            set: (input, options) => t.json({
+                method: "PUT",
+                path: "/v1/billing/auto-top-up",
+                body: input,
+                ...options,
+            }),
+            /** Turn it off. The figures and the card are kept; running sandboxes are never stopped. */
+            off: (options) => t.json({ method: "DELETE", path: "/v1/billing/auto-top-up", ...options }),
+        },
     };
 }

package/dist/products/browser.d.ts

@@ -18,6 +18,11 @@ export type SandboxBrowser = {
     expiresAt: string | null;
     /** headless: false only: the desktop's live view. */
     streamUrl?: string;
+    /** start() only: the sandbox's memory, which is the browser's. */
+    memoryMiB?: number;
+    /** start() only, under 2 GiB: heavy apps such as Google Sheets, YouTube
+     * and StackBlitz need a 2 GiB sandbox; 1 GiB suits light pages. */
+    hint?: string;
 };
 export type BrowserStartOptions = {
     /** true (the default): no window. false: on the sandbox's desktop, with a live view. */
@@ -52,6 +57,11 @@ export declare function sandboxBrowser(t: Transport, sandbox: Sandbox): {
         expiresAt: string | null;
         /** headless: false only: the desktop's live view. */
         streamUrl?: string;
+        /** start() only: the sandbox's memory, which is the browser's. */
+        memoryMiB?: number;
+        /** start() only, under 2 GiB: heavy apps such as Google Sheets, YouTube
+         * and StackBlitz need a 2 GiB sandbox; 1 GiB suits light pages. */
+        hint?: string;
     }>;
     /** Whether it runs, and a fresh cdpUrl when it does. */
     get: (options?: RequestOptions) => Promise<SandboxBrowser>;

package/dist/products/browsers.d.ts

@@ -0,0 +1,71 @@
+import { Page } from "../page.js";
+import type { RequestOptions, Transport } from "../transport.js";
+export type CreateBrowser = {
+    /** 1024–16384 MiB; the server defaults to 2048. */
+    memoryMiB?: number;
+    /** The server defaults to 1 vCPU. */
+    vcpu?: number;
+    /** Defaults to true; false requests a visible browser. */
+    headless?: boolean;
+    width?: number;
+    height?: number;
+    timeoutSeconds?: number;
+    idlePauseSeconds?: number;
+    name?: string;
+    labels?: Record<string, string>;
+};
+export type UpdateBrowser = {
+    name?: string | null;
+    labels?: Record<string, string>;
+};
+export type ListBrowsers = {
+    limit?: number;
+    cursor?: string;
+};
+/** A browser resource and its current connection credentials. */
+export type BrowserInfo = {
+    id: string;
+    name: string | null;
+    labels: Record<string, string>;
+    state: string;
+    sandboxId: string;
+    memoryMiB: number;
+    vcpu: number;
+    headless: boolean;
+    version: string;
+    cdpUrl: string;
+    httpUrl: string;
+    headers: Record<string, string>;
+    expiresAt: string | null;
+    liveViewUrl?: string;
+    hint?: string;
+};
+export type BrowserConnectOptions = {
+    playwright: [endpointURL: string, options: {
+        headers: Record<string, string>;
+    }];
+    puppeteer: {
+        browserWSEndpoint: string;
+        headers: Record<string, string>;
+    };
+};
+export type Browser = BrowserInfo & {
+    /** End this browser; concurrent calls share one request, and failures can be retried. */
+    delete(options?: RequestOptions): Promise<void>;
+    /** Get Playwright's argument tuple and Puppeteer's options, including authentication headers. */
+    connectOptions(): BrowserConnectOptions;
+    /** End this browser on scope exit; an already missing browser counts as cleaned up. */
+    [Symbol.asyncDispose](): Promise<void>;
+};
+/** Browsers follow the shared resource interface: id, name, labels, state. */
+export declare function browsers(t: Transport): {
+    /** Create a browser ready to connect; omitted fields use the server's defaults. */
+    create(input?: CreateBrowser, options?: RequestOptions): Promise<Browser>;
+    /** Fetch a browser by id with fresh CDP connection credentials. */
+    get(id: string, options?: RequestOptions): Promise<Browser>;
+    list: (query?: ListBrowsers, options?: RequestOptions) => Promise<Page<Browser>>;
+    /** Change a browser's name or labels without changing its compute settings. */
+    update(id: string, input: UpdateBrowser, options?: RequestOptions): Promise<Browser>;
+    /** End a browser by id; pass RequestOptions to bound or deduplicate the request. */
+    delete: (id: string, options?: RequestOptions) => Promise<void>;
+};

package/dist/products/browsers.js

@@ -0,0 +1,102 @@
+/**
+ * Managed Chromium browsers with authenticated Chrome DevTools Protocol (CDP) connections.
+ *
+ * await using browser = await runtime.browsers.create();
+ * const playwrightBrowser = await chromium.connectOverCDP(...browser.connectOptions().playwright);
+ * const puppeteerBrowser = await puppeteer.connect(browser.connectOptions().puppeteer);
+ *
+ * Use `get(browser.id)` for fresh connection credentials after `expiresAt`.
+ */
+import { RuntimeError } from "../errors.js";
+import { Page } from "../page.js";
+/** Browsers follow the shared resource interface: id, name, labels, state. */
+export function browsers(t) {
+    const path = (id) => `/v1/browsers/${encodeURIComponent(id)}`;
+    /** End a browser by id; API errors retain their code and recovery hint. */
+    const remove = async (id, options) => {
+        await t.json({ method: "DELETE", path: path(id), ...options });
+    };
+    const wrap = (info) => {
+        let deleted = false;
+        let deleting;
+        const browser = {
+            ...info,
+            delete(options) {
+                if (deleted)
+                    return Promise.resolve();
+                if (!deleting) {
+                    deleting = remove(info.id, options)
+                        .then(() => {
+                        deleted = true;
+                    })
+                        .catch((error) => {
+                        if (error instanceof RuntimeError && error.status === 404)
+                            deleted = true;
+                        throw error;
+                    })
+                        .finally(() => {
+                        deleting = undefined;
+                    });
+                }
+                return deleting;
+            },
+            connectOptions() {
+                return {
+                    playwright: [browser.cdpUrl, { headers: { ...browser.headers } }],
+                    puppeteer: {
+                        browserWSEndpoint: browser.cdpUrl,
+                        headers: { ...browser.headers },
+                    },
+                };
+            },
+            async [Symbol.asyncDispose]() {
+                // Creation's signal/key belong to creation: an aborted task must still clean up.
+                try {
+                    await browser.delete();
+                }
+                catch (error) {
+                    if (!(error instanceof RuntimeError && error.status === 404))
+                        throw error;
+                }
+            },
+        };
+        return browser;
+    };
+    /** Fetch one page; `for await (const browser of await list())` follows every cursor. */
+    const list = async (query = {}, options) => {
+        const page = await t.json({
+            method: "GET",
+            path: "/v1/browsers",
+            query,
+            ...options,
+        });
+        return new Page(page.data.map(wrap), page.nextCursor, (cursor) => list({ ...query, cursor }, options));
+    };
+    return {
+        /** Create a browser ready to connect; omitted fields use the server's defaults. */
+        async create(input = {}, options) {
+            return wrap(await t.json({
+                method: "POST",
+                path: "/v1/browsers",
+                body: input,
+                ...options,
+            }));
+        },
+        /** Fetch a browser by id with fresh CDP connection credentials. */
+        async get(id, options) {
+            return wrap(await t.json({ method: "GET", path: path(id), ...options }));
+        },
+        list,
+        /** Change a browser's name or labels without changing its compute settings. */
+        async update(id, input, options) {
+            return wrap(await t.json({
+                method: "POST",
+                path: `${path(id)}:update`,
+                body: input,
+                ...options,
+            }));
+        },
+        /** End a browser by id; pass RequestOptions to bound or deduplicate the request. */
+        delete: remove,
+    };
+}

package/dist/products/builds.d.ts

@@ -0,0 +1,126 @@
+import { Page } from "../page.js";
+import { type RequestOptions, type Transport } from "../transport.js";
+export type BuildState = "queued" | "fetching" | "building" | "deploying" | "succeeded" | "failed" | "cancelled" | "superseded";
+type Resource = {
+    id: string;
+    name: string | null;
+    labels: Record<string, string>;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt: number | null;
+    error: {
+        code: string;
+        message: string;
+    } | null;
+};
+export type Build = Resource & {
+    repositoryId: string;
+    ref: string;
+    commit: string | null;
+    state: BuildState;
+    reason: string | null;
+};
+export type CreateBuild = {
+    repositoryId: string;
+    ref: string;
+    name?: string;
+    labels?: Record<string, string>;
+};
+export type ConnectRepository = {
+    provider: "github" | "git";
+    repository: string;
+    deploy: `app:${string}` | `function:${string}` | `container:${string}`;
+    productionBranch?: string;
+    previews?: boolean;
+    /** The folder the build runs in; the repository's root by default. */
+    rootDirectory?: string;
+    /** Leave out to choose by the lockfile (bun, pnpm, Yarn or npm). */
+    installCommand?: string | null;
+    buildCommand?: string | null;
+    name?: string;
+    labels?: Record<string, string>;
+};
+export type Repository = Resource & {
+    provider: "github" | "git";
+    repository: string;
+    deploy: ConnectRepository["deploy"];
+    productionBranch: string;
+    previews: boolean;
+    rootDirectory: string;
+    installCommand: string | null;
+    buildCommand: string | null;
+    state: "connected" | "disconnected";
+};
+export type ListBuilds = {
+    limit?: number;
+    cursor?: string;
+    name?: string;
+    label?: string[];
+    state?: BuildState[];
+};
+export type ListRepositories = Omit<ListBuilds, "state"> & {
+    state?: Repository["state"][];
+};
+export type BuildLine = {
+    cursor: string | null;
+    at: number;
+    step: string | null;
+    text: string;
+    stream: "stdout" | "stderr";
+};
+export type FailingStep = {
+    name: string;
+    exitCode: number | null;
+    lastLines: string[];
+};
+export type BuildLog = {
+    lines: BuildLine[];
+    cursor: string | null;
+    state: BuildState;
+    reason: string | null;
+    failingStep: FailingStep | null;
+    hasMore: boolean;
+    nextCursor: string | null;
+};
+export type BuildLogEvent = ({
+    type: "line";
+} & BuildLine & {
+    cursor: string;
+}) | {
+    type: "gap";
+    cursor: string | null;
+    earliestCursor: string;
+} | {
+    type: "terminal";
+    cursor: string | null;
+    state: "succeeded" | "failed" | "cancelled" | "superseded";
+    reason: string;
+    failingStep: FailingStep | null;
+};
+/** cursor resumes a follow; pageCursor pages older search results. */
+export type LogOptions = {
+    follow?: boolean;
+    cursor?: string;
+    pageCursor?: string;
+};
+export declare function builds(t: Transport): {
+    create: (input: CreateBuild, options?: RequestOptions) => Promise<Build>;
+    get: (id: string, options?: RequestOptions) => Promise<Build>;
+    list: (query?: ListBuilds, options?: RequestOptions) => Promise<Page<Build>>;
+    logs: {
+        (id: string, query: LogOptions & {
+            follow: true;
+        }, options?: RequestOptions): AsyncGenerator<BuildLogEvent>;
+        (id: string, query?: LogOptions & {
+            follow?: false;
+        }, options?: RequestOptions): Promise<BuildLog>;
+        (id: string, query: LogOptions, options?: RequestOptions): Promise<BuildLog> | AsyncGenerator<BuildLogEvent>;
+    };
+    cancel: (id: string, options?: RequestOptions) => Promise<Build>;
+    repositories: {
+        connect: (input: ConnectRepository, options?: RequestOptions) => Promise<Repository>;
+        list: (query?: ListRepositories, options?: RequestOptions) => Promise<Page<Repository>>;
+        disconnect: (id: string, options?: RequestOptions) => Promise<Repository>;
+    };
+};
+export {};

package/dist/products/builds.js

@@ -0,0 +1,221 @@
+/** Builds uses the shared request keys and paged lists.
+ * Unwired until the build planner's production adapter is ready. */
+import { ConnectionError, RuntimeError } from "../errors.js";
+import { Page } from "../page.js";
+import { timeoutSignal } from "../transport.js";
+const terminal = new Set(["succeeded", "failed", "cancelled", "superseded"]);
+function validFailure(value) {
+    if (value === null)
+        return true;
+    if (!value || typeof value !== "object")
+        return false;
+    const step = value;
+    return (typeof step.name === "string" &&
+        (step.exitCode === null || Number.isSafeInteger(step.exitCode)) &&
+        Array.isArray(step.lastLines) &&
+        step.lastLines.length <= 20 &&
+        step.lastLines.every((line) => typeof line === "string"));
+}
+function failure(code, hint, cursor) {
+    return new RuntimeError({ code, status: 0, message: hint, hint, details: { cursor } });
+}
+function validCursor(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= 4096 &&
+        ![...value].some((c) => c.charCodeAt(0) < 0x20 || c.charCodeAt(0) === 0x7f));
+}
+/** Why a wait ended: the signal's own reason, always as an Error. */
+const abortReason = (signal) => signal?.reason instanceof Error ? signal.reason : new Error(String(signal?.reason ?? "aborted"));
+async function* boundedEvents(source, signal) {
+    try {
+        for (;;) {
+            signal?.throwIfAborted();
+            let abort = () => { };
+            let next;
+            try {
+                next = await Promise.race([
+                    source.next(),
+                    new Promise((_, reject) => {
+                        abort = () => reject(abortReason(signal));
+                        signal?.addEventListener("abort", abort, { once: true });
+                        if (signal?.aborted)
+                            abort();
+                    }),
+                ]);
+            }
+            finally {
+                signal?.removeEventListener("abort", abort);
+            }
+            if (next.done)
+                return;
+            yield next.value;
+        }
+    }
+    finally {
+        // An injected transport can ignore abort while next() is pending. It must
+        // not prevent the caller's deadline from resolving; request its cleanup.
+        const closed = source.return(undefined);
+        if (signal?.aborted)
+            void closed.catch(() => { });
+        else
+            await closed;
+    }
+}
+export function builds(t) {
+    const path = (id) => `/v1/builds/${encodeURIComponent(id)}`;
+    const list = async (query = {}, options) => {
+        const page = await t.json({
+            method: "GET",
+            path: "/v1/builds",
+            query,
+            ...options,
+        });
+        return new Page(page.data, page.nextCursor, (cursor) => list({ ...query, cursor }, options));
+    };
+    const listRepositories = async (query = {}, options) => {
+        const page = await t.json({
+            method: "GET",
+            path: "/v1/repositories",
+            query,
+            ...options,
+        });
+        return new Page(page.data, page.nextCursor, (cursor) => listRepositories({ ...query, cursor }, options));
+    };
+    async function* follow(id, query, options = {}) {
+        let cursor = query.cursor ?? null;
+        if ((cursor !== null && !validCursor(cursor)) || query.pageCursor !== undefined)
+            throw failure("invalid_log_options", "Use an opaque cursor for follow; pageCursor is only for search pages.", cursor);
+        const seen = new Set(cursor === null ? [] : [cursor]);
+        let failures = 0;
+        // Bound the entire follow when the caller sets a deadline, including
+        // reconnections. Transport's per-request deadline alone resets on retry.
+        const signal = (options.timeoutMs ?? 120_000) > 0
+            ? AbortSignal.any([
+                ...(options.signal ? [options.signal] : []),
+                timeoutSignal(options.timeoutMs ?? 120_000),
+            ])
+            : options.signal;
+        for (;;) {
+            signal?.throwIfAborted();
+            let continued = false;
+            try {
+                for await (const event of boundedEvents(t.events({
+                    method: "GET",
+                    path: `${path(id)}/logs`,
+                    query: { follow: true, ...(cursor === null ? {} : { cursor }) },
+                    ...options,
+                    ...(signal ? { signal } : {}),
+                }), signal)) {
+                    signal?.throwIfAborted();
+                    if (!event || typeof event !== "object")
+                        throw failure("build_log_invalid", "Retry the log from the last received cursor.", cursor);
+                    if (event.cursor !== null && !validCursor(event.cursor))
+                        throw failure("build_log_invalid", "Retry from the last received cursor.", cursor);
+                    if (event.type === "line") {
+                        if (typeof event.text !== "string" ||
+                            !["stdout", "stderr"].includes(event.stream) ||
+                            !Number.isSafeInteger(event.at) ||
+                            event.at < 0 ||
+                            (event.step !== null && typeof event.step !== "string") ||
+                            !validCursor(event.cursor))
+                            throw failure("build_log_invalid", "Retry the log from the last received cursor.", cursor);
+                        // Opaque physical positions cannot be ordered or incremented.
+                        if (seen.has(event.cursor))
+                            continue;
+                        seen.add(event.cursor);
+                        if (seen.size > 10_000)
+                            seen.delete(seen.values().next().value);
+                        cursor = event.cursor;
+                        failures = 0;
+                        yield event;
+                    }
+                    else if (event.type === "gap") {
+                        if (!validCursor(event.earliestCursor) || (cursor !== null && event.cursor !== cursor))
+                            throw failure("build_log_invalid", "Retry from the last received cursor.", cursor);
+                        cursor = event.cursor;
+                        yield event;
+                    }
+                    else if (event.type === "terminal") {
+                        if ((cursor !== null && event.cursor !== cursor) ||
+                            !terminal.has(event.state) ||
+                            typeof event.reason !== "string" ||
+                            !event.reason ||
+                            !validFailure(event.failingStep) ||
+                            (event.state !== "failed" && event.failingStep !== null))
+                            throw failure("build_log_invalid", "Retry the log from the last received cursor.", cursor);
+                        yield event;
+                        return;
+                    }
+                    else if (event.type === "continue") {
+                        if (cursor !== null && event.cursor !== cursor)
+                            throw failure("build_log_gap", "Resume from details.cursor; report a persistent missing log line.", cursor);
+                        cursor = event.cursor;
+                        continued = true;
+                        break;
+                    }
+                    else if (event.type === "error") {
+                        if (event.cursor !== cursor ||
+                            typeof event.code !== "string" ||
+                            !event.code ||
+                            typeof event.hint !== "string" ||
+                            !event.hint)
+                            throw failure("build_log_invalid", "Retry the log from the last received cursor.", cursor);
+                        throw failure(event.code, event.hint, cursor);
+                    }
+                    else
+                        throw failure("build_log_invalid", "Retry the log from the last received cursor.", cursor);
+                }
+            }
+            catch (error) {
+                signal?.throwIfAborted();
+                if (error instanceof SyntaxError)
+                    throw failure("build_log_invalid", "The log contained invalid JSON; retry from details.cursor.", cursor);
+                // HTTP refusals and protocol errors are actionable, not connection
+                // loss. The transport itself retries retryable HTTP responses.
+                if (!(error instanceof TypeError) && !(error instanceof ConnectionError))
+                    throw error;
+            }
+            if (!continued && ++failures > 3)
+                throw failure("build_log_interrupted", "Reconnect with logs(id, { follow: true, cursor: details.cursor }).", cursor);
+            // Prevent a disconnected service or repeated continuations busy-looping.
+            await new Promise((resolve, reject) => {
+                const done = () => {
+                    signal?.removeEventListener("abort", abort);
+                    resolve();
+                };
+                const timer = setTimeout(done, 50 * Math.max(1, failures));
+                const abort = () => {
+                    clearTimeout(timer);
+                    signal?.removeEventListener("abort", abort);
+                    reject(abortReason(signal));
+                };
+                if (signal?.aborted)
+                    abort();
+                else
+                    signal?.addEventListener("abort", abort, { once: true });
+            });
+        }
+    }
+    function logs(id, query = {}, options) {
+        return query.follow
+            ? follow(id, query, options)
+            : t.json({ method: "GET", path: `${path(id)}/logs`, query, ...options });
+    }
+    return {
+        create: (input, options) => t.json({ method: "POST", path: "/v1/builds", body: input, ...options }),
+        get: (id, options) => t.json({ method: "GET", path: path(id), ...options }),
+        list,
+        logs,
+        cancel: (id, options) => t.json({ method: "POST", path: `${path(id)}:cancel`, ...options }),
+        repositories: {
+            connect: (input, options) => t.json({ method: "POST", path: "/v1/repositories", body: input, ...options }),
+            list: listRepositories,
+            disconnect: (id, options) => t.json({
+                method: "DELETE",
+                path: `/v1/repositories/${encodeURIComponent(id)}`,
+                ...options,
+            }),
+        },
+    };
+}

package/dist/products/index.d.ts

@@ -5,7 +5,7 @@ import { sandboxDesktop } from "./desktop.js";
 import { sandboxBrowser } from "./browser.js";
 import { sandboxInterpreter } from "./interpreter.js";
 import { sandboxNetwork } from "./network.js";
-import { addresses, domains, network, ports, tunnel } from "./network-products.js";
+import { domains, ips, networks, ports } from "./network-products.js";
 import { sandboxPreviews } from "./previews.js";
 import { referrals } from "./referrals.js";
 import { billing } from "./billing.js";
@@ -37,19 +37,8 @@ export declare const clientExtensions: {
     sso: typeof sso;
     domains: typeof domains;
     ports: typeof ports;
-    addresses: typeof addresses;
-    tunnel: typeof tunnel;
-    network: typeof network;
-};
-/** Canonical CLI product names share the existing factory instance. Account
- * commands such as secrets, events and billing retain their current names. */
-export declare const clientProductAliases: {
-    readonly image: "images";
-    readonly volume: "volumes";
-    readonly job: "jobs";
-    readonly domain: "domains";
-    readonly port: "ports";
-    readonly address: "addresses";
+    ips: typeof ips;
+    networks: typeof networks;
 };
 export declare const sandboxExtensions: {
     interpreter: typeof sandboxInterpreter;
@@ -64,8 +53,6 @@ export declare const sandboxExtensions: {
 };
 export type ClientExtensions = {
     readonly [K in keyof typeof clientExtensions]: ReturnType<(typeof clientExtensions)[K]>;
-} & {
-    readonly [K in keyof typeof clientProductAliases]: ReturnType<(typeof clientExtensions)[(typeof clientProductAliases)[K]]>;
 };
 export type SandboxExtensions = {
     readonly [K in keyof typeof sandboxExtensions]: ReturnType<(typeof sandboxExtensions)[K]>;