@rivetkit/engine 1.0.0

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessHealthCheckResponseFailureFailure.ts

@@ -0,0 +1,9 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+import * as Rivet from "../index";
+
+export interface RunnerConfigsServerlessHealthCheckResponseFailureFailure {
+    error: Rivet.RunnerConfigsServerlessMetadataError;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessHealthCheckResponseSuccess.ts

@@ -0,0 +1,9 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+import * as Rivet from "../index";
+
+export interface RunnerConfigsServerlessHealthCheckResponseSuccess {
+    success: Rivet.RunnerConfigsServerlessHealthCheckResponseSuccessSuccess;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessHealthCheckResponseSuccessSuccess.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+export interface RunnerConfigsServerlessHealthCheckResponseSuccessSuccess {
+    version: string;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessMetadataError.ts

@@ -0,0 +1,13 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+import * as Rivet from "../index";
+
+export type RunnerConfigsServerlessMetadataError =
+    | Rivet.RunnerConfigsServerlessMetadataErrorInvalidRequest
+    | Rivet.RunnerConfigsServerlessMetadataErrorRequestFailed
+    | Rivet.RunnerConfigsServerlessMetadataErrorRequestTimedOut
+    | Rivet.RunnerConfigsServerlessMetadataErrorNonSuccessStatus
+    | Rivet.RunnerConfigsServerlessMetadataErrorInvalidResponseJson
+    | Rivet.RunnerConfigsServerlessMetadataErrorInvalidResponseSchema;

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessMetadataErrorInvalidRequest.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+export interface RunnerConfigsServerlessMetadataErrorInvalidRequest {
+    invalidRequest: Record<string, unknown>;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessMetadataErrorInvalidResponseJson.ts

@@ -0,0 +1,9 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+import * as Rivet from "../index";
+
+export interface RunnerConfigsServerlessMetadataErrorInvalidResponseJson {
+    invalidResponseJson: Rivet.RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+export interface RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson {
+    body: string;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessMetadataErrorInvalidResponseSchema.ts

@@ -0,0 +1,9 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+import * as Rivet from "../index";
+
+export interface RunnerConfigsServerlessMetadataErrorInvalidResponseSchema {
+    invalidResponseSchema: Rivet.RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema.ts

@@ -0,0 +1,8 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+export interface RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema {
+    runtime: string;
+    version: string;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessMetadataErrorNonSuccessStatus.ts

@@ -0,0 +1,9 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+import * as Rivet from "../index";
+
+export interface RunnerConfigsServerlessMetadataErrorNonSuccessStatus {
+    nonSuccessStatus: Rivet.RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus.ts

@@ -0,0 +1,8 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+export interface RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus {
+    body: string;
+    statusCode: number;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessMetadataErrorRequestFailed.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+export interface RunnerConfigsServerlessMetadataErrorRequestFailed {
+    requestFailed: Record<string, unknown>;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsServerlessMetadataErrorRequestTimedOut.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+export interface RunnerConfigsServerlessMetadataErrorRequestTimedOut {
+    requestTimedOut: Record<string, unknown>;
+}

package/sdks/typescript/api-full/src/api/types/RunnerConfigsUpsertResponse.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+export interface RunnerConfigsUpsertResponse {
+    endpointConfigChanged: boolean;
+}

package/sdks/typescript/api-full/src/api/types/RunnersListNamesResponse.ts

@@ -0,0 +1,10 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+import * as Rivet from "../index";
+
+export interface RunnersListNamesResponse {
+    names: string[];
+    pagination: Rivet.Pagination;
+}

package/sdks/typescript/api-full/src/api/types/RunnersListResponse.ts

@@ -0,0 +1,10 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+
+import * as Rivet from "../index";
+
+export interface RunnersListResponse {
+    pagination: Rivet.Pagination;
+    runners: Rivet.Runner[];
+}

package/sdks/typescript/api-full/src/api/types/index.ts

@@ -0,0 +1,51 @@
+export * from "./Actor";
+export * from "./ActorName";
+export * from "./ActorsCreateResponse";
+export * from "./ActorsDeleteResponse";
+export * from "./ActorsGetOrCreateResponse";
+export * from "./ActorsKvGetResponse";
+export * from "./ActorsListNamesResponse";
+export * from "./ActorsListResponse";
+export * from "./CrashPolicy";
+export * from "./Datacenter";
+export * from "./DatacenterHealth";
+export * from "./DatacentersListResponse";
+export * from "./HealthFanoutResponse";
+export * from "./HealthResponse";
+export * from "./HealthStatus";
+export * from "./Namespace";
+export * from "./NamespaceListResponse";
+export * from "./NamespacesCreateResponse";
+export * from "./Pagination";
+export * from "./RivetId";
+export * from "./Runner";
+export * from "./RunnerConfigServerless";
+export * from "./RunnerConfig";
+export * from "./RunnerConfigKindNormal";
+export * from "./RunnerConfigKindServerlessServerless";
+export * from "./RunnerConfigKindServerless";
+export * from "./RunnerConfigKind";
+export * from "./RunnerConfigVariant";
+export * from "./RunnerConfigsDeleteResponse";
+export * from "./RunnerConfigsListResponse";
+export * from "./RunnerConfigsListResponseRunnerConfigsValue";
+export * from "./RunnerConfigsRefreshMetadataRequestBody";
+export * from "./RunnerConfigsRefreshMetadataResponse";
+export * from "./RunnerConfigsServerlessHealthCheckResponseSuccessSuccess";
+export * from "./RunnerConfigsServerlessHealthCheckResponseSuccess";
+export * from "./RunnerConfigsServerlessHealthCheckResponseFailureFailure";
+export * from "./RunnerConfigsServerlessHealthCheckResponseFailure";
+export * from "./RunnerConfigsServerlessHealthCheckResponse";
+export * from "./RunnerConfigsServerlessMetadataErrorInvalidRequest";
+export * from "./RunnerConfigsServerlessMetadataErrorRequestFailed";
+export * from "./RunnerConfigsServerlessMetadataErrorRequestTimedOut";
+export * from "./RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus";
+export * from "./RunnerConfigsServerlessMetadataErrorNonSuccessStatus";
+export * from "./RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson";
+export * from "./RunnerConfigsServerlessMetadataErrorInvalidResponseJson";
+export * from "./RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema";
+export * from "./RunnerConfigsServerlessMetadataErrorInvalidResponseSchema";
+export * from "./RunnerConfigsServerlessMetadataError";
+export * from "./RunnerConfigsUpsertResponse";
+export * from "./RunnersListNamesResponse";
+export * from "./RunnersListResponse";

package/sdks/typescript/api-full/src/core/auth/BasicAuth.ts

@@ -0,0 +1,31 @@
+import { Base64 } from "js-base64";
+
+export interface BasicAuth {
+    username: string;
+    password: string;
+}
+
+const BASIC_AUTH_HEADER_PREFIX = /^Basic /i;
+
+export const BasicAuth = {
+    toAuthorizationHeader: (basicAuth: BasicAuth | undefined): string | undefined => {
+        if (basicAuth == null) {
+            return undefined;
+        }
+        const token = Base64.encode(`${basicAuth.username}:${basicAuth.password}`);
+        return `Basic ${token}`;
+    },
+    fromAuthorizationHeader: (header: string): BasicAuth => {
+        const credentials = header.replace(BASIC_AUTH_HEADER_PREFIX, "");
+        const decoded = Base64.decode(credentials);
+        const [username, password] = decoded.split(":", 2);
+
+        if (username == null || password == null) {
+            throw new Error("Invalid basic auth");
+        }
+        return {
+            username,
+            password,
+        };
+    },
+};

package/sdks/typescript/api-full/src/core/auth/BearerToken.ts

@@ -0,0 +1,15 @@
+export type BearerToken = string;
+
+const BEARER_AUTH_HEADER_PREFIX = /^Bearer /i;
+
+export const BearerToken = {
+    toAuthorizationHeader: (token: BearerToken | undefined): string | undefined => {
+        if (token == null) {
+            return undefined;
+        }
+        return `Bearer ${token}`;
+    },
+    fromAuthorizationHeader: (header: string): BearerToken => {
+        return header.replace(BEARER_AUTH_HEADER_PREFIX, "").trim() as BearerToken;
+    },
+};

package/sdks/typescript/api-full/src/core/auth/index.ts

@@ -0,0 +1,2 @@
+export { BasicAuth } from "./BasicAuth";
+export { BearerToken } from "./BearerToken";

package/sdks/typescript/api-full/src/core/fetcher/APIResponse.ts

@@ -0,0 +1,12 @@
+export type APIResponse<Success, Failure> = SuccessfulResponse<Success> | FailedResponse<Failure>;
+
+export interface SuccessfulResponse<T> {
+    ok: true;
+    body: T;
+    headers?: Record<string, any>;
+}
+
+export interface FailedResponse<T> {
+    ok: false;
+    error: T;
+}

package/sdks/typescript/api-full/src/core/fetcher/Fetcher.ts

@@ -0,0 +1,144 @@
+import { toJson } from "../json";
+import { APIResponse } from "./APIResponse";
+import { createRequestUrl } from "./createRequestUrl";
+import { getFetchFn } from "./getFetchFn";
+import { getRequestBody } from "./getRequestBody";
+import { getResponseBody } from "./getResponseBody";
+import { makeRequest } from "./makeRequest";
+import { requestWithRetries } from "./requestWithRetries";
+
+export type FetchFunction = <R = unknown>(args: Fetcher.Args) => Promise<APIResponse<R, Fetcher.Error>>;
+
+export declare namespace Fetcher {
+    export interface Args {
+        url: string;
+        method: string;
+        contentType?: string;
+        headers?: Record<string, string | undefined>;
+        queryParameters?: Record<string, string | string[] | object | object[] | null>;
+        body?: unknown;
+        timeoutMs?: number;
+        maxRetries?: number;
+        withCredentials?: boolean;
+        abortSignal?: AbortSignal;
+        requestType?: "json" | "file" | "bytes";
+        responseType?: "json" | "blob" | "sse" | "streaming" | "text" | "arrayBuffer";
+        duplex?: "half";
+    }
+
+    export type Error = FailedStatusCodeError | NonJsonError | TimeoutError | UnknownError;
+
+    export interface FailedStatusCodeError {
+        reason: "status-code";
+        statusCode: number;
+        body: unknown;
+    }
+
+    export interface NonJsonError {
+        reason: "non-json";
+        statusCode: number;
+        rawBody: string;
+    }
+
+    export interface TimeoutError {
+        reason: "timeout";
+    }
+
+    export interface UnknownError {
+        reason: "unknown";
+        errorMessage: string;
+    }
+}
+
+export async function fetcherImpl<R = unknown>(args: Fetcher.Args): Promise<APIResponse<R, Fetcher.Error>> {
+    const headers: Record<string, string> = {};
+    if (args.body !== undefined && args.contentType != null) {
+        headers["Content-Type"] = args.contentType;
+    }
+
+    if (args.headers != null) {
+        for (const [key, value] of Object.entries(args.headers)) {
+            if (value != null) {
+                headers[key] = value;
+            }
+        }
+    }
+
+    const url = createRequestUrl(args.url, args.queryParameters);
+    const requestBody: BodyInit | undefined = await getRequestBody({
+        body: args.body,
+        type: args.requestType === "json" ? "json" : "other",
+    });
+    const fetchFn = await getFetchFn();
+
+    try {
+        const response = await requestWithRetries(
+            async () =>
+                makeRequest(
+                    fetchFn,
+                    url,
+                    args.method,
+                    headers,
+                    requestBody,
+                    args.timeoutMs,
+                    args.abortSignal,
+                    args.withCredentials,
+                    args.duplex,
+                ),
+            args.maxRetries,
+        );
+        const responseBody = await getResponseBody(response, args.responseType);
+
+        if (response.status >= 200 && response.status < 400) {
+            return {
+                ok: true,
+                body: responseBody as R,
+                headers: response.headers,
+            };
+        } else {
+            return {
+                ok: false,
+                error: {
+                    reason: "status-code",
+                    statusCode: response.status,
+                    body: responseBody,
+                },
+            };
+        }
+    } catch (error) {
+        if (args.abortSignal != null && args.abortSignal.aborted) {
+            return {
+                ok: false,
+                error: {
+                    reason: "unknown",
+                    errorMessage: "The user aborted a request",
+                },
+            };
+        } else if (error instanceof Error && error.name === "AbortError") {
+            return {
+                ok: false,
+                error: {
+                    reason: "timeout",
+                },
+            };
+        } else if (error instanceof Error) {
+            return {
+                ok: false,
+                error: {
+                    reason: "unknown",
+                    errorMessage: error.message,
+                },
+            };
+        }
+
+        return {
+            ok: false,
+            error: {
+                reason: "unknown",
+                errorMessage: toJson(error),
+            },
+        };
+    }
+}
+
+export const fetcher: FetchFunction = fetcherImpl;

package/sdks/typescript/api-full/src/core/fetcher/Supplier.ts

@@ -0,0 +1,11 @@
+export type Supplier<T> = T | Promise<T> | (() => T | Promise<T>);
+
+export const Supplier = {
+    get: async <T>(supplier: Supplier<T>): Promise<T> => {
+        if (typeof supplier === "function") {
+            return (supplier as () => T)();
+        } else {
+            return supplier;
+        }
+    },
+};

package/sdks/typescript/api-full/src/core/fetcher/createRequestUrl.ts

@@ -0,0 +1,10 @@
+import qs from "qs";
+
+export function createRequestUrl(
+    baseUrl: string,
+    queryParameters?: Record<string, string | string[] | object | object[] | null>,
+): string {
+    return Object.keys(queryParameters ?? {}).length > 0
+        ? `${baseUrl}?${qs.stringify(queryParameters, { arrayFormat: "repeat" })}`
+        : baseUrl;
+}

package/sdks/typescript/api-full/src/core/fetcher/getFetchFn.ts

@@ -0,0 +1,25 @@
+import { RUNTIME } from "../runtime";
+
+/**
+ * Returns a fetch function based on the runtime
+ */
+export async function getFetchFn(): Promise<any> {
+    // In Node.js 18+ environments, use native fetch
+    if (RUNTIME.type === "node" && RUNTIME.parsedVersion != null && RUNTIME.parsedVersion >= 18) {
+        return fetch;
+    }
+
+    // In Node.js 18 or lower environments, the SDK always uses`node-fetch`.
+    if (RUNTIME.type === "node") {
+        return (await import("node-fetch")).default as any;
+    }
+
+    // Otherwise the SDK uses global fetch if available,
+    // and falls back to node-fetch.
+    if (typeof fetch == "function") {
+        return fetch;
+    }
+
+    // Defaults to node `node-fetch` if global fetch isn't available
+    return (await import("node-fetch")).default as any;
+}

package/sdks/typescript/api-full/src/core/fetcher/getHeader.ts

@@ -0,0 +1,8 @@
+export function getHeader(headers: Record<string, any>, header: string): string | undefined {
+    for (const [headerKey, headerValue] of Object.entries(headers)) {
+        if (headerKey.toLowerCase() === header.toLowerCase()) {
+            return headerValue;
+        }
+    }
+    return undefined;
+}

package/sdks/typescript/api-full/src/core/fetcher/getRequestBody.ts

@@ -0,0 +1,16 @@
+import { toJson } from "../json";
+
+export declare namespace GetRequestBody {
+    interface Args {
+        body: unknown;
+        type: "json" | "file" | "bytes" | "other";
+    }
+}
+
+export async function getRequestBody({ body, type }: GetRequestBody.Args): Promise<BodyInit | undefined> {
+    if (type.includes("json")) {
+        return toJson(body);
+    } else {
+        return body as BodyInit;
+    }
+}

package/sdks/typescript/api-full/src/core/fetcher/getResponseBody.ts

@@ -0,0 +1,34 @@
+import { chooseStreamWrapper } from "./stream-wrappers/chooseStreamWrapper";
+
+export async function getResponseBody(response: Response, responseType?: string): Promise<unknown> {
+    if (response.body != null && responseType === "blob") {
+        return await response.blob();
+    } else if (response.body != null && responseType === "arrayBuffer") {
+        return await response.arrayBuffer();
+    } else if (response.body != null && responseType === "sse") {
+        return response.body;
+    } else if (response.body != null && responseType === "streaming") {
+        return chooseStreamWrapper(response.body);
+    } else if (response.body != null && responseType === "text") {
+        return await response.text();
+    } else {
+        const text = await response.text();
+        if (text.length > 0) {
+            try {
+                let responseBody = JSON.parse(text);
+                return responseBody;
+            } catch (err) {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "non-json",
+                        statusCode: response.status,
+                        rawBody: text,
+                    },
+                };
+            }
+        } else {
+            return undefined;
+        }
+    }
+}

package/sdks/typescript/api-full/src/core/fetcher/index.ts

@@ -0,0 +1,5 @@
+export type { APIResponse } from "./APIResponse";
+export { fetcher } from "./Fetcher";
+export type { Fetcher, FetchFunction } from "./Fetcher";
+export { getHeader } from "./getHeader";
+export { Supplier } from "./Supplier";

package/sdks/typescript/api-full/src/core/fetcher/makeRequest.ts

@@ -0,0 +1,44 @@
+import { anySignal, getTimeoutSignal } from "./signals";
+
+export const makeRequest = async (
+    fetchFn: (url: string, init: RequestInit) => Promise<Response>,
+    url: string,
+    method: string,
+    headers: Record<string, string>,
+    requestBody: BodyInit | undefined,
+    timeoutMs?: number,
+    abortSignal?: AbortSignal,
+    withCredentials?: boolean,
+    duplex?: "half",
+): Promise<Response> => {
+    const signals: AbortSignal[] = [];
+
+    // Add timeout signal
+    let timeoutAbortId: NodeJS.Timeout | undefined = undefined;
+    if (timeoutMs != null) {
+        const { signal, abortId } = getTimeoutSignal(timeoutMs);
+        timeoutAbortId = abortId;
+        signals.push(signal);
+    }
+
+    // Add arbitrary signal
+    if (abortSignal != null) {
+        signals.push(abortSignal);
+    }
+    let newSignals = anySignal(signals);
+    const response = await fetchFn(url, {
+        method: method,
+        headers,
+        body: requestBody,
+        signal: newSignals,
+        credentials: withCredentials ? "include" : undefined,
+        // @ts-ignore
+        duplex,
+    });
+
+    if (timeoutAbortId != null) {
+        clearTimeout(timeoutAbortId);
+    }
+
+    return response;
+};

package/sdks/typescript/api-full/src/core/fetcher/requestWithRetries.ts

@@ -0,0 +1,33 @@
+const INITIAL_RETRY_DELAY = 1000; // in milliseconds
+const MAX_RETRY_DELAY = 60000; // in milliseconds
+const DEFAULT_MAX_RETRIES = 2;
+const JITTER_FACTOR = 0.2; // 20% random jitter
+
+function addJitter(delay: number): number {
+    // Generate a random value between -JITTER_FACTOR and +JITTER_FACTOR
+    const jitterMultiplier = 1 + (Math.random() * 2 - 1) * JITTER_FACTOR;
+    return delay * jitterMultiplier;
+}
+
+export async function requestWithRetries(
+    requestFn: () => Promise<Response>,
+    maxRetries: number = DEFAULT_MAX_RETRIES,
+): Promise<Response> {
+    let response: Response = await requestFn();
+
+    for (let i = 0; i < maxRetries; ++i) {
+        if ([408, 429].includes(response.status) || response.status >= 500) {
+            // Calculate base delay using exponential backoff (in milliseconds)
+            const baseDelay = Math.min(INITIAL_RETRY_DELAY * Math.pow(2, i), MAX_RETRY_DELAY);
+
+            // Add jitter to the delay
+            const delayWithJitter = addJitter(baseDelay);
+
+            await new Promise((resolve) => setTimeout(resolve, delayWithJitter));
+            response = await requestFn();
+        } else {
+            break;
+        }
+    }
+    return response!;
+}

package/sdks/typescript/api-full/src/core/fetcher/signals.ts

@@ -0,0 +1,38 @@
+const TIMEOUT = "timeout";
+
+export function getTimeoutSignal(timeoutMs: number): { signal: AbortSignal; abortId: NodeJS.Timeout } {
+    const controller = new AbortController();
+    const abortId = setTimeout(() => controller.abort(TIMEOUT), timeoutMs);
+    return { signal: controller.signal, abortId };
+}
+
+/**
+ * Returns an abort signal that is getting aborted when
+ * at least one of the specified abort signals is aborted.
+ *
+ * Requires at least node.js 18.
+ */
+export function anySignal(...args: AbortSignal[] | [AbortSignal[]]): AbortSignal {
+    // Allowing signals to be passed either as array
+    // of signals or as multiple arguments.
+    const signals = (args.length === 1 && Array.isArray(args[0]) ? args[0] : args) as AbortSignal[];
+
+    const controller = new AbortController();
+
+    for (const signal of signals) {
+        if (signal.aborted) {
+            // Exiting early if one of the signals
+            // is already aborted.
+            controller.abort((signal as any)?.reason);
+            break;
+        }
+
+        // Listening for signals and removing the listeners
+        // when at least one symbol is aborted.
+        signal.addEventListener("abort", () => controller.abort((signal as any)?.reason), {
+            signal: controller.signal,
+        });
+    }
+
+    return controller.signal;
+}