shrinkray 25.12.26.2__py3-none-any.whl → 25.12.27.1__py3-none-any.whl

shrinkray/__main__.py

@@ -75,12 +75,14 @@ async def run_shrink_ray(
 )
 @click.option(
     "--timeout",
-    default=1,
+    default=None,
     type=click.FLOAT,
     help=(
-        "Time out subprocesses after this many seconds. If set to <= 0 then "
-        "no timeout will be used. Any commands that time out will be treated "
-        "as failing the test"
+        "Time out subprocesses after this many seconds. If not specified, "
+        "runs the interestingness test once and sets timeout to 10x the "
+        "measured time (capped at 5 minutes). If set to <= 0 then no timeout "
+        "will be used. Any commands that time out will be treated as failing "
+        "the test"
     ),
 )
 @click.option(
@@ -212,7 +214,7 @@ def main(
     backup: str,
     filename: str,
     test: list[str],
-    timeout: float,
+    timeout: float | None,
     in_place: bool,
     parallelism: int,
     seed: int,
@@ -225,7 +227,7 @@ def main(
     ui_type: UIType,
     theme: str,
 ) -> None:
-    if timeout <= 0:
+    if timeout is not None and timeout <= 0:
         timeout = float("inf")
 
     if not os.access(test[0], os.X_OK):
@@ -271,20 +273,20 @@ def main(
     if not backup:
         backup = filename + os.extsep + "bak"
 
-    state_kwargs: dict[str, Any] = dict(
-        input_type=input_type,
-        in_place=in_place,
-        test=test,
-        timeout=timeout,
-        base=os.path.basename(filename),
-        parallelism=parallelism,
-        filename=filename,
-        formatter=formatter,
-        trivial_is_error=trivial_is_error,
-        seed=seed,
-        volume=volume,
-        clang_delta_executable=clang_delta_executable,
-    )
+    state_kwargs: dict[str, Any] = {
+        "input_type": input_type,
+        "in_place": in_place,
+        "test": test,
+        "timeout": timeout,
+        "base": os.path.basename(filename),
+        "parallelism": parallelism,
+        "filename": filename,
+        "formatter": formatter,
+        "trivial_is_error": trivial_is_error,
+        "seed": seed,
+        "volume": volume,
+        "clang_delta_executable": clang_delta_executable,
+    }
 
     state: ShrinkRayState[Any]
     ui: ShrinkRayUI[Any]

shrinkray/passes/sat.py

@@ -165,14 +165,14 @@ async def renumber_variables(problem: ReductionProblem[SAT]) -> None:
         result: SAT = []
         for clause in sat:
             new_clause: Clause = sorted(
-                set(
-                    [
+                {
+                    (
                         (renumbering[lit] if lit > 0 else -renumbering[-lit])
                         if abs(lit) in renumbering
                         else lit
-                        for lit in clause
-                    ]
-                )
+                    )
+                    for lit in clause
+                }
             )
             if len(set(map(abs, new_clause))) == len(new_clause):
                 result.append(new_clause)
@@ -290,7 +290,7 @@ class BooleanEquivalence(UnionFind[int]):
 
     def find(self, value: int) -> int:
         if not value:
-            raise ValueError("Invalid variable %r" % (value,))
+            raise ValueError(f"Invalid variable {value!r}")
         return super().find(value)
 
     def merge(self, left: int, right: int) -> None:

shrinkray/reducer.py

@@ -59,7 +59,9 @@ class Reducer[T](ABC):
     # Optional pass statistics tracking (implemented by ShrinkRay)
     pass_stats: "PassStatsTracker | None" = attrs.field(default=None, init=False)
     # Optional current pass tracking (implemented by ShrinkRay)
-    current_reduction_pass: "ReductionPass[T] | None" = attrs.field(default=None, init=False)
+    current_reduction_pass: "ReductionPass[T] | None" = attrs.field(
+        default=None, init=False
+    )
 
     @contextmanager
     def backtrack(self, restart: T) -> Generator[None, None, None]:
@@ -192,7 +194,9 @@ class ShrinkRay(Reducer[bytes]):
     # Pass control: disabled passes and skip functionality
     disabled_passes: set[str] = attrs.Factory(set)
     _skip_requested: bool = attrs.field(default=False, init=False)
-    _current_pass_scope: "trio.CancelScope | None" = attrs.field(default=None, init=False)
+    _current_pass_scope: "trio.CancelScope | None" = attrs.field(
+        default=None, init=False
+    )
     _passes_were_skipped: bool = attrs.field(default=False, init=False)
 
     def disable_pass(self, pass_name: str) -> None:

shrinkray/state.py

@@ -36,13 +36,32 @@ class TimeoutExceededOnInitial(InvalidInitialExample):
         )
 
 
+# Constants for dynamic timeout
+DYNAMIC_TIMEOUT_CALIBRATION_TIMEOUT = 300.0  # 5 minutes for first call
+DYNAMIC_TIMEOUT_MULTIPLIER = 10
+DYNAMIC_TIMEOUT_MAX = 300.0  # 5 minutes maximum
+DYNAMIC_TIMEOUT_MIN = 1.0  # 1 second minimum to prevent edge cases
+
+
+def compute_dynamic_timeout(runtime: float) -> float:
+    """Compute dynamic timeout based on measured runtime.
+
+    The timeout is set to 10x the measured runtime, clamped between
+    DYNAMIC_TIMEOUT_MIN and DYNAMIC_TIMEOUT_MAX.
+    """
+    return max(
+        DYNAMIC_TIMEOUT_MIN,
+        min(runtime * DYNAMIC_TIMEOUT_MULTIPLIER, DYNAMIC_TIMEOUT_MAX),
+    )
+
+
 @define(slots=False)
 class ShrinkRayState[TestCase](ABC):
     input_type: Any  # InputType from __main__
     in_place: bool
     test: list[str]
     filename: str
-    timeout: float
+    timeout: float | None
     base: str
     parallelism: int
     initial: TestCase
@@ -105,12 +124,12 @@ class ShrinkRayState[TestCase](ABC):
         else:
             command = self.test
 
-        kwargs: dict[str, Any] = dict(
-            universal_newlines=False,
-            preexec_fn=os.setsid,
-            cwd=cwd,
-            check=False,
-        )
+        kwargs: dict[str, Any] = {
+            "universal_newlines": False,
+            "preexec_fn": os.setsid,
+            "cwd": cwd,
+            "check": False,
+        }
         if self.input_type.enabled(self._InputType.stdin) and not os.path.isdir(
             working
         ):
@@ -127,7 +146,8 @@ class ShrinkRayState[TestCase](ABC):
             completed = await trio.run_process(command, **kwargs)
             runtime = time.time() - start_time
 
-            if runtime >= self.timeout and self.first_call:
+            # Check for timeout violation (only when timeout is explicitly set)
+            if self.timeout is not None and runtime >= self.timeout and self.first_call:
                 self.initial_exit_code = completed.returncode
                 self.first_call = False
                 raise TimeoutExceededOnInitial(
@@ -137,6 +157,9 @@ class ShrinkRayState[TestCase](ABC):
 
             if self.first_call:
                 self.initial_exit_code = completed.returncode
+                # Set dynamic timeout if not explicitly specified
+                if self.timeout is None:
+                    self.timeout = compute_dynamic_timeout(runtime)
             self.first_call = False
 
             # Store captured output
@@ -168,9 +191,19 @@ class ShrinkRayState[TestCase](ABC):
             sp = await nursery.start(call_with_kwargs)
 
             try:
-                with trio.move_on_after(
-                    self.timeout * 10 if self.first_call else self.timeout
-                ):
+                # Determine effective timeout for this call
+                if self.first_call:
+                    # For first call: use calibration timeout if dynamic, otherwise 10x explicit timeout
+                    if self.timeout is None:
+                        effective_timeout = DYNAMIC_TIMEOUT_CALIBRATION_TIMEOUT
+                    else:
+                        effective_timeout = self.timeout * 10
+                else:
+                    # For subsequent calls, timeout must be set (either explicit or computed)
+                    assert self.timeout is not None
+                    effective_timeout = self.timeout
+
+                with trio.move_on_after(effective_timeout):
                     await sp.wait()
 
                 runtime = time.time() - start_time
@@ -179,7 +212,12 @@ class ShrinkRayState[TestCase](ABC):
                     # Process didn't terminate before timeout - kill it
                     await self._interrupt_wait_and_kill(sp)
 
-                if runtime >= self.timeout and self.first_call:
+                # Check for timeout violation (only when timeout is explicitly set)
+                if (
+                    self.timeout is not None
+                    and runtime >= self.timeout
+                    and self.first_call
+                ):
                     raise TimeoutExceededOnInitial(
                         timeout=self.timeout,
                         runtime=runtime,
@@ -187,6 +225,10 @@ class ShrinkRayState[TestCase](ABC):
             finally:
                 if self.first_call:
                     self.initial_exit_code = sp.returncode
+                    # Set dynamic timeout if not explicitly specified
+                    if self.timeout is None:
+                        runtime = time.time() - start_time
+                        self.timeout = compute_dynamic_timeout(runtime)
                 self.first_call = False
 
             result: int | None = sp.returncode
@@ -562,10 +604,10 @@ class ShrinkRayDirectoryState(ShrinkRayState[dict[str, bytes]]):
                 sorted((k, shortlex(v)) for k, v in test_case.items()),
             )
 
-        return dict(
-            sort_key=dict_sort_key,
-            size=dict_size,
-        )
+        return {
+            "sort_key": dict_sort_key,
+            "size": dict_size,
+        }
 
     def new_reducer(
         self, problem: ReductionProblem[dict[str, bytes]]

shrinkray/subprocess/client.py

@@ -4,7 +4,7 @@ import asyncio
 import sys
 import traceback
 import uuid
-from collections.abc import AsyncIterator
+from collections.abc import AsyncGenerator
 from typing import Any
 
 from shrinkray.subprocess.protocol import (
@@ -127,7 +127,7 @@ class SubprocessClient:
         file_path: str,
         test: list[str],
         parallelism: int | None = None,
-        timeout: float = 1.0,
+        timeout: float | None = None,
         seed: int = 0,
         input_type: str = "all",
         in_place: bool = False,
@@ -138,10 +138,9 @@ class SubprocessClient:
         trivial_is_error: bool = True,
     ) -> Response:
         """Start the reduction process."""
-        params = {
+        params: dict[str, Any] = {
             "file_path": file_path,
             "test": test,
-            "timeout": timeout,
             "seed": seed,
             "input_type": input_type,
             "in_place": in_place,
@@ -153,6 +152,8 @@ class SubprocessClient:
         }
         if parallelism is not None:
             params["parallelism"] = parallelism
+        if timeout is not None:
+            params["timeout"] = timeout
         return await self.send_command("start", params)
 
     async def get_status(self) -> Response:
@@ -200,7 +201,7 @@ class SubprocessClient:
             traceback.print_exc()
             return Response(id="", error="Failed to skip pass")
 
-    async def get_progress_updates(self) -> AsyncIterator[ProgressUpdate]:
+    async def get_progress_updates(self) -> AsyncGenerator[ProgressUpdate, None]:
         """Yield progress updates as they arrive."""
         while not self._completed:
             try:

shrinkray/subprocess/worker.py

@@ -4,6 +4,7 @@ import os
 import sys
 import time
 import traceback
+from contextlib import aclosing
 from typing import Any, Protocol
 
 import trio
@@ -25,6 +26,7 @@ class InputStream(Protocol):
 
     def __aiter__(self) -> "InputStream": ...
     async def __anext__(self) -> bytes | bytearray: ...
+    async def aclose(self) -> None: ...
 
 
 class OutputStream(Protocol):
@@ -88,12 +90,13 @@ class ReducerWorker:
             stream = trio.lowlevel.FdStream(os.dup(sys.stdin.fileno()))
 
         buffer = b""
-        async for chunk in stream:
-            buffer += chunk
-            while b"\n" in buffer:
-                line, buffer = buffer.split(b"\n", 1)
-                if line:
-                    await self.handle_line(line.decode("utf-8"))
+        async with aclosing(stream) as aiter:
+            async for chunk in aiter:
+                buffer += chunk
+                while b"\n" in buffer:
+                    line, buffer = buffer.split(b"\n", 1)
+                    if line:
+                        await self.handle_line(line.decode("utf-8"))
 
     async def handle_line(self, line: str) -> None:
         """Handle a single command line."""
@@ -124,7 +127,9 @@ class ReducerWorker:
             case "skip_pass":
                 return self._handle_skip_pass(request.id)
             case _:
-                return Response(id=request.id, error=f"Unknown command: {request.command}")
+                return Response(
+                    id=request.id, error=f"Unknown command: {request.command}"
+                )
 
     async def _handle_start(self, request_id: str, params: dict) -> Response:
         """Start the reduction process."""
@@ -164,7 +169,7 @@ class ReducerWorker:
         filename = params["file_path"]
         test = params["test"]
         parallelism = params.get("parallelism", os.cpu_count() or 1)
-        timeout = params.get("timeout", 1.0)
+        timeout = params.get("timeout")  # None means dynamic timeout
         seed = params.get("seed", 0)
         input_type = InputType[params.get("input_type", "all")]
         in_place = params.get("in_place", False)
@@ -181,20 +186,20 @@ class ReducerWorker:
             if clang_delta_path:
                 clang_delta_executable = ClangDelta(clang_delta_path)
 
-        state_kwargs: dict[str, Any] = dict(
-            input_type=input_type,
-            in_place=in_place,
-            test=test,
-            timeout=timeout,
-            base=os.path.basename(filename),
-            parallelism=parallelism,
-            filename=filename,
-            formatter=formatter,
-            trivial_is_error=trivial_is_error,
-            seed=seed,
-            volume=volume,
-            clang_delta_executable=clang_delta_executable,
-        )
+        state_kwargs: dict[str, Any] = {
+            "input_type": input_type,
+            "in_place": in_place,
+            "test": test,
+            "timeout": timeout,
+            "base": os.path.basename(filename),
+            "parallelism": parallelism,
+            "filename": filename,
+            "formatter": formatter,
+            "trivial_is_error": trivial_is_error,
+            "seed": seed,
+            "volume": volume,
+            "clang_delta_executable": clang_delta_executable,
+        }
 
         if os.path.isdir(filename):
             files = [os.path.join(d, f) for d, _, fs in os.walk(filename) for f in fs]
@@ -263,7 +268,9 @@ class ReducerWorker:
 
         if self.reducer is not None and hasattr(self.reducer, "disable_pass"):
             self.reducer.disable_pass(pass_name)
-            return Response(id=request_id, result={"status": "disabled", "pass_name": pass_name})
+            return Response(
+                id=request_id, result={"status": "disabled", "pass_name": pass_name}
+            )
         return Response(id=request_id, error="Reducer does not support pass control")
 
     def _handle_enable_pass(self, request_id: str, params: dict) -> Response:
@@ -281,7 +288,9 @@ class ReducerWorker:
 
         if self.reducer is not None and hasattr(self.reducer, "enable_pass"):
             self.reducer.enable_pass(pass_name)
-            return Response(id=request_id, result={"status": "enabled", "pass_name": pass_name})
+            return Response(
+                id=request_id, result={"status": "enabled", "pass_name": pass_name}
+            )
         return Response(id=request_id, error="Reducer does not support pass control")
 
     def _handle_skip_pass(self, request_id: str) -> Response:

shrinkray/tui.py

@@ -1,7 +1,9 @@
 """Textual-based TUI for Shrink Ray."""
 
 import os
-from collections.abc import AsyncIterator
+import traceback
+from collections.abc import AsyncGenerator
+from contextlib import aclosing
 from datetime import timedelta
 from typing import Literal, Protocol
 
@@ -96,7 +98,7 @@ class ReductionClientProtocol(Protocol):
         file_path: str,
         test: list[str],
         parallelism: int | None = None,
-        timeout: float = 1.0,
+        timeout: float | None = None,
         seed: int = 0,
         input_type: str = "all",
         in_place: bool = False,
@@ -114,7 +116,7 @@ class ReductionClientProtocol(Protocol):
 
     @property
     def error_message(self) -> str | None: ...
-    def get_progress_updates(self) -> AsyncIterator[ProgressUpdate]: ...
+    def get_progress_updates(self) -> AsyncGenerator[ProgressUpdate, None]: ...
     @property
     def is_completed(self) -> bool: ...
 
@@ -485,7 +487,9 @@ class PassStatsScreen(ModalScreen[None]):
                     reductions = str(ps.successful_reductions)
                     success = f"{ps.success_rate:.1f}%"
 
-                table.add_row(checkbox, name, runs, bytes_del, tests, reductions, success)
+                table.add_row(
+                    checkbox, name, runs, bytes_del, tests, reductions, success
+                )
 
         # Restore cursor and scroll position after rebuilding
         # Only restore if the saved position is still valid
@@ -510,7 +514,9 @@ class PassStatsScreen(ModalScreen[None]):
             # Update footer with disabled count
             disabled_count = len(self.disabled_passes)
             if disabled_count > 0:
-                footer_text = f"Showing {len(self.pass_stats)} passes ({disabled_count} disabled)"
+                footer_text = (
+                    f"Showing {len(self.pass_stats)} passes ({disabled_count} disabled)"
+                )
             else:
                 footer_text = f"Showing {len(self.pass_stats)} passes in run order"
             footer = self.query_one("#stats-footer", Static)
@@ -610,7 +616,7 @@ class ShrinkRayApp(App[None]):
         file_path: str,
         test: list[str],
         parallelism: int | None = None,
-        timeout: float = 1.0,
+        timeout: float | None = None,
         seed: int = 0,
         input_type: str = "all",
         in_place: bool = False,
@@ -651,6 +657,7 @@ class ShrinkRayApp(App[None]):
             yield Label(
                 "Shrink Ray - [h] help, [p] passes, [c] skip pass, [q] quit",
                 id="status-label",
+                markup=False,
             )
             with Vertical(id="stats-container"):
                 yield StatsDisplay(id="stats-display")
@@ -713,18 +720,21 @@ class ShrinkRayApp(App[None]):
             stats_display = self.query_one("#stats-display", StatsDisplay)
             content_preview = self.query_one("#content-preview", ContentPreview)
 
-            async for update in self._client.get_progress_updates():
-                stats_display.update_stats(update)
-                content_preview.update_content(update.content_preview, update.hex_mode)
-                self._latest_pass_stats = update.pass_stats
-                self._current_pass_name = update.current_pass_name
-                self._disabled_passes = update.disabled_passes
+            async with aclosing(self._client.get_progress_updates()) as updates:
+                async for update in updates:
+                    stats_display.update_stats(update)
+                    content_preview.update_content(
+                        update.content_preview, update.hex_mode
+                    )
+                    self._latest_pass_stats = update.pass_stats
+                    self._current_pass_name = update.current_pass_name
+                    self._disabled_passes = update.disabled_passes
 
-                # Check if all passes are disabled
-                self._check_all_passes_disabled()
+                    # Check if all passes are disabled
+                    self._check_all_passes_disabled()
 
-                if self._client.is_completed:
-                    break
+                    if self._client.is_completed:
+                        break
 
             self._completed = True
 
@@ -739,6 +749,7 @@ class ShrinkRayApp(App[None]):
                 self.update_status("Reduction completed! Press 'q' to exit.")
 
         except Exception as e:
+            traceback.print_exc()
             self.exit(return_code=1, message=f"Error: {e}")
         finally:
             if self._owns_client and self._client:
@@ -750,7 +761,7 @@ class ShrinkRayApp(App[None]):
             all_pass_names = {ps.pass_name for ps in self._latest_pass_stats}
             if all_pass_names and all_pass_names <= set(self._disabled_passes):
                 self.update_status(
-                    "Reduction paused (all passes disabled) - " "[p] to re-enable passes"
+                    "Reduction paused (all passes disabled) - [p] to re-enable passes"
                 )
 
     def update_status(self, message: str) -> None:
@@ -797,7 +808,7 @@ async def _validate_initial_example(
     file_path: str,
     test: list[str],
     parallelism: int | None,
-    timeout: float,
+    timeout: float | None,
     seed: int,
     input_type: str,
     in_place: bool,
@@ -845,7 +856,7 @@ def run_textual_ui(
     file_path: str,
     test: list[str],
     parallelism: int | None = None,
-    timeout: float = 1.0,
+    timeout: float | None = None,
     seed: int = 0,
     input_type: str = "all",
     in_place: bool = False,

shrinkray/work.py

@@ -13,7 +13,7 @@ Key concepts:
 
 import heapq
 from collections.abc import Awaitable, Callable, Sequence
-from contextlib import asynccontextmanager
+from contextlib import aclosing, asynccontextmanager
 from enum import IntEnum
 from itertools import islice
 from random import Random
@@ -100,8 +100,9 @@ class WorkContext:
                         async with parallel_map(
                             values, f, parallelism=min(self.parallelism, n)
                         ) as result:
-                            async for v in result:
-                                await send.send(v)
+                            async with aclosing(result) as aiter:
+                                async for v in aiter:
+                                    await send.send(v)
 
                         n *= 2
                 else:
@@ -122,9 +123,10 @@ class WorkContext:
             @nursery.start_soon
             async def _():
                 async with self.map(ls, apply) as results:
-                    async for x, v in results:
-                        if v:
-                            await send.send(x)
+                    async with aclosing(results) as aiter:
+                        async for x, v in aiter:
+                            if v:
+                                await send.send(x)
                     send.close()
 
             yield receive
@@ -139,8 +141,9 @@ class WorkContext:
         Will run in parallel if parallelism is enabled.
         """
         async with self.filter(ls, f) as filtered:
-            async for x in filtered:
-                return x
+            async with aclosing(filtered) as aiter:
+                async for x in aiter:
+                    return x
         raise NotFound()
 
     async def find_large_integer(self, f: Callable[[int], Awaitable[bool]]) -> int:

{shrinkray-25.12.26.2.dist-info → shrinkray-25.12.27.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 25.12.26.2
+Version: 25.12.27.1
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT
@@ -28,7 +28,8 @@ Requires-Dist: hypothesmith>=0.3.1; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-trio>=0.8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
-Requires-Dist: pytest-textual-snapshot>=1.0.0; extra == "dev"
+Requires-Dist: syrupy>=5.0.0; extra == "dev"
+Requires-Dist: jinja2>=3.0.0; extra == "dev"
 Requires-Dist: coverage[toml]>=7.4.0; extra == "dev"
 Requires-Dist: pygments>=2.17.0; extra == "dev"
 Requires-Dist: basedpyright>=1.1.0; extra == "dev"

{shrinkray-25.12.26.2.dist-info → shrinkray-25.12.27.1.dist-info}/RECORD

@@ -1,16 +1,16 @@
 shrinkray/__init__.py,sha256=b5MvcvhsEGYya3GRXNbCJAlAL5IZHSsETLK_vtfmXRY,18
-shrinkray/__main__.py,sha256=sRYLrG-7FMa-y067JyYmLZMOkO2FJ2V-BenxqtBwQj0,10887
+shrinkray/__main__.py,sha256=K3_s96Tyoi7SxNOyoZXkfiEoSxVBL__TJ3o2Cefadmg,11093
 shrinkray/cli.py,sha256=1-qjaIchyCDd-YCdGWtK7q9j9qr6uX6AqtwW8m5QCQg,1697
 shrinkray/display.py,sha256=WYN05uqmUVpZhwi2pxr1U-wLHWZ9KiL0RUlTCBJ1N3E,2430
 shrinkray/formatting.py,sha256=tXCGnhJn-WJGpHMaLHRCAXK8aKJBbrOdiW9QGERrQEk,3121
 shrinkray/problem.py,sha256=Kp7QN10E4tzjdpoqJve8_RT26VpywzQwY0gX2VkBGCo,17277
 shrinkray/process.py,sha256=-eP8h5X0ESbkcTic8FFEzkd4-vwaZ0YI5tLxUR25L8U,1599
 shrinkray/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shrinkray/reducer.py,sha256=66Q5BjTLKamO2M04i2CSrbThp7PyGTRu63_ueQnjc7g,19849
-shrinkray/state.py,sha256=_-gyAkUm0vEdF1U0Fz_Deykj-kY2u3nGn3X6BfH3viA,22371
-shrinkray/tui.py,sha256=HtvqimSr1r7IX_fukRsCsVxyhEdyj2W-HLqjVATt1eM,31235
+shrinkray/reducer.py,sha256=xhLo_GF7qrIVoiLHed6Wt4nxjdE-9jj_7K9F76un89o,19877
+shrinkray/state.py,sha256=HQ7VivCXWiP2L53gB0lh6dHcdru6waWZkbPg6rYO7z4,24290
+shrinkray/tui.py,sha256=3RskLo6JvKdUQIHi40R5ka-F_1GkBXyA_d_SkYbLlCw,31601
 shrinkray/ui.py,sha256=xuDUwU-MM3AetvwUB7bfzav0P_drUsBrKFPhON_Nr-k,2251
-shrinkray/work.py,sha256=DXeqJTB_G8r7e8vrsMW2J56CJ-nhgymKBH55DT8SXs8,7901
+shrinkray/work.py,sha256=GEZ14Kk3bvwUxAnACvY-wom2lVWaGrELMNxrDjv03dk,8110
 shrinkray/passes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shrinkray/passes/bytes.py,sha256=pX2kBeH38SM4j55f8bNF_2PVBCDo6XdUj73EvOFH9f8,23904
 shrinkray/passes/clangdelta.py,sha256=t9EQ_kc159HRs48JwB5JvlJCsiCscrZgf2nhHCZRZX0,8419
@@ -19,15 +19,15 @@ shrinkray/passes/genericlanguages.py,sha256=qbTuJgUieHqWtf7cly2tm0qdbrVXzVoWcAnF
 shrinkray/passes/json.py,sha256=AcmroHgb38Aa3aApwcuYNzmyya_vnCi2RFSVqomiDg8,2586
 shrinkray/passes/patching.py,sha256=1uOTir3IbywKmsg6IIhSnxHFovZTdUCS-8PSwzgza00,8936
 shrinkray/passes/python.py,sha256=3WN1lZTf5oVL8FCTGomhrCuE04wIX9ocKcmFV86NMZA,6875
-shrinkray/passes/sat.py,sha256=2FGMM4rh4AX1BVEbry082C4aLCOEOXlfr3exHbxYgSQ,19514
+shrinkray/passes/sat.py,sha256=5Zv4IgGfg3SYplMAAaPLkbBNh4fuVpci4F9GdVacayA,19504
 shrinkray/passes/sequences.py,sha256=jCK1fWBxCz79u7JWSps9wf7Yru7W_FAsJwdgg--CLxU,3040
 shrinkray/subprocess/__init__.py,sha256=FyV2y05uwQ1RTZGwREI0aAVaLX1jiwRcWsdsksFmdbM,451
-shrinkray/subprocess/client.py,sha256=xSFqm5UyQT0WJ5aBVVkuiWDsHjZYv7RqjgrjjyX0rK0,9269
+shrinkray/subprocess/client.py,sha256=erqnPglPO0YNdwEKlmhB3yDo6Mfc00Lxh4T85lZhsDo,9341
 shrinkray/subprocess/protocol.py,sha256=LuHl0IkKpDzYhAGZz_EiTHNqDNq_v1ozg5aUSl7UzE4,6203
-shrinkray/subprocess/worker.py,sha256=MbubmnuXNFxD_SRKdiFDkGhdkCEgRxdn0tPN0HoJpyk,18998
-shrinkray-25.12.26.2.dist-info/licenses/LICENSE,sha256=iMKX79AuokJfIZUnGUARdUp30vVAoIPOJ7ek8TY63kk,1072
-shrinkray-25.12.26.2.dist-info/METADATA,sha256=3EX6HRC0LFouM2oCEKcOCjB1K1yfN1O0LrvT7LlWHh8,9693
-shrinkray-25.12.26.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-shrinkray-25.12.26.2.dist-info/entry_points.txt,sha256=wIZvnGyOdVeaLTiv2klnSyTe-EKkkwn4SwHh9bmJ7qk,104
-shrinkray-25.12.26.2.dist-info/top_level.txt,sha256=fLif8-rFoFOnf5h8-vs3ECkKNWQopTQh3xvl1s7pchQ,10
-shrinkray-25.12.26.2.dist-info/RECORD,,
+shrinkray/subprocess/worker.py,sha256=ke-9DYFH117EpJEntkucTrn7ep7pygzmV-VXkRe1o-E,19294
+shrinkray-25.12.27.1.dist-info/licenses/LICENSE,sha256=iMKX79AuokJfIZUnGUARdUp30vVAoIPOJ7ek8TY63kk,1072
+shrinkray-25.12.27.1.dist-info/METADATA,sha256=bB-_7Y4Gk9a-QiXEFKy_iTDy3nWM72YOYXhq0W_PJ7o,9721
+shrinkray-25.12.27.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shrinkray-25.12.27.1.dist-info/entry_points.txt,sha256=wIZvnGyOdVeaLTiv2klnSyTe-EKkkwn4SwHh9bmJ7qk,104
+shrinkray-25.12.27.1.dist-info/top_level.txt,sha256=fLif8-rFoFOnf5h8-vs3ECkKNWQopTQh3xvl1s7pchQ,10
+shrinkray-25.12.27.1.dist-info/RECORD,,