modal 0.3.15 → 0.3.17

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/app.ts
-import { ClientError as ClientError3, Status as Status3 } from "nice-grpc";
+import { ClientError as ClientError4, Status as Status4 } from "nice-grpc";
 
 // node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
 function varint64read() {
@@ -38797,68 +38797,8 @@ function initializeClient(options) {
   client = createClient(mergedProfile);
 }
 
-// src/image.ts
-var Image2 = class {
-  imageId;
-  /** @ignore */
-  constructor(imageId) {
-    this.imageId = imageId;
-  }
-};
-async function fromRegistryInternal(appId, tag, imageRegistryConfig) {
-  const resp = await client.imageGetOrCreate({
-    appId,
-    image: {
-      dockerfileCommands: [`FROM ${tag}`],
-      imageRegistryConfig
-    },
-    builderVersion: imageBuilderVersion()
-  });
-  let result;
-  let metadata = void 0;
-  if (resp.result?.status) {
-    result = resp.result;
-    metadata = resp.metadata;
-  } else {
-    let lastEntryId = "";
-    let resultJoined = void 0;
-    while (!resultJoined) {
-      for await (const item of client.imageJoinStreaming({
-        imageId: resp.imageId,
-        timeout: 55,
-        lastEntryId
-      })) {
-        if (item.entryId) lastEntryId = item.entryId;
-        if (item.result?.status) {
-          resultJoined = item.result;
-          metadata = item.metadata;
-          break;
-        }
-      }
-    }
-    result = resultJoined;
-  }
-  void metadata;
-  if (result.status === 2 /* GENERIC_STATUS_FAILURE */) {
-    throw new Error(
-      `Image build for ${resp.imageId} failed with the exception:
-${result.exception}`
-    );
-  } else if (result.status === 3 /* GENERIC_STATUS_TERMINATED */) {
-    throw new Error(
-      `Image build for ${resp.imageId} terminated due to external shut-down. Please try again.`
-    );
-  } else if (result.status === 4 /* GENERIC_STATUS_TIMEOUT */) {
-    throw new Error(
-      `Image build for ${resp.imageId} timed out. Please try again with a larger timeout parameter.`
-    );
-  } else if (result.status !== 1 /* GENERIC_STATUS_SUCCESS */) {
-    throw new Error(
-      `Image build for ${resp.imageId} failed with unknown status: ${result.status}`
-    );
-  }
-  return new Image2(resp.imageId);
-}
+// src/secret.ts
+import { ClientError as ClientError2, Status as Status2 } from "nice-grpc";
 
 // src/errors.ts
 var FunctionTimeoutError = class extends Error {
@@ -38916,6 +38856,200 @@ var SandboxTimeoutError = class extends Error {
   }
 };
 
+// src/secret.ts
+var Secret = class _Secret {
+  secretId;
+  name;
+  /** @ignore */
+  constructor(secretId, name) {
+    this.secretId = secretId;
+    this.name = name;
+  }
+  /** Reference a Secret by its name. */
+  static async fromName(name, options) {
+    try {
+      const resp = await client.secretGetOrCreate({
+        deploymentName: name,
+        environmentName: environmentName(options?.environment),
+        requiredKeys: options?.requiredKeys ?? []
+      });
+      return new _Secret(resp.secretId, name);
+    } catch (err) {
+      if (err instanceof ClientError2 && err.code === Status2.NOT_FOUND)
+        throw new NotFoundError(err.details);
+      if (err instanceof ClientError2 && err.code === Status2.FAILED_PRECONDITION && err.details.includes("Secret is missing key"))
+        throw new NotFoundError(err.details);
+      throw err;
+    }
+  }
+  /** Create a Secret from a plain object of key-value pairs. */
+  static async fromObject(entries, options) {
+    for (const [, value] of Object.entries(entries)) {
+      if (value == null || typeof value !== "string") {
+        throw new InvalidError(
+          "entries must be an object mapping string keys to string values, but got:\n" + JSON.stringify(entries)
+        );
+      }
+    }
+    try {
+      const resp = await client.secretGetOrCreate({
+        objectCreationType: 5 /* OBJECT_CREATION_TYPE_EPHEMERAL */,
+        envDict: entries,
+        environmentName: environmentName(options?.environment)
+      });
+      return new _Secret(resp.secretId);
+    } catch (err) {
+      if (err instanceof ClientError2 && (err.code === Status2.INVALID_ARGUMENT || err.code === Status2.FAILED_PRECONDITION))
+        throw new InvalidError(err.details);
+      throw err;
+    }
+  }
+};
+
+// src/image.ts
+var Image2 = class _Image {
+  #imageId;
+  #tag;
+  #imageRegistryConfig;
+  /** @ignore */
+  constructor(imageId, tag, imageRegistryConfig) {
+    this.#imageId = imageId;
+    this.#tag = tag;
+    this.#imageRegistryConfig = imageRegistryConfig;
+  }
+  get imageId() {
+    return this.#imageId;
+  }
+  /**
+   * Creates an `Image` instance from a raw registry tag, optionally using a secret for authentication.
+   *
+   * @param tag - The registry tag for the image.
+   * @param secret - Optional. A `Secret` instance containing credentials for registry authentication.
+   */
+  static fromRegistry(tag, secret) {
+    let imageRegistryConfig;
+    if (secret) {
+      if (!(secret instanceof Secret)) {
+        throw new TypeError(
+          "secret must be a reference to an existing Secret, e.g. `await Secret.fromName('my_secret')`"
+        );
+      }
+      imageRegistryConfig = {
+        registryAuthType: 4 /* REGISTRY_AUTH_TYPE_STATIC_CREDS */,
+        secretId: secret.secretId
+      };
+    }
+    return new _Image("", tag, imageRegistryConfig);
+  }
+  /**
+   * Creates an `Image` instance from a raw registry tag, optionally using a secret for authentication.
+   *
+   * @param tag - The registry tag for the image.
+   * @param secret - A `Secret` instance containing credentials for registry authentication.
+   */
+  static fromAwsEcr(tag, secret) {
+    let imageRegistryConfig;
+    if (secret) {
+      if (!(secret instanceof Secret)) {
+        throw new TypeError(
+          "secret must be a reference to an existing Secret, e.g. `await Secret.fromName('my_secret')`"
+        );
+      }
+      imageRegistryConfig = {
+        registryAuthType: 1 /* REGISTRY_AUTH_TYPE_AWS */,
+        secretId: secret.secretId
+      };
+    }
+    return new _Image("", tag, imageRegistryConfig);
+  }
+  /**
+   * Creates an `Image` instance from a raw registry tag, optionally using a secret for authentication.
+   *
+   * @param tag - The registry tag for the image.
+   * @param secret - A `Secret` instance containing credentials for registry authentication.
+   */
+  static fromGcpArtifactRegistry(tag, secret) {
+    let imageRegistryConfig;
+    if (secret) {
+      if (!(secret instanceof Secret)) {
+        throw new TypeError(
+          "secret must be a reference to an existing Secret, e.g. `await Secret.fromName('my_secret')`"
+        );
+      }
+      imageRegistryConfig = {
+        registryAuthType: 2 /* REGISTRY_AUTH_TYPE_GCP */,
+        secretId: secret.secretId
+      };
+    }
+    return new _Image("", tag, imageRegistryConfig);
+  }
+  /**
+   * @internal
+   * Build image object
+   */
+  async _build(appId) {
+    if (this.imageId !== "") {
+      return this;
+    }
+    const resp = await client.imageGetOrCreate({
+      appId,
+      image: {
+        dockerfileCommands: [`FROM ${this.#tag}`],
+        imageRegistryConfig: this.#imageRegistryConfig
+      },
+      builderVersion: imageBuilderVersion()
+    });
+    let result;
+    let metadata = void 0;
+    if (resp.result?.status) {
+      result = resp.result;
+      metadata = resp.metadata;
+    } else {
+      let lastEntryId = "";
+      let resultJoined = void 0;
+      while (!resultJoined) {
+        for await (const item of client.imageJoinStreaming({
+          imageId: resp.imageId,
+          timeout: 55,
+          lastEntryId
+        })) {
+          if (item.entryId) lastEntryId = item.entryId;
+          if (item.result?.status) {
+            resultJoined = item.result;
+            metadata = item.metadata;
+            break;
+          }
+        }
+      }
+      result = resultJoined;
+    }
+    void metadata;
+    if (result.status === 2 /* GENERIC_STATUS_FAILURE */) {
+      throw new Error(
+        `Image build for ${resp.imageId} failed with the exception:
+${result.exception}`
+      );
+    } else if (result.status === 3 /* GENERIC_STATUS_TERMINATED */) {
+      throw new Error(
+        `Image build for ${resp.imageId} terminated due to external shut-down. Please try again.`
+      );
+    } else if (result.status === 4 /* GENERIC_STATUS_TIMEOUT */) {
+      throw new Error(
+        `Image build for ${resp.imageId} timed out. Please try again with a larger timeout parameter.`
+      );
+    } else if (result.status !== 1 /* GENERIC_STATUS_SUCCESS */) {
+      throw new Error(
+        `Image build for ${resp.imageId} failed with unknown status: ${result.status}`
+      );
+    }
+    this.#imageId = resp.imageId;
+    return this;
+  }
+};
+
+// src/sandbox.ts
+import { ClientError as ClientError3, Status as Status3 } from "nice-grpc";
+
 // src/sandbox_filesystem.ts
 var SandboxFile = class {
   #fileDescriptor;
@@ -39179,6 +39313,42 @@ var Sandbox2 = class _Sandbox {
       ).pipeThrough(new TextDecoderStream())
     );
   }
+  /** Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in `Sandbox.list`. */
+  async setTags(tags) {
+    const tagsList = Object.entries(tags).map(([tagName, tagValue]) => ({
+      tagName,
+      tagValue
+    }));
+    try {
+      await client.sandboxTagsSet({
+        environmentName: environmentName(),
+        sandboxId: this.sandboxId,
+        tags: tagsList
+      });
+    } catch (err) {
+      if (err instanceof ClientError3 && err.code === Status3.INVALID_ARGUMENT) {
+        throw new InvalidError(err.details || err.message);
+      }
+      throw err;
+    }
+  }
+  /** Returns a running Sandbox object from an ID.
+   *
+   * @returns Sandbox with ID
+   */
+  static async fromId(sandboxId) {
+    try {
+      await client.sandboxWait({
+        sandboxId,
+        timeout: 0
+      });
+    } catch (err) {
+      if (err instanceof ClientError3 && err.code === Status3.NOT_FOUND)
+        throw new NotFoundError(`Sandbox with id: '${sandboxId}' not found`);
+      throw err;
+    }
+    return new _Sandbox(sandboxId);
+  }
   /**
    * Open a file in the sandbox filesystem.
    * @param path - Path to the file to open
@@ -39236,7 +39406,7 @@ var Sandbox2 = class _Sandbox {
     while (true) {
       const resp = await client.sandboxWait({
         sandboxId: this.sandboxId,
-        timeout: 55
+        timeout: 10
       });
       if (resp.result) {
         return _Sandbox.#getReturnCode(resp.result);
@@ -39293,7 +39463,7 @@ var Sandbox2 = class _Sandbox {
     if (!resp.imageId) {
       throw new Error("Sandbox snapshot response missing image ID");
     }
-    return new Image2(resp.imageId);
+    return new Image2(resp.imageId, "");
   }
   /**
    * Check if the Sandbox has finished running.
@@ -39307,6 +39477,41 @@ var Sandbox2 = class _Sandbox {
     });
     return _Sandbox.#getReturnCode(resp.result);
   }
+  /**
+   * List all Sandboxes for the current Environment or App ID (if specified).
+   * If tags are specified, only Sandboxes that have at least those tags are returned.
+   */
+  static async *list(options = {}) {
+    const env = environmentName(options.environment);
+    const tagsList = options.tags ? Object.entries(options.tags).map(([tagName, tagValue]) => ({
+      tagName,
+      tagValue
+    })) : [];
+    let beforeTimestamp = void 0;
+    while (true) {
+      try {
+        const resp = await client.sandboxList({
+          appId: options.appId,
+          beforeTimestamp,
+          environmentName: env,
+          includeFinished: false,
+          tags: tagsList
+        });
+        if (!resp.sandboxes || resp.sandboxes.length === 0) {
+          return;
+        }
+        for (const info of resp.sandboxes) {
+          yield new _Sandbox(info.id);
+        }
+        beforeTimestamp = resp.sandboxes[resp.sandboxes.length - 1].createdAt;
+      } catch (err) {
+        if (err instanceof ClientError3 && err.code === Status3.INVALID_ARGUMENT) {
+          throw new InvalidError(err.details || err.message);
+        }
+        throw err;
+      }
+    }
+  }
   static #getReturnCode(result) {
     if (result === void 0 || result.status === 0 /* GENERIC_STATUS_UNSPECIFIED */) {
       return null;
@@ -39472,39 +39677,99 @@ function encodeIfString(chunk) {
   return typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk;
 }
 
-// src/secret.ts
-import { ClientError as ClientError2, Status as Status2 } from "nice-grpc";
-var Secret = class _Secret {
-  secretId;
-  /** @ignore */
-  constructor(secretId) {
-    this.secretId = secretId;
-  }
-  /** Reference a Secret by its name. */
-  static async fromName(name, options) {
-    try {
-      const resp = await client.secretGetOrCreate({
-        deploymentName: name,
-        environmentName: environmentName(options?.environment),
-        requiredKeys: options?.requiredKeys ?? []
-      });
-      return new _Secret(resp.secretId);
-    } catch (err) {
-      if (err instanceof ClientError2 && err.code === Status2.NOT_FOUND)
-        throw new NotFoundError(err.details);
-      if (err instanceof ClientError2 && err.code === Status2.FAILED_PRECONDITION && err.details.includes("Secret is missing key"))
-        throw new NotFoundError(err.details);
-      throw err;
+// src/cloud_bucket_mount.ts
+var CloudBucketMount2 = class {
+  bucketName;
+  secret;
+  readOnly;
+  requesterPays;
+  bucketEndpointUrl;
+  keyPrefix;
+  oidcAuthRoleArn;
+  constructor(bucketName, options = {}) {
+    this.bucketName = bucketName;
+    this.secret = options.secret;
+    this.readOnly = options.readOnly ?? false;
+    this.requesterPays = options.requesterPays ?? false;
+    this.bucketEndpointUrl = options.bucketEndpointUrl;
+    this.keyPrefix = options.keyPrefix;
+    this.oidcAuthRoleArn = options.oidcAuthRoleArn;
+    if (this.bucketEndpointUrl) {
+      const url = new URL(this.bucketEndpointUrl);
+      if (!url.hostname.endsWith("r2.cloudflarestorage.com") && !url.hostname.endsWith("storage.googleapis.com")) {
+        console.warn(
+          "CloudBucketMount received unrecognized bucket endpoint URL. Assuming AWS S3 configuration as fallback."
+        );
+      }
+    }
+    if (this.requesterPays && !this.secret) {
+      throw new Error("Credentials required in order to use Requester Pays.");
+    }
+    if (this.keyPrefix && !this.keyPrefix.endsWith("/")) {
+      throw new Error(
+        "keyPrefix will be prefixed to all object paths, so it must end in a '/'"
+      );
     }
   }
 };
+function endpointUrlToBucketType(bucketEndpointUrl) {
+  if (!bucketEndpointUrl) {
+    return 1 /* S3 */;
+  }
+  const url = new URL(bucketEndpointUrl);
+  if (url.hostname.endsWith("r2.cloudflarestorage.com")) {
+    return 2 /* R2 */;
+  } else if (url.hostname.endsWith("storage.googleapis.com")) {
+    return 3 /* GCP */;
+  } else {
+    return 1 /* S3 */;
+  }
+}
+function cloudBucketMountToProto(mount, mountPath) {
+  return {
+    bucketName: mount.bucketName,
+    mountPath,
+    credentialsSecretId: mount.secret?.secretId ?? "",
+    readOnly: mount.readOnly,
+    bucketType: endpointUrlToBucketType(mount.bucketEndpointUrl),
+    requesterPays: mount.requesterPays,
+    bucketEndpointUrl: mount.bucketEndpointUrl,
+    keyPrefix: mount.keyPrefix,
+    oidcAuthRoleArn: mount.oidcAuthRoleArn
+  };
+}
 
 // src/app.ts
+function parseGpuConfig(gpu) {
+  if (!gpu) {
+    return void 0;
+  }
+  let gpuType = gpu;
+  let count = 1;
+  if (gpu.includes(":")) {
+    const [type, countStr] = gpu.split(":", 2);
+    gpuType = type;
+    count = parseInt(countStr, 10);
+    if (isNaN(count) || count < 1) {
+      throw new Error(
+        `Invalid GPU count: ${countStr}. Value must be a positive integer.`
+      );
+    }
+  }
+  return {
+    type: 0,
+    // Deprecated field, but required by proto
+    count,
+    gpuType: gpuType.toUpperCase()
+  };
+}
 var App = class _App {
   appId;
+  name;
   /** @ignore */
-  constructor(appId) {
+  constructor(appId, name) {
     this.appId = appId;
+    this.name = name;
   }
   /** Lookup a deployed app by name, or create if it does not exist. */
   static async lookup(name, options = {}) {
@@ -39514,25 +39779,35 @@ var App = class _App {
         environmentName: environmentName(options.environment),
         objectCreationType: options.createIfMissing ? 1 /* OBJECT_CREATION_TYPE_CREATE_IF_MISSING */ : 0 /* OBJECT_CREATION_TYPE_UNSPECIFIED */
       });
-      return new _App(resp.appId);
+      return new _App(resp.appId, name);
     } catch (err) {
-      if (err instanceof ClientError3 && err.code === Status3.NOT_FOUND)
+      if (err instanceof ClientError4 && err.code === Status4.NOT_FOUND)
         throw new NotFoundError(`App '${name}' not found`);
       throw err;
     }
   }
   async createSandbox(image, options = {}) {
+    const gpuConfig = parseGpuConfig(options.gpu);
     if (options.timeout && options.timeout % 1e3 !== 0) {
       throw new Error(
         `Timeout must be a multiple of 1000ms, got ${options.timeout}`
       );
     }
+    await image._build(this.appId);
+    if (options.workdir && !options.workdir.startsWith("/")) {
+      throw new Error(
+        `workdir must be an absolute path, got: ${options.workdir}`
+      );
+    }
     const volumeMounts = options.volumes ? Object.entries(options.volumes).map(([mountPath, volume]) => ({
       volumeId: volume.volumeId,
       mountPath,
       allowBackgroundCommits: true,
-      readOnly: false
+      readOnly: volume.isReadOnly
     })) : [];
+    const cloudBucketMounts = options.cloudBucketMounts ? Object.entries(options.cloudBucketMounts).map(
+      ([mountPath, mount]) => cloudBucketMountToProto(mount, mountPath)
+    ) : [];
     const openPorts = [];
     if (options.encryptedPorts) {
       openPorts.push(
@@ -39560,6 +39835,31 @@ var App = class _App {
       );
     }
     const secretIds = options.secrets ? options.secrets.map((secret) => secret.secretId) : [];
+    let networkAccess;
+    if (options.blockNetwork) {
+      if (options.cidrAllowlist) {
+        throw new Error(
+          "cidrAllowlist cannot be used when blockNetwork is enabled"
+        );
+      }
+      networkAccess = {
+        networkAccessType: 2 /* BLOCKED */,
+        allowedCidrs: []
+      };
+    } else if (options.cidrAllowlist) {
+      networkAccess = {
+        networkAccessType: 3 /* ALLOWLIST */,
+        allowedCidrs: options.cidrAllowlist
+      };
+    } else {
+      networkAccess = {
+        networkAccessType: 1 /* OPEN */,
+        allowedCidrs: []
+      };
+    }
+    const schedulerPlacement = SchedulerPlacement.create({
+      regions: options.regions ?? []
+    });
     const createResp = await client.sandboxCreate({
       appId: this.appId,
       definition: {
@@ -39567,64 +39867,48 @@ var App = class _App {
         entrypointArgs: options.command ?? ["sleep", "48h"],
         imageId: image.imageId,
         timeoutSecs: options.timeout != void 0 ? options.timeout / 1e3 : 600,
-        networkAccess: {
-          networkAccessType: 1 /* OPEN */
-        },
+        workdir: options.workdir ?? void 0,
+        networkAccess,
         resources: {
           // https://modal.com/docs/guide/resources
           milliCpu: Math.round(1e3 * (options.cpu ?? 0.125)),
-          memoryMb: options.memory ?? 128
+          memoryMb: options.memory ?? 128,
+          gpuConfig
         },
         volumeMounts,
+        cloudBucketMounts,
         secretIds,
-        openPorts: openPorts.length > 0 ? { ports: openPorts } : void 0
+        openPorts: openPorts.length > 0 ? { ports: openPorts } : void 0,
+        cloudProviderStr: options.cloud ?? "",
+        schedulerPlacement,
+        verbose: options.verbose ?? false,
+        proxyId: options.proxy?.proxyId
       }
     });
     return new Sandbox2(createResp.sandboxId);
   }
+  /**
+   * @deprecated Use `Image.fromRegistry` instead.
+   */
   async imageFromRegistry(tag, secret) {
-    let imageRegistryConfig;
-    if (secret) {
-      if (!(secret instanceof Secret)) {
-        throw new TypeError(
-          "secret must be a reference to an existing Secret, e.g. `await Secret.fromName('my_secret')`"
-        );
-      }
-      imageRegistryConfig = {
-        registryAuthType: 4 /* REGISTRY_AUTH_TYPE_STATIC_CREDS */,
-        secretId: secret.secretId
-      };
-    }
-    return await fromRegistryInternal(this.appId, tag, imageRegistryConfig);
+    return await Image2.fromRegistry(tag, secret)._build(this.appId);
   }
+  /**
+   * @deprecated Use `Image.fromAwsEcr` instead.
+   */
   async imageFromAwsEcr(tag, secret) {
-    if (!(secret instanceof Secret)) {
-      throw new TypeError(
-        "secret must be a reference to an existing Secret, e.g. `await Secret.fromName('my_secret')`"
-      );
-    }
-    const imageRegistryConfig = {
-      registryAuthType: 1 /* REGISTRY_AUTH_TYPE_AWS */,
-      secretId: secret.secretId
-    };
-    return await fromRegistryInternal(this.appId, tag, imageRegistryConfig);
+    return await Image2.fromAwsEcr(tag, secret)._build(this.appId);
   }
+  /**
+   * @deprecated Use `Image.fromGcpArtifactRegistry` instead.
+   */
   async imageFromGcpArtifactRegistry(tag, secret) {
-    if (!(secret instanceof Secret)) {
-      throw new TypeError(
-        "secret must be a reference to an existing Secret, e.g. `await Secret.fromName('my_secret')`"
-      );
-    }
-    const imageRegistryConfig = {
-      registryAuthType: 2 /* REGISTRY_AUTH_TYPE_GCP */,
-      secretId: secret.secretId
-    };
-    return await fromRegistryInternal(this.appId, tag, imageRegistryConfig);
+    return await Image2.fromGcpArtifactRegistry(tag, secret)._build(this.appId);
   }
 };
 
 // src/cls.ts
-import { ClientError as ClientError5, Status as Status5 } from "nice-grpc";
+import { ClientError as ClientError6, Status as Status6 } from "nice-grpc";
 
 // src/function.ts
 import { createHash } from "node:crypto";
@@ -40197,18 +40481,20 @@ var FunctionCall = class _FunctionCall {
 };
 
 // src/function.ts
-import { ClientError as ClientError4, Status as Status4 } from "nice-grpc";
+import { ClientError as ClientError5, Status as Status5 } from "nice-grpc";
 var maxObjectSizeBytes = 2 * 1024 * 1024;
 var maxSystemRetries = 8;
 var Function_ = class _Function_ {
   functionId;
   methodName;
   #inputPlaneUrl;
+  #webUrl;
   /** @ignore */
-  constructor(functionId, methodName, inputPlaneUrl) {
+  constructor(functionId, methodName, inputPlaneUrl, webUrl) {
     this.functionId = functionId;
     this.methodName = methodName;
     this.#inputPlaneUrl = inputPlaneUrl;
+    this.#webUrl = webUrl;
   }
   static async lookup(appName, name, options = {}) {
     try {
@@ -40220,10 +40506,11 @@ var Function_ = class _Function_ {
       return new _Function_(
         resp.functionId,
         void 0,
-        resp.handleMetadata?.inputPlaneUrl
+        resp.handleMetadata?.inputPlaneUrl,
+        resp.handleMetadata?.webUrl
       );
     } catch (err) {
-      if (err instanceof ClientError4 && err.code === Status4.NOT_FOUND)
+      if (err instanceof ClientError5 && err.code === Status5.NOT_FOUND)
         throw new NotFoundError(`Function '${appName}/${name}' not found`);
       throw err;
     }
@@ -40270,6 +40557,38 @@ var Function_ = class _Function_ {
     );
     return new FunctionCall(invocation.functionCallId);
   }
+  // Returns statistics about the Function.
+  async getCurrentStats() {
+    const resp = await client.functionGetCurrentStats(
+      { functionId: this.functionId },
+      { timeout: 1e4 }
+    );
+    return {
+      backlog: resp.backlog,
+      numTotalRunners: resp.numTotalTasks
+    };
+  }
+  // Overrides the current autoscaler behavior for this Function.
+  async updateAutoscaler(options) {
+    await client.functionUpdateSchedulingParams({
+      functionId: this.functionId,
+      warmPoolSizeOverride: 0,
+      // Deprecated field, always set to 0
+      settings: {
+        minContainers: options.minContainers,
+        maxContainers: options.maxContainers,
+        bufferContainers: options.bufferContainers,
+        scaledownWindow: options.scaledownWindow
+      }
+    });
+  }
+  /**
+   * URL of a Function running as a web endpoint.
+   * @returns The web URL if this function is a web endpoint, otherwise undefined
+   */
+  async getWebUrl() {
+    return this.#webUrl || void 0;
+  }
   async #createInput(args = [], kwargs = {}) {
     const payload = dumps([args, kwargs]);
     let argsBlobId = void 0;
@@ -40361,7 +40680,7 @@ var Cls = class _Cls {
         serviceFunction.handleMetadata?.inputPlaneUrl
       );
     } catch (err) {
-      if (err instanceof ClientError5 && err.code === Status5.NOT_FOUND)
+      if (err instanceof ClientError6 && err.code === Status6.NOT_FOUND)
         throw new NotFoundError(`Class '${appName}/${name}' not found`);
       throw err;
     }
@@ -40460,17 +40779,19 @@ var ClsInstance = class {
 };
 
 // src/queue.ts
-import { ClientError as ClientError6, Status as Status6 } from "nice-grpc";
+import { ClientError as ClientError7, Status as Status7 } from "nice-grpc";
 var ephemeralObjectHeartbeatSleep = 3e5;
 var queueInitialPutBackoff = 100;
 var queueDefaultPartitionTtl = 24 * 3600 * 1e3;
 var Queue = class _Queue {
   queueId;
+  name;
   #ephemeral;
   #abortController;
   /** @ignore */
-  constructor(queueId, ephemeral = false) {
+  constructor(queueId, name, ephemeral = false) {
     this.queueId = queueId;
+    this.name = name;
     this.#ephemeral = ephemeral;
     this.#abortController = ephemeral ? new AbortController() : void 0;
   }
@@ -40495,7 +40816,7 @@ var Queue = class _Queue {
       objectCreationType: 5 /* OBJECT_CREATION_TYPE_EPHEMERAL */,
       environmentName: environmentName(options.environment)
     });
-    const queue = new _Queue(resp.queueId, true);
+    const queue = new _Queue(resp.queueId, void 0, true);
     const signal = queue.#abortController.signal;
     (async () => {
       while (true) {
@@ -40529,7 +40850,7 @@ var Queue = class _Queue {
       objectCreationType: options.createIfMissing ? 1 /* OBJECT_CREATION_TYPE_CREATE_IF_MISSING */ : void 0,
       environmentName: environmentName(options.environment)
     });
-    return new _Queue(resp.queueId);
+    return new _Queue(resp.queueId, name);
   }
   /** Delete a queue by name. */
   static async delete(name, options = {}) {
@@ -40614,7 +40935,7 @@ var Queue = class _Queue {
         });
         break;
       } catch (e) {
-        if (e instanceof ClientError6 && e.code === Status6.RESOURCE_EXHAUSTED) {
+        if (e instanceof ClientError7 && e.code === Status7.RESOURCE_EXHAUSTED) {
           delay = Math.min(delay * 2, 3e4);
           if (deadline !== void 0) {
             const remaining = deadline - Date.now();
@@ -40706,12 +41027,16 @@ var Queue = class _Queue {
 };
 
 // src/volume.ts
-import { ClientError as ClientError7, Status as Status7 } from "nice-grpc";
+import { ClientError as ClientError8, Status as Status8 } from "nice-grpc";
 var Volume = class _Volume {
   volumeId;
+  name;
+  _readOnly = false;
   /** @ignore */
-  constructor(volumeId) {
+  constructor(volumeId, name, readOnly = false) {
     this.volumeId = volumeId;
+    this.name = name;
+    this._readOnly = readOnly;
   }
   static async fromName(name, options) {
     try {
@@ -40720,16 +41045,51 @@ var Volume = class _Volume {
         environmentName: environmentName(options?.environment),
         objectCreationType: options?.createIfMissing ? 1 /* OBJECT_CREATION_TYPE_CREATE_IF_MISSING */ : 0 /* OBJECT_CREATION_TYPE_UNSPECIFIED */
       });
-      return new _Volume(resp.volumeId);
+      return new _Volume(resp.volumeId, name);
     } catch (err) {
-      if (err instanceof ClientError7 && err.code === Status7.NOT_FOUND)
+      if (err instanceof ClientError8 && err.code === Status8.NOT_FOUND)
         throw new NotFoundError(err.details);
       throw err;
     }
   }
+  /** Configure Volume to mount as read-only. */
+  readOnly() {
+    return new _Volume(this.volumeId, this.name, true);
+  }
+  get isReadOnly() {
+    return this._readOnly;
+  }
+};
+
+// src/proxy.ts
+import { ClientError as ClientError9, Status as Status9 } from "nice-grpc";
+var Proxy2 = class _Proxy {
+  proxyId;
+  /** @ignore */
+  constructor(proxyId) {
+    this.proxyId = proxyId;
+  }
+  /** Reference a Proxy by its name. */
+  static async fromName(name, options) {
+    try {
+      const resp = await client.proxyGet({
+        name,
+        environmentName: environmentName(options?.environment)
+      });
+      if (!resp.proxy?.proxyId) {
+        throw new NotFoundError(`Proxy '${name}' not found`);
+      }
+      return new _Proxy(resp.proxy.proxyId);
+    } catch (err) {
+      if (err instanceof ClientError9 && err.code === Status9.NOT_FOUND)
+        throw new NotFoundError(`Proxy '${name}' not found`);
+      throw err;
+    }
+  }
 };
 export {
   App,
+  CloudBucketMount2 as CloudBucketMount,
   Cls,
   ClsInstance,
   ContainerProcess,
@@ -40740,6 +41100,7 @@ export {
   InternalFailure,
   InvalidError,
   NotFoundError,
+  Proxy2 as Proxy,
   Queue,
   QueueEmptyError,
   QueueFullError,