// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {Squeeklings} from "src/Squeeklings.sol";
import {SqueeklingsArt} from "src/SqueeklingsArt.sol";
import {Loot, Kind} from "src/SqueekTypes.sol";

/// Encodes roundPage exactly as the live Sepolia SqueekCore 0xfd6c...c4 does: ONE struct return
/// (leading 0x20 offset word; an empty page is 320 bytes, not 288). Paging otherwise mirrors the brief.
contract LiveLayoutCore {
    struct Point { uint64 cumulativeWork; uint96 cumulativeBlockUnits; uint32 auxiliary; }
    struct Round { uint64 roundId; uint64 cumulativeWork; uint96 cumulativeBlockUnits; uint32 auxiliary; bytes32 dataHash; }
    struct RoundPage { uint64 certifiedThroughRound; Point start; Point end; Round[] rounds; }

    uint64 public genesis;
    uint64 public settled;
    uint64 public work;
    uint96 public units;
    mapping(uint64 => Point) internal points;
    Round[] internal active;

    constructor(uint64 g) { genesis = g; }

    function append(uint64 w, uint96 u, bytes32 h) external {
        ++settled; work += w; units += u;
        points[settled] = Point(work, units, 0);
        if (w > 0) active.push(Round(settled, work, units, 0, h));
    }

    function state() external view returns (uint64, uint64, uint96, uint64, uint96, uint32, uint256, bool) {
        return (settled, work, units, 0, 0, 0, 0, false);
    }

    function configuration() external view returns (bytes32, uint64, uint64, uint64, uint16, address, address, uint32, uint64, uint64, uint96) {
        return (bytes32(0), genesis, 60, 10_000, 16, address(this), address(this), 0, 40, 30, 1e9);
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords) external view returns (RoundPage memory p) {
        require(maxRecords <= 16 && afterRound <= throughRound && throughRound <= settled);
        p.start = points[afterRound];
        p.certifiedThroughRound = throughRound;
        Round[] memory rs = new Round[](maxRecords);
        uint256 n;
        for (uint256 i; i < active.length; ++i) {
            Round memory r = active[i];
            if (r.roundId <= afterRound) continue;
            if (r.roundId > throughRound) break;
            if (n == maxRecords) { p.certifiedThroughRound = rs[n - 1].roundId; break; }
            rs[n++] = r;
        }
        assembly { mstore(rs, n) }
        p.rounds = rs;
        p.end = points[p.certifiedThroughRound];
    }
}

contract LiveLayoutTest is Test {
    function testReturnHomeWorksAgainstLiveRoundPageEncoding() public {
        vm.warp(1_000_000);
        vm.roll(100);
        LiveLayoutCore core = new LiveLayoutCore(1_000_000);
        Squeeklings game = new Squeeklings(address(core), address(new SqueeklingsArt()), address(0xA11CE0));
        address alice = makeAddr("alice");
        vm.prank(alice);
        uint256 id = game.hatch();
        vm.prank(alice);
        game.embark(id, 0); // rounds 2..7
        core.append(0, 0, 0); // round 1
        core.append(0, 0, 0); // round 2
        core.append(700, 50e9, keccak256("r3"));
        for (uint256 i; i < 4; ++i) core.append(0, 0, 0); // rounds 4..7

        // Currently reverts InvalidHistory(): SqueekCoreReader.page rejects the live layout,
        // so the pet stays away (and non-transferable) forever.
        Loot memory got = game.returnHome(id);
        assertEq(uint8(got.kind), uint8(Kind.Trail));
        vm.prank(alice);
        game.transferFrom(alice, address(0xB0B), id);
        assertEq(game.ownerOf(id), address(0xB0B));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {Squeeklings} from "src/Squeeklings.sol";
import {SqueeklingsArt} from "src/SqueeklingsArt.sol";
import {Loot, Rarity, Kind} from "src/SqueekTypes.sol";

/// Minimal V3 core with no active rounds (the hamster is idle): every point read is (0,0,0).
contract IdleCore {
    uint64 public genesis;
    uint64 public settled;
    struct Point { uint64 w; uint96 u; uint32 a; }
    struct Round { uint64 id; uint64 w; uint96 u; uint32 a; bytes32 h; }
    constructor(uint64 g) { genesis = g; }
    function settle(uint64 through) external { settled = through; }
    function state() external view returns (uint64, uint64, uint96, uint64, uint96, uint32, uint256, bool) {
        return (settled, 0, 0, 0, 0, 0, 0, false);
    }
    function configuration() external view returns (bytes32, uint64, uint64, uint64, uint16, address, address, uint32, uint64, uint64, uint96) {
        return (bytes32(0), genesis, 60, 0, 0, address(this), address(this), 0, 0, 0, 1e9);
    }
    function roundPage(uint64, uint64 through, uint256) external view returns (uint64, Point memory s, Point memory e, Round[] memory r) {
        require(through <= settled);
        return (through, s, e, new Round[](0));
    }
}

contract DreamPredictTest is Test {
    uint64 constant GENESIS = 1_000_000;

    function testDreamLootIsSelectableAtEmbarkTime() public {
        vm.warp(GENESIS);
        vm.roll(100);
        IdleCore core = new IdleCore(GENESIS);
        Squeeklings game = new Squeeklings(address(core), address(new SqueeklingsArt()), address(0xA11CE0));
        address alice = makeAddr("alice");
        vm.prank(alice);
        uint256 id = game.hatch();
        bytes32 seed = game.pet(id).seed;
        // Entropy of a trip with no active rounds is keccak256 of zero bytes: known before the trip.
        bytes32 emptyEntropy = keccak256("");

        uint256 legendaries;
        uint64 round = 1;
        for (uint256 trip; trip < 5; ++trip) {
            // Off-chain: pick the next embark round whose Dream roll on the 36-round route is < 10.
            while (uint256(keccak256(abi.encode(emptyEntropy, seed, id, uint64(round + 36)))) % 100 >= 10) ++round;
            vm.warp(GENESIS + uint256(round - 1) * 60); // currentRound() == round
            core.settle(round - 1);
            vm.prank(alice);
            game.embark(id, 2);
            core.settle(round + 36);
            Loot memory got = game.returnHome(id);
            assertEq(uint8(got.kind), uint8(Kind.Dream));
            if (got.rarity == Rarity.Legendary) ++legendaries;
            round += 37;
        }
        // An honest 10% roll gives 5/5 legendaries with probability 1e-5; the chosen timing gives it always.
        assertLt(legendaries, 5, "Dream legendary chosen by embark timing");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {Squeeklings} from "src/Squeeklings.sol";
import {SqueeklingsArt} from "src/SqueeklingsArt.sol";
import {Loot, Kind, PetView} from "src/SqueekTypes.sol";

/// @notice Mirrors the deployed Sepolia SqueekCore V3 (proxy 0xFD6C166D4B8E2962E65746a13e5a0797CD4dE0c4,
/// implementation 0x6869d6102696243fd17013ab955d99cd0c522ad3, verified source). The live contract declares
/// `roundPage(...) returns (RoundPage memory)`: ONE dynamic struct, so its return data starts with a 0x20
/// offset word and is 320 + 160*n bytes long. The project's ISqueekCoreV3 declares four separate return
/// values (288 + 160*n bytes, no offset word), so SqueekCoreReader.page rejects every live response.
contract LiveShapedCore {
    struct LedgerPosition {
        uint64 cumulativeWork;
        uint96 cumulativeBlockUnits;
        uint32 workPerThousandBlocks;
    }

    struct RoundCheckpoint {
        uint64 roundId;
        uint64 cumulativeWork;
        uint96 cumulativeBlockUnits;
        uint32 workPerThousandBlocks;
        bytes32 dataHash;
    }

    struct RoundPage {
        uint64 certifiedThroughRound;
        LedgerPosition start;
        LedgerPosition end;
        RoundCheckpoint[] rounds;
    }

    struct CoreState {
        uint64 settledThroughRound;
        uint64 cumulativeWork;
        uint96 cumulativeBlockUnits;
        uint64 blockHeight;
        uint96 blockProgress;
        uint32 workPerThousandBlocks;
        uint256 authorizationNonce;
        bool paused;
    }

    struct CoreConfiguration {
        bytes32 streamId;
        uint64 genesisTimestamp;
        uint64 roundDuration;
        uint64 maxWorkPerRound;
        uint16 maxRoundsPerBatch;
        address guardian;
        address reporter;
        uint32 initialWorkPerThousandBlocks;
        uint64 targetBlocksPerActiveRound;
        uint64 difficultySmoothingRounds;
        uint96 blockUnitsPerBlock;
    }

    uint64 public genesis;
    uint64 public settled;
    uint64 public work;
    uint96 public units;
    mapping(uint64 => LedgerPosition) internal points;
    RoundCheckpoint[] internal checkpoints;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

    /// @dev Settles one round; a zero-work round is an empty round (no checkpoint record).
    function append(uint64 addedWork, uint96 addedUnits, bytes32 dataHash) external {
        ++settled;
        work += addedWork;
        units += addedUnits;
        points[settled] = LedgerPosition(work, units, 0);
        if (addedWork > 0) checkpoints.push(RoundCheckpoint(settled, work, units, 0, dataHash));
    }

    function state() external view returns (CoreState memory) {
        return CoreState(settled, work, units, 0, 0, 0, 0, false);
    }

    function configuration() external view returns (CoreConfiguration memory) {
        return CoreConfiguration(keccak256("live"), genesis, 600, 10000, 16, address(1), address(2), 0, 0, 0, 1e9);
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory result)
    {
        require(afterRound <= throughRound && throughRound <= settled && maxRecords <= 16, "bounds");
        result.start = points[afterRound];
        uint256 low;
        uint256 high = checkpoints.length;
        while (low < high) {
            uint256 mid = (low + high) / 2;
            if (checkpoints[mid].roundId <= afterRound) low = mid + 1;
            else high = mid;
        }
        RoundCheckpoint[] memory rounds = new RoundCheckpoint[](maxRecords);
        uint256 count;
        uint64 certified = throughRound;
        for (uint256 i = low; i < checkpoints.length; ++i) {
            if (checkpoints[i].roundId > throughRound) break;
            if (count == maxRecords) {
                certified = checkpoints[i].roundId - 1;
                break;
            }
            rounds[count++] = checkpoints[i];
        }
        assembly ("memory-safe") { mstore(rounds, count) }
        result.certifiedThroughRound = certified;
        result.end = points[certified];
        result.rounds = rounds;
    }
}

contract LiveAbiReturnTest is Test {
    uint64 constant GENESIS = 1_793_735_400;
    LiveShapedCore core;
    Squeeklings game;
    address alice = address(0xA11CE);
    address owner = address(0x60731C2F051dA8708E405f64e803F3c8D1059dee);

    function setUp() public {
        vm.warp(GENESIS);
        vm.roll(100);
        core = new LiveShapedCore(GENESIS);
        SqueeklingsArt art = new SqueeklingsArt();
        game = new Squeeklings(address(core), address(art), owner);
    }

    /// @dev The live return layout for an empty point read (captured from roundPage(564,564,0) on Sepolia):
    /// word0 = 0x20 offset, word1 = certified, words 2-4 start, words 5-7 end, word8 = 0x100, word9 = 0.
    function testLiveShapedPointReadIsTenWordsWithLeadingOffset() public view {
        bytes memory raw = abi.encodeWithSelector(bytes4(keccak256("roundPage(uint64,uint64,uint256)")), uint64(0), uint64(0), uint256(0));
        (bool ok, bytes memory data) = address(core).staticcall(raw);
        assertTrue(ok);
        assertEq(data.length, 320, "live core returns 320 bytes for an empty page");
        assertEq(abi.decode(data, (uint256)), 32, "live core return starts with a struct offset word");
    }

    /// @dev Six empty settled rounds (a plain Dream trip) must return and credit one Dream item.
    /// On the current code the trip can never return: SqueekCoreReader.page rejects every live-shaped page.
    function testDreamTripReturnsAgainstLiveShapedCore() public {
        vm.prank(alice);
        uint256 id = game.hatch();
        vm.prank(alice);
        game.embark(id, 0); // rounds 2..7
        for (uint64 r; r < 7; ++r) core.append(0, 0, bytes32(0));
        Loot memory result = game.returnHome(id);
        assertEq(uint256(result.kind), uint256(Kind.Dream));
        assertFalse(game.expedition(id).away, "pet must be home again");
        assertEq(game.itemBalanceOf(id, result.itemId), 1, "exactly one item credited");
        vm.prank(alice);
        game.transferFrom(alice, address(0xB0B), id); // transfers unlock after a successful return
    }

    /// @dev A worked trip with active rounds must also return, with the trip's work and busiest round.
    function testTrailTripReturnsAgainstLiveShapedCore() public {
        vm.prank(alice);
        uint256 id = game.hatch();
        vm.prank(alice);
        game.embark(id, 0); // rounds 2..7
        core.append(0, 0, bytes32(0)); // round 1
        for (uint64 r = 2; r <= 7; ++r) core.append(r == 5 ? 600 : 10, 2e9, keccak256(abi.encode(r)));
        Loot memory result = game.returnHome(id);
        assertEq(uint256(result.kind), uint256(Kind.Trail));
        assertFalse(game.expedition(id).away);
    }

    /// @dev Mood must be readable (not "Signal lost") when state, config and pages all succeed.
    function testMoodIsNotSignalLostAgainstLiveShapedCore() public {
        for (uint64 r; r < 8; ++r) core.append(r == 3 ? 500 : 0, r == 3 ? 1e9 : 0, keccak256(abi.encode(r)));
        (, bool signalLost) = game.mood();
        assertFalse(signalLost, "mood must not report signal lost with a healthy core");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {Squeeklings} from "src/Squeeklings.sol";
import {SqueeklingsArt} from "src/SqueeklingsArt.sol";

/// @dev The core ABI actually deployed at the pinned Sepolia address 0xfd6c166d...:
/// roundPage(...) returns one dynamic struct, so its ABI encoding starts with a 0x20 offset
/// and is 320 bytes for a point read (not the 288-byte four-value tuple the repo declares).
contract StructPageCore {
    struct Point {
        uint64 cumulativeWork;
        uint96 cumulativeBlockUnits;
        uint32 auxiliary;
    }

    struct Round {
        uint64 roundId;
        uint64 cumulativeWork;
        uint96 cumulativeBlockUnits;
        uint32 auxiliary;
        bytes32 dataHash;
    }

    struct Page {
        uint64 certifiedThroughRound;
        Point start;
        Point end;
        Round[] rounds;
    }

    uint64 internal constant GENESIS = 1_000_000;
    uint64 public duration = 60;
    uint96 public unitsPerBlock = 1e9;
    uint64 public settled;
    uint64 public work;
    uint96 public units;
    mapping(uint64 => Point) private points;
    Round[] private active;

    function state() external view returns (uint64, uint64, uint96, uint64, uint96, uint32, uint256, bool) {
        return (settled, work, units, 0, 0, 0, 0, false);
    }

    function configuration()
        external
        view
        returns (bytes32, uint64, uint64, uint64, uint16, address, address, uint32, uint64, uint64, uint96)
    {
        return (keccak256("v3"), GENESIS, duration, 0, 0, address(this), address(this), 0, 0, 0, unitsPerBlock);
    }

    function append(uint64 addedWork, uint96 addedUnits, bytes32 h) external {
        require(addedWork > 0 || addedUnits == 0, "empty rounds have no units");
        ++settled;
        work += addedWork;
        units += addedUnits;
        points[settled] = Point(work, units, 0);
        if (addedWork > 0) active.push(Round(settled, work, units, 0, h));
    }

    /// @notice Same selector as ISqueekCoreV3.roundPage, but the deployed struct return encoding.
    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (Page memory page)
    {
        Point memory start = points[afterRound];
        if (maxRecords == 0) return Page(throughRound, start, points[throughRound], new Round[](0));
        Round[] memory tmp = new Round[](maxRecords);
        uint256 count;
        for (uint256 i; i < active.length; ++i) {
            if (active[i].roundId <= afterRound) continue;
            if (active[i].roundId > throughRound) break;
            if (count == maxRecords) {
                uint64 certified = active[i].roundId - 1;
                assembly ("memory-safe") {
                    mstore(tmp, count)
                }
                return Page(certified, start, points[certified], tmp);
            }
            tmp[count++] = active[i];
        }
        assembly ("memory-safe") {
            mstore(tmp, count)
        }
        return Page(throughRound, start, points[throughRound], tmp);
    }
}

contract RoundPageAbiProof is Test {
    function testReturnHomeWorksAgainstPinnedCoreAbi() public {
        vm.warp(1_000_000);
        StructPageCore core = new StructPageCore();
        SqueeklingsArt art = new SqueeklingsArt();
        Squeeklings game = new Squeeklings(address(core), address(art), address(this));

        address alice = address(0xA11CE);
        vm.prank(alice);
        uint256 id = game.hatch();

        vm.prank(alice);
        game.embark(id, 0); // current round 1 -> start 2, end 7

        for (uint64 r = 1; r <= 7; ++r) {
            core.append(100, 1e9, keccak256(abi.encode("round", r)));
        }

        vm.prank(alice);
        game.returnHome(id);

        uint256[17] memory counts = game.inventory(id);
        uint256 total;
        for (uint256 i; i < 17; ++i) {
            total += counts[i];
        }
        assertEq(total, 1, "one capsule must be credited");
        assertFalse(game.expedition(id).away, "trip must end");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {Squeeklings} from "src/Squeeklings.sol";
import {SqueeklingsArt} from "src/SqueeklingsArt.sol";
import {Loot, Kind} from "src/SqueekTypes.sol";

/// @notice Replays the exact returndata the pinned Sepolia SqueekCore V3
/// (0xfd6c166d4b8e2962e65746a13e5a0797cd4de0c4) produced at block 0xb86882 (12085378) for state(),
/// configuration() and the three roundPage reads a 6-round trip over rounds 559..564 needs.
/// Nothing is invented: every byte below is a captured eth_call result. roundPage returns are
/// 320 bytes and begin with the 0x20 offset word of a single dynamic struct, not the 288-byte
/// four-value tuple ISqueekCoreV3 declares.
contract LiveBytesCore {
    mapping(bytes32 => bytes) internal replies;

    function set(bytes memory input, bytes memory output) external {
        replies[keccak256(input)] = output;
    }

    fallback(bytes calldata input) external returns (bytes memory) {
        bytes memory out = replies[keccak256(input)];
        require(out.length != 0, "no captured reply for this call");
        return out;
    }
}

contract LiveBytesReturnHomeTest is Test {
    uint64 constant GENESIS = 1_793_735_400; // configuration().genesisTimestamp, live
    uint64 constant DURATION = 600; // configuration().roundDuration, live

    LiveBytesCore core;
    Squeeklings game;
    address alice = address(0xA11CE);

    function setUp() public {
        core = new LiveBytesCore();
        // state() at block 0xb86882: settledThroughRound 566, cumulativeWork 0x4879, units 0x1d180e7f6ef.
        core.set(
            abi.encodeWithSignature("state()"),
            hex"00000000000000000000000000000000000000000000000000000000000002360000000000000000000000000000000000000000000000000000000000004879000000000000000000000000000000000000000000000000000001d180e7f6ef00000000000000000000000000000000000000000000000000000000000007cf000000000000000000000000000000000000000000000000000000001338a0ef000000000000000000000000000000000000000000000000000000000000202e000000000000000000000000000000000000000000000000000000000000017d0000000000000000000000000000000000000000000000000000000000000000"
        );
        // configuration() at block 0xb86882: genesis 1793735400, duration 600, blockUnitsPerBlock 1e9.
        core.set(
            abi.encodeWithSignature("configuration()"),
            hex"a78faebd5aad38b4f90c7f61b9c5c10e8d9b9afe74ebfc2e82ca98b7e57ed562000000000000000000000000000000000000000000000000000000006aea3ae8000000000000000000000000000000000000000000000000000000000000025800000000000000000000000000000000000000000000000000000000000027100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000b2826926ef5cffebef86037c27b48ce345ed691f00000000000000000000000071f47c02431e6995cf6f757c14bc6bfa443d0a860000000000000000000000000000000000000000000000000000000000002a7b0000000000000000000000000000000000000000000000000000000000000028000000000000000000000000000000000000000000000000000000000000001e000000000000000000000000000000000000000000000000000000003b9aca00"
        );
        // roundPage(558, 558, 0): 320 bytes, word0 = 0x20, certified 558, start == end, no records.
        core.set(
            abi.encodeWithSignature("roundPage(uint64,uint64,uint256)", uint64(558), uint64(558), uint256(0)),
            hex"0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000022e0000000000000000000000000000000000000000000000000000000000004879000000000000000000000000000000000000000000000000000001d180e7f6ef000000000000000000000000000000000000000000000000000000000000202e0000000000000000000000000000000000000000000000000000000000004879000000000000000000000000000000000000000000000000000001d180e7f6ef000000000000000000000000000000000000000000000000000000000000202e00000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000"
        );
        // roundPage(564, 564, 0): 320 bytes, certified 564.
        core.set(
            abi.encodeWithSignature("roundPage(uint64,uint64,uint256)", uint64(564), uint64(564), uint256(0)),
            hex"000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002340000000000000000000000000000000000000000000000000000000000004879000000000000000000000000000000000000000000000000000001d180e7f6ef000000000000000000000000000000000000000000000000000000000000202e0000000000000000000000000000000000000000000000000000000000004879000000000000000000000000000000000000000000000000000001d180e7f6ef000000000000000000000000000000000000000000000000000000000000202e00000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000"
        );
        // roundPage(558, 564, 16): 320 bytes, certified 564, zero active records (idle window).
        core.set(
            abi.encodeWithSignature("roundPage(uint64,uint64,uint256)", uint64(558), uint64(564), uint256(16)),
            hex"000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002340000000000000000000000000000000000000000000000000000000000004879000000000000000000000000000000000000000000000000000001d180e7f6ef000000000000000000000000000000000000000000000000000000000000202e0000000000000000000000000000000000000000000000000000000000004879000000000000000000000000000000000000000000000000000001d180e7f6ef000000000000000000000000000000000000000000000000000000000000202e00000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000"
        );

        // currentRound() == 558 so that embark(id, 0) books rounds 559..564.
        vm.warp(uint256(GENESIS) + uint256(557) * DURATION);
        vm.roll(12_085_378);
        game = new Squeeklings(address(core), address(new SqueeklingsArt()), address(0xD00D));
    }

    /// @dev The live point read is accepted by the live core's own layout but rejected by the reader.
    function testCapturedPointReadIsStructEncoded() public view {
        (bool ok, bytes memory data) = address(core).staticcall(
            abi.encodeWithSignature("roundPage(uint64,uint64,uint256)", uint64(564), uint64(564), uint256(0))
        );
        assertTrue(ok);
        assertEq(data.length, 320, "live point read is 320 bytes, not 288");
        assertEq(abi.decode(data, (uint256)), 32, "live return begins with a struct offset word");
    }

    /// @dev hatch and embark succeed against the live bytes (state/config decode), but the settled trip
    /// can never return: history() rejects every live-shaped page and returnHome reverts InvalidHistory.
    function testSettledTripReturnsAgainstLiveBytes() public {
        vm.prank(alice);
        uint256 id = game.hatch();
        assertEq(game.currentRound(), 558);
        vm.prank(alice);
        game.embark(id, 0); // start 559, end 564; live settledThroughRound is 566 >= 564
        assertEq(game.expedition(id).endRound, 564);

        Loot memory result = game.returnHome(id);
        assertEq(uint8(result.kind), uint8(Kind.Dream), "idle window is a Dream trip");
        assertFalse(game.expedition(id).away, "pet must be home");
        assertEq(game.itemBalanceOf(id, result.itemId), 1, "one capsule credited");

        vm.prank(alice);
        game.transferFrom(alice, address(0xB0B), id); // transfers unlock after the return
        assertEq(game.ownerOf(id), address(0xB0B));
    }
}