disk-coldstore 0.1.0__py3-none-any.whl

coldstore/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

coldstore/__main__.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+import argparse
+import sys
+import time
+from pathlib import Path
+
+from rich.console import Console
+
+from .analyze import print_analysis, print_tree
+from .report import build_candidates, print_report
+from .rules import classify
+from .scanner import scan
+
+
+def _do_scan(root: Path, verbose: bool):
+    con = Console()
+    con.print(f"[bold]Scanning[/bold] {root} ...")
+    started = time.time()
+
+    def on_progress(current: Path, count: int) -> None:
+        con.print(f"  [dim]{count} folders scanned — {current}[/dim]", highlight=False)
+
+    result = scan(root, on_progress=on_progress if verbose else None)
+    con.print(
+        f"[dim]Scan finished in {time.time() - started:.1f}s — "
+        f"{result.aggregate.total_folder_count:,} folders, "
+        f"{result.aggregate.total_file_count:,} files, "
+        f"{result.aggregate.total_bytes / (1024**3):.2f} GB[/dim]"
+    )
+    return result
+
+
+def cmd_scan(args: argparse.Namespace) -> int:
+    root = Path(args.path).resolve()
+    if not root.exists():
+        print(f"error: path does not exist: {root}", file=sys.stderr)
+        return 2
+
+    result = _do_scan(root, args.verbose)
+    min_size = args.min_size_mb * 1024 * 1024
+    scanned = [(s, classify(s, min_size_bytes=min_size,
+                             cool_age_days=args.cool_days,
+                             cold_age_days=args.cold_days)) for s in result.folders]
+    candidates = build_candidates(scanned, min_size_bytes=min_size)
+    print_report(root, scanned, candidates, top_n=args.top)
+    return 0
+
+
+def cmd_analyze(args: argparse.Namespace) -> int:
+    root = Path(args.path).resolve()
+    if not root.exists():
+        print(f"error: path does not exist: {root}", file=sys.stderr)
+        return 2
+
+    result = _do_scan(root, args.verbose)
+    print_analysis(root, result.folders, result.aggregate,
+                   top_folders=args.top_folders,
+                   top_files=args.top_files,
+                   top_exts=args.top_exts)
+    if args.tree:
+        Console().print()
+        print_tree(root, result.folders, max_depth=args.tree_depth, min_share=args.tree_min_share / 100.0)
+    return 0
+
+
+def cmd_apply(args: argparse.Namespace) -> int:
+    from .apply import run_apply
+    root = Path(args.path).resolve()
+    if not root.exists():
+        print(f"error: path does not exist: {root}", file=sys.stderr)
+        return 2
+
+    result = _do_scan(root, args.verbose)
+    min_size = args.min_size_mb * 1024 * 1024
+    scanned = [(s, classify(s, min_size_bytes=min_size,
+                             cool_age_days=args.cool_days,
+                             cold_age_days=args.cold_days)) for s in result.folders]
+    candidates = build_candidates(scanned, min_size_bytes=min_size)
+    return run_apply(
+        root, candidates,
+        do_junk=args.junk,
+        do_cool=args.cool,
+        do_cold=args.cold,
+        yes=args.yes,
+    )
+
+
+def cmd_restore(args: argparse.Namespace) -> int:
+    from .recovery import cmd_restore as _restore
+    return _restore(Path(args.stub))
+
+
+def cmd_journal(args: argparse.Namespace) -> int:
+    from .recovery import cmd_journal_list
+    return cmd_journal_list(limit=args.limit)
+
+
+def cmd_undo(args: argparse.Namespace) -> int:
+    from .recovery import cmd_undo as _undo
+    return _undo(entry_number=args.entry, last_n=args.last)
+
+
+def cmd_gui(args: argparse.Namespace) -> int:
+    from .gui import run_gui
+    run_gui()
+    return 0
+
+
+def cmd_media(args: argparse.Namespace) -> int:
+    from .media import cmd_media_apply, cmd_media_scan, restore_one
+    if args.media_op == "scan":
+        return cmd_media_scan(Path(args.path))
+    if args.media_op == "apply":
+        return cmd_media_apply(Path(args.path), yes=args.yes)
+    if args.media_op == "restore":
+        result = restore_one(Path(args.jxl))
+        if result.ok:
+            print(f"restored: {result.path} {result.note}")
+            return 0
+        print(f"failed: {result.error}", file=sys.stderr)
+        return 1
+    return 2
+
+
+def cmd_register(args: argparse.Namespace) -> int:
+    from .integration import register_file_association, unregister_file_association
+    if args.uninstall:
+        ok, msg = unregister_file_association()
+    else:
+        ok, msg = register_file_association()
+    print(msg)
+    return 0 if ok else 1
+
+
+def cmd_schedule(args: argparse.Namespace) -> int:
+    from .integration import (create_scheduled_scan, delete_scheduled_scan,
+                              query_scheduled_scan)
+    if args.delete:
+        ok, msg = delete_scheduled_scan()
+    elif args.query:
+        ok, msg = query_scheduled_scan()
+    else:
+        if not args.target:
+            print("error: --target is required when creating a schedule", file=sys.stderr)
+            return 2
+        ok, msg = create_scheduled_scan(
+            target=Path(args.target),
+            cadence=args.cadence,
+            min_size_mb=args.min_size_mb,
+        )
+    print(msg)
+    return 0 if ok else 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="coldstore", description="Tiered laptop storage reclaimer.")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    ps = sub.add_parser("scan", help="scan and report reclaimable space (no changes made)")
+    ps.add_argument("path")
+    ps.add_argument("--top", type=int, default=40)
+    ps.add_argument("--min-size-mb", type=int, default=50)
+    ps.add_argument("--cool-days", type=int, default=30)
+    ps.add_argument("--cold-days", type=int, default=180)
+    ps.add_argument("-v", "--verbose", action="store_true")
+    ps.set_defaults(func=cmd_scan)
+
+    pa = sub.add_parser("analyze", help="WizTree-style disk analysis (no changes made)")
+    pa.add_argument("path")
+    pa.add_argument("--top-folders", type=int, default=25)
+    pa.add_argument("--top-files", type=int, default=25)
+    pa.add_argument("--top-exts", type=int, default=20)
+    pa.add_argument("--tree", action="store_true", help="also print an indented folder tree")
+    pa.add_argument("--tree-depth", type=int, default=3)
+    pa.add_argument("--tree-min-share", type=float, default=1.0,
+                    help="prune tree branches below this percentage of root size (default 1.0)")
+    pa.add_argument("-v", "--verbose", action="store_true")
+    pa.set_defaults(func=cmd_analyze)
+
+    pap = sub.add_parser("apply", help="perform recommended actions (interactive by default)")
+    pap.add_argument("path")
+    pap.add_argument("--min-size-mb", type=int, default=50)
+    pap.add_argument("--cool-days", type=int, default=30)
+    pap.add_argument("--cold-days", type=int, default=180)
+    pap.add_argument("--junk", action="store_true", help="process JUNK candidates (Recycle Bin)")
+    pap.add_argument("--cool", action="store_true", help="process COOL candidates (compact.exe LZX)")
+    pap.add_argument("--cold", action="store_true", help="process COLD candidates (7z archive + stub)")
+    pap.add_argument("--yes", action="store_true", help="do not prompt for confirmation")
+    pap.add_argument("-v", "--verbose", action="store_true")
+    pap.set_defaults(func=cmd_apply)
+
+    pr = sub.add_parser("restore", help="restore a .coldstore stub back to its original folder")
+    pr.add_argument("stub", help="path to the .coldstore stub file")
+    pr.set_defaults(func=cmd_restore)
+
+    pj = sub.add_parser("journal", help="show recent journal entries")
+    pj.add_argument("--limit", type=int, default=30)
+    pj.set_defaults(func=cmd_journal)
+
+    pu = sub.add_parser("undo", help="undo one or more previous actions from the journal")
+    grp = pu.add_mutually_exclusive_group()
+    grp.add_argument("--entry", type=int, help="undo a specific journal entry number (see 'journal')")
+    grp.add_argument("--last", type=int, help="undo the last N successful actions")
+    pu.set_defaults(func=cmd_undo)
+
+    pg = sub.add_parser("gui", help="launch the graphical interface")
+    pg.set_defaults(func=cmd_gui)
+
+    pmed = sub.add_parser("media", help="bit-exact JPEG -> JPEG XL lossless transcode (requires libjxl)")
+    med_sub = pmed.add_subparsers(dest="media_op", required=True)
+    med_scan = med_sub.add_parser("scan", help="report JPEGs and estimated savings")
+    med_scan.add_argument("path")
+    med_apply = med_sub.add_parser("apply", help="transcode JPEGs to JXL with byte-exact verification")
+    med_apply.add_argument("path")
+    med_apply.add_argument("--yes", action="store_true")
+    med_restore = med_sub.add_parser("restore", help="restore a .jxl back to its bit-exact .jpg")
+    med_restore.add_argument("jxl")
+    pmed.set_defaults(func=cmd_media)
+
+    preg = sub.add_parser("register",
+        help="register .coldstore file association (double-click to restore)")
+    preg.add_argument("--uninstall", action="store_true", help="remove the association instead")
+    preg.set_defaults(func=cmd_register)
+
+    psch = sub.add_parser("schedule",
+        help="create/query/delete a Windows scheduled task that runs 'scan' periodically")
+    psch.add_argument("--target", help="folder to scan (required when creating a schedule)")
+    psch.add_argument("--cadence", choices=["daily", "weekly", "monthly"], default="weekly")
+    psch.add_argument("--min-size-mb", type=int, default=100)
+    psch.add_argument("--query", action="store_true", help="show the existing scheduled task")
+    psch.add_argument("--delete", action="store_true", help="remove the scheduled task")
+    psch.set_defaults(func=cmd_schedule)
+
+    args = p.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

coldstore/actions.py

@@ -0,0 +1,157 @@
+"""Pure per-candidate action functions used by both the CLI and GUI.
+
+Each `do_*` function returns an `ItemResult` and does NOT print or journal.
+The caller owns UI + journaling."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from .archive import ArchiveError, archive_folder
+from .journal import Action, Journal
+from .report import Candidate
+
+
+@dataclass(slots=True)
+class ItemResult:
+    ok: bool
+    op: str
+    path: str
+    before_bytes: int = 0
+    after_bytes: int = 0
+    note: str = ""
+    error: str | None = None
+    extras: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def bytes_freed(self) -> int:
+        return max(0, self.before_bytes - self.after_bytes)
+
+    @property
+    def ratio(self) -> float:
+        if self.after_bytes <= 0:
+            return 1.0
+        return self.before_bytes / self.after_bytes
+
+
+def _send_to_recycle_bin(path: Path) -> tuple[bool, str]:
+    try:
+        import send2trash
+        send2trash.send2trash(str(path))
+        return True, "send2trash"
+    except ImportError:
+        pass
+    except Exception as exc:
+        return False, f"send2trash failed: {exc!r}"
+
+    ps_script = (
+        "Add-Type -AssemblyName Microsoft.VisualBasic; "
+        "[Microsoft.VisualBasic.FileIO.FileSystem]::DeleteDirectory("
+        f"'{str(path).replace(chr(39), chr(39)*2)}',"
+        "'OnlyErrorDialogs','SendToRecycleBin')"
+    )
+    proc = subprocess.run(
+        ["powershell", "-NoProfile", "-NonInteractive", "-Command", ps_script],
+        capture_output=True, text=True,
+    )
+    if proc.returncode != 0:
+        return False, f"powershell fallback failed: {proc.stderr.strip()[:200]}"
+    return True, "powershell-recyclebin"
+
+
+_COMPACT_STORED_RE = re.compile(
+    r"([\d,\.\s]+)\s+total bytes of data are stored in\s+([\d,\.\s]+)\s+bytes",
+    re.IGNORECASE,
+)
+
+
+def _parse_compact_output(out: str) -> tuple[int, int] | None:
+    m = _COMPACT_STORED_RE.search(out)
+    if not m:
+        return None
+    def _n(s: str) -> int:
+        return int(s.replace(",", "").replace(".", "").strip())
+    try:
+        return _n(m.group(1)), _n(m.group(2))
+    except ValueError:
+        return None
+
+
+def _compact_lzx(path: Path) -> tuple[bool, int, int, str]:
+    args = ["compact.exe", "/c", "/s", "/a", "/i", "/exe:LZX"]
+    try:
+        proc = subprocess.run(args, capture_output=True, text=True, cwd=str(path))
+    except FileNotFoundError:
+        return False, 0, 0, "compact.exe not found on PATH"
+    except OSError as exc:
+        return False, 0, 0, f"failed to chdir into {path}: {exc!r}"
+
+    out = (proc.stdout or "") + "\n" + (proc.stderr or "")
+    parsed = _parse_compact_output(out)
+    if parsed:
+        return proc.returncode == 0, parsed[0], parsed[1], "compact.exe stored/on-disk"
+    return proc.returncode == 0, 0, 0, (out.splitlines()[-1] if out.strip() else "no output")
+
+
+def do_recycle(candidate: Candidate) -> ItemResult:
+    before = candidate.stats.total_bytes
+    ok, note = _send_to_recycle_bin(candidate.stats.path)
+    return ItemResult(
+        ok=ok, op="recycle", path=str(candidate.stats.path),
+        before_bytes=before, after_bytes=0 if ok else before,
+        note=note, error=None if ok else note,
+    )
+
+
+def do_compact_lzx(candidate: Candidate) -> ItemResult:
+    ok, before, after, note = _compact_lzx(candidate.stats.path)
+    if before == 0:
+        before = candidate.stats.total_bytes
+    return ItemResult(
+        ok=ok, op="compact_lzx", path=str(candidate.stats.path),
+        before_bytes=before, after_bytes=(after or before),
+        note=note, error=None if ok else note,
+        extras={"algorithm": "LZX"},
+    )
+
+
+def do_archive(candidate: Candidate) -> ItemResult:
+    before = candidate.stats.total_bytes
+    try:
+        stub_path, meta = archive_folder(candidate.stats.path)
+    except ArchiveError as exc:
+        return ItemResult(
+            ok=False, op="archive_7z", path=str(candidate.stats.path),
+            before_bytes=before, after_bytes=before,
+            note="archive failed", error=str(exc),
+        )
+    return ItemResult(
+        ok=True, op="archive_7z", path=str(candidate.stats.path),
+        before_bytes=meta.original_bytes, after_bytes=meta.archive_bytes,
+        note="archived",
+        extras={
+            "stub_path": str(stub_path),
+            "original_name": meta.original_name,
+            "sha256_archive": meta.sha256_archive,
+        },
+    )
+
+
+def record_result(journal: Journal, candidate: Candidate, result: ItemResult) -> None:
+    journal.record(Action(
+        ts=time.time(),
+        op=result.op,
+        path=result.path,
+        verdict=candidate.classification.verdict.value,
+        bytes_before=result.before_bytes,
+        bytes_after=result.after_bytes,
+        reversible=True,
+        detail={"note": result.note, **result.extras},
+        outcome="ok" if result.ok else "error",
+        error=result.error,
+    ))

coldstore/analyze.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+from .scanner import FolderStats, ScanAggregate
+
+
+def _fmt_bytes(n: int) -> str:
+    if n == 0:
+        return "0 B"
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if abs(n) < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} PB"
+
+
+def _bar(fraction: float, width: int = 20) -> str:
+    filled = int(round(fraction * width))
+    return "█" * filled + "░" * (width - filled)
+
+
+def print_analysis(
+    root: Path,
+    folders: list[FolderStats],
+    agg: ScanAggregate,
+    top_folders: int = 25,
+    top_files: int = 25,
+    top_exts: int = 20,
+) -> None:
+    con = Console()
+
+    con.rule(f"[bold]ColdStore disk analysis[/bold] — {root}")
+
+    header = Table.grid(padding=(0, 2))
+    header.add_column(style="dim")
+    header.add_column(style="bold")
+    header.add_row("Total size", _fmt_bytes(agg.total_bytes))
+    header.add_row("Files", f"{agg.total_file_count:,}")
+    header.add_row("Folders", f"{agg.total_folder_count:,}")
+    header.add_row("Distinct extensions", str(len(agg.ext_bytes)))
+    if agg.error_count:
+        header.add_row("Errors (permission etc.)", f"[yellow]{agg.error_count}[/yellow]")
+    con.print(header)
+
+    con.print()
+    con.rule(f"[bold]Top {top_folders} largest folders[/bold]", style="dim")
+    ranked = sorted(folders, key=lambda f: -f.total_bytes)[:top_folders]
+    max_bytes = ranked[0].total_bytes if ranked else 1
+
+    folder_table = Table(show_header=True, header_style="bold")
+    folder_table.add_column("size", justify="right", width=10, style="bold cyan")
+    folder_table.add_column("share", width=22)
+    folder_table.add_column("files", justify="right", width=8, style="dim")
+    folder_table.add_column("path", overflow="fold")
+    for f in ranked:
+        frac = f.total_bytes / max_bytes if max_bytes else 0
+        folder_table.add_row(
+            _fmt_bytes(f.total_bytes),
+            _bar(frac),
+            f"{f.total_file_count:,}",
+            str(f.path),
+        )
+    con.print(folder_table)
+
+    con.print()
+    con.rule(f"[bold]Top {top_files} largest files[/bold]", style="dim")
+    largest = agg.largest_files()[:top_files]
+    file_table = Table(show_header=True, header_style="bold")
+    file_table.add_column("size", justify="right", width=10, style="bold magenta")
+    file_table.add_column("path", overflow="fold")
+    for size, path in largest:
+        file_table.add_row(_fmt_bytes(size), path)
+    con.print(file_table)
+
+    con.print()
+    con.rule(f"[bold]Top {top_exts} extensions by size[/bold]", style="dim")
+    ext_table = Table(show_header=True, header_style="bold")
+    ext_table.add_column("ext", width=12)
+    ext_table.add_column("bytes", justify="right", width=10, style="bold green")
+    ext_table.add_column("share", width=22)
+    ext_table.add_column("count", justify="right", width=10, style="dim")
+    ext_ranked = agg.ext_bytes.most_common(top_exts)
+    max_ext_bytes = ext_ranked[0][1] if ext_ranked else 1
+    for ext, size in ext_ranked:
+        frac = size / max_ext_bytes if max_ext_bytes else 0
+        ext_table.add_row(
+            ext or "(no ext)",
+            _fmt_bytes(size),
+            _bar(frac),
+            f"{agg.ext_counts[ext]:,}",
+        )
+    con.print(ext_table)
+
+
+def print_tree(
+    root: Path,
+    folders: list[FolderStats],
+    max_depth: int = 3,
+    min_share: float = 0.01,
+) -> None:
+    """WizTree-style indented tree, sorted by size, pruned to significant folders."""
+    con = Console()
+    by_path = {f.path: f for f in folders}
+    root_stats = next((f for f in folders if f.path == root.resolve()), None)
+    if root_stats is None:
+        con.print("[yellow]root not found in scan[/yellow]")
+        return
+    root_bytes = root_stats.total_bytes or 1
+
+    con.rule(f"[bold]Folder tree[/bold] — {root} ([dim]≥ {min_share:.0%} of root, depth ≤ {max_depth}[/dim])")
+
+    def walk(path: Path, depth: int) -> None:
+        stats = by_path.get(path)
+        if stats is None:
+            return
+        share = stats.total_bytes / root_bytes
+        if depth > 0 and share < min_share:
+            return
+        indent = "  " * depth
+        con.print(
+            f"{indent}[bold cyan]{_fmt_bytes(stats.total_bytes):>10s}[/bold cyan] "
+            f"[dim]{share*100:5.1f}%[/dim]  {path.name or str(path)}"
+        )
+        if depth >= max_depth:
+            return
+        children = [f for f in folders if f.path.parent == path]
+        children.sort(key=lambda f: -f.total_bytes)
+        for c in children:
+            walk(c.path, depth + 1)
+
+    walk(root.resolve(), 0)

coldstore/apply.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.prompt import Confirm
+
+from .actions import do_archive, do_compact_lzx, do_recycle, record_result
+from .journal import Journal
+from .report import Candidate
+from .rules import Verdict
+
+
+def _fmt_bytes(n: int) -> str:
+    if n == 0:
+        return "0 B"
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if abs(n) < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} PB"
+
+
+def run_apply(
+    root: Path,
+    candidates: list[Candidate],
+    do_junk: bool,
+    do_cool: bool,
+    do_cold: bool,
+    yes: bool,
+) -> int:
+    con = Console()
+    journal = Journal()
+
+    if not (do_junk or do_cool or do_cold):
+        con.print("[yellow]nothing to do — pass --junk, --cool, and/or --cold[/yellow]")
+        return 2
+
+    junk = [c for c in candidates if c.classification.verdict == Verdict.JUNK]
+    cool = [c for c in candidates if c.classification.verdict == Verdict.COOL]
+    cold = [c for c in candidates if c.classification.verdict == Verdict.COLD]
+
+    def _preview(items: list[Candidate], title: str, style: str) -> None:
+        total = sum(c.stats.total_bytes for c in items)
+        con.rule(f"[bold {style}]{title}[/bold {style}]")
+        con.print(f"{len(items)} folders, total {_fmt_bytes(total)}")
+        for c in items[:10]:
+            con.print(f"  [dim]{_fmt_bytes(c.stats.total_bytes):>10s}[/dim]  {c.stats.path}")
+        if len(items) > 10:
+            con.print(f"  [dim]... and {len(items) - 10} more[/dim]")
+
+    if do_junk and junk:
+        _preview(junk, "JUNK — Recycle Bin", "red")
+        if yes or Confirm.ask("Send these to the Recycle Bin?", default=False):
+            _run_batch(junk, do_recycle, "Recycled", "green", con, journal)
+
+    if do_cool and cool:
+        _preview(cool, "COOL — NTFS/LZX compression", "cyan")
+        if yes or Confirm.ask("Compress these in place (compact.exe LZX)?", default=False):
+            _run_batch(cool, do_compact_lzx, "Compressed", "cyan", con, journal, show_ratio=True)
+
+    if do_cold and cold:
+        _preview(cold, "COLD — 7z archive + stub", "blue")
+        if yes or Confirm.ask("Archive these to .coldstore stubs (deletes originals after verify)?", default=False):
+            _run_batch(cold, do_archive, "Archived", "blue", con, journal, show_ratio=True, show_stub=True)
+
+    con.print()
+    con.print(f"[dim]Journal: {journal.file}[/dim]")
+    return 0
+
+
+def _run_batch(items, action_fn, verb, style, con, journal, show_ratio=False, show_stub=False):
+    freed = 0
+    ok_count = 0
+    for c in items:
+        con.print(f"  [dim]{verb.lower()}[/dim] {c.stats.path} ...")
+        result = action_fn(c)
+        record_result(journal, c, result)
+        if result.ok:
+            freed += result.bytes_freed
+            ok_count += 1
+            line = f"  [green]✓[/green] {c.stats.path}"
+            if show_ratio and result.before_bytes:
+                line += (f"  {_fmt_bytes(result.before_bytes)} → "
+                         f"{_fmt_bytes(result.after_bytes)}  "
+                         f"[bold]({result.ratio:.2f}x)[/bold]")
+            else:
+                line += f"  ({_fmt_bytes(result.before_bytes)})"
+            con.print(line)
+            if show_stub and "stub_path" in result.extras:
+                con.print(f"    [dim]stub: {result.extras['stub_path']}[/dim]")
+        else:
+            con.print(f"  [red]✗[/red] {c.stats.path}  [dim]{result.error or result.note}[/dim]")
+    con.print(f"[bold {style}]{verb} {ok_count}/{len(items)} folders, freed {_fmt_bytes(freed)}[/bold {style}]")