funoteka 0.1.0

package/dist/cue/match.js

@@ -0,0 +1,142 @@
+import { basenameOf, folderOf, stemOf } from "../util/names.js";
+/**
+ * A cue's `FILE` reference, resolved to a root-relative path.
+ *
+ * References are written relative to the cue's own folder, and rips do use
+ * `..` — a cue sitting above the audio it describes is a real layout. Without
+ * resolving, a `FILE "../x.flac"` could only ever match a same-named file
+ * beside the cue, which is the one place the file is not.
+ */
+export function resolveRef(cueFolder, ref) {
+    const parts = cueFolder === '' ? [] : cueFolder.split('/');
+    for (const segment of ref.replace(/\\/g, '/').split('/')) {
+        if (segment === '' || segment === '.')
+            continue;
+        if (segment === '..') {
+            parts.pop();
+            continue;
+        }
+        parts.push(segment);
+    }
+    return parts.join('/');
+}
+/** Higher wins. A name is better evidence than a stem. */
+const SCORE = { 'exact-name': 3, stem: 2 };
+/**
+ * Every landing a cue's own `FILE` tags make on the files the folder actually
+ * holds, in reference order.
+ *
+ * The one loop both questions below are put through. Written once because
+ * "which file does this reference name" must not answer differently depending
+ * on who is asking: the matcher wants the single best landing, and the plan
+ * wants to know whether the cue named the folder whole or only a part of it.
+ */
+function refMatches(cue, audioFiles) {
+    const cueFolder = folderOf(cue.relPath);
+    const found = [];
+    for (const ref of cue.doc.files) {
+        const resolved = resolveRef(cueFolder, ref.name).toLowerCase();
+        const resolvedFolder = folderOf(resolved);
+        const resolvedStem = stemOf(basenameOf(resolved));
+        for (const audio of audioFiles) {
+            const path = audio.relPath.toLowerCase();
+            let how = null;
+            if (path === resolved) {
+                how = 'exact-name';
+            }
+            else if (folderOf(path) === resolvedFolder && stemOf(basenameOf(path)) === resolvedStem) {
+                // Same folder, same stem, different extension. A cue declaring `.wav`
+                // for a rip that is really `.flac` lands here — and only here, since
+                // the folder has to agree, so it cannot reach across albums.
+                how = 'stem';
+            }
+            if (how === null)
+                continue;
+            found.push({ audio, how });
+        }
+    }
+    return found;
+}
+/**
+ * The audio file a cue's own `FILE` tags name, resolved against the files the
+ * folder actually holds — or null when they name nothing that is there.
+ *
+ * This is `chooseCue`'s per-cue half, split out because a caller has a second
+ * question to put to it: a cue the matcher did *not* pick still has to be told
+ * apart from a cue that describes nothing at all, and only that cue's own
+ * references can answer which one it is. Asking the album's match instead
+ * answers about the wrong cue.
+ */
+export function audioNamedBy(cue, audioFiles) {
+    let best = null;
+    for (const match of refMatches(cue, audioFiles)) {
+        if (best === null || SCORE[match.how] > SCORE[best.how])
+            best = match;
+    }
+    return best;
+}
+/**
+ * The audio files a cue's own `FILE` tags name — the plural of the question
+ * `audioNamedBy` answers.
+ *
+ * The plan has to put this one, because "does this cue describe these files" is
+ * a question about the whole folder and not about the one file a match settles
+ * on. Counting a cue's TRACK tags against a folder's audio files looks like the
+ * same test and is not: a cue naming one file under two TRACK tags has the same
+ * count as a folder holding two files, so the second file was handed a title
+ * the cue never wrote for it (task:2723). Only the references can answer it.
+ *
+ * Answers in the folder's own order, and names each file once however many
+ * references reach it — a cue that repeats `FILE` per track is ordinary.
+ */
+export function audioNamedByCue(cue, audioFiles) {
+    const named = new Set();
+    for (const match of refMatches(cue, audioFiles))
+        named.add(match.audio);
+    return audioFiles.filter((audio) => named.has(audio));
+}
+/**
+ * Decide which cue in a folder describes which audio file.
+ *
+ * The cue's `FILE` tag is treated as a hint, never as truth — real rips declare
+ * `WAVE` for an `.m4a` and `.wav` for a `.flac`. Resolution runs against the
+ * audio files that are actually present, in descending order of evidence:
+ *
+ *   1. the basename matches exactly (ignoring case)
+ *   2. the basename matches once extensions are dropped — this is what catches
+ *      the `.wav`-declared `.flac`
+ *
+ * Those two are the whole of it: a cue whose `FILE` tags land on none of the
+ * folder's audio is answered `null`, because it does not describe these files.
+ *
+ * A third rule used to stand below them — nothing matched, but the folder held
+ * exactly one audio file and at least one cue, so take the two as belonging
+ * together — and it was a guess wearing the clothes of a reading. Its cost was
+ * total: a stale cue for a rip that is not here ([[task:2712]]) sat above a
+ * one-file, fully tagged album, cut that file into the stranger's three
+ * segments, gave them the stranger's three titles and wrote them under
+ * `title_source = 'cue'` — the value `011_track_title_source.sql` reserves for
+ * a cue that *describes* these files. The album's real track was gone and
+ * nothing was reported. Which cue describes which audio is the question this
+ * module exists to answer; "neither does, so probably this one" is not an
+ * answer it can give, and being wrong costs an album its tracks. A cue that
+ * names audio the folder no longer holds is reported instead — see the loser
+ * loop in `cue/engine.ts`.
+ *
+ * A folder with several cues is normal (rippers leave a stale one behind); the
+ * best-scoring cue wins, and ties fall to the first path so repeated scans
+ * agree.
+ */
+export function chooseCue(cues, audioFiles) {
+    const ordered = [...cues].sort((a, b) => (a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0));
+    let best = null;
+    for (const cue of ordered) {
+        const named = audioNamedBy(cue, audioFiles);
+        if (named === null)
+            continue;
+        if (best === null || SCORE[named.how] > SCORE[best.how]) {
+            best = { cue, audio: named.audio, how: named.how };
+        }
+    }
+    return best;
+}

package/dist/cue/parse.js

@@ -0,0 +1,182 @@
+/**
+ * A cue sheet, reported exactly as written.
+ *
+ * The parser deliberately makes no judgement calls. It does not decide that a
+ * `FILE ... WAVE` line is really an `.m4a`, does not fall back to the album
+ * PERFORMER for a track that lacks one, and does not tidy a missing INDEX 01.
+ * Those are decisions with consequences, and they belong to the matcher, which
+ * can record what it assumed. Here, what the file says is what comes out.
+ */
+/** 75 CD frames to the second — the unit INDEX timestamps are counted in. */
+const FRAMES_PER_SECOND = 75;
+/**
+ * `mm:ss:ff` to milliseconds, or null when the value is not a cue time at all.
+ *
+ * Frames are optional because some rippers write plain `mm:ss`. Seconds and
+ * frames are range-checked so a malformed timestamp is reported rather than
+ * quietly turned into a plausible-looking offset.
+ */
+export function parseCueTime(value) {
+    const match = /^(\d{1,3}):(\d{2})(?::(\d{2}))?$/.exec(value.trim());
+    if (!match)
+        return null;
+    const minutes = Number(match[1]);
+    const seconds = Number(match[2]);
+    const frames = match[3] === undefined ? 0 : Number(match[3]);
+    if (seconds > 59 || frames >= FRAMES_PER_SECOND)
+        return null;
+    return minutes * 60_000 + seconds * 1000 + Math.round((frames * 1000) / FRAMES_PER_SECOND);
+}
+const FILE_LINE = /^FILE\s+(?:"([^"]*)"|(\S+))(?:\s+(\S+))?\s*$/i;
+const TRACK_LINE = /^TRACK\s+(\d+)\s+(\S+)/i;
+const INDEX_LINE = /^INDEX\s+(\d{1,2})\s+(\S+)/i;
+const REM_LINE = /^REM\s+(\S+)\s*(.*)$/i;
+const FIELD_LINE = /^(TITLE|PERFORMER)\s+(.*)$/i;
+/**
+ * Commands a cue sheet carries that this reader reads nothing out of.
+ *
+ * Dropping one of these is a decision, not a failure to understand: the pregap
+ * is where the split stage already gets its answer from `INDEX 00`, the flags
+ * and the ISRC describe the disc, and the songwriter is a credit the artist
+ * stage does not take from a cue. Counting them as unrecognised would make the
+ * counter fire on most cues in the library and say nothing by doing so.
+ *
+ * `CATALOG` is deliberately **not** here, though it reads like the others. It
+ * was, until the counter was pointed at the library and the vocabulary of all
+ * 263 cues was counted: 21 of them state a catalogue number as a bare `CATALOG`
+ * line, and not one of those 21 writes it as `REM CATALOG` as well. The column
+ * that exists for it is filled from the `REM` form alone, so those 21 numbers —
+ * real EANs, `4988015085082`, `0602475036746` — reached no column and no report.
+ * A command whose value goes nowhere was never "understood and not kept"; it
+ * was the same silence this counter is here to end (task:2756, finding 2).
+ */
+const IGNORED_LINE = /^(?:CDTEXTFILE|FLAGS|ISRC|POSTGAP|PREGAP|SONGWRITER)\b/i;
+/**
+ * The media catalogue number, which a cue states under its own command.
+ *
+ * Kept in the same map the `REM` form lands in, so the caller reads one key —
+ * `cue.catalog` is filled from `doc.rem['CATALOG']` and does not have to learn
+ * about a second spelling. When a cue writes both, the *command* is the one
+ * that stands: `REM` is a comment convention and `CATALOG` is the format's own
+ * field for the number, so the reading is settled by position in the grammar
+ * rather than by line order. No cue in the collection writes both; the rule is
+ * here so that the first one that does is read the same way twice.
+ */
+const CATALOG_LINE = /^CATALOG\s+(.*)$/i;
+/** The commands this parser does read, for telling a broken line from a foreign one. */
+const READ_COMMAND = /^(?:FILE|TRACK|INDEX|REM|TITLE|PERFORMER)\b/i;
+function unquote(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+export function parseCue(text) {
+    const doc = {
+        title: null,
+        performer: null,
+        rem: {},
+        files: [],
+        tracks: [],
+        unrecognized: [],
+    };
+    let current = null;
+    // Held apart from `rem` until the end so that the command outranks the
+    // comment however the two are ordered in the file — see `CATALOG_LINE`.
+    let statedCatalog = null;
+    // A BOM would otherwise attach itself to the first key and silently lose it.
+    const lines = text.replace(/^/, '').split(/\r?\n/);
+    for (let lineNo = 0; lineNo < lines.length; lineNo += 1) {
+        const line = (lines[lineNo] ?? '').trim();
+        if (line === '')
+            continue;
+        const file = FILE_LINE.exec(line);
+        if (file) {
+            doc.files.push({ name: file[1] ?? file[2] ?? '', type: file[3] ?? null });
+            continue;
+        }
+        const track = TRACK_LINE.exec(line);
+        if (track) {
+            current = {
+                ordinal: Number(track[1]),
+                type: (track[2] ?? 'AUDIO').toUpperCase(),
+                title: null,
+                performer: null,
+                index00Ms: null,
+                index01Ms: null,
+                index00FileIndex: null,
+                index01FileIndex: null,
+                fileIndex: Math.max(0, doc.files.length - 1),
+            };
+            doc.tracks.push(current);
+            continue;
+        }
+        const index = INDEX_LINE.exec(line);
+        if (index && current) {
+            const ms = parseCueTime(index[2] ?? '');
+            if (ms !== null) {
+                // The file in force at *this* line, which is what makes the time mean
+                // something: a cue writes a track's pregap at the end of the file before
+                // the one the track opens, so the two marks can be in different files
+                // and their times are then counted from different starts.
+                const at = Math.max(0, doc.files.length - 1);
+                if (index[1] === '00') {
+                    current.index00Ms = ms;
+                    current.index00FileIndex = at;
+                }
+                else if (index[1] === '01') {
+                    current.index01Ms = ms;
+                    current.index01FileIndex = at;
+                }
+            }
+            continue;
+        }
+        const rem = REM_LINE.exec(line);
+        if (rem) {
+            const key = (rem[1] ?? '').toUpperCase();
+            if (key !== '')
+                doc.rem[key] = unquote(rem[2] ?? '');
+            continue;
+        }
+        const catalog = CATALOG_LINE.exec(line);
+        if (catalog) {
+            const value = unquote(catalog[1] ?? '');
+            if (value !== '')
+                statedCatalog = value;
+            continue;
+        }
+        const field = FIELD_LINE.exec(line);
+        if (field) {
+            const key = (field[1] ?? '').toUpperCase();
+            const value = unquote(field[2] ?? '');
+            // Album-level fields precede the first TRACK; per-track fields follow it.
+            if (current === null) {
+                if (key === 'TITLE')
+                    doc.title = value;
+                else
+                    doc.performer = value;
+            }
+            else if (key === 'TITLE') {
+                current.title = value;
+            }
+            else {
+                current.performer = value;
+            }
+            continue;
+        }
+        // Understood and deliberately not kept — see `IGNORED_LINE`.
+        if (IGNORED_LINE.test(line))
+            continue;
+        // Nothing claimed it. The parser's contract is to report what the file says,
+        // and this is a thing it says that nothing here read.
+        doc.unrecognized.push({
+            line: lineNo + 1,
+            text: line,
+            malformed: READ_COMMAND.test(line),
+        });
+    }
+    if (statedCatalog !== null)
+        doc.rem['CATALOG'] = statedCatalog;
+    return doc;
+}

package/dist/cue/plan.js

@@ -0,0 +1,286 @@
+import { compareNatural, folderOf } from "../util/names.js";
+import { isSiteName } from "../text/site-name.js";
+import { audioNamedByCue } from "./match.js";
+import { titleFromFileName } from "./track-name.js";
+// Digit-aware, so `2 - x.flac` precedes `10 - y.flac`. Lexicographic order put
+// the tenth track second and handed its name to the wrong file.
+function byName(a, b) {
+    return compareNatural(a.name, b.name);
+}
+/**
+ * Make ordinals unique within an album without discarding the cue's numbering.
+ *
+ * Cues repeat track numbers — a spanning cue restarts at TRACK 01 per FILE, and
+ * broken rips simply duplicate one. The album's track list is unique by
+ * ordinal, so a repeat would abort the insert and take the scan with it. The
+ * first claim on a number keeps it; later ones fall to the next free slot.
+ */
+function uniqueOrdinals(ordinals) {
+    const used = new Set();
+    return ordinals.map((ordinal, index) => {
+        if (!used.has(ordinal)) {
+            used.add(ordinal);
+            return ordinal;
+        }
+        let candidate = index + 1;
+        while (used.has(candidate))
+            candidate += 1;
+        used.add(candidate);
+        return candidate;
+    });
+}
+/**
+ * A ripper's marker standing where a track's name should be.
+ *
+ * EAC writes `TITLE "(empty)"` for a division of the disc that carries no name —
+ * Undertow's tracks 10..68, the silence before its hidden track. The division is
+ * real, and stays: it has an INDEX 01, so it is part of the disc's structure.
+ * The *string* is not a name, and a client showing `(empty)` is showing what the
+ * ripper wrote in place of one.
+ *
+ * Deliberately short, and matched whole. A missing marker leaves a word visible
+ * in the dump, which costs nothing; an invented one erases a real title —
+ * `Empty Spaces` is a song, and any containment rule kills it. `(data track)`
+ * cannot arrive from a cue (`planAlbum` reads AUDIO tracks only) but a tagged
+ * file can carry it, and the list is the vocabulary rather than one source.
+ *
+ * The marker becomes null rather than a friendlier stand-in like `[silence]`.
+ * Inventing one would have the layer assert a meaning the ripper never stated —
+ * `(empty)` does not say *why* the division has no name — and null already means
+ * "no name here", which is the thing that is true.
+ *
+ * Nothing is lost by dropping it. `cue_track` keeps the parsed value verbatim
+ * and a tag's own text stays in `file_tag`, so this is the projection deciding
+ * what may be *shown* as a name — the planner's business, not the parser's,
+ * whose rule is that what was written is what came out.
+ *
+ * Named for the ripper rather than for `placeholder`, which this codebase
+ * already uses for a different question entirely: whether an album's title
+ * source is weak enough to be overwritten (`applyAlbumTitle` in `cue/engine.ts`).
+ */
+const RIPPER_MARKER = /^\((?:empty|silence|untitled|data track)\)$/i;
+function dropRipperMarker(raw) {
+    if (raw === null)
+        return null;
+    return RIPPER_MARKER.test(raw.trim()) ? null : raw;
+}
+export function planAlbum(audioFiles, cue, deps = {}) {
+    const issues = [];
+    /**
+     * Track titles a cue stated that were a rip's source rather than a name.
+     *
+     * Counted by `titleFor` and reported once, because a rip names every track of
+     * the disc after the same host and one finding per track would be the same
+     * sentence four times (task:2756).
+     */
+    let declinedTrackTitles = 0;
+    /** One finding for the disc, not one per track — see `declinedTrackTitles`. */
+    const reportDeclinedTitles = () => {
+        if (declinedTrackTitles === 0)
+            return;
+        issues.push({
+            kind: 'track-title-cue-declined',
+            detail: `${declinedTrackTitles} track title(s) named the rip's source rather than the track — the file's own tag, and then the name it carries, was used instead`,
+        });
+    };
+    const audio = [...audioFiles].sort(byName);
+    const cueTracks = (cue?.tracks ?? []).filter((t) => t.type === 'AUDIO');
+    const albumPerformer = cue?.performer ?? null;
+    // The cue as the matcher sees it, so its references resolve the way the
+    // matcher resolved them. Only the directory of `relPath` is ever read —
+    // `resolveRef` splits the folder off and ignores the name — so the file name
+    // here carries nothing and is named for what it is.
+    const cueFolder = deps.cuePath != null ? folderOf(deps.cuePath) : (audio[0]?.folderRelPath ?? '');
+    const cueCandidate = cue === null ? null : { relPath: `${cueFolder}/cue.cue`, doc: cue };
+    /**
+     * The name the file's own bytes state — its tag, then its name.
+     *
+     * Sources two and three of the priority chain: a cue is a document about
+     * *this* album and speaks with authority, while the file only speaks for
+     * itself, so both are asked only where the cue has already declined to name a
+     * track — never as a tie-break, and never for an image, where one file covers
+     * every track and its TITLE describes the file rather than track 7.
+     *
+     * Between the two, the tag wins: it is a statement somebody made about the
+     * track, where the name is a hint the filesystem happens to carry. But a name
+     * beats an empty cell, which is the whole of the untagged, folder-organized
+     * part of a collection (`track-name.ts` holds that rule and its evidence).
+     */
+    const titleOf = (file) => deps.titleOf?.(file) ?? null;
+    const nameOf = (file) => titleFromFileName(file.name, deps.albumName ?? null);
+    // How many names the ripper had marked rather than written. Counted here and
+    // reported below, because the projection is the only place that knows: the
+    // value it drops is not wrong, it is absent, and a dump showing `(untitled)`
+    // where the cue said `(empty)` has no way to say why without this.
+    let markers = 0;
+    const named = (raw) => {
+        const title = dropRipperMarker(raw);
+        if (title === null && raw !== null && raw.trim() !== '')
+            markers += 1;
+        return title;
+    };
+    /** Says how many names were markers, once the album's tracks are known. */
+    const reportMarkers = () => {
+        if (markers === 0)
+            return;
+        issues.push({
+            kind: 'ripper-marker-titles',
+            detail: `${markers} track(s) were marked rather than named by the ripper and are left unnamed`,
+            severity: 'info',
+        });
+    };
+    /**
+     * What one source says, and whether it can be shown as a name.
+     *
+     * A source that *spoke* has answered the question even when its answer is a
+     * ripper's marker: `(empty)` says this division of the disc has no name, and
+     * the title is then null — which is what "no name here" means. Null here is
+     * therefore two different things, and the caller below reads it as both.
+     */
+    const claim = (raw, source) => {
+        if (raw === null || raw === undefined)
+            return null;
+        const title = named(raw);
+        return { title, titleSource: title === null ? null : source };
+    };
+    /** A track no source names at all — the shape `claim` does not produce. */
+    const UNNAMED = { title: null, titleSource: null };
+    /**
+     * The track's name, and which source stated it — the first source to speak.
+     *
+     * A marker ends the chain rather than falling through it: asking the tag, or
+     * the file name, after the ripper has said there is no name would dress the
+     * hole up rather than fill it.
+     */
+    const titleFor = (file, fromCue) => {
+        // A cue that names where the rip came from has not named the track. That is
+        // the rule the record's own name already follows — `text/site-name.ts`, and
+        // the album path refuses it on both the cue and the tag — applied one level
+        // down, where it was missing: `TITLE "lossless-galaxy.ru"` named every track
+        // of the rip (task:2756, and task:2725 for the record).
+        //
+        // Skipped rather than refused outright, so the chain falls through to the
+        // tag and then to the file's own name, which is exactly what "no cue named
+        // this track" already means here. The refusal is counted, and reported once
+        // per plan below: four tracks of one rip carry the same host, and four
+        // findings would say the same thing four times.
+        if (fromCue !== null && fromCue !== undefined && isSiteName(fromCue)) {
+            declinedTrackTitles += 1;
+            fromCue = null;
+        }
+        // Asked one at a time, not collected first: a source below the one that
+        // answered is never consulted, and the tag reader is a database lookup that
+        // a cue-named track must not pay for.
+        const sources = [
+            [() => fromCue, 'cue'],
+            [() => titleOf(file), 'tag'],
+            [() => nameOf(file), 'name'],
+        ];
+        for (const [ask, source] of sources) {
+            const claimed = claim(ask(), source);
+            if (claimed !== null)
+                return claimed;
+        }
+        return UNNAMED;
+    };
+    const untimed = cueTracks.filter((t) => t.index01Ms === null);
+    if (untimed.length > 0) {
+        issues.push({
+            kind: 'track-without-index',
+            detail: `${untimed.length} track(s) declare no INDEX 01 and were left out`,
+        });
+    }
+    const timed = cueTracks
+        .filter((t) => t.index01Ms !== null)
+        .sort((a, b) => a.index01Ms - b.index01Ms);
+    const image = audio[0];
+    // One file, several tracks: the cue describes an image, so the album lives
+    // inside it as time windows rather than as files.
+    if (image !== undefined && audio.length === 1 && timed.length > 1) {
+        const duration = deps.durationMs?.(image) ?? null;
+        const ordinals = uniqueOrdinals(timed.map((cueTrack) => cueTrack.ordinal));
+        const tracks = timed.map((cueTrack, index) => ({
+            ordinal: ordinals[index] ?? index + 1,
+            // The cue, and nothing else. Every segment plays from this one file, so
+            // the only title that describes a *track* here is the one the cue wrote
+            // next to it — see the note on priority above.
+            ...(claim(cueTrack.title, 'cue') ?? UNNAMED),
+            performer: cueTrack.performer ?? albumPerformer,
+            file: image,
+            segmentStartMs: cueTrack.index01Ms,
+            segmentEndMs: timed[index + 1]?.index01Ms ?? duration,
+        }));
+        reportMarkers();
+        if (duration === null) {
+            issues.push({
+                kind: 'unbounded-last-segment',
+                detail: `${image.name}: duration unknown, the closing track has no end`,
+            });
+        }
+        return { shape: 'image-cue', tracks, issues };
+    }
+    if (cueCandidate !== null && cueTracks.length > 0) {
+        // A cue earns the right to name these files only if it plausibly describes
+        // them. A folder can hold several discs ripped flat, each with its own cue;
+        // the folder is one album by identity, but no single cue covers it. Taking
+        // disc 1's titles anyway would put confidently wrong words on discs 2 and
+        // 3, which is worse than leaving them unnamed.
+        //
+        // "Describes them" is a reading of the cue's own `FILE` references, and a
+        // count is not a reading of anything. A cue naming one file under two TRACK
+        // tags has the same count as a folder holding two files, so counting handed
+        // the second file a title the cue never wrote for it, threw away the name
+        // the file carried, and recorded the guess under `title_source = 'cue'` —
+        // the value the schema reserves for a cue that *does* describe these files
+        // (task:2723). The same false knowledge as task:2712, by the other door.
+        const named = audioNamedByCue(cueCandidate, audio);
+        const countsAgree = cueTracks.length === audio.length;
+        const describesTheseFiles = countsAgree && named.length === audio.length;
+        if (!countsAgree) {
+            issues.push({
+                kind: 'track-count-mismatch',
+                detail: `cue declares ${cueTracks.length} tracks, folder holds ${audio.length} audio files — cue names were not applied`,
+            });
+        }
+        else if (!describesTheseFiles) {
+            issues.push({
+                kind: 'cue-describes-other-files',
+                detail: `cue's FILE tags name ${named.length} of the folder's ${audio.length} audio files — cue names were not applied`,
+            });
+        }
+        const cueOrdinals = describesTheseFiles
+            ? uniqueOrdinals(cueTracks.map((track) => track.ordinal))
+            : [];
+        const tracks = audio.map((file, index) => {
+            const cueTrack = describesTheseFiles ? cueTracks[index] : undefined;
+            return {
+                ordinal: cueOrdinals[index] ?? index + 1,
+                // The cue names the track where it names it, and a TRACK with no
+                // TITLE is not a refusal to speak — it is silence, and the file's own
+                // tag, then its own name, is a better answer than an empty cell. When
+                // the cue does not describe these files at all, none of it is applied
+                // and the file is the only thing left.
+                ...titleFor(file, cueTrack?.title),
+                performer: cueTrack?.performer ?? (describesTheseFiles ? albumPerformer : null),
+                file,
+                segmentStartMs: null,
+                segmentEndMs: null,
+            };
+        });
+        reportDeclinedTitles();
+        reportMarkers();
+        return { shape: 'tracks-cue', tracks, issues };
+    }
+    const tracks = audio.map((file, index) => ({
+        ordinal: index + 1,
+        // Nothing describes this folder, so the file is the only thing that can
+        // name itself — its tag first, then the name it carries.
+        ...titleFor(file, null),
+        performer: albumPerformer,
+        file,
+        segmentStartMs: null,
+        segmentEndMs: null,
+    }));
+    reportMarkers();
+    return { shape: 'tracks-only', tracks, issues };
+}