FL MiniMax H3 Neural Latent Upscale 2D

Here's the H3 problem this node solves. MiniMax H3 generates at a fixed native canvas, and "I want it bigger" usually means decoding the video latent to pixels, resizing, re-encoding, and hoping the second encode doesn't smear what you just gained - a VAE round trip that's slow, VRAM-hungry, and does nothing to recover detail the base render never had. FL MiniMax H3 Neural Latent Upscale 2D is the alternative: a learned upscaler that operates directly on the 24-channel video latent, in latent space, no decode in sight.

If that reminds you of the classic image-model "latent upscale then low-denoise pass" trick, you're exactly right - this is that idea rebuilt for H3's weird nested video/audio latent. The pack's own Latent Upscale node does the dumb-but-cheap version of this (bilinear-style interpolation that just stretches pixels-in-latent). This one runs a real trained model instead. The checkpoint was trained to reproduce H3's per-channel latent statistics and reconstruct the detail that interpolation can't invent, which is the difference between "soft 2x" and "2x with believable texture."

Mechanically, here's what happens under the hood. Your H3 latent isn't a flat tensor - it's a nested thing carrying a video tensor shaped [1, 24, T, H, W] and a separate audio latent [1, 32, 2, ...]. This node only ever touches the video half. It normalizes those 24 channels using H3's own model-native mean/std (the same stats ComfyUI's H3 VAE uses), runs them through the learned resizer, then denormalizes back. Temporal length is untouched. Audio is passed through byte-for-byte. The noise_mask metadata gets resized to match so downstream sampling still knows what's protected.

Inputs are mercifully few:

• upscale_model - from FL MiniMax H3 Load Latent Upscaler. Must be a 2D checkpoint; feed it a 3D one and it refuses.
• latent - the native nested H3 latent out of the pack's Prompt Timeline or Beat Shot Planner. It won't accept a flattened or non-H3 latent.
• scale - 1.0× to 4.0×, default 2.0. Applied to both spatial axes, so 2x means roughly 4x the pixels and roughly 4x the video tokens for any downstream pass.

Output is one latent: still nested, still H3-native, just spatially bigger. That's the whole promise - the result can keep flowing through H3-aware nodes that would choke on a flat tensor.

What do you do with it? Two honest options. Decode it straight to pixels and you've got a fast, clean enlargement - but remember, this is the fast spatial path, so it's not doing heavy temporal reasoning between frames. If you want the upscaled size to also gain quality, wire the output through the pack's Apply Timeline node (which rebuilds your prompt conditioning at the new spatial dimensions) into a low-denoise refinement sampler pass. That's the workflow the pack's README pushes: base render → latent upscale → Apply Timeline → low-denoise KSampler → decode.

Where people get burned, in order:

1. Pairing it with the wrong checkpoint. The loader detects architecture; this node hard-requires a 2D one. Mismatched = clear error, not silent weirdness.
2. Expecting the upscale to add detail by itself. The learned model recovers detail, but a subsequent hi-res refinement pass is still what sharpens it, and that pass runs at hi-res VRAM. A 2x upscale is ~4x the tokens - your memory budget is the real constraint, not the node.
3. Feeding it a temporal reshot latent. The pack explicitly blocks latents tied to an in-progress reshot here, because the reshot's source mask is bound to its original canvas. Reshot first, upscale the finished result.

One more context note: this pack is the H3 work from filliptm's ComfyUI Fill Nodes, migrated out into its own pack at v1.2.0. Install it via ComfyUI Manager (search FL MiniMax H3) or git clone https://github.com/filliptm/ComfyUI-FL-MiniMaxH3.git into custom_nodes and restart - and if you run an older Fill Nodes that still registers these node IDs, update that first so you don't get duplicate-registration errors.