modal 0.7.5 → 0.7.6

package/dist/index.cjs

@@ -62,6 +62,15 @@ __export(index_exports, {
   Retries: () => Retries,
   Sandbox: () => Sandbox2,
   SandboxFile: () => SandboxFile,
+  SandboxFilesystem: () => SandboxFilesystem,
+  SandboxFilesystemDirectoryNotEmptyError: () => SandboxFilesystemDirectoryNotEmptyError,
+  SandboxFilesystemError: () => SandboxFilesystemError,
+  SandboxFilesystemFileTooLargeError: () => SandboxFilesystemFileTooLargeError,
+  SandboxFilesystemIsADirectoryError: () => SandboxFilesystemIsADirectoryError,
+  SandboxFilesystemNotADirectoryError: () => SandboxFilesystemNotADirectoryError,
+  SandboxFilesystemNotFoundError: () => SandboxFilesystemNotFoundError,
+  SandboxFilesystemPathAlreadyExistsError: () => SandboxFilesystemPathAlreadyExistsError,
+  SandboxFilesystemPermissionError: () => SandboxFilesystemPermissionError,
   SandboxService: () => SandboxService,
   SandboxTimeoutError: () => SandboxTimeoutError,
   Secret: () => Secret,
@@ -76,7 +85,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/app.ts
-var import_nice_grpc12 = require("nice-grpc");
+var import_nice_grpc14 = require("nice-grpc");
 
 // node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
 function varint64read() {
@@ -1954,6 +1963,36 @@ function endpointInputModalityToJSON(object) {
       return "UNRECOGNIZED";
   }
 }
+function endpointStopSourceFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "ENDPOINT_STOP_SOURCE_UNSPECIFIED":
+      return 0 /* ENDPOINT_STOP_SOURCE_UNSPECIFIED */;
+    case 1:
+    case "ENDPOINT_STOP_SOURCE_CLI":
+      return 1 /* ENDPOINT_STOP_SOURCE_CLI */;
+    case 2:
+    case "ENDPOINT_STOP_SOURCE_WEB":
+      return 2 /* ENDPOINT_STOP_SOURCE_WEB */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function endpointStopSourceToJSON(object) {
+  switch (object) {
+    case 0 /* ENDPOINT_STOP_SOURCE_UNSPECIFIED */:
+      return "ENDPOINT_STOP_SOURCE_UNSPECIFIED";
+    case 1 /* ENDPOINT_STOP_SOURCE_CLI */:
+      return "ENDPOINT_STOP_SOURCE_CLI";
+    case 2 /* ENDPOINT_STOP_SOURCE_WEB */:
+      return "ENDPOINT_STOP_SOURCE_WEB";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
 function environmentRoleFromJSON(object) {
   switch (object) {
     case 0:
@@ -16156,6 +16195,338 @@ var EndpointHuggingFaceModelSource = {
     return message;
   }
 };
+function createBaseEndpointListItem() {
+  return { endpointId: "", name: "", description: "", activeDeploymentId: "", updatedAt: 0, metadata: void 0 };
+}
+var EndpointListItem = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    if (message.description !== "") {
+      writer.uint32(26).string(message.description);
+    }
+    if (message.activeDeploymentId !== "") {
+      writer.uint32(34).string(message.activeDeploymentId);
+    }
+    if (message.updatedAt !== 0) {
+      writer.uint32(41).double(message.updatedAt);
+    }
+    if (message.metadata !== void 0) {
+      EndpointMetadata.encode(message.metadata, writer.uint32(50).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseEndpointListItem();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.name = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.description = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.activeDeploymentId = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 41) {
+            break;
+          }
+          message.updatedAt = reader.double();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.metadata = EndpointMetadata.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointId: isSet5(object.endpointId) ? globalThis.String(object.endpointId) : "",
+      name: isSet5(object.name) ? globalThis.String(object.name) : "",
+      description: isSet5(object.description) ? globalThis.String(object.description) : "",
+      activeDeploymentId: isSet5(object.activeDeploymentId) ? globalThis.String(object.activeDeploymentId) : "",
+      updatedAt: isSet5(object.updatedAt) ? globalThis.Number(object.updatedAt) : 0,
+      metadata: isSet5(object.metadata) ? EndpointMetadata.fromJSON(object.metadata) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.activeDeploymentId !== "") {
+      obj.activeDeploymentId = message.activeDeploymentId;
+    }
+    if (message.updatedAt !== 0) {
+      obj.updatedAt = message.updatedAt;
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = EndpointMetadata.toJSON(message.metadata);
+    }
+    return obj;
+  },
+  create(base) {
+    return EndpointListItem.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseEndpointListItem();
+    message.endpointId = object.endpointId ?? "";
+    message.name = object.name ?? "";
+    message.description = object.description ?? "";
+    message.activeDeploymentId = object.activeDeploymentId ?? "";
+    message.updatedAt = object.updatedAt ?? 0;
+    message.metadata = object.metadata !== void 0 && object.metadata !== null ? EndpointMetadata.fromPartial(object.metadata) : void 0;
+    return message;
+  }
+};
+function createBaseEndpointListRequest() {
+  return { environmentName: "", pagination: void 0 };
+}
+var EndpointListRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.environmentName !== "") {
+      writer.uint32(10).string(message.environmentName);
+    }
+    if (message.pagination !== void 0) {
+      ListPagination.encode(message.pagination, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseEndpointListRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.environmentName = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.pagination = ListPagination.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      environmentName: isSet5(object.environmentName) ? globalThis.String(object.environmentName) : "",
+      pagination: isSet5(object.pagination) ? ListPagination.fromJSON(object.pagination) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.environmentName !== "") {
+      obj.environmentName = message.environmentName;
+    }
+    if (message.pagination !== void 0) {
+      obj.pagination = ListPagination.toJSON(message.pagination);
+    }
+    return obj;
+  },
+  create(base) {
+    return EndpointListRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseEndpointListRequest();
+    message.environmentName = object.environmentName ?? "";
+    message.pagination = object.pagination !== void 0 && object.pagination !== null ? ListPagination.fromPartial(object.pagination) : void 0;
+    return message;
+  }
+};
+function createBaseEndpointListResponse() {
+  return { items: [], environmentName: "" };
+}
+var EndpointListResponse = {
+  encode(message, writer = new BinaryWriter()) {
+    for (const v of message.items) {
+      EndpointListItem.encode(v, writer.uint32(10).fork()).join();
+    }
+    if (message.environmentName !== "") {
+      writer.uint32(18).string(message.environmentName);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseEndpointListResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.items.push(EndpointListItem.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.environmentName = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      items: globalThis.Array.isArray(object?.items) ? object.items.map((e) => EndpointListItem.fromJSON(e)) : [],
+      environmentName: isSet5(object.environmentName) ? globalThis.String(object.environmentName) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.items?.length) {
+      obj.items = message.items.map((e) => EndpointListItem.toJSON(e));
+    }
+    if (message.environmentName !== "") {
+      obj.environmentName = message.environmentName;
+    }
+    return obj;
+  },
+  create(base) {
+    return EndpointListResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseEndpointListResponse();
+    message.items = object.items?.map((e) => EndpointListItem.fromPartial(e)) || [];
+    message.environmentName = object.environmentName ?? "";
+    return message;
+  }
+};
+function createBaseEndpointMetadata() {
+  return { name: "", creationInfo: void 0 };
+}
+var EndpointMetadata = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.creationInfo !== void 0) {
+      CreationInfo.encode(message.creationInfo, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseEndpointMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.name = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.creationInfo = CreationInfo.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      name: isSet5(object.name) ? globalThis.String(object.name) : "",
+      creationInfo: isSet5(object.creationInfo) ? CreationInfo.fromJSON(object.creationInfo) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.creationInfo !== void 0) {
+      obj.creationInfo = CreationInfo.toJSON(message.creationInfo);
+    }
+    return obj;
+  },
+  create(base) {
+    return EndpointMetadata.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseEndpointMetadata();
+    message.name = object.name ?? "";
+    message.creationInfo = object.creationInfo !== void 0 && object.creationInfo !== null ? CreationInfo.fromPartial(object.creationInfo) : void 0;
+    return message;
+  }
+};
 function createBaseEndpointModalVolumeModelSource() {
   return { volumeId: "", modelPath: "" };
 }
@@ -16292,6 +16663,111 @@ var EndpointModelSource = {
     return message;
   }
 };
+function createBaseEndpointStopRequest() {
+  return { endpointId: "", source: 0 };
+}
+var EndpointStopRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    if (message.source !== 0) {
+      writer.uint32(16).int32(message.source);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseEndpointStopRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.source = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointId: isSet5(object.endpointId) ? globalThis.String(object.endpointId) : "",
+      source: isSet5(object.source) ? endpointStopSourceFromJSON(object.source) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    if (message.source !== 0) {
+      obj.source = endpointStopSourceToJSON(message.source);
+    }
+    return obj;
+  },
+  create(base) {
+    return EndpointStopRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseEndpointStopRequest();
+    message.endpointId = object.endpointId ?? "";
+    message.source = object.source ?? 0;
+    return message;
+  }
+};
+function createBaseEndpointStopResponse() {
+  return {};
+}
+var EndpointStopResponse = {
+  encode(_, writer = new BinaryWriter()) {
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseEndpointStopResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(_) {
+    return {};
+  },
+  toJSON(_) {
+    const obj = {};
+    return obj;
+  },
+  create(base) {
+    return EndpointStopResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseEndpointStopResponse();
+    return message;
+  }
+};
 function createBaseEnvironmentCreateRequest() {
   return { name: "", isManaged: false };
 }
@@ -34619,7 +35095,8 @@ function createBaseSandbox() {
     customDomain: "",
     includeOidcIdentityToken: false,
     readinessProbe: void 0,
-    inboundCidrAllowlist: []
+    inboundCidrAllowlist: [],
+    environmentVariables: void 0
   };
 }
 var Sandbox = {
@@ -34735,6 +35212,9 @@ var Sandbox = {
     for (const v of message.inboundCidrAllowlist) {
       writer.uint32(314).string(v);
     }
+    if (message.environmentVariables !== void 0) {
+      StringMap.encode(message.environmentVariables, writer.uint32(322).fork()).join();
+    }
     return writer;
   },
   decode(input, length) {
@@ -35006,6 +35486,13 @@ var Sandbox = {
           message.inboundCidrAllowlist.push(reader.string());
           continue;
         }
+        case 40: {
+          if (tag !== 322) {
+            break;
+          }
+          message.environmentVariables = StringMap.decode(reader, reader.uint32());
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -35055,7 +35542,8 @@ var Sandbox = {
       customDomain: isSet5(object.customDomain) ? globalThis.String(object.customDomain) : "",
       includeOidcIdentityToken: isSet5(object.includeOidcIdentityToken) ? globalThis.Boolean(object.includeOidcIdentityToken) : false,
       readinessProbe: isSet5(object.readinessProbe) ? Probe.fromJSON(object.readinessProbe) : void 0,
-      inboundCidrAllowlist: globalThis.Array.isArray(object?.inboundCidrAllowlist) ? object.inboundCidrAllowlist.map((e) => globalThis.String(e)) : []
+      inboundCidrAllowlist: globalThis.Array.isArray(object?.inboundCidrAllowlist) ? object.inboundCidrAllowlist.map((e) => globalThis.String(e)) : [],
+      environmentVariables: isSet5(object.environmentVariables) ? StringMap.fromJSON(object.environmentVariables) : void 0
     };
   },
   toJSON(message) {
@@ -35177,6 +35665,9 @@ var Sandbox = {
     if (message.inboundCidrAllowlist?.length) {
       obj.inboundCidrAllowlist = message.inboundCidrAllowlist;
     }
+    if (message.environmentVariables !== void 0) {
+      obj.environmentVariables = StringMap.toJSON(message.environmentVariables);
+    }
     return obj;
   },
   create(base) {
@@ -35229,6 +35720,7 @@ var Sandbox = {
     message.includeOidcIdentityToken = object.includeOidcIdentityToken ?? false;
     message.readinessProbe = object.readinessProbe !== void 0 && object.readinessProbe !== null ? Probe.fromPartial(object.readinessProbe) : void 0;
     message.inboundCidrAllowlist = object.inboundCidrAllowlist?.map((e) => e) || [];
+    message.environmentVariables = object.environmentVariables !== void 0 && object.environmentVariables !== null ? StringMap.fromPartial(object.environmentVariables) : void 0;
     return message;
   }
 };
@@ -41075,6 +41567,144 @@ var SharedVolumeRemoveFileRequest = {
     return message;
   }
 };
+function createBaseStringMap() {
+  return { contents: {} };
+}
+var StringMap = {
+  encode(message, writer = new BinaryWriter()) {
+    Object.entries(message.contents).forEach(([key, value]) => {
+      StringMap_ContentsEntry.encode({ key, value }, writer.uint32(10).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStringMap();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          const entry1 = StringMap_ContentsEntry.decode(reader, reader.uint32());
+          if (entry1.value !== void 0) {
+            message.contents[entry1.key] = entry1.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      contents: isObject2(object.contents) ? Object.entries(object.contents).reduce((acc, [key, value]) => {
+        acc[key] = String(value);
+        return acc;
+      }, {}) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.contents) {
+      const entries = Object.entries(message.contents);
+      if (entries.length > 0) {
+        obj.contents = {};
+        entries.forEach(([k, v]) => {
+          obj.contents[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+  create(base) {
+    return StringMap.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseStringMap();
+    message.contents = Object.entries(object.contents ?? {}).reduce((acc, [key, value]) => {
+      if (value !== void 0) {
+        acc[key] = globalThis.String(value);
+      }
+      return acc;
+    }, {});
+    return message;
+  }
+};
+function createBaseStringMap_ContentsEntry() {
+  return { key: "", value: "" };
+}
+var StringMap_ContentsEntry = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStringMap_ContentsEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet5(object.key) ? globalThis.String(object.key) : "",
+      value: isSet5(object.value) ? globalThis.String(object.value) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+  create(base) {
+    return StringMap_ContentsEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseStringMap_ContentsEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  }
+};
 function createBaseSystemErrorMessage() {
   return { errorCode: 0, errorMessage: "" };
 }
@@ -48157,6 +48787,22 @@ var ModalClientDefinition = {
       responseStream: false,
       options: {}
     },
+    endpointList: {
+      name: "EndpointList",
+      requestType: EndpointListRequest,
+      requestStream: false,
+      responseType: EndpointListResponse,
+      responseStream: false,
+      options: {}
+    },
+    endpointStop: {
+      name: "EndpointStop",
+      requestType: EndpointStopRequest,
+      requestStream: false,
+      responseType: EndpointStopResponse,
+      responseStream: false,
+      options: {}
+    },
     /** Environments */
     environmentCreate: {
       name: "EnvironmentCreate",
@@ -49348,7 +49994,7 @@ function isSet5(value) {
 
 // src/client.ts
 var import_uuid2 = require("uuid");
-var import_nice_grpc11 = require("nice-grpc");
+var import_nice_grpc13 = require("nice-grpc");
 
 // src/cloud_bucket_mount.ts
 var CloudBucketMountService = class {
@@ -49434,7 +50080,7 @@ var CloudBucketMount2 = class {
 };
 
 // src/cls.ts
-var import_nice_grpc3 = require("nice-grpc");
+var import_nice_grpc4 = require("nice-grpc");
 
 // src/errors.ts
 var TimeoutError = class extends Error {
@@ -49497,6 +50143,48 @@ var SandboxFilesystemError = class extends Error {
     this.name = "SandboxFilesystemError";
   }
 };
+var SandboxFilesystemDirectoryNotEmptyError = class extends SandboxFilesystemError {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxFilesystemDirectoryNotEmptyError";
+  }
+};
+var SandboxFilesystemFileTooLargeError = class extends SandboxFilesystemError {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxFilesystemFileTooLargeError";
+  }
+};
+var SandboxFilesystemIsADirectoryError = class extends SandboxFilesystemError {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxFilesystemIsADirectoryError";
+  }
+};
+var SandboxFilesystemNotADirectoryError = class extends SandboxFilesystemError {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxFilesystemNotADirectoryError";
+  }
+};
+var SandboxFilesystemNotFoundError = class extends SandboxFilesystemError {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxFilesystemNotFoundError";
+  }
+};
+var SandboxFilesystemPathAlreadyExistsError = class extends SandboxFilesystemError {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxFilesystemPathAlreadyExistsError";
+  }
+};
+var SandboxFilesystemPermissionError = class extends SandboxFilesystemError {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxFilesystemPermissionError";
+  }
+};
 var SandboxTimeoutError = class extends Error {
   constructor(message = "Sandbox operation timed out") {
     super(message);
@@ -50207,6 +50895,207 @@ function parseRetries(retries) {
   );
 }
 
+// src/volume.ts
+var import_nice_grpc3 = require("nice-grpc");
+
+// src/ephemeral.ts
+var ephemeralObjectHeartbeatSleep = 3e5;
+var EphemeralHeartbeatManager = class {
+  heartbeatFn;
+  abortController;
+  constructor(heartbeatFn) {
+    this.heartbeatFn = heartbeatFn;
+    this.abortController = new AbortController();
+    this.start();
+  }
+  start() {
+    const signal = this.abortController.signal;
+    (async () => {
+      while (!signal.aborted) {
+        await this.heartbeatFn();
+        await Promise.race([
+          new Promise((resolve) => {
+            setTimeout(resolve, ephemeralObjectHeartbeatSleep).unref();
+          }),
+          new Promise((resolve) => {
+            signal.addEventListener("abort", resolve, { once: true });
+          })
+        ]);
+      }
+    })();
+  }
+  stop() {
+    this.abortController.abort();
+  }
+};
+
+// src/volume.ts
+var VolumeService = class {
+  #client;
+  constructor(client2) {
+    this.#client = client2;
+  }
+  /**
+   * Reference a {@link Volume} by its name.
+   */
+  async fromName(name, params) {
+    try {
+      const resp = await this.#client.cpClient.volumeGetOrCreate({
+        deploymentName: name,
+        environmentName: this.#client.environmentName(params?.environment),
+        objectCreationType: params?.createIfMissing ? 1 /* OBJECT_CREATION_TYPE_CREATE_IF_MISSING */ : 0 /* OBJECT_CREATION_TYPE_UNSPECIFIED */
+      });
+      this.#client.logger.debug(
+        "Retrieved Volume",
+        "volume_id",
+        resp.volumeId,
+        "volume_name",
+        name
+      );
+      return new Volume(resp.volumeId, name);
+    } catch (err) {
+      if (err instanceof import_nice_grpc3.ClientError && err.code === import_nice_grpc3.Status.NOT_FOUND)
+        throw new NotFoundError(err.details);
+      throw err;
+    }
+  }
+  /**
+   * Create a nameless, temporary {@link Volume}.
+   * It persists until closeEphemeral() is called, or the process exits.
+   */
+  async ephemeral(params = {}) {
+    const resp = await this.#client.cpClient.volumeGetOrCreate({
+      objectCreationType: 5 /* OBJECT_CREATION_TYPE_EPHEMERAL */,
+      environmentName: this.#client.environmentName(params.environment)
+    });
+    this.#client.logger.debug(
+      "Created ephemeral Volume",
+      "volume_id",
+      resp.volumeId
+    );
+    const ephemeralHbManager = new EphemeralHeartbeatManager(
+      () => this.#client.cpClient.volumeHeartbeat({ volumeId: resp.volumeId })
+    );
+    return new Volume(resp.volumeId, void 0, void 0, ephemeralHbManager);
+  }
+  /**
+   * Delete a named {@link Volume}.
+   *
+   * Warning: Deletion is irreversible and will affect any Apps currently using the Volume.
+   */
+  async delete(name, params) {
+    try {
+      const volume = await this.fromName(name, {
+        environment: params?.environment,
+        createIfMissing: false
+      });
+      await this.#client.cpClient.volumeDelete({
+        volumeId: volume.volumeId
+      });
+      this.#client.logger.debug(
+        "Deleted Volume",
+        "volume_name",
+        name,
+        "volume_id",
+        volume.volumeId
+      );
+    } catch (err) {
+      const isNotFound = err instanceof NotFoundError || err instanceof import_nice_grpc3.ClientError && err.code === import_nice_grpc3.Status.NOT_FOUND;
+      if (isNotFound && params?.allowMissing) {
+        return;
+      }
+      throw err;
+    }
+  }
+};
+var DEFAULT_MOUNT_OPTIONS = {
+  readOnly: false,
+  subPath: void 0
+};
+var Volume = class _Volume {
+  volumeId;
+  name;
+  /**
+   * @hidden
+   * @internal
+   */
+  _mountOptions = DEFAULT_MOUNT_OPTIONS;
+  #ephemeralHbManager;
+  /** @ignore */
+  constructor(volumeId, name, mountOptions, ephemeralHbManager) {
+    this.volumeId = volumeId;
+    this.name = name;
+    if (mountOptions) {
+      this._mountOptions = mountOptions;
+    }
+    this.#ephemeralHbManager = ephemeralHbManager;
+  }
+  /**
+   * @deprecated Use {@link VolumeService#fromName client.volumes.fromName()} instead.
+   */
+  static async fromName(name, options) {
+    return getDefaultClient().volumes.fromName(name, options);
+  }
+  /**
+   * Configure Volume to mount as read-only.
+   *
+   * @deprecated Use {@link withMountOptions} with `{ readOnly: true }` instead.
+   */
+  readOnly() {
+    return this.withMountOptions({ readOnly: true });
+  }
+  /**
+   * Configure options used when mounting this Volume. Fields left undefined preserve their value
+   * from any previous withMountOptions call on the same Volume (stacking).
+   */
+  withMountOptions(params = {}) {
+    let subPath = this._mountOptions.subPath;
+    if (params.subPath !== void 0) {
+      subPath = params.subPath === "/" ? void 0 : params.subPath;
+    }
+    return new _Volume(
+      this.volumeId,
+      this.name,
+      {
+        readOnly: params.readOnly ?? this._mountOptions.readOnly,
+        subPath
+      },
+      this.#ephemeralHbManager
+    );
+  }
+  /**
+   * @deprecated Inspect mount configuration at the call site that configured it instead.
+   * Future versions of this SDK may remove direct mount-option accessors on Volume.
+   */
+  get isReadOnly() {
+    return this._mountOptions.readOnly;
+  }
+  /**
+   * @deprecated Use {@link VolumeService#ephemeral client.volumes.ephemeral()} instead.
+   */
+  static async ephemeral(options = {}) {
+    return getDefaultClient().volumes.ephemeral(options);
+  }
+  /** Delete the ephemeral Volume. Only usable with emphemeral Volumes. */
+  closeEphemeral() {
+    if (this.#ephemeralHbManager) {
+      this.#ephemeralHbManager.stop();
+    } else {
+      throw new InvalidError("Volume is not ephemeral.");
+    }
+  }
+};
+function volumeToMountProto(mountPath, volume) {
+  const opts = volume._mountOptions ?? DEFAULT_MOUNT_OPTIONS;
+  return {
+    volumeId: volume.volumeId,
+    mountPath,
+    allowBackgroundCommits: true,
+    readOnly: opts.readOnly,
+    subPath: opts.subPath
+  };
+}
+
 // src/cls.ts
 var ClsService = class {
   #client;
@@ -50247,7 +51136,7 @@ var ClsService = class {
         void 0
       );
     } catch (err) {
-      if (err instanceof import_nice_grpc3.ClientError && err.code === import_nice_grpc3.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc4.ClientError && err.code === import_nice_grpc4.Status.NOT_FOUND)
         throw new NotFoundError(`Class '${appName}/${name}' not found`);
       throw err;
     }
@@ -50426,12 +51315,9 @@ async function buildFunctionOptionsProto(options) {
     gpuConfig
   } : void 0;
   const secretIds = (o.secrets || []).map((s) => s.secretId);
-  const volumeMounts = o.volumes ? Object.entries(o.volumes).map(([mountPath, volume]) => ({
-    volumeId: volume.volumeId,
-    mountPath,
-    allowBackgroundCommits: true,
-    readOnly: volume.isReadOnly
-  })) : [];
+  const volumeMounts = o.volumes ? Object.entries(o.volumes).map(
+    ([mountPath, volume]) => volumeToMountProto(mountPath, volume)
+  ) : [];
   const parsedRetries = parseRetries(o.retries);
   const retryPolicy = parsedRetries ? {
     retries: parsedRetries.maxRetries,
@@ -50528,8 +51414,8 @@ var ClsInstance = class {
 };
 
 // src/image.ts
-var import_nice_grpc4 = require("nice-grpc");
 var import_nice_grpc5 = require("nice-grpc");
+var import_nice_grpc6 = require("nice-grpc");
 var ImageService = class {
   #client;
   constructor(client2) {
@@ -50545,9 +51431,9 @@ var ImageService = class {
       const resp = await this.#client.cpClient.imageFromId({ imageId });
       return new Image2(this.#client, resp.imageId, "");
     } catch (err) {
-      if (err instanceof import_nice_grpc4.ClientError && err.code === import_nice_grpc5.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc5.ClientError && err.code === import_nice_grpc6.Status.NOT_FOUND)
         throw new NotFoundError(err.details);
-      if (err instanceof import_nice_grpc4.ClientError && err.code === import_nice_grpc5.Status.FAILED_PRECONDITION && err.details.includes("Could not find image with ID"))
+      if (err instanceof import_nice_grpc5.ClientError && err.code === import_nice_grpc6.Status.FAILED_PRECONDITION && err.details.includes("Could not find image with ID"))
         throw new NotFoundError(err.details);
       throw err;
     }
@@ -50629,9 +51515,9 @@ var ImageService = class {
     try {
       await this.#client.cpClient.imageDelete({ imageId });
     } catch (err) {
-      if (err instanceof import_nice_grpc4.ClientError && err.code === import_nice_grpc5.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc5.ClientError && err.code === import_nice_grpc6.Status.NOT_FOUND)
         throw new NotFoundError(err.details);
-      if (err instanceof import_nice_grpc4.ClientError && err.code === import_nice_grpc5.Status.FAILED_PRECONDITION && err.details.includes("Could not find image with ID"))
+      if (err instanceof import_nice_grpc5.ClientError && err.code === import_nice_grpc6.Status.FAILED_PRECONDITION && err.details.includes("Could not find image with ID"))
         throw new NotFoundError(err.details);
       throw err;
     }
@@ -50819,7 +51705,7 @@ ${result.exception}`
 };
 
 // src/proxy.ts
-var import_nice_grpc6 = require("nice-grpc");
+var import_nice_grpc7 = require("nice-grpc");
 var ProxyService = class {
   #client;
   constructor(client2) {
@@ -50845,7 +51731,7 @@ var ProxyService = class {
       }
       return new Proxy3(resp.proxy.proxyId);
     } catch (err) {
-      if (err instanceof import_nice_grpc6.ClientError && err.code === import_nice_grpc6.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc7.ClientError && err.code === import_nice_grpc7.Status.NOT_FOUND)
         throw new NotFoundError(`Proxy '${name}' not found`);
       throw err;
     }
@@ -51221,40 +52107,7 @@ function loads(buf) {
 }
 
 // src/queue.ts
-var import_nice_grpc7 = require("nice-grpc");
-
-// src/ephemeral.ts
-var ephemeralObjectHeartbeatSleep = 3e5;
-var EphemeralHeartbeatManager = class {
-  heartbeatFn;
-  abortController;
-  constructor(heartbeatFn) {
-    this.heartbeatFn = heartbeatFn;
-    this.abortController = new AbortController();
-    this.start();
-  }
-  start() {
-    const signal = this.abortController.signal;
-    (async () => {
-      while (!signal.aborted) {
-        await this.heartbeatFn();
-        await Promise.race([
-          new Promise((resolve) => {
-            setTimeout(resolve, ephemeralObjectHeartbeatSleep).unref();
-          }),
-          new Promise((resolve) => {
-            signal.addEventListener("abort", resolve, { once: true });
-          })
-        ]);
-      }
-    })();
-  }
-  stop() {
-    this.abortController.abort();
-  }
-};
-
-// src/queue.ts
+var import_nice_grpc8 = require("nice-grpc");
 var queueInitialPutBackoffMs = 100;
 var queueDefaultPartitionTtlMs = 24 * 3600 * 1e3;
 var QueueService = class {
@@ -51300,7 +52153,7 @@ var QueueService = class {
       );
       return new Queue(this.#client, resp.queueId, name);
     } catch (err) {
-      if (err instanceof import_nice_grpc7.ClientError && err.code === import_nice_grpc7.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.NOT_FOUND)
         throw new NotFoundError(err.details);
       throw err;
     }
@@ -51325,7 +52178,7 @@ var QueueService = class {
         queue.queueId
       );
     } catch (err) {
-      const isNotFound = err instanceof NotFoundError || err instanceof import_nice_grpc7.ClientError && err.code === import_nice_grpc7.Status.NOT_FOUND;
+      const isNotFound = err instanceof NotFoundError || err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.NOT_FOUND;
       if (isNotFound && params.allowMissing) {
         return;
       }
@@ -51463,7 +52316,7 @@ var Queue = class _Queue {
         });
         break;
       } catch (e) {
-        if (e instanceof import_nice_grpc7.ClientError && e.code === import_nice_grpc7.Status.RESOURCE_EXHAUSTED) {
+        if (e instanceof import_nice_grpc8.ClientError && e.code === import_nice_grpc8.Status.RESOURCE_EXHAUSTED) {
           delay = Math.min(delay * 2, 3e4);
           if (deadline !== void 0) {
             const remaining = deadline - Date.now();
@@ -51564,8 +52417,8 @@ var Queue = class _Queue {
 };
 
 // src/sandbox.ts
-var import_nice_grpc9 = require("nice-grpc");
-var import_promises2 = require("timers/promises");
+var import_nice_grpc12 = require("nice-grpc");
+var import_promises3 = require("timers/promises");
 
 // proto/modal_proto/task_command_router.ts
 function sandboxStdioFileDescriptorFromJSON(object) {
@@ -54726,7 +55579,7 @@ function isSet6(value) {
 
 // src/task_command_router_client.ts
 var import_promises = require("timers/promises");
-var import_nice_grpc8 = require("nice-grpc");
+var import_nice_grpc9 = require("nice-grpc");
 
 // src/config.ts
 var import_node_console = require("console");
@@ -54795,7 +55648,7 @@ function getProfile(profileName) {
 }
 
 // src/task_command_router_client.ts
-function parseJwtExpiration(jwtToken, logger) {
+function parseJwtExpiration(jwtToken, logger2) {
   try {
     const parts = jwtToken.split(".");
     if (parts.length !== 3) {
@@ -54812,7 +55665,7 @@ function parseJwtExpiration(jwtToken, logger) {
       return exp;
     }
   } catch (e) {
-    logger.warn("Failed to parse JWT expiration", "error", e);
+    logger2.warn("Failed to parse JWT expiration", "error", e);
   }
   return null;
 }
@@ -54822,11 +55675,11 @@ async function callWithRetriesOnTransientErrors(func, baseDelayMs = 10, delayFac
   let delayMs = baseDelayMs;
   let numRetries = 0;
   const retryableStatusCodes = /* @__PURE__ */ new Set([
-    import_nice_grpc8.Status.DEADLINE_EXCEEDED,
-    import_nice_grpc8.Status.UNAVAILABLE,
-    import_nice_grpc8.Status.CANCELLED,
-    import_nice_grpc8.Status.INTERNAL,
-    import_nice_grpc8.Status.UNKNOWN
+    import_nice_grpc9.Status.DEADLINE_EXCEEDED,
+    import_nice_grpc9.Status.UNAVAILABLE,
+    import_nice_grpc9.Status.CANCELLED,
+    import_nice_grpc9.Status.INTERNAL,
+    import_nice_grpc9.Status.UNKNOWN
   ]);
   const excluded = new Set(excludeStatusCodes);
   while (true) {
@@ -54836,10 +55689,10 @@ async function callWithRetriesOnTransientErrors(func, baseDelayMs = 10, delayFac
     try {
       return await func();
     } catch (err) {
-      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.CANCELLED && isClosed?.()) {
+      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.CANCELLED && isClosed?.()) {
         throw new ClientClosedError();
       }
-      if (err instanceof import_nice_grpc8.ClientError && retryableStatusCodes.has(err.code) && !excluded.has(err.code) && (maxRetries === null || numRetries < maxRetries)) {
+      if (err instanceof import_nice_grpc9.ClientError && retryableStatusCodes.has(err.code) && !excluded.has(err.code) && (maxRetries === null || numRetries < maxRetries)) {
         let sleepMs = delayMs;
         if (deadlineMs !== null) {
           sleepMs = Math.min(sleepMs, deadlineMs - Date.now());
@@ -54867,7 +55720,7 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
   jwtRefreshLock = Promise.resolve();
   logger;
   closed = false;
-  static async tryInit(serverClient, taskId, sandboxId, isV2, logger, profile) {
+  static async tryInit(serverClient, taskId, sandboxId, isV2, logger2, profile) {
     let resp;
     try {
       resp = await getCommandRouterAccess(
@@ -54877,8 +55730,8 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
         isV2
       );
     } catch (err) {
-      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.FAILED_PRECONDITION) {
-        logger.debug(
+      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.FAILED_PRECONDITION) {
+        logger2.debug(
           "Command router access is not enabled for task",
           "task_id",
           taskId
@@ -54887,7 +55740,7 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
       }
       throw err;
     }
-    logger.debug(
+    logger2.debug(
       "Using command router access for task",
       "task_id",
       taskId,
@@ -54911,18 +55764,18 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
     };
     let channel;
     if (isLocalhost(profile)) {
-      logger.warn(
+      logger2.warn(
         "Using insecure TLS (skip certificate verification) for task command router"
       );
-      channel = (0, import_nice_grpc8.createChannel)(
+      channel = (0, import_nice_grpc9.createChannel)(
         serverUrl,
-        import_nice_grpc8.ChannelCredentials.createInsecure(),
+        import_nice_grpc9.ChannelCredentials.createInsecure(),
         channelConfig
       );
     } else {
-      channel = (0, import_nice_grpc8.createChannel)(
+      channel = (0, import_nice_grpc9.createChannel)(
         serverUrl,
-        import_nice_grpc8.ChannelCredentials.createSsl(),
+        import_nice_grpc9.ChannelCredentials.createSsl(),
         channelConfig
       );
     }
@@ -54934,28 +55787,28 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
       resp.url,
       resp.jwt,
       channel,
-      logger
+      logger2
     );
-    logger.debug(
+    logger2.debug(
       "Successfully initialized command router client",
       "task_id",
       taskId
     );
     return client2;
   }
-  constructor(serverClient, taskId, sandboxId, isV2, serverUrl, jwt, channel, logger) {
+  constructor(serverClient, taskId, sandboxId, isV2, serverUrl, jwt, channel, logger2) {
     this.serverClient = serverClient;
     this.taskId = taskId;
     this.sandboxId = sandboxId;
     this.isV2 = isV2;
     this.serverUrl = serverUrl;
     this.jwt = jwt;
-    this.jwtExp = parseJwtExpiration(jwt, logger);
-    this.logger = logger;
+    this.jwtExp = parseJwtExpiration(jwt, logger2);
+    this.logger = logger2;
     this.channel = channel;
     const self = this;
-    const factory = (0, import_nice_grpc8.createClientFactory)().use(timeoutMiddleware).use(async function* authMiddleware(call, options) {
-      options.metadata ??= new import_nice_grpc8.Metadata();
+    const factory = (0, import_nice_grpc9.createClientFactory)().use(timeoutMiddleware).use(async function* authMiddleware(call, options) {
+      options.metadata ??= new import_nice_grpc9.Metadata();
       options.metadata.set("authorization", `Bearer ${self.jwt}`);
       return yield* call.next(call.request, options);
     });
@@ -55027,7 +55880,7 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
         () => this.closed
       );
     } catch (err) {
-      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.DEADLINE_EXCEEDED) {
+      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.DEADLINE_EXCEEDED) {
         throw new Error(`Deadline exceeded while polling for exec ${execId}`);
       }
       throw err;
@@ -55056,7 +55909,7 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
         () => this.closed
       );
     } catch (err) {
-      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.DEADLINE_EXCEEDED) {
+      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.DEADLINE_EXCEEDED) {
         throw new Error(`Deadline exceeded while waiting for exec ${execId}`);
       }
       throw err;
@@ -55098,7 +55951,7 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
         10,
         overallDeadlineMs,
         () => this.closed,
-        [import_nice_grpc8.Status.DEADLINE_EXCEEDED, import_nice_grpc8.Status.CANCELLED]
+        [import_nice_grpc9.Status.DEADLINE_EXCEEDED, import_nice_grpc9.Status.CANCELLED]
       );
     } catch (err) {
       if (overallDeadlineMs !== null && Date.now() >= overallDeadlineMs) {
@@ -55156,7 +56009,7 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
     try {
       return await func();
     } catch (err) {
-      if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.UNAUTHENTICATED) {
+      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.UNAUTHENTICATED) {
         await this.refreshJwt();
         return await func();
       }
@@ -55170,11 +56023,11 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
     let numRetriesRemaining = 10;
     let didAuthRetry = false;
     const retryableStatusCodes = /* @__PURE__ */ new Set([
-      import_nice_grpc8.Status.DEADLINE_EXCEEDED,
-      import_nice_grpc8.Status.UNAVAILABLE,
-      import_nice_grpc8.Status.CANCELLED,
-      import_nice_grpc8.Status.INTERNAL,
-      import_nice_grpc8.Status.UNKNOWN
+      import_nice_grpc9.Status.DEADLINE_EXCEEDED,
+      import_nice_grpc9.Status.UNAVAILABLE,
+      import_nice_grpc9.Status.CANCELLED,
+      import_nice_grpc9.Status.INTERNAL,
+      import_nice_grpc9.Status.UNKNOWN
     ]);
     while (true) {
       try {
@@ -55199,7 +56052,7 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
           }
           return;
         } catch (err) {
-          if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.UNAUTHENTICATED && !didAuthRetry) {
+          if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.UNAUTHENTICATED && !didAuthRetry) {
             await this.refreshJwt();
             didAuthRetry = true;
             continue;
@@ -55207,10 +56060,10 @@ var TaskCommandRouterClientImpl = class _TaskCommandRouterClientImpl {
           throw err;
         }
       } catch (err) {
-        if (err instanceof import_nice_grpc8.ClientError && err.code === import_nice_grpc8.Status.CANCELLED && this.closed) {
+        if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.CANCELLED && this.closed) {
           throw new ClientClosedError();
         }
-        if (err instanceof import_nice_grpc8.ClientError && retryableStatusCodes.has(err.code) && numRetriesRemaining > 0) {
+        if (err instanceof import_nice_grpc9.ClientError && retryableStatusCodes.has(err.code) && numRetriesRemaining > 0) {
           if (deadline && deadline - Date.now() <= delayMs) {
             throw new Error(
               `Deadline exceeded while streaming stdio for exec ${execId}`
@@ -55354,6 +56207,760 @@ async function runFilesystemExec(cpClient, request) {
   return { chunks, response };
 }
 
+// src/sandbox_fs.ts
+var import_node_crypto2 = require("crypto");
+var import_node_fs2 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_stream = require("stream");
+var import_node_path3 = require("path");
+var import_nice_grpc11 = require("nice-grpc");
+
+// src/sandbox_fs_utils.ts
+var import_node_path2 = require("path");
+var import_nice_grpc10 = require("nice-grpc");
+
+// src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function parseLogLevel(level) {
+  if (!level) {
+    return "warn";
+  }
+  const normalized = level.toLowerCase();
+  if (normalized === "debug" || normalized === "info" || normalized === "warn" || normalized === "warning" || normalized === "error") {
+    return normalized === "warning" ? "warn" : normalized;
+  }
+  throw new Error(
+    `Invalid log level value: "${level}" (must be debug, info, warn, or error)`
+  );
+}
+var DefaultLogger = class {
+  levelValue;
+  constructor(level = "warn") {
+    this.levelValue = LOG_LEVELS[level];
+  }
+  debug(message, ...args) {
+    if (this.levelValue <= LOG_LEVELS.debug) {
+      console.log(this.formatMessage("DEBUG", message, args));
+    }
+  }
+  info(message, ...args) {
+    if (this.levelValue <= LOG_LEVELS.info) {
+      console.log(this.formatMessage("INFO", message, args));
+    }
+  }
+  warn(message, ...args) {
+    if (this.levelValue <= LOG_LEVELS.warn) {
+      console.warn(this.formatMessage("WARN", message, args));
+    }
+  }
+  error(message, ...args) {
+    if (this.levelValue <= LOG_LEVELS.error) {
+      console.error(this.formatMessage("ERROR", message, args));
+    }
+  }
+  formatMessage(level, message, args) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    let formatted = `time=${timestamp} level=${level} msg="${message}"`;
+    if (args.length > 0) {
+      for (let i = 0; i < args.length; i += 2) {
+        if (i + 1 < args.length) {
+          const key = args[i];
+          const value = args[i + 1];
+          formatted += ` ${key}=${this.formatValue(value)}`;
+        }
+      }
+    }
+    return formatted;
+  }
+  formatValue(value) {
+    if (typeof value === "string") {
+      return value.includes(" ") ? `"${value}"` : value;
+    }
+    if (value instanceof Error) {
+      return `"${value.message}"`;
+    }
+    if (Array.isArray(value)) {
+      return `[${value.join(",")}]`;
+    }
+    return String(value);
+  }
+};
+var FilteredLogger = class {
+  constructor(logger2, level) {
+    this.logger = logger2;
+    this.levelValue = LOG_LEVELS[level];
+  }
+  levelValue;
+  debug(message, ...args) {
+    if (this.levelValue <= LOG_LEVELS.debug) {
+      this.logger.debug(message, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.levelValue <= LOG_LEVELS.info) {
+      this.logger.info(message, ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.levelValue <= LOG_LEVELS.warn) {
+      this.logger.warn(message, ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.levelValue <= LOG_LEVELS.error) {
+      this.logger.error(message, ...args);
+    }
+  }
+};
+function createLogger(logger2, logLevel = "") {
+  const level = parseLogLevel(logLevel);
+  if (logger2) {
+    return new FilteredLogger(logger2, level);
+  }
+  return new DefaultLogger(level);
+}
+function newLogger(logLevel = "") {
+  return createLogger(void 0, logLevel);
+}
+
+// src/sandbox_fs_utils.ts
+var logger = newLogger();
+var SANDBOX_FS_TOOLS_PATH = "/__modal/.bin/modal-sandbox-fs-tools";
+function validateAbsoluteRemotePath(remotePath, operation) {
+  if (!import_node_path2.posix.isAbsolute(remotePath)) {
+    throw new InvalidError(
+      `Sandbox.filesystem.${operation}() currently only supports absolute remotePath values`
+    );
+  }
+}
+function stderrToText(stderr) {
+  if (typeof stderr === "string") return stderr.trim();
+  return new TextDecoder("utf-8", { fatal: false }).decode(stderr).trim();
+}
+function tryParseErrorPayload(stderr) {
+  const text = stderrToText(stderr);
+  if (!text) return null;
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof payload !== "object" || payload === null) return null;
+  const obj = payload;
+  const errorKind = obj.error_kind;
+  const message = obj.message;
+  if (typeof errorKind !== "string") return null;
+  if (typeof message !== "string" || !message.trim()) return null;
+  const detailRaw = obj.detail;
+  const detail = typeof detailRaw === "string" ? detailRaw : "";
+  return { error_kind: errorKind, message, detail };
+}
+function raiseListFilesError(returnCode, stderr, remotePath) {
+  const payload = tryParseErrorPayload(stderr);
+  if (payload) {
+    logger.debug(
+      `sandbox-fs-tools listFiles error: path=${remotePath}, error_kind=${payload.error_kind}, message=${payload.message}, detail=${payload.detail}`
+    );
+    if (payload.error_kind === "NotFound")
+      throw new SandboxFilesystemNotFoundError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "IsFile" || payload.error_kind === "NotDirectory")
+      throw new SandboxFilesystemNotADirectoryError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "PermissionDenied")
+      throw new SandboxFilesystemPermissionError(
+        `${payload.message}: ${remotePath}`
+      );
+    throw new SandboxFilesystemError(payload.message);
+  }
+  const text = stderrToText(stderr);
+  if (text) logger.debug(`Unstructured modal-sandbox-fs-tools stderr: ${text}`);
+  throw new SandboxFilesystemError(
+    `Operation on '${remotePath}' failed with exit code ${returnCode}`
+  );
+}
+function makeListFilesCommand(remotePath) {
+  return JSON.stringify({ ListFiles: { path: remotePath } });
+}
+function raiseMakeDirectoryError(returnCode, stderr, remotePath) {
+  const payload = tryParseErrorPayload(stderr);
+  if (payload) {
+    logger.debug(
+      `sandbox-fs-tools makeDirectory error: path=${remotePath}, error_kind=${payload.error_kind}, message=${payload.message}, detail=${payload.detail}`
+    );
+    if (payload.error_kind === "NotFound")
+      throw new SandboxFilesystemNotFoundError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "PathAlreadyExists")
+      throw new SandboxFilesystemPathAlreadyExistsError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "NotDirectory")
+      throw new SandboxFilesystemNotADirectoryError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "PermissionDenied")
+      throw new SandboxFilesystemPermissionError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "NotSupported")
+      throw new InvalidError(
+        `${payload.message}: ${remotePath} - this operation is not supported for CloudBucketMounts`
+      );
+    throw new SandboxFilesystemError(payload.message);
+  }
+  const text = stderrToText(stderr);
+  if (text) logger.debug(`Unstructured modal-sandbox-fs-tools stderr: ${text}`);
+  throw new SandboxFilesystemError(
+    `Operation on '${remotePath}' failed with exit code ${returnCode}`
+  );
+}
+function makeMakeDirectoryCommand(remotePath, createParents) {
+  return JSON.stringify({
+    MakeDirectory: { path: remotePath, parents: createParents }
+  });
+}
+function raiseReadFileError(returnCode, stderr, remotePath) {
+  const payload = tryParseErrorPayload(stderr);
+  if (payload) {
+    logger.debug(
+      `sandbox-fs-tools read error: path=${remotePath}, error_kind=${payload.error_kind}, message=${payload.message}, detail=${payload.detail}`
+    );
+    if (payload.error_kind === "NotFound")
+      throw new SandboxFilesystemNotFoundError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "IsDirectory")
+      throw new SandboxFilesystemIsADirectoryError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "PermissionDenied")
+      throw new SandboxFilesystemPermissionError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "FileTooLarge")
+      throw new SandboxFilesystemFileTooLargeError(
+        `${payload.message}: ${remotePath}`
+      );
+    throw new SandboxFilesystemError(payload.message);
+  }
+  const text = stderrToText(stderr);
+  if (text) logger.debug(`Unstructured modal-sandbox-fs-tools stderr: ${text}`);
+  throw new SandboxFilesystemError(
+    `Operation on '${remotePath}' failed with exit code ${returnCode}`
+  );
+}
+function makeReadFileCommand(remotePath) {
+  return JSON.stringify({ ReadFile: { path: remotePath } });
+}
+function raiseRemoveError(returnCode, stderr, remotePath) {
+  const payload = tryParseErrorPayload(stderr);
+  if (payload) {
+    logger.debug(
+      `sandbox-fs-tools remove error: path=${remotePath}, error_kind=${payload.error_kind}, message=${payload.message}, detail=${payload.detail}`
+    );
+    if (payload.error_kind === "NotFound")
+      throw new SandboxFilesystemNotFoundError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "DirectoryNotEmpty")
+      throw new SandboxFilesystemDirectoryNotEmptyError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "NotSupported")
+      throw new InvalidError(
+        `${payload.message}: ${remotePath} - this operation is not supported for CloudBucketMounts`
+      );
+    if (payload.error_kind === "PermissionDenied")
+      throw new SandboxFilesystemPermissionError(
+        `${payload.message}: ${remotePath}`
+      );
+    throw new SandboxFilesystemError(payload.message);
+  }
+  const text = stderrToText(stderr);
+  if (text) logger.debug(`Unstructured modal-sandbox-fs-tools stderr: ${text}`);
+  throw new SandboxFilesystemError(
+    `Operation on '${remotePath}' failed with exit code ${returnCode}`
+  );
+}
+function makeRemoveCommand(remotePath, recursive) {
+  return JSON.stringify({ Remove: { path: remotePath, recursive } });
+}
+function raiseStatError(returnCode, stderr, remotePath) {
+  const payload = tryParseErrorPayload(stderr);
+  if (payload) {
+    logger.debug(
+      `sandbox-fs-tools stat error: path=${remotePath}, error_kind=${payload.error_kind}, message=${payload.message}, detail=${payload.detail}`
+    );
+    if (payload.error_kind === "NotFound")
+      throw new SandboxFilesystemNotFoundError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "NotDirectory")
+      throw new SandboxFilesystemNotADirectoryError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "PermissionDenied")
+      throw new SandboxFilesystemPermissionError(
+        `${payload.message}: ${remotePath}`
+      );
+    throw new SandboxFilesystemError(payload.message);
+  }
+  const text = stderrToText(stderr);
+  if (text) logger.debug(`Unstructured modal-sandbox-fs-tools stderr: ${text}`);
+  throw new SandboxFilesystemError(
+    `Operation on '${remotePath}' failed with exit code ${returnCode}`
+  );
+}
+function makeStatCommand(remotePath) {
+  return JSON.stringify({ Stat: { path: remotePath } });
+}
+function raiseWriteFileError(returnCode, stderr, remotePath) {
+  const payload = tryParseErrorPayload(stderr);
+  if (payload) {
+    logger.debug(
+      `sandbox-fs-tools write error: path=${remotePath}, error_kind=${payload.error_kind}, message=${payload.message}, detail=${payload.detail}`
+    );
+    if (payload.error_kind === "NotDirectory" || payload.error_kind === "AlreadyExists")
+      throw new SandboxFilesystemNotADirectoryError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "IsDirectory")
+      throw new SandboxFilesystemIsADirectoryError(
+        `${payload.message}: ${remotePath}`
+      );
+    if (payload.error_kind === "PermissionDenied")
+      throw new SandboxFilesystemPermissionError(
+        `${payload.message}: ${remotePath}`
+      );
+    throw new SandboxFilesystemError(payload.message);
+  }
+  const text = stderrToText(stderr);
+  if (text) logger.debug(`Unstructured modal-sandbox-fs-tools stderr: ${text}`);
+  throw new SandboxFilesystemError(
+    `Operation on '${remotePath}' failed with exit code ${returnCode}`
+  );
+}
+function makeWriteFileCommand(remotePath) {
+  return JSON.stringify({ WriteFile: { path: remotePath } });
+}
+var SUPPORT_ERROR_CODE_RE = /Error code:\s*([A-Z0-9]{8})/;
+function extractSupportErrorCode(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  const match = SUPPORT_ERROR_CODE_RE.exec(message);
+  return match ? match[1] : null;
+}
+function describeError(err) {
+  if (err instanceof Error) return `${err.name}: ${err.message}`;
+  return String(err);
+}
+function isSandboxUnavailableError(err) {
+  if (err instanceof NotFoundError) return true;
+  if (err instanceof import_nice_grpc10.ClientError) {
+    return err.code === import_nice_grpc10.Status.NOT_FOUND || err.code === import_nice_grpc10.Status.CANCELLED || err.code === import_nice_grpc10.Status.UNKNOWN || err.code === import_nice_grpc10.Status.DEADLINE_EXCEEDED || err.code === import_nice_grpc10.Status.UNAVAILABLE;
+  }
+  return false;
+}
+function translateExecSandboxUnavailableError(operation, remotePath, err) {
+  logger.debug(
+    `Sandbox filesystem control-plane error for operation=${operation}, path=${remotePath}: ${describeError(err)}`
+  );
+  return new NotFoundError(
+    "The Sandbox is unavailable. This Sandbox may have already shut down."
+  );
+}
+function translateExecUnexpectedError(operation, remotePath, err) {
+  const code = extractSupportErrorCode(err);
+  logger.debug(
+    `Unexpected sandbox filesystem exec error for operation=${operation}, path=${remotePath}: ${describeError(err)}`
+  );
+  const supportSuffix = code ? `please contact support@modal.com (Error code: ${code})` : "please contact support@modal.com";
+  return new SandboxFilesystemError(
+    `An unexpected error occurred, ${supportSuffix}`
+  );
+}
+async function translateExecErrors(operation, remotePath, fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    if (isSandboxUnavailableError(err)) {
+      throw translateExecSandboxUnavailableError(operation, remotePath, err);
+    }
+    if (err instanceof import_nice_grpc10.ClientError) {
+      throw translateExecUnexpectedError(operation, remotePath, err);
+    }
+    throw err;
+  }
+}
+
+// src/sandbox_fs.ts
+function parseFileEntry(raw) {
+  return {
+    name: raw.name,
+    path: raw.path,
+    type: raw.type,
+    size: raw.size,
+    mode: raw.mode,
+    permissions: raw.permissions,
+    owner: raw.owner,
+    group: raw.group,
+    modifiedTime: raw.modified_time,
+    symlinkTarget: raw.symlink_target ?? null
+  };
+}
+var WRITE_CHUNK_SIZE = 4 * 1024 * 1024;
+function toUint8Array(data) {
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (data instanceof Uint8Array) return data;
+  throw new TypeError(
+    `Expected Uint8Array, ArrayBuffer, or Buffer, got ${typeof data}`
+  );
+}
+var SandboxFilesystem = class {
+  /** @ignore */
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+  /**
+   * Copy a local file into the Sandbox.
+   *
+   * `remotePath` must be an absolute path to a file in the Sandbox.
+   * Parent directories are created if needed. The remote file is overwritten
+   * if it already exists.
+   *
+   * @throws {SandboxFilesystemNotADirectoryError} a parent component of `remotePath` is not a directory.
+   * @throws {SandboxFilesystemIsADirectoryError} `remotePath` points to a directory.
+   * @throws {SandboxFilesystemPermissionError} write permission is denied in the Sandbox.
+   * @throws {SandboxFilesystemError} the command fails for any other reason.
+   * @throws {Error} `localPath` does not exist, is a directory, or cannot be read (`ENOENT`, `EISDIR`, `EACCES`).
+   */
+  async copyFromLocal(localPath, remotePath) {
+    validateAbsoluteRemotePath(remotePath, "copyFromLocal");
+    await translateExecErrors("copyFromLocal", remotePath, async () => {
+      const process2 = await this.sandbox.exec(
+        [SANDBOX_FS_TOOLS_PATH, makeWriteFileCommand(remotePath)],
+        { mode: "binary" }
+      );
+      const writer = process2.stdin.getWriter();
+      try {
+        const fileStream = (0, import_node_fs2.createReadStream)(localPath);
+        for await (const chunk of fileStream) {
+          await writer.write(chunk);
+        }
+        await writer.close();
+      } catch (err) {
+        if (err instanceof import_nice_grpc11.ClientError && (err.code === import_nice_grpc11.Status.FAILED_PRECONDITION || err.code === import_nice_grpc11.Status.ABORTED)) {
+          await process2.closeStdin();
+        } else {
+          await writer.abort(err).catch(() => {
+          });
+          throw err;
+        }
+      } finally {
+        writer.releaseLock();
+      }
+      const returnCode = await process2.wait();
+      if (returnCode !== 0) {
+        const stderr = await process2.stderr.readBytes();
+        raiseWriteFileError(returnCode, stderr, remotePath);
+      }
+    });
+  }
+  /**
+   * Copy a file from the Sandbox to a local path.
+   *
+   * `remotePath` must be an absolute path to a file in the Sandbox.
+   * Parent directories for `localPath` are created if needed. The local file
+   * is overwritten if it already exists.
+   *
+   * @throws {SandboxFilesystemNotFoundError} the remote path does not exist.
+   * @throws {SandboxFilesystemIsADirectoryError} the remote path points to a directory.
+   * @throws {SandboxFilesystemFileTooLargeError} the file exceeds the read size limit.
+   * @throws {SandboxFilesystemPermissionError} read permission is denied in the Sandbox.
+   * @throws {SandboxFilesystemError} the command fails for any other reason.
+   * @throws {Error} `localPath` points to a directory, or writing it is not permitted.
+   */
+  async copyToLocal(remotePath, localPath) {
+    validateAbsoluteRemotePath(remotePath, "copyToLocal");
+    const dir = (0, import_node_path3.dirname)(localPath);
+    const createdDir = await (0, import_promises2.mkdir)(dir, { recursive: true });
+    const tmpPath = `${dir}/.modal-sandbox-fs-tmp-${(0, import_node_crypto2.randomBytes)(8).toString("hex")}`;
+    try {
+      await translateExecErrors("copyToLocal", remotePath, async () => {
+        const process2 = await this.sandbox.exec(
+          [SANDBOX_FS_TOOLS_PATH, makeReadFileCommand(remotePath)],
+          { mode: "binary" }
+        );
+        const returnCode = await process2.wait();
+        if (returnCode !== 0) {
+          const stderr = await process2.stderr.readBytes();
+          raiseReadFileError(returnCode, stderr, remotePath);
+        }
+        await process2.stdout.pipeTo(import_node_stream.Writable.toWeb((0, import_node_fs2.createWriteStream)(tmpPath)));
+      });
+      await (0, import_promises2.rename)(tmpPath, localPath);
+    } catch (err) {
+      await (0, import_promises2.unlink)(tmpPath).catch(() => {
+      });
+      if (createdDir !== void 0) {
+        await (0, import_promises2.rm)(createdDir, { recursive: true, force: true }).catch(() => {
+        });
+      }
+      throw err;
+    }
+  }
+  /**
+   * List files and directories in a Sandbox directory.
+   *
+   * `remotePath` must be an absolute path to a directory in the Sandbox.
+   * Returns an array of {@link FileInfo} objects sorted by name.
+   *
+   * @throws {SandboxFilesystemNotFoundError} the path does not exist.
+   * @throws {SandboxFilesystemNotADirectoryError} the path is not a directory.
+   * @throws {SandboxFilesystemPermissionError} read permission is denied.
+   * @throws {SandboxFilesystemError} the command fails for any other reason.
+   */
+  async listFiles(remotePath) {
+    validateAbsoluteRemotePath(remotePath, "listFiles");
+    const json = await translateExecErrors(
+      "listFiles",
+      remotePath,
+      async () => {
+        const process2 = await this.sandbox.exec(
+          [SANDBOX_FS_TOOLS_PATH, makeListFilesCommand(remotePath)],
+          { mode: "text" }
+        );
+        const returnCode = await process2.wait();
+        if (returnCode !== 0) {
+          const stderr = await process2.stderr.readBytes();
+          raiseListFilesError(returnCode, stderr, remotePath);
+        }
+        return process2.stdout.readText();
+      }
+    );
+    return JSON.parse(json).map(parseFileEntry);
+  }
+  /**
+   * Create a new directory in the Sandbox.
+   *
+   * `remotePath` must be an absolute path in the Sandbox.
+   *
+   * When `createParents` is `true` (the default), any missing parent
+   * directories are created and the call is idempotent (succeeds if the
+   * directory already exists). When `createParents` is `false`, the immediate
+   * parent must already exist and the path must not already exist.
+   *
+   * @throws {SandboxFilesystemNotFoundError} the parent does not exist and `createParents` is `false`.
+   * @throws {SandboxFilesystemPathAlreadyExistsError} the path already exists and `createParents` is `false`.
+   * @throws {SandboxFilesystemNotADirectoryError} a path component is not a directory.
+   * @throws {SandboxFilesystemPermissionError} creation is not permitted.
+   * @throws {InvalidError} the operation is not supported by the mount.
+   * @throws {SandboxFilesystemError} the command fails for any other reason.
+   */
+  async makeDirectory(remotePath, options) {
+    validateAbsoluteRemotePath(remotePath, "makeDirectory");
+    const createParents = options?.createParents ?? true;
+    await translateExecErrors("makeDirectory", remotePath, async () => {
+      const process2 = await this.sandbox.exec(
+        [
+          SANDBOX_FS_TOOLS_PATH,
+          makeMakeDirectoryCommand(remotePath, createParents)
+        ],
+        { mode: "binary" }
+      );
+      const returnCode = await process2.wait();
+      if (returnCode !== 0) {
+        const stderr = await process2.stderr.readBytes();
+        raiseMakeDirectoryError(returnCode, stderr, remotePath);
+      }
+    });
+  }
+  /**
+   * Read a file from the Sandbox and return its contents as bytes.
+   *
+   * `remotePath` must be an absolute path to a file in the Sandbox.
+   *
+   * @throws {SandboxFilesystemNotFoundError} the path does not exist.
+   * @throws {SandboxFilesystemIsADirectoryError} the path points to a directory.
+   * @throws {SandboxFilesystemFileTooLargeError} the file exceeds the read size limit.
+   * @throws {SandboxFilesystemPermissionError} read permission is denied.
+   * @throws {SandboxFilesystemError} the command fails for any other reason.
+   */
+  async readBytes(remotePath) {
+    validateAbsoluteRemotePath(remotePath, "readBytes");
+    return translateExecErrors("readBytes", remotePath, async () => {
+      const process2 = await this.sandbox.exec(
+        [SANDBOX_FS_TOOLS_PATH, makeReadFileCommand(remotePath)],
+        { mode: "binary" }
+      );
+      const returnCode = await process2.wait();
+      if (returnCode !== 0) {
+        const stderr = await process2.stderr.readBytes();
+        raiseReadFileError(returnCode, stderr, remotePath);
+      }
+      return process2.stdout.readBytes();
+    });
+  }
+  /**
+   * Read a file from the Sandbox and return its contents as a UTF-8 string.
+   *
+   * `remotePath` must be an absolute path to a file in the Sandbox.
+   *
+   * @throws {SandboxFilesystemNotFoundError} the path does not exist.
+   * @throws {SandboxFilesystemIsADirectoryError} the path points to a directory.
+   * @throws {SandboxFilesystemFileTooLargeError} the file exceeds the read size limit.
+   * @throws {SandboxFilesystemPermissionError} read permission is denied.
+   * @throws {SandboxFilesystemError} the command fails for any other reason.
+   */
+  async readText(remotePath) {
+    validateAbsoluteRemotePath(remotePath, "readText");
+    return translateExecErrors("readText", remotePath, async () => {
+      const process2 = await this.sandbox.exec(
+        [SANDBOX_FS_TOOLS_PATH, makeReadFileCommand(remotePath)],
+        { mode: "text" }
+      );
+      const returnCode = await process2.wait();
+      if (returnCode !== 0) {
+        const stderr = await process2.stderr.readBytes();
+        raiseReadFileError(returnCode, stderr, remotePath);
+      }
+      return process2.stdout.readText();
+    });
+  }
+  /**
+   * Remove a file or directory in the Sandbox.
+   *
+   * `remotePath` must be an absolute path in the Sandbox. When `remotePath`
+   * is a directory and `recursive` is `false` (the default), it is removed
+   * only if empty. When `recursive` is `true`, the directory and all its
+   * contents are removed. Recursive removal is not supported on all mounts —
+   * `CloudBucketMount` does not support it.
+   *
+   * @throws {SandboxFilesystemNotFoundError} the path does not exist.
+   * @throws {SandboxFilesystemDirectoryNotEmptyError} `recursive` is `false` and the directory is not empty.
+   * @throws {SandboxFilesystemPermissionError} removal is not permitted.
+   * @throws {InvalidError} the operation is not supported by the mount.
+   * @throws {SandboxFilesystemError} the command fails for any other reason.
+   */
+  async remove(remotePath, options) {
+    validateAbsoluteRemotePath(remotePath, "remove");
+    const recursive = options?.recursive ?? false;
+    await translateExecErrors("remove", remotePath, async () => {
+      const process2 = await this.sandbox.exec(
+        [SANDBOX_FS_TOOLS_PATH, makeRemoveCommand(remotePath, recursive)],
+        { mode: "binary" }
+      );
+      const returnCode = await process2.wait();
+      if (returnCode !== 0) {
+        const stderr = await process2.stderr.readBytes();
+        raiseRemoveError(returnCode, stderr, remotePath);
+      }
+    });
+  }
+  /**
+   * Return metadata for a single file, directory, or symlink in the Sandbox.
+   *
+   * `remotePath` must be an absolute path in the Sandbox. If `remotePath` is
+   * a symlink, the returned {@link FileInfo} describes the symlink itself, not
+   * the target it points to.
+   *
+   * @throws {SandboxFilesystemNotFoundError} the path does not exist.
+   * @throws {SandboxFilesystemNotADirectoryError} a non-leaf component of the path is not a directory.
+   * @throws {SandboxFilesystemPermissionError} a path component is not searchable.
+   * @throws {SandboxFilesystemError} the command fails for any other reason.
+   */
+  async stat(remotePath) {
+    validateAbsoluteRemotePath(remotePath, "stat");
+    const stdout = await translateExecErrors("stat", remotePath, async () => {
+      const process2 = await this.sandbox.exec(
+        [SANDBOX_FS_TOOLS_PATH, makeStatCommand(remotePath)],
+        { mode: "text" }
+      );
+      const returnCode = await process2.wait();
+      if (returnCode !== 0) {
+        const stderr = await process2.stderr.readBytes();
+        raiseStatError(returnCode, stderr, remotePath);
+      }
+      return await process2.stdout.readText();
+    });
+    return parseFileEntry(JSON.parse(stdout));
+  }
+  /**
+   * Write binary content to a file in the Sandbox.
+   *
+   * `remotePath` must be an absolute path to a file in the Sandbox.
+   * Parent directories are created if needed. The remote file is overwritten
+   * if it already exists.
+   *
+   * @throws {TypeError} `data` is not a `Uint8Array`, `ArrayBuffer`, or `Buffer`.
+   * @throws {SandboxFilesystemNotADirectoryError} a parent component of `remotePath` is not a directory.
+   * @throws {SandboxFilesystemIsADirectoryError} `remotePath` points to a directory.
+   * @throws {SandboxFilesystemPermissionError} write permission is denied.
+   * @throws {SandboxFilesystemError} the command fails for any other reason.
+   */
+  async writeBytes(data, remotePath) {
+    validateAbsoluteRemotePath(remotePath, "writeBytes");
+    const bytes = toUint8Array(data);
+    await translateExecErrors("writeBytes", remotePath, async () => {
+      const process2 = await this.sandbox.exec(
+        [SANDBOX_FS_TOOLS_PATH, makeWriteFileCommand(remotePath)],
+        { mode: "binary" }
+      );
+      const writer = process2.stdin.getWriter();
+      try {
+        const end = Math.max(bytes.length, 1);
+        for (let offset = 0; offset < end; offset += WRITE_CHUNK_SIZE) {
+          await writer.write(bytes.subarray(offset, offset + WRITE_CHUNK_SIZE));
+        }
+        await writer.close();
+      } catch (err) {
+        if (err instanceof import_nice_grpc11.ClientError && (err.code === import_nice_grpc11.Status.FAILED_PRECONDITION || err.code === import_nice_grpc11.Status.ABORTED)) {
+          await process2.closeStdin();
+        } else {
+          await writer.abort(err).catch(() => {
+          });
+          throw err;
+        }
+      } finally {
+        writer.releaseLock();
+      }
+      const returnCode = await process2.wait();
+      if (returnCode !== 0) {
+        const stderr = await process2.stderr.readBytes();
+        raiseWriteFileError(returnCode, stderr, remotePath);
+      }
+    });
+  }
+  /**
+   * Write UTF-8 text to a file in the Sandbox.
+   *
+   * `remotePath` must be an absolute path to a file in the Sandbox.
+   * Parent directories are created if needed. The remote file is overwritten
+   * if it already exists.
+   *
+   * @throws {TypeError} `data` is not a string.
+   * @throws {SandboxFilesystemNotADirectoryError} a parent component of `remotePath` is not a directory.
+   * @throws {SandboxFilesystemIsADirectoryError} `remotePath` points to a directory.
+   * @throws {SandboxFilesystemPermissionError} write permission is denied.
+   * @throws {SandboxFilesystemError} the command fails for any other reason.
+   */
+  async writeText(data, remotePath) {
+    validateAbsoluteRemotePath(remotePath, "writeText");
+    if (typeof data !== "string")
+      throw new TypeError(`writeText() expects a string, got ${typeof data}`);
+    await this.writeBytes(new TextEncoder().encode(data), remotePath);
+  }
+};
+
 // src/streams.ts
 function toModalReadStream(stream) {
   return Object.assign(stream, readMixin);
@@ -55469,6 +57076,27 @@ var SB_LOGS_INITIAL_DELAY_MS = 10;
 var SB_LOGS_DELAY_FACTOR = 2;
 var SB_LOGS_MAX_RETRIES = 10;
 var TTL_NO_EXPIRY_SENTINEL = -1;
+var V1_SANDBOX_ID_ALPHABET = new Set(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+);
+var ULID_ALPHABET = new Set("0123456789ABCDEFGHJKMNPQRSTVWXYZ");
+function isV1SandboxId(sandboxId) {
+  const [prefix, suffix, ...extra] = sandboxId.split("-");
+  return prefix === "sb" && extra.length === 0 && suffix !== void 0 && suffix.length === 22 && Array.from(suffix).every((ch) => V1_SANDBOX_ID_ALPHABET.has(ch));
+}
+function isV2SandboxId(sandboxId) {
+  const [prefix, suffix, ...extra] = sandboxId.split("-");
+  return prefix === "sb" && extra.length === 0 && suffix !== void 0 && suffix.length === 26 && "01234567".includes(suffix[0]) && Array.from(suffix).every((ch) => ULID_ALPHABET.has(ch));
+}
+function getSandboxVersion(sandboxId) {
+  if (isV2SandboxId(sandboxId)) {
+    return "V2" /* V2 */;
+  }
+  if (isV1SandboxId(sandboxId)) {
+    return "V1" /* V1 */;
+  }
+  throw new InvalidError(`Invalid Sandbox ID: ${sandboxId}`);
+}
 var Probe2 = class _Probe {
   #tcpPort;
   #execArgv;
@@ -55570,12 +57198,9 @@ async function buildSandboxCreateRequestProto(appId, imageId, params = {}) {
   if (params.workdir && !params.workdir.startsWith("/")) {
     throw new Error(`workdir must be an absolute path, got: ${params.workdir}`);
   }
-  const volumeMounts = params.volumes ? Object.entries(params.volumes).map(([mountPath, volume]) => ({
-    volumeId: volume.volumeId,
-    mountPath,
-    allowBackgroundCommits: true,
-    readOnly: volume.isReadOnly
-  })) : [];
+  const volumeMounts = params.volumes ? Object.entries(params.volumes).map(
+    ([mountPath, volume]) => volumeToMountProto(mountPath, volume)
+  ) : [];
   const cloudBucketMounts = params.cloudBucketMounts ? Object.entries(params.cloudBucketMounts).map(
     ([mountPath, mount]) => mount.toProto(mountPath)
   ) : [];
@@ -55812,7 +57437,7 @@ var SandboxService = class {
     try {
       createResp = await this.#client.cpClient.sandboxCreate(createReq);
     } catch (err) {
-      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.ALREADY_EXISTS) {
+      if (err instanceof import_nice_grpc12.ClientError && err.code === import_nice_grpc12.Status.ALREADY_EXISTS) {
         throw new AlreadyExistsError(err.details || err.message);
       }
       throw err;
@@ -55826,6 +57451,20 @@ var SandboxService = class {
   }
   /**
    * Create a new {@link Sandbox} using the experimental V2 backend.
+   *
+   * Supported features include exec, encrypted tunnels, wait/poll/terminate,
+   * CPU and memory configuration, and region placement.
+   *
+   * Features like tags, filesystem snapshots, memory snapshots, volumes, cloud
+   * bucket mounts, GPUs, custom domains, OIDC identity tokens, proxies, and
+   * readiness probes are not supported.
+   *
+   * V2 sandboxes created with this method are not currently returned by
+   * {@link SandboxService#list client.sandboxes.list()} and cannot be looked up
+   * with {@link SandboxService#fromName client.sandboxes.fromName()}. Store
+   * {@link Sandbox#sandboxId sandbox.sandboxId} if you need to retrieve the
+   * sandbox later, and use {@link SandboxService#fromId client.sandboxes.fromId()}
+   * to reattach.
    */
   async experimentalCreate(app, image, params = {}) {
     await image.build(app);
@@ -55849,7 +57488,7 @@ var SandboxService = class {
     try {
       createResp = await this.#client.cpClient.sandboxCreateV2(createReq);
     } catch (err) {
-      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.ALREADY_EXISTS) {
+      if (err instanceof import_nice_grpc12.ClientError && err.code === import_nice_grpc12.Status.ALREADY_EXISTS) {
         throw new AlreadyExistsError(err.details || err.message);
       }
       throw err;
@@ -55876,17 +57515,21 @@ var SandboxService = class {
    * @returns Sandbox with ID
    */
   async fromId(sandboxId) {
+    const sandboxVersion = getSandboxVersion(sandboxId);
+    const isV2 = sandboxVersion === "V2" /* V2 */;
+    const req = { sandboxId, timeout: 0 };
     try {
-      await this.#client.cpClient.sandboxWait({
-        sandboxId,
-        timeout: 0
-      });
+      if (isV2) {
+        await this.#client.cpClient.sandboxWaitV2(req);
+      } else {
+        await this.#client.cpClient.sandboxWait(req);
+      }
     } catch (err) {
-      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc12.ClientError && err.code === import_nice_grpc12.Status.NOT_FOUND)
         throw new NotFoundError(`Sandbox with id: '${sandboxId}' not found`);
       throw err;
     }
-    return new Sandbox2(this.#client, sandboxId);
+    return new Sandbox2(this.#client, sandboxId, { isV2 });
   }
   /** Get a running {@link Sandbox} by name from a deployed {@link App}.
    *
@@ -55907,7 +57550,7 @@ var SandboxService = class {
       });
       return new Sandbox2(this.#client, resp.sandboxId);
     } catch (err) {
-      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc12.ClientError && err.code === import_nice_grpc12.Status.NOT_FOUND)
         throw new NotFoundError(
           `Sandbox with name '${name}' not found in App '${appName}'`
         );
@@ -55942,7 +57585,7 @@ var SandboxService = class {
         }
         beforeTimestamp = resp.sandboxes[resp.sandboxes.length - 1].createdAt;
       } catch (err) {
-        if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.INVALID_ARGUMENT) {
+        if (err instanceof import_nice_grpc12.ClientError && err.code === import_nice_grpc12.Status.INVALID_ARGUMENT) {
           throw new InvalidError(err.details || err.message);
         }
         throw err;
@@ -56062,6 +57705,7 @@ var Sandbox2 = class _Sandbox {
   #commandRouterClient;
   #commandRouterClientPromise;
   #attached = true;
+  #filesystem;
   /** @ignore */
   constructor(client2, sandboxId, params = {}) {
     this.#client = client2;
@@ -56117,6 +57761,13 @@ var Sandbox2 = class _Sandbox {
     }
     return this.#stderr;
   }
+  get filesystem() {
+    this.#ensureAttached();
+    if (!this.#filesystem) {
+      this.#filesystem = new SandboxFilesystem(this);
+    }
+    return this.#filesystem;
+  }
   /** Set tags (key-value pairs) on the Sandbox. Tags can be used to filter results in {@link SandboxService#list Sandbox.list}. */
   async setTags(tags) {
     this.#ensureAttached();
@@ -56132,7 +57783,7 @@ var Sandbox2 = class _Sandbox {
         tags: tagsList
       });
     } catch (err) {
-      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.INVALID_ARGUMENT) {
+      if (err instanceof import_nice_grpc12.ClientError && err.code === import_nice_grpc12.Status.INVALID_ARGUMENT) {
         throw new InvalidError(err.details || err.message);
       }
       throw err;
@@ -56148,7 +57799,7 @@ var Sandbox2 = class _Sandbox {
         sandboxId: this.sandboxId
       });
     } catch (err) {
-      if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.INVALID_ARGUMENT) {
+      if (err instanceof import_nice_grpc12.ClientError && err.code === import_nice_grpc12.Status.INVALID_ARGUMENT) {
         throw new InvalidError(err.details || err.message);
       }
       throw err;
@@ -56175,6 +57826,10 @@ var Sandbox2 = class _Sandbox {
   }
   /**
    * Open a file in the Sandbox filesystem.
+   *
+   * @deprecated Use {@link SandboxFilesystem} methods: `sandbox.filesystem.readBytes()`,
+   * `writeBytes()`, or `copyToLocal()` instead for improved reliability.
+   *
    * @param path - Path to the file to open
    * @param mode - File open mode (r, w, a, r+, w+, a+)
    * @returns Promise that resolves to a {@link SandboxFile}
@@ -56285,7 +57940,7 @@ var Sandbox2 = class _Sandbox {
         this.#taskId = resp.taskId;
         return this.#taskId;
       }
-      await (0, import_promises2.setTimeout)(500);
+      await (0, import_promises3.setTimeout)(500);
     }
     throw new Error(
       `Timed out waiting for task ID for Sandbox ${this.sandboxId}`
@@ -56416,7 +58071,7 @@ var Sandbox2 = class _Sandbox {
           return;
         }
       } catch (err) {
-        if (err instanceof import_nice_grpc9.ClientError && err.code === import_nice_grpc9.Status.DEADLINE_EXCEEDED)
+        if (err instanceof import_nice_grpc12.ClientError && err.code === import_nice_grpc12.Status.DEADLINE_EXCEEDED)
           continue;
         throw err;
       }
@@ -56625,6 +58280,16 @@ var ContainerProcess = class {
       this.stderr = toModalReadStream(stderrStream);
     }
   }
+  /**
+   * @ignore
+   * Send stdin EOF directly, bypassing the WritableStream state machine.
+   *
+   * Useful for when an stdin write has failed.
+   */
+  async closeStdin() {
+    await this.#commandRouterClient.execStdinWrite(this.#taskId, this.#execId, 0, new Uint8Array(0), true).catch(() => {
+    });
+  }
   /** Wait for process completion and return the exit code. */
   async wait() {
     const resp = await this.#commandRouterClient.execWait(
@@ -56676,7 +58341,7 @@ async function* outputStreamSb(cpClient, sandboxId, fileDescriptor, signal) {
       }
       if (isRetryableGrpc(err) && retriesRemaining > 0) {
         try {
-          await (0, import_promises2.setTimeout)(delayMs, void 0, { signal });
+          await (0, import_promises3.setTimeout)(delayMs, void 0, { signal });
         } catch {
           return;
         }
@@ -56750,127 +58415,6 @@ function encodeIfString(chunk) {
   return typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk;
 }
 
-// src/volume.ts
-var import_nice_grpc10 = require("nice-grpc");
-var VolumeService = class {
-  #client;
-  constructor(client2) {
-    this.#client = client2;
-  }
-  /**
-   * Reference a {@link Volume} by its name.
-   */
-  async fromName(name, params) {
-    try {
-      const resp = await this.#client.cpClient.volumeGetOrCreate({
-        deploymentName: name,
-        environmentName: this.#client.environmentName(params?.environment),
-        objectCreationType: params?.createIfMissing ? 1 /* OBJECT_CREATION_TYPE_CREATE_IF_MISSING */ : 0 /* OBJECT_CREATION_TYPE_UNSPECIFIED */
-      });
-      this.#client.logger.debug(
-        "Retrieved Volume",
-        "volume_id",
-        resp.volumeId,
-        "volume_name",
-        name
-      );
-      return new Volume(resp.volumeId, name);
-    } catch (err) {
-      if (err instanceof import_nice_grpc10.ClientError && err.code === import_nice_grpc10.Status.NOT_FOUND)
-        throw new NotFoundError(err.details);
-      throw err;
-    }
-  }
-  /**
-   * Create a nameless, temporary {@link Volume}.
-   * It persists until closeEphemeral() is called, or the process exits.
-   */
-  async ephemeral(params = {}) {
-    const resp = await this.#client.cpClient.volumeGetOrCreate({
-      objectCreationType: 5 /* OBJECT_CREATION_TYPE_EPHEMERAL */,
-      environmentName: this.#client.environmentName(params.environment)
-    });
-    this.#client.logger.debug(
-      "Created ephemeral Volume",
-      "volume_id",
-      resp.volumeId
-    );
-    const ephemeralHbManager = new EphemeralHeartbeatManager(
-      () => this.#client.cpClient.volumeHeartbeat({ volumeId: resp.volumeId })
-    );
-    return new Volume(resp.volumeId, void 0, false, ephemeralHbManager);
-  }
-  /**
-   * Delete a named {@link Volume}.
-   *
-   * Warning: Deletion is irreversible and will affect any Apps currently using the Volume.
-   */
-  async delete(name, params) {
-    try {
-      const volume = await this.fromName(name, {
-        environment: params?.environment,
-        createIfMissing: false
-      });
-      await this.#client.cpClient.volumeDelete({
-        volumeId: volume.volumeId
-      });
-      this.#client.logger.debug(
-        "Deleted Volume",
-        "volume_name",
-        name,
-        "volume_id",
-        volume.volumeId
-      );
-    } catch (err) {
-      const isNotFound = err instanceof NotFoundError || err instanceof import_nice_grpc10.ClientError && err.code === import_nice_grpc10.Status.NOT_FOUND;
-      if (isNotFound && params?.allowMissing) {
-        return;
-      }
-      throw err;
-    }
-  }
-};
-var Volume = class _Volume {
-  volumeId;
-  name;
-  _readOnly = false;
-  #ephemeralHbManager;
-  /** @ignore */
-  constructor(volumeId, name, readOnly = false, ephemeralHbManager) {
-    this.volumeId = volumeId;
-    this.name = name;
-    this._readOnly = readOnly;
-    this.#ephemeralHbManager = ephemeralHbManager;
-  }
-  /**
-   * @deprecated Use {@link VolumeService#fromName client.volumes.fromName()} instead.
-   */
-  static async fromName(name, options) {
-    return getDefaultClient().volumes.fromName(name, options);
-  }
-  /** Configure Volume to mount as read-only. */
-  readOnly() {
-    return new _Volume(this.volumeId, this.name, true, this.#ephemeralHbManager);
-  }
-  get isReadOnly() {
-    return this._readOnly;
-  }
-  /**
-   * @deprecated Use {@link VolumeService#ephemeral client.volumes.ephemeral()} instead.
-   */
-  static async ephemeral(options = {}) {
-    return getDefaultClient().volumes.ephemeral(options);
-  }
-  /** Delete the ephemeral Volume. Only usable with emphemeral Volumes. */
-  closeEphemeral() {
-    if (this.#ephemeralHbManager) {
-      this.#ephemeralHbManager.stop();
-    } else {
-      throw new InvalidError("Volume is not ephemeral.");
-    }
-  }
-};
-
 // src/auth_token_manager.ts
 var REFRESH_WINDOW = 5 * 60;
 var DEFAULT_EXPIRY_OFFSET = 20 * 60;
@@ -56880,9 +58424,9 @@ var AuthTokenManager = class {
   currentToken = "";
   tokenExpiry = 0;
   refreshPromise = null;
-  constructor(client2, logger) {
+  constructor(client2, logger2) {
     this.client = client2;
-    this.logger = logger;
+    this.logger = logger2;
   }
   /**
    * Returns a valid auth token.
@@ -56990,113 +58534,7 @@ var AuthTokenManager = class {
 
 // src/version.ts
 function getSDKVersion() {
-  return true ? "0.7.5" : "0.0.0";
-}
-
-// src/logger.ts
-var LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-function parseLogLevel(level) {
-  if (!level) {
-    return "warn";
-  }
-  const normalized = level.toLowerCase();
-  if (normalized === "debug" || normalized === "info" || normalized === "warn" || normalized === "warning" || normalized === "error") {
-    return normalized === "warning" ? "warn" : normalized;
-  }
-  throw new Error(
-    `Invalid log level value: "${level}" (must be debug, info, warn, or error)`
-  );
-}
-var DefaultLogger = class {
-  levelValue;
-  constructor(level = "warn") {
-    this.levelValue = LOG_LEVELS[level];
-  }
-  debug(message, ...args) {
-    if (this.levelValue <= LOG_LEVELS.debug) {
-      console.log(this.formatMessage("DEBUG", message, args));
-    }
-  }
-  info(message, ...args) {
-    if (this.levelValue <= LOG_LEVELS.info) {
-      console.log(this.formatMessage("INFO", message, args));
-    }
-  }
-  warn(message, ...args) {
-    if (this.levelValue <= LOG_LEVELS.warn) {
-      console.warn(this.formatMessage("WARN", message, args));
-    }
-  }
-  error(message, ...args) {
-    if (this.levelValue <= LOG_LEVELS.error) {
-      console.error(this.formatMessage("ERROR", message, args));
-    }
-  }
-  formatMessage(level, message, args) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    let formatted = `time=${timestamp} level=${level} msg="${message}"`;
-    if (args.length > 0) {
-      for (let i = 0; i < args.length; i += 2) {
-        if (i + 1 < args.length) {
-          const key = args[i];
-          const value = args[i + 1];
-          formatted += ` ${key}=${this.formatValue(value)}`;
-        }
-      }
-    }
-    return formatted;
-  }
-  formatValue(value) {
-    if (typeof value === "string") {
-      return value.includes(" ") ? `"${value}"` : value;
-    }
-    if (value instanceof Error) {
-      return `"${value.message}"`;
-    }
-    if (Array.isArray(value)) {
-      return `[${value.join(",")}]`;
-    }
-    return String(value);
-  }
-};
-var FilteredLogger = class {
-  constructor(logger, level) {
-    this.logger = logger;
-    this.levelValue = LOG_LEVELS[level];
-  }
-  levelValue;
-  debug(message, ...args) {
-    if (this.levelValue <= LOG_LEVELS.debug) {
-      this.logger.debug(message, ...args);
-    }
-  }
-  info(message, ...args) {
-    if (this.levelValue <= LOG_LEVELS.info) {
-      this.logger.info(message, ...args);
-    }
-  }
-  warn(message, ...args) {
-    if (this.levelValue <= LOG_LEVELS.warn) {
-      this.logger.warn(message, ...args);
-    }
-  }
-  error(message, ...args) {
-    if (this.levelValue <= LOG_LEVELS.error) {
-      this.logger.error(message, ...args);
-    }
-  }
-};
-function createLogger(logger, logLevel = "") {
-  const level = parseLogLevel(logLevel);
-  if (logger) {
-    return new FilteredLogger(logger, level);
-  }
-  return new DefaultLogger(level);
+  return true ? "0.7.6" : "0.0.0";
 }
 
 // src/client.ts
@@ -57183,7 +58621,7 @@ var ModalClient2 = class {
     return getSDKVersion();
   }
   createClient(profile) {
-    const channel = (0, import_nice_grpc11.createChannel)(profile.serverUrl, void 0, {
+    const channel = (0, import_nice_grpc13.createChannel)(profile.serverUrl, void 0, {
       "grpc.max_receive_message_length": 100 * 1024 * 1024,
       "grpc.max_send_message_length": 100 * 1024 * 1024,
       "grpc-node.flow_control_window": 64 * 1024 * 1024,
@@ -57191,7 +58629,7 @@ var ModalClient2 = class {
       "grpc.keepalive_timeout_ms": 1e4,
       "grpc.keepalive_permit_without_calls": 1
     });
-    let factory = (0, import_nice_grpc11.createClientFactory)().use(this.authMiddleware(profile)).use(this.retryMiddleware()).use(timeoutMiddleware);
+    let factory = (0, import_nice_grpc13.createClientFactory)().use(this.authMiddleware(profile)).use(this.retryMiddleware()).use(timeoutMiddleware);
     for (const middleware of this.customMiddleware) {
       factory = factory.use(middleware);
     }
@@ -57199,7 +58637,7 @@ var ModalClient2 = class {
   }
   /** Middleware to retry transient errors and timeouts for unary requests. */
   retryMiddleware() {
-    const logger = this.logger;
+    const logger2 = this.logger;
     const maxThrottleWaitSecs = this.profile.maxThrottleWaitSecs;
     return async function* retryMiddleware(call, options) {
       const {
@@ -57225,9 +58663,9 @@ var ModalClient2 = class {
       let delayMs = baseDelay;
       let throttleRetries = 0;
       let lastServerRetryWarnTime = 0;
-      logger.debug("Sending gRPC request", "method", call.method.path);
+      logger2.debug("Sending gRPC request", "method", call.method.path);
       while (true) {
-        const metadata = new import_nice_grpc11.Metadata(restOptions.metadata ?? {});
+        const metadata = new import_nice_grpc13.Metadata(restOptions.metadata ?? {});
         metadata.set("x-idempotency-key", idempotencyKey);
         metadata.set("x-retry-attempt", String(attempt));
         metadata.set("x-throttle-retry-attempt", String(throttleRetries));
@@ -57266,7 +58704,7 @@ var ModalClient2 = class {
             const serverDelaySecs = serverDelayMs / 1e3;
             const elapsedSecs = (Date.now() - startTime) / 1e3;
             if (maxThrottleWaitSecs && elapsedSecs + serverDelaySecs >= maxThrottleWaitSecs) {
-              logger.debug(
+              logger2.debug(
                 "Max throttle wait exceeded, not retrying",
                 "method",
                 call.method.path,
@@ -57281,7 +58719,7 @@ var ModalClient2 = class {
               );
               throw err;
             }
-            logger.debug(
+            logger2.debug(
               "Server requested retry delay",
               "method",
               call.method.path,
@@ -57297,8 +58735,8 @@ var ModalClient2 = class {
             const now = Date.now();
             if (!lastServerRetryWarnTime || now - lastServerRetryWarnTime >= SERVER_RETRY_WARNING_INTERVAL_MS) {
               lastServerRetryWarnTime = now;
-              const clientError2 = err instanceof import_nice_grpc11.ClientError ? err : null;
-              logger.warn(
+              const clientError2 = err instanceof import_nice_grpc13.ClientError ? err : null;
+              logger2.warn(
                 "Server requested retry delay. Retrying...",
                 "status",
                 clientError2?.code ?? "unknown",
@@ -57312,10 +58750,10 @@ var ModalClient2 = class {
             await sleep(serverDelayMs, signal);
             continue;
           }
-          const clientError = err instanceof import_nice_grpc11.ClientError ? err : null;
+          const clientError = err instanceof import_nice_grpc13.ClientError ? err : null;
           if (!clientError || !retryableCodes.has(clientError.code) || attempt >= retries) {
             if (attempt === retries && attempt > 0) {
-              logger.debug(
+              logger2.debug(
                 "Final retry attempt failed",
                 "error",
                 err,
@@ -57332,7 +58770,7 @@ var ModalClient2 = class {
             throw err;
           }
           if (attempt > 0) {
-            logger.debug(
+            logger2.debug(
               "Retryable failure",
               "error",
               err,
@@ -57370,7 +58808,7 @@ var ModalClient2 = class {
         );
       }
       const { tokenId, tokenSecret } = profile;
-      options.metadata ??= new import_nice_grpc11.Metadata();
+      options.metadata ??= new import_nice_grpc13.Metadata();
       options.metadata.set(
         "x-modal-client-type",
         String(8 /* CLIENT_TYPE_LIBMODAL_JS */)
@@ -57415,20 +58853,20 @@ var timeoutMiddleware = async function* timeoutMiddleware2(call, options) {
     origSignal?.removeEventListener("abort", abortListener);
     clearTimeout(timer);
     if (timedOut) {
-      throw new import_nice_grpc11.ClientError(
+      throw new import_nice_grpc13.ClientError(
         call.method.path,
-        import_nice_grpc11.Status.DEADLINE_EXCEEDED,
+        import_nice_grpc13.Status.DEADLINE_EXCEEDED,
         `Timed out after ${timeoutMs}ms`
       );
     }
   }
 };
 var retryableGrpcStatusCodes = /* @__PURE__ */ new Set([
-  import_nice_grpc11.Status.DEADLINE_EXCEEDED,
-  import_nice_grpc11.Status.UNAVAILABLE,
-  import_nice_grpc11.Status.CANCELLED,
-  import_nice_grpc11.Status.INTERNAL,
-  import_nice_grpc11.Status.UNKNOWN
+  import_nice_grpc13.Status.DEADLINE_EXCEEDED,
+  import_nice_grpc13.Status.UNAVAILABLE,
+  import_nice_grpc13.Status.CANCELLED,
+  import_nice_grpc13.Status.INTERNAL,
+  import_nice_grpc13.Status.UNKNOWN
 ]);
 var SERVER_RETRY_WARNING_INTERVAL_MS = 3e4;
 function getServerRetryPolicy(statusDetails) {
@@ -57445,7 +58883,7 @@ function getServerRetryPolicy(statusDetails) {
   return null;
 }
 function isRetryableGrpc(err) {
-  if (err instanceof import_nice_grpc11.ClientError) {
+  if (err instanceof import_nice_grpc13.ClientError) {
     return retryableGrpcStatusCodes.has(err.code);
   }
   return false;
@@ -57514,7 +58952,7 @@ var AppService = class {
       );
       return new App2(resp.appId, name);
     } catch (err) {
-      if (err instanceof import_nice_grpc12.ClientError && err.code === import_nice_grpc12.Status.NOT_FOUND)
+      if (err instanceof import_nice_grpc14.ClientError && err.code === import_nice_grpc14.Status.NOT_FOUND)
         throw new NotFoundError(`App '${name}' not found`);
       throw err;
     }
@@ -57615,6 +59053,15 @@ var App2 = class {
   Retries,
   Sandbox,
   SandboxFile,
+  SandboxFilesystem,
+  SandboxFilesystemDirectoryNotEmptyError,
+  SandboxFilesystemError,
+  SandboxFilesystemFileTooLargeError,
+  SandboxFilesystemIsADirectoryError,
+  SandboxFilesystemNotADirectoryError,
+  SandboxFilesystemNotFoundError,
+  SandboxFilesystemPathAlreadyExistsError,
+  SandboxFilesystemPermissionError,
   SandboxService,
   SandboxTimeoutError,
   Secret,