@mountra/mountra-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,711 @@
+// src/upload.ts
+var JUMBO_CHUNK_THRESHOLD_BYTES = 128 * 1024 * 1024;
+var MIN_S3_MULTIPART_PART_SIZE_BYTES = 5 * 1024 * 1024;
+var DEFAULT_S3_MULTIPART_PART_SIZE_BYTES = 16 * 1024 * 1024;
+var MAX_S3_MULTIPART_PARTS = 1e4;
+var MountraApiError = class extends Error {
+  status;
+  code;
+  body;
+  constructor(message, input) {
+    super(message);
+    this.name = "MountraApiError";
+    this.status = input.status;
+    this.code = input.code;
+    this.body = input.body;
+  }
+};
+var memoryCheckpointRecords = /* @__PURE__ */ new Map();
+function parseJumboCheckpoint(value) {
+  if (!isRecord(value) || value.version !== 1 || typeof value.storageKey !== "string") {
+    return null;
+  }
+  if (typeof value.chunkIndex !== "number" || typeof value.chunkSize !== "number" || typeof value.chunkSha256 !== "string" || typeof value.partSize !== "number" || typeof value.uploadId !== "string" || !Array.isArray(value.parts)) {
+    return null;
+  }
+  const parts = [];
+  for (const part of value.parts) {
+    if (!isRecord(part)) {
+      return null;
+    }
+    if (typeof part.partNumber !== "number" || typeof part.etag !== "string" || typeof part.size !== "number" || typeof part.sha256 !== "string") {
+      return null;
+    }
+    parts.push({
+      partNumber: part.partNumber,
+      etag: part.etag,
+      size: part.size,
+      sha256: part.sha256
+    });
+  }
+  return {
+    version: 1,
+    storageKey: value.storageKey,
+    chunkIndex: value.chunkIndex,
+    chunkSize: value.chunkSize,
+    chunkSha256: value.chunkSha256,
+    partSize: value.partSize,
+    uploadId: value.uploadId,
+    completed: value.completed === true,
+    completing: value.completing === true,
+    parts
+  };
+}
+var InMemoryJumboChunkCheckpointStore = class {
+  records = /* @__PURE__ */ new Map();
+  async load(key) {
+    return this.records.get(key) ?? null;
+  }
+  async save(key, checkpoint) {
+    this.records.set(key, {
+      ...checkpoint,
+      parts: checkpoint.parts.map((part) => ({ ...part }))
+    });
+  }
+  async remove(key) {
+    this.records.delete(key);
+  }
+};
+var LocalStorageJumboChunkCheckpointStore = class {
+  prefix;
+  constructor(prefix = "mountra-sdk:jumbo:") {
+    this.prefix = prefix;
+  }
+  async load(key) {
+    const storageKey = this.storageKey(key);
+    const raw = this.getStorage()?.getItem(storageKey) ?? memoryCheckpointRecords.get(storageKey);
+    if (!raw) {
+      return null;
+    }
+    try {
+      return parseJumboCheckpoint(JSON.parse(raw));
+    } catch {
+      await this.remove(key);
+      return null;
+    }
+  }
+  async save(key, checkpoint) {
+    const storageKey = this.storageKey(key);
+    const serialized = JSON.stringify(checkpoint);
+    const storage = this.getStorage();
+    if (storage) {
+      storage.setItem(storageKey, serialized);
+    } else {
+      memoryCheckpointRecords.set(storageKey, serialized);
+    }
+  }
+  async remove(key) {
+    const storageKey = this.storageKey(key);
+    this.getStorage()?.removeItem(storageKey);
+    memoryCheckpointRecords.delete(storageKey);
+  }
+  storageKey(key) {
+    return `${this.prefix}${key}`;
+  }
+  getStorage() {
+    try {
+      return globalThis.localStorage ?? null;
+    } catch {
+      return null;
+    }
+  }
+};
+var S3MultipartUploader = class {
+  bucket;
+  client;
+  constructor(input) {
+    const bucket = input.bucket.trim();
+    if (!bucket) {
+      throw new TypeError("S3 bucket is required");
+    }
+    this.bucket = bucket;
+    this.client = input.client;
+  }
+  createMultipartUpload(input) {
+    return this.client.createMultipartUpload({
+      bucket: this.bucket,
+      key: input.storageKey,
+      contentType: input.contentType,
+      signal: input.signal
+    });
+  }
+  uploadPart(input) {
+    return this.client.uploadPart({
+      bucket: this.bucket,
+      key: input.storageKey,
+      uploadId: input.uploadId,
+      partNumber: input.partNumber,
+      body: input.body,
+      signal: input.signal
+    });
+  }
+  completeMultipartUpload(input) {
+    return this.client.completeMultipartUpload({
+      bucket: this.bucket,
+      key: input.storageKey,
+      uploadId: input.uploadId,
+      parts: input.parts,
+      signal: input.signal
+    });
+  }
+  abortMultipartUpload(input) {
+    if (!this.client.abortMultipartUpload) {
+      return Promise.resolve();
+    }
+    return this.client.abortMultipartUpload({
+      bucket: this.bucket,
+      key: input.storageKey,
+      uploadId: input.uploadId,
+      signal: input.signal
+    });
+  }
+};
+function assertPositiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new RangeError(`${name} must be a positive safe integer`);
+  }
+}
+function assertMultipartPartSize(value) {
+  assertPositiveInteger(value, "jumboPartSize");
+  if (value < MIN_S3_MULTIPART_PART_SIZE_BYTES) {
+    throw new RangeError(
+      `jumboPartSize must be at least ${MIN_S3_MULTIPART_PART_SIZE_BYTES} bytes for S3 Multipart uploads`
+    );
+  }
+}
+function normalizeBaseUrl(value) {
+  const trimmed = value.trim().replace(/\/+$/, "");
+  if (!trimmed) {
+    throw new TypeError("baseUrl is required");
+  }
+  return trimmed;
+}
+function normalizeApiPrefix(value) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "/") {
+    return "";
+  }
+  return `/${trimmed.replace(/^\/+|\/+$/g, "")}`;
+}
+function getWorkspaceBody(clientSelector, requestSelector) {
+  const workspaceCuid = requestSelector.workspaceCuid ?? clientSelector.workspaceCuid;
+  const workspaceId = requestSelector.workspaceId ?? clientSelector.workspaceId;
+  if (workspaceCuid === void 0 && workspaceId === void 0) {
+    throw new TypeError("workspaceCuid or workspaceId is required");
+  }
+  return {
+    ...workspaceCuid !== void 0 ? { workspace_cuid: workspaceCuid } : {},
+    ...workspaceId !== void 0 ? { workspace_id: workspaceId } : {}
+  };
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) {
+    return;
+  }
+  throw new DOMException("The upload was aborted", "AbortError");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseApiErrorBody(body) {
+  if (!isRecord(body)) {
+    return {};
+  }
+  return {
+    message: typeof body.error === "string" ? body.error : void 0,
+    code: typeof body.code === "string" ? body.code : void 0
+  };
+}
+function ensurePrepareResponse(value) {
+  if (!isRecord(value) || typeof value.upload_id !== "string") {
+    throw new TypeError("Mountra prepare response is invalid");
+  }
+  if (!Array.isArray(value.upload_targets)) {
+    throw new TypeError("Mountra prepare response has no upload targets");
+  }
+  return value;
+}
+function ensureFinishResponse(value) {
+  if (!isRecord(value) || typeof value.upload_id !== "string") {
+    throw new TypeError("Mountra finish response is invalid");
+  }
+  return value;
+}
+function ensureUploadStatusResponse(value) {
+  if (!isRecord(value) || typeof value.upload_id !== "string") {
+    throw new TypeError("Mountra upload status response is invalid");
+  }
+  if (!Array.isArray(value.chunks)) {
+    throw new TypeError("Mountra upload status response has no chunk states");
+  }
+  return value;
+}
+function splitFileIntoChunks(file, chunkCount = 1) {
+  assertPositiveInteger(chunkCount, "chunkCount");
+  if (file.size === 0) {
+    return [{ index: 0, offset: 0, size: 0, blob: file.slice(0, 0) }];
+  }
+  if (chunkCount > file.size) {
+    throw new RangeError("chunkCount cannot be greater than the file size in bytes");
+  }
+  const chunkSize = Math.ceil(file.size / chunkCount);
+  const chunks = [];
+  for (let index = 0; index < chunkCount; index += 1) {
+    const offset = index * chunkSize;
+    const end = Math.min(offset + chunkSize, file.size);
+    chunks.push({
+      index,
+      offset,
+      size: end - offset,
+      blob: file.slice(offset, end)
+    });
+  }
+  return chunks;
+}
+function isJumboChunk(size) {
+  return size > JUMBO_CHUNK_THRESHOLD_BYTES;
+}
+async function sha256Hex(blob) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error("Web Crypto SHA-256 is not available in this environment");
+  }
+  const digest = await subtle.digest("SHA-256", await blob.arrayBuffer());
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+var MountraClient = class {
+  baseUrl;
+  apiPrefix;
+  clientSelector;
+  token;
+  headers;
+  fetchImpl;
+  jumboChunkUploader;
+  jumboChunkCheckpointStore;
+  jumboPartSize;
+  constructor(options) {
+    this.baseUrl = normalizeBaseUrl(options.baseUrl);
+    this.apiPrefix = normalizeApiPrefix(options.apiPrefix ?? "/api");
+    this.clientSelector = {
+      workspaceCuid: options.workspaceCuid,
+      workspaceId: options.workspaceId
+    };
+    this.token = options.token;
+    this.headers = options.headers;
+    this.jumboChunkUploader = options.jumboChunkUploader;
+    this.jumboChunkCheckpointStore = options.jumboChunkCheckpointStore ?? new LocalStorageJumboChunkCheckpointStore();
+    this.jumboPartSize = options.jumboPartSize ?? DEFAULT_S3_MULTIPART_PART_SIZE_BYTES;
+    assertMultipartPartSize(this.jumboPartSize);
+    const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!fetchImpl) {
+      throw new Error("fetch is not available; provide fetch in MountraClientOptions");
+    }
+    this.fetchImpl = fetchImpl;
+  }
+  async prepareUpload(file, options) {
+    const chunks = splitFileIntoChunks(file, options.chunkCount ?? 1);
+    const chunkHashes = await Promise.all(chunks.map((chunk) => sha256Hex(chunk.blob)));
+    const contentHash = await sha256Hex(file);
+    const chunkMethod = chunks.length === 1 ? "none" : "fix";
+    const contentType = options.contentType ?? ("type" in file ? file.type : void 0);
+    throwIfAborted(options.signal);
+    const response = ensurePrepareResponse(
+      await this.requestJson("/upload/prepare", {
+        ...getWorkspaceBody(this.clientSelector, options),
+        path: options.path,
+        size: file.size,
+        content_hash: contentHash,
+        chunks: chunks.map((chunk, index) => ({
+          chunk_index: chunk.index,
+          size: chunk.size,
+          sha256: chunkHashes[index]
+        })),
+        chunk_method: chunkMethod,
+        ...contentType ? { content_type: contentType } : {},
+        ...options.nameConflictStrategy ? { name_conflict_strategy: options.nameConflictStrategy } : {}
+      }, options.signal)
+    );
+    const context = {
+      uploadId: response.upload_id,
+      path: response.path,
+      fileSize: file.size,
+      contentHash,
+      chunkMethod: response.chunk_method,
+      chunks: chunks.map((chunk, index) => ({
+        index: chunk.index,
+        offset: chunk.offset,
+        size: chunk.size,
+        sha256: chunkHashes[index]
+      })),
+      ...contentType ? { contentType } : {}
+    };
+    await options.onSessionPrepared?.(context);
+    return { response, chunks, chunkHashes, contentHash, context };
+  }
+  async uploadFile(file, options) {
+    const prepared = await this.prepareUpload(file, options);
+    return this.uploadPreparedChunks(file, prepared.context, prepared.chunks, prepared.response.upload_targets, options);
+  }
+  /** Generic upload entry point. It selects PUT or S3 Multipart per chunk. */
+  async upload(file, options) {
+    return this.uploadFile(file, options);
+  }
+  async getUploadStatus(uploadId, selector = {}, signal) {
+    if (!uploadId.trim()) {
+      throw new TypeError("uploadId is required");
+    }
+    return ensureUploadStatusResponse(
+      await this.requestJson("/upload/status", {
+        ...getWorkspaceBody(this.clientSelector, selector),
+        upload_id: uploadId
+      }, signal)
+    );
+  }
+  /**
+   * Resume a previously prepared session. The caller must restore the same
+   * file/blob separately; this context only describes how that file was cut.
+   */
+  async resumeUpload(file, context, options = {}) {
+    this.assertUploadContext(context, file);
+    const actualChunkHashes = await Promise.all(
+      context.chunks.map((chunk) => sha256Hex(file.slice(chunk.offset, chunk.offset + chunk.size)))
+    );
+    if (actualChunkHashes.some(
+      (hash, index) => hash !== context.chunks[index]?.sha256
+    ) || await sha256Hex(file) !== context.contentHash) {
+      throw new Error("The restored file does not match the upload context hashes");
+    }
+    const chunks = context.chunks.map((chunk) => ({
+      index: chunk.index,
+      offset: chunk.offset,
+      size: chunk.size,
+      blob: file.slice(chunk.offset, chunk.offset + chunk.size)
+    }));
+    const status = await this.getUploadStatus(context.uploadId, options, options.signal);
+    if (status.upload_id !== context.uploadId || status.size !== context.fileSize) {
+      throw new Error("Mountra upload status does not match the saved upload context");
+    }
+    if (status.chunks.length !== context.chunks.length) {
+      throw new Error("Mountra upload status has a different chunk layout");
+    }
+    for (const [index, chunk] of status.chunks.entries()) {
+      const savedChunk = context.chunks[index];
+      if (chunk.chunk_index !== savedChunk.index || chunk.offset !== savedChunk.offset || chunk.size !== savedChunk.size || chunk.sha256 !== savedChunk.sha256) {
+        throw new Error("Mountra upload status has a different chunk layout");
+      }
+    }
+    return this.uploadPreparedChunks(file, context, chunks, status.chunks, options);
+  }
+  async uploadPreparedChunks(file, context, chunks, targets, options) {
+    const orderedTargets = [...targets].sort((left, right) => left.chunk_index - right.chunk_index);
+    if (orderedTargets.length !== chunks.length) {
+      throw new Error(
+        `Mountra returned ${orderedTargets.length} upload targets for ${chunks.length} chunks`
+      );
+    }
+    let uploadedBytes = 0;
+    let uploadedChunks = 0;
+    const jumboCheckpointKeys = /* @__PURE__ */ new Set();
+    for (const [position, target] of orderedTargets.entries()) {
+      const chunk = chunks[target.chunk_index];
+      if (!chunk || target.chunk_index !== position) {
+        throw new Error("Mountra upload targets must contain contiguous chunk indexes");
+      }
+      throwIfAborted(options.signal);
+      if (isJumboChunk(chunk.size)) {
+        const checkpointKey = this.buildJumboCheckpointKey(context, target, options);
+        jumboCheckpointKeys.add(checkpointKey);
+        if (target.upload_required) {
+          await this.uploadJumboChunk(
+            chunk,
+            target,
+            context,
+            checkpointKey,
+            options,
+            uploadedBytes,
+            uploadedChunks,
+            orderedTargets.length
+          );
+        }
+      } else if (target.upload_required) {
+        if (!target.put_url) {
+          throw new Error(`Mountra upload target ${target.chunk_index} has no signed URL`);
+        }
+        const response = await this.fetchImpl(target.put_url, {
+          method: target.put_method ?? "PUT",
+          headers: target.put_headers ?? {},
+          body: chunk.blob,
+          ...options.signal ? { signal: options.signal } : {}
+        });
+        if (!response.ok) {
+          throw new MountraApiError(
+            `Signed upload for chunk ${target.chunk_index} failed with HTTP ${response.status}`,
+            { status: response.status }
+          );
+        }
+      }
+      uploadedBytes += chunk.size;
+      uploadedChunks += 1;
+      options.onProgress?.({
+        phase: "uploading",
+        uploadedBytes,
+        totalBytes: file.size,
+        uploadedChunks,
+        totalChunks: orderedTargets.length
+      });
+    }
+    throwIfAborted(options.signal);
+    options.onProgress?.({
+      phase: "finishing",
+      uploadedBytes: file.size,
+      totalBytes: file.size,
+      uploadedChunks: orderedTargets.length,
+      totalChunks: orderedTargets.length
+    });
+    const finished = ensureFinishResponse(
+      await this.requestJson(
+        "/upload/finish",
+        {
+          ...getWorkspaceBody(this.clientSelector, options),
+          upload_id: context.uploadId
+        },
+        options.signal
+      )
+    );
+    if (finished.finish_status !== "completed") {
+      throw new Error(`Mountra upload did not finish successfully: ${finished.finish_status}`);
+    }
+    await Promise.all(
+      [...jumboCheckpointKeys].map(
+        (checkpointKey) => this.jumboChunkCheckpointStore.remove(checkpointKey)
+      )
+    );
+    return finished;
+  }
+  buildJumboCheckpointKey(context, target, selector) {
+    const workspaceCuid = selector.workspaceCuid ?? this.clientSelector.workspaceCuid ?? "";
+    const workspaceId = selector.workspaceId ?? this.clientSelector.workspaceId ?? "";
+    return encodeURIComponent(
+      [
+        this.baseUrl,
+        workspaceCuid,
+        workspaceId,
+        target.storage_key,
+        target.chunk_index,
+        context.chunks[target.chunk_index]?.sha256 ?? ""
+      ].join("|")
+    );
+  }
+  async uploadJumboChunk(chunk, target, context, checkpointKey, options, baseUploadedBytes, uploadedChunks, totalChunks) {
+    const uploader = this.jumboChunkUploader;
+    if (!uploader) {
+      throw new Error(
+        `Chunk ${target.chunk_index} is larger than 128 MiB; configure jumboChunkUploader to use S3 Multipart uploads`
+      );
+    }
+    const totalParts = Math.ceil(chunk.size / this.jumboPartSize);
+    if (totalParts > MAX_S3_MULTIPART_PARTS) {
+      throw new RangeError(
+        `Jumbo chunk requires ${totalParts} parts, exceeding S3's ${MAX_S3_MULTIPART_PARTS}-part limit`
+      );
+    }
+    let checkpoint = await this.jumboChunkCheckpointStore.load(checkpointKey);
+    if (checkpoint && !this.isCompatibleJumboCheckpoint(checkpoint, chunk, target, context)) {
+      await this.jumboChunkCheckpointStore.remove(checkpointKey);
+      checkpoint = null;
+    }
+    if (!checkpoint) {
+      const created = await uploader.createMultipartUpload({
+        storageKey: target.storage_key,
+        contentType: context.contentType,
+        signal: options.signal
+      });
+      if (!created.uploadId.trim()) {
+        throw new Error(`S3 Multipart create returned no upload id for chunk ${target.chunk_index}`);
+      }
+      checkpoint = {
+        version: 1,
+        storageKey: target.storage_key,
+        chunkIndex: target.chunk_index,
+        chunkSize: chunk.size,
+        chunkSha256: context.chunks[target.chunk_index]?.sha256 ?? "",
+        partSize: this.jumboPartSize,
+        uploadId: created.uploadId,
+        completed: false,
+        completing: false,
+        parts: []
+      };
+      await this.jumboChunkCheckpointStore.save(checkpointKey, checkpoint);
+    }
+    if (checkpoint.completed) {
+      return;
+    }
+    if (checkpoint.completing) {
+      const status = await this.getUploadStatus(context.uploadId, options, options.signal);
+      const statusChunk = status.chunks.find(
+        (candidate) => candidate.chunk_index === target.chunk_index
+      );
+      if (statusChunk?.status === "uploaded") {
+        checkpoint.completed = true;
+        checkpoint.completing = false;
+        await this.jumboChunkCheckpointStore.save(checkpointKey, checkpoint);
+        return;
+      }
+      checkpoint.completing = false;
+      await this.jumboChunkCheckpointStore.save(checkpointKey, checkpoint);
+    }
+    const parts = new Map(checkpoint.parts.map((part) => [part.partNumber, part]));
+    let uploadedBytes = 0;
+    let uploadedParts = 0;
+    for (let partNumber = 1; partNumber <= totalParts; partNumber += 1) {
+      throwIfAborted(options.signal);
+      const start = (partNumber - 1) * this.jumboPartSize;
+      const partBlob = chunk.blob.slice(start, Math.min(start + this.jumboPartSize, chunk.size));
+      const partHash = await sha256Hex(partBlob);
+      const savedPart = parts.get(partNumber);
+      const part = savedPart && savedPart.size === partBlob.size && savedPart.sha256 === partHash && savedPart.etag ? savedPart : await this.uploadJumboPart(
+        uploader,
+        target.storage_key,
+        checkpoint.uploadId,
+        partNumber,
+        partBlob,
+        partHash,
+        options.signal
+      );
+      parts.set(partNumber, part);
+      checkpoint.parts = [...parts.values()].sort(
+        (left, right) => left.partNumber - right.partNumber
+      );
+      await this.jumboChunkCheckpointStore.save(checkpointKey, checkpoint);
+      uploadedBytes += partBlob.size;
+      uploadedParts += 1;
+      options.onProgress?.({
+        phase: "uploading",
+        uploadedBytes: baseUploadedBytes + uploadedBytes,
+        totalBytes: context.fileSize,
+        uploadedChunks,
+        totalChunks,
+        uploadedParts,
+        totalParts
+      });
+    }
+    checkpoint.completing = true;
+    await this.jumboChunkCheckpointStore.save(checkpointKey, checkpoint);
+    try {
+      await uploader.completeMultipartUpload({
+        storageKey: target.storage_key,
+        uploadId: checkpoint.uploadId,
+        parts: checkpoint.parts.map(({ partNumber, etag }) => ({ partNumber, etag })),
+        signal: options.signal
+      });
+    } catch (error) {
+      checkpoint.completing = false;
+      await this.jumboChunkCheckpointStore.save(checkpointKey, checkpoint);
+      throw error;
+    }
+    checkpoint.completed = true;
+    checkpoint.completing = false;
+    await this.jumboChunkCheckpointStore.save(checkpointKey, checkpoint);
+  }
+  async uploadJumboPart(uploader, storageKey, uploadId, partNumber, body, sha256, signal) {
+    const result = await uploader.uploadPart({
+      storageKey,
+      uploadId,
+      partNumber,
+      body,
+      signal
+    });
+    if (!result.etag.trim()) {
+      throw new Error(`S3 Multipart upload returned no ETag for part ${partNumber}`);
+    }
+    return {
+      partNumber,
+      etag: result.etag,
+      size: body.size,
+      sha256
+    };
+  }
+  isCompatibleJumboCheckpoint(checkpoint, chunk, target, context) {
+    return checkpoint.version === 1 && checkpoint.storageKey === target.storage_key && checkpoint.chunkIndex === target.chunk_index && checkpoint.chunkSize === chunk.size && checkpoint.chunkSha256 === (context.chunks[target.chunk_index]?.sha256 ?? "") && checkpoint.partSize === this.jumboPartSize && checkpoint.uploadId.trim().length > 0;
+  }
+  assertUploadContext(context, file) {
+    if (!context.uploadId.trim()) {
+      throw new TypeError("upload context uploadId is required");
+    }
+    if (context.fileSize !== file.size) {
+      throw new Error("The restored file does not match the upload context size");
+    }
+    if (!Array.isArray(context.chunks) || context.chunks.length === 0) {
+      throw new TypeError("upload context must contain chunks");
+    }
+    let expectedOffset = 0;
+    for (const [index, chunk] of context.chunks.entries()) {
+      if (chunk.index !== index || chunk.offset !== expectedOffset || chunk.offset < 0 || chunk.size < 0 || chunk.offset + chunk.size > file.size || typeof chunk.sha256 !== "string") {
+        throw new TypeError("upload context contains an invalid chunk layout");
+      }
+      expectedOffset += chunk.size;
+    }
+  }
+  async finishUpload(uploadId, selector = {}) {
+    if (!uploadId.trim()) {
+      throw new TypeError("uploadId is required");
+    }
+    return ensureFinishResponse(
+      await this.requestJson("/upload/finish", {
+        ...getWorkspaceBody(this.clientSelector, selector),
+        upload_id: uploadId
+      })
+    );
+  }
+  endpoint(path) {
+    return `${this.baseUrl}${this.apiPrefix}${path}`;
+  }
+  async requestJson(path, body, signal) {
+    const headers = new Headers(this.headers);
+    headers.set("Content-Type", "application/json");
+    const token = typeof this.token === "function" ? await this.token() : this.token;
+    if (token) {
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    const response = await this.fetchImpl(this.endpoint(path), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      ...signal ? { signal } : {}
+    });
+    let responseBody;
+    try {
+      responseBody = await response.json();
+    } catch {
+      responseBody = void 0;
+    }
+    if (!response.ok) {
+      const error = parseApiErrorBody(responseBody);
+      throw new MountraApiError(
+        error.message ?? `Mountra API request failed with HTTP ${response.status}`,
+        { status: response.status, code: error.code, body: responseBody }
+      );
+    }
+    return responseBody;
+  }
+};
+function createMountraClient(options) {
+  return new MountraClient(options);
+}
+export {
+  DEFAULT_S3_MULTIPART_PART_SIZE_BYTES,
+  InMemoryJumboChunkCheckpointStore,
+  JUMBO_CHUNK_THRESHOLD_BYTES,
+  LocalStorageJumboChunkCheckpointStore,
+  MAX_S3_MULTIPART_PARTS,
+  MIN_S3_MULTIPART_PART_SIZE_BYTES,
+  MountraApiError,
+  MountraClient,
+  MountraClient as MountraSDK,
+  S3MultipartUploader,
+  createMountraClient,
+  isJumboChunk,
+  sha256Hex,
+  splitFileIntoChunks
+};
+//# sourceMappingURL=index.js.map