{#if ambSrc}

{/if}

{#each STEPS as [k, label], i} {#if i > 0}

{/if}

{i < stepIndex ? "✓" : i + 1}{label}

{/each} {#if root || scan} {/if}

{#if confirmReset}

Start over? This forgets the scan of {nfmt(resetCost.records)} record{resetCost.records === 1 ? "" : "s"}{#if resetCost.decided}, the {nfmt(resetCost.decided)} decision{resetCost.decided === 1 ? "" : "s"} made so far{/if}{#if resetCost.cached}, and {nfmt(resetCost.cached)} downloaded cop{resetCost.cached === 1 ? "y" : "ies"} waiting in the cache{/if}. Your music is not touched — not the source folder, and not what is already in the library.

{/if} {#if step !== "done" && leftBehind.length}

{nfmt(leftBehind.length)} record{leftBehind.length === 1 ? "" : "s"} {leftBehind.length === 1 ? "was" : "were"} not imported. Nothing was written for {leftBehind.length === 1 ? "it" : "them"} and {leftBehind.length === 1 ? "it is" : "they are"} still on the list — importing again once the reason below is gone will pick {leftBehind.length === 1 ? "it" : "them"} up.

{#each report.skipped.slice(0, 6) as s (s.rel)}

{s.rel.split(/[\\/]/).pop() || s.album} — {s.reason}

{/each} {#if report.skipped.length > 6}

and {nfmt(report.skipped.length - 6)} more

{/if}

{/if} {#if step === "source"}

Bring in your music

Two folders: the one the music is in now, and the one SoulStream keeps its copy in. The source is only ever read from — importing copies, so the original folder survives anything the review decides.

{#if root}

→

▤

SoulStream's library — written to

{dest?.dir ?? dest?.suggested ?? "Choose where the library lives…"}

{#if dest?.dir} {#if scan}{fmtGB(totals.bytes)} to copy · {/if} {dest.freeBytes != null ? fmtGB(dest.freeBytes) + " free" : ""} {destFits === false ? " — not enough room" : ""} {:else if dest?.suggested} suggested — {#if scan}{fmtGB(totals.bytes)} to copy · {/if} {dest.freeBytes != null ? fmtGB(dest.freeBytes) + " free · " : ""} {destFits === false ? "not enough room — choose elsewhere" : "nothing is created until you take it"} {:else} required before anything is imported {/if}

{#if !dest?.dir && dest?.suggested} {/if}

{/if}

{#if !root}

Point it at a folder Your own collection or a friend's drive — the folder is only ever read from, whatever the review decides.

Scan and review Headers only — duration, quality, tags, artwork. You see what's there before anything is written anywhere.

Import copies The records you approve are copied into SoulStream's library, filed the way the collection already files itself.

{/if}

Why two folders. Upgrading replaces files — a better cover written into the tags, a higher-quality rip in place of a worn one, a corrected year. Those writes land on SoulStream's copy. {root ?? "The folder you point it at"} is never written to, so if an upgrade turns out to be the wrong record or a worse master, the original is still sitting there untouched. {#if scan}It costs {fmtGB(totals.bytes)} to hold the second copy.{/if}

{#if error}

{error}

{/if} {:else if step === "scanning"}

Reading the music

Headers only — nothing is decoded and nothing is written.

{scanProg?.done ?? 0}

of {scanProg?.total ?? "…"} folders

{#if scanEta}

{scanEta}

{/if}

{nfmt(scanProg?.filesDone ?? 0)}tracks

{nfmt(Math.round((scanProg?.tracksSecs ?? 0) / 60))}minutes of music

{((scanProg?.bytes ?? 0) / 1024 ** 3).toFixed(2)}GB

{nfmt(scanProg?.lossless ?? 0)}lossless

{nfmt(scanProg?.artists ?? 0)}artists

{#each ledger as r, i (r.id)}

{#if r.kind === "head"} ▸ {r.label} {:else if r.kind === "sum"} ✓ {r.label} {r.tracks} tracks · {mmss(r.secs)} · {r.mb} MB {#if r.chip}{r.chip.t}{/if} {:else} · {r.name} {#if r.secs != null}{mmss(r.secs)}{/if} {#if r.chip}{r.chip.t}{/if} {/if}

{/each}

{:else if step === "review"}

Here's what's there

{nfmt(issues.clean.length)} records are ready to import as they are. Nothing below is an error — they are folders that don't say what they are.

{nfmt(totals.albums)}records

{nfmt(totals.tracks)}tracks

{fmtGB(totals.bytes)}to copy

{#if issues.junk.length}

{issues.junk.length}skipped as junk

{/if} {#if folding?.folds.length}

{folding.folds.filter((f) => !f.off).length}rejoined from parts

{/if}

{#if folding?.folds.length}

Put back together {folding.folds.length} scanned as separate folders, imported as one record

{#each folding.folds as f (f.container)}

{f.container.includes("\\") ? f.container.split("\\")[0] + " — " : ""}{f.name} {f.off ? `${f.parts} separate records` : `${f.parts} ${f.parts === 1 ? "folder" : "parts"} · ${nfmt(f.tracks)} tracks`}

{/each}

{/if} {#if folding?.refused}

Folders nested unevenly {Math.round(folding.share * 100)}% at one level

Records sit at several different depths here, so there is no one level that means "a release" — and guessing one would merge albums under the wrong parent. Anything filed as parts of a record imports as separate records instead. Nothing is lost; they just arrive unjoined.

{/if} {#each [["Named like a disc, filed as a record", issues.disc, "these sit at the top of their artist folder, so there is no record above them to be joined to — they import under this name"],["No artist folder", issues.loose, "the artist comes from the tags"], ["No artwork anywhere", issues.noArt, "a cover is generated from the name until one is found"]] as [title, list, sub]} {#if list.length}

{title} {list.length}

{#each list.slice(0, 6) as a}

{a.depth >= 2 ? a.artistFolder + " — " : ""}{a.title} {a.tracks.length} tracks

{/each} {#if list.length > 6}

and {list.length - 6} more

{/if}

{/if} {/each} {#if filing?.folders.length} {@const top = filing.folders[0]} {@const topFile = filing.files[0]} {@const noNumber = filing.files.find((f) => f.shape === "{title}")} {@const defaultShare = filing.folders.find((f) => f.shape === APP_DEFAULT_LAYOUT)?.pct ?? 0}

How this music is already filed {top.pct}% of {nfmt(filing.folderTotal)} records use one shape

{#each filing.folders as f (f.shape)} {/each}

{#if chosenLayout === APP_DEFAULT_LAYOUT && defaultShare < 20}

That is SoulStream's default, and only {defaultShare}% of this music is filed that way — importing on it would refile the other {nfmt(filing.folderTotal - (filing.folders.find((f) => f.shape === chosenLayout)?.n ?? 0))} records.

{/if} {#if topFile}

And how the files are named {topFile.pct < 50 ? `no single shape — the most common is ${topFile.pct}% of ${nfmt(filing.fileTotal)} tracks` : `${topFile.pct}% of ${nfmt(filing.fileTotal)} tracks read one way`}

{#each filing.files as f (f.shape)}

{f.shape} {f.pct}% · {nfmt(f.n)} file{f.n === 1 ? "" : "s"}

{/each}

{/if}

{dest?.dir ?? "library"}\{layoutPreview(chosenLayout)}\{previewAlbum?.tracks[0]?.name ?? ""}

The folders are rebuilt from the chosen shape; file names are copied verbatim — the same thing SoulStream does with its own downloads. {#if noNumber}
{nfmt(noNumber.n)} of the files carry no track number in their name — those albums play in the order the tags say, falling back to alphabetical where a tag is missing. {/if}

{/if} {#if error}

{error}

{/if} {#if applying}

Copying {applyProg?.album ?? "…"} · {applyProg?.done ?? 0} of {applyProg?.total ?? plan.length}

{/if} {:else if step === "upgrades"}

{#each BUCKETS as [k, label] (k)} {@const n = k === "all" ? pickerBase.length : (bucketCounts[k] ?? 0)} {/each} {#if arrivals.length} {/if}

{#if trayOpen && arrivals.length}

{#if !arrivalFiles} Everything arrived. {arrivals.length === 1 ? "This copy is" : `All ${nfmt(arrivals.length)} copies are`} cached — importing now takes {arrivals.length === 1 ? "it" : "them"}. {:else if arrivalStalled} Stalled. {nfmt(arrivalFiles)} file{arrivalFiles === 1 ? "" : "s"} still owed, and nothing is moving. {:else} Still arriving. {nfmt(arrivalsOwed.length)} record{arrivalsOwed.length === 1 ? "" : "s"} · {nfmt(arrivalFiles)} file{arrivalFiles === 1 ? "" : "s"}{#if arrivalBytes} · {nfmt(Math.round(arrivalBytes / 1e6))} MB to come{/if}. {/if}

{#each arrivals as a (a.rel)} {@const w = arrivalWords(a)}

{arrivalInitials(a.name)}

{a.name}

0 && a.live?.phase === "transferring"}>

{nfmt(a.have)} of {nfmt(a.want)} cached ·{arrivalFormat(a)} {w.label} {w.detail}

{#if a.owed} {/if}

{/each}

{#if arrivalFiles} Nothing here needs you — they import themselves on the next run once the files land. "Keep mine" on the record takes your own copy instead. {:else} {/if}

{/if} {#if curPick} {#key curPick.rel} findBetterCopy(curPick.rel)} onTryAnother={() => switchPeer(curPick.rel, "you asked for another peer")} onChoose={(patch) => choose(curPick.rel, patch)} onSnapshot={(snap) => snapshot(curPick.rel, snap)} onReset={() => { delete choices[curPick.rel]; schedulePersist(); }} /> {/key} {:else}

Nothing to compare

{/if} {:else if step === "done"}

The library is in

{nfmt(report?.albums ?? 0)} records · {nfmt(report?.tracks ?? 0)} tracks · {fmtGB(report?.bytes ?? 0)} copied.

The originals in {scan?.root} were not touched.

{#if report?.replaced}

{nfmt(report.replaced)} file{report.replaced === 1 ? "" : "s"} of a previous version {report.replaced === 1 ? "was" : "were"} removed — those records now hold the copy the review chose.

{/if} {#if report?.skipped?.length}

Not imported {report.skipped.length} nothing was written for these

{#each report.skipped.slice(0, 12) as s (s.rel)}

{s.rel.split(/[\\/]/).pop() || s.album} {s.reason}

{/each} {#if report.skipped.length > 12}

and {report.skipped.length - 12} more

{/if}

{/if} {/if}

{#if step === "source"}

Nothing is copied or written until the review says so.

{:else if step === "scanning"}

Reading headers — safe to leave; it keeps going.

{:else if step === "review"}

{#if !dest?.dir}Choose where the library lives (Source step) before importing. {:else}Copies {fmtGB(totals.bytes)} into {dest.dir} · the source is only read from.{/if}

{:else if step === "upgrades"}

{Math.min(pick, Math.max(0, pickerQueue.length - 1)) + 1} of {nfmt(pickerQueue.length)} · {nfmt(Object.values(found).filter((f) => f?.result?.candidate).length)} matched so far{#if deferred} · {nfmt(deferred)} skipped for now{/if}

{:else if step === "done"}

{/if}