@ozdao/martyrs 0.2.549 → 0.2.550

package/dist/music.server.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const globals_abac = require("./globals.abac-CPXLas7N.cjs");
-const globals_logger = require("./globals.logger-BuW7JHMY.cjs");
-const crud = require("./crud-pedHI2by.cjs");
-const abac = require("./abac-DOyUjhee.cjs");
-const globals_verifier = require("./globals.verifier-Bi-XLEi9.cjs");
+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");
@@ -13,88 +13,88 @@ 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 globals_verifier.Verifier({
+  const createVerifier = new core_verifier.Verifier({
     title: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Track title is required").min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+      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: globals_verifier.Validator.schema().string().required("Artist is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+      validator: core_verifier.Validator.schema().string().required("Artist is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
     },
     album: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
     },
     fileUrl: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("File URL is required").pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+      validator: core_verifier.Validator.schema().string().required("File URL is required").pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
     },
     coverUrl: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
     },
     duration: {
       rule: "optional",
       default: 0,
-      validator: globals_verifier.Validator.schema().number().min(0, "Duration cannot be negative").max(3600, "Duration cannot exceed 1 hour")
+      validator: core_verifier.Validator.schema().number().min(0, "Duration cannot be negative").max(3600, "Duration cannot exceed 1 hour")
     },
     genre: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      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: globals_verifier.Validator.schema().date()
+      validator: core_verifier.Validator.schema().date()
     },
     isExplicit: {
       rule: "optional",
       default: false,
-      validator: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     lyrics: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().max(1e4, "Lyrics too long")
+      validator: core_verifier.Validator.schema().string().max(1e4, "Lyrics too long")
     },
     isPublic: {
       rule: "optional",
       default: true,
-      validator: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     owner: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().object({
-        type: globals_verifier.Validator.schema().string().oneOf(["user", "organization"]),
-        target: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      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 globals_verifier.Verifier({
+  const updateVerifier = new core_verifier.Verifier({
     _id: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Track ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format")
+      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: globals_verifier.Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+      validator: core_verifier.Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
     },
     artist: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
     },
     album: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
     },
     fileUrl: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
     },
     coverUrl: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
     },
     // duration: {
     //   rule: 'optional',
@@ -105,80 +105,80 @@ function tracksVerifierFactory(db) {
     // },
     genre: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      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: globals_verifier.Validator.schema().date()
+      validator: core_verifier.Validator.schema().date()
     },
     isExplicit: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     lyrics: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().max(1e4, "Lyrics too long")
+      validator: core_verifier.Validator.schema().string().max(1e4, "Lyrics too long")
     },
     isPublic: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     status: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
+      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
     }
   });
-  const readVerifier = new globals_verifier.Verifier({
+  const readVerifier = new core_verifier.Verifier({
     _id: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format")
     },
     artist: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
     },
     album: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
     },
     genre: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
     },
     isPublic: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     status: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
+      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
     },
     skip: {
       rule: "optional",
       default: 0,
-      validator: globals_verifier.Validator.schema().integer().min(0)
+      validator: core_verifier.Validator.schema().integer().min(0)
     },
     limit: {
       rule: "optional",
       default: 20,
-      validator: globals_verifier.Validator.schema().integer().min(1).max(100)
+      validator: core_verifier.Validator.schema().integer().min(1).max(100)
     },
     sortParam: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["title", "playCount", "releaseDate", "createdAt", "updatedAt"])
+      validator: core_verifier.Validator.schema().string().oneOf(["title", "playCount", "releaseDate", "createdAt", "updatedAt"])
     },
     sortOrder: {
       rule: "optional",
       default: "desc",
-      validator: globals_verifier.Validator.schema().string().oneOf(["asc", "desc"])
+      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
     }
   });
-  const deleteVerifier = new globals_verifier.Verifier({
+  const deleteVerifier = new core_verifier.Verifier({
     _id: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Track ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format")
+      validator: core_verifier.Validator.schema().string().required("Track ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format")
     }
   });
   return {
@@ -313,134 +313,134 @@ function setupTracksRoutes(app, db) {
   return tracksCRUD;
 }
 function artistsVerifierFactory(db) {
-  const createVerifier = new globals_verifier.Verifier({
+  const createVerifier = new core_verifier.Verifier({
     name: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Artist name is required").min(1, "Name cannot be empty").max(100, "Name must not exceed 100 characters")
+      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: globals_verifier.Validator.schema().string().max(2e3, "Bio must not exceed 2000 characters")
+      validator: core_verifier.Validator.schema().string().max(2e3, "Bio must not exceed 2000 characters")
     },
     photoUrl: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
     },
     coverUrl: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
     },
     genre: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      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: globals_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid website URL format")
+      validator: core_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid website URL format")
     },
     location: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().max(100, "Location must not exceed 100 characters")
+      validator: core_verifier.Validator.schema().string().max(100, "Location must not exceed 100 characters")
     },
     owner: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().object({
-        type: globals_verifier.Validator.schema().string().oneOf(["user", "organization"]),
-        target: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      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 globals_verifier.Verifier({
+  const updateVerifier = new core_verifier.Verifier({
     _id: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Artist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+      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: globals_verifier.Validator.schema().string().min(1, "Name cannot be empty").max(100, "Name must not exceed 100 characters")
+      validator: core_verifier.Validator.schema().string().min(1, "Name cannot be empty").max(100, "Name must not exceed 100 characters")
     },
     bio: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().max(2e3, "Bio must not exceed 2000 characters")
+      validator: core_verifier.Validator.schema().string().max(2e3, "Bio must not exceed 2000 characters")
     },
     photoUrl: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
     },
     coverUrl: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
     },
     genre: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      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: globals_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid website URL format")
+      validator: core_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid website URL format")
     },
     location: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().max(100, "Location must not exceed 100 characters")
+      validator: core_verifier.Validator.schema().string().max(100, "Location must not exceed 100 characters")
     },
     isVerified: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     status: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
+      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
     }
   });
-  const readVerifier = new globals_verifier.Verifier({
+  const readVerifier = new core_verifier.Verifier({
     _id: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
     },
     genre: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
     },
     isVerified: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     status: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
+      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
     },
     location: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string()
+      validator: core_verifier.Validator.schema().string()
     },
     skip: {
       rule: "optional",
       default: 0,
-      validator: globals_verifier.Validator.schema().integer().min(0)
+      validator: core_verifier.Validator.schema().integer().min(0)
     },
     limit: {
       rule: "optional",
       default: 20,
-      validator: globals_verifier.Validator.schema().integer().min(1).max(100)
+      validator: core_verifier.Validator.schema().integer().min(1).max(100)
     },
     sortParam: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["name", "popularity", "createdAt", "updatedAt"])
+      validator: core_verifier.Validator.schema().string().oneOf(["name", "popularity", "createdAt", "updatedAt"])
     },
     sortOrder: {
       rule: "optional",
       default: "desc",
-      validator: globals_verifier.Validator.schema().string().oneOf(["asc", "desc"])
+      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
     }
   });
-  const deleteVerifier = new globals_verifier.Verifier({
+  const deleteVerifier = new core_verifier.Verifier({
     _id: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Artist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+      validator: core_verifier.Validator.schema().string().required("Artist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
     }
   });
   return {
@@ -586,144 +586,144 @@ function setupArtistsRoutes(app, db) {
   return artistsCRUD;
 }
 function albumsVerifierFactory(db) {
-  const createVerifier = new globals_verifier.Verifier({
+  const createVerifier = new core_verifier.Verifier({
     title: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Album title is required").min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+      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: globals_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+      validator: core_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
     },
     releaseDate: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().date().required("Release date is required")
+      validator: core_verifier.Validator.schema().date().required("Release date is required")
     },
     coverArt: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
     },
     artists: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+      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: globals_verifier.Validator.schema().string().oneOf(["album", "single", "EP", "compilation"], "Invalid album type")
+      validator: core_verifier.Validator.schema().string().oneOf(["album", "single", "EP", "compilation"], "Invalid album type")
     },
     genres: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      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: globals_verifier.Validator.schema().integer().min(0, "Total tracks cannot be negative").max(100, "Too many tracks")
+      validator: core_verifier.Validator.schema().integer().min(0, "Total tracks cannot be negative").max(100, "Too many tracks")
     },
     owner: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().object({
-        type: globals_verifier.Validator.schema().string().oneOf(["user", "organization"]),
-        target: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      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 globals_verifier.Verifier({
+  const updateVerifier = new core_verifier.Verifier({
     _id: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Album ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+      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: globals_verifier.Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+      validator: core_verifier.Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
     },
     description: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+      validator: core_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
     },
     releaseDate: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().date()
+      validator: core_verifier.Validator.schema().date()
     },
     coverArt: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
     },
     artists: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+      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: globals_verifier.Validator.schema().string().oneOf(["album", "single", "EP", "compilation"], "Invalid album type")
+      validator: core_verifier.Validator.schema().string().oneOf(["album", "single", "EP", "compilation"], "Invalid album type")
     },
     genres: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      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: globals_verifier.Validator.schema().integer().min(0, "Total tracks cannot be negative").max(100, "Too many tracks")
+      validator: core_verifier.Validator.schema().integer().min(0, "Total tracks cannot be negative").max(100, "Too many tracks")
     },
     status: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
+      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
     }
   });
-  const readVerifier = new globals_verifier.Verifier({
+  const readVerifier = new core_verifier.Verifier({
     _id: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
     },
     artists: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid artist ID format")
     },
     type: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["album", "single", "EP", "compilation"])
+      validator: core_verifier.Validator.schema().string().oneOf(["album", "single", "EP", "compilation"])
     },
     genres: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
     },
     status: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
+      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
     },
     skip: {
       rule: "optional",
       default: 0,
-      validator: globals_verifier.Validator.schema().integer().min(0)
+      validator: core_verifier.Validator.schema().integer().min(0)
     },
     limit: {
       rule: "optional",
       default: 20,
-      validator: globals_verifier.Validator.schema().integer().min(1).max(100)
+      validator: core_verifier.Validator.schema().integer().min(1).max(100)
     },
     sortParam: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["title", "releaseDate", "totalTracks", "createdAt", "updatedAt"])
+      validator: core_verifier.Validator.schema().string().oneOf(["title", "releaseDate", "totalTracks", "createdAt", "updatedAt"])
     },
     sortOrder: {
       rule: "optional",
       default: "desc",
-      validator: globals_verifier.Validator.schema().string().oneOf(["asc", "desc"])
+      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
     }
   });
-  const deleteVerifier = new globals_verifier.Verifier({
+  const deleteVerifier = new core_verifier.Verifier({
     _id: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Album ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
+      validator: core_verifier.Validator.schema().string().required("Album ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid album ID format")
     }
   });
   return {
@@ -845,142 +845,142 @@ function setupAlbumsRoutes(app, db) {
   return albumsCRUD;
 }
 function playlistsVerifierFactory(db) {
-  const createVerifier = new globals_verifier.Verifier({
+  const createVerifier = new core_verifier.Verifier({
     title: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Playlist title is required").min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+      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: globals_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+      validator: core_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
     },
     coverUrl: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
+      validator: core_verifier.Validator.schema().string().pattern(/^\/(?!\/)/, 'Only relative URLs starting with "/" are allowed')
     },
     tracks: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().object({
-          track: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format").required(),
-          addedAt: globals_verifier.Validator.schema().date()
+      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: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     isCollaborative: {
       rule: "optional",
       default: false,
-      validator: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     collaborators: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid collaborator ID format")
+      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: globals_verifier.Validator.schema().object({
-        type: globals_verifier.Validator.schema().string().oneOf(["user", "organization"]),
-        target: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      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 globals_verifier.Verifier({
+  const updateVerifier = new core_verifier.Verifier({
     _id: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Playlist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid playlist ID format")
+      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: globals_verifier.Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
+      validator: core_verifier.Validator.schema().string().min(1, "Title cannot be empty").max(200, "Title must not exceed 200 characters")
     },
     description: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
+      validator: core_verifier.Validator.schema().string().max(1e3, "Description must not exceed 1000 characters")
     },
     coverUrl: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid cover URL format")
+      validator: core_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid cover URL format")
     },
     tracks: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().object({
-          track: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid track ID format").required(),
-          addedAt: globals_verifier.Validator.schema().date()
+      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: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     isCollaborative: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     collaborators: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().array().items(
-        globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid collaborator ID format")
+      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: globals_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
+      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
     }
   });
-  const readVerifier = new globals_verifier.Verifier({
+  const readVerifier = new core_verifier.Verifier({
     _id: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid playlist ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid playlist ID format")
     },
     owner: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid owner ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid owner ID format")
     },
     isPublic: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     isCollaborative: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().boolean()
+      validator: core_verifier.Validator.schema().boolean()
     },
     status: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["draft", "published", "archived", "featured"])
+      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived", "featured"])
     },
     skip: {
       rule: "optional",
       default: 0,
-      validator: globals_verifier.Validator.schema().integer().min(0)
+      validator: core_verifier.Validator.schema().integer().min(0)
     },
     limit: {
       rule: "optional",
       default: 20,
-      validator: globals_verifier.Validator.schema().integer().min(1).max(100)
+      validator: core_verifier.Validator.schema().integer().min(1).max(100)
     },
     sortParam: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["title", "followers", "createdAt", "updatedAt"])
+      validator: core_verifier.Validator.schema().string().oneOf(["title", "followers", "createdAt", "updatedAt"])
     },
     sortOrder: {
       rule: "optional",
       default: "desc",
-      validator: globals_verifier.Validator.schema().string().oneOf(["asc", "desc"])
+      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
     }
   });
-  const deleteVerifier = new globals_verifier.Verifier({
+  const deleteVerifier = new core_verifier.Verifier({
     _id: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Playlist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid playlist ID format")
+      validator: core_verifier.Validator.schema().string().required("Playlist ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid playlist ID format")
     }
   });
   return {
@@ -1199,88 +1199,88 @@ function setupPlaylistsRoutes(app, db) {
   return playlistsCRUD;
 }
 function genresVerifierFactory(db) {
-  const createVerifier = new globals_verifier.Verifier({
+  const createVerifier = new core_verifier.Verifier({
     name: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Genre name is required").min(1, "Name cannot be empty").max(50, "Name must not exceed 50 characters")
+      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: globals_verifier.Validator.schema().string().max(500, "Description must not exceed 500 characters")
+      validator: core_verifier.Validator.schema().string().max(500, "Description must not exceed 500 characters")
     },
     iconUrl: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid icon URL format")
+      validator: core_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid icon URL format")
     },
     popularity: {
       rule: "optional",
       default: 0,
-      validator: globals_verifier.Validator.schema().number().min(0, "Popularity cannot be negative").max(100, "Popularity cannot exceed 100")
+      validator: core_verifier.Validator.schema().number().min(0, "Popularity cannot be negative").max(100, "Popularity cannot exceed 100")
     }
   });
-  const updateVerifier = new globals_verifier.Verifier({
+  const updateVerifier = new core_verifier.Verifier({
     _id: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Genre ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      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: globals_verifier.Validator.schema().string().min(1, "Name cannot be empty").max(50, "Name must not exceed 50 characters")
+      validator: core_verifier.Validator.schema().string().min(1, "Name cannot be empty").max(50, "Name must not exceed 50 characters")
     },
     description: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().max(500, "Description must not exceed 500 characters")
+      validator: core_verifier.Validator.schema().string().max(500, "Description must not exceed 500 characters")
     },
     iconUrl: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid icon URL format")
+      validator: core_verifier.Validator.schema().string().pattern(/^https?:\/\/.+/, "Invalid icon URL format")
     },
     popularity: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().number().min(0, "Popularity cannot be negative").max(100, "Popularity cannot exceed 100")
+      validator: core_verifier.Validator.schema().number().min(0, "Popularity cannot be negative").max(100, "Popularity cannot exceed 100")
     },
     status: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
+      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"], "Invalid status")
     }
   });
-  const readVerifier = new globals_verifier.Verifier({
+  const readVerifier = new core_verifier.Verifier({
     _id: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
     },
     name: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string()
+      validator: core_verifier.Validator.schema().string()
     },
     status: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
+      validator: core_verifier.Validator.schema().string().oneOf(["draft", "published", "archived"])
     },
     skip: {
       rule: "optional",
       default: 0,
-      validator: globals_verifier.Validator.schema().integer().min(0)
+      validator: core_verifier.Validator.schema().integer().min(0)
     },
     limit: {
       rule: "optional",
       default: 20,
-      validator: globals_verifier.Validator.schema().integer().min(1).max(100)
+      validator: core_verifier.Validator.schema().integer().min(1).max(100)
     },
     sortParam: {
       rule: "optional",
-      validator: globals_verifier.Validator.schema().string().oneOf(["name", "popularity", "createdAt", "updatedAt"])
+      validator: core_verifier.Validator.schema().string().oneOf(["name", "popularity", "createdAt", "updatedAt"])
     },
     sortOrder: {
       rule: "optional",
       default: "desc",
-      validator: globals_verifier.Validator.schema().string().oneOf(["asc", "desc"])
+      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
     }
   });
-  const deleteVerifier = new globals_verifier.Verifier({
+  const deleteVerifier = new core_verifier.Verifier({
     _id: {
       rule: "required",
-      validator: globals_verifier.Validator.schema().string().required("Genre ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
+      validator: core_verifier.Validator.schema().string().required("Genre ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid genre ID format")
     }
   });
   return {
@@ -1377,8 +1377,8 @@ function setupGenresRoutes(app, db) {
   return genresCRUD;
 }
 const SearchController = (function(app, db) {
-  const logger = new globals_logger.LoggerNamespaced(db);
-  const cache = new globals_logger.CacheNamespaced();
+  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;
@@ -1437,8 +1437,8 @@ const SearchController = (function(app, db) {
   };
 });
 const StreamController = (function(app, db, publicPath) {
-  const { getInstance: getInstance2 } = globals_abac.globalsabac;
-  const logger = new globals_logger.LoggerNamespaced(db);
+  const { getInstance: getInstance2 } = core_abac.coreabac;
+  const logger = new core_logger.LoggerNamespaced(db);
   const abac2 = getInstance2(db);
   async function streamAudio(req, res) {
     try {
@@ -1935,7 +1935,7 @@ const streamRoutes = (function(app, db, origins, publicPath) {
   });
 });
 const StreamingHandler = (function(db) {
-  const logger = new globals_logger.LoggerNamespaced(db);
+  const logger = new core_logger.LoggerNamespaced(db);
   return {
     // Handle WebSocket messages for music streaming
     handleStreamingMessage: async (ws, message) => {
@@ -2062,7 +2062,7 @@ function initializeMusic({ app, db, wss, origins, publicPath }) {
     streamRoutes(app, db, origins, publicPath);
     searchRoutes(app, db);
   }
-  const { getInstance: getInstance2 } = globals_abac.globalsabac;
+  const { getInstance: getInstance2 } = core_abac.coreabac;
   const abac2 = getInstance2(db);
   musicPolicies(abac2);
   if (wss) {
@@ -2073,8 +2073,8 @@ function initializeMusic({ app, db, wss, origins, publicPath }) {
   } else {
     console.log("Music Server: WebSocket server (wss) not provided, streaming handler not registered");
   }
-  new globals_logger.CacheNamespaced({ ttlSeconds: 60 * 15 });
-  const musicLogger = new globals_logger.LoggerNamespaced(db);
+  new core_logger.CacheNamespaced({ ttlSeconds: 60 * 15 });
+  const musicLogger = new core_logger.LoggerNamespaced(db);
   musicLogger.info("Music module initialized");
 }
 const models = {