exp-runtime-engine 0.5.0__py3-none-any.whl

exp_runtime/scene_badge.py

@@ -0,0 +1,65 @@
+"""Service 90's nonblocking scene label (FUN_0007b97c)."""
+from dataclasses import dataclass
+
+from .fonts import TextStyle, layout_text
+
+
+@dataclass
+class SceneBadge:
+    asset_id: int
+    text: str
+    blue: bool
+    elapsed_ms: int = 0
+
+    def tick(self, elapsed_ms):
+        self.elapsed_ms = min(200, self.elapsed_ms + elapsed_ms)
+
+    def validate(self):
+        if not 0 <= self.asset_id <= 32767 or not 0 <= self.elapsed_ms <= 200:
+            raise ValueError('Invalid scene label')
+
+    @property
+    def text_position(self):
+        # Native label node centers in a 171x60 sprite (GL local coordinates).
+        n = len(self.text)
+        if 15 <= n <= 17:
+            return 123, 55, 1.0
+        if n < 13:
+            x = {'Before Class': 120, 'Mascot Theft': 122, 'Driving Home': 120}.get(self.text, 125)
+            return x, 45, 1.0
+        if n < 19:
+            x, y = {'Before School': (117, 45), "Chuck's Party": (120, 45),
+                    'Football Game': (120, 45), 'After Practice': (120, 45),
+                    "Counselor's Office": (123, 53), 'Unsupervised Study': (120, 53),
+                    'Saturday Night': (119, 45)}.get(self.text, (117, 53))
+            return x, y, .9 if self.text == 'Before School' else 1.0
+        return 121, 55, 1.0
+
+    @property
+    def text_origin(self):
+        # FUN_0007b97c: a 110x20 label with (.5,.5) anchor and flags 0x11
+        # (wrapped, left/top aligned). Text draws downward from local zero;
+        # converting the anchor to screen Y therefore adds half its height.
+        x, y, scale = self.text_position
+        return x - 55 * scale, 60 - y + 10 * scale, scale
+
+
+def outline_badge_text(text, font, region, color):
+    """CSFont's wrapped, left/center-aligned layout-67 text (flags 0x19).
+
+    Both iOS games use Arial 14, cap-height line boxes and no added gap.
+    Bound substitute-font ink to the same region without changing the label
+    or any saved state. Android's separate bitmap-label rules remain above.
+    """
+    # A substitute font may have a glyph wider than the entire native region.
+    # Let that glyph wrap alone, then fit its ink with the rest of the label.
+    width = max(region.width, max((font.glyph(c).advance
+                for c in text.split('\x00', 1)[0] if c != '\n'), default=0))
+    layout = layout_text(font, text, width, TextStyle(font.cap_height, 0, color))
+    left, top, right, bottom = layout.ink_bounds
+    scale = min(1, region.width / max(1, right - left),
+                region.height / max(1, bottom - top))
+    x, y = region.x, region.y + (region.height - layout.height * scale) / 2
+    x = max(region.x - left * scale, min(x, region.x + region.width - right * scale))
+    y = max(region.y - top * scale, min(y, region.y + region.height - bottom * scale))
+    return layout, (x, y), scale

exp_runtime/speaker_names.py

@@ -0,0 +1,258 @@
+"""Native speaker label state and layout (000a7fa8 / 000a8544).
+
+The four font objects survive dialogue changes. Their previous line counts,
+content sizes and line spacing are inputs to the next layout, not caches that
+can be recomputed from the next speaker's name. See docs/UI_FIDELITY.md.
+"""
+from copy import deepcopy
+from dataclasses import dataclass, field, replace
+
+from .fonts import BitmapFont, TextLayout, TextStyle, layout_label, layout_text
+from .ui_assets import LayoutBank, Rect
+
+
+NAME_FONTS = {-1: 'PajamaHipY26', 2: 'PajamaHip266', 3: 'PajamaHipG26'}
+DEFAULT_FONT = 'PajamaHip26'
+
+
+@dataclass
+class NameFontState:
+    width: int = 0
+    height: int = 0
+    gap: int = -16
+    # 0007cbbc initializes each label with "SHS", then sets nominal height 16.
+    lines: int = 1
+    indents: list[int] = field(default_factory=list)
+
+    @property
+    def style(self):
+        return TextStyle(16, self.gap, indents=tuple(self.indents))
+
+    def validate(self):
+        if (not 0 <= self.width <= 65535 or not 0 <= self.height <= 65535
+                or self.gap not in (-16, 8) or not 0 <= self.lines <= 65535
+                or self.indents not in ([], [0, 5], [0, 20])):
+            raise ValueError('Invalid speaker font state')
+
+
+@dataclass
+class SpeakerNames:
+    fonts: dict[str, NameFontState] = field(default_factory=dict)
+    # State before the current dialogue: redraws and page turns replay only
+    # this layout, without advancing the live font objects a second time.
+    basis: dict[str, NameFontState] | None = None
+
+    def validate(self):
+        for bank in (self.fonts, self.basis):
+            if bank is not None:
+                if set(bank) - {DEFAULT_FONT, *NAME_FONTS.values()}:
+                    raise ValueError('Invalid speaker font bank')
+                for state in bank.values():
+                    state.validate()
+
+
+@dataclass(frozen=True)
+class SpeakerLabel:
+    text: str
+    font: str
+    layout: TextLayout
+    origin: tuple[float, float]
+    scale: float
+    extra: int
+    content_size: tuple[int, int]
+    flags: int
+    # Outline fonts use CSFont's top-left title region, rather than a Cocos
+    # label with retained content size. Keep that distinction at the font
+    # adapter boundary, within the common dialogue renderer.
+    header: Rect | None = None
+
+
+def speaker_label(text: str, mode: int, theme: int, bank: LayoutBank, font_loader,
+                  states: dict[str, NameFontState]) -> SpeakerLabel:
+    """Execute one native name layout, updating only the supplied font bank."""
+    font_name = NAME_FONTS.get(theme, DEFAULT_FONT)
+    font: BitmapFont = font_loader(font_name)
+    if mode == 4:
+        return SpeakerLabel('', font_name, layout_text(font, '', 1, TextStyle(16, -16)),
+                            (0, 0), .9, 8, (0, 0), 0x19)
+    state = states.setdefault(font_name, NameFontState())
+    # 000a7fa8 measures theme -1 with the default font, although 000a8544
+    # draws it with the separate yellow font object.
+    measure_name = NAME_FONTS.get(theme, DEFAULT_FONT) if theme in (2, 3) else DEFAULT_FONT
+    measure_state = states.setdefault(measure_name, NameFontState())
+    measure_font = font_loader(measure_name)
+    rect = bank.rectangle(17, {1: 0x2e, 2: 0x4c, 3: 0x6a}[mode])
+    if mode == 2:
+        large = layout_text(measure_font, text, 2**31, measure_state.style).width > rect.width
+    else:
+        measured = layout_text(measure_font, text, rect.width, measure_state.style)
+        measure_state.lines = len(measured.lines)
+        large = measured.height > rect.height
+    extra = 40 if large else 8
+    if large:
+        rect = bank.rectangle(17, {1: 0x25, 2: 0x43, 3: 0x61}[mode])
+        if mode in (1, 2):
+            rect = replace(rect, y=rect.y - 40)
+    if mode == 1:
+        rect = replace(rect, x=rect.x + 1)
+    elif mode == 2:
+        rect = replace(rect, x=rect.x + (1 if len(text) == 8 else 5))
+
+    unwrapped = layout_text(font, text, 2**31, state.style).width
+    w, h = rect.width, rect.height
+    scale, offset, flags = .9, 0, 0x1a
+    if mode == 1:
+        flags = 0x19 if large else 0x1b
+        offset = -23 if not large and int(unwrapped) < 127 else 0
+        if text != 'Brendizzle':  # Native branch deliberately retains the previous size.
+            state.height = h + 30
+            if state.lines < 2:
+                state.width = w + 20
+            else:
+                state.width = w + (80 if len(text) < 14 else 40)
+                scale = .8
+        state.indents = [0, 20]
+    elif mode == 2:
+        if large:
+            state.gap = 8
+            flags = 0x19
+        if text in ("Howard's Mom", "Howard's Dad", 'French Teacher', "Neighbor's Wife"):
+            state.width, state.height, scale = {
+                "Howard's Mom": (235, h + 32, .9),
+                "Howard's Dad": (223, h + 32, .9),
+                'French Teacher': (225, h + 50, .8),
+                "Neighbor's Wife": (w + 80, h + 60, .8),
+            }[text]
+            flags = 0x3d
+        elif len(text) == 8:
+            if text == 'The Boss':
+                text = 'Th e Boss '
+            state.width, state.height = w, h + 34
+        elif len(text) == 11:
+            state.width, state.height, flags = w, h + 82, 0x3d
+        elif state.lines < 2:
+            text = {'The Mayor': 'Th e Mayor', 'Judge Tigh': 'Judge Ti gh',
+                    'Animal Thief': 'Animal Th ief'}.get(text, text)
+            state.width, state.height, flags = w + 20, h + 32, 0x19
+        elif len(text) < 19:
+            state.width, state.height, scale = w + 80, h + 30, .8
+            if text == 'Spud The Stud':
+                text, scale = 'Spud Th e Stud', .7
+        else:
+            state.width, state.height, scale = 300, h + 32, .7
+        state.indents = [0, 5]
+        offset = 23 if int(unwrapped) < 127 else 0
+    else:
+        if len(text) == 8:
+            if text == 'The team':
+                text = 'Th e team'
+            state.width, state.height = w + 20, h + 34
+        elif len(text) < 16:
+            text = {'The Whole Room': 'Th e Whole Room', 'The Crowd': 'Th e Crowd'}.get(text, text)
+            state.indents = []
+            state.width, state.height = w + 20, h + 20
+        else:
+            state.width, state.height, scale = 580, h + 30, .6
+
+    laid_out = layout_label(font, text, state.width, state.height, state.style, flags)
+    state.lines = len(laid_out.lines)
+    # 000a8544 sets the node position before setString. Glyph coordinates from
+    # layout_label are local to its bottom-left corner, with downward Y.
+    px = rect.x + offset - 10 + (w + 20) // 2
+    py = 480 - state.height + 19 - rect.y + (h + 20) // 2
+    origin = (px - scale * state.width / 2, 480 - py + scale * state.height / 2)
+    return SpeakerLabel(text, font_name, laid_out, origin, scale, extra,
+                        (state.width, state.height), flags)
+
+
+def preview_speaker(details, bank, font_loader, names: SpeakerNames | None = None):
+    font_name = NAME_FONTS.get(details['theme'], DEFAULT_FONT)
+    font = font_loader(font_name)
+    if getattr(font, 'cap_height', None) is not None:
+        return outline_speaker_label(details['speaker'], details['presentation_mode'],
+                                     font_name, bank, font)
+    basis = deepcopy(names.basis) if names is not None and names.basis is not None else {}
+    return speaker_label(details['speaker'], details['presentation_mode'], details['theme'],
+                         bank, font_loader, basis)
+
+
+def outline_speaker_label(text, mode, font_name, bank, font):
+    """SHS/CoD CSFont title layout, independent of Android label history.
+
+    updateTitleBounds (CoD 00036adc / SHS 0007ce08) measures at the normal
+    region's width and selects the tall region if wrapped height exceeds it.
+    animateTitleLayer sets the offsets/flags below, then drawTextInRegion
+    centers the line boxes vertically. CSFont uses cap height and gap 8;
+    Cocos's width expansion, nominal height 16 and 0.9 scale do not apply.
+    """
+    style = TextStyle(font.cap_height, 8)
+    rect = bank.rectangle(17, {1: 0x2e, 2: 0x4c, 3: 0x6a}[mode])
+    measured = layout_text(font, text, rect.width, style)
+    large = measured.height > rect.height
+    if large:
+        rect = bank.rectangle(17, {1: 0x25, 2: 0x43, 3: 0x61}[mode])
+    unwrapped = layout_text(font, text, 2**31, style).width
+    flags, offset = 0x1a, 0
+    if mode == 1:
+        flags = 0x19 if large else 0x1b
+        offset = -15 if not large and int(unwrapped) < 135 else 0
+        rect = replace(rect, x=rect.x + 1)
+        style = replace(style, indents=(0, 20))
+    elif mode == 2:
+        flags = 0x19
+        offset = 15 if int(unwrapped) < 135 else 0
+        rect = replace(rect, x=rect.x - 2)
+        style = replace(style, indents=(0, 5))
+    layout = layout_text(font, text, rect.width, style)
+    alignment = {2: .5, 3: 1}.get(flags & 3, 0)
+    lines, glyphs = [], []
+    for index, line in enumerate(layout.lines):
+        indent = style.indents[index] if index < len(style.indents) else 0
+        shift = (rect.width - abs(indent) - line.width) * alignment
+        lines.append(replace(line, x=line.x + shift))
+        glyphs.extend(replace(g, x=g.x + shift) for g in layout.glyphs
+                      if line.start <= g.index < line.end)
+    layout = replace(layout, lines=tuple(lines), glyphs=tuple(glyphs))
+    origin = (rect.x + offset, rect.y + (rect.height - layout.height) / 2)
+    return SpeakerLabel(text, font_name, layout, origin, 1, 40 if large else 8,
+                        (rect.width, rect.height), flags, rect)
+
+
+def fit_speaker_ink(label: SpeakerLabel, bounds: Rect):
+    """Fit complete visible ink to the header attached to the current box.
+
+    The native routine sizes line boxes using height 16, although the imported
+    name glyphs can be taller than 30. Its retained gap can also put a later
+    single-line name far above or below the header. Separate overlapping rows,
+    then fit both dimensions to the selected normal/tall header. Outline
+    fonts retain their native position unless ink exceeds that region or the
+    body/portrait boundary. This drawing correction never changes font history.
+    """
+    layout = label.layout
+    if not layout.glyphs:
+        return layout, label.origin, label.scale
+    lines, glyphs, previous_bottom, shift = [], [], None, 0
+    for line in layout.lines:
+        row = [g for g in layout.glyphs if line.start <= g.index < line.end]
+        if row:
+            top = min(g.y for g in row) + shift
+            if previous_bottom is not None and top < previous_bottom:
+                shift += previous_bottom - top
+            previous_bottom = max(g.y + g.glyph.height for g in row) + shift
+        lines.append(replace(line, y=line.y + shift))
+        glyphs.extend(replace(g, y=g.y + shift) for g in row)
+    layout = replace(layout, lines=tuple(lines), glyphs=tuple(glyphs))
+    ink_left, ink_top, ink_right, ink_bottom = layout.ink_bounds
+    scale = min(label.scale, bounds.width / (ink_right - ink_left),
+                bounds.height / (ink_bottom - ink_top))
+    if label.header is not None:
+        x = min(max(label.origin[0], bounds.x - ink_left * scale),
+                bounds.x + bounds.width - ink_right * scale)
+        y = min(max(label.origin[1], bounds.y - ink_top * scale),
+                bounds.y + bounds.height - ink_bottom * scale)
+        return layout, (x, y), scale
+    alignment = {2: .5, 3: 1}.get(label.flags & 3, 0)
+    spare = bounds.width - (ink_right - ink_left) * scale
+    x = bounds.x + spare * alignment - ink_left * scale
+    y = bounds.y + bounds.height - ink_bottom * scale
+    return layout, (x, y), scale

exp_runtime/text_input.py

@@ -0,0 +1,55 @@
+"""Native services 17/40 name editing, independent of the desktop and VM.
+
+See docs/NAME_INPUT.md. The width check is on the existing text plus the
+cursor, before appending the next character (FUN_000d3cb0).
+"""
+from .fonts import BitmapFont
+
+
+MAX_NAME_LENGTH = 16
+NAME_FONT = 'ArialRoundedMTBold28'
+CURSOR_FONT = 'PajamaHip26'
+NAME_ENTRY_ERROR = (
+    'The name entry screen only supports the following alphanumeric '
+    'characters: A-Z and 0-9.'
+)
+
+
+def input_fonts(resources):
+    if getattr(getattr(resources, 'library', None), 'kind', 'apk') == 'ipa':
+        return 'PajamaHip24', 'PajamaHip24'
+    return NAME_FONT, CURSOR_FONT
+
+
+def _alphanumeric(text: str) -> bool:
+    return all('a' <= c <= 'z' or 'A' <= c <= 'Z' or '0' <= c <= '9' for c in text)
+
+
+def _has_room(current: str, font: BitmapFont | None, cursor_width: float) -> bool:
+    # Kerning shifts ink, not the native measuring pen. Authored headless
+    # fixtures without APK fonts can still exercise the byte/length rules.
+    return font is None or sum(font.glyph(c).advance for c in current) + cursor_width < 240
+
+
+def accept_name_character(current: str, char: str, *, font: BitmapFont | None = None,
+                          cursor_width: float = 0) -> tuple[str, str | None]:
+    if (len(char) != 1 or not _alphanumeric(char) or len(current) >= MAX_NAME_LENGTH
+            or not _alphanumeric(current) or not _has_room(current, font, cursor_width)):
+        return current, NAME_ENTRY_ERROR
+    if current and 'A' <= char <= 'Z':
+        char = char.lower()
+    return current + char, None
+
+
+def validate_name(value: str, *, font: BitmapFont | None = None, cursor_width: float = 0):
+    """Validate a confirmed value without recasing script defaults or callers.
+
+    A final character may cross the width threshold: native checks the prefix
+    before accepting it. Empty Return hides the keyboard; it never resumes.
+    """
+    if not isinstance(value, str) or len(value) > MAX_NAME_LENGTH or not _alphanumeric(value):
+        raise ValueError(NAME_ENTRY_ERROR)
+    if not value:
+        raise ValueError('Enter a name before continuing.')
+    if not _has_room(value[:-1], font, cursor_width):
+        raise ValueError(NAME_ENTRY_ERROR)

exp_runtime/title_screen.py

@@ -0,0 +1,104 @@
+"""Service 8 title cards: native wipe, input gate and external-atlas lettering."""
+from dataclasses import dataclass
+
+from .atlas import AtlasFont
+from .ui_assets import LayoutBank
+from .vm import VMError
+
+
+@dataclass
+class TitleScreen:
+    elapsed_ms: int = 0
+    reveal_width: int = 0
+    ready: bool = False
+
+    def tick(self, elapsed_ms):
+        # 000a650c adds five pixels per update. Use the application's
+        # configured 30 Hz cadence, independent of the desktop render rate.
+        before = self.elapsed_ms * 30 // 1000
+        self.elapsed_ms = min(4000, self.elapsed_ms + elapsed_ms)
+        steps = self.elapsed_ms * 30 // 1000 - before
+        if steps:
+            # The native gate tests the OLD width before adding five.
+            self.ready |= self.reveal_width + 5 * (steps - 1) > 240
+            self.reveal_width = min(320, self.reveal_width + 5 * steps)
+
+    def acknowledge(self):
+        if not self.ready:
+            # 000a6800: an early tap completes the wipe, without closing.
+            # The following native update opens the acknowledgement gate.
+            self.reveal_width = 320
+            return False
+        return True
+
+    @property
+    def background_alpha(self):
+        return max(0., min(1., (self.elapsed_ms - 1000) / 3000))
+
+    @property
+    def subtitle_scale_y(self):
+        return .5 + .5 * max(0., min(1., (self.elapsed_ms - 500) / 500))
+
+    @classmethod
+    def settled(cls):
+        # Older saves contain no entrance history; preserve their readable,
+        # immediately acknowledgeable title instead of replaying the intro.
+        return cls(4000, 320, True)
+
+    def validate(self):
+        if (type(self.elapsed_ms) is not int or not 0 <= self.elapsed_ms <= 4000
+                or type(self.reveal_width) is not int or not 0 <= self.reveal_width <= 320
+                or type(self.ready) is not bool):
+            raise VMError('Invalid title-screen animation state')
+        steps = self.elapsed_ms * 30 // 1000
+        if (self.reveal_width not in (min(320, steps * 5), 320)
+                or (steps >= 50 and not self.ready)
+                or (self.ready and (steps == 0 or self.reveal_width <= 245))):
+            raise VMError('Title-screen wipe does not match its clock or input gate')
+
+
+@dataclass(frozen=True)
+class TitleGlyph:
+    character: str
+    x: int
+    y: int
+
+
+@dataclass(frozen=True)
+class TitleLabel:
+    asset_id: int
+    origin: tuple[float, float]
+    scale: float
+    glyphs: tuple[TitleGlyph, ...]
+
+
+def _glyphs(font: AtlasFont, text: str, width: int, *, right=False, subtitle=False):
+    """00054148/00054490/0005373c, converted from local GL to downward Y."""
+    result, pen_y = [], 0
+    # Native subtitle fitting adjusts the first glyph's local Y. Subsequent
+    # rows then descend because the title panel sets host flag +0x6ac43.
+    adjust = subtitle and 24 < len(text) < 100 and font.height == 23
+    for line in font.wrap(text, width):
+        x = width - font.width(line) if right else 0
+        for character in line:
+            if character != ' ' and font.glyph(character) is not None:
+                if adjust:
+                    if pen_y >= font.height - 2:
+                        pen_y = 3
+                    elif pen_y == 0:
+                        pen_y = font.height - 4
+                result.append(TitleGlyph(character, x, -pen_y - font.height))
+            x += font.char_width(character) + font.tracking
+        pen_y -= font.height + font.line_gap
+    return tuple(result)
+
+
+def title_labels(bank: LayoutBank, title_font: AtlasFont, subtitle_font: AtlasFont,
+                 title: str, subtitle: str):
+    """000a70b4: zero-anchor labels with independent node positions/scales."""
+    heading, subheading = bank.rectangle(48, 9), bank.rectangle(48, 10)
+    title_origin = heading.x - 10, heading.height // 2 - 10
+    subtitle_y = subheading.y - subheading.height // 2 - (75 if len(subtitle) < 100 else 0)
+    return (TitleLabel(528, title_origin, .85, _glyphs(title_font, title, 380)),
+            TitleLabel(530, (0, 480 - subtitle_y), 1.,
+                       _glyphs(subtitle_font, subtitle, 320, right=True, subtitle=True)))

exp_runtime/trace.py

@@ -0,0 +1,76 @@
+"""Execute an EXP's KiWi code to the first pending action or diagnostic stop."""
+from dataclasses import asdict
+import hashlib
+from pathlib import Path
+
+from .decode.bytecode import decode_program
+from .content import ExpArchive
+from .engine import EngineState
+from .games import GAMES
+from .vm import KiwiVM, StopKind, VMError
+
+
+def trace_archive(path: Path, *, max_events: int = 10_000, max_steps: int = 100_000, game='shs') -> dict:
+    """Trace a fresh game state. Never answer presentation/unknown yields.
+
+    Scheduled scripts are popped in LIFO order, as in FUN_0007f5f4.
+    Resource decoding/rendering, native saves, and minigames are outside
+    this trace. The result contains only state this handler subset models.
+    """
+    if max_events < 1 or max_steps < 1:
+        raise ValueError('trace budgets must be positive')
+    if game not in GAMES:
+        raise ValueError(f'Unknown game: {game}')
+    data = path.read_bytes()
+    digest = hashlib.sha256(data).hexdigest()
+    archive = ExpArchive(data)
+    programs = {}
+    for resource_id in archive.entries:
+        payload = archive.read(resource_id)
+        if payload.startswith(b'kiwi'):
+            programs[resource_id] = decode_program(payload)
+    if not programs:
+        raise ValueError(f'no KiWi scripts in {path}')
+    scene = next(iter(programs))
+    vm = KiwiVM(programs[scene])
+    engine = EngineState()
+    engine.game_key = game
+    events = []
+    stop = 'event_budget'
+    error = None
+    for _ in range(max_events):
+        remaining = max_steps - vm.steps_executed
+        if remaining <= 0:
+            stop = 'instruction_budget'
+            break
+        try:
+            event = vm.run(remaining)
+            if event.kind == StopKind.YIELD:
+                action = engine.dispatch(vm)
+                events.append(dict(scene=scene, **asdict(action)))
+                if not action.completed:
+                    stop = action.name
+                    break
+            elif event.kind == StopKind.HALT and engine.scheduled_scripts:
+                next_scene, flag = engine.scheduled_scripts[-1]
+                if next_scene not in programs:
+                    stop = 'missing_script'
+                    error = f'scheduled script {next_scene} is absent from this archive'
+                    break
+                engine.scheduled_scripts.pop()
+                events.append(dict(scene=scene, name='load_script', file_id=next_scene, flag=flag))
+                scene = next_scene
+                vm.load_next(programs[scene])
+            else:
+                stop = event.kind.value
+                break
+        except VMError as exc:
+            stop, error = 'vm_error', str(exc)
+            break
+    return dict(
+        archive=str(path), sha256=digest, status=stop, error=error,
+        scene=scene, pc=vm.pc, sp=vm.sp, fp=vm.fp,
+        steps=vm.steps_executed, events=events, state=asdict(engine),
+        executed_opcodes={f'0x{op:02x}': count for op, count in sorted(vm.opcode_counts.items())},
+        recent_pcs=list(vm.recent_pcs),
+    )