publish: per-bundle width overrides; compact n=3 trio shipped

build_bundle and the modal spec grammar (name:n[:d[:d_hidden]]) gain
d / d_hidden overrides for right-sized small-n bundles; d_head stays
graph-baked.  The card states each bundle's own compile width instead
of assuming the family geometry, and push_remote prunes stale remote
shards when a replacement bundle has fewer.

Shipped 2026-07-26: the three n=3 repos replaced at 2048:4096 — the
measured free-shrink geometry (scripts/measure_calculator_compiled_
layers: floor-optimal at 27/29/18 layers, same as canonical; the
publish path's RMS reserved column cost zero).  simple n=3 drops
14.26GB -> 4.08GB.  Depth-sweep artifacts (n>=5 repos, layer table,
blog figure) stay at the canonical shared geometry.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: physicsrob

examples/compile.py

@@ -89,8 +89,8 @@
 
 ## Size
 
-The checkpoint stores {size_gb} GB of dense fp32 weights ({total} entries) at
-the example family's shared compile width.  {zero_pct}% of those entries are
+The checkpoint stores {size_gb} GB of dense fp32 weights ({total} entries){width}.
+{zero_pct}% of those entries are
 exactly zero: the vast majority of the model is unused canvas, so size reflects
 the compile geometry rather than stored knowledge.
 
@@ -245,7 +245,15 @@ def write_card(
         card += _CARD_LIMITS
         card += _CARD_VERIFICATION
     nonzero, total, size_bytes = _weight_stats(out_dir)
+    config_path = Path(out_dir, "config.json")
+    width = ""
+    if config_path.is_file():
+        with config_path.open() as f:
+            hidden = json.load(f).get("hidden_size")
+        if hidden:
+            width = f" at compile width d={hidden}"
     card += _CARD_SIZE.format(
+        width=width,
         zero_pct=f"{100.0 * (1.0 - nonzero / total):.2f}",
         total=f"{total:,}",
         size_gb=f"{size_bytes / 1e9:.2f}",
@@ -335,14 +343,20 @@ def build_bundle(
     *,
     max_digits: int | None = None,
     optimize: int = 0,
+    d: int | None = None,
+    d_hidden: int | None = None,
 ) -> tuple[str, list[str] | None, int]:
     """Compile ``examples.<name>`` into an HF bundle with its model card.
 
     ``max_digits`` threads through to ``create_network_parts`` for the
     examples that take it (the calculator family); passing it for one
-    that doesn't raises.  Returns ``(out_dir, demo prompts or None,
-    generation budget)`` — the demo itself is the caller's decision,
-    not part of the build.
+    that doesn't raises.  ``d`` / ``d_hidden`` override the module's
+    family geometry — for right-sized small-n bundles whose free-shrink
+    region is measured (scripts/measure_calculator_compiled_layers);
+    ``d_head`` is never overridable (it is baked into the graph at
+    build time).  Returns ``(out_dir, demo prompts or None, generation
+    budget)`` — the demo itself is the caller's decision, not part of
+    the build.
     """
     module = importlib.import_module(f"examples.{name}")
     if not hasattr(module, "create_network_parts"):
@@ -365,10 +379,12 @@ def build_bundle(
         output_node,
         embedding,
         out_dir,
-        d=getattr(module, "D_MODEL", 1024),
+        d=d if d is not None else int(getattr(module, "D_MODEL", 1024)),
         d_head=getattr(module, "D_HEAD", 16),
         n_heads=getattr(module, "N_HEADS", None),
-        d_hidden=getattr(module, "D_HIDDEN", None),
+        d_hidden=d_hidden
+        if d_hidden is not None
+        else getattr(module, "D_HIDDEN", None),
         optimize=optimize,
     )
     write_card(name, out_dir, max_digits)
@@ -391,6 +407,18 @@ def main() -> None:
         help="operand digit width, for examples whose create_network_parts "
         "takes max_digits (default: the example's own default)",
     )
+    ap.add_argument(
+        "--d",
+        type=int,
+        default=None,
+        help="override the module's D_MODEL (right-sized small-n bundles)",
+    )
+    ap.add_argument(
+        "--d-hidden",
+        type=int,
+        default=None,
+        help="override the module's D_HIDDEN",
+    )
     ap.add_argument(
         "--optimize",
         type=int,
@@ -401,7 +429,12 @@ def main() -> None:
 
     try:
         out_dir, prompts, max_new_tokens = build_bundle(
-            args.name, args.out, max_digits=args.max_digits, optimize=args.optimize
+            args.name,
+            args.out,
+            max_digits=args.max_digits,
+            optimize=args.optimize,
+            d=args.d,
+            d_hidden=args.d_hidden,
         )
     except ValueError as exc:
         raise SystemExit(str(exc)) from None

modal_compile.py

@@ -66,7 +66,7 @@ def repo_name(name: str, max_digits: int | None) -> str:
 def compile_remote(spec: tuple) -> dict:
     from examples.compile import build_bundle, bundle_dirname, run_prompts
 
-    name, max_digits, optimize = spec
+    name, max_digits, optimize, d, d_hidden = (*spec, None, None)[:5]
     dirname = bundle_dirname(name, max_digits)
     t0 = time.time()
     try:
@@ -75,6 +75,8 @@ def compile_remote(spec: tuple) -> dict:
             str(Path(BUNDLE_ROOT) / dirname),
             max_digits=max_digits,
             optimize=optimize,
+            d=d,
+            d_hidden=d_hidden,
         )
     except (ValueError, RuntimeError) as exc:
         # A cell can refuse to build (calculator_memorize past n=2) or to
@@ -263,19 +265,39 @@ def push_remote(dirname: str, repo_id: str) -> str:
 
     api = HfApi()
     api.create_repo(repo_id, exist_ok=True)
-    api.upload_folder(folder_path=str(Path(BUNDLE_ROOT) / dirname), repo_id=repo_id)
+    api.upload_folder(
+        folder_path=str(Path(BUNDLE_ROOT) / dirname),
+        repo_id=repo_id,
+        # A replacement bundle may have fewer shards than its
+        # predecessor; stale remote shards would linger (the index
+        # ignores them, but they bloat and confuse the repo).
+        delete_patterns=["model-*.safetensors"],
+    )
     return f"https://huggingface.co/{repo_id}"
 
 
 @app.local_entrypoint()
 def main(specs: str, optimize: int = 0, push_prefix: str = "") -> None:
     cells = []
     for cell_spec in specs.split(","):
-        cell_name, _, digits = cell_spec.partition(":")
-        cells.append((cell_name.strip(), int(digits) if digits else None, optimize))
+        # name[:max_digits[:d[:d_hidden]]] — trailing fields optional.
+        fields = [f or None for f in cell_spec.strip().split(":")]
+        fields += [None] * (4 - len(fields))
+        name_part, digits, d, d_hidden = fields[:4]
+        if not name_part:
+            raise ValueError(f"bad spec: {cell_spec!r}")
+        cells.append(
+            (
+                name_part,
+                int(digits) if digits else None,
+                optimize,
+                int(d) if d else None,
+                int(d_hidden) if d_hidden else None,
+            )
+        )
 
     to_push = []
-    for (name, n, _), row in zip(cells, compile_remote.map(cells), strict=True):
+    for (name, n, *_rest), row in zip(cells, compile_remote.map(cells), strict=True):
         print(row, flush=True)
         if push_prefix and "error" not in row:
             to_push.append((row["bundle"], f"{push_prefix}{repo_name(name, n)}"))