rivetkit 2.3.19 → 2.3.21

package/dist/tsup/{chunk-BKX7UDTA.js → chunk-PYRI75DL.js}

@@ -5,7 +5,7 @@ import {
 import {
   importWebSocket,
   logger
-} from "./chunk-X7RMJQGY.js";
+} from "./chunk-2CI2IEVN.js";
 import {
   AsyncMutex
 } from "./chunk-JTHHCZCZ.js";
@@ -35,7 +35,7 @@ import {
   serializeWithEncoding,
   stringifyError,
   uint8ArrayToBase64
-} from "./chunk-DN6MD3KK.js";
+} from "./chunk-RGIZNZYO.js";
 import {
   INTERNAL_ERROR_CODE,
   RivetError,
@@ -2574,7 +2574,8 @@ async function sendHttpRequest(opts) {
         {
           metadata: responseData.metadata,
           rayId: rayId ?? void 0,
-          actor: responseData.actor
+          actor: responseData.actor,
+          statusCode: response.status
         }
       );
     } catch (error) {
@@ -3490,6 +3491,22 @@ var ActorHandleRaw = class {
       "dynamic actor resolution did not produce a direct actor id"
     );
   }
+  /** Issue a token scoped to this actor. Defaults to actor gateway read access. */
+  async issueToken(options = {}) {
+    const actorId = await this.resolve();
+    const permissions = options.permissions ?? {
+      actor_gateway: ["read"]
+    };
+    const grants = Object.keys(permissions).flatMap((resource) => {
+      const operations = permissions[resource];
+      return operations ? [{ resource, target: { id: actorId }, operations }] : [];
+    });
+    return this.#driver.issueToken({
+      subject: options.subject,
+      expiresIn: options.expiresIn,
+      grants
+    });
+  }
   /**
    * Returns the raw URL for routing traffic to the actor.
    */
@@ -3524,6 +3541,8 @@ var ACTOR_CONNS_SYMBOL = /* @__PURE__ */ Symbol("actorConns");
 var CREATE_ACTOR_CONN_PROXY = /* @__PURE__ */ Symbol("createActorConnProxy");
 var ClientRaw = class {
   #disposed = false;
+  /** Issue namespace-scoped tokens with an explicit grant list. */
+  auth;
   [ACTOR_CONNS_SYMBOL] = /* @__PURE__ */ new Set();
   #driver;
   #encodingKind;
@@ -3535,6 +3554,9 @@ var ClientRaw = class {
    */
   constructor(driver, options = {}) {
     this.#driver = driver;
+    this.auth = {
+      issueToken: (issueOptions) => this.#driver.issueToken(issueOptions)
+    };
     this.#encodingKind = options.encoding ?? "bare";
     this.#gatewayOptions = options.gateway ?? {};
     this.#currentActorInvocation = options.currentActorInvocation;
@@ -3827,6 +3849,74 @@ function createActorProxy(handle) {
   });
 }
 
+// src/client/token-provider.ts
+function isInvalidToken(group, code) {
+  return group === "auth" && (code === "invalid_token" || code === "token_expired");
+}
+function isInvalidTokenResponse(response) {
+  if (response.status !== 401) return false;
+  const error = response.headers.get("x-rivet-error");
+  if (!error) return false;
+  const separator = error.indexOf(".");
+  return separator > 0 && isInvalidToken(error.slice(0, separator), error.slice(separator + 1));
+}
+var TokenProvider = class {
+  constructor(getToken) {
+    this.getToken = getToken;
+  }
+  #cached;
+  #pending;
+  #pendingForce = false;
+  async current() {
+    if (this.#cached && (this.#cached.expiresAt === void 0 || Date.now() < this.#cached.expiresAt - 5e3)) {
+      return this.#cached.token;
+    }
+    return this.#load(false);
+  }
+  /** A late rejection for an older token must never erase a newer credential. */
+  async refreshIfCurrent(failedToken) {
+    var _a;
+    if (this.#pending !== void 0) {
+      const wasForced = this.#pendingForce;
+      const refreshed = await this.#pending;
+      if (wasForced || refreshed !== failedToken) return refreshed;
+    }
+    if (((_a = this.#cached) == null ? void 0 : _a.token) !== failedToken) {
+      return this.current();
+    }
+    return this.#load(true);
+  }
+  #load(forceRefresh) {
+    if (this.#pending !== void 0) return this.#pending;
+    const pending = Promise.resolve().then(() => this.getToken({ forceRefresh })).then((token) => {
+      if (typeof token !== "string" || token.length === 0) {
+        throw new Error(
+          "getToken must resolve to a nonempty string"
+        );
+      }
+      this.#cached = { token, expiresAt: jwtExpiration(token) };
+      return token;
+    }).finally(() => {
+      if (this.#pending === pending) this.#pending = void 0;
+    });
+    this.#pending = pending;
+    this.#pendingForce = forceRefresh;
+    return pending;
+  }
+};
+function jwtExpiration(token) {
+  try {
+    const payload = token.split(".")[1];
+    if (!payload) return void 0;
+    const claims = JSON.parse(
+      atob(payload.replace(/-/g, "+").replace(/_/g, "/"))
+    );
+    return typeof claims.exp === "number" && Number.isSafeInteger(claims.exp) ? claims.exp * 1e3 : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/client/actor-conn.ts
 var CONNECT_SYMBOL = /* @__PURE__ */ Symbol("connect");
 var ActorConnRaw = class {
@@ -3856,6 +3946,7 @@ var ActorConnRaw = class {
   /** Promise used to indicate the socket has connected successfully. This will be rejected if the connection fails. */
   #onOpenPromise;
   #websocket;
+  #authRetryAvailable = true;
   #client;
   #driver;
   #currentActorInvocation;
@@ -4101,6 +4192,10 @@ var ActorConnRaw = class {
     if (error instanceof ActorConnDisposed) {
       return false;
     }
+    if (error instanceof RivetError && isInvalidToken(error.group, error.code) && this.#driver.refreshAuthToken && this.#authRetryAvailable) {
+      this.#authRetryAvailable = false;
+      return true;
+    }
     if (error instanceof RivetError && this.#shouldReconnectForStaleActor(error.group, error.code)) {
       return true;
     }
@@ -4225,6 +4320,7 @@ var ActorConnRaw = class {
         messageQueueLength: this.#messageQueue.length,
         connId: this.#connId
       });
+      this.#authRetryAvailable = true;
       this.#setConnStatus("connected");
       if (this.#onOpenPromise) {
         this.#onOpenPromise.resolve(void 0);
@@ -4367,7 +4463,8 @@ var ActorConnRaw = class {
   }
   /** Called by the onclose event from drivers. */
   async #handleOnClose(event) {
-    var _a;
+    var _a, _b, _c;
+    const failedSocket = this.#websocket;
     const closeEvent = event;
     const wasClean = closeEvent.wasClean;
     const wasConnected = this.#connStatus === "connected";
@@ -4389,9 +4486,24 @@ var ActorConnRaw = class {
       const parsed = parseWebSocketCloseReason(reason);
       if (parsed) {
         const { group, code, rayId } = parsed;
+        if (isInvalidToken(group, code) && closeEvent.code === 1008 && failedSocket) {
+          try {
+            if (!await ((_b = (_a = this.#driver).refreshAuthToken) == null ? void 0 : _b.call(
+              _a,
+              failedSocket
+            ))) {
+              this.#authRetryAvailable = false;
+            }
+          } catch {
+            logger().warn("token renewal failed");
+            this.#authRetryAvailable = false;
+          }
+        } else if (isInvalidToken(group, code)) {
+          this.#authRetryAvailable = false;
+        }
         if (this.#shouldReconnectForStaleActor(group, code)) {
           this.#clearResolvedActorIdentity();
-          (_a = this.#onOpenPromise) == null ? void 0 : _a.reject(
+          (_c = this.#onOpenPromise) == null ? void 0 : _c.reject(
             new RivetError(
               group,
               code,
@@ -4438,7 +4550,7 @@ var ActorConnRaw = class {
       if (error instanceof RivetError) {
         this.#dispatchActorError(error);
       }
-      if (wasConnected) {
+      if (wasConnected && this.#authRetryAvailable) {
         logger().debug({
           msg: "triggering reconnect",
           connId: this.#connId
@@ -4911,6 +5023,25 @@ var ActorConnRaw = class {
 // src/client/config.ts
 import z2 from "zod/v4";
 
+// src/common/engine.ts
+var ENGINE_HOST = "127.0.0.1";
+var ENGINE_PORT = 6420;
+var ENGINE_ENDPOINT = buildEngineEndpoint(ENGINE_HOST, ENGINE_PORT);
+function buildEngineEndpoint(host, port) {
+  const urlHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  return `http://${urlHost}:${port}`;
+}
+function isLocalEngineEndpoint(endpoint) {
+  let url;
+  try {
+    url = new URL(endpoint);
+  } catch {
+    return false;
+  }
+  const hostname = url.hostname.toLowerCase();
+  return hostname === "localhost" || hostname === "0.0.0.0" || hostname === "::" || hostname === "[::]" || hostname === "::1" || hostname === "[::1]" || /^127(?:\.\d{1,3}){0,3}$/.test(hostname);
+}
+
 // src/utils/endpoint-parser.ts
 function tryParseEndpoint(ctx, options) {
   const {
@@ -5008,6 +5139,8 @@ var ClientConfigSchemaBase = z2.object({
   }),
   /** Token to use to authenticate with the API. */
   token: z2.string().optional().transform((val) => val ?? getRivetToken()),
+  /** Issue and renew a client token on demand. Overrides the static token when provided. */
+  getToken: z2.custom().optional(),
   /** Namespace to connect to. */
   namespace: z2.string().optional().transform((val) => val ?? getRivetNamespace()),
   /** Name of the envoy pool. This is used to group together envoys in to different pools. */
@@ -5052,7 +5185,7 @@ function transformClientConfig(config, ctx) {
     ...config,
     endpoint: parsedEndpoint == null ? void 0 : parsedEndpoint.endpoint,
     namespace: (parsedEndpoint == null ? void 0 : parsedEndpoint.namespace) ?? config.namespace ?? "default",
-    token: (parsedEndpoint == null ? void 0 : parsedEndpoint.token) ?? config.token
+    token: (parsedEndpoint == null ? void 0 : parsedEndpoint.token) ?? config.token ?? (config.endpoint && isLocalEngineEndpoint(config.endpoint) ? "default" : void 0)
   };
 }
 function convertRegistryConfigToClientConfig(config) {
@@ -5060,6 +5193,7 @@ function convertRegistryConfigToClientConfig(config) {
   return {
     endpoint: config.endpoint,
     token: config.token,
+    getToken: void 0,
     namespace: config.namespace,
     poolName: config.envoy.poolName,
     headers: config.headers,
@@ -5404,7 +5538,8 @@ async function openWebSocketToGateway(runConfig, gatewayUrl, encoding, params, o
   const ackHookToken = typeof process !== "undefined" && process.env.VITEST ? crypto.randomUUID() : void 0;
   logger2().debug({
     msg: "opening websocket to actor via guard",
-    gatewayUrl
+    // Gateway URLs can embed credentials; never include the path or query in logs.
+    origin: new URL(gatewayUrl).origin
   });
   const ws = new WebSocket2(
     gatewayUrl,
@@ -5499,6 +5634,14 @@ async function apiCall(config, method, path, body) {
 }
 
 // src/engine-client/api-endpoints.ts
+async function issueToken(config, options) {
+  return apiCall(config, "POST", "/auth/tokens", {
+    namespace: config.namespace,
+    subject: options.subject,
+    duration: options.expiresIn,
+    grants: options.grants
+  });
+}
 async function getActor(config, _, actorId) {
   return apiCall(
     config,
@@ -5747,6 +5890,8 @@ function closeWebSocketIfOpen(ws, code, reason) {
 var RemoteEngineControlClient = class {
   #config;
   #metadataPromise;
+  #tokenProvider;
+  #webSocketTokens = /* @__PURE__ */ new WeakMap();
   constructor(runConfig) {
     if (getNextPhase() === "phase-production-build") {
       logger2().info(
@@ -5755,6 +5900,8 @@ var RemoteEngineControlClient = class {
       runConfig.disableMetadataLookup = true;
     }
     this.#config = { ...runConfig };
+    if (runConfig.getToken)
+      this.#tokenProvider = new TokenProvider(runConfig.getToken);
     if (!runConfig.disableMetadataLookup) {
       this.#metadataPromise = lookupMetadataCached(this.#config).then(
         (metadataData) => {
@@ -5763,14 +5910,13 @@ var RemoteEngineControlClient = class {
             if (metadataData.clientNamespace) {
               this.#config.namespace = metadataData.clientNamespace;
             }
-            if (metadataData.clientToken) {
+            if (metadataData.clientToken && !this.#tokenProvider) {
               this.#config.token = metadataData.clientToken;
             }
             logger2().info({
               msg: "overriding client endpoint",
               endpoint: metadataData.clientEndpoint,
-              namespace: metadataData.clientNamespace,
-              token: metadataData.clientToken
+              namespace: metadataData.clientNamespace
             });
           }
           logger2().info({
@@ -5783,12 +5929,47 @@ var RemoteEngineControlClient = class {
       );
     }
   }
+  async #authorizedConfig() {
+    if (!this.#tokenProvider) return this.#config;
+    return { ...this.#config, token: await this.#tokenProvider.current() };
+  }
+  async #withCredential(request, readOnly = false) {
+    const config = await this.#authorizedConfig();
+    try {
+      return await request(config);
+    } catch (error) {
+      if (this.#tokenProvider && config.token && error instanceof RivetError && error.statusCode === 401 && isInvalidToken(error.group, error.code)) {
+        if (readOnly) {
+          const token = await this.#tokenProvider.refreshIfCurrent(
+            config.token
+          );
+          return request({ ...this.#config, token });
+        }
+        await this.#tokenProvider.refreshIfCurrent(config.token);
+      }
+      throw error;
+    }
+  }
+  async issueToken(options) {
+    await this.#metadataPromise;
+    const response = await this.#withCredential(
+      (config) => issueToken(config, options)
+    );
+    return {
+      token: response.token,
+      issuedAt: response.issued_ts,
+      expiresAt: response.expires_ts
+    };
+  }
   async getForId({
     name,
     actorId
   }) {
     await this.#metadataPromise;
-    const response = await getActor(this.#config, name, actorId);
+    const response = await this.#withCredential(
+      (config) => getActor(config, name, actorId),
+      true
+    );
     const actor = response.actors[0];
     if (!actor) return void 0;
     if (actor.name !== name) {
@@ -5809,7 +5990,10 @@ var RemoteEngineControlClient = class {
     await this.#metadataPromise;
     logger2().debug({ msg: "getWithKey: searching for actor", name, key });
     try {
-      const response = await getActorByKey(this.#config, name, key);
+      const response = await this.#withCredential(
+        (config) => getActorByKey(config, name, key),
+        true
+      );
       const actor = response.actors[0];
       if (!actor) return void 0;
       logger2().debug({
@@ -5842,16 +6026,18 @@ var RemoteEngineControlClient = class {
       key
     });
     try {
-      const { actor, created } = await getOrCreateActor(this.#config, {
-        datacenter: region,
-        name,
-        key: serializeActorKey(key),
-        runner_name_selector: poolName ?? this.#config.poolName,
-        input: actorInput ? uint8ArrayToBase64(
-          encodeCborCompat(actorInput)
-        ) : void 0,
-        crash_policy: crashPolicy ?? "sleep"
-      });
+      const { actor, created } = await this.#withCredential(
+        (config) => getOrCreateActor(config, {
+          datacenter: region,
+          name,
+          key: serializeActorKey(key),
+          runner_name_selector: poolName ?? this.#config.poolName,
+          input: actorInput ? uint8ArrayToBase64(
+            encodeCborCompat(actorInput)
+          ) : void 0,
+          crash_policy: crashPolicy ?? "sleep"
+        })
+      );
       logger2().info({
         msg: "getOrCreateWithKey: actor ready",
         actorId: actor.actor_id,
@@ -5867,7 +6053,10 @@ var RemoteEngineControlClient = class {
           name,
           key
         });
-        const response = await getActorByKey(this.#config, name, key);
+        const response = await this.#withCredential(
+          (config) => getActorByKey(config, name, key),
+          true
+        );
         const existing = response.actors[0];
         if (!existing) throw error;
         logger2().info({
@@ -5891,14 +6080,18 @@ var RemoteEngineControlClient = class {
   }) {
     await this.#metadataPromise;
     logger2().info({ msg: "creating actor via engine api", name, key });
-    const result = await createActor(this.#config, {
-      datacenter: region,
-      name,
-      runner_name_selector: poolName ?? this.#config.poolName,
-      key: serializeActorKey(key),
-      input: input ? uint8ArrayToBase64(encodeCborCompat(input)) : void 0,
-      crash_policy: crashPolicy ?? "sleep"
-    });
+    const result = await this.#withCredential(
+      (config) => createActor(config, {
+        datacenter: region,
+        name,
+        runner_name_selector: poolName ?? this.#config.poolName,
+        key: serializeActorKey(key),
+        input: input ? uint8ArrayToBase64(
+          encodeCborCompat(input)
+        ) : void 0,
+        crash_policy: crashPolicy ?? "sleep"
+      })
+    );
     logger2().info({
       msg: "actor created",
       actorId: result.actor.actor_id,
@@ -5910,43 +6103,61 @@ var RemoteEngineControlClient = class {
   async listActors({ name }) {
     await this.#metadataPromise;
     logger2().debug({ msg: "listing actors via engine api", name });
-    const response = await listActorsByName(this.#config, name);
+    const response = await this.#withCredential(
+      (config) => listActorsByName(config, name),
+      true
+    );
     return response.actors.map(apiActorToOutput);
   }
   async destroyActor(actorId) {
     await this.#metadataPromise;
     logger2().info({ msg: "destroying actor via engine api", actorId });
-    await destroyActor(this.#config, actorId);
+    await this.#withCredential((config) => destroyActor(config, actorId));
     logger2().info({ msg: "actor destroyed", actorId });
   }
   async sendRequest(target, actorRequest, options = {}) {
+    var _a;
     await this.#metadataPromise;
-    const path = requestPath(actorRequest);
-    const gatewayUrl = this.#buildGatewayUrlForTarget(
-      target,
-      path,
-      options
-    );
+    const config = await this.#authorizedConfig();
     const httpOptions = {
       ...options,
       directActorId: shouldSkipReadyWait(options) ? directActorIdFromTarget(target) : void 0
     };
-    return sendHttpRequestToGateway(
-      this.#config,
-      gatewayUrl,
+    const send = (current) => sendHttpRequestToGateway(
+      current,
+      this.#buildGatewayUrlForTarget(
+        current,
+        target,
+        requestPath(actorRequest),
+        options
+      ),
       actorRequest,
       httpOptions
     );
+    const response = await send(config);
+    if (!this.#tokenProvider || !config.token || !isInvalidTokenResponse(response))
+      return response;
+    if ((actorRequest.method === "GET" || actorRequest.method === "HEAD") && !("getOrCreateForKey" in target)) {
+      const token = await this.#tokenProvider.refreshIfCurrent(
+        config.token
+      );
+      await ((_a = response.body) == null ? void 0 : _a.cancel());
+      return send({ ...this.#config, token });
+    }
+    await this.#tokenProvider.refreshIfCurrent(config.token);
+    return response;
   }
   async openWebSocket(path, target, encoding, params, options = {}) {
     await this.#metadataPromise;
+    const config = await this.#authorizedConfig();
     const gatewayUrl = this.#buildGatewayUrlForTarget(
+      config,
       target,
       path,
       options
     );
-    return openWebSocketToGateway(
-      this.#config,
+    const ws = await openWebSocketToGateway(
+      config,
       gatewayUrl,
       encoding,
       params,
@@ -5955,25 +6166,59 @@ var RemoteEngineControlClient = class {
         directActorId: shouldSkipReadyWait(options) ? directActorIdFromTarget(target) : void 0
       }
     );
+    this.#watchWebSocketAuth(ws, config.token);
+    return ws;
+  }
+  async refreshAuthToken(ws) {
+    const context2 = this.#webSocketTokens.get(ws);
+    if (!(context2 == null ? void 0 : context2.refresh)) return false;
+    await context2.refresh;
+    return true;
+  }
+  #watchWebSocketAuth(ws, token) {
+    const tokenProvider = this.#tokenProvider;
+    if (!tokenProvider || !token) return;
+    const context2 = {};
+    this.#webSocketTokens.set(ws, context2);
+    ws.addEventListener(
+      "close",
+      (event) => {
+        if (event.code !== 1008 || !event.reason) return;
+        const separator = event.reason.indexOf(".");
+        if (separator < 0) return;
+        const code = event.reason.slice(separator + 1).split(/[\s:#]/, 1)[0];
+        if (isInvalidToken(event.reason.slice(0, separator), code)) {
+          context2.refresh = tokenProvider.refreshIfCurrent(token).catch((error) => {
+            logger2().warn(
+              "failed to renew authentication token"
+            );
+            throw error;
+          });
+          context2.refresh.catch(() => {
+          });
+        }
+      }
+    );
   }
   async buildGatewayUrl(target, options = {}) {
     await this.#metadataPromise;
-    return this.#buildGatewayUrlForTarget(target, "", options);
+    return this.#buildGatewayUrlForTarget(
+      await this.#authorizedConfig(),
+      target,
+      "",
+      options
+    );
   }
   async proxyRequest(_c, actorRequest, actorId) {
-    await this.#metadataPromise;
-    const gatewayUrl = this.#buildGatewayUrlForTarget(
-      { directId: actorId },
-      requestPath(actorRequest)
-    );
-    return sendHttpRequestToGateway(this.#config, gatewayUrl, actorRequest);
+    return this.sendRequest({ directId: actorId }, actorRequest);
   }
   async proxyWebSocket(c, path, actorId, encoding, params) {
-    var _a, _b;
+    var _a;
     await this.#metadataPromise;
-    const upgradeWebSocket = (_b = (_a = this.#config).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
+    const config = await this.#authorizedConfig();
+    const upgradeWebSocket = (_a = config.getUpgradeWebSocket) == null ? void 0 : _a.call(config);
     invariant3(upgradeWebSocket, "missing getUpgradeWebSocket");
-    const endpoint = getEndpoint(this.#config);
+    const endpoint = getEndpoint(config);
     const guardUrl = combineUrlPath(endpoint, path);
     const wsGuardUrl = guardUrl.replace("http://", "ws://");
     logger2().debug({
@@ -5983,7 +6228,7 @@ var RemoteEngineControlClient = class {
       guardUrl
     });
     const protocols = buildWebSocketProtocols(
-      this.#config,
+      config,
       encoding,
       params,
       void 0,
@@ -6001,8 +6246,8 @@ var RemoteEngineControlClient = class {
   setGetUpgradeWebSocket(getUpgradeWebSocket) {
     this.#config.getUpgradeWebSocket = getUpgradeWebSocket;
   }
-  #buildGatewayUrlForTarget(target, path, options = {}) {
-    const endpoint = getEndpoint(this.#config);
+  #buildGatewayUrlForTarget(config, target, path, options = {}) {
+    const endpoint = getEndpoint(config);
     if (shouldSkipReadyWait(options) && directActorIdFromTarget(target) && canUseDirectSkipReadyWaitPath(path)) {
       return combineUrlPath(endpoint, path);
     }
@@ -6010,7 +6255,7 @@ var RemoteEngineControlClient = class {
       return buildActorGatewayUrl(
         endpoint,
         target.directId,
-        this.#config.token,
+        config.token,
         path
       );
     }
@@ -6018,20 +6263,20 @@ var RemoteEngineControlClient = class {
       return buildActorGatewayUrl(
         endpoint,
         target.getForId.actorId,
-        this.#config.token,
+        config.token,
         path
       );
     }
     if ("getForKey" in target || "getOrCreateForKey" in target) {
       return buildActorQueryGatewayUrl(
         endpoint,
-        this.#config.namespace,
+        config.namespace,
         target,
-        this.#config.token,
+        config.token,
         path,
-        this.#config.maxInputSize,
+        config.maxInputSize,
         void 0,
-        "getOrCreateForKey" in target ? target.getOrCreateForKey.poolName ?? this.#config.poolName : void 0,
+        "getOrCreateForKey" in target ? target.getOrCreateForKey.poolName ?? config.poolName : void 0,
         options
       );
     }
@@ -6094,6 +6339,10 @@ export {
   isResponseLike,
   ActorHandleRaw,
   createClientWithDriver,
+  ENGINE_HOST,
+  ENGINE_PORT,
+  buildEngineEndpoint,
+  isLocalEngineEndpoint,
   tryParseEndpoint,
   ClientConfigSchema,
   convertRegistryConfigToClientConfig,
@@ -6101,4 +6350,4 @@ export {
   updateRunnerConfig,
   RemoteEngineControlClient
 };
-//# sourceMappingURL=chunk-BKX7UDTA.js.map
+//# sourceMappingURL=chunk-PYRI75DL.js.map