Where everything lives — drawn as the wall stands.
'
+ + "".join(parts)
+ )
+
+
def _detail_body(g: dict, art: dict[str, str]) -> str:
art_html = (
f' dict:
@@ -517,17 +608,70 @@ def run_export(
'"Powered by BGG" link; save the official badge from '
"boardgamegeek.com/applications to upgrade it"
)
+ # the location layer, when the owner has one and wants it published
+ units = load_furniture(cfg) if include_shelves else []
+ locations = load_locations(cfg) if include_shelves else {}
+ openings = opening_index(units)
+ where: dict[str, str] = {}
+ contains: dict[str, list[str]] = {}
+ for key, game in games.items():
+ oid, note, via = effective_location(key, game, games, locations)
+ opening = openings.get(oid) if oid else None
+ if opening:
+ where[key] = f"{opening['unit']} · {opening['label']}"
+ elif via is None and note:
+ where[key] = note
+ if game.get("stored_in"):
+ for other_key, other in games.items():
+ if str(other.get("bgg_id")) == str(game["stored_in"]):
+ contains.setdefault(other_key, []).append(key)
+
# game pages FIRST, index last: a killed run must not leave an index
# linking to pages that were never written
for key, game in games.items():
page_dir = out_dir / slugs[key]
page_dir.mkdir(exist_ok=True)
cover = art.get(key, {}).get("full", "")
+ extras = ""
+ if where.get(key):
+ extras += (
+ '
where it lives '
+ f"{html.escape(where[key])}
"
+ )
+ container_key = next(
+ (
+ k
+ for k, other in games.items()
+ if game.get("stored_in")
+ and str(other.get("bgg_id")) == str(game["stored_in"])
+ ),
+ None,
+ )
+ if container_key:
+ extras += (
+ '
',
+ 1,
+ )
atomic_write_text(
out_dir / "index.html",
_page(title, index_body, rel="", site_title=title, badge_present=badge_present),
diff --git a/src/bggpipe/shelves.py b/src/bggpipe/shelves.py
index 04e7dd6..1c0fc13 100644
--- a/src/bggpipe/shelves.py
+++ b/src/bggpipe/shelves.py
@@ -178,29 +178,171 @@ def effective_location(
return loc.get("opening_id"), loc.get("note", ""), via if via != key else None
-def opening_report(opening: dict, games_here: list[tuple[str, dict]]) -> dict:
- """Capacity picture for one opening: fill (stacked thickness vs
- interior height), misfits, and how many boxes are unmeasured. Games
- stored INSIDE another box are listed residents but occupy no shelf
- space of their own — only their container is stacked and fit-checked,
- the same stance the dims report takes."""
- physical = [(k, e) for k, e in games_here if not e.get("stored_in")]
- thicknesses = [stack_thickness(e) for _, e in physical]
- stacked = sum(t for t in thicknesses if t)
- unmeasured = sum(1 for t in thicknesses if t is None)
+def _flat_claim(dims: tuple, opening: dict) -> float | None:
+ """A flat box's claim on the opening's WIDTH: its footprint (the two
+ larger axes) must fit width × depth; the claim is the footprint axis
+ left running along the width, minimized over the two orientations.
+ None = the footprint fits neither way."""
+ t = min(dims)
+ rest = sorted(dims)
+ rest.remove(t)
+ a, b = rest # a <= b
+ claims = []
+ if b <= opening["depth_in"] and a <= opening["width_in"]:
+ claims.append(a)
+ if a <= opening["depth_in"] and b <= opening["width_in"]:
+ claims.append(b)
+ return min(claims) if claims else None
+
+
+def _stands(dims: tuple, opening: dict) -> bool:
+ """On edge, the thinnest axis runs along the width; the other two
+ must fit height × depth one way or the other."""
+ t = min(dims)
+ rest = sorted(dims)
+ rest.remove(t)
+ a, b = rest
+ return (a <= opening["height_in"] and b <= opening["depth_in"]) or (
+ b <= opening["height_in"] and a <= opening["depth_in"]
+ )
+
+
+def lane_split(opening: dict, physical: list[tuple[str, dict, str]]) -> dict:
+ """The two-lane packing model. Each opening holds a flat stack
+ (thinnest axes summing against interior HEIGHT, claiming the widest
+ flat box's width) and a standing lane beside it (boxes on edge,
+ thinnest axes summing against the REMAINING width). Lanes are chosen
+ greedily — larger footprints lie flat, smaller boxes stand — unless
+ an assignment carries an explicit lane override. A box no lane can
+ take is laneless; the opening warns only then.
+
+ physical: [(key, entry, override)] with override in "", "flat",
+ "standing". Unmeasured boxes take no lane but are counted."""
height = opening.get("height_in")
+ width = opening.get("width_in")
+ lanes: dict[str, str] = {}
+ laneless: list[str] = []
+ unmeasured = 0
+ flat_in = 0.0
+ flat_claim = 0.0
+ standing: list[tuple[str, float]] = [] # (key, thickness)
+
+ def footprint(dims):
+ axes = sorted(dims, reverse=True)
+ return axes[0] * axes[1]
+
+ measured = []
+ for key, entry, override in physical:
+ dims = game_dims(entry)
+ if dims is None:
+ unmeasured += 1
+ else:
+ measured.append((key, entry, override, dims))
+ measured.sort(key=lambda item: footprint(item[3]), reverse=True)
+
+ def try_flat(key, dims):
+ nonlocal flat_in, flat_claim
+ claim = _flat_claim(dims, opening)
+ thickness = min(dims)
+ if claim is None or flat_in + thickness > height:
+ return False
+ flat_in += thickness
+ flat_claim = max(flat_claim, claim)
+ lanes[key] = "flat"
+ return True
+
+ def try_standing(key, dims):
+ thickness = min(dims)
+ used = sum(t for _, t in standing)
+ if not _stands(dims, opening) or used + thickness > width - flat_claim:
+ return False
+ standing.append((key, thickness))
+ lanes[key] = "standing"
+ return True
+
+ max_fp = footprint(measured[0][3]) if measured else 0
+ for key, entry, override, dims in measured:
+ if override == "flat":
+ placed = try_flat(key, dims)
+ elif override == "standing":
+ placed = try_standing(key, dims)
+ elif footprint(dims) >= max_fp - 1e-6:
+ # the largest-footprint class lies flat; smaller boxes stand
+ # beside the stack when they can
+ placed = try_flat(key, dims) or try_standing(key, dims)
+ else:
+ placed = try_standing(key, dims) or try_flat(key, dims)
+ if not placed:
+ laneless.append(entry.get("name") or "?")
+ # the flat claim can grow after standing boxes were placed: re-check
+ while standing and sum(t for _, t in standing) > width - flat_claim:
+ key, _ = standing.pop()
+ laneless.append(
+ next((e.get("name") or "?" for k, e, _o in physical if k == key), "?")
+ )
+ lanes.pop(key, None)
+ return {
+ "lanes": lanes,
+ "flat_in": round(flat_in, 2),
+ "flat_claim": round(flat_claim, 2),
+ "standing_in": round(sum(t for _, t in standing), 2),
+ "laneless": laneless,
+ "unmeasured": unmeasured,
+ }
+
+
+def opening_report(
+ opening: dict,
+ games_here: list[tuple[str, dict]],
+ overrides: dict[str, str] | None = None,
+) -> dict:
+ """Capacity picture for one opening under the two-lane model. Games
+ stored INSIDE another box are listed residents but occupy no shelf
+ space of their own — only their container is packed, the same stance
+ the dims report takes."""
+ overrides = overrides or {}
+ physical = [
+ (k, e, overrides.get(k, "")) for k, e in games_here if not e.get("stored_in")
+ ]
+ height = opening.get("height_in")
+ width = opening.get("width_in")
+ if not (height and width):
+ return {
+ "games": len(physical),
+ "flat_in": 0,
+ "standing_in": 0,
+ "flat_claim": 0,
+ "lanes": {},
+ "unmeasured": sum(1 for _, e, _o in physical if game_dims(e) is None),
+ "fill": 0,
+ "standing_fill": 0,
+ "overfull": False,
+ "misfits": [],
+ "laneless": [],
+ }
+ split = lane_split(opening, physical)
misfits = [
entry.get("name") or "?"
- for _, entry in physical
+ for _, entry, _o in physical
if fits_opening(entry, opening) is False
]
+ standing_budget = max(width - split["flat_claim"], 0.01)
return {
"games": len(physical),
- "stacked_in": round(stacked, 2),
- "unmeasured": unmeasured,
- "fill": round(stacked / height, 2) if height and stacked else 0,
- "overfull": bool(height and stacked > height),
+ "flat_in": split["flat_in"],
+ "standing_in": split["standing_in"],
+ "flat_claim": split["flat_claim"],
+ "lanes": split["lanes"],
+ "unmeasured": split["unmeasured"],
+ "fill": round(split["flat_in"] / height, 2) if split["flat_in"] else 0,
+ "standing_fill": (
+ round(split["standing_in"] / standing_budget, 2)
+ if split["standing_in"]
+ else 0
+ ),
+ "overfull": bool(split["laneless"]),
"misfits": misfits,
+ "laneless": split["laneless"],
}
diff --git a/src/bggpipe/static/app.css b/src/bggpipe/static/app.css
index 291c3b8..4797950 100644
--- a/src/bggpipe/static/app.css
+++ b/src/bggpipe/static/app.css
@@ -581,6 +581,12 @@ button.opening:hover, button.opening:focus-visible {
.fillbar > div { height: 100%; background: var(--go, #2f8a45);
border-radius: 1rem; }
.fillbar > div.over { background: #b3372f; }
+.fillbar.dual { margin-top: 2px; }
+.fillbar > div.stand { background: #3e6fa3; }
+.lanebtn { font: inherit; font-size: .72rem; cursor: pointer;
+ border: 1px solid var(--board-edge); border-radius: 1rem;
+ background: #fff; padding: .05rem .5rem; color: var(--ink-soft); }
+.lanebtn:hover { border-color: var(--accent); color: var(--accent); }
.unshelved-row { display: flex; gap: .6rem; align-items: center;
flex-wrap: wrap; padding: .4rem 0;
border-bottom: 1px solid var(--board-edge); }
diff --git a/src/bggpipe/templates/pages/help.html b/src/bggpipe/templates/pages/help.html
index 5606182..2d6f20d 100644
--- a/src/bggpipe/templates/pages/help.html
+++ b/src/bggpipe/templates/pages/help.html
@@ -30,7 +30,7 @@
Titles — every read off your shelves, alphabetized, with its status and photos. This is the proofread checkpoint: edit, split, remove. Its badge counts shaky read lines — the model wasn't sure and nothing has verified them; filter to them, then press ✓ looks right or edit each one.
Review — the decisions only you can make: which game a title is, which edition a copy is, whether two same-game reads are really one box (merges show a veto), and whether an unmatched title is a real game BGG simply doesn't have (keep locally: it joins the Library, never uploads). Keyboard-first; see shortcuts.
Queue — exactly what upload will do (new entries and version upgrades) and the log of everything it has done. Nothing reaches BGG that isn't visible here first. A job that fails is skipped by later runs (so one broken game can't loop forever); when any exist, the Pipeline's upload card offers a retry N failed checkbox. Each queued row shows what upload did with it — pending, done, failed, or retired (a review decision since the last diff withdrew it). Finished rows stay listed until the next diff rebuilds the queue; the log below them is the permanent record.
-
Shelves — where everything physically lives, drawn as it really stands: openings group into rows by label letter with widths proportional to their interiors, so the page is a diagram of your wall. Describe furniture once (presets for Kallax cubes and Billy shelves, grids of rows × columns — a later grid continues the row letters — custom sizes, and no-size spots like a travel case); units and openings both take a free-text description beside the zone keyword. Suggestions rank an opening holding a series-mate or base game first (marked ♥ — every placement you confirm teaches the suggester your organization), always against the remaining room, then tightest verified fit; a measured game with nowhere suitable says "no matching openings yet", and unmeasured games get no suggestions because can't-verify ≠ fits. Assign by tapping suggestions, searching inside an opening, or from any game's detail page. Fill bars show stacked thickness against interior height; ⚠ flags overfull openings and boxes that can't fit; games stored inside another box ride along with their container, through whole chains. Your layout is local data only — never sent anywhere. Bulk-load a plan with bggpipe shelve --import plan.csv (name,opening) and check capacity anytime with bggpipe dims.
+
Shelves — where everything physically lives, drawn as it really stands: openings group into rows by label letter with widths proportional to their interiors, so the page is a diagram of your wall. Describe furniture once (presets for Kallax cubes and Billy shelves, grids of rows × columns — a later grid continues the row letters — custom sizes, and no-size spots like a travel case); units and openings both take a free-text description beside the zone keyword. Suggestions rank an opening holding a series-mate or base game first (marked ♥ — every placement you confirm teaches the suggester your organization), always against the remaining room, then tightest verified fit; a measured game with nowhere suitable says "no matching openings yet", and unmeasured games get no suggestions because can't-verify ≠ fits. Assign by tapping suggestions, searching inside an opening, or from any game's detail page. Capacity is a two-lane model — a flat stack against interior height plus a standing lane against the remaining width; the largest boxes lie flat, smaller ones stand, and each box's lane is flippable in the opening's view. ⚠ means no packing fits, not merely "tall stack"; games stored inside another box ride along with their container, through whole chains. Your layout is local data only — never sent anywhere. Bulk-load a plan with bggpipe shelve --import plan.csv (name,opening) and check capacity anytime with bggpipe dims.
Library — your enriched collection. Search titles, designers, mechanics and categories at once; filter by kind (board games, RPGs, off-BGG) or by how many people are playing tonight; sort by name, year, BGG rank, weight, or playing time. Click any game for its full detail: art, the usual stats, designers and mechanics, your edition, the shelf photos it was read from, and a link to its BGG page. RPG and off-BGG games live here too — identified and enriched, never uploaded. RPGs pull their designers, publishers and genres from RPGGeek; an off-BGG game's detail page lets you write its facts yourself and add a cover photo, since nothing else will ever have them (both are saved under data/ and folded in by the next enrich).
diff --git a/src/bggpipe/templates/pages/shelves.html b/src/bggpipe/templates/pages/shelves.html
index 5453caa..9b27818 100644
--- a/src/bggpipe/templates/pages/shelves.html
+++ b/src/bggpipe/templates/pages/shelves.html
@@ -80,18 +80,25 @@ function openingById(id) {
function fillBar(o) {
if (!o.width_in) return `no size limits`;
- const pct = Math.min(100, Math.round((o.fill || 0) * 100));
- return `