@hyperserve/hyperserve-js 0.1.0

package/dist/errors-C89laaKB.d.cts

@@ -0,0 +1,176 @@
+type VideoResolution = "144p" | "240p" | "360p" | "480p" | "720p" | "1080p" | "1440p" | "4k" | "8k";
+type VideoStatus = "pending_upload" | "processing" | "ready" | "fail";
+interface HyperserveClientOptions {
+    /** Your Hyperserve API key. Must be kept server-side — never expose in browser code. */
+    apiKey: string;
+    /** Override the base URL (must include the /api prefix). Useful for local development. Defaults to https://api.hyperserve.io/api */
+    baseUrl?: string;
+    /** Timeout in milliseconds for API calls (not the storage PUT). Defaults to 30000. */
+    timeoutMs?: number;
+    /**
+     * Number of additional retry attempts on transient failures (5xx responses and network errors).
+     * Uses exponential backoff with full jitter (random delay up to min(10s, 100ms × 2^attempt)).
+     * Does not retry on 4xx errors or timeouts. Defaults to 0 (no retries).
+     */
+    retries?: number;
+}
+interface VerifyWebhookSignatureOptions {
+    /**
+     * Value of the x-hyperserve-signature header from the incoming webhook request.
+     * Format: "{timestampMs}.{hmac-sha256-hex}"
+     */
+    signature: string;
+    /** Your webhook signing secret from the Hyperserve dashboard. */
+    secret: string;
+    /**
+     * The raw request body as a string. Must be the exact bytes received — do not parse
+     * and re-serialize, as any whitespace difference will invalidate the signature.
+     *
+     * @example
+     * // Express
+     * app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
+     *   const body = req.body.toString();
+     *   ...
+     * });
+     *
+     * // Next.js App Router
+     * const body = await request.text();
+     */
+    body: string;
+    /**
+     * Maximum age of the timestamp in milliseconds. Defaults to 300000 (5 minutes).
+     * Must match or exceed the server-side tolerance to avoid rejecting valid webhooks.
+     */
+    toleranceMs?: number;
+}
+interface CreateVideoOptions {
+    /** Original filename including extension (e.g. "promo.mp4"). Used server-side to derive content type. */
+    filename: string;
+    /** File size in bytes. */
+    fileSizeBytes: number;
+    /** At least one resolution is required. */
+    resolutions: [VideoResolution, ...VideoResolution[]];
+    /** Controls whether playback URLs are public or time-limited signed URLs. */
+    isPublic: boolean;
+    /** Timestamps (seconds) at which to generate thumbnail images. */
+    thumbnailTimestampsSeconds?: number[];
+    /** Arbitrary key/value stored against the video. */
+    customMetadata?: Record<string, unknown>;
+}
+interface CreateVideoResult {
+    /** Video ID — use in completeUpload and all subsequent calls. */
+    id: string;
+    /** Presigned PUT URL for the original file. Pass to your frontend. Expires shortly. */
+    uploadUrl: string;
+    /** Exact Content-Type to send on the presigned PUT. Pass to your frontend alongside uploadUrl. */
+    contentType: string;
+    isPublic: boolean;
+    resolutions: Record<VideoResolution, {
+        status: "pending_upload";
+    }>;
+}
+interface CompleteUploadResult {
+    id: string;
+    isPublic: boolean;
+    resolutions: Record<VideoResolution, {
+        status: VideoStatus;
+    }>;
+}
+interface UploadVideoOptions {
+    /** The video file. Use File/Blob in browser contexts, Buffer or ReadableStream in Node. */
+    file: Blob | Buffer | ReadableStream;
+    /** Filename including extension (e.g. "clip.mp4"). */
+    filename: string;
+    /** Required when file is a ReadableStream (cannot be inferred). Inferred automatically for Blob/Buffer. */
+    fileSizeBytes?: number;
+    resolutions: [VideoResolution, ...VideoResolution[]];
+    isPublic: boolean;
+    thumbnailTimestampsSeconds?: number[];
+    customMetadata?: Record<string, unknown>;
+}
+interface GetVideoOptions {
+    /** Return time-limited signed URLs instead of public URLs. */
+    private?: boolean;
+    /** Signed URL TTL in seconds when private is true. Defaults to 3600. */
+    expirationSeconds?: number;
+}
+interface VideoResolutionResult {
+    id: string;
+    status: VideoStatus;
+    videoUrl: string;
+    thumbnailImageUrls: string[];
+}
+interface VideoResult {
+    id: string;
+    status: VideoStatus;
+    isPublic: boolean;
+    resolutions: Partial<Record<VideoResolution, VideoResolutionResult>>;
+}
+interface PutVideoToStorageOptions {
+    /** Presigned PUT URL obtained from your backend (which called createVideo). */
+    uploadUrl: string;
+    /** Content-Type obtained from your backend alongside uploadUrl. */
+    contentType: string;
+    /** The video file from a browser file picker or drag-and-drop. */
+    file: File | Blob;
+    /** Called during the upload with progress 0–100. Uses XHR when provided. */
+    onProgress?: (percent: number) => void;
+}
+interface PutVideoToStorageRNOptions {
+    /** Presigned PUT URL obtained from your backend (which called createVideo). */
+    uploadUrl: string;
+    /** Content-Type obtained from your backend alongside uploadUrl. */
+    contentType: string;
+    /**
+     * Local file URI from a React Native video/image picker.
+     * e.g. "file:///var/mobile/Containers/.../video.mp4"
+     * Accepted from expo-image-picker, react-native-image-picker, expo-document-picker, etc.
+     */
+    uri: string;
+    /** Called during the upload with progress 0–100. Uses XHR when provided. */
+    onProgress?: (percent: number) => void;
+}
+
+/**
+ * Base class for all Hyperserve SDK errors.
+ */
+declare class HyperserveError extends Error {
+    readonly statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}
+/**
+ * The Hyperserve API returned a 4xx response.
+ * Typically indicates a validation problem: unsupported file format,
+ * file too large, invalid resolutions, video not in expected state, etc.
+ */
+declare class HyperserveValidationError extends HyperserveError {
+    readonly detail?: unknown | undefined;
+    constructor(message: string, statusCode: number, detail?: unknown | undefined);
+}
+/**
+ * The Hyperserve API returned a 404 response.
+ */
+declare class HyperserveNotFoundError extends HyperserveError {
+    constructor(message?: string);
+}
+/**
+ * The Hyperserve API returned a 5xx response.
+ */
+declare class HyperserveApiError extends HyperserveError {
+    constructor(message: string, statusCode: number);
+}
+/**
+ * The storage PUT request failed.
+ */
+declare class HyperserveUploadError extends HyperserveError {
+    readonly uploadStatus?: number | undefined;
+    constructor(message: string, uploadStatus?: number | undefined);
+}
+/**
+ * A request exceeded the configured timeoutMs.
+ */
+declare class HyperserveTimeoutError extends HyperserveError {
+    constructor(message?: string);
+}
+
+export { type CreateVideoOptions as C, type GetVideoOptions as G, type HyperserveClientOptions as H, type PutVideoToStorageOptions as P, type UploadVideoOptions as U, type VideoResult as V, type CreateVideoResult as a, type CompleteUploadResult as b, type VerifyWebhookSignatureOptions as c, HyperserveApiError as d, HyperserveError as e, HyperserveNotFoundError as f, HyperserveTimeoutError as g, HyperserveUploadError as h, HyperserveValidationError as i, type PutVideoToStorageRNOptions as j, type VideoResolution as k, type VideoResolutionResult as l, type VideoStatus as m };

package/dist/errors-C89laaKB.d.ts

@@ -0,0 +1,176 @@
+type VideoResolution = "144p" | "240p" | "360p" | "480p" | "720p" | "1080p" | "1440p" | "4k" | "8k";
+type VideoStatus = "pending_upload" | "processing" | "ready" | "fail";
+interface HyperserveClientOptions {
+    /** Your Hyperserve API key. Must be kept server-side — never expose in browser code. */
+    apiKey: string;
+    /** Override the base URL (must include the /api prefix). Useful for local development. Defaults to https://api.hyperserve.io/api */
+    baseUrl?: string;
+    /** Timeout in milliseconds for API calls (not the storage PUT). Defaults to 30000. */
+    timeoutMs?: number;
+    /**
+     * Number of additional retry attempts on transient failures (5xx responses and network errors).
+     * Uses exponential backoff with full jitter (random delay up to min(10s, 100ms × 2^attempt)).
+     * Does not retry on 4xx errors or timeouts. Defaults to 0 (no retries).
+     */
+    retries?: number;
+}
+interface VerifyWebhookSignatureOptions {
+    /**
+     * Value of the x-hyperserve-signature header from the incoming webhook request.
+     * Format: "{timestampMs}.{hmac-sha256-hex}"
+     */
+    signature: string;
+    /** Your webhook signing secret from the Hyperserve dashboard. */
+    secret: string;
+    /**
+     * The raw request body as a string. Must be the exact bytes received — do not parse
+     * and re-serialize, as any whitespace difference will invalidate the signature.
+     *
+     * @example
+     * // Express
+     * app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
+     *   const body = req.body.toString();
+     *   ...
+     * });
+     *
+     * // Next.js App Router
+     * const body = await request.text();
+     */
+    body: string;
+    /**
+     * Maximum age of the timestamp in milliseconds. Defaults to 300000 (5 minutes).
+     * Must match or exceed the server-side tolerance to avoid rejecting valid webhooks.
+     */
+    toleranceMs?: number;
+}
+interface CreateVideoOptions {
+    /** Original filename including extension (e.g. "promo.mp4"). Used server-side to derive content type. */
+    filename: string;
+    /** File size in bytes. */
+    fileSizeBytes: number;
+    /** At least one resolution is required. */
+    resolutions: [VideoResolution, ...VideoResolution[]];
+    /** Controls whether playback URLs are public or time-limited signed URLs. */
+    isPublic: boolean;
+    /** Timestamps (seconds) at which to generate thumbnail images. */
+    thumbnailTimestampsSeconds?: number[];
+    /** Arbitrary key/value stored against the video. */
+    customMetadata?: Record<string, unknown>;
+}
+interface CreateVideoResult {
+    /** Video ID — use in completeUpload and all subsequent calls. */
+    id: string;
+    /** Presigned PUT URL for the original file. Pass to your frontend. Expires shortly. */
+    uploadUrl: string;
+    /** Exact Content-Type to send on the presigned PUT. Pass to your frontend alongside uploadUrl. */
+    contentType: string;
+    isPublic: boolean;
+    resolutions: Record<VideoResolution, {
+        status: "pending_upload";
+    }>;
+}
+interface CompleteUploadResult {
+    id: string;
+    isPublic: boolean;
+    resolutions: Record<VideoResolution, {
+        status: VideoStatus;
+    }>;
+}
+interface UploadVideoOptions {
+    /** The video file. Use File/Blob in browser contexts, Buffer or ReadableStream in Node. */
+    file: Blob | Buffer | ReadableStream;
+    /** Filename including extension (e.g. "clip.mp4"). */
+    filename: string;
+    /** Required when file is a ReadableStream (cannot be inferred). Inferred automatically for Blob/Buffer. */
+    fileSizeBytes?: number;
+    resolutions: [VideoResolution, ...VideoResolution[]];
+    isPublic: boolean;
+    thumbnailTimestampsSeconds?: number[];
+    customMetadata?: Record<string, unknown>;
+}
+interface GetVideoOptions {
+    /** Return time-limited signed URLs instead of public URLs. */
+    private?: boolean;
+    /** Signed URL TTL in seconds when private is true. Defaults to 3600. */
+    expirationSeconds?: number;
+}
+interface VideoResolutionResult {
+    id: string;
+    status: VideoStatus;
+    videoUrl: string;
+    thumbnailImageUrls: string[];
+}
+interface VideoResult {
+    id: string;
+    status: VideoStatus;
+    isPublic: boolean;
+    resolutions: Partial<Record<VideoResolution, VideoResolutionResult>>;
+}
+interface PutVideoToStorageOptions {
+    /** Presigned PUT URL obtained from your backend (which called createVideo). */
+    uploadUrl: string;
+    /** Content-Type obtained from your backend alongside uploadUrl. */
+    contentType: string;
+    /** The video file from a browser file picker or drag-and-drop. */
+    file: File | Blob;
+    /** Called during the upload with progress 0–100. Uses XHR when provided. */
+    onProgress?: (percent: number) => void;
+}
+interface PutVideoToStorageRNOptions {
+    /** Presigned PUT URL obtained from your backend (which called createVideo). */
+    uploadUrl: string;
+    /** Content-Type obtained from your backend alongside uploadUrl. */
+    contentType: string;
+    /**
+     * Local file URI from a React Native video/image picker.
+     * e.g. "file:///var/mobile/Containers/.../video.mp4"
+     * Accepted from expo-image-picker, react-native-image-picker, expo-document-picker, etc.
+     */
+    uri: string;
+    /** Called during the upload with progress 0–100. Uses XHR when provided. */
+    onProgress?: (percent: number) => void;
+}
+
+/**
+ * Base class for all Hyperserve SDK errors.
+ */
+declare class HyperserveError extends Error {
+    readonly statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}
+/**
+ * The Hyperserve API returned a 4xx response.
+ * Typically indicates a validation problem: unsupported file format,
+ * file too large, invalid resolutions, video not in expected state, etc.
+ */
+declare class HyperserveValidationError extends HyperserveError {
+    readonly detail?: unknown | undefined;
+    constructor(message: string, statusCode: number, detail?: unknown | undefined);
+}
+/**
+ * The Hyperserve API returned a 404 response.
+ */
+declare class HyperserveNotFoundError extends HyperserveError {
+    constructor(message?: string);
+}
+/**
+ * The Hyperserve API returned a 5xx response.
+ */
+declare class HyperserveApiError extends HyperserveError {
+    constructor(message: string, statusCode: number);
+}
+/**
+ * The storage PUT request failed.
+ */
+declare class HyperserveUploadError extends HyperserveError {
+    readonly uploadStatus?: number | undefined;
+    constructor(message: string, uploadStatus?: number | undefined);
+}
+/**
+ * A request exceeded the configured timeoutMs.
+ */
+declare class HyperserveTimeoutError extends HyperserveError {
+    constructor(message?: string);
+}
+
+export { type CreateVideoOptions as C, type GetVideoOptions as G, type HyperserveClientOptions as H, type PutVideoToStorageOptions as P, type UploadVideoOptions as U, type VideoResult as V, type CreateVideoResult as a, type CompleteUploadResult as b, type VerifyWebhookSignatureOptions as c, HyperserveApiError as d, HyperserveError as e, HyperserveNotFoundError as f, HyperserveTimeoutError as g, HyperserveUploadError as h, HyperserveValidationError as i, type PutVideoToStorageRNOptions as j, type VideoResolution as k, type VideoResolutionResult as l, type VideoStatus as m };

package/dist/index.cjs

@@ -0,0 +1,342 @@
+'use strict';
+
+// src/errors.ts
+var HyperserveError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "HyperserveError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var HyperserveValidationError = class extends HyperserveError {
+  constructor(message, statusCode, detail) {
+    super(message, statusCode);
+    this.detail = detail;
+    this.name = "HyperserveValidationError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var HyperserveNotFoundError = class extends HyperserveError {
+  constructor(message = "Resource not found") {
+    super(message, 404);
+    this.name = "HyperserveNotFoundError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var HyperserveApiError = class extends HyperserveError {
+  constructor(message, statusCode) {
+    super(message, statusCode);
+    this.name = "HyperserveApiError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var HyperserveUploadError = class extends HyperserveError {
+  constructor(message, uploadStatus) {
+    super(message);
+    this.uploadStatus = uploadStatus;
+    this.name = "HyperserveUploadError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var HyperserveTimeoutError = class extends HyperserveError {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "HyperserveTimeoutError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/http.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryable(err) {
+  if (err instanceof HyperserveApiError && err.statusCode !== void 0 && err.statusCode >= 500)
+    return true;
+  if (err instanceof Error && !(err instanceof HyperserveError)) return true;
+  return false;
+}
+async function apiRequest(options) {
+  const { retries = 0 } = options;
+  let attempt = 0;
+  while (true) {
+    try {
+      return await attemptRequest(options);
+    } catch (err) {
+      if (attempt >= retries || !isRetryable(err)) {
+        throw err;
+      }
+      const delay = Math.random() * Math.min(1e4, 100 * 2 ** attempt);
+      await sleep(delay);
+      attempt++;
+    }
+  }
+}
+async function attemptRequest(options) {
+  const { method, url, apiKey, timeoutMs, body } = options;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers: {
+        "X-API-KEY": apiKey,
+        ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+      },
+      // Omit body entirely when not present — passing body: null on DELETE requests
+      // can be treated differently by some proxies and intermediaries.
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {},
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new HyperserveTimeoutError(`Request to ${url} timed out after ${timeoutMs}ms`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.ok) {
+    if (response.status === 204) {
+      return void 0;
+    }
+    try {
+      return await response.json();
+    } catch {
+      throw new HyperserveApiError(`Failed to parse response from ${url}`, response.status);
+    }
+  }
+  let errorBody = {};
+  try {
+    errorBody = await response.json();
+  } catch {
+  }
+  const message = errorBody.message ?? response.statusText;
+  if (response.status === 404) {
+    throw new HyperserveNotFoundError(message);
+  }
+  if (response.status >= 400 && response.status < 500) {
+    throw new HyperserveValidationError(message, response.status, errorBody);
+  }
+  throw new HyperserveApiError(message, response.status);
+}
+
+// src/normalize.ts
+function normalizeFile(file, filename, fileSizeBytes) {
+  if (file instanceof ReadableStream) {
+    if (fileSizeBytes === void 0) {
+      throw new TypeError(
+        "fileSizeBytes is required when file is a ReadableStream (size cannot be inferred)"
+      );
+    }
+    return { body: file, size: fileSizeBytes };
+  }
+  if (Buffer.isBuffer(file)) {
+    const size2 = fileSizeBytes ?? file.byteLength;
+    const blob = new Blob([new Uint8Array(file)], { type: deriveTypeHint(filename) });
+    return { body: blob, size: size2 };
+  }
+  const size = fileSizeBytes ?? file.size;
+  return { body: file, size };
+}
+function deriveTypeHint(filename) {
+  const ext = filename.slice(filename.lastIndexOf(".") + 1).toLowerCase();
+  const map = {
+    mp4: "video/mp4",
+    mov: "video/quicktime",
+    webm: "video/webm",
+    avi: "video/x-msvideo",
+    mkv: "video/x-matroska",
+    m4v: "video/x-m4v"
+  };
+  return map[ext] ?? "application/octet-stream";
+}
+
+// src/storage.ts
+async function putToStorage(uploadUrl, contentType, body, onProgress) {
+  return putWithFetch(uploadUrl, contentType, body);
+}
+function putWithFetch(uploadUrl, contentType, body) {
+  return fetch(uploadUrl, {
+    method: "PUT",
+    headers: { "Content-Type": contentType },
+    // duplex is required for ReadableStream bodies in some runtimes (Node 18)
+    ...body instanceof ReadableStream ? { duplex: "half" } : {},
+    body
+  }).then((response) => {
+    if (!response.ok) {
+      throw new HyperserveUploadError(
+        `Storage PUT failed with status ${response.status}`,
+        response.status
+      );
+    }
+  });
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.hyperserve.io/api";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var HyperserveClient = class {
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl?.replace(/\/$/, "") ?? DEFAULT_BASE_URL;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.retries = options.retries ?? 0;
+  }
+  /**
+   * Creates a video record and returns a presigned upload URL.
+   * Pass uploadUrl and contentType to your frontend so it can PUT the file directly to storage.
+   * Call completeUpload once the frontend confirms the PUT is done.
+   */
+  async createVideo(options) {
+    return apiRequest({
+      method: "POST",
+      url: `${this.baseUrl}/video`,
+      apiKey: this.apiKey,
+      timeoutMs: this.timeoutMs,
+      retries: this.retries,
+      body: {
+        filename: options.filename,
+        fileSizeBytes: options.fileSizeBytes,
+        resolutions: options.resolutions,
+        isPublic: options.isPublic,
+        ...options.thumbnailTimestampsSeconds !== void 0 && {
+          thumbnail_timestamps_seconds: options.thumbnailTimestampsSeconds
+        },
+        ...options.customMetadata !== void 0 && {
+          custom_user_metadata: options.customMetadata
+        }
+      }
+    });
+  }
+  /**
+   * Notifies Hyperserve that the file has been uploaded to the presigned URL.
+   * Hyperserve verifies the object and queues transcoding.
+   * Call this after your frontend confirms the storage PUT is complete.
+   */
+  async completeUpload(videoId) {
+    return apiRequest({
+      method: "POST",
+      url: `${this.baseUrl}/video/${videoId}/complete-upload`,
+      apiKey: this.apiKey,
+      timeoutMs: this.timeoutMs,
+      retries: this.retries
+    });
+  }
+  /**
+   * Retrieves the current state of a video, including per-resolution status and playback URLs.
+   *
+   * @param videoId - The video ID returned by createVideo or uploadVideo.
+   * @param options.private - Return time-limited signed URLs instead of public URLs.
+   * @param options.expirationSeconds - Signed URL TTL when private is true. Defaults to 3600.
+   */
+  async getVideo(videoId, options) {
+    const isPrivate = options?.private === true;
+    const expiration = options?.expirationSeconds ?? 3600;
+    const url = isPrivate ? `${this.baseUrl}/video/${videoId}/private/${expiration}` : `${this.baseUrl}/video/${videoId}/public`;
+    return apiRequest({
+      method: "GET",
+      url,
+      apiKey: this.apiKey,
+      timeoutMs: this.timeoutMs,
+      retries: this.retries
+    });
+  }
+  /**
+   * Deletes a video and all associated resolutions and thumbnails.
+   */
+  async deleteVideo(videoId) {
+    return apiRequest({
+      method: "DELETE",
+      url: `${this.baseUrl}/video/${videoId}`,
+      apiKey: this.apiKey,
+      timeoutMs: this.timeoutMs,
+      retries: this.retries
+    });
+  }
+  /**
+   * Deletes a single resolution for a video.
+   */
+  async deleteResolution(resolutionId) {
+    return apiRequest({
+      method: "DELETE",
+      url: `${this.baseUrl}/video/resolution/${resolutionId}`,
+      apiKey: this.apiKey,
+      timeoutMs: this.timeoutMs,
+      retries: this.retries
+    });
+  }
+  /**
+   * Convenience method for server-side / script use cases.
+   * Wraps createVideo, the storage PUT, and completeUpload into a single call.
+   *
+   * Not suitable for the browser proxy pattern — use createVideo + putVideoToStorage
+   * from '@hyperserve/hyperserve-js/browser' + completeUpload separately for that flow.
+   */
+  async uploadVideo(options) {
+    const { file, filename, resolutions, isPublic, thumbnailTimestampsSeconds, customMetadata } = options;
+    const normalized = normalizeFile(file, filename, options.fileSizeBytes);
+    const upload = await this.createVideo({
+      filename,
+      fileSizeBytes: normalized.size,
+      resolutions,
+      isPublic,
+      ...thumbnailTimestampsSeconds !== void 0 && { thumbnailTimestampsSeconds },
+      ...customMetadata !== void 0 && { customMetadata }
+    });
+    await putToStorage(upload.uploadUrl, upload.contentType, normalized.body);
+    return this.completeUpload(upload.id);
+  }
+};
+
+// src/webhook.ts
+var DEFAULT_TOLERANCE_MS = 3e5;
+async function verifyWebhookSignature(options) {
+  const { signature, secret, body, toleranceMs = DEFAULT_TOLERANCE_MS } = options;
+  const dotIndex = signature.indexOf(".");
+  if (dotIndex === -1) return false;
+  const timestampStr = signature.slice(0, dotIndex);
+  const receivedHex = signature.slice(dotIndex + 1);
+  const timestamp = Number(timestampStr);
+  if (!Number.isInteger(timestamp) || timestamp < 0) return false;
+  if (Math.abs(Date.now() - timestamp) > toleranceMs) return false;
+  const receivedBytes = hexToBytes(receivedHex);
+  if (receivedBytes === null) return false;
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["verify"]
+  );
+  return crypto.subtle.verify(
+    "HMAC",
+    key,
+    receivedBytes,
+    encoder.encode(`${timestampStr}.${body}`)
+  );
+}
+function hexToBytes(hex) {
+  if (hex.length === 0 || hex.length % 2 !== 0) return null;
+  const bytes = new Uint8Array(new ArrayBuffer(hex.length / 2));
+  for (let i = 0; i < hex.length; i += 2) {
+    const value = parseInt(hex.slice(i, i + 2), 16);
+    if (Number.isNaN(value)) return null;
+    bytes[i / 2] = value;
+  }
+  return bytes;
+}
+
+exports.HyperserveApiError = HyperserveApiError;
+exports.HyperserveClient = HyperserveClient;
+exports.HyperserveError = HyperserveError;
+exports.HyperserveNotFoundError = HyperserveNotFoundError;
+exports.HyperserveTimeoutError = HyperserveTimeoutError;
+exports.HyperserveUploadError = HyperserveUploadError;
+exports.HyperserveValidationError = HyperserveValidationError;
+exports.verifyWebhookSignature = verifyWebhookSignature;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map