load under transformers' remote-code loader: defer the imports it cannot resolve

The loader resolves every relative import to a FLAT file beside the module,
whatever the nesting. Three `from .fusion import ...` sites in alephlm.py and
one `from .data.curriculum import ...` in presets.py therefore made it demand
fusion.py and data.curriculum.py in this repo and refuse to load the model
(OSError / FileNotFoundError on transformers 5).

Both imports are inert for this craft: the config carries no `fusion` key, so
that branch is never taken, and the curriculum is a training-side concern. They
are now resolved by name at the point of use, so nothing is imported unless the
code path is actually run. No weights, config or math changed.

Proved before push, in a virtualenv with transformers 5.13 and no geolip
installed: AutoModelForCausalLM.from_pretrained(..., trust_remote_code=True)
loads 112.5M params with no missing or unexpected keys and runs a forward
pass over a byte prompt.

alephlm.py

@@ -101,7 +101,17 @@ class AlephLM(nn.Module):
         # units and the front/back blocks stay at byte resolution.
         spec = getattr(cfg, "fusion", None)
         if spec:
-            from .fusion import Fusion
+            # VENDORED: the live package reads
+            #     from .fusion import Fusion
+            # transformers' remote-code loader resolves every relative
+            # import to a flat file beside this one, so written that way
+            # it demands a fusion.py here and refuses to load the model.
+            # This craft is fusion-free (its config carries no `fusion`
+            # key, so this branch is never taken); fusion belongs to the
+            # training side and itself imports the data subpackage, which
+            # a flat package cannot carry. Deferred and resolved by name.
+            from importlib import import_module
+            Fusion = import_module("geolip.alephllm.model.fusion").Fusion
             self.fusion = Fusion(spec, cfg.d_model)
         else:
             self.fusion = None
@@ -219,7 +229,10 @@ class AlephLM(nn.Module):
         across rows (the hub's prefix state has one shape per row)."""
         from .embedding import PAD_ROW
         from .governor import raw_block
-        from .fusion import cat_caches, zero_cache_rows
+        # VENDORED: from .fusion import cat_caches, zero_cache_rows (see __init__)
+        from importlib import import_module
+        _f = import_module("geolip.alephllm.model.fusion")
+        cat_caches, zero_cache_rows = _f.cat_caches, _f.zero_cache_rows
         front, middle, back = self._ranges()
         for b in middle:
             assert raw_block(b).is_hub, "fused decode needs hub blocks in the middle"
@@ -265,7 +278,10 @@ class AlephLM(nn.Module):
     @torch.no_grad()
     def _decode_step_fused(self, next_id, cache, t):
         from .embedding import PAD_ROW
-        from .fusion import snapshot, restore_rows
+        # VENDORED: from .fusion import snapshot, restore_rows (see __init__)
+        from importlib import import_module
+        _f = import_module("geolip.alephllm.model.fusion")
+        snapshot, restore_rows = _f.snapshot, _f.restore_rows
         front, middle, back = self._ranges()
         prev1, prev2, prev3 = cache["prev1"], cache["prev2"], cache["prev3"]
         st = self.fusion.starts_step(next_id, prev1, prev2, prev3, PAD_ROW)   # (B,) closes the open unit

presets.py

@@ -256,7 +256,18 @@ def make_v3_preset(n_layers: int = 24, d_model: int = 1024,
     epoch_cap / rebalance_to: the data-plane decisions (the trainer
     refuses a scaled stage without a rebalance rule); under 'hold' the
     stages stay at 1x and the held budget goes to fineweb_main."""
-    from .data.curriculum import curriculum_phases, _BASE_STAGE_TOKENS
+    # VENDORED: the live package reads
+    #     from .data.curriculum import curriculum_phases, _BASE_STAGE_TOKENS
+    # Written that way here it is a relative import of a SUBPACKAGE, and
+    # transformers' remote-code loader resolves every relative import to a
+    # flat file beside this one — it would demand "data.curriculum.py" and
+    # refuse to load the model. This package ships the inference path only;
+    # the curriculum lives in the installable geolip-alephllm, so the
+    # import is deferred and resolved by name when that package is there.
+    from importlib import import_module
+    _curriculum = import_module("geolip.alephllm.data.curriculum")
+    curriculum_phases = _curriculum.curriculum_phases
+    _BASE_STAGE_TOKENS = _curriculum._BASE_STAGE_TOKENS
     if name is None:
         name = "mini-beatrix-3" if n_layers == 24 and d_model == 1024 \
             else f"mini-beatrix-3-d{d_model}-l{n_layers}"