Update inference solvers and versioning

Add ER-SDE, corrected finite endpoint scheduling, Euler-Maruyama endpoint handling, independent code version provenance, and current-code/older-checkpoint documentation. Existing checkpoint and text-encoder weights are unchanged.

API.md

@@ -6,6 +6,11 @@
 Canter exposes a high-level image pipeline and a lower-level latent inference
 engine. Configuration uses frozen dataclasses and enums.
 
+The installed `canter` package always supplies the inference implementation.
+For remote model IDs, `revision` selects checkpoint artifacts only; selecting
+an older checkpoint does not load or execute the Python package bundled in
+that historical repository snapshot.
+
 ## Minimal use
 
 ```python
@@ -56,7 +61,7 @@ pipe = CanterPipeline.from_pretrained(
 | `dtype` | `WeightDType.BFLOAT16` | Weight storage dtype. Compute still uses bfloat16 AMP with explicit float32 operations. |
 | `text_backend` | `TextAttentionBackend.JAGGED` | Text refinement and cross-attention layout. |
 | `device` | `"cuda"` | CUDA device string or `torch.device`. |
-| `revision` | `None` | Hugging Face branch, commit, or immutable release tag. `None` uses the package's pinned default release. Pass `"main"` explicitly to follow the moving repository head. |
+| `revision` | `None` | Hugging Face checkpoint branch, commit, or immutable release tag. `None` uses the installed package's pinned default checkpoint. An explicit tag such as `"v0001"` loads those weights with the currently installed code. |
 | `cache_dir` | `None` | Optional Hugging Face cache directory. |
 | `compile_model` | `True` | Compile the selected inference kernels. Compilation errors are reported directly. |
 | `vae` | `None` | Optional compatible `CanterVae` instance. `None` downloads DINAC-AE-D2 automatically. |
@@ -152,6 +157,7 @@ config = CanterInferenceConfig(
     ),
     self_attention_gain=-0.03,
     euler_maruyama_multiplier=1.0,
+    er_sde_noise_multiplier=1.0,
     seed=42,
     generator=None,
 )
@@ -170,7 +176,8 @@ config = CanterInferenceConfig(
 | `cfg` | disabled | Classifier-free guidance settings. |
 | `pdg` | full-path PDG 2.5 | Path-drop guidance settings. |
 | `self_attention_gain` | `-0.03` | Gain applied exclusively to image self-attention on the main denoiser path. |
-| `euler_maruyama_multiplier` | `1.0` | Non-negative stochastic noise multiplier used only by Euler-Maruyama. |
+| `euler_maruyama_multiplier` | `1.0` | Non-negative stochastic noise multiplier used by Euler-Maruyama. |
+| `er_sde_noise_multiplier` | `1.0` | Non-negative stochastic noise multiplier used by ER-SDE. |
 | `seed` | `42` | Random seed. Set to `None` when supplying `generator`. |
 | `generator` | `None` | Optional CUDA `torch.Generator` on the same device as the model. Exactly one of `seed` and `generator` is required. |
 
@@ -182,8 +189,9 @@ operations. The VAE decoder retains its published seed behavior.
 Images downloaded from the Gradio interface contain a `canter` PNG text field
 with compact JSON. The object begins with the prompt, effective per-image seed,
 width, height, steps, solver, and schedule. It then records PDG, CFG,
-self-attention gain, logSNR shift, Euler-Maruyama multiplier, numbered release,
-and weight dtype.
+self-attention gain, logSNR shift, the Euler-Maruyama and ER-SDE noise
+multipliers, installed code version, numbered checkpoint release, and weight
+dtype.
 
 ### Solvers
 
@@ -191,7 +199,8 @@ and weight dtype.
 | --- | --- | --- |
 | `Solver.EULER` | `"euler"` | First-order deterministic Euler updates. |
 | `Solver.EULER_MARUYAMA` | `"euler_maruyama"` | Stochastic reverse-SDE updates. Uses `euler_maruyama_multiplier`. |
-| `Solver.DPMPP_2M` | `"dpmpp_2m"` | Flow-matching DPM++ 2M updates with finite start handling. |
+| `Solver.ER_SDE` | `"er_sde"` | Third-stage VP ER-SDE with 16-point Gauss-Legendre correction quadrature. Uses `er_sde_noise_multiplier`. |
+| `Solver.DPMPP_2M` | `"dpmpp_2m"` | Flow-matching DPM++ 2M updates with finite pre-shift endpoint handling. |
 | `Solver.ABM2` | `"abm2"` | Variable-step Adams-Bashforth-Moulton updates with corrected-state reevaluation. |
 
 ABM2 is the default and performs additional denoiser evaluations for its
@@ -367,6 +376,7 @@ inference = CanterInferenceConfig(
     ),
     self_attention_gain=-0.03,
     euler_maruyama_multiplier=1.0,
+    er_sde_noise_multiplier=1.0,
     seed=123,
     generator=None,
 )
@@ -431,7 +441,7 @@ The returned latents use float32 and channels-last memory format.
 
 ## Pipeline metadata
 
-`pipe.metadata` records the resolved release, weight dtype, source
-digests, text-encoder revision, VAE repository, and resolved immutable VAE
-revision. Applications that require reproducibility should store this metadata
-with their outputs and pin a release tag.
+`pipe.metadata` records the installed Canter code version, resolved checkpoint
+release, weight dtype, source digests, text-encoder revision, VAE repository,
+and resolved immutable VAE revision. Applications that require reproducibility
+should store this metadata and pin both the package version and checkpoint tag.

README.md

@@ -22,7 +22,7 @@ base_model:
 > The model is still training. Checkpoints and behavior may change during
 > the preview period, and generation quality is still quite variable.
 
-**Current release:** [`v0001`](RELEASES.md#v0001)
+**Current checkpoint:** [`v0001`](RELEASES.md#v0001)
 
 [Example gallery](GALLERY.md) · [Getting started](#getting-started) ·
 [API and inference parameters](API.md) ·
@@ -55,21 +55,38 @@ Install a CUDA-enabled PyTorch build for your system first. The
 [PyTorch installation selector](https://pytorch.org/get-started/locally/)
 provides the appropriate command.
 
-### Download and install
+### Install the latest code and checkpoint
 
-Install the Hugging Face CLI, download the repository, and install the package
-from the downloaded directory:
+Install the Hugging Face CLI, download the moving `main` revision, and install
+the package in editable mode:
 
 ```bash
 python -m pip install "huggingface-hub>=1.15,<2"
-hf download data-archetype/canter --revision v0001 --local-dir canter
+hf download data-archetype/canter --revision main --local-dir canter
 cd canter
-python -m pip install .
+python -m pip install -e .
 ```
 
-The default release stores most weights in bfloat16. Numerically sensitive
+`main` contains the latest Canter code and the current default checkpoint.
+Editable installation means that refreshing the same directory updates the
+code used by the installed `canter-web` command.
+
+The default checkpoint stores most weights in bfloat16. Numerically sensitive
 parameters remain in float32.
 
+### Update an existing download
+
+Refresh a directory created with `hf download` by running:
+
+```bash
+hf download data-archetype/canter --revision main --local-dir canter
+```
+
+If the package was installed without `-e`, reinstall it afterwards with
+`python -m pip install --upgrade ./canter`. A Git clone on the `main` branch can
+instead be updated with `git pull`; an editable installation immediately uses
+the updated checkout.
+
 ### Start the Gradio interface
 
 Run the application from the downloaded repository:
@@ -82,8 +99,8 @@ python app.py --in-browser
 downloads the latest compatible DINAC-AE-D2 VAE.
 The interface appears immediately and reports model loading and pytorch dynamo compilation
 progress.
-Downloaded PNG files contain the prompt, effective per-image settings, and
-numbered model release as JSON metadata.
+Downloaded PNG files contain the prompt, effective per-image settings, Canter
+code version, and numbered checkpoint release as JSON metadata.
 
 The server listens on port 7860. To select the bind address explicitly:
 
@@ -148,14 +165,14 @@ rights.
 
 ## Releases
 
-Remote loading without a revision uses the package's pinned default release.
-It does not follow changes to `main`:
+The installed package supplies the inference code. Remote loading without a
+revision uses the checkpoint pinned by that package:
 
 ```python
 pipe = CanterPipeline.from_pretrained("data-archetype/canter")
 ```
 
-Pin an immutable checkpoint tag for reproducible use:
+Select an immutable older checkpoint while retaining the installed code:
 
 ```python
 pipe = CanterPipeline.from_pretrained(
@@ -164,6 +181,19 @@ pipe = CanterPipeline.from_pretrained(
 )
 ```
 
+The web interface supports the same separation:
+
+```bash
+canter-web \
+  --model data-archetype/canter \
+  --revision v0001 \
+  --in-browser
+```
+
+Running `app.py` from a tagged standalone download intentionally uses the code
+bundled with that historical snapshot. Use the installed `canter-web` command
+as above when testing old weights with current code.
+
 Release tags follow the `v0001`, `v0002`, and later numbering scheme. Optional
 full-float32 releases use tags such as `v0001-fp32`.
 

RELEASES.md

@@ -3,38 +3,48 @@
 [Model card](README.md) · [Getting started](README.md#getting-started) ·
 [API and inference parameters](API.md)
 
-The default package behavior is pinned to the release shown in the model card.
-It does not automatically follow the repository's `main` revision.
+Checkpoint tags are immutable snapshots. The installed package supplies the
+inference code, so current code can load any compatible checkpoint tag without
+executing the Python files stored in that historical snapshot.
 
 | Release | Date | Weight storage | Status |
 | --- | --- | --- | --- |
 | [`v0001`](https://huggingface.co/data-archetype/canter/tree/v0001) | July 2026 | bfloat16 with float32 precision islands | Preview |
 
-## Updating
+## Updating code
 
-Download a new release into a new directory and reinstall it:
+Refresh the moving `main` directory and use an editable installation:
 
 ```bash
-hf download data-archetype/canter --revision v0002 --local-dir canter-v0002
-cd canter-v0002
-python -m pip install --upgrade .
+hf download data-archetype/canter --revision main --local-dir canter
+python -m pip install -e ./canter
 ```
 
-Remote API and web UI loading can select the new release explicitly:
+For a Git clone on `main`, use `git pull`. If the checkout was installed
+without `-e`, reinstall it after updating.
+
+## Selecting a checkpoint
+
+Remote API and web UI loading can select any compatible checkpoint explicitly:
 
 ```python
 pipe = CanterPipeline.from_pretrained(
     "data-archetype/canter",
-    revision="v0002",
+    revision="v0001",
 )
 ```
 
 ```bash
-canter-web --model data-archetype/canter --revision v0002 --in-browser
+canter-web --model data-archetype/canter --revision v0001 --in-browser
 ```
 
-Passing `revision="main"` explicitly follows the moving repository head.
-Pinned release tags are recommended for normal use.
+These commands use the currently installed code and download only the selected
+checkpoint artifacts. Running `app.py` inside a tagged standalone directory
+instead uses the historical code bundled with that snapshot.
+
+For exact reproduction, pin both the Canter package version and checkpoint
+tag. Passing `revision="main"` explicitly selects the moving repository head
+and is not an immutable checkpoint reference.
 
 ## v0001
 

canter/__init__.py

@@ -34,12 +34,14 @@ from .schedules import Schedule
 from .solvers import Solver, SolverProgress
 from .text_encoder import CanterTextEncoder, TextBackboneOutput
 from .vae import CanterVae
+from .version import CANTER_VERSION, __version__
 
 __all__ = [
     "CANTER_CONFIG",
     "CANTER_DEFAULT_RELEASE",
     "CANTER_LICENSE",
     "CANTER_LICENSE_URL",
+    "CANTER_VERSION",
     "CanterComponents",
     "CanterConfig",
     "CanterInferenceConfig",
@@ -66,4 +68,5 @@ __all__ = [
     "TextAttentionBackend",
     "TextBackboneOutput",
     "WeightDType",
+    "__version__",
 ]

canter/inference.py

@@ -15,7 +15,7 @@ from torch.amp import autocast
 from .modeling_canter import CanterPath, PreparedText
 from .runtime import CANTER_AMP_DTYPE, validate_common_runtime
 from .schedules import Schedule, build_schedule
-from .solvers import Solver, SolverProgress, solve
+from .solvers import LOGSNR_SOLVER_START_EPS, Solver, SolverProgress, solve
 
 if TYPE_CHECKING:
     from .loading import CanterComponents
@@ -141,6 +141,7 @@ class CanterInferenceConfig:
     euler_maruyama_multiplier: float = 1.0
     seed: int | None = 42
     generator: torch.Generator | None = None
+    er_sde_noise_multiplier: float = 1.0
 
     def __post_init__(self) -> None:
         """Validate all public inference parameters before model execution."""
@@ -170,11 +171,14 @@ class CanterInferenceConfig:
             ("log_snr_shift", self.log_snr_shift),
             ("self_attention_gain", self.self_attention_gain),
             ("euler_maruyama_multiplier", self.euler_maruyama_multiplier),
+            ("er_sde_noise_multiplier", self.er_sde_noise_multiplier),
         ):
             if not math.isfinite(float(value)):
                 raise ValueError(f"{name} must be finite.")
         if float(self.euler_maruyama_multiplier) < 0.0:
             raise ValueError("euler_maruyama_multiplier must be non-negative.")
+        if float(self.er_sde_noise_multiplier) < 0.0:
+            raise ValueError("er_sde_noise_multiplier must be non-negative.")
         _validate_rng(self.seed, self.generator)
         _resolve_window(self.cfg.start_step, self.cfg.stop_step, self.steps, "CFG")
         _resolve_window(self.pdg.start_step, self.pdg.stop_step, self.steps, "PDG")
@@ -568,6 +572,11 @@ class CanterInferenceEngine:
             config.schedule,
             steps=config.steps,
             log_snr_shift=config.log_snr_shift,
+            finite_noisy_endpoint_epsilon=(
+                float(LOGSNR_SOLVER_START_EPS)
+                if config.solver in (Solver.DPMPP_2M, Solver.ER_SDE)
+                else None
+            ),
             device=self.device,
         )
         self.model.eval()
@@ -621,6 +630,7 @@ class CanterInferenceEngine:
                 solver=config.solver,
                 generator=execution_generator,
                 euler_maruyama_multiplier=config.euler_maruyama_multiplier,
+                er_sde_noise_multiplier=config.er_sde_noise_multiplier,
                 progress=progress,
             )
         return CanterLatentOutput(latents=latents, schedule=schedule)

canter/loading.py

@@ -25,6 +25,14 @@ from .runtime import (
 )
 from .text_encoder import CanterTextEncoder
 
+_CHECKPOINT_ALLOW_PATTERNS = (
+    "config.json",
+    "release.json",
+    "weights_manifest.json",
+    "model*.safetensors*",
+    "text_encoder/*",
+)
+
 
 class WeightDType(Enum):
     """Public Canter checkpoint storage dtypes."""
@@ -167,6 +175,7 @@ def _resolve_model_dir(
             str(path_or_repo_id),
             revision=resolved_revision,
             cache_dir=cache,
+            allow_patterns=list(_CHECKPOINT_ALLOW_PATTERNS),
         )
     )
 

canter/pipeline.py

@@ -25,6 +25,7 @@ from .loading import (
     WeightDType,
 )
 from .vae import CanterVae
+from .version import CANTER_VERSION
 
 if TYPE_CHECKING:
     from .solvers import SolverProgress
@@ -61,6 +62,7 @@ class CanterPipelineMetadata:
     canter: CanterReleaseMetadata
     vae_repository: str
     vae_revision: str
+    code_version: str = field(default=CANTER_VERSION, init=False)
 
 
 @dataclass(frozen=True)

canter/schedules.py

@@ -63,11 +63,51 @@ def _beta_quantiles(points: int) -> Tensor:
     return torch.from_numpy(values)
 
 
+def _finite_noisy_endpoint_epsilon(value: float | None) -> float | None:
+    """Validate an optional pre-shift endpoint trimming distance."""
+
+    if value is None:
+        return None
+    epsilon = float(value)
+    if not math.isfinite(epsilon) or not 0.0 < epsilon < 1.0:
+        raise ValueError(
+            "finite_noisy_endpoint_epsilon must be finite and lie in (0, 1)."
+        )
+    return epsilon
+
+
+def _cap_ascending_noisy_endpoint(timesteps: Tensor, *, epsilon: float) -> Tensor:
+    """Replace the exact t=1 endpoint before applying a log-SNR shift."""
+
+    if int(timesteps.numel()) < 2 or float(timesteps[-1].item()) != 1.0:
+        return timesteps
+    candidate = torch.tensor(
+        1.0 - float(epsilon),
+        device=timesteps.device,
+        dtype=timesteps.dtype,
+    )
+    neighbor = timesteps[-2]
+    if float(neighbor.item()) >= float(candidate.item()):
+        candidate = torch.nextafter(
+            neighbor,
+            torch.tensor(1.0, device=timesteps.device, dtype=timesteps.dtype),
+        )
+        if float(candidate.item()) >= 1.0:
+            raise ValueError(
+                "Cannot construct a finite noisy endpoint strictly between "
+                "the adjacent schedule point and t=1."
+            )
+    capped = timesteps.clone()
+    capped[-1] = candidate
+    return capped
+
+
 def build_schedule(
     kind: Schedule,
     *,
     steps: int,
     log_snr_shift: float,
+    finite_noisy_endpoint_epsilon: float | None,
     device: torch.device,
 ) -> Tensor:
     """Build a descending FP32 schedule with ``steps + 1`` endpoint samples."""
@@ -78,6 +118,7 @@ def build_schedule(
         raise TypeError("steps must be an int.")
     if steps < 1:
         raise ValueError("steps must be positive.")
+    endpoint_epsilon = _finite_noisy_endpoint_epsilon(finite_noisy_endpoint_epsilon)
     points = steps + 1
     match kind:
         case Schedule.LINEAR:
@@ -93,5 +134,10 @@ def build_schedule(
         case _ as unreachable:
             raise RuntimeError(f"Unsupported Canter schedule: {unreachable}")
     ascending = ascending.to(device=device, dtype=torch.float32)
+    if endpoint_epsilon is not None:
+        ascending = _cap_ascending_noisy_endpoint(
+            ascending,
+            epsilon=float(endpoint_epsilon),
+        )
     shifted = apply_log_snr_shift(ascending, float(log_snr_shift))
     return torch.flip(shifted, dims=(0,)).contiguous()

canter/solvers.py

@@ -6,11 +6,15 @@ import math
 from enum import Enum
 from typing import Protocol
 
+import numpy as np
 import torch
 import torch.nn.functional as F
 from torch import Tensor
 
-_DPM_START_EPS = 1.0e-4
+LOGSNR_SOLVER_START_EPS = 1.0e-4
+_ER_QUADRATURE_POINTS = 16
+_ER_NOISE_EXPONENT = 0.3
+_ER_NOISE_OFFSET = 10.0
 _SCORE_EPS = 1.0e-4
 
 
@@ -19,6 +23,7 @@ class Solver(Enum):
 
     EULER = "euler"
     EULER_MARUYAMA = "euler_maruyama"
+    ER_SDE = "er_sde"
     DPMPP_2M = "dpmpp_2m"
     ABM2 = "abm2"
 
@@ -121,7 +126,7 @@ def _euler_maruyama(
             dtype=torch.float32,
         )
         predicted = velocity(state, time, index).float()
-        terminal = index == intervals - 1 and abs(next_value) <= _SCORE_EPS
+        terminal = index == intervals - 1 and next_value == 0.0
         if terminal:
             state = state - time_value * predicted
             progress(index + 1, intervals)
@@ -144,29 +149,17 @@ def _euler_maruyama(
     return state
 
 
-def _prepare_dpm_schedule(schedule: Tensor) -> Tensor:
-    """Apply Canter's finite-start policy for DPM++ 2M."""
+def _prepare_logsnr_schedule(schedule: Tensor, *, solver_name: str) -> Tensor:
+    """Require finite evaluation times for a flow log-SNR solver."""
 
-    adjusted = schedule.clone()
-    if float(adjusted[0].item()) == 1.0:
-        candidate = torch.tensor(
-            1.0 - _DPM_START_EPS,
-            device=adjusted.device,
-            dtype=adjusted.dtype,
+    if bool(((schedule[:-1] <= 0.0) | (schedule[:-1] >= 1.0)).any().item()):
+        raise ValueError(
+            f"{solver_name} evaluation times must lie strictly inside (0, 1)."
         )
-        if float(adjusted[1].item()) >= float(candidate.item()):
-            candidate = torch.nextafter(
-                adjusted[1],
-                torch.tensor(1.0, device=adjusted.device, dtype=adjusted.dtype),
-            )
-            if float(candidate.item()) >= 1.0:
-                raise ValueError("DPM++ 2M cannot construct a finite start timestep.")
-        adjusted[0] = candidate
-    if bool(((adjusted[:-1] <= 0.0) | (adjusted[:-1] >= 1.0)).any().item()):
-        raise ValueError("DPM++ 2M evaluation times must lie strictly inside (0, 1).")
-    if float(adjusted[-1].item()) < 0.0:
-        raise ValueError("DPM++ 2M final time must be non-negative.")
-    return adjusted
+    final_time = float(schedule[-1].item())
+    if final_time < 0.0 or final_time >= 1.0:
+        raise ValueError(f"{solver_name} final time must lie in [0, 1).")
+    return schedule
 
 
 def _half_log_snr(time: Tensor) -> Tensor:
@@ -210,7 +203,7 @@ def _dpmpp_2m(
 ) -> Tensor:
     """Integrate with the flow-matching DPM++ 2M formulation."""
 
-    times = _prepare_dpm_schedule(schedule)
+    times = _prepare_logsnr_schedule(schedule, solver_name="DPM++ 2M")
     lambdas = _half_log_snr(times.clamp_min(torch.finfo(times.dtype).tiny))
     batch = int(state.shape[0])
     previous_denoised: Tensor | None = None
@@ -241,6 +234,159 @@ def _dpmpp_2m(
     return state
 
 
+def _er_noise_scaler(er_lambda: Tensor) -> Tensor:
+    """Evaluate the paper-selected ER-SDE noise-scaling function."""
+
+    return er_lambda * (torch.exp(er_lambda.pow(_ER_NOISE_EXPONENT)) + _ER_NOISE_OFFSET)
+
+
+def _er_quadrature_rule(*, device: torch.device) -> tuple[Tensor, Tensor]:
+    """Return float32 Gauss-Legendre nodes and weights on the solver device."""
+
+    nodes_np, weights_np = np.polynomial.legendre.leggauss(_ER_QUADRATURE_POINTS)
+    nodes = torch.as_tensor(nodes_np, device=device, dtype=torch.float32)
+    weights = torch.as_tensor(weights_np, device=device, dtype=torch.float32)
+    return nodes, weights
+
+
+def _er_quadrature_terms(
+    er_lambda_s: Tensor,
+    er_lambda_t: Tensor,
+    nodes: Tensor,
+    weights: Tensor,
+) -> tuple[Tensor, Tensor]:
+    """Evaluate the ER-SDE correction integrals with Gauss-Legendre quadrature."""
+
+    midpoint = (er_lambda_s + er_lambda_t) / 2.0
+    half_span = (er_lambda_s - er_lambda_t) / 2.0
+    positions = midpoint + half_span * nodes
+    scaled_positions = _er_noise_scaler(positions)
+    second = half_span * torch.sum(weights / scaled_positions)
+    third = half_span * torch.sum(
+        weights * (positions - er_lambda_s) / scaled_positions
+    )
+    return second, third
+
+
+def _er_sde_step(
+    *,
+    state: Tensor,
+    denoised: Tensor,
+    old_denoised: Tensor | None,
+    old_denoised_derivative: Tensor | None,
+    times: Tensor,
+    er_lambdas: Tensor,
+    index: int,
+    nodes: Tensor,
+    weights: Tensor,
+    generator: torch.Generator,
+    noise_multiplier: float,
+) -> tuple[Tensor, Tensor | None]:
+    """Apply one nonterminal third-stage ER-SDE update."""
+
+    er_lambda_s = er_lambdas[index]
+    er_lambda_t = er_lambdas[index + 1]
+    alpha_s = times[index] / er_lambda_s
+    alpha_t = times[index + 1] / er_lambda_t
+    ratio = _er_noise_scaler(er_lambda_t) / _er_noise_scaler(er_lambda_s)
+    next_state = (alpha_t / alpha_s) * ratio * state
+    next_state = next_state + alpha_t * (1.0 - ratio) * denoised
+
+    denoised_derivative: Tensor | None = None
+    stage = min(3, int(index) + 1)
+    if stage >= 2:
+        if old_denoised is None:
+            raise RuntimeError("ER-SDE stage 2 requires denoised history.")
+        second, third = _er_quadrature_terms(
+            er_lambda_s,
+            er_lambda_t,
+            nodes,
+            weights,
+        )
+        delta = er_lambda_t - er_lambda_s
+        previous_delta = er_lambda_s - er_lambdas[index - 1]
+        denoised_derivative = (denoised - old_denoised) / previous_delta
+        next_state = (
+            next_state
+            + alpha_t
+            * (delta + second * _er_noise_scaler(er_lambda_t))
+            * denoised_derivative
+        )
+        if stage >= 3:
+            if old_denoised_derivative is None:
+                raise RuntimeError("ER-SDE stage 3 requires derivative history.")
+            derivative_span = (er_lambda_s - er_lambdas[index - 2]) / 2.0
+            second_derivative = (
+                denoised_derivative - old_denoised_derivative
+            ) / derivative_span
+            next_state = (
+                next_state
+                + alpha_t
+                * (delta.square() / 2.0 + third * _er_noise_scaler(er_lambda_t))
+                * second_derivative
+            )
+
+    if float(noise_multiplier) > 0.0:
+        noise = torch.randn(
+            state.shape,
+            device=state.device,
+            dtype=torch.float32,
+            generator=generator,
+        )
+        variance = er_lambda_t.square() - er_lambda_s.square() * ratio.square()
+        stochastic_scale = alpha_t * torch.sqrt(torch.clamp(variance, min=0.0))
+        next_state = next_state + float(noise_multiplier) * stochastic_scale * noise
+    return next_state.float(), denoised_derivative
+
+
+def _er_sde(
+    velocity: VelocityFunction,
+    state: Tensor,
+    schedule: Tensor,
+    *,
+    generator: torch.Generator,
+    noise_multiplier: float,
+    progress: SolverProgress,
+) -> Tensor:
+    """Integrate with third-stage VP ER-SDE and Gauss-Legendre quadrature."""
+
+    times = _prepare_logsnr_schedule(schedule, solver_name="ER-SDE")
+    half_log_snr = torch.log1p(-times.float()) - torch.log(times.float())
+    er_lambdas = torch.exp(-half_log_snr)
+    nodes, weights = _er_quadrature_rule(device=state.device)
+    old_denoised: Tensor | None = None
+    old_denoised_derivative: Tensor | None = None
+    batch = int(state.shape[0])
+    intervals = int(times.numel()) - 1
+    for index in range(intervals):
+        current_time = times[index]
+        predicted = velocity(
+            state,
+            _time_batch(current_time, batch, state.device),
+            index,
+        ).float()
+        denoised = state - current_time * predicted
+        if float(times[index + 1].item()) == 0.0:
+            state = denoised
+        else:
+            state, old_denoised_derivative = _er_sde_step(
+                state=state,
+                denoised=denoised,
+                old_denoised=old_denoised,
+                old_denoised_derivative=old_denoised_derivative,
+                times=times,
+                er_lambdas=er_lambdas,
+                index=index,
+                nodes=nodes,
+                weights=weights,
+                generator=generator,
+                noise_multiplier=float(noise_multiplier),
+            )
+        old_denoised = denoised
+        progress(index + 1, intervals)
+    return state
+
+
 def _ab2_predict(
     state: Tensor,
     current_step: Tensor,
@@ -316,6 +462,7 @@ def solve(
     solver: Solver,
     generator: torch.Generator,
     euler_maruyama_multiplier: float,
+    er_sde_noise_multiplier: float = 1.0,
     progress: SolverProgress | None = None,
 ) -> Tensor:
     """Integrate Canter velocity predictions over one validated schedule."""
@@ -323,9 +470,12 @@ def solve(
     _validate_inputs(initial_state, schedule)
     if not isinstance(solver, Solver):
         raise TypeError("solver must be a Solver.")
-    multiplier = float(euler_maruyama_multiplier)
-    if not math.isfinite(multiplier) or multiplier < 0.0:
+    em_multiplier = float(euler_maruyama_multiplier)
+    if not math.isfinite(em_multiplier) or em_multiplier < 0.0:
         raise ValueError("euler_maruyama_multiplier must be finite and non-negative.")
+    er_multiplier = float(er_sde_noise_multiplier)
+    if not math.isfinite(er_multiplier) or er_multiplier < 0.0:
+        raise ValueError("er_sde_noise_multiplier must be finite and non-negative.")
     resolved_progress = _ignore_progress if progress is None else progress
     match solver:
         case Solver.EULER:
@@ -336,7 +486,16 @@ def solve(
                 initial_state,
                 schedule,
                 generator=generator,
-                multiplier=multiplier,
+                multiplier=em_multiplier,
+                progress=resolved_progress,
+            )
+        case Solver.ER_SDE:
+            return _er_sde(
+                velocity,
+                initial_state,
+                schedule,
+                generator=generator,
+                noise_multiplier=er_multiplier,
                 progress=resolved_progress,
             )
         case Solver.DPMPP_2M:

canter/version.py

@@ -0,0 +1,4 @@
+"""Single source of truth for the installable Canter code version."""
+
+__version__ = "0.2.0"
+CANTER_VERSION = __version__

canter/webui.py

@@ -59,6 +59,7 @@ _TEXT_BACKENDS = {value.value: value for value in TextAttentionBackend}
 _SOLVER_CHOICES = (
     ("ABM2", Solver.ABM2.value),
     ("DPM++ 2M", Solver.DPMPP_2M.value),
+    ("ER-SDE", Solver.ER_SDE.value),
     ("Euler", Solver.EULER.value),
     ("Euler-Maruyama", Solver.EULER_MARUYAMA.value),
 )
@@ -1048,7 +1049,11 @@ def build_web_request(
         ),
         euler_maruyama_multiplier=_number(
             euler_maruyama_multiplier,
-            "Euler-Maruyama multiplier",
+            "SDE noise multiplier",
+        ),
+        er_sde_noise_multiplier=_number(
+            euler_maruyama_multiplier,
+            "SDE noise multiplier",
         ),
         seed=resolved_seed,
         generator=None,
@@ -1130,6 +1135,8 @@ def _png_metadata_json(
         "self_attention_gain": inference.self_attention_gain,
         "log_snr_shift": inference.log_snr_shift,
         "euler_maruyama_multiplier": inference.euler_maruyama_multiplier,
+        "er_sde_noise_multiplier": inference.er_sde_noise_multiplier,
+        "code_version": metadata.code_version,
         "release": metadata.canter.release,
         "weight_dtype": metadata.canter.weight_dtype.value,
     }
@@ -1164,7 +1171,9 @@ def _model_summary(metadata: CanterPipelineMetadata) -> str:
 
     canter = metadata.canter
     return (
-        f"**Canter {canter.release}** · {canter.weight_dtype.value} EMA weights  \n"
+        f"**Canter checkpoint {canter.release}** · "
+        f"code `{metadata.code_version}` · "
+        f"{canter.weight_dtype.value} EMA weights  \n"
         f"VAE `{metadata.vae_repository}` @ `{metadata.vae_revision[:12]}`"
     )
 
@@ -1238,7 +1247,8 @@ def _generation_status(
         f"{inference.width}×{inference.height} · "
         f"{inference.steps} {inference.solver.value} updates · "
         f"{_pdg_status(inference)} · "
-        f"Canter `{metadata.canter.release}`"
+        f"Canter code `{metadata.code_version}` · "
+        f"checkpoint `{metadata.canter.release}`"
     )
 
 
@@ -1363,7 +1373,7 @@ def _solver_inputs() -> tuple[
         maximum=2.0,
         value=_DEFAULT_INFERENCE.euler_maruyama_multiplier,
         step=0.05,
-        label="Euler-Maruyama noise",
+        label="SDE noise multiplier",
     )
     return (
         steps,
@@ -1794,7 +1804,10 @@ def _argument_parser() -> argparse.ArgumentParser:
         description="Launch the bundled Canter Gradio inference application.",
     )
     parser.add_argument("--model", default=_DEFAULT_MODEL)
-    parser.add_argument("--revision")
+    parser.add_argument(
+        "--revision",
+        help="Checkpoint branch, commit, or immutable tag such as v0001.",
+    )
     parser.add_argument(
         "--dtype",
         choices=tuple(_WEIGHT_DTYPES),

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "canter"
-version = "0.1.0"
+dynamic = ["version"]
 description = "Lean inference package for the Canter text-to-image flow model"
 readme = "README.md"
 requires-python = ">=3.10,<3.14"
@@ -31,3 +31,6 @@ test = [
 
 [tool.hatch.build.targets.wheel]
 packages = ["canter"]
+
+[tool.hatch.version]
+path = "canter/version.py"