modal 0.5.0-dev.6 → 0.5.0

package/dist/index.js

@@ -43349,7 +43349,7 @@ function cborDecode(data) {
 }
 
 // src/invocation.ts
-var outputsTimeout = 55 * 1e3;
+var outputsTimeoutMs = 55 * 1e3;
 var ControlPlaneInvocation = class _ControlPlaneInvocation {
   cpClient;
   functionCallId;
@@ -43385,19 +43385,18 @@ var ControlPlaneInvocation = class _ControlPlaneInvocation {
   static fromFunctionCallId(client2, functionCallId) {
     return new _ControlPlaneInvocation(client2.cpClient, functionCallId);
   }
-  async awaitOutput(timeout) {
+  async awaitOutput(timeoutMs) {
     return await pollFunctionOutput(
       this.cpClient,
-      (timeoutMillis) => this.#getOutput(timeoutMillis),
-      timeout
+      (timeoutMs2) => this.#getOutput(timeoutMs2),
+      timeoutMs
     );
   }
-  async #getOutput(timeoutMillis) {
+  async #getOutput(timeoutMs) {
     const response = await this.cpClient.functionGetOutputs({
       functionCallId: this.functionCallId,
       maxValues: 1,
-      timeout: timeoutMillis / 1e3,
-      // Backend needs seconds
+      timeout: timeoutMs / 1e3,
       lastEntryId: "0-0",
       clearOnSuccess: true,
       requestedAt: timeNowSeconds()
@@ -43451,18 +43450,18 @@ var InputPlaneInvocation = class _InputPlaneInvocation {
       attemptStartResponse.attemptToken
     );
   }
-  async awaitOutput(timeout) {
+  async awaitOutput(timeoutMs) {
     return await pollFunctionOutput(
       this.cpClient,
-      (timeoutMillis) => this.#getOutput(timeoutMillis),
-      timeout
+      (timeoutMs2) => this.#getOutput(timeoutMs2),
+      timeoutMs
     );
   }
-  async #getOutput(timeoutMillis) {
+  async #getOutput(timeoutMs) {
     const response = await this.ipClient.attemptAwait({
       attemptToken: this.attemptToken,
       requestedAt: timeNowSeconds(),
-      timeoutSecs: timeoutMillis / 1e3
+      timeoutSecs: timeoutMs / 1e3
     });
     return response.output;
   }
@@ -43478,24 +43477,24 @@ var InputPlaneInvocation = class _InputPlaneInvocation {
 function timeNowSeconds() {
   return Date.now() / 1e3;
 }
-async function pollFunctionOutput(cpClient, getOutput, timeout) {
+async function pollFunctionOutput(cpClient, getOutput, timeoutMs) {
   const startTime = Date.now();
-  let pollTimeout = outputsTimeout;
-  if (timeout !== void 0) {
-    pollTimeout = Math.min(timeout, outputsTimeout);
+  let pollTimeoutMs = outputsTimeoutMs;
+  if (timeoutMs !== void 0) {
+    pollTimeoutMs = Math.min(timeoutMs, outputsTimeoutMs);
   }
   while (true) {
-    const output = await getOutput(pollTimeout);
+    const output = await getOutput(pollTimeoutMs);
     if (output) {
       return await processResult(cpClient, output.result, output.dataFormat);
     }
-    if (timeout !== void 0) {
-      const remainingTime = timeout - (Date.now() - startTime);
-      if (remainingTime <= 0) {
-        const message = `Timeout exceeded: ${(timeout / 1e3).toFixed(1)}s`;
+    if (timeoutMs !== void 0) {
+      const remainingMs = timeoutMs - (Date.now() - startTime);
+      if (remainingMs <= 0) {
+        const message = `Timeout exceeded: ${timeoutMs}ms`;
         throw new FunctionTimeoutError(message);
       }
-      pollTimeout = Math.min(outputsTimeout, remainingTime);
+      pollTimeoutMs = Math.min(outputsTimeoutMs, remainingMs);
     }
   }
 }
@@ -43550,6 +43549,18 @@ function deserializeDataFormat(data, dataFormat) {
   }
 }
 
+// src/validation.ts
+function checkForRenamedParams(params, renames) {
+  if (!params) return;
+  for (const [oldName, newName] of Object.entries(renames)) {
+    if (oldName in params) {
+      throw new Error(
+        `Parameter '${oldName}' has been renamed to '${newName}'.`
+      );
+    }
+  }
+}
+
 // src/function_call.ts
 var FunctionCallService = class {
   #client;
@@ -43579,12 +43590,12 @@ var FunctionCall = class _FunctionCall {
   }
   /** Get the result of a FunctionCall, optionally waiting with a timeout. */
   async get(params = {}) {
-    const timeout = params.timeout;
+    checkForRenamedParams(params, { timeout: "timeoutMs" });
     const invocation = ControlPlaneInvocation.fromFunctionCallId(
       this.#client || getDefaultClient(),
       this.functionCallId
     );
-    return invocation.awaitOutput(timeout);
+    return invocation.awaitOutput(params.timeoutMs);
   }
   /** Cancel a running FunctionCall. */
   async cancel(params = {}) {
@@ -43704,7 +43715,7 @@ var Function_ = class {
   async getCurrentStats() {
     const resp = await this.#client.cpClient.functionGetCurrentStats(
       { functionId: this.functionId },
-      { timeout: 1e4 }
+      { timeoutMs: 1e4 }
     );
     return {
       backlog: resp.backlog,
@@ -43713,6 +43724,7 @@ var Function_ = class {
   }
   // Overrides the current autoscaler behavior for this Function.
   async updateAutoscaler(params) {
+    checkForRenamedParams(params, { scaledownWindow: "scaledownWindowMs" });
     await this.#client.cpClient.functionUpdateSchedulingParams({
       functionId: this.functionId,
       warmPoolSizeOverride: 0,
@@ -43721,7 +43733,7 @@ var Function_ = class {
         minContainers: params.minContainers,
         maxContainers: params.maxContainers,
         bufferContainers: params.bufferContainers,
-        scaledownWindow: params.scaledownWindow
+        scaledownWindow: params.scaledownWindowMs !== void 0 ? Math.trunc(params.scaledownWindowMs / 1e3) : void 0
       }
     });
   }
@@ -44073,10 +44085,58 @@ function mergeServiceOptions(base, diff) {
 async function buildFunctionOptionsProto(options) {
   if (!options) return void 0;
   const o = options ?? {};
+  checkForRenamedParams(o, {
+    memory: "memoryMiB",
+    memoryLimit: "memoryLimitMiB",
+    scaledownWindow: "scaledownWindowMs",
+    timeout: "timeoutMs"
+  });
   const gpuConfig = parseGpuConfig(o.gpu);
-  const resources = o.cpu !== void 0 || o.memory !== void 0 || gpuConfig ? {
-    milliCpu: o.cpu !== void 0 ? Math.round(1e3 * o.cpu) : void 0,
-    memoryMb: o.memory,
+  let milliCpu = void 0;
+  let milliCpuMax = void 0;
+  if (o.cpu === void 0 && o.cpuLimit !== void 0) {
+    throw new Error("must also specify cpu when cpuLimit is specified");
+  }
+  if (o.cpu !== void 0) {
+    if (o.cpu <= 0) {
+      throw new Error(`cpu (${o.cpu}) must be a positive number`);
+    }
+    milliCpu = Math.trunc(1e3 * o.cpu);
+    if (o.cpuLimit !== void 0) {
+      if (o.cpuLimit < o.cpu) {
+        throw new Error(
+          `cpu (${o.cpu}) cannot be higher than cpuLimit (${o.cpuLimit})`
+        );
+      }
+      milliCpuMax = Math.trunc(1e3 * o.cpuLimit);
+    }
+  }
+  let memoryMb = void 0;
+  let memoryMbMax = void 0;
+  if (o.memoryMiB === void 0 && o.memoryLimitMiB !== void 0) {
+    throw new Error(
+      "must also specify memoryMiB when memoryLimitMiB is specified"
+    );
+  }
+  if (o.memoryMiB !== void 0) {
+    if (o.memoryMiB <= 0) {
+      throw new Error(`memoryMiB (${o.memoryMiB}) must be a positive number`);
+    }
+    memoryMb = o.memoryMiB;
+    if (o.memoryLimitMiB !== void 0) {
+      if (o.memoryLimitMiB < o.memoryMiB) {
+        throw new Error(
+          `memoryMiB (${o.memoryMiB}) cannot be higher than memoryLimitMiB (${o.memoryLimitMiB})`
+        );
+      }
+      memoryMbMax = o.memoryLimitMiB;
+    }
+  }
+  const resources = milliCpu !== void 0 || milliCpuMax !== void 0 || memoryMb !== void 0 || memoryMbMax !== void 0 || gpuConfig ? {
+    milliCpu,
+    milliCpuMax,
+    memoryMb,
+    memoryMbMax,
     gpuConfig
   } : void 0;
   const secretIds = (o.secrets || []).map((s) => s.secretId);
@@ -44093,13 +44153,15 @@ async function buildFunctionOptionsProto(options) {
     initialDelayMs: parsedRetries.initialDelayMs,
     maxDelayMs: parsedRetries.maxDelayMs
   } : void 0;
-  if (o.scaledownWindow !== void 0 && o.scaledownWindow % 1e3 !== 0) {
+  if (o.scaledownWindowMs !== void 0 && o.scaledownWindowMs % 1e3 !== 0) {
     throw new Error(
-      `scaledownWindow must be a multiple of 1000ms, got ${o.scaledownWindow}`
+      `scaledownWindowMs must be a multiple of 1000ms, got ${o.scaledownWindowMs}`
     );
   }
-  if (o.timeout !== void 0 && o.timeout % 1e3 !== 0) {
-    throw new Error(`timeout must be a multiple of 1000ms, got ${o.timeout}`);
+  if (o.timeoutMs !== void 0 && o.timeoutMs % 1e3 !== 0) {
+    throw new Error(
+      `timeoutMs must be a multiple of 1000ms, got ${o.timeoutMs}`
+    );
   }
   const functionOptions = FunctionOptions.create({
     secretIds,
@@ -44110,8 +44172,8 @@ async function buildFunctionOptionsProto(options) {
     retryPolicy,
     concurrencyLimit: o.maxContainers,
     bufferContainers: o.bufferContainers,
-    taskIdleTimeoutSecs: o.scaledownWindow !== void 0 ? o.scaledownWindow / 1e3 : void 0,
-    timeoutSecs: o.timeout !== void 0 ? o.timeout / 1e3 : void 0,
+    taskIdleTimeoutSecs: o.scaledownWindowMs !== void 0 ? o.scaledownWindowMs / 1e3 : void 0,
+    timeoutSecs: o.timeoutMs !== void 0 ? o.timeoutMs / 1e3 : void 0,
     maxConcurrentInputs: o.maxConcurrentInputs,
     targetConcurrentInputs: o.targetConcurrentInputs,
     batchMaxSize: o.batchMaxSize,
@@ -44891,8 +44953,8 @@ var EphemeralHeartbeatManager = class {
 };
 
 // src/queue.ts
-var queueInitialPutBackoff = 100;
-var queueDefaultPartitionTtl = 24 * 3600 * 1e3;
+var queueInitialPutBackoffMs = 100;
+var queueDefaultPartitionTtlMs = 24 * 3600 * 1e3;
 var QueueService = class {
   #client;
   constructor(client2) {
@@ -44996,30 +45058,30 @@ var Queue = class _Queue {
       allPartitions: params.all
     });
   }
-  async #get(n, partition, timeout) {
+  async #get(n, partition, timeoutMs) {
     const partitionKey = _Queue.#validatePartitionKey(partition);
     const startTime = Date.now();
-    let pollTimeout = 5e4;
-    if (timeout !== void 0) {
-      pollTimeout = Math.min(pollTimeout, timeout);
+    let pollTimeoutMs = 5e4;
+    if (timeoutMs !== void 0) {
+      pollTimeoutMs = Math.min(pollTimeoutMs, timeoutMs);
     }
     while (true) {
       const response = await this.#client.cpClient.queueGet({
         queueId: this.queueId,
         partitionKey,
-        timeout: pollTimeout / 1e3,
+        timeout: pollTimeoutMs / 1e3,
         nValues: n
       });
       if (response.values && response.values.length > 0) {
         return response.values.map((value) => loads(value));
       }
-      if (timeout !== void 0) {
-        const remaining = timeout - (Date.now() - startTime);
-        if (remaining <= 0) {
-          const message = `Queue ${this.queueId} did not return values within ${timeout}ms.`;
+      if (timeoutMs !== void 0) {
+        const remainingMs = timeoutMs - (Date.now() - startTime);
+        if (remainingMs <= 0) {
+          const message = `Queue ${this.queueId} did not return values within ${timeoutMs}ms.`;
           throw new QueueEmptyError(message);
         }
-        pollTimeout = Math.min(pollTimeout, remaining);
+        pollTimeoutMs = Math.min(pollTimeoutMs, remainingMs);
       }
     }
   }
@@ -45027,35 +45089,37 @@ var Queue = class _Queue {
    * Remove and return the next object from the Queue.
    *
    * By default, this will wait until at least one item is present in the Queue.
-   * If `timeout` is set, raises `QueueEmptyError` if no items are available
+   * If `timeoutMs` is set, raises `QueueEmptyError` if no items are available
    * within that timeout in milliseconds.
    */
   async get(params = {}) {
-    const values = await this.#get(1, params.partition, params.timeout);
+    checkForRenamedParams(params, { timeout: "timeoutMs" });
+    const values = await this.#get(1, params.partition, params.timeoutMs);
     return values[0];
   }
   /**
    * Remove and return up to `n` objects from the Queue.
    *
    * By default, this will wait until at least one item is present in the Queue.
-   * If `timeout` is set, raises `QueueEmptyError` if no items are available
+   * If `timeoutMs` is set, raises `QueueEmptyError` if no items are available
    * within that timeout in milliseconds.
    */
   async getMany(n, params = {}) {
-    return await this.#get(n, params.partition, params.timeout);
+    checkForRenamedParams(params, { timeout: "timeoutMs" });
+    return await this.#get(n, params.partition, params.timeoutMs);
   }
-  async #put(values, timeout, partition, partitionTtl) {
+  async #put(values, timeoutMs, partition, partitionTtlMs) {
     const valuesEncoded = values.map((v) => dumps(v));
     const partitionKey = _Queue.#validatePartitionKey(partition);
-    let delay = queueInitialPutBackoff;
-    const deadline = timeout ? Date.now() + timeout : void 0;
+    let delay = queueInitialPutBackoffMs;
+    const deadline = timeoutMs ? Date.now() + timeoutMs : void 0;
     while (true) {
       try {
         await this.#client.cpClient.queuePut({
           queueId: this.queueId,
           values: valuesEncoded,
           partitionKey,
-          partitionTtlSeconds: (partitionTtl || queueDefaultPartitionTtl) / 1e3
+          partitionTtlSeconds: (partitionTtlMs || queueDefaultPartitionTtlMs) / 1e3
         });
         break;
       } catch (e) {
@@ -45078,25 +45142,38 @@ var Queue = class _Queue {
    * Add an item to the end of the Queue.
    *
    * If the Queue is full, this will retry with exponential backoff until the
-   * provided `timeout` is reached, or indefinitely if `timeout` is not set.
+   * provided `timeoutMs` is reached, or indefinitely if `timeoutMs` is not set.
    * Raises {@link QueueFullError} if the Queue is still full after the timeout.
    */
   async put(v, params = {}) {
-    await this.#put([v], params.timeout, params.partition, params.partitionTtl);
+    checkForRenamedParams(params, {
+      timeout: "timeoutMs",
+      partitionTtl: "partitionTtlMs"
+    });
+    await this.#put(
+      [v],
+      params.timeoutMs,
+      params.partition,
+      params.partitionTtlMs
+    );
   }
   /**
    * Add several items to the end of the Queue.
    *
    * If the Queue is full, this will retry with exponential backoff until the
-   * provided `timeout` is reached, or indefinitely if `timeout` is not set.
+   * provided `timeoutMs` is reached, or indefinitely if `timeoutMs` is not set.
    * Raises {@link QueueFullError} if the Queue is still full after the timeout.
    */
   async putMany(values, params = {}) {
+    checkForRenamedParams(params, {
+      timeout: "timeoutMs",
+      partitionTtl: "partitionTtlMs"
+    });
     await this.#put(
       values,
-      params.timeout,
+      params.timeoutMs,
       params.partition,
-      params.partitionTtl
+      params.partitionTtlMs
     );
   }
   /** Return the number of objects in the Queue. */
@@ -45115,20 +45192,21 @@ var Queue = class _Queue {
   }
   /** Iterate through items in a Queue without mutation. */
   async *iterate(params = {}) {
-    const { partition, itemPollTimeout = 0 } = params;
+    checkForRenamedParams(params, { itemPollTimeout: "itemPollTimeoutMs" });
+    const { partition, itemPollTimeoutMs = 0 } = params;
     let lastEntryId = void 0;
     const validatedPartitionKey = _Queue.#validatePartitionKey(partition);
-    let fetchDeadline = Date.now() + itemPollTimeout;
-    const maxPollDuration = 3e4;
+    let fetchDeadline = Date.now() + itemPollTimeoutMs;
+    const maxPollDurationMs = 3e4;
     while (true) {
-      const pollDuration = Math.max(
+      const pollDurationMs = Math.max(
         0,
-        Math.min(maxPollDuration, fetchDeadline - Date.now())
+        Math.min(maxPollDurationMs, fetchDeadline - Date.now())
       );
       const request = {
         queueId: this.queueId,
         partitionKey: validatedPartitionKey,
-        itemPollTimeout: pollDuration / 1e3,
+        itemPollTimeout: pollDurationMs / 1e3,
         lastEntryId: lastEntryId || ""
       };
       const response = await this.#client.cpClient.queueNextItems(request);
@@ -45137,7 +45215,7 @@ var Queue = class _Queue {
           yield loads(item.value);
           lastEntryId = item.entryId;
         }
-        fetchDeadline = Date.now() + itemPollTimeout;
+        fetchDeadline = Date.now() + itemPollTimeoutMs;
       } else if (Date.now() > fetchDeadline) {
         break;
       }
@@ -45424,15 +45502,21 @@ function cloudBucketMountToProto(mount, mountPath) {
 
 // src/sandbox.ts
 async function buildSandboxCreateRequestProto(appId, imageId, params = {}) {
+  checkForRenamedParams(params, {
+    memory: "memoryMiB",
+    memoryLimit: "memoryLimitMiB",
+    timeout: "timeoutMs",
+    idleTimeout: "idleTimeoutMs"
+  });
   const gpuConfig = parseGpuConfig(params.gpu);
-  if (params.timeout && params.timeout % 1e3 !== 0) {
+  if (params.timeoutMs && params.timeoutMs % 1e3 !== 0) {
     throw new Error(
-      `timeout must be a multiple of 1000ms, got ${params.timeout}`
+      `timeoutMs must be a multiple of 1000ms, got ${params.timeoutMs}`
     );
   }
-  if (params.idleTimeout && params.idleTimeout % 1e3 !== 0) {
+  if (params.idleTimeoutMs && params.idleTimeoutMs % 1e3 !== 0) {
     throw new Error(
-      `idleTimeout must be a multiple of 1000ms, got ${params.idleTimeout}`
+      `idleTimeoutMs must be a multiple of 1000ms, got ${params.idleTimeoutMs}`
     );
   }
   if (params.workdir && !params.workdir.startsWith("/")) {
@@ -45503,20 +45587,63 @@ async function buildSandboxCreateRequestProto(appId, imageId, params = {}) {
   if (params.pty) {
     ptyInfo = defaultSandboxPTYInfo();
   }
+  let milliCpu = void 0;
+  let milliCpuMax = void 0;
+  if (params.cpu === void 0 && params.cpuLimit !== void 0) {
+    throw new Error("must also specify cpu when cpuLimit is specified");
+  }
+  if (params.cpu !== void 0) {
+    if (params.cpu <= 0) {
+      throw new Error(`cpu (${params.cpu}) must be a positive number`);
+    }
+    milliCpu = Math.trunc(1e3 * params.cpu);
+    if (params.cpuLimit !== void 0) {
+      if (params.cpuLimit < params.cpu) {
+        throw new Error(
+          `cpu (${params.cpu}) cannot be higher than cpuLimit (${params.cpuLimit})`
+        );
+      }
+      milliCpuMax = Math.trunc(1e3 * params.cpuLimit);
+    }
+  }
+  let memoryMb = void 0;
+  let memoryMbMax = void 0;
+  if (params.memoryMiB === void 0 && params.memoryLimitMiB !== void 0) {
+    throw new Error(
+      "must also specify memoryMiB when memoryLimitMiB is specified"
+    );
+  }
+  if (params.memoryMiB !== void 0) {
+    if (params.memoryMiB <= 0) {
+      throw new Error(
+        `the memoryMiB request (${params.memoryMiB}) must be a positive number`
+      );
+    }
+    memoryMb = params.memoryMiB;
+    if (params.memoryLimitMiB !== void 0) {
+      if (params.memoryLimitMiB < params.memoryMiB) {
+        throw new Error(
+          `the memoryMiB request (${params.memoryMiB}) cannot be higher than memoryLimitMiB (${params.memoryLimitMiB})`
+        );
+      }
+      memoryMbMax = params.memoryLimitMiB;
+    }
+  }
   return SandboxCreateRequest.create({
     appId,
     definition: {
       // Sleep default is implicit in image builder version <=2024.10
       entrypointArgs: params.command ?? ["sleep", "48h"],
       imageId,
-      timeoutSecs: params.timeout != void 0 ? params.timeout / 1e3 : 600,
-      idleTimeoutSecs: params.idleTimeout != void 0 ? params.idleTimeout / 1e3 : void 0,
+      timeoutSecs: params.timeoutMs != void 0 ? params.timeoutMs / 1e3 : 600,
+      idleTimeoutSecs: params.idleTimeoutMs != void 0 ? params.idleTimeoutMs / 1e3 : void 0,
       workdir: params.workdir ?? void 0,
       networkAccess,
       resources: {
-        // https://modal.com/docs/guide/resources
-        milliCpu: Math.round(1e3 * (params.cpu ?? 0.125)),
-        memoryMb: params.memory ?? 128,
+        milliCpu,
+        milliCpuMax,
+        memoryMb,
+        memoryMbMax,
         gpuConfig
       },
       volumeMounts,
@@ -45691,6 +45818,7 @@ function defaultSandboxPTYInfo() {
   });
 }
 async function buildContainerExecRequestProto(taskId, command, params) {
+  checkForRenamedParams(params, { timeout: "timeoutMs" });
   const secretIds = (params?.secrets || []).map((secret) => secret.secretId);
   let ptyInfo;
   if (params?.pty) {
@@ -45700,7 +45828,7 @@ async function buildContainerExecRequestProto(taskId, command, params) {
     taskId,
     command,
     workdir: params?.workdir,
-    timeoutSecs: params?.timeout ? params.timeout / 1e3 : 0,
+    timeoutSecs: params?.timeoutMs ? params.timeoutMs / 1e3 : 0,
     secretIds,
     ptyInfo
   });
@@ -45868,14 +45996,13 @@ var Sandbox2 = class _Sandbox {
    *
    * @returns A dictionary of {@link Tunnel} objects which are keyed by the container port.
    */
-  async tunnels(timeout = 5e4) {
+  async tunnels(timeoutMs = 5e4) {
     if (this.#tunnels) {
       return this.#tunnels;
     }
     const resp = await this.#client.cpClient.sandboxGetTunnels({
       sandboxId: this.sandboxId,
-      timeout: timeout / 1e3
-      // Convert to seconds
+      timeout: timeoutMs / 1e3
     });
     if (resp.result?.status === 4 /* GENERIC_STATUS_TIMEOUT */) {
       throw new SandboxTimeoutError();
@@ -45896,13 +46023,13 @@ var Sandbox2 = class _Sandbox {
    *
    * Returns an {@link Image} object which can be used to spawn a new Sandbox with the same filesystem.
    *
-   * @param timeout - Timeout for the snapshot operation in milliseconds
+   * @param timeoutMs - Timeout for the snapshot operation in milliseconds
    * @returns Promise that resolves to an {@link Image}
    */
-  async snapshotFilesystem(timeout = 55e3) {
+  async snapshotFilesystem(timeoutMs = 55e3) {
     const resp = await this.#client.cpClient.sandboxSnapshotFs({
       sandboxId: this.sandboxId,
-      timeout: timeout / 1e3
+      timeout: timeoutMs / 1e3
     });
     if (resp.result?.status !== 1 /* GENERIC_STATUS_SUCCESS */) {
       throw new Error(
@@ -46354,7 +46481,7 @@ var AuthTokenManager = class {
 
 // src/version.ts
 function getSDKVersion() {
-  return true ? "0.5.0-dev.6" : "0.0.0";
+  return true ? "0.5.0" : "0.0.0";
 }
 
 // src/client.ts
@@ -46375,6 +46502,7 @@ var ModalClient = class {
   ipClients;
   authTokenManager = null;
   constructor(params) {
+    checkForRenamedParams(params, { timeout: "timeoutMs" });
     const baseProfile = getProfile(process.env["MODAL_PROFILE"]);
     this.profile = {
       ...baseProfile,
@@ -46468,10 +46596,10 @@ var ModalClient = class {
   }
 };
 var timeoutMiddleware = async function* timeoutMiddleware2(call, options) {
-  if (!options.timeout || options.signal?.aborted) {
+  if (!options.timeoutMs || options.signal?.aborted) {
     return yield* call.next(call.request, options);
   }
-  const { timeout, signal: origSignal, ...restOptions } = options;
+  const { timeoutMs, signal: origSignal, ...restOptions } = options;
   const abortController = new AbortController();
   const abortListener = () => abortController.abort();
   origSignal?.addEventListener("abort", abortListener);
@@ -46479,7 +46607,7 @@ var timeoutMiddleware = async function* timeoutMiddleware2(call, options) {
   const timer = setTimeout(() => {
     timedOut = true;
     abortController.abort();
-  }, timeout);
+  }, timeoutMs);
   try {
     return yield* call.next(call.request, {
       ...restOptions,
@@ -46492,7 +46620,7 @@ var timeoutMiddleware = async function* timeoutMiddleware2(call, options) {
       throw new ClientError9(
         call.method.path,
         Status9.DEADLINE_EXCEEDED,
-        `Timed out after ${timeout}ms`
+        `Timed out after ${timeoutMs}ms`
       );
     }
   }
@@ -46718,6 +46846,7 @@ export {
   SecretService,
   Volume,
   VolumeService,
+  checkForRenamedParams,
   close,
   initializeClient
 };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "modal",
-  "version": "0.5.0-dev.6",
-  "description": "Modal client library for JavaScript",
+  "version": "0.5.0",
+  "description": "Modal SDK for JavaScript/TypeScript",
   "license": "Apache-2.0",
-  "homepage": "https://modal.com/docs",
+  "homepage": "https://modal.com/docs/guide/sdk-javascript-go",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/modal-labs/libmodal.git"