scrollkit 0.8.4__tar.gz → 0.8.5__tar.gz

{scrollkit-0.8.4/src/scrollkit.egg-info → scrollkit-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrollkit
-Version: 0.8.4
+Version: 0.8.5
 Summary: LED Matrix Display Framework for CircuitPython and Desktop
 Author-email: Michael Czeiszperger <michael@czei.org>
 License: MIT
@@ -228,7 +228,6 @@ if is_dev_mode():
 | Platform | Backend | Status |
 |---|---|---|
 | Adafruit MatrixPortal S3 | CircuitPython + displayio | ✅ Calibrated from device |
-| Pimoroni Interstate 75 W (RP2350) | CircuitPython + rgbmatrix | ✅ Supported (perf profile uncalibrated) |
 | Desktop (macOS/Linux/Windows) | SLDK Simulator | ✅ |
 | Custom CircuitPython boards | displayio / rgbmatrix | 🔌 Extensible (see [Adding New Hardware](https://scrollkit.dev/guide/hardware/)) |
 

{scrollkit-0.8.4 → scrollkit-0.8.5}/README.md

@@ -184,7 +184,6 @@ if is_dev_mode():
 | Platform | Backend | Status |
 |---|---|---|
 | Adafruit MatrixPortal S3 | CircuitPython + displayio | ✅ Calibrated from device |
-| Pimoroni Interstate 75 W (RP2350) | CircuitPython + rgbmatrix | ✅ Supported (perf profile uncalibrated) |
 | Desktop (macOS/Linux/Windows) | SLDK Simulator | ✅ |
 | Custom CircuitPython boards | displayio / rgbmatrix | 🔌 Extensible (see [Adding New Hardware](https://scrollkit.dev/guide/hardware/)) |
 
@@ -208,4 +207,4 @@ of his code — but the idea came from his project, and it deserves the shout-ou
 
 ## License
 
-MIT
+MIT

{scrollkit-0.8.4 → scrollkit-0.8.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scrollkit"
-version = "0.8.4"
+version = "0.8.5"
 description = "LED Matrix Display Framework for CircuitPython and Desktop"
 readme = "README.md"
 requires-python = ">=3.8"

{scrollkit-0.8.4 → scrollkit-0.8.5}/src/scrollkit/__init__.py

@@ -13,4 +13,4 @@ need from submodules, e.g.::
     from scrollkit.display.unified import UnifiedDisplay
 """
 
-__version__ = "0.8.4"
+__version__ = "0.8.5"

{scrollkit-0.8.4 → scrollkit-0.8.5}/src/scrollkit/display/_graphics.py

@@ -120,6 +120,32 @@ class GraphicsMixin:
                 lg.pop(i)
                 return
 
+    def clear_layers(self):
+        """Strip EVERY persistent layer — the takeover blank.
+
+        ``clear()`` deliberately leaves ``_layer_group`` alone (per-frame label
+        reset must not disturb long-lived effect layers), so a full-screen
+        takeover message needs this instead: without it, an interrupted ride
+        screen's bitmap layers stay composited and the takeover text paints ON
+        TOP of them (the "Updating — DO NOT UNPLUG over the ride list" bug,
+        2026-07-12). Content objects whose layers vanish are unaffected later:
+        ``remove_layer`` is idempotent.
+
+        The bounded painter's canvas lives in ``_layer_group`` too, so its refs
+        are reset here — ``_ensure_paint`` rebuilds a composited canvas on the
+        next ``set_pixel``/``fill_rect`` (stale refs would silently draw into a
+        bitmap no longer in the displayio tree).
+        """
+        lg = getattr(self, "_layer_group", None)
+        if lg is None:
+            return
+        while len(lg):
+            lg.pop()
+        self._paint_bitmap = None
+        self._paint_palette = None
+        self._paint_tile = None
+        self._paint_colors = {}
+
     # --- bounded painters -----------------------------------------------------
     def _ensure_paint(self):
         if self._paint_bitmap is not None:

{scrollkit-0.8.4 → scrollkit-0.8.5}/src/scrollkit/effects/image_animators.py

@@ -579,7 +579,9 @@ class RegionRotateAnimator(IntroAnimator):
                 ci = bitmap[x, y]
                 if ci != 0 and not self._in_excl(x, y):    # body pixels stay put
                     src[(x, y)] = ci
-                    r = math.hypot(x - self._px, y - self._py)
+                    dx = x - self._px
+                    dy = y - self._py
+                    r = math.sqrt(dx * dx + dy * dy)   # math.hypot is absent on CircuitPython
                     if r > maxr:
                         maxr = r
         if not src or len(src) > 320:
@@ -598,16 +600,18 @@ class RegionRotateAnimator(IntroAnimator):
         self._hidden = False
 
     def _stamp(self, ang):
-        bmp = self.bitmap
-        for x, y in self._stamped:               # erase only what we last drew
-            bmp[x, y] = 0
         # forward is dest = R(ang)*(p-pivot)+pivot, so the pre-image of a dest pixel is
         # src = R(-ang)*(dest-pivot)+pivot.  R(-ang) = [[cos, sin], [-sin, cos]].
+        # Compute the whole new pose FIRST (no bitmap writes), then apply it as a
+        # DIFF against the previous pose. The device panel refreshes continuously
+        # from the bitmap, so the old erase-everything-then-slowly-redraw left a
+        # visible "head blinks out" window on every restamp (the desktop simulator
+        # only presents between steps, which is why it never showed there).
         ca = math.cos(ang)
         sa = math.sin(ang)
         px, py = self._px, self._py
         src = self._src
-        stamped = []
+        new = {}
         excl = self._excl
         for Y in range(self._sy0, self._sy1 + 1):
             dY = Y - py
@@ -619,9 +623,15 @@ class RegionRotateAnimator(IntroAnimator):
                 sy = int(round(py - dX * sa + dY * ca))
                 ci = src.get((sx, sy))
                 if ci:
-                    bmp[X, Y] = ci
-                    stamped.append((X, Y))
-        self._stamped = stamped
+                    new[(X, Y)] = ci
+        bmp = self.bitmap
+        for xy in self._stamped:                 # erase only pixels LEAVING the pose
+            if xy not in new:
+                bmp[xy[0], xy[1]] = 0
+        for xy, ci in new.items():               # write only pixels that changed
+            if bmp[xy[0], xy[1]] != ci:
+                bmp[xy[0], xy[1]] = ci
+        self._stamped = list(new)
         self._last_ang = ang
         self._hidden = False
 
@@ -1074,14 +1084,36 @@ class CelWalkAnimator(IntroAnimator):
     HOLD_FRAMES = 104            # a full off-screen-to-off-screen crossing plus several strides
 
     def __init__(self, sheet_suffix="_walk", period=6, bob=0, path="traverse_lr",
-                 tile_w=None, tile_h=None):
+                 tile_w=None, tile_h=None, head_box=None, head_pivot=None,
+                 head_amp_deg=0, head_period=None, head_steps=5):
+        """Create an authored cel walk, optionally with a procedurally nodding head.
+
+        ``head_box`` is an inclusive ``(x0, y0, x1, y1)`` box in each cel and
+        ``head_pivot`` is the fixed neck joint.  When both are supplied with a
+        non-zero ``head_amp_deg``, the head pixels are split from every authored
+        cel and a small set of rotated head poses is baked at :meth:`start`.
+        The walk still costs only tile-index and position writes per displayed
+        frame; the one-time bake avoids rotating pixels on the MatrixPortal.
+
+        The box must include only the head/neck and the transparent space its arc
+        crosses.  The default ``head_period`` is one complete authored gait cycle
+        (``period * number_of_cels``), and ``head_steps`` is the number of baked
+        angles across ``-head_amp_deg`` through ``+head_amp_deg``.
+        """
         self._suffix = sheet_suffix
         self._period = max(1, period)     # display frames per pose (the gait clock)
         self._bob = bob
         self._path = path
         self._tw = tile_w
         self._th = tile_h
+        self._head_box = tuple(head_box) if head_box is not None else None
+        self._head_pivot = tuple(head_pivot) if head_pivot is not None else None
+        self._head_amp = head_amp_deg * 0.017453292519943295
+        self._head_period = head_period
+        steps = max(3, head_steps)
+        self._head_steps = steps if steps & 1 else steps + 1
         self._tile = None
+        self._head_tile = None
         self._odb = None
 
     def _sheet_path(self):
@@ -1108,17 +1140,98 @@ class CelWalkAnimator(IntroAnimator):
         n = sheet.width // tw
         if n < 1:
             raise ValueError("cel_walk: sheet narrower than one tile")
-        gtile = display.gfx.TileGrid(sheet, pixel_shader=pal, tile_width=tw, tile_height=th)
+        head_enabled = self._head_box is not None or self._head_pivot is not None
+        if head_enabled:
+            if self._head_box is None or self._head_pivot is None or not self._head_amp:
+                raise ValueError("cel_walk: head rotation needs box, pivot, and non-zero amplitude")
+            sheet, head_sheet = self._bake_head_poses(display.gfx, self._sheet_path(),
+                                                       n, tw, th, len(pal))
+            gtile = display.gfx.TileGrid(sheet, pixel_shader=pal,
+                                         tile_width=tw, tile_height=th)
+            head_tile = display.gfx.TileGrid(head_sheet, pixel_shader=pal,
+                                              tile_width=tw, tile_height=th)
+        else:
+            gtile = display.gfx.TileGrid(sheet, pixel_shader=pal, tile_width=tw, tile_height=th)
+            head_tile = None
         # Commit: blank the static base sprite, then composite the walking strip above it.
         self._odb = odb
         self._tile = gtile
+        self._head_tile = head_tile
         self._n = n
         self._apply(0)
         bitmap.fill(0)
         display.add_layer(self._tile)
+        if self._head_tile is not None:
+            display.add_layer(self._head_tile)
+
+    def _bake_head_poses(self, gfx, sheet_path, n, tw, th, ncolors):
+        """Return a headless cel sheet plus a sheet of pre-rotated head poses.
+
+        A sheet read from ``OnDiskBitmap`` cannot be inspected or changed on
+        CircuitPython.  Decode it once only when this opt-in feature is used;
+        the base sheet retains the authored body/leg poses while the sparse head
+        sheet supplies ``n * head_steps`` rotated alternatives.
+        """
+        x0, y0, x1, y1 = self._head_box
+        px, py = self._head_pivot
+        if x0 < 0 or y0 < 0 or x1 < x0 or y1 < y0 or x1 >= tw or y1 >= th:
+            raise ValueError("cel_walk: head box outside a cel")
+        if not (0 <= px < tw and 0 <= py < th):
+            raise ValueError("cel_walk: head pivot outside a cel")
+
+        base = read_indexed_bmp(gfx, sheet_path)
+        head_sheet = gfx.Bitmap(tw * n * self._head_steps, th, ncolors)
+        max_radius = 1.0
+        head_pixels = []
+        for pose in range(n):
+            pixels = {}
+            offset = pose * tw
+            for y in range(y0, y1 + 1):
+                for x in range(x0, x1 + 1):
+                    ci = base[offset + x, y]
+                    if ci:
+                        pixels[(x, y)] = ci
+                        base[offset + x, y] = 0
+                        dx, dy = x - px, y - py
+                        radius = math.sqrt(dx * dx + dy * dy)
+                        if radius > max_radius:
+                            max_radius = radius
+            if not pixels:
+                raise ValueError("cel_walk: head box has no pixels in pose %d" % pose)
+            head_pixels.append(pixels)
+
+        margin = int(max_radius * abs(math.sin(self._head_amp))) + 1
+        sx0, sx1 = max(0, x0 - margin), min(tw - 1, x1 + margin)
+        sy0, sy1 = max(0, y0 - margin), min(th - 1, y1 + margin)
+        for pose, pixels in enumerate(head_pixels):
+            for step in range(self._head_steps):
+                # Equally-spaced angles include the upright rest pose because
+                # head_steps is always odd.
+                angle = self._head_amp * ((2.0 * step / (self._head_steps - 1)) - 1.0)
+                ca, sa = math.cos(angle), math.sin(angle)
+                cell_offset = (pose * self._head_steps + step) * tw
+                # Inverse-map the bounded destination rectangle so the rotated
+                # head stays solid instead of developing forward-map holes.
+                for Y in range(sy0, sy1 + 1):
+                    dy = Y - py
+                    for X in range(sx0, sx1 + 1):
+                        dx = X - px
+                        sx = int(round(px + dx * ca + dy * sa))
+                        sy = int(round(py - dx * sa + dy * ca))
+                        ci = pixels.get((sx, sy))
+                        if ci:
+                            head_sheet[cell_offset + X, Y] = ci
+        return base, head_sheet
 
     def _apply(self, frame):
         self._tile[0, 0] = (frame // self._period) % self._n     # gait clock -> which pose
+        head_tile = self._head_tile
+        if head_tile is not None:
+            cycle = self._head_period or (self._period * self._n)
+            amount = (math.sin(6.2832 * frame / float(max(1, cycle))) + 1.0) * 0.5
+            head_step = int(round(amount * (self._head_steps - 1)))
+            pose = (frame // self._period) % self._n
+            head_tile[0, 0] = pose * self._head_steps + head_step
         span = self.HOLD_FRAMES - 1 if self.HOLD_FRAMES > 1 else 1
         t = frame / span
         if t > 1.0:
@@ -1126,13 +1239,23 @@ class CelWalkAnimator(IntroAnimator):
         x0, x1 = ((self._off, -self._off) if self._path == "traverse_rl"
                   else (-self._off, self._off))
         self._tile.x = int(round(x0 + (x1 - x0) * t))
+        if head_tile is not None:
+            head_tile.x = self._tile.x
         if self._bob:
             self._tile.y = int(round(self._bob * math.sin(frame * 0.3)))
+        if head_tile is not None:
+            head_tile.y = self._tile.y
 
     def step(self, frame):
         self._apply(frame)
 
     def detach(self):
+        head = getattr(self, "_head_tile", None)
+        if head is not None and getattr(self, "display", None) is not None:
+            try:
+                self.display.remove_layer(head)
+            except Exception:
+                pass
         t = getattr(self, "_tile", None)
         if t is not None and getattr(self, "display", None) is not None:
             try:
@@ -1143,6 +1266,7 @@ class CelWalkAnimator(IntroAnimator):
         # (CircuitPython has a small open-file limit). No base-restore — the sprite walked off,
         # the base is blank, the fade shows empty sky (matches MotionAnimator traverse).
         self._tile = None
+        self._head_tile = None
         self._odb = None
 
 

{scrollkit-0.8.4 → scrollkit-0.8.5}/src/scrollkit/network/http_client.py

@@ -324,6 +324,28 @@ class HttpClient:
                 # a rebuild doesn't immediately rebuild again (thrash).
                 self._failures_since_rebuild = 0
 
+    def close_pooled_sockets(self):
+        """Properly close every socket the current session's connection manager
+        holds, releasing their NATIVE resources (each pooled TLS socket pins an
+        mbedtls context — ~40 KB of the ESP32-S3's ~320 KB internal SRAM, which
+        PSRAM cannot substitute for). Public so callers needing native headroom
+        for a new TLS handshake (e.g. an OTA check to a second host) can make
+        room through a supported API. The pool stays valid: the manager opens
+        fresh sockets transparently on the next request.
+
+        Returns True if a close-all ran. Never raises."""
+        session = self.session
+        if session is None:
+            return False
+        try:
+            from adafruit_connection_manager import connection_manager_close_all
+            pool = session._connection_manager._socket_pool
+            connection_manager_close_all(socket_pool=pool)
+            return True
+        except Exception as e:
+            _logger().error(e, "close_pooled_sockets failed")
+            return False
+
     def _rebuild_session(self):
         """Tear down and recreate the adafruit_requests session.
 
@@ -332,9 +354,21 @@ class HttpClient:
         failure short of a reboot. Device-only (the imports exist on CircuitPython
         only); a no-op that returns False on desktop, where the urllib path never
         uses a session. Never raises into the caller.
+
+        HYGIENE IS LOAD-BEARING: the old session's pooled sockets must be
+        properly CLOSED before the replacement exists — dropping them to the GC
+        does not promptly release their native mbedtls TLS contexts. With a
+        rebuild threshold of 2, every pair of transient blips on a multi-day run
+        orphaned another ~40 KB of internal SRAM, until TLS handshakes (data
+        path AND the OTA check) died with mbedtls PK_ALLOC_FAILED / MemoryError.
+        Found 2026-07-11 after a ~30 h soak left the field device in
+        'STALE (network issues)'.
         """
         if not (self.using_adafruit and self.session is not None):
             return False
+        # Release the wedged pool's native sockets/TLS contexts first — this is
+        # both the leak fix and what frees room for the replacement context.
+        self.close_pooled_sockets()
         try:
             import socketpool
             import wifi

{scrollkit-0.8.4 → scrollkit-0.8.5}/src/scrollkit/network/wifi_manager.py

@@ -47,21 +47,29 @@ class WiFiManager:
     Manages WiFi connections for the application
     """
     
-    def __init__(self, settings_manager):
+    def __init__(self, settings_manager, ap_name=None):
         """
         Initialize the WiFi manager
-        
+
         Args:
             settings_manager: The settings manager
+            ap_name: Brand name for the setup-portal access point. The SSID a
+                customer sees while onboarding is ``"<ap_name>-<tail>"`` where
+                the tail is a short MAC-derived suffix (kept library-side so two
+                un-onboarded boxes in one home never broadcast identical SSIDs).
+                Apps SHOULD pass their product name — the default is the
+                generic ``WifiManager`` prefix, deliberately not a product name
+                (branding belongs to the app, never hardwired here).
         """
         self.settings_manager = settings_manager
+        self._ap_base = ap_name or "WifiManager"
         self.ssid, self.password = self._resolve_credentials()
         self.is_connected = False
         self.wifi_client = None
         self.ap_enabled = False
 
         # Development mode values
-        self.AP_SSID = "WifiManager_DEV"
+        self.AP_SSID = self._ap_base + "-DEV"
         self.AP_PASSWORD = "password"
 
         try:
@@ -72,10 +80,10 @@ class WiFiManager:
                 self.wifi = None
                 self.HAS_WIFI = False
                 # Set dummy values for development
-                self.AP_SSID = "WifiManager_DEV"
+                self.AP_SSID = self._ap_base + "-DEV"
                 self.AP_PASSWORD = "password"
                 return
-                
+
             # Try to import CircuitPython specific modules
             import wifi
             self.wifi = wifi
@@ -84,7 +92,7 @@ class WiFiManager:
             mac_ap = ' '.join([hex(i) for i in self.wifi.radio.mac_address_ap])
             mac_ap = mac_ap.replace('0x', '').replace(' ', '').upper()
             # access point settings
-            self.AP_SSID = "WifiManager_" + mac_ap[5:10] + mac_ap[1:2]
+            self.AP_SSID = self._ap_base + "-" + mac_ap[5:10] + mac_ap[1:2]
             self.AP_PASSWORD = "password"
             self.AP_AUTHMODES = [self.wifi.AuthMode.WPA2, self.wifi.AuthMode.PSK]
             

{scrollkit-0.8.4 → scrollkit-0.8.5}/src/scrollkit/ota/client.py

@@ -180,6 +180,11 @@ class OTAClient:
         self.update_dir = update_dir
         self.backup_dir = backup_dir
         self.download_timeout = 30
+        # Checks get a much shorter leash than downloads: the check runs inside
+        # a synchronous web handler that freezes the display loop for its whole
+        # duration, so a single stalled read must cost seconds, not the full
+        # 30 s download budget ("the box froze for 30 seconds").
+        self.check_timeout = 8
         self.chunk_size = 1024
         self.session = session
 
@@ -216,7 +221,7 @@ class OTAClient:
         if on_error:
             self.on_update_error = on_error
 
-    def _http_get(self, url: str) -> Any:
+    def _http_get(self, url: str, timeout: Any = None) -> Any:
         """Perform an HTTP GET, preferring an injected Session.
 
         ``self.session`` is read live (never cached) so the app can create or
@@ -224,11 +229,15 @@ class OTAClient:
         right before use. When a session is present, its ``.get`` is used (modern
         ``adafruit_requests`` is Session-based and exposes no module-level
         ``get``); otherwise the module-level ``requests.get`` is used (desktop).
+        ``timeout`` overrides ``download_timeout`` (the check path passes the
+        short ``check_timeout``).
         """
+        if timeout is None:
+            timeout = self.download_timeout
         try:
             if self.session is not None:
-                return self.session.get(url, timeout=self.download_timeout)
-            return requests.get(url, timeout=self.download_timeout)
+                return self.session.get(url, timeout=timeout)
+            return requests.get(url, timeout=timeout)
         except Exception as e:
             # Typed boundary error (no `from e` chaining: heap fragmentation on
             # CircuitPython). The public check/download methods catch it and
@@ -244,17 +253,65 @@ class OTAClient:
         if self.session is None and not requests:
             return False, "Requests library not available"
 
+        # FAST PATH: the channel publishes a ~6-byte version.txt next to the
+        # manifest. Comparing versions needs those bytes, not the ~31 KB / 176-
+        # entry manifest (which the old check fetched, flash-streamed and JSON-
+        # parsed every time — slow, and pure waste when the answer is "up to
+        # date", i.e. almost always). Only a NEWER version proceeds to the full
+        # manifest fetch below (needed then anyway for staging). Any miss —
+        # 404 on an older channel, junk content, transport error — falls
+        # through to the manifest path unchanged.
+        try:
+            v_resp = self._http_get(f"{self.server_url}/version.txt",
+                                    timeout=self.check_timeout)
+            try:
+                if v_resp.status_code == 200:
+                    remote_version = str(v_resp.text).strip()
+                    # Trust ONLY a strict MAJOR.MINOR[.PATCH] shape: parse_version
+                    # maps junk to (0,0,0), so an unvalidated error page would
+                    # compare as "older" and fake an up-to-date answer.
+                    parts = remote_version.split(".")
+                    if 2 <= len(parts) <= 3 and all(p.isdigit() for p in parts):
+                        probe = UpdateManifest(version=remote_version)
+                        if probe.compare_version(self.current_version) <= 0:
+                            return False, UP_TO_DATE
+            finally:
+                try:
+                    v_resp.close()
+                except Exception:
+                    pass
+        except Exception:
+            pass  # fall through to the manifest fetch
+        gc.collect()
+
         try:
             url = f"{self.server_url}/manifest.json"
-            response = self._http_get(url)
+            response = self._http_get(url, timeout=self.check_timeout)
 
             if response.status_code != 200:
                 return False, f"Server error: {response.status_code}"
 
             try:
-                manifest_data = response.json()
+                # Avoid response.json() when the body can be streamed: .json()
+                # needs the whole body as ONE contiguous allocation, and a
+                # ~30 KB manifest routinely exceeds the largest free block on a
+                # hot CircuitPython heap (the intermittent "Check for Update ...
+                # MemoryError"). Stream the body to flash in small chunks, then
+                # json.load the FILE — the parser reads it incrementally, so the
+                # RAM cost is many small allocations instead of one big one.
+                if getattr(response, "iter_content", None) is None:
+                    manifest_data = response.json()   # desktop mocks/shims
+                else:
+                    part_path = f"{self.update_dir}/manifest.part"
+                    self._stream_body_to_file(response, part_path)
+                    gc.collect()
+                    try:
+                        with open(part_path) as f:
+                            manifest_data = json.load(f)
+                    finally:
+                        self._remove(part_path)
                 manifest = UpdateManifest.from_dict(manifest_data)
-            except ValueError as e:  # CircuitPython: json.loads raises ValueError
+            except ValueError as e:  # CircuitPython: json raises ValueError
                 return False, f"Invalid manifest: {e}"
 
             is_valid, error = manifest.validate()
@@ -407,22 +464,23 @@ class OTAClient:
                 raise OTAError("Server error %d for %s"
                                % (response.status_code, file_path))
 
-            content = response.content
+            # Stream to flash while hashing per chunk — response.content would
+            # need the whole file as one contiguous allocation (same hot-heap
+            # MemoryError class as the manifest fetch above). Verify AFTER the
+            # write and delete the staged file on any mismatch, so a bad body
+            # never survives in the staging area.
+            digest = _sha256()
+            local_path = f"{self.update_dir}/{file_path.lstrip('/')}"
+            total = self._stream_body_to_file(response, local_path, digest)
 
-            if len(content) != file_info['size']:
+            if total != file_info['size']:
+                self._remove(local_path)
                 raise OTAError("Size mismatch for %s: %d != %d"
-                               % (file_path, len(content), file_info['size']))
+                               % (file_path, total, file_info['size']))
 
-            digest = _sha256()
-            digest.update(content)
             if _hexdigest(digest) != file_info['checksum']:
+                self._remove(local_path)
                 raise OTAError("Checksum mismatch for %s" % file_path)
-
-            local_path = f"{self.update_dir}/{file_path.lstrip('/')}"
-            self._ensure_directory_for_file(local_path)
-
-            with open(local_path, 'wb') as f:
-                f.write(content)
         finally:
             if response is not None:
                 try:
@@ -776,6 +834,34 @@ class OTAClient:
         """True if this file was downloaded into the staging dir (i.e. changed)."""
         return self._exists(f"{self.update_dir}/{file_path.lstrip('/')}")
 
+    def _stream_body_to_file(self, response, path, digest=None):
+        """Write a response body to ``path`` in small chunks; return the byte count.
+
+        The point is to never hold the whole body in RAM: on a hot CircuitPython
+        heap the largest free block is often smaller than a 30 KB manifest or
+        source file, so ``response.content`` / ``response.json()`` fail with
+        MemoryError while chunked writes sail through. Feeds ``digest`` per
+        chunk when given. Falls back to ``response.content`` when the response
+        has no ``iter_content`` (desktop mocks / simple session shims).
+        """
+        self._ensure_directory_for_file(path)
+        total = 0
+        iter_content = getattr(response, "iter_content", None)
+        with open(path, "wb") as f:
+            if iter_content is None:
+                content = response.content
+                f.write(content)
+                total = len(content)
+                if digest is not None:
+                    digest.update(content)
+            else:
+                for chunk in iter_content(chunk_size=1024):
+                    f.write(chunk)
+                    total += len(chunk)
+                    if digest is not None:
+                        digest.update(chunk)
+        return total
+
     def _remove_mpy_sibling(self, file_path):
         """Delete a same-basename ``.mpy`` before writing a ``.py`` under /lib.
 

{scrollkit-0.8.4 → scrollkit-0.8.5}/src/scrollkit/ota/display_progress.py

@@ -137,6 +137,12 @@ class OTAProgressDisplay:
         if isinstance(lines, str):
             lines = [lines]
         try:
+            # Takeover: strip the interrupted content's persistent bitmap layers
+            # (intro tiles, wait-number compositions, effect overlays) — clear()
+            # alone leaves them composited and this message paints OVER them.
+            clear_layers = getattr(self.display, "clear_layers", None)
+            if clear_layers is not None:
+                clear_layers()
             await self.display.clear()
             line_h = 9                      # ~8px glyphs + 1px gap
             height = getattr(self.display, "height", 32)

{scrollkit-0.8.4 → scrollkit-0.8.5}/src/scrollkit/web/wifi_setup.py

@@ -7,7 +7,8 @@ architecture, not a revert). The flow:
 1. The device can't join Wi-Fi (no/wrong credentials), so the app calls
    ``WiFiManager.run_setup_portal(display=...)`` — usually right after a
    failed ``connect()``.
-2. The device starts its own access point (``WifiManager_XXXX``) and shows
+2. The device starts its own access point (named by the app via
+   ``WiFiManager(ap_name=...)``, e.g. ``ThemeParkWaits-XXXX``) and shows
    join instructions on the LED panel.
 3. The user's phone joins that AP and opens ``http://192.168.4.1``: a page
    with the scanned nearby networks (signal bars), a manual-SSID field, and

{scrollkit-0.8.4 → scrollkit-0.8.5/src/scrollkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrollkit
-Version: 0.8.4
+Version: 0.8.5
 Summary: LED Matrix Display Framework for CircuitPython and Desktop
 Author-email: Michael Czeiszperger <michael@czei.org>
 License: MIT
@@ -228,7 +228,6 @@ if is_dev_mode():
 | Platform | Backend | Status |
 |---|---|---|
 | Adafruit MatrixPortal S3 | CircuitPython + displayio | ✅ Calibrated from device |
-| Pimoroni Interstate 75 W (RP2350) | CircuitPython + rgbmatrix | ✅ Supported (perf profile uncalibrated) |
 | Desktop (macOS/Linux/Windows) | SLDK Simulator | ✅ |
 | Custom CircuitPython boards | displayio / rgbmatrix | 🔌 Extensible (see [Adding New Hardware](https://scrollkit.dev/guide/hardware/)) |