@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/lib/tracker/sync-state.js

@@ -1,21 +0,0 @@
-import { SettingsRepository } from '../../repositories/settings.repository.js';
-export async function readTrackerSyncState(db, key) {
-    const row = await SettingsRepository.getByKey(db, key);
-    if (!row?.value)
-        return {};
-    try {
-        return JSON.parse(row.value);
-    }
-    catch {
-        return {};
-    }
-}
-export function resolveStatus(localStatus, remoteStatus, remoteUpdated, localLastSync) {
-    if (remoteUpdated > localLastSync && remoteStatus !== localStatus) {
-        return { status: remoteStatus, pull: true };
-    }
-    if (remoteStatus !== localStatus) {
-        return { status: localStatus, pull: false };
-    }
-    return { status: localStatus, pull: false };
-}

package/server/dist/lib/tracker/sync.service.js

@@ -1,476 +0,0 @@
-import { AniListTracker } from './anilist-tracker.js';
-import { WatchlistRepository } from '../../repositories/watchlist.repository.js';
-import { WatchedEpisodesRepository } from '../../repositories/watched-episodes.repository.js';
-import { ShowsMetaRepository } from '../../repositories/shows-meta.repository.js';
-import { SettingsRepository } from '../../repositories/settings.repository.js';
-import { NotificationsRepository } from '../../repositories/notifications.repository.js';
-import { performWriteTransactionAsync } from '../../sync.js';
-import { dbGet } from '../../utils/db-utils.js';
-import logger from '../../logger.js';
-import { fetchMalUserList } from '../mal.js';
-import { offlineDb } from '../offline-db.js';
-import { getShowMetaById, getShowMetaByMalId, isAnilistRateLimited, searchAnilistByTitle, } from '../anilist.js';
-import { kitsuSearchAnime } from '../kitsu.js';
-import { readTrackerSyncState, resolveStatus, } from './sync-state.js';
-const TOKEN_KEY = 'tracker_anilist_token';
-const SYNC_STATE_KEY = 'tracker_anilist_sync_state';
-async function getWatchedCount(db, showId) {
-    const row = await dbGet(db, 'SELECT COUNT(DISTINCT episodeNumber) as total FROM watched_episodes WHERE showId = ?', [showId]);
-    return row?.total ?? 0;
-}
-export async function syncAniList(db) {
-    const tokenRow = await SettingsRepository.getByKey(db, TOKEN_KEY);
-    const token = tokenRow?.value;
-    if (!token)
-        throw new Error('AniList is not connected. Please log in first.');
-    const tracker = new AniListTracker(token);
-    const viewer = await tracker.getViewer();
-    const remoteEntries = await tracker.fetchUserAnimeList(viewer.id);
-    const localItems = await WatchlistRepository.getAll(db);
-    const syncState = await readTrackerSyncState(db, SYNC_STATE_KEY);
-    const remoteByMediaId = new Map();
-    for (const entry of remoteEntries)
-        remoteByMediaId.set(entry.mediaId, entry);
-    const localByMediaId = new Map();
-    for (const item of localItems) {
-        const meta = (await ShowsMetaRepository.getById(db, item.id));
-        const anilistId = meta?.anilistId;
-        if (anilistId == null || !Number.isFinite(anilistId) || String(anilistId) !== String(item.id)) {
-            continue;
-        }
-        if (!localByMediaId.has(anilistId)) {
-            localByMediaId.set(anilistId, item);
-        }
-    }
-    const allMediaIds = new Set([
-        ...localByMediaId.keys(),
-        ...remoteByMediaId.keys(),
-        ...Object.keys(syncState)
-            .map((k) => Number.parseInt(k, 10))
-            .filter((n) => Number.isFinite(n)),
-    ]);
-    const summary = { pushed: 0, pulled: 0, merged: 0, unchanged: 0, errors: [] };
-    const watchlistUpserts = [];
-    const metaUpserts = [];
-    const watchedInserts = [];
-    const stateUpdates = {};
-    const watchlistDeletes = [];
-    const pushUpdates = [];
-    const remoteDeleteEntryIds = [];
-    const now = Math.floor(Date.now() / 1000);
-    for (const mediaId of allMediaIds) {
-        const local = localByMediaId.get(mediaId);
-        const remote = remoteByMediaId.get(mediaId);
-        const showId = String(mediaId);
-        try {
-            if (local && !remote) {
-                if (syncState[showId] && remoteEntries.length > 0) {
-                    watchlistDeletes.push(showId);
-                    stateUpdates[showId] = undefined;
-                    summary.pulled++;
-                    continue;
-                }
-                const watchedCount = await getWatchedCount(db, showId);
-                pushUpdates.push({
-                    mediaId,
-                    status: DANGO_STATUS_OR_FALLBACK(local.status),
-                    progress: watchedCount,
-                });
-                stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: now };
-                summary.pushed++;
-                continue;
-            }
-            if (!local && remote) {
-                if (syncState[showId]) {
-                    if (remote.entryId) {
-                        remoteDeleteEntryIds.push({ showId, entryId: remote.entryId });
-                        stateUpdates[showId] = undefined;
-                        summary.pushed++;
-                        continue;
-                    }
-                    stateUpdates[showId] = undefined;
-                    summary.pushed++;
-                    continue;
-                }
-                logger.debug({ mediaId, remoteStatus: remote.status }, '[AniList Sync] Remote only -> pulling to local');
-                const title = remote.title.english || remote.title.romaji || `Anime #${mediaId}`;
-                watchlistUpserts.push({
-                    id: showId,
-                    name: title,
-                    thumbnail: remote.coverImage ?? '',
-                    status: remote.status,
-                    nativeName: remote.title.native ?? '',
-                    englishName: remote.title.english ?? '',
-                    type: 'TV',
-                });
-                metaUpserts.push({
-                    id: showId,
-                    name: title,
-                    thumbnail: remote.coverImage,
-                    nativeName: remote.title.native,
-                    englishName: remote.title.english,
-                    episodeCount: remote.totalEpisodes,
-                    anilistId: mediaId,
-                    episodeDuration: remote.episodeDuration,
-                });
-                if (remote.progress > 0) {
-                    watchedInserts.push({ showId, from: 1, to: remote.progress, updatedAt: remote.updatedAt });
-                }
-                stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: remote.updatedAt };
-                summary.pulled++;
-                continue;
-            }
-            if (!local && !remote && syncState[showId]) {
-                stateUpdates[showId] = undefined;
-                continue;
-            }
-            if (local && remote) {
-                const watchedCount = await getWatchedCount(db, showId);
-                const localLastSync = syncState[showId]?.lastSyncedAt ?? 0;
-                const remoteUpdated = remote.updatedAt || 0;
-                const targetProgress = Math.max(watchedCount, remote.progress);
-                const shouldPushProgress = watchedCount > remote.progress;
-                const shouldPullProgress = remote.progress > watchedCount;
-                const { status: targetStatus, pull: pullStatus } = resolveStatus(local.status, remote.status, remoteUpdated, localLastSync);
-                const statusDiffers = remote.status !== local.status;
-                if (shouldPushProgress || (!pullStatus && statusDiffers)) {
-                    pushUpdates.push({
-                        mediaId,
-                        status: targetStatus,
-                        progress: targetProgress,
-                    });
-                    if (targetStatus !== local.status) {
-                        watchlistUpserts.push({
-                            id: showId,
-                            name: local.name,
-                            thumbnail: local.thumbnail ?? '',
-                            status: targetStatus,
-                            nativeName: local.nativeName ?? '',
-                            englishName: local.englishName ?? '',
-                            type: local.type ?? '',
-                        });
-                    }
-                    if (shouldPullProgress) {
-                        watchedInserts.push({
-                            showId,
-                            from: watchedCount + 1,
-                            to: targetProgress,
-                            updatedAt: remoteUpdated,
-                        });
-                    }
-                    stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: now };
-                    summary.merged++;
-                }
-                else if (pullStatus || shouldPullProgress) {
-                    if (targetStatus !== local.status) {
-                        watchlistUpserts.push({
-                            id: showId,
-                            name: local.name,
-                            thumbnail: local.thumbnail ?? '',
-                            status: targetStatus,
-                            nativeName: local.nativeName ?? '',
-                            englishName: local.englishName ?? '',
-                            type: local.type ?? '',
-                        });
-                    }
-                    if (shouldPullProgress) {
-                        watchedInserts.push({
-                            showId,
-                            from: watchedCount + 1,
-                            to: targetProgress,
-                            updatedAt: remoteUpdated,
-                        });
-                    }
-                    stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: remoteUpdated };
-                    summary.merged++;
-                }
-                else {
-                    summary.unchanged++;
-                }
-            }
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            logger.warn({ err, mediaId }, '[AniList Sync] Entry failed');
-            summary.errors.push(`${local?.name ?? `Media ${mediaId}`}: ${message}`);
-        }
-    }
-    if (pushUpdates.length > 0 || remoteDeleteEntryIds.length > 0 || watchlistDeletes.length > 0) {
-        const deleteCap = Math.max(5, Math.ceil(localItems.length * 0.1));
-        const totalDeletes = watchlistDeletes.length + remoteDeleteEntryIds.length;
-        if (totalDeletes > deleteCap) {
-            throw new Error(`AniList sync would delete ${totalDeletes} shows but only ${remoteEntries.length} were fetched. Aborting to protect your library — if you really removed that many shows on AniList, delete them locally first and sync again.`);
-        }
-    }
-    if (pushUpdates.length > 0) {
-        const batchSize = 10;
-        for (let i = 0; i < pushUpdates.length; i += batchSize) {
-            const batch = pushUpdates.slice(i, i + batchSize);
-            await tracker.batchUpdateMediaEntries(batch);
-        }
-    }
-    if (remoteDeleteEntryIds.length > 0) {
-        const deleteBatch = remoteDeleteEntryIds.map((r) => r.entryId);
-        const batchSize = 10;
-        for (let i = 0; i < deleteBatch.length; i += batchSize) {
-            const batch = deleteBatch.slice(i, i + batchSize);
-            await tracker.batchDeleteMediaEntries(batch);
-        }
-    }
-    if (watchlistUpserts.length > 0 ||
-        metaUpserts.length > 0 ||
-        watchedInserts.length > 0 ||
-        watchlistDeletes.length > 0 ||
-        Object.keys(stateUpdates).length > 0) {
-        await performWriteTransactionAsync(db, async (tx) => {
-            for (const item of watchlistUpserts) {
-                await WatchlistRepository.upsert(tx, item);
-            }
-            for (const meta of metaUpserts) {
-                await ShowsMetaRepository.upsert(tx, meta);
-            }
-            for (const w of watchedInserts) {
-                for (let ep = w.from; ep <= w.to; ep++) {
-                    await WatchedEpisodesRepository.insertIfMissing(tx, {
-                        showId: w.showId,
-                        episodeNumber: String(ep),
-                        watchedAt: toSqliteDatetime(w.updatedAt),
-                    });
-                }
-            }
-            for (const id of watchlistDeletes) {
-                await WatchlistRepository.delete(tx, id);
-                await WatchedEpisodesRepository.deleteByShow(tx, id);
-                await NotificationsRepository.deleteByShow(tx, id);
-            }
-            const mergedState = { ...syncState };
-            for (const [k, v] of Object.entries(stateUpdates)) {
-                if (v === undefined)
-                    delete mergedState[k];
-                else
-                    mergedState[k] = v;
-            }
-            await SettingsRepository.upsert(tx, SYNC_STATE_KEY, JSON.stringify(mergedState));
-        });
-    }
-    return summary;
-}
-function toSqliteDatetime(unixSeconds) {
-    if (!unixSeconds || unixSeconds <= 0)
-        return undefined;
-    return new Date(unixSeconds * 1000).toISOString().slice(0, 19).replace('T', ' ');
-}
-function DANGO_STATUS_OR_FALLBACK(status) {
-    const known = ['Watching', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
-    return known.includes(status) ? status : undefined;
-}
-export async function importFromUsername(db, username, erase = false) {
-    const tokenRow = await SettingsRepository.getByKey(db, TOKEN_KEY);
-    const token = tokenRow?.value;
-    const tracker = new AniListTracker(token);
-    let entries;
-    if (token) {
-        const viewer = await tracker.getViewer();
-        entries = await tracker.fetchUserAnimeList(viewer.id);
-    }
-    else {
-        entries = await tracker.fetchUserAnimeList(username);
-    }
-    if (entries.length === 0)
-        return 0;
-    const now = Math.floor(Date.now() / 1000);
-    const syncState = await readTrackerSyncState(db, SYNC_STATE_KEY);
-    await performWriteTransactionAsync(db, async (tx) => {
-        if (erase)
-            await SettingsRepository.clearWatchlist(tx);
-        for (const remote of entries) {
-            const showId = String(remote.mediaId);
-            const title = remote.title.english || remote.title.romaji || `Anime #${remote.mediaId}`;
-            await WatchlistRepository.upsert(tx, {
-                id: showId,
-                name: title,
-                thumbnail: remote.coverImage ?? '',
-                status: remote.status,
-                nativeName: remote.title.native ?? '',
-                englishName: remote.title.english ?? '',
-                type: 'TV',
-            });
-            await ShowsMetaRepository.upsert(tx, {
-                id: showId,
-                name: title,
-                thumbnail: remote.coverImage,
-                nativeName: remote.title.native,
-                englishName: remote.title.english,
-                episodeCount: remote.totalEpisodes,
-                anilistId: remote.mediaId,
-            });
-            if (remote.progress > 0) {
-                for (let ep = 1; ep <= remote.progress; ep++) {
-                    await WatchedEpisodesRepository.insertIfMissing(tx, {
-                        showId,
-                        episodeNumber: String(ep),
-                        watchedAt: toSqliteDatetime(remote.updatedAt),
-                    });
-                }
-            }
-            syncState[showId] = { lastSyncedAt: now, remoteUpdatedAt: remote.updatedAt };
-        }
-        await SettingsRepository.upsert(tx, SYNC_STATE_KEY, JSON.stringify(syncState));
-    });
-    return entries.length;
-}
-function mapMalListStatus(status) {
-    switch (status) {
-        case 1:
-            return 'Watching';
-        case 2:
-            return 'Completed';
-        case 3:
-            return 'On-Hold';
-        case 4:
-            return 'Dropped';
-        case 6:
-            return 'Planned';
-        default:
-            return null;
-    }
-}
-async function searchTitleForMalImport(title) {
-    const result = await searchAnilistByTitle(title);
-    if (result)
-        return result.id;
-    if (isAnilistRateLimited()) {
-        try {
-            const fb = await kitsuSearchAnime({ query: title, page: 1, perPage: 5 });
-            if (fb.length > 0)
-                return fb[0].id > 0 ? fb[0].id : null;
-        }
-        catch {
-            // ignore
-        }
-    }
-    return null;
-}
-export async function importFromMalUsername(db, username, options = {}) {
-    const { erase = false, useOfflineDb = true, skipFallback = false } = options;
-    const entries = await fetchMalUserList(username);
-    if (entries.length === 0)
-        return 0;
-    const shows = [];
-    const metas = [];
-    const watched = [];
-    const fallbackQueue = [];
-    for (const entry of entries) {
-        const status = mapMalListStatus(entry.status);
-        if (!status)
-            continue;
-        const offline = useOfflineDb ? offlineDb.getByMalId(entry.malId) : null;
-        if (offline) {
-            const showId = String(offline.anilistId);
-            const title = offline.title || entry.titleEnglish || entry.title || `MAL #${entry.malId}`;
-            shows.push({
-                id: showId,
-                name: title,
-                thumbnail: offline.thumbnail ?? entry.imageUrl ?? undefined,
-                status,
-                englishName: entry.titleEnglish ?? undefined,
-                type: offline.type ?? entry.type ?? undefined,
-            });
-            if (offline.thumbnail || offline.type || offline.genres) {
-                metas.push({
-                    id: showId,
-                    thumbnail: offline.thumbnail,
-                    type: offline.type,
-                    genres: offline.genres,
-                });
-            }
-            if (entry.watchedEpisodes > 0)
-                watched.push({ showId, progress: entry.watchedEpisodes });
-        }
-        else {
-            fallbackQueue.push(entry);
-        }
-    }
-    if (fallbackQueue.length > 0 && !skipFallback) {
-        const BATCH_SIZE = 5;
-        for (let i = 0; i < fallbackQueue.length; i += BATCH_SIZE) {
-            const batch = fallbackQueue.slice(i, i + BATCH_SIZE);
-            const results = await Promise.allSettled(batch.map(async (entry) => {
-                const byMal = await getShowMetaByMalId(entry.malId).catch(() => null);
-                if (byMal?.anilistId)
-                    return byMal;
-                const title = entry.titleEnglish || entry.title;
-                if (!title)
-                    return null;
-                const id = await searchTitleForMalImport(title);
-                if (!id)
-                    return null;
-                return getShowMetaById(String(id)).catch(() => null);
-            }));
-            results.forEach((r, idx) => {
-                if (r.status !== 'fulfilled' || !r.value)
-                    return;
-                const meta = r.value;
-                const entry = batch[idx];
-                const status = mapMalListStatus(entry.status);
-                if (!status)
-                    return;
-                const showId = meta.anilistId ? String(meta.anilistId) : meta._id;
-                const title = meta.names?.english ||
-                    meta.names?.romaji ||
-                    entry.titleEnglish ||
-                    entry.title ||
-                    `MAL #${entry.malId}`;
-                shows.push({
-                    id: showId,
-                    name: title,
-                    thumbnail: meta.thumbnail || entry.imageUrl || undefined,
-                    status,
-                    englishName: entry.titleEnglish ?? undefined,
-                    type: meta.type ?? entry.type ?? 'TV',
-                });
-                if (meta.thumbnail || meta.type) {
-                    metas.push({ id: showId, thumbnail: meta.thumbnail, type: meta.type });
-                }
-                if (entry.watchedEpisodes > 0)
-                    watched.push({ showId, progress: entry.watchedEpisodes });
-            });
-        }
-    }
-    if (shows.length > 0 || erase) {
-        await performWriteTransactionAsync(db, async (tx) => {
-            if (erase)
-                await SettingsRepository.clearWatchlist(tx);
-            for (const show of shows) {
-                await WatchlistRepository.upsert(tx, {
-                    id: show.id,
-                    name: show.name,
-                    thumbnail: show.thumbnail ?? '',
-                    status: show.status,
-                    nativeName: '',
-                    englishName: show.englishName ?? '',
-                    type: show.type ?? 'TV',
-                });
-            }
-            for (const meta of metas) {
-                if (meta.thumbnail || meta.type || meta.genres) {
-                    await ShowsMetaRepository.upsert(tx, {
-                        id: meta.id,
-                        thumbnail: meta.thumbnail,
-                        type: meta.type,
-                        genres: meta.genres,
-                    });
-                }
-            }
-            for (const w of watched) {
-                for (let ep = 1; ep <= w.progress; ep++) {
-                    await WatchedEpisodesRepository.insertIfMissing(tx, {
-                        showId: w.showId,
-                        episodeNumber: String(ep),
-                    });
-                }
-            }
-        });
-    }
-    return shows.length;
-}

package/server/dist/lib/translate.js

@@ -1,79 +0,0 @@
-import { AppCache } from '../utils/cache.utils.js';
-import { parseJsonBody } from '../utils/http.utils.js';
-const cache = new AppCache({
-    ttlSeconds: 7 * 24 * 60 * 60,
-    maxKeys: 5000,
-});
-function toTitleCase(s) {
-    return s
-        .split(' ')
-        .map((w, i) => {
-        if (i !== 0 &&
-            ['x', 'and', 'or', 'the', 'a', 'an', 'of', 'in', 'on', 'with'].includes(w.toLowerCase())) {
-            return w.toLowerCase();
-        }
-        return w.charAt(0).toUpperCase() + w.slice(1);
-    })
-        .join(' ')
-        .replace(/\bX\b/g, 'x');
-}
-function normalize(s) {
-    const t = s.trim();
-    if (!t)
-        return t;
-    return toTitleCase(t);
-}
-export async function translateTexts(texts, source, target) {
-    const jobs = texts.map((t) => String(t).trim()).filter(Boolean);
-    const result = {};
-    const toFetch = [];
-    for (const t of jobs) {
-        const key = `${source}:${target}:${t}`;
-        const cached = cache.get(key);
-        if (cached)
-            result[t] = cached;
-        else
-            toFetch.push(t);
-    }
-    if (toFetch.length > 0) {
-        const chunks = [];
-        for (let i = 0; i < toFetch.length; i += 15)
-            chunks.push(toFetch.slice(i, i + 15));
-        for (const chunk of chunks) {
-            const q = chunk.join('\n');
-            const url = `https://clients5.google.com/translate_a/t?client=dict-chrome-ex&sl=${encodeURIComponent(source)}&tl=${encodeURIComponent(target)}&dt=t&q=${encodeURIComponent(q)}`;
-            try {
-                const r = await fetch(url, {
-                    headers: { 'User-Agent': 'Mozilla/5.0' },
-                    signal: AbortSignal.timeout(5000),
-                });
-                if (!r.ok)
-                    throw new Error(`translate ${r.status}`);
-                const data = (await parseJsonBody(r));
-                let translated = '';
-                if (Array.isArray(data) && typeof data[0] === 'string') {
-                    translated = data[0];
-                }
-                else if (Array.isArray(data) && Array.isArray(data[0])) {
-                    const outer = data;
-                    translated = outer[0]?.map((p) => p[0]).join('') || '';
-                }
-                const parts = translated.split('\n');
-                chunk.forEach((orig, i) => {
-                    const trans = (parts[i] ?? '').trim();
-                    const norm = trans ? normalize(trans) : orig;
-                    result[orig] = norm;
-                    cache.set(`${source}:${target}:${orig}`, norm);
-                });
-            }
-            catch {
-                for (const orig of chunk) {
-                    if (!result[orig])
-                        result[orig] = orig;
-                }
-            }
-            await new Promise((r) => setTimeout(r, 80));
-        }
-    }
-    return result;
-}

package/server/dist/lib/ump.js

@@ -1,106 +0,0 @@
-const MEDIA_HEADER = 20;
-const MEDIA = 21;
-const STREAM_PROTECTION_STATUS = 58;
-function readVarint(buf, pos) {
-    if (pos >= buf.length)
-        return null;
-    const prefix = buf[pos];
-    let size = 0;
-    for (let shift = 1; shift <= 5; shift++) {
-        if ((prefix & (128 >> (shift - 1))) === 0) {
-            size = shift;
-            break;
-        }
-    }
-    if (size < 1 || pos + size > buf.length)
-        return null;
-    if (size === 1)
-        return [prefix, pos + 1];
-    if (size === 5) {
-        const value = buf[pos + 1] + buf[pos + 2] * 256 + buf[pos + 3] * 65536 + buf[pos + 4] * 16777216;
-        return [value >>> 0, pos + 5];
-    }
-    const lowBits = 8 - size;
-    let value = prefix & ((1 << lowBits) - 1);
-    for (let i = 1; i < size; i++) {
-        value += buf[pos + i] * 2 ** (lowBits + 8 * (i - 1));
-    }
-    return [value, pos + size];
-}
-function readStatusField(payload) {
-    let pos = 0;
-    while (pos < payload.length) {
-        const key = payload[pos++];
-        const field = key >> 3;
-        const wire = key & 7;
-        if (wire !== 0)
-            break;
-        const decoded = readVarint(payload, pos);
-        if (!decoded)
-            break;
-        if (field === 1)
-            return decoded[0];
-        pos = decoded[1];
-    }
-    return 1;
-}
-export function parseUmpResponse(buf, carry) {
-    const mediaChunks = [];
-    let status = 1;
-    let nextCarry = carry;
-    let pos = 0;
-    if (nextCarry) {
-        const t = readVarint(buf, pos);
-        const s = t && readVarint(buf, t[1]);
-        if (t && s && t[0] === MEDIA_HEADER) {
-            pos = s[1] + s[0];
-        }
-        const ct = readVarint(buf, pos);
-        const cs = ct && readVarint(buf, ct[1]);
-        if (ct && cs && ct[0] === nextCarry.pendingType) {
-            pos = cs[1];
-            const take = Math.min(cs[0], buf.length - pos);
-            nextCarry.chunks.push(buf.subarray(pos, pos + take));
-            nextCarry.remaining = cs[0] - take;
-            pos += take;
-            if (nextCarry.remaining <= 0) {
-                const full = Buffer.concat(nextCarry.chunks);
-                nextCarry = null;
-                if (ct[0] === MEDIA && full.length > 1)
-                    mediaChunks.push(full.subarray(1));
-            }
-        }
-        else {
-            nextCarry = null;
-        }
-    }
-    while (pos < buf.length) {
-        const t = readVarint(buf, pos);
-        if (!t)
-            break;
-        const s = readVarint(buf, t[1]);
-        if (!s)
-            break;
-        const [type, size] = [t[0], s[0]];
-        pos = s[1];
-        const available = buf.length - pos;
-        if (size > available) {
-            nextCarry = {
-                pendingType: type,
-                remaining: size - available,
-                chunks: [buf.subarray(pos)],
-            };
-            break;
-        }
-        const payload = buf.subarray(pos, pos + size);
-        pos += size;
-        if (type === MEDIA) {
-            if (payload.length > 1)
-                mediaChunks.push(payload.subarray(1));
-        }
-        else if (type === STREAM_PROTECTION_STATUS) {
-            status = readStatusField(payload);
-        }
-    }
-    return { media: Buffer.concat(mediaChunks), status, carry: nextCarry };
-}