Index: src/assets/js/shared/post-music-type.js
===================================================================
--- src/assets/js/shared/post-music-type.js	(revision 8ed36de2a9b6b822f55c28663bec1275f43fb70d)
+++ src/assets/js/shared/post-music-type.js	(revision b0ccd0d9b11ffb2a364ca71fd3a63aeff057890e)
@@ -21,5 +21,9 @@
  *   een collectie                 -> die soort  metadata van de post geleend
  *   een collectie + losse tracks  -> album      de losse zijn BONUS-TRACKS
+ *   een MIXTAPE + losse tracks    -> mixtape    de losse zijn BONUS-TRACKS
  *   twee of meer collecties       -> post       NIETS geleend
+ *
+ * Die vierde regel is de uitzondering op de derde en staat er met opzet naast:
+ * bonustracks maken van een uitgave een album, maar een bandje is geen uitgave.
  *
  * Waarom de lening bij de laatste vervalt: die bestaat omdat een collectie soms
@@ -39,4 +43,14 @@
 // insluit, telt hier niet mee. Anders zou een shortcode die niets oplevert wel
 // het type van de post kunnen bepalen.
+// De soorten die een playlist kan zijn, en dit is de ENIGE lijst. PlaylistService
+// en music/index.js halen hem hier op, precies omdat het andersom niet kan:
+// deze module draait ook in de browser en mag niets van de database weten.
+//
+// Waarom dat uitmaakt: bij twee soorten stond de keuze vijf keer als
+// `x === 'playlist' ? 'playlist' : 'album'` verspreid over drie bestanden. Zo'n
+// vorm valt niet om bij een derde soort, hij slikt hem -- een mixtape werd
+// stilzwijgend een album en ging als Album de deur uit.
+export const SOORTEN = ['album', 'playlist', 'mixtape'];
+
 const RE_PLAYLIST = /\[\[playlist:([a-z0-9][a-z0-9-]*)\]\]/gi;
 const RE_ALBUM    = /\[\[album:([^\]]+)\]\]/g;
@@ -64,5 +78,5 @@
   const uitPlaylists = playlists.map((id) => {
     const kind = zoek(id);
-    if (kind !== 'album' && kind !== 'playlist') { onbekend.push(id); return null; }
+    if (!SOORTEN.includes(kind)) { onbekend.push(id); return null; }
     return { soort: kind, id };
   }).filter(Boolean);
@@ -87,4 +101,14 @@
   if (collecties.length === 1) {
     const c0 = collecties[0];
+    // EEN MIXTAPE BLIJFT EEN MIXTAPE, ook met losse tracks erbij. De regel
+    // hieronder maakt van collectie + losse tracks een album met bonustracks, en
+    // dat klopt voor een uitgave: extra nummers bij een plaat zijn bonus. Een
+    // bandje is geen uitgave. Er een album van maken omdat er een los nummer
+    // naast staat zou het ding hernoemen op grond van iets wat er niet bij
+    // hoort. Album en playlist houden bewust hun oude gedrag: dat zijn
+    // bestaande posts en die mogen hier niet stilletjes van soort wisselen.
+    if (c0.soort === 'mixtape') {
+      return { type: 'mixtape', collectie: c0, tracks: [], bonus: tracks, leentMetadata: true };
+    }
     // Losse tracks naast een collectie zijn geen rommelrestje maar bonus-tracks,
     // en dat maakt het geheel een album.
Index: src/services/PlaylistService.js
===================================================================
--- src/services/PlaylistService.js	(revision 8ed36de2a9b6b822f55c28663bec1275f43fb70d)
+++ src/services/PlaylistService.js	(revision b0ccd0d9b11ffb2a364ca71fd3a63aeff057890e)
@@ -14,4 +14,5 @@
 import db from '../config/database.js';
 import { v4 as uuid } from 'uuid';
+import { SOORTEN } from '../assets/js/shared/post-music-type.js';
 
 /**
@@ -41,4 +42,29 @@
   return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(s) ? s : null;
 }
+
+/**
+ * De drie soorten die een playlist kan zijn, op EEN plek.
+ *
+ * Stond eerder vijf keer als `data.kind === 'playlist' ? 'playlist' : 'album'`
+ * verspreid over dit bestand. Met twee soorten kon dat nog; bij een derde is
+ * het een fout die staat te wachten, want een van de vijf vergeten betekent dat
+ * een mixtape stilletjes als album wordt opgeslagen en als Album de deur uit
+ * gaat.
+ *
+ * Album blijft de terugval: een onbekende waarde hoort niet stilzwijgend iets
+ * nieuws te worden. De lijst zelf staat in de gedeelde pure module, want de
+ * editor in de browser moet dezelfde drie kennen.
+ */
+export function normKind(v) {
+  const s = String(v == null ? '' : v).trim().toLowerCase();
+  return SOORTEN.includes(s) ? s : 'album';
+}
+
+/**
+ * Draagt deze soort uitgavegegevens? Alleen een album. Een afspeellijst en een
+ * mixtape hebben geen uitgavedatum en geen release-id: het zijn samenstellingen
+ * van andermans of eigen werk, geen uitgave op zichzelf.
+ */
+export const isUitgave = (kind) => normKind(kind) === 'album';
 
 class PlaylistService {
@@ -92,5 +118,5 @@
       year: r.year || 0,
       cover: r.cover_url || '',
-      kind: r.kind || 'album',
+      kind: normKind(r.kind),
       release_date: r.release_date || '',
       mb_release_id: r.mb_release_id || '',
@@ -154,5 +180,5 @@
       year: p.year || 0,
       cover: p.cover_url || fallbackCover,
-      kind: (p.kind === 'playlist') ? 'playlist' : 'album',
+      kind: normKind(p.kind),
       // created_at hoort erbij omdat de AP-kant er `published` van maakt. Zonder
       // dit veld viel buildAlbumObject terug op 1970, en dat stond op 16-8
@@ -162,6 +188,6 @@
       // maar dit is de plek waar de editor leest en die mag niet afhangen van
       // wat er toevallig in de kolom stond.
-      release_date: p.kind === 'playlist' ? '' : (p.release_date || ''),
-      mb_release_id: p.kind === 'playlist' ? '' : (p.mb_release_id || ''),
+      release_date: isUitgave(p.kind) ? (p.release_date || '') : '',
+      mb_release_id: isUitgave(p.kind) ? (p.mb_release_id || '') : '',
       tracks: mappedTracks,
     };
@@ -178,5 +204,5 @@
     const id = this.generateId(siteId, title);
     const now = new Date().toISOString();
-    const kind = data.kind === 'playlist' ? 'playlist' : 'album';
+    const kind = normKind(data.kind);
 
     // Alleen een UITGAVE draagt deze twee. Een afspeellijst heeft geen
@@ -186,5 +212,5 @@
     // voor de post-editor -- en dan staat er stille rommel op een mixtape die
     // later als Album de deur uit gaat.
-    const uitgave = kind === 'album';
+    const uitgave = isUitgave(kind);
     const releaseDate = uitgave ? normDatum(data.release_date) : null;
     const mbRelease = uitgave ? normMbid(data.mb_release_id) : null;
@@ -229,6 +255,6 @@
     // val terug op wat er ligt.
     const nieuwKind = Object.prototype.hasOwnProperty.call(data, 'kind')
-      ? (data.kind === 'playlist' ? 'playlist' : 'album')
-      : (existing.kind || 'album');
+      ? normKind(data.kind)
+      : normKind(existing.kind);
     if (Object.prototype.hasOwnProperty.call(data, 'title')) {
       const v = String(data.title || '').trim();
Index: src/services/music/index.js
===================================================================
--- src/services/music/index.js	(revision 8ed36de2a9b6b822f55c28663bec1275f43fb70d)
+++ src/services/music/index.js	(revision b0ccd0d9b11ffb2a364ca71fd3a63aeff057890e)
@@ -15,5 +15,5 @@
 import db from '../../config/database.js';
 import { AP_CONTEXT, PUBLIC, actorId, noteId, safeUrl, guessMediaType, buildHashtagList, pagedCollection, isMbid } from '../ap-core.js';
-import { afleidenUitInsluitingen, ingeslotenPlaylists } from '../../assets/js/shared/post-music-type.js';
+import { afleidenUitInsluitingen, ingeslotenPlaylists, SOORTEN } from '../../assets/js/shared/post-music-type.js';
 // De luisteraars horen bij de muziekkant; hier doorgegeven zodat
 // ActivityPubService niet in een submap hoeft te grijpen.
@@ -495,4 +495,62 @@
  * een heeft.
  */
+/**
+ * Het bandje: EEN object, samengesteld uit de nummers van een playlist.
+ *
+ * Waarom het een eigen soort is en geen album met een ander jasje. Een album is
+ * een uitgave: het heeft een uitgavedatum, een release-id, en de nummers
+ * bestaan er los van. Een mixtape is het omgekeerde -- de volgorde IS het werk,
+ * en de nummers zijn er onderdelen van. Vandaar `orderedItems` op het object
+ * zelf in plaats van een collectie ernaast, en vandaar geen `released` en geen
+ * `musicbrainzId`: die zouden beweren dat dit een uitgave is.
+ *
+ * GEEN EIGEN `url`, en dat is een keuze van Robin (21-8) met een prijs die het
+ * waard is om hier op te schrijven. Het bandje is een logische omhulling, geen
+ * gerenderd bestand: er wordt niets samengevoegd. Een ontvanger die `Mixtape`
+ * niet kent heeft dus geen stream om te spelen. Dat is bewust -- de nummers
+ * staan er stuk voor stuk in, met hun eigen id en hun eigen url, dus er gaat
+ * niets verloren; het kost alleen een consument die het type wel begrijpt.
+ *
+ * `type` is een STRING en geen array. Dat is geen slordigheid maar een geleerde
+ * les: er stond bij de playlist-collectie ooit ['OrderedCollection', 'Album'],
+ * geldig AS2 en werkelijk allebei, en een lezer die `type` als tekst uitpakt
+ * (Shaer doet dat) verloor daarmee stil het hele object.
+ */
+export function buildMixtapeObject(base, site, pl, rows) {
+  if (!pl) return null;
+  const abs = (u) => !u ? null : (/^https?:/i.test(u) ? u : `${base}${u.startsWith('/') ? '' : '/'}${u}`);
+  const postDatum = (pl._post && pl._post.uit_wanneer) ? new Date(pl._post.uit_wanneer) : null;
+  const wanneer = postDatum ? postDatum.toISOString()
+    : (pl.created_at ? new Date(pl.created_at).toISOString() : null);
+  // Dezelfde lening als bij het album: de post die het bandje uitbrengt geeft
+  // zijn titel, en de eigen titel blijft als alsoKnownAs staan.
+  const titel = (pl._post && pl._post.title) || pl.title;
+  const items = (rows || []).map((r) => buildTrackAudio(base, site, r, { coverFallback: pl.cover_url || null }));
+  const tape = {
+    type: 'Mixtape',
+    id: `${actorId(base, site.slug)}/playlists/${pl.id}`,
+    name: titel,
+    ...(wanneer ? { published: wanneer } : {}),
+    attributedTo: actorId(base, site.slug),
+    artist_credit: artistCredit(base, site, pl.artist, wanneer || new Date().toISOString()),
+    // De kant die het bandje maakt: eerst dit nummer, dan dat. Vooruit en
+    // achteruit is de speler; de volgorde is het object.
+    totalItems: items.length,
+    orderedItems: items,
+  };
+  if (titel !== pl.title) tape.alsoKnownAs = pl.title;
+  // De speelduur van het geheel, want dat is wat een bandje heeft: een lengte.
+  // Alleen als we van ELK nummer de duur kennen -- een som met gaten erin is
+  // een verzonnen getal, en die zetten we hier niet neer (zelfde regel als bij
+  // de bitrate van een track).
+  const duren = (rows || []).map((r) => Number(r.duration) || 0);
+  if (duren.length && duren.every((d) => d > 0)) {
+    tape.duration = `PT${Math.round(duren.reduce((a, b) => a + b, 0))}S`;
+  }
+  const hoes = abs(pl.cover_url || null);
+  if (hoes) tape.image = { type: 'Image', mediaType: guessMediaType(hoes), url: hoes };
+  return tape;
+}
+
 export function buildAlbumObject(base, site, pl) {
   if (!pl) return null;
@@ -580,8 +638,19 @@
   // album, dan leest hij deze velden gewoon. En het object dat hij echt gebruikt
   // staat toch al ingesloten op de track.
-  if ((playlist.kind || 'album') === 'album') {
+  const soort = SOORTEN.includes(playlist.kind) ? playlist.kind : 'album';
+  if (soort === 'album') {
     const album = buildAlbumObject(base, site, { ...playlist, _post: post });
     for (const veld of ['published', 'released', 'musicbrainzId', 'artist_credit', 'image']) {
       if (album[veld] !== undefined) out[veld] = album[veld];
+    }
+  }
+  // Een mixtape draagt hier zijn eigen velden, om dezelfde reden als het album:
+  // dit adres is waar een lezer terechtkomt die het bandje wil ophalen, en dan
+  // hoort er hetzelfde te staan als in het ingesloten object. `type` blijft ook
+  // hier OrderedCollection -- zie de uitleg hierboven over Shaer.
+  if (soort === 'mixtape') {
+    const tape = buildMixtapeObject(base, site, { ...playlist, _post: post }, rows);
+    for (const veld of ['published', 'artist_credit', 'image', 'duration', 'alsoKnownAs']) {
+      if (tape[veld] !== undefined) out[veld] = tape[veld];
     }
   }
@@ -801,7 +870,7 @@
 
 /**
- * De gekozen soort van een playlist: 'album' | 'playlist', of null als hij niet
- * (op deze site) bestaat. Zelfde normalisatie als PlaylistService: alles wat
- * geen 'playlist' zegt is een album.
+ * De gekozen soort van een playlist: 'album' | 'playlist' | 'mixtape', of null
+ * als hij niet (op deze site) bestaat. Zelfde lijst als PlaylistService, via
+ * de gedeelde pure module -- alles wat er niet in staat is een album.
  */
 function playlistKind(id, siteId) {
@@ -810,5 +879,5 @@
     const r = db.prepare('SELECT kind FROM playlists WHERE id = ? AND site_id = ?').get(id, siteId);
     if (!r) return null;
-    return r.kind === 'playlist' ? 'playlist' : 'album';
+    return SOORTEN.includes(r.kind) ? r.kind : 'album';
   } catch { return null; }
 }