@ozdao/martyrs 0.2.550 → 0.2.552

package/dist/music.server.cjs

@@ -1,2114 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const core_abac = require("./core.abac-DqDvtkHR.cjs");
-const core_logger = require("./core.logger-BuW7JHMY.cjs");
-const crud = require("./crud-CQ3ICbm7.cjs");
-const abac = require("./abac-gNSxNkX1.cjs");
-const core_verifier = require("./core.verifier-Bi-XLEi9.cjs");
-const fs$1 = require("fs");
-const path$1 = require("path");
-const common_schema = require("./common.schema-BtXLULba.cjs");
-const engagement_schema = require("./engagement.schema-DHw4iY_W.cjs");
-const metadata_schema = require("./metadata.schema-BGykn-_r.cjs");
-const ownership_schema = require("./ownership.schema-CRYdbemm.cjs");
-const socials_schema = require("./socials.schema-CqEHax2w.cjs");
-function tracksVerifierFactory(db) {
-  const createVerifier = new core_verifier.Verifier({
-    title: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Track title is required").min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
-    },
-    artist: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Artist is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
-    },
-    album: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
-    },
-    fileUrl: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("File URL is required").pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
-    },
-    coverUrl: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
-    },
-    duration: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().number().min(0, "Duration cannot be negative").max(3600, "Duration cannot exceed 1 hour")
-    },
-    genre: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-      )
-    },
-    releaseDate: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().date()
-    },
-    isExplicit: {
-      rule: "optional",
-      default: false,
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    lyrics: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(1e4, "Lyrics too long")
-    },
-    isPublic: {
-      rule: "optional",
-      default: true,
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    owner: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["user", "organization"]),
-        target: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-      })
-    }
-  });
-  const updateVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Track ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format")
-    },
-    title: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
-    },
-    artist: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
-    },
-    album: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
-    },
-    fileUrl: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
-    },
-    coverUrl: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
-    },
-    // duration: {
-    //   rule: 'optional',
-    //   validator: Validator.schema()
-    //     .number()
-    //     .min(0, 'Duration cannot be negative')
-    //     .max(3600, 'Duration cannot exceed 1 hour')
-    // },
-    genre: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-      )
-    },
-    releaseDate: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().date()
-    },
-    isExplicit: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    lyrics: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(1e4, "Lyrics too long")
-    },
-    isPublic: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
-    }
-  });
-  const readVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format")
-    },
-    artist: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
-    },
-    album: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
-    },
-    genre: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-    },
-    isPublic: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
-    },
-    skip: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().integer().min(0)
-    },
-    limit: {
-      rule: "optional",
-      default: 20,
-      validator: core_verifier.Validator.schema().integer().min(1).max(100)
-    },
-    sortParam: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["title", "playCount", "releaseDate", "createdAt", "updatedAt"])
-    },
-    sortOrder: {
-      rule: "optional",
-      default: "desc",
-      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
-    }
-  });
-  const deleteVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Track ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format")
-    }
-  });
-  return {
-    createVerifier,
-    readVerifier,
-    updateVerifier,
-    deleteVerifier
-  };
-}
-const { getInstance: getInstance$4 } = abac.ABAC;
-function setupTracksRoutes(app, db) {
-  const abac2 = getInstance$4(db);
-  const verifier = tracksVerifierFactory();
-  const tracksCRUD = new crud.CRUD({
-    app,
-    db,
-    model: db.track,
-    modelName: "track",
-    basePath: "/api/tracks",
-    auth: { read: false },
-    verifiers: {
-      create: verifier.createVerifier,
-      read: verifier.readVerifier,
-      update: verifier.updateVerifier,
-      delete: verifier.deleteVerifier
-    },
-    abac: abac2,
-    policies: {
-      read: { enabled: false }
-    },
-    cache: {
-      enabled: true,
-      ttl: 300,
-      tags: ["tracks", "music"]
-    },
-    events: {
-      enabled: true,
-      logReads: false
-    }
-  });
-  tracksCRUD.policies.disableForAction("get-by-url");
-  tracksCRUD.policies.disableForAction("recent");
-  tracksCRUD.policies.disableForAction("popular");
-  tracksCRUD.policies.disableForAction("by-genre");
-  tracksCRUD.addAction("get-by-url", {
-    method: "get",
-    path: "/url/:url",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const track = await db.track.findOne({ url: req.params.url }).populate("artist", "name url photoUrl isVerified").populate("album", "title url coverArt").populate("genre", "name url");
-        if (!track) {
-          return res.status(404).json({ error: "Track not found" });
-        }
-        const accessResult = await abac2.checkAccess({
-          user: req.userId,
-          resource: "tracks",
-          action: "read",
-          currentResource: track
-        });
-        if (!accessResult.allowed && !track.isPublic) {
-          return res.status(403).json({
-            errorCode: accessResult.reason,
-            message: "Access Denied"
-          });
-        }
-        res.json(track);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  tracksCRUD.addAction("recent", {
-    method: "get",
-    path: "/recent",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const limit = parseInt(req.query.limit) || 10;
-        const recentTracks = await db.track.find({
-          status: "published",
-          isPublic: true
-        }).populate("artist", "name url photoUrl isVerified").populate("album", "title url coverArt").sort({ createdAt: -1 }).limit(limit);
-        res.json(recentTracks);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  tracksCRUD.addAction("popular", {
-    method: "get",
-    path: "/popular",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const limit = parseInt(req.query.limit) || 10;
-        const popularTracks = await db.track.find({
-          status: "published",
-          isPublic: true
-        }).populate("artist", "name url photoUrl isVerified").populate("album", "title url coverArt").sort({ playCount: -1 }).limit(limit);
-        res.json(popularTracks);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  tracksCRUD.addAction("by-genre", {
-    method: "get",
-    path: "/genre/:genreId",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const tracks = await db.track.find({
-          genre: req.params.genreId,
-          status: "published",
-          isPublic: true
-        }).populate("artist", "name url photoUrl isVerified").populate("album", "title url coverArt").sort({ releaseDate: -1 });
-        res.json(tracks);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  return tracksCRUD;
-}
-function artistsVerifierFactory(db) {
-  const createVerifier = new core_verifier.Verifier({
-    name: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Artist name is required").min(1, "Name cannot be empty").max(100, "Name must not exceed 100 characters")
-    },
-    bio: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(2e3, "Bio must not exceed 2000 characters")
-    },
-    photoUrl: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
-    },
-    coverUrl: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
-    },
-    genre: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-      )
-    },
-    website: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid website URL format")
-    },
-    location: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(100, "Location must not exceed 100 characters")
-    },
-    owner: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["user", "organization"]),
-        target: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-      })
-    }
-  });
-  const updateVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Artist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
-    },
-    name: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().min(1, "Name cannot be empty").max(100, "Name must not exceed 100 characters")
-    },
-    bio: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(2e3, "Bio must not exceed 2000 characters")
-    },
-    photoUrl: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
-    },
-    coverUrl: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
-    },
-    genre: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-      )
-    },
-    website: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid website URL format")
-    },
-    location: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(100, "Location must not exceed 100 characters")
-    },
-    isVerified: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
-    }
-  });
-  const readVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
-    },
-    genre: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-    },
-    isVerified: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
-    },
-    location: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string()
-    },
-    skip: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().integer().min(0)
-    },
-    limit: {
-      rule: "optional",
-      default: 20,
-      validator: core_verifier.Validator.schema().integer().min(1).max(100)
-    },
-    sortParam: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["name", "popularity", "createdAt", "updatedAt"])
-    },
-    sortOrder: {
-      rule: "optional",
-      default: "desc",
-      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
-    }
-  });
-  const deleteVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Artist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
-    }
-  });
-  return {
-    createVerifier,
-    readVerifier,
-    updateVerifier,
-    deleteVerifier
-  };
-}
-const { getInstance: getInstance$3 } = abac.ABAC;
-function setupArtistsRoutes(app, db) {
-  const abac2 = getInstance$3(db);
-  const verifier = artistsVerifierFactory();
-  const artistsCRUD = new crud.CRUD({
-    app,
-    db,
-    model: db.artist,
-    modelName: "artist",
-    basePath: "/api/artists",
-    auth: { read: false },
-    verifiers: {
-      create: verifier.createVerifier,
-      read: verifier.readVerifier,
-      update: verifier.updateVerifier,
-      delete: verifier.deleteVerifier
-    },
-    abac: abac2,
-    policies: {
-      read: { enabled: false }
-    },
-    cache: {
-      enabled: true,
-      ttl: 300,
-      tags: ["artists", "music"]
-    },
-    events: {
-      enabled: true,
-      logReads: false
-    }
-  });
-  artistsCRUD.addAction("get-by-url", {
-    method: "get",
-    path: "/url/:url",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const artist = await db.artist.findOne({ url: req.params.url });
-        if (!artist) {
-          return res.status(404).json({ error: "Artist not found" });
-        }
-        res.json(artist);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  artistsCRUD.addAction("discography", {
-    method: "get",
-    path: "/:artistId/discography",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const { artistId } = req.params;
-        const albums = await db.album.find({ artists: artistId }).populate("artists", "name").sort({ releaseDate: -1 });
-        const tracks = await db.track.find({
-          artist: artistId,
-          status: "published",
-          isPublic: true
-        }).populate("album", "title url coverArt").populate("genre", "name").sort({ playCount: -1 }).limit(10);
-        res.json({
-          albums,
-          tracks,
-          singles: tracks.filter((track) => !track.album),
-          // треки без альбома считаем синглами
-          artist: artistId
-        });
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  artistsCRUD.addAction("verify-artist", {
-    method: "put",
-    path: "/:artistId/verify",
-    auth: true,
-    abac: {
-      resource: "artists",
-      action: "verify",
-      strict: true
-    },
-    handler: async (req, res) => {
-      try {
-        const { artistId } = req.params;
-        const artist = await db.artist.findByIdAndUpdate(
-          artistId,
-          { isVerified: true },
-          { new: true }
-        );
-        if (!artist) {
-          return res.status(404).json({ error: "Artist not found" });
-        }
-        res.json({
-          message: "Artist verified successfully",
-          artist
-        });
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  artistsCRUD.addAction("related-artists", {
-    method: "get",
-    path: "/:artistId/related",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const { artistId } = req.params;
-        const limit = parseInt(req.query.limit) || 10;
-        const artist = await db.artist.findById(artistId);
-        if (!artist) {
-          return res.status(404).json({ error: "Artist not found" });
-        }
-        const relatedArtists = await db.artist.find({
-          _id: { $ne: artistId },
-          // исключаем самого артиста
-          genre: { $in: artist.genre },
-          // общие жанры
-          status: "published"
-        }).limit(limit).sort({ popularity: -1 });
-        res.json(relatedArtists);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  return artistsCRUD;
-}
-function albumsVerifierFactory(db) {
-  const createVerifier = new core_verifier.Verifier({
-    title: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Album title is required").min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
-    },
-    description: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
-    },
-    releaseDate: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().date().required("Release date is required")
-    },
-    coverArt: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
-    },
-    artists: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
-      ).min(1, "At least one artist is required")
-    },
-    type: {
-      rule: "optional",
-      default: "album",
-      validator: core_verifier.Validator.schema().string().oneOf(["album", "single", "EP", "compilation"], "Invalid album type")
-    },
-    genres: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-      )
-    },
-    totalTracks: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().integer().min(0, "Total tracks cannot be negative").max(100, "Too many tracks")
-    },
-    owner: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["user", "organization"]),
-        target: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-      })
-    }
-  });
-  const updateVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Album ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
-    },
-    title: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
-    },
-    description: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
-    },
-    releaseDate: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().date()
-    },
-    coverArt: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
-    },
-    artists: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
-      ).min(1, "At least one artist is required")
-    },
-    type: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["album", "single", "EP", "compilation"], "Invalid album type")
-    },
-    genres: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-      )
-    },
-    totalTracks: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().integer().min(0, "Total tracks cannot be negative").max(100, "Too many tracks")
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
-    }
-  });
-  const readVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
-    },
-    artists: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
-    },
-    type: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["album", "single", "EP", "compilation"])
-    },
-    genres: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
-    },
-    skip: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().integer().min(0)
-    },
-    limit: {
-      rule: "optional",
-      default: 20,
-      validator: core_verifier.Validator.schema().integer().min(1).max(100)
-    },
-    sortParam: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["title", "releaseDate", "totalTracks", "createdAt", "updatedAt"])
-    },
-    sortOrder: {
-      rule: "optional",
-      default: "desc",
-      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
-    }
-  });
-  const deleteVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Album ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
-    }
-  });
-  return {
-    createVerifier,
-    readVerifier,
-    updateVerifier,
-    deleteVerifier
-  };
-}
-const { getInstance: getInstance$2 } = abac.ABAC;
-function setupAlbumsRoutes(app, db) {
-  const abac2 = getInstance$2(db);
-  const verifier = albumsVerifierFactory();
-  const albumsCRUD = new crud.CRUD({
-    app,
-    db,
-    model: db.album,
-    modelName: "album",
-    basePath: "/api/albums",
-    auth: { read: false },
-    verifiers: {
-      create: verifier.createVerifier,
-      read: verifier.readVerifier,
-      update: verifier.updateVerifier,
-      delete: verifier.deleteVerifier
-    },
-    abac: abac2,
-    policies: {
-      read: { enabled: false }
-    },
-    cache: {
-      enabled: true,
-      ttl: 300,
-      tags: ["albums", "music"]
-    },
-    events: {
-      enabled: true,
-      logReads: false
-    }
-  });
-  albumsCRUD.addAction("get-by-url", {
-    method: "get",
-    path: "/url/:url",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const album = await db.album.findOne({ url: req.params.url }).populate("artists", "name url photoUrl isVerified");
-        if (!album) {
-          return res.status(404).json({ error: "Album not found" });
-        }
-        const trackCount = await db.track.countDocuments({
-          album: album._id,
-          status: "published"
-        });
-        if (album.totalTracks !== trackCount) {
-          album.totalTracks = trackCount;
-          await album.save();
-        }
-        res.json(album);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  albumsCRUD.addAction("album-tracks", {
-    method: "get",
-    path: "/:albumId/tracks",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const { albumId } = req.params;
-        const tracks = await db.track.find({
-          album: albumId,
-          status: "published",
-          isPublic: true
-        }).populate("artist", "name url photoUrl isVerified").populate("album", "title url coverArt").populate("genre", "name url").sort({ trackNumber: 1, createdAt: 1 });
-        res.json(tracks);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  albumsCRUD.addAction("featured", {
-    method: "get",
-    path: "/featured",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const limit = parseInt(req.query.limit) || 10;
-        const featuredAlbums = await db.album.find({
-          status: "published",
-          releaseDate: {
-            $gte: new Date(Date.now() - 90 * 24 * 60 * 60 * 1e3)
-            // последние 90 дней
-          }
-        }).populate("artists", "name url photoUrl isVerified").sort({ createdAt: -1 }).limit(limit);
-        for (const album of featuredAlbums) {
-          const trackCount = await db.track.countDocuments({
-            album: album._id,
-            status: "published"
-          });
-          if (album.totalTracks !== trackCount) {
-            album.totalTracks = trackCount;
-            await album.save();
-          }
-        }
-        res.json(featuredAlbums);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  return albumsCRUD;
-}
-function playlistsVerifierFactory(db) {
-  const createVerifier = new core_verifier.Verifier({
-    title: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Playlist title is required").min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
-    },
-    description: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
-    },
-    coverUrl: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
-    },
-    tracks: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().object({
-          track: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format").required(),
-          addedAt: core_verifier.Validator.schema().date()
-        })
-      )
-    },
-    isPublic: {
-      rule: "optional",
-      default: true,
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    isCollaborative: {
-      rule: "optional",
-      default: false,
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    collaborators: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid collaborator ID format")
-      )
-    },
-    owner: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["user", "organization"]),
-        target: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-      })
-    }
-  });
-  const updateVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Playlist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid playlist ID format")
-    },
-    title: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
-    },
-    description: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
-    },
-    coverUrl: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid cover URL format")
-    },
-    tracks: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().object({
-          track: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format").required(),
-          addedAt: core_verifier.Validator.schema().date()
-        })
-      )
-    },
-    isPublic: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    isCollaborative: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    collaborators: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid collaborator ID format")
-      )
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
-    }
-  });
-  const readVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid playlist ID format")
-    },
-    owner: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid owner ID format")
-    },
-    isPublic: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    isCollaborative: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived", "featured"])
-    },
-    skip: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().integer().min(0)
-    },
-    limit: {
-      rule: "optional",
-      default: 20,
-      validator: core_verifier.Validator.schema().integer().min(1).max(100)
-    },
-    sortParam: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["title", "followers", "createdAt", "updatedAt"])
-    },
-    sortOrder: {
-      rule: "optional",
-      default: "desc",
-      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
-    }
-  });
-  const deleteVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Playlist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid playlist ID format")
-    }
-  });
-  return {
-    createVerifier,
-    readVerifier,
-    updateVerifier,
-    deleteVerifier
-  };
-}
-const { getInstance: getInstance$1 } = abac.ABAC;
-function setupPlaylistsRoutes(app, db) {
-  const abac2 = getInstance$1(db);
-  const verifier = playlistsVerifierFactory();
-  const playlistsCRUD = new crud.CRUD({
-    app,
-    db,
-    model: db.playlist,
-    modelName: "playlist",
-    basePath: "/api/playlists",
-    auth: { read: false },
-    verifiers: {
-      create: verifier.createVerifier,
-      read: verifier.readVerifier,
-      update: verifier.updateVerifier,
-      delete: verifier.deleteVerifier
-    },
-    abac: abac2,
-    policies: {
-      read: { enabled: false }
-    },
-    cache: {
-      enabled: true,
-      ttl: 300,
-      tags: ["playlists", "music"]
-    },
-    events: {
-      enabled: true,
-      logReads: false
-    }
-  });
-  playlistsCRUD.addAction("get-by-url", {
-    method: "get",
-    path: "/url/:url",
-    auth: false,
-    abac: { enabled: false },
-    handler: async (req, res) => {
-      try {
-        const playlist = await db.playlist.findOne({ url: req.params.url }).populate({
-          path: "tracks.track",
-          select: "-lyrics",
-          populate: [
-            {
-              path: "artist",
-              select: "name url photoUrl isVerified"
-            },
-            {
-              path: "album",
-              select: "title url coverArt"
-            },
-            {
-              path: "genre",
-              select: "name url"
-            }
-          ]
-        });
-        if (!playlist) {
-          return res.status(404).json({ error: "Playlist not found" });
-        }
-        if (!playlist.isPublic && !req.userId) {
-          return res.status(404).json({ error: "Playlist not found" });
-        }
-        if (!playlist.isPublic && req.userId) {
-          const isOwner = playlist.owner.target.toString() === req.userId;
-          const isCollaborator = playlist.collaborators.some((collab) => collab.toString() === req.userId);
-          if (!isOwner && !isCollaborator) {
-            return res.status(404).json({ error: "Playlist not found" });
-          }
-        }
-        res.json(playlist);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  playlistsCRUD.addAction("user-playlists", {
-    method: "get",
-    path: "/user/:userId?",
-    auth: true,
-    handler: async (req, res) => {
-      try {
-        const userId = req.params.userId || req.userId;
-        const query = { "owner.target": userId };
-        if (userId !== req.userId) {
-          query.isPublic = true;
-        }
-        const playlists = await db.playlist.find(query).populate({
-          path: "tracks.track",
-          select: "title artist album genre duration",
-          populate: [
-            {
-              path: "artist",
-              select: "name url photoUrl isVerified"
-            },
-            {
-              path: "album",
-              select: "title url coverArt"
-            }
-          ]
-        }).sort({ updatedAt: -1 });
-        res.json(playlists);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  playlistsCRUD.addAction("add-track", {
-    method: "post",
-    path: "/:playlistId/tracks/:trackId",
-    auth: true,
-    abac: {
-      resource: "playlists",
-      action: "update"
-    },
-    handler: async (req, res) => {
-      try {
-        const { playlistId, trackId } = req.params;
-        const track = await db.track.findById(trackId);
-        if (!track) {
-          return res.status(404).json({ error: "Track not found" });
-        }
-        const playlist = await db.playlist.findById(playlistId);
-        if (!playlist) {
-          return res.status(404).json({ error: "Playlist not found" });
-        }
-        const trackExists = playlist.tracks.some((t) => t.track.toString() === trackId);
-        if (trackExists) {
-          return res.status(400).json({ error: "Track already in playlist" });
-        }
-        playlist.tracks.push({
-          track: trackId,
-          addedAt: /* @__PURE__ */ new Date()
-        });
-        await playlist.save();
-        res.json({
-          message: "Track added to playlist successfully",
-          playlist
-        });
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  playlistsCRUD.addAction("remove-track", {
-    method: "delete",
-    path: "/:playlistId/tracks/:trackId",
-    auth: true,
-    abac: {
-      resource: "playlists",
-      action: "update"
-    },
-    handler: async (req, res) => {
-      try {
-        const { playlistId, trackId } = req.params;
-        const playlist = await db.playlist.findById(playlistId);
-        if (!playlist) {
-          return res.status(404).json({ error: "Playlist not found" });
-        }
-        playlist.tracks = playlist.tracks.filter(
-          (t) => t.track.toString() !== trackId
-        );
-        await playlist.save();
-        res.json({
-          message: "Track removed from playlist successfully",
-          playlist
-        });
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  playlistsCRUD.addAction("add-collaborator", {
-    method: "post",
-    path: "/:playlistId/collaborators/:userId",
-    auth: true,
-    abac: {
-      resource: "playlists",
-      action: "update"
-    },
-    handler: async (req, res) => {
-      try {
-        const { playlistId, userId } = req.params;
-        const playlist = await db.playlist.findById(playlistId);
-        if (!playlist) {
-          return res.status(404).json({ error: "Playlist not found" });
-        }
-        if (playlist.collaborators.includes(userId)) {
-          return res.status(400).json({ error: "User is already a collaborator" });
-        }
-        playlist.collaborators.push(userId);
-        playlist.isCollaborative = true;
-        await playlist.save();
-        res.json({
-          message: "Collaborator added successfully",
-          playlist
-        });
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  return playlistsCRUD;
-}
-function genresVerifierFactory(db) {
-  const createVerifier = new core_verifier.Verifier({
-    name: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Genre name is required").min(1, "Name cannot be empty").max(50, "Name must not exceed 50 characters")
-    },
-    description: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(500, "Description must not exceed 500 characters")
-    },
-    iconUrl: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid icon URL format")
-    },
-    popularity: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().number().min(0, "Popularity cannot be negative").max(100, "Popularity cannot exceed 100")
-    }
-  });
-  const updateVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Genre ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-    },
-    name: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().min(1, "Name cannot be empty").max(50, "Name must not exceed 50 characters")
-    },
-    description: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().max(500, "Description must not exceed 500 characters")
-    },
-    iconUrl: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid icon URL format")
-    },
-    popularity: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().number().min(0, "Popularity cannot be negative").max(100, "Popularity cannot exceed 100")
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
-    }
-  });
-  const readVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-    },
-    name: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string()
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
-    },
-    skip: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().integer().min(0)
-    },
-    limit: {
-      rule: "optional",
-      default: 20,
-      validator: core_verifier.Validator.schema().integer().min(1).max(100)
-    },
-    sortParam: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["name", "popularity", "createdAt", "updatedAt"])
-    },
-    sortOrder: {
-      rule: "optional",
-      default: "desc",
-      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
-    }
-  });
-  const deleteVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Genre ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
-    }
-  });
-  return {
-    createVerifier,
-    readVerifier,
-    updateVerifier,
-    deleteVerifier
-  };
-}
-const { getInstance } = abac.ABAC;
-function setupGenresRoutes(app, db) {
-  const abac2 = getInstance(db);
-  const verifier = genresVerifierFactory();
-  const genresCRUD = new crud.CRUD({
-    app,
-    db,
-    model: db.genre,
-    modelName: "genre",
-    basePath: "/api/genres",
-    auth: { read: false },
-    verifiers: {
-      create: verifier.createVerifier,
-      read: verifier.readVerifier,
-      update: verifier.updateVerifier,
-      delete: verifier.deleteVerifier
-    },
-    abac: abac2,
-    policies: {
-      read: { enabled: false }
-    },
-    cache: {
-      enabled: true,
-      ttl: 300,
-      tags: ["genres", "music"]
-    },
-    events: {
-      enabled: true,
-      logReads: false
-    }
-  });
-  genresCRUD.addAction("get-by-url", {
-    method: "get",
-    path: "/url/:url",
-    auth: false,
-    handler: async (req, res) => {
-      try {
-        const genre = await db.genre.findOne({ url: req.params.url });
-        if (!genre) {
-          return res.status(404).json({ error: "Genre not found" });
-        }
-        res.json(genre);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  genresCRUD.addAction("genre-tracks", {
-    method: "get",
-    path: "/:genreId/tracks",
-    auth: false,
-    handler: async (req, res) => {
-      try {
-        const { genreId } = req.params;
-        const limit = parseInt(req.query.limit) || 50;
-        const skip = parseInt(req.query.skip) || 0;
-        const tracks = await db.track.find({
-          genre: genreId,
-          status: "published",
-          isPublic: true
-        }).populate("artist", "name url").populate("album", "title url").sort({ playCount: -1, releaseDate: -1 }).skip(skip).limit(limit);
-        res.json(tracks);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  genresCRUD.addAction("popular", {
-    method: "get",
-    path: "/popular",
-    auth: false,
-    handler: async (req, res) => {
-      try {
-        const limit = parseInt(req.query.limit) || 20;
-        const popularGenres = await db.genre.find({ status: "published" }).sort({ popularity: -1 }).limit(limit);
-        res.json(popularGenres);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ error: error.message });
-      }
-    }
-  });
-  return genresCRUD;
-}
-const SearchController = (function(app, db) {
-  const logger = new core_logger.LoggerNamespaced(db);
-  const cache = new core_logger.CacheNamespaced();
-  async function search(req, res) {
-    try {
-      const { query, type, limit = 10 } = req.query;
-      if (!query || query.length < 2) {
-        return res.status(400).json({ error: "Search query must be at least 2 characters" });
-      }
-      const limitNum = parseInt(limit, 10);
-      const cacheKey = `search:${query}:${type || "all"}:${limitNum}`;
-      let results = await cache.get(cacheKey);
-      if (!results) {
-        results = {};
-        const searchRegex = new RegExp(query, "i");
-        const types = type ? [type] : ["tracks", "albums", "artists", "playlists", "genres"];
-        if (types.includes("tracks") || types.includes("all")) {
-          results.tracks = await db.track.find({
-            $or: [{ title: searchRegex }, { tags: searchRegex }],
-            status: "published",
-            isPublic: true
-          }).populate("artist", "name url photoUrl isVerified").populate("album", "title url coverArt").populate("genre", "name url").limit(limitNum);
-        }
-        if (types.includes("albums") || types.includes("all")) {
-          results.albums = await db.album.find({
-            $or: [{ title: searchRegex }, { description: searchRegex }, { tags: searchRegex }],
-            status: "published",
-            isPublic: true
-          }).limit(limitNum);
-        }
-        if (types.includes("artists") || types.includes("all")) {
-          results.artists = await db.artist.find({
-            $or: [{ name: searchRegex }, { bio: searchRegex }, { tags: searchRegex }],
-            status: "published"
-          }).limit(limitNum);
-        }
-        if (types.includes("playlists") || types.includes("all")) {
-          results.playlists = await db.playlist.find({
-            $or: [{ title: searchRegex }, { description: searchRegex }, { tags: searchRegex }],
-            isPublic: true
-          }).limit(limitNum);
-        }
-        if (types.includes("genres") || types.includes("all")) {
-          results.genres = await db.genre.find({
-            $or: [{ name: searchRegex }, { description: searchRegex }],
-            status: "published"
-          }).limit(limitNum);
-        }
-        await cache.set(cacheKey, results, 600);
-      }
-      res.json(results);
-    } catch (error) {
-      logger.error(`Error searching: ${error.message}`);
-      res.status(500).json({ error: error.message });
-    }
-  }
-  return {
-    search
-  };
-});
-const StreamController = (function(app, db, publicPath) {
-  const { getInstance: getInstance2 } = core_abac.coreabac;
-  const logger = new core_logger.LoggerNamespaced(db);
-  const abac2 = getInstance2(db);
-  async function streamAudio(req, res) {
-    try {
-      const trackId = req.params.trackId;
-      const track = await db.track.findById(trackId);
-      if (!track) {
-        return res.status(404).json({ error: "Track not found" });
-      }
-      const accessResult = await abac2.checkAccess({
-        user: req.userId,
-        resource: "tracks",
-        action: "read",
-        currentResource: track
-      });
-      if (!accessResult.allowed && !track.isPublic) {
-        return res.status(403).json({
-          errorCode: accessResult.reason,
-          message: "Access Denied"
-        });
-      }
-      const fileUrl = track.fileUrl;
-      const filePath = path$1.join(publicPath, fileUrl);
-      if (!fs$1.existsSync(filePath)) {
-        logger.error(`File not found: ${filePath}`);
-        return res.status(404).json({ error: "Audio file not found" });
-      }
-      const stat = fs$1.statSync(filePath);
-      const fileSize = stat.size;
-      const range = req.headers.range;
-      const isFirstRequest = !range || range === "bytes=0-";
-      if (req.userId) {
-        try {
-          await db.playHistory.create({
-            user: req.userId,
-            track: trackId,
-            playedAt: /* @__PURE__ */ new Date(),
-            deviceInfo: req.headers["user-agent"],
-            playedFrom: req.query.from || "other",
-            contextId: req.query.contextId || null
-          });
-          const updatedTrack = await db.track.findByIdAndUpdate(trackId, { $inc: { playCount: 1 } }, { new: true });
-        } catch (error) {
-          logger.error(`Error logging play history: ${error.message}`);
-        }
-      } else {
-        try {
-          const updatedTrack = await db.track.findByIdAndUpdate(trackId, { $inc: { playCount: 1 } }, { new: true });
-        } catch (error) {
-          logger.error(`Error incrementing playCount: ${error.message}`);
-        }
-      }
-      if (range) {
-        const parts = range.replace(/bytes=/, "").split("-");
-        const start = parseInt(parts[0], 10);
-        const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
-        const chunksize = end - start + 1;
-        const file = fs$1.createReadStream(filePath, { start, end });
-        res.writeHead(206, {
-          "Content-Range": `bytes ${start}-${end}/${fileSize}`,
-          "Accept-Ranges": "bytes",
-          "Content-Length": chunksize,
-          "Content-Type": "audio/mpeg"
-        });
-        file.pipe(res);
-      } else {
-        res.writeHead(200, {
-          "Content-Length": fileSize,
-          "Content-Type": "audio/mpeg"
-        });
-        fs$1.createReadStream(filePath).pipe(res);
-      }
-    } catch (error) {
-      logger.error(`Error streaming audio: ${error.message}`);
-      res.status(500).json({ error: error.message });
-    }
-  }
-  return {
-    streamAudio
-  };
-});
-const AlbumModel = (function(db) {
-  const albumSchema = new db.mongoose.Schema(
-    {
-      title: {
-        type: String,
-        required: true
-      },
-      description: {
-        type: String,
-        default: ""
-      },
-      releaseDate: {
-        type: Date,
-        required: true
-      },
-      coverArt: {
-        type: String,
-        default: null
-      },
-      artists: [
-        {
-          type: db.mongoose.Schema.Types.ObjectId,
-          ref: "Artist",
-          required: true
-        }
-      ],
-      type: {
-        type: String,
-        enum: ["album", "single", "EP", "compilation"],
-        default: "album"
-      },
-      genres: [
-        {
-          type: db.mongoose.Schema.Types.ObjectId,
-          ref: "Genre"
-        }
-      ],
-      totalTracks: {
-        type: Number,
-        default: 0
-      }
-    },
-    {
-      timestamps: true,
-      versionKey: false
-    }
-  );
-  ownership_schema.applyOwnershipSchema(albumSchema, db);
-  metadata_schema.applyMetadataSchema(albumSchema);
-  common_schema.applyCommonSchema(albumSchema);
-  engagement_schema.applyEngagementSchema(albumSchema);
-  albumSchema.index({ title: "text", description: "text" });
-  albumSchema.index({ artists: 1 });
-  albumSchema.index({ releaseDate: -1 });
-  albumSchema.index({ type: 1 });
-  albumSchema.index({ genres: 1 });
-  return db.mongoose.models.Album || db.mongoose.model("Album", albumSchema);
-});
-const ArtistModel = (function(db) {
-  const mongoose = db.mongoose;
-  const Schema = mongoose.Schema;
-  const ArtistSchema = new Schema(
-    {
-      name: {
-        type: String,
-        required: true,
-        trim: true
-      },
-      bio: {
-        type: String,
-        trim: true
-      },
-      photoUrl: {
-        type: String
-      },
-      coverUrl: {
-        type: String
-      },
-      genre: [
-        {
-          type: Schema.Types.ObjectId,
-          ref: "Genre"
-        }
-      ],
-      isVerified: {
-        type: Boolean,
-        default: false
-      },
-      website: {
-        type: String,
-        trim: true
-      },
-      location: {
-        type: String,
-        trim: true
-      },
-      popularity: {
-        type: Number,
-        default: 0
-      }
-    },
-    {
-      timestamps: true,
-      versionKey: false
-    }
-  );
-  common_schema.applyCommonSchema(ArtistSchema);
-  metadata_schema.applyMetadataSchema(ArtistSchema);
-  ownership_schema.applyOwnershipSchema(ArtistSchema, db);
-  socials_schema.applySocialsSchema(ArtistSchema);
-  engagement_schema.applyEngagementSchema(ArtistSchema);
-  ArtistSchema.index({ name: "text", bio: "text" });
-  ArtistSchema.index({ popularity: -1 });
-  ArtistSchema.index({ isVerified: 1 });
-  return mongoose.models.Artist || mongoose.model("Artist", ArtistSchema);
-});
-const GenreModel = (function(db) {
-  const mongoose = db.mongoose;
-  const Schema = mongoose.Schema;
-  const GenreSchema = new Schema(
-    {
-      name: {
-        type: String,
-        required: true,
-        trim: true,
-        unique: true
-      },
-      description: {
-        type: String,
-        trim: true
-      },
-      iconUrl: {
-        type: String
-      },
-      popularity: {
-        type: Number,
-        default: 0
-      }
-    },
-    {
-      timestamps: true,
-      versionKey: false
-    }
-  );
-  common_schema.applyCommonSchema(GenreSchema);
-  metadata_schema.applyMetadataSchema(GenreSchema);
-  GenreSchema.index({ name: "text", description: "text" });
-  GenreSchema.index({ popularity: -1 });
-  return mongoose.models.Genre || mongoose.model("Genre", GenreSchema);
-});
-const PlayHistoryModel = (function(db) {
-  const mongoose = db.mongoose;
-  const Schema = mongoose.Schema;
-  const PlayHistorySchema = new Schema(
-    {
-      user: {
-        type: Schema.Types.ObjectId,
-        ref: "User",
-        required: true
-      },
-      track: {
-        type: Schema.Types.ObjectId,
-        ref: "Track",
-        required: true
-      },
-      playedAt: {
-        type: Date,
-        default: Date.now
-      },
-      playDuration: {
-        type: Number,
-        default: 0
-      },
-      playedFrom: {
-        type: String,
-        enum: ["playlist", "album", "search", "recommendation", "artist", "other"],
-        default: "other"
-      },
-      contextId: {
-        type: Schema.Types.ObjectId,
-        refPath: "playedFrom"
-      },
-      deviceInfo: {
-        type: String
-      },
-      location: {
-        type: String
-      }
-    },
-    {
-      timestamps: true,
-      versionKey: false
-    }
-  );
-  PlayHistorySchema.index({ user: 1, playedAt: -1 });
-  PlayHistorySchema.index({ track: 1 });
-  PlayHistorySchema.index({ playedAt: -1 });
-  return mongoose.models.PlayHistory || mongoose.model("PlayHistory", PlayHistorySchema);
-});
-const PlaylistModel = (function(db) {
-  const mongoose = db.mongoose;
-  const Schema = mongoose.Schema;
-  const PlaylistSchema = new Schema(
-    {
-      title: {
-        type: String,
-        required: true,
-        trim: true
-      },
-      description: {
-        type: String,
-        trim: true
-      },
-      coverUrl: {
-        type: String
-      },
-      tracks: [
-        {
-          track: {
-            type: Schema.Types.ObjectId,
-            ref: "Track"
-          },
-          addedAt: {
-            type: Date,
-            default: Date.now
-          }
-        }
-      ],
-      isPublic: {
-        type: Boolean,
-        default: true
-      },
-      followers: {
-        type: Number,
-        default: 0
-      },
-      isCollaborative: {
-        type: Boolean,
-        default: false
-      },
-      collaborators: [
-        {
-          type: Schema.Types.ObjectId,
-          ref: "User"
-        }
-      ]
-    },
-    {
-      timestamps: true,
-      versionKey: false
-    }
-  );
-  common_schema.applyCommonSchema(PlaylistSchema);
-  metadata_schema.applyMetadataSchema(PlaylistSchema);
-  ownership_schema.applyOwnershipSchema(PlaylistSchema, db);
-  engagement_schema.applyEngagementSchema(PlaylistSchema);
-  PlaylistSchema.index({ title: "text", description: "text" });
-  PlaylistSchema.index({ isPublic: 1 });
-  PlaylistSchema.index({ followers: -1 });
-  PlaylistSchema.index({ "tracks.addedAt": -1 });
-  return mongoose.models.Playlist || mongoose.model("Playlist", PlaylistSchema);
-});
-const TrackModel = (function(db) {
-  const mongoose = db.mongoose;
-  const Schema = mongoose.Schema;
-  const TrackSchema = new Schema(
-    {
-      title: {
-        type: String,
-        required: true,
-        trim: true
-      },
-      artist: {
-        type: Schema.Types.ObjectId,
-        ref: "Artist",
-        required: true
-      },
-      album: {
-        type: Schema.Types.ObjectId,
-        ref: "Album"
-      },
-      duration: {
-        type: Number,
-        default: 0
-      },
-      fileUrl: {
-        type: String,
-        required: true
-      },
-      coverUrl: {
-        type: String
-      },
-      genre: [
-        {
-          type: Schema.Types.ObjectId,
-          ref: "Genre"
-        }
-      ],
-      releaseDate: {
-        type: Date,
-        default: Date.now
-      },
-      isExplicit: {
-        type: Boolean,
-        default: false
-      },
-      lyrics: {
-        type: String
-      },
-      playCount: {
-        type: Number,
-        default: 0
-      },
-      isPublic: {
-        type: Boolean,
-        default: true
-      }
-    },
-    {
-      timestamps: true,
-      versionKey: false
-    }
-  );
-  common_schema.applyCommonSchema(TrackSchema);
-  metadata_schema.applyMetadataSchema(TrackSchema);
-  ownership_schema.applyOwnershipSchema(TrackSchema, db);
-  engagement_schema.applyEngagementSchema(TrackSchema);
-  TrackSchema.index({ title: "text" });
-  TrackSchema.index({ artist: 1 });
-  TrackSchema.index({ album: 1 });
-  TrackSchema.index({ releaseDate: -1 });
-  TrackSchema.index({ playCount: -1 });
-  TrackSchema.pre("save", function(next) {
-    if (!this.url) {
-      this.url = metadata_schema.createFriendlyURL(`${this.title}-${this._id}`);
-    }
-    next();
-  });
-  TrackSchema.virtual("artistName").get(function() {
-    return this.artist ? this.artist.name : "";
-  });
-  return mongoose.models.Track || mongoose.model("Track", TrackSchema);
-});
-const musicPolicies = (function initializeMusicPolicies(abacAccessControl) {
-  abacAccessControl.registerResourcePolicy("tracks", async (context) => {
-    const { user, action, currentResource, resourceModel } = context;
-    const ObjectId = abacAccessControl.db.mongoose.Types.ObjectId;
-    if (action === "read" && currentResource?.status === "published" && currentResource?.isPublic === true) {
-      return true;
-    }
-    if (action === "create") {
-      if (context.data.creator && context.data.creator.target) {
-        return context.data.creator.target.toString() === user.toString();
-      }
-      return false;
-    }
-    if (["update", "edit", "delete"].includes(action) && currentResource) {
-      if (currentResource.owner && currentResource.owner.type === "Organization") {
-        const Organization = abacAccessControl.db.organization;
-        const org = await Organization.findOne({
-          _id: currentResource.owner.target,
-          members: { $elemMatch: { user: new ObjectId(user) } }
-        });
-        if (org) return true;
-      }
-      if (currentResource.creator && currentResource.creator.target && currentResource.creator.target.toString() === user.toString()) {
-        return true;
-      }
-      return false;
-    }
-    return false;
-  });
-  abacAccessControl.registerResourcePolicy("albums", async (context) => {
-    return abacAccessControl.policies.resources.tracks(context);
-  });
-  abacAccessControl.registerResourcePolicy("playlists", async (context) => {
-    const { user, action, currentResource } = context;
-    if (currentResource && currentResource.isCollaborative && currentResource.collaborators && currentResource.collaborators.some((collaborator) => collaborator.toString() === user.toString())) {
-      if (action === "edit" || action === "update") {
-        return true;
-      }
-    }
-    return abacAccessControl.policies.resources.tracks(context);
-  });
-  abacAccessControl.registerResourcePolicy("artists", async (context) => {
-    return abacAccessControl.policies.resources.tracks(context);
-  });
-  return abacAccessControl;
-});
-const searchRoutes = (function(app, db, origins, publicPath) {
-  const controller = SearchController(app, db);
-  app.get("/api/music/search", controller.search);
-});
-const streamRoutes = (function(app, db, origins, publicPath) {
-  console.log("rouus publioc is", publicPath);
-  const controller = StreamController(app, db, publicPath);
-  app.get("/api/stream/:trackId", controller.streamAudio);
-  app.get("/api/waveform/:trackId", async (req, res) => {
-    try {
-      const track = await db.track.findById(req.params.trackId);
-      if (!track) {
-        return res.status(404).json({ error: "Track not found" });
-      }
-      const waveformPath = path.join(process.env.FILE_STORAGE_PATH || "./uploads", `waveforms/${track._id}.json`);
-      if (fs.existsSync(waveformPath)) {
-        const waveformData = JSON.parse(fs.readFileSync(waveformPath, "utf8"));
-        return res.json(waveformData);
-      }
-      res.status(404).json({ error: "Waveform data not found" });
-    } catch (error) {
-      console.error(error);
-      res.status(500).json({ error: error.message });
-    }
-  });
-});
-const StreamingHandler = (function(db) {
-  const logger = new core_logger.LoggerNamespaced(db);
-  return {
-    // Handle WebSocket messages for music streaming
-    handleStreamingMessage: async (ws, message) => {
-      try {
-        console.log("StreamingHandler: Received message:", { action: message.action, data: message.data });
-        const { action, data } = message;
-        switch (action) {
-          case "startPlaying":
-            console.log("StreamingHandler: Processing startPlaying event for track:", data.trackId, "user:", ws.userId);
-            if (ws.userId && data.trackId) {
-              await db.playHistory.create({
-                user: ws.userId,
-                track: data.trackId,
-                playedAt: /* @__PURE__ */ new Date(),
-                deviceInfo: data.deviceInfo || "Unknown",
-                playedFrom: data.from || "other",
-                contextId: data.contextId || null
-              });
-              console.log("StreamingHandler: Created play history record");
-              const trackUpdate = await db.track.findByIdAndUpdate(data.trackId, { $inc: { playCount: 1 } }, { new: true });
-              console.log("StreamingHandler: Updated track playCount to:", trackUpdate?.playCount);
-              ws.send(
-                JSON.stringify({
-                  type: "playAcknowledged",
-                  trackId: data.trackId
-                })
-              );
-            }
-            break;
-          case "syncPosition":
-            if (ws.userId && data.trackId && data.position) {
-              const latestPlay = await db.playHistory.findOne({
-                user: ws.userId,
-                track: data.trackId
-              }).sort({ playedAt: -1 });
-              if (latestPlay) {
-                latestPlay.playDuration = data.position;
-                await latestPlay.save();
-              }
-            }
-            break;
-          case "getRecommendations":
-            if (ws.userId) {
-              const recentTracks = await db.playHistory.find({
-                user: ws.userId
-              }).sort({ playedAt: -1 }).limit(10).populate("track");
-              const recentGenres = /* @__PURE__ */ new Set();
-              const recentArtists = /* @__PURE__ */ new Set();
-              recentTracks.forEach((history) => {
-                if (history.track) {
-                  if (history.track.genre) {
-                    history.track.genre.forEach((g) => recentGenres.add(g.toString()));
-                  }
-                  if (history.track.artist) {
-                    recentArtists.add(history.track.artist.toString());
-                  }
-                }
-              });
-              const recommendations = await db.track.find({
-                $or: [{ genre: { $in: Array.from(recentGenres) } }, { artist: { $in: Array.from(recentArtists) } }],
-                _id: { $nin: recentTracks.map((h) => h.track._id) },
-                // Exclude recently played
-                status: "published",
-                isPublic: true
-              }).limit(10).populate("artist", "name").populate("album", "title coverUrl");
-              ws.send(
-                JSON.stringify({
-                  type: "recommendations",
-                  tracks: recommendations
-                })
-              );
-            }
-            break;
-          case "joinListeningParty":
-            if (ws.userId && data.partyId) {
-              ws.listeningParty = data.partyId;
-              global.webSocketManager.broadcastToModuleWithFilter("music-streaming", (socket) => socket.listeningParty === data.partyId, {
-                type: "partyMemberJoined",
-                userId: ws.userId,
-                partyId: data.partyId
-              });
-            }
-            break;
-          case "syncPartyPlayback":
-            if (ws.userId && ws.listeningParty && data.trackId && data.position) {
-              global.webSocketManager.broadcastToModuleWithFilter("music-streaming", (socket) => socket.listeningParty === ws.listeningParty && socket !== ws, {
-                type: "partyPlaybackSync",
-                trackId: data.trackId,
-                position: data.position,
-                isPlaying: data.isPlaying,
-                timestamp: Date.now()
-              });
-            }
-            break;
-          default:
-            logger.info(`Unknown streaming action: ${action}`);
-        }
-      } catch (error) {
-        logger.error(`Error in streaming handler: ${error.message}`);
-        ws.send(
-          JSON.stringify({
-            type: "error",
-            message: "An error occurred while processing your request"
-          })
-        );
-      }
-    }
-  };
-});
-function initializeMusic({ app, db, wss, origins, publicPath }) {
-  db.track = TrackModel(db);
-  db.playlist = PlaylistModel(db);
-  db.album = AlbumModel(db);
-  db.artist = ArtistModel(db);
-  db.genre = GenreModel(db);
-  db.playHistory = PlayHistoryModel(db);
-  console.log("server publioc is", publicPath);
-  if (app) {
-    setupTracksRoutes(app, db);
-    setupArtistsRoutes(app, db);
-    setupAlbumsRoutes(app, db);
-    setupPlaylistsRoutes(app, db);
-    setupGenresRoutes(app, db);
-    streamRoutes(app, db, origins, publicPath);
-    searchRoutes(app, db);
-  }
-  const { getInstance: getInstance2 } = core_abac.coreabac;
-  const abac2 = getInstance2(db);
-  musicPolicies(abac2);
-  if (wss) {
-    console.log("Music Server: Registering music-streaming WebSocket handler");
-    const handler = StreamingHandler(db);
-    wss.registerModule("music-streaming", handler.handleStreamingMessage);
-    console.log("Music Server: WebSocket handler registered successfully");
-  } else {
-    console.log("Music Server: WebSocket server (wss) not provided, streaming handler not registered");
-  }
-  new core_logger.CacheNamespaced({ ttlSeconds: 60 * 15 });
-  const musicLogger = new core_logger.LoggerNamespaced(db);
-  musicLogger.info("Music module initialized");
-}
-const models = {
-  TrackModel,
-  PlaylistModel,
-  AlbumModel,
-  ArtistModel,
-  GenreModel,
-  PlayHistoryModel
-};
-const routes = {
-  // NEW CRUD Routes
-  setupTracksRoutes,
-  setupArtistsRoutes,
-  setupAlbumsRoutes,
-  setupPlaylistsRoutes,
-  setupGenresRoutes,
-  // Legacy routes
-  streamRoutes,
-  searchRoutes
-};
-const controllers = {
-  // Keep only non-CRUD controllers
-  StreamController,
-  SearchController
-};
-const music_server = {
-  initialize: initializeMusic,
-  models,
-  routes,
-  controllers
-};
-exports.controllers = controllers;
-exports.default = music_server;
-exports.initialize = initializeMusic;
-exports.models = models;
-exports.routes = routes;