# D.2b-B B-Wire — inventory wire layer Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Deliver the player's server-authoritative properties (so the burden bar reads the wire `EncumbranceVal`), fix two latent inbound-parse bugs, and add the missing inventory builders/parsers — completing the inventory wire layer so B-Drag and container-open are unblocked.

**Architecture:** All wire code is in `AcDream.Core.Net` (pure data, no GL). New pure parsers/builders/table-methods are TDD'd directly. The glue (WorldSession's GameMessage switch, ObjectTableWiring subscriptions, the GameEventWiring PD handler, GameWindow call sites) follows the codebase's existing convention: dispatcher-routed GameEvents are unit-tested through the `GameEventWiringTests` harness; top-level GameMessages (no test seam on `WorldSession`) are wired and verified by build + the parser tests + the live run.

**Tech Stack:** C# / .NET 10, xUnit, `System.Buffers.Binary.BinaryPrimitives`. Spec: `docs/superpowers/specs/2026-06-21-d2b-inventory-wire-design.md`. Oracle field orders: `docs/research/2026-06-16-inventory-deep-dive.md` §4 (ACE `file:line` + holtburger fixtures cited per format).

**Mandatory per-format workflow:** before porting each wire format, grep `docs/research/named-retail/acclient_2013_pseudo_c.txt` for the client symbol + confirm the field order against the cited ACE writer. The golden bytes in each test below are derived from those confirmed orders; if grep-named reveals a discrepancy, fix the one test + impl and note it.

**Opcodes (pinned against `references/ACE/.../GameMessageOpcode.cs` + `GameActionType.cs`):**
- `PrivateUpdatePropertyInt = 0x02CD` (top-level GameMessage, **no guid**)
- `SetStackSize = 0x0197` (top-level GameMessage, UIQueue)
- `InventoryRemoveObject = 0x0024` (top-level GameMessage, UIQueue)
- `ViewContents = 0x0196` (GameEvent, inside `0xF7B0`)
- C→S GameActions: `GetAndWieldItem = 0x001A`, `DropItem = 0x001B`, `NoLongerViewingContents = 0x0195`

> **Namespace caution:** `SetStackSize 0x0197` / `InventoryRemoveObject 0x0024` are **GameMessage** opcodes (WorldSession top-level switch, like `0x02CE`). `ViewContents 0x0196` is a **GameEvent** eventType (dispatcher path). Adjacent numbers, different dispatchers — don't cross them.

---

## Task 1: `ClientObjectTable.UpsertProperties` (Core)

The PD handler needs to apply the player's property bundle even if the player's `ClientObject` doesn't exist yet (PD may arrive before the player's `CreateObject`). `UpdateProperties` no-ops on an unknown object; add a create-if-absent variant.

**Files:**
- Modify: `src/AcDream.Core/Items/ClientObjectTable.cs` (add method after `UpdateProperties`, ~line 164)
- Test: `tests/AcDream.Core.Tests/Items/ClientObjectTableUpdateTests.cs` (create)

- [ ] **Step 1: Write the failing test**

Create `tests/AcDream.Core.Tests/Items/ClientObjectTableUpdateTests.cs`:

```csharp
using AcDream.Core.Items;
using Xunit;

namespace AcDream.Core.Tests.Items;

public sealed class ClientObjectTableUpdateTests
{
    [Fact]
    public void UpsertProperties_unknownObject_createsThenMerges()
    {
        var t = new ClientObjectTable();
        bool added = false;
        t.ObjectAdded += _ => added = true;

        var bundle = new PropertyBundle();
        bundle.Ints[5] = 1234;     // EncumbranceVal

        t.UpsertProperties(0x50000001u, bundle);

        var o = t.Get(0x50000001u);
        Assert.NotNull(o);
        Assert.Equal(1234, o!.Properties.Ints[5]);
        Assert.True(added);
    }

    [Fact]
    public void UpsertProperties_existingObject_mergesAndFiresUpdated()
    {
        var t = new ClientObjectTable();
        t.AddOrUpdate(new ClientObject { ObjectId = 0x50000001u });
        bool updated = false;
        t.ObjectUpdated += _ => updated = true;

        var bundle = new PropertyBundle();
        bundle.Ints[5] = 99;
        t.UpsertProperties(0x50000001u, bundle);

        Assert.Equal(99, t.Get(0x50000001u)!.Properties.Ints[5]);
        Assert.True(updated);
    }
}
```

- [ ] **Step 2: Run test to verify it fails**

Run: `dotnet test tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "FullyQualifiedName~ClientObjectTableUpdateTests"`
Expected: FAIL — compile error, `ClientObjectTable` has no `UpsertProperties`.

- [ ] **Step 3: Write minimal implementation**

In `src/AcDream.Core/Items/ClientObjectTable.cs`, immediately after the `UpdateProperties` method (the one ending at ~line 164), add:

```csharp
    /// <summary>
    /// Apply a <see cref="PropertyBundle"/> patch, creating the object if it does not
    /// exist yet. Used for the local player's own properties from PlayerDescription
    /// (0x0013), which may arrive BEFORE the player's CreateObject — unlike
    /// <see cref="UpdateProperties"/>, which no-ops on an unknown object. Fires
    /// ObjectAdded on create, else ObjectUpdated.
    /// </summary>
    public void UpsertProperties(uint guid, PropertyBundle incoming)
    {
        ArgumentNullException.ThrowIfNull(incoming);
        bool existed = _objects.TryGetValue(guid, out var item);
        if (!existed || item is null)
        {
            item = new ClientObject { ObjectId = guid };
            _objects[guid] = item;
        }
        foreach (var kv in incoming.Ints)        item.Properties.Ints[kv.Key] = kv.Value;
        foreach (var kv in incoming.Int64s)      item.Properties.Int64s[kv.Key] = kv.Value;
        foreach (var kv in incoming.Bools)       item.Properties.Bools[kv.Key] = kv.Value;
        foreach (var kv in incoming.Floats)      item.Properties.Floats[kv.Key] = kv.Value;
        foreach (var kv in incoming.Strings)     item.Properties.Strings[kv.Key] = kv.Value;
        foreach (var kv in incoming.DataIds)     item.Properties.DataIds[kv.Key] = kv.Value;
        foreach (var kv in incoming.InstanceIds) item.Properties.InstanceIds[kv.Key] = kv.Value;
        if (!existed) ObjectAdded?.Invoke(item); else ObjectUpdated?.Invoke(item);
    }
```

- [ ] **Step 4: Run test to verify it passes**

Run: `dotnet test tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "FullyQualifiedName~ClientObjectTableUpdateTests"`
Expected: PASS (2 tests).

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core/Items/ClientObjectTable.cs tests/AcDream.Core.Tests/Items/ClientObjectTableUpdateTests.cs
git commit -m "feat(core): D.2b-B B-Wire — ClientObjectTable.UpsertProperties (create-if-absent)"
```

---

## Task 2: `ClientObjectTable.UpdateStackSize` (Core)

`SetStackSize (0x0197)` updates a stack's count + value. Add the typed apply method (the parser + glue come later).

**Files:**
- Modify: `src/AcDream.Core/Items/ClientObjectTable.cs` (add after `UpdateIntProperty`, ~line 180)
- Test: `tests/AcDream.Core.Tests/Items/ClientObjectTableUpdateTests.cs` (append)

- [ ] **Step 1: Write the failing test**

Append to `ClientObjectTableUpdateTests.cs` (inside the class):

```csharp
    [Fact]
    public void UpdateStackSize_knownObject_setsFieldsAndFiresUpdated()
    {
        var t = new ClientObjectTable();
        t.AddOrUpdate(new ClientObject { ObjectId = 0x600u, StackSize = 1, Value = 5 });
        bool updated = false;
        t.ObjectUpdated += _ => updated = true;

        bool ok = t.UpdateStackSize(0x600u, stackSize: 25, value: 125);

        Assert.True(ok);
        Assert.Equal(25, t.Get(0x600u)!.StackSize);
        Assert.Equal(125, t.Get(0x600u)!.Value);
        Assert.True(updated);
    }

    [Fact]
    public void UpdateStackSize_unknownObject_returnsFalse()
        => Assert.False(new ClientObjectTable().UpdateStackSize(0xDEADu, 1, 1));
```

- [ ] **Step 2: Run test to verify it fails**

Run: `dotnet test tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "FullyQualifiedName~ClientObjectTableUpdateTests"`
Expected: FAIL — no `UpdateStackSize`.

- [ ] **Step 3: Write minimal implementation**

In `src/AcDream.Core/Items/ClientObjectTable.cs`, after `UpdateIntProperty` (~line 180), add:

```csharp
    /// <summary>
    /// Apply a SetStackSize (0x0197) update: set the object's StackSize + Value and
    /// fire ObjectUpdated so bound widgets refresh the quantity overlay. False if the
    /// object is unknown. Retail: ACCWeenieObject::ServerSaysSetStackSize (0x0058...).
    /// </summary>
    public bool UpdateStackSize(uint guid, int stackSize, int value)
    {
        if (!_objects.TryGetValue(guid, out var item)) return false;
        item.StackSize = stackSize;
        item.Value = value;
        ObjectUpdated?.Invoke(item);
        return true;
    }
```

- [ ] **Step 4: Run test to verify it passes**

Run: `dotnet test tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "FullyQualifiedName~ClientObjectTableUpdateTests"`
Expected: PASS (4 tests).

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core/Items/ClientObjectTable.cs tests/AcDream.Core.Tests/Items/ClientObjectTableUpdateTests.cs
git commit -m "feat(core): D.2b-B B-Wire — ClientObjectTable.UpdateStackSize"
```

---

## Task 3: `PrivateUpdatePropertyInt (0x02CD)` parser (Core.Net)

Live burden updates ride `0x02CD` — the player's own object, **no guid**. Mirror `PublicUpdatePropertyInt.cs`.

**Files:**
- Create: `src/AcDream.Core.Net/Messages/PrivateUpdatePropertyInt.cs`
- Test: `tests/AcDream.Core.Net.Tests/Messages/PrivateUpdatePropertyIntTests.cs`

- [ ] **Step 1: Write the failing test**

Create `tests/AcDream.Core.Net.Tests/Messages/PrivateUpdatePropertyIntTests.cs`:

```csharp
using System.Buffers.Binary;
using AcDream.Core.Net.Messages;
using Xunit;

namespace AcDream.Core.Net.Tests.Messages;

public sealed class PrivateUpdatePropertyIntTests
{
    // 0x02CD body: opcode(4) + seq(1) + property(4) + value(4) = 13 bytes. NO guid.
    private static byte[] Build(uint property, int value, byte seq = 1, uint opcode = 0x02CDu)
    {
        var b = new byte[13];
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(0), opcode);
        b[4] = seq;
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(5), property);
        BinaryPrimitives.WriteInt32LittleEndian(b.AsSpan(9), value);
        return b;
    }

    [Fact]
    public void TryParse_encumbranceVal_returnsPropValue()
    {
        var p = PrivateUpdatePropertyInt.TryParse(Build(property: 5u, value: 1500));
        Assert.NotNull(p);
        Assert.Equal(5u, p!.Value.Property);
        Assert.Equal(1500, p.Value.Value);
    }

    [Fact]
    public void TryParse_wrongOpcode_returnsNull()
        => Assert.Null(PrivateUpdatePropertyInt.TryParse(Build(5, 1, opcode: 0x02CEu)));

    [Fact]
    public void TryParse_truncated_returnsNull()
        => Assert.Null(PrivateUpdatePropertyInt.TryParse(new byte[12]));
}
```

- [ ] **Step 2: Run test to verify it fails**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~PrivateUpdatePropertyIntTests"`
Expected: FAIL — `PrivateUpdatePropertyInt` does not exist.

- [ ] **Step 3: Write minimal implementation**

Create `src/AcDream.Core.Net/Messages/PrivateUpdatePropertyInt.cs`:

```csharp
using System;
using System.Buffers.Binary;

namespace AcDream.Core.Net.Messages;

/// <summary>
/// Inbound <c>PrivateUpdatePropertyInt (0x02CD)</c> — the server updates one
/// <c>PropertyInt</c> on the player's OWN object. Unlike the sibling
/// <see cref="PublicUpdatePropertyInt"/> (0x02CE), this carries NO guid (it
/// implicitly targets the local player). Burden (<c>EncumbranceVal</c>, PropertyInt 5)
/// changes ride this opcode on every pick-up / drop.
///
/// <para>Wire layout (ACE <c>GameMessagePrivateUpdatePropertyInt</c>):</para>
/// <code>
///   u32 opcode = 0x02CD
///   u8  sequence    // single byte (ByteSequence) — not honored, latest-wins (DR-4)
///   u32 property    // PropertyInt enum
///   i32 value
/// </code>
/// </summary>
public static class PrivateUpdatePropertyInt
{
    public const uint Opcode = 0x02CDu;

    public readonly record struct Parsed(uint Property, int Value);

    /// <summary>Parse a raw 0x02CD body. Returns null on opcode mismatch / truncation.</summary>
    public static Parsed? TryParse(ReadOnlySpan<byte> body)
    {
        if (body.Length < 13) return null;          // 4 + 1 + 4 + 4
        if (BinaryPrimitives.ReadUInt32LittleEndian(body) != Opcode) return null;
        int pos = 4;
        pos += 1;                                   // sequence byte (not honored)
        uint prop = BinaryPrimitives.ReadUInt32LittleEndian(body[pos..]); pos += 4;
        int value = BinaryPrimitives.ReadInt32LittleEndian(body[pos..]);
        return new Parsed(prop, value);
    }
}
```

- [ ] **Step 4: Run test to verify it passes**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~PrivateUpdatePropertyIntTests"`
Expected: PASS (3 tests).

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core.Net/Messages/PrivateUpdatePropertyInt.cs tests/AcDream.Core.Net.Tests/Messages/PrivateUpdatePropertyIntTests.cs
git commit -m "feat(net): D.2b-B B-Wire — PrivateUpdatePropertyInt (0x02CD) parser"
```

---

## Task 4: `SetStackSize (0x0197)` parser (Core.Net)

Top-level GameMessage. Wire layout (ACE `GameMessageSetStackSize.cs`, size hint 17 ⇒ byte seq): `opcode(4) + u8 seq + guid(4) + stackSize(4) + value(4)`.

**Files:**
- Create: `src/AcDream.Core.Net/Messages/SetStackSize.cs`
- Test: `tests/AcDream.Core.Net.Tests/Messages/SetStackSizeTests.cs`

- [ ] **Step 1: Write the failing test**

Create `tests/AcDream.Core.Net.Tests/Messages/SetStackSizeTests.cs`:

```csharp
using System.Buffers.Binary;
using AcDream.Core.Net.Messages;
using Xunit;

namespace AcDream.Core.Net.Tests.Messages;

public sealed class SetStackSizeTests
{
    private static byte[] Build(uint guid, int stackSize, int value, byte seq = 1, uint opcode = 0x0197u)
    {
        var b = new byte[17];
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(0), opcode);
        b[4] = seq;
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(5), guid);
        BinaryPrimitives.WriteInt32LittleEndian(b.AsSpan(9), stackSize);
        BinaryPrimitives.WriteInt32LittleEndian(b.AsSpan(13), value);
        return b;
    }

    [Fact]
    public void TryParse_validStack_returnsGuidStackValue()
    {
        var p = SetStackSize.TryParse(Build(0x50000A01u, stackSize: 25, value: 125));
        Assert.NotNull(p);
        Assert.Equal(0x50000A01u, p!.Value.Guid);
        Assert.Equal(25, p.Value.StackSize);
        Assert.Equal(125, p.Value.Value);
    }

    [Fact]
    public void TryParse_wrongOpcode_returnsNull()
        => Assert.Null(SetStackSize.TryParse(Build(1, 1, 1, opcode: 0x0196u)));

    [Fact]
    public void TryParse_truncated_returnsNull()
        => Assert.Null(SetStackSize.TryParse(new byte[16]));
}
```

- [ ] **Step 2: Run test to verify it fails**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~SetStackSizeTests"`
Expected: FAIL — `SetStackSize` does not exist.

- [ ] **Step 3: Write minimal implementation**

Create `src/AcDream.Core.Net/Messages/SetStackSize.cs`:

```csharp
using System;
using System.Buffers.Binary;

namespace AcDream.Core.Net.Messages;

/// <summary>
/// Inbound <c>SetStackSize (0x0197)</c> — a top-level GameMessage (UIQueue group),
/// NOT a GameEvent. The server updates a stack's count + value after a merge / split.
/// Client consumer: ACCWeenieObject::ServerSaysSetStackSize.
///
/// <para>Wire layout (ACE <c>GameMessageSetStackSize.cs</c>, size hint 17):</para>
/// <code>
///   u32 opcode = 0x0197
///   u8  sequence    // ByteSequence (UpdatePropertyInt) — not honored
///   u32 guid
///   i32 stackSize
///   i32 value
/// </code>
/// </summary>
public static class SetStackSize
{
    public const uint Opcode = 0x0197u;

    public readonly record struct Parsed(uint Guid, int StackSize, int Value);

    /// <summary>Parse a raw 0x0197 body. Returns null on opcode mismatch / truncation.</summary>
    public static Parsed? TryParse(ReadOnlySpan<byte> body)
    {
        if (body.Length < 17) return null;          // 4 + 1 + 4 + 4 + 4
        if (BinaryPrimitives.ReadUInt32LittleEndian(body) != Opcode) return null;
        int pos = 4;
        pos += 1;                                   // sequence byte (not honored)
        uint guid = BinaryPrimitives.ReadUInt32LittleEndian(body[pos..]); pos += 4;
        int stack = BinaryPrimitives.ReadInt32LittleEndian(body[pos..]); pos += 4;
        int value = BinaryPrimitives.ReadInt32LittleEndian(body[pos..]);
        return new Parsed(guid, stack, value);
    }
}
```

- [ ] **Step 4: Run test to verify it passes**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~SetStackSizeTests"`
Expected: PASS (3 tests).

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core.Net/Messages/SetStackSize.cs tests/AcDream.Core.Net.Tests/Messages/SetStackSizeTests.cs
git commit -m "feat(net): D.2b-B B-Wire — SetStackSize (0x0197) parser"
```

---

## Task 5: `InventoryRemoveObject (0x0024)` parser (Core.Net)

Top-level GameMessage. Wire layout (ACE `GameMessageInventoryRemoveObject.cs`, size hint 8): `opcode(4) + guid(4)`.

**Files:**
- Create: `src/AcDream.Core.Net/Messages/InventoryRemoveObject.cs`
- Test: `tests/AcDream.Core.Net.Tests/Messages/InventoryRemoveObjectTests.cs`

- [ ] **Step 1: Write the failing test**

Create `tests/AcDream.Core.Net.Tests/Messages/InventoryRemoveObjectTests.cs`:

```csharp
using System.Buffers.Binary;
using AcDream.Core.Net.Messages;
using Xunit;

namespace AcDream.Core.Net.Tests.Messages;

public sealed class InventoryRemoveObjectTests
{
    private static byte[] Build(uint guid, uint opcode = 0x0024u)
    {
        var b = new byte[8];
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(0), opcode);
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(4), guid);
        return b;
    }

    [Fact]
    public void TryParse_valid_returnsGuid()
    {
        var p = InventoryRemoveObject.TryParse(Build(0x50000A07u));
        Assert.NotNull(p);
        Assert.Equal(0x50000A07u, p!.Value.Guid);
    }

    [Fact]
    public void TryParse_wrongOpcode_returnsNull()
        => Assert.Null(InventoryRemoveObject.TryParse(Build(1, opcode: 0x0023u)));

    [Fact]
    public void TryParse_truncated_returnsNull()
        => Assert.Null(InventoryRemoveObject.TryParse(new byte[7]));
}
```

- [ ] **Step 2: Run test to verify it fails**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~InventoryRemoveObjectTests"`
Expected: FAIL — `InventoryRemoveObject` does not exist.

- [ ] **Step 3: Write minimal implementation**

Create `src/AcDream.Core.Net/Messages/InventoryRemoveObject.cs`:

```csharp
using System;
using System.Buffers.Binary;

namespace AcDream.Core.Net.Messages;

/// <summary>
/// Inbound <c>InventoryRemoveObject (0x0024)</c> — a top-level GameMessage (UIQueue),
/// NOT a GameEvent. The server tells the client an object left its inventory view
/// (given away / sold / destroyed). The client drops it from object maintenance.
///
/// <para>Wire layout (ACE <c>GameMessageInventoryRemoveObject.cs</c>, size hint 8):</para>
/// <code>
///   u32 opcode = 0x0024
///   u32 guid
/// </code>
/// </summary>
public static class InventoryRemoveObject
{
    public const uint Opcode = 0x0024u;

    public readonly record struct Parsed(uint Guid);

    /// <summary>Parse a raw 0x0024 body. Returns null on opcode mismatch / truncation.</summary>
    public static Parsed? TryParse(ReadOnlySpan<byte> body)
    {
        if (body.Length < 8) return null;           // 4 + 4
        if (BinaryPrimitives.ReadUInt32LittleEndian(body) != Opcode) return null;
        uint guid = BinaryPrimitives.ReadUInt32LittleEndian(body[4..]);
        return new Parsed(guid);
    }
}
```

- [ ] **Step 4: Run test to verify it passes**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~InventoryRemoveObjectTests"`
Expected: PASS (3 tests).

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core.Net/Messages/InventoryRemoveObject.cs tests/AcDream.Core.Net.Tests/Messages/InventoryRemoveObjectTests.cs
git commit -m "feat(net): D.2b-B B-Wire — InventoryRemoveObject (0x0024) parser"
```

---

## Task 6: `GameEvents.ParseViewContents (0x0196)` (Core.Net)

GameEvent (payload = envelope stripped). Layout (ACE `GameEventViewContents.cs`): `containerGuid(4), count(4), [guid(4), containerType(4)] × count`.

**Files:**
- Modify: `src/AcDream.Core.Net/Messages/GameEvents.cs` (add near `ParsePutObjInContainer`, ~line 359)
- Test: `tests/AcDream.Core.Net.Tests/Messages/GameEventsInventoryTests.cs` (create)

- [ ] **Step 1: Write the failing test**

Create `tests/AcDream.Core.Net.Tests/Messages/GameEventsInventoryTests.cs`:

```csharp
using System.Buffers.Binary;
using AcDream.Core.Net.Messages;
using Xunit;

namespace AcDream.Core.Net.Tests.Messages;

public sealed class GameEventsInventoryTests
{
    [Fact]
    public void ParseViewContents_twoEntries_returnsContainerAndItems()
    {
        // containerGuid + count(2) + 2×{guid, containerType}
        var b = new byte[4 + 4 + 2 * 8];
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(0), 0x500000C9u); // containerGuid
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(4), 2u);          // count
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(8), 0x50000A01u); // guid 1
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(12), 0u);         // type 1 (item)
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(16), 0x50000A02u);// guid 2
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(20), 1u);         // type 2 (container)

        var p = GameEvents.ParseViewContents(b);
        Assert.NotNull(p);
        Assert.Equal(0x500000C9u, p!.Value.ContainerGuid);
        Assert.Equal(2, p.Value.Items.Count);
        Assert.Equal(0x50000A01u, p.Value.Items[0].Guid);
        Assert.Equal(0u, p.Value.Items[0].ContainerType);
        Assert.Equal(0x50000A02u, p.Value.Items[1].Guid);
        Assert.Equal(1u, p.Value.Items[1].ContainerType);
    }

    [Fact]
    public void ParseViewContents_zeroCount_returnsEmptyList()
    {
        var b = new byte[8];
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(0), 0x500000C9u);
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(4), 0u);
        var p = GameEvents.ParseViewContents(b);
        Assert.NotNull(p);
        Assert.Empty(p!.Value.Items);
    }

    [Fact]
    public void ParseViewContents_truncated_returnsNull()
        => Assert.Null(GameEvents.ParseViewContents(new byte[4]));
}
```

- [ ] **Step 2: Run test to verify it fails**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~GameEventsInventoryTests.ParseViewContents"`
Expected: FAIL — no `ParseViewContents` / no `ViewContents` record.

- [ ] **Step 3: Write minimal implementation**

In `src/AcDream.Core.Net/Messages/GameEvents.cs`, after `ParsePutObjInContainer` (~line 359), add:

```csharp
    /// <summary>0x0196 ViewContents: full contents list of a container you opened.
    /// Layout (ACE GameEventViewContents.cs): containerGuid, count, [guid, containerType]×count.
    /// Client consumer: ClientUISystem::OnViewContents (PackableList&lt;ContentProfile&gt;).</summary>
    public readonly record struct ViewContentsEntry(uint Guid, uint ContainerType);
    public readonly record struct ViewContents(uint ContainerGuid, System.Collections.Generic.IReadOnlyList<ViewContentsEntry> Items);

    public static ViewContents? ParseViewContents(ReadOnlySpan<byte> payload)
    {
        if (payload.Length < 8) return null;
        uint containerGuid = BinaryPrimitives.ReadUInt32LittleEndian(payload);
        uint count = BinaryPrimitives.ReadUInt32LittleEndian(payload.Slice(4));
        int pos = 8;
        if ((long)payload.Length - pos < (long)count * 8) return null;
        var items = new ViewContentsEntry[count];
        for (int i = 0; i < count; i++)
        {
            uint guid = BinaryPrimitives.ReadUInt32LittleEndian(payload.Slice(pos)); pos += 4;
            uint type = BinaryPrimitives.ReadUInt32LittleEndian(payload.Slice(pos)); pos += 4;
            items[i] = new ViewContentsEntry(guid, type);
        }
        return new ViewContents(containerGuid, items);
    }
```

- [ ] **Step 4: Run test to verify it passes**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~GameEventsInventoryTests.ParseViewContents"`
Expected: PASS (3 tests).

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core.Net/Messages/GameEvents.cs tests/AcDream.Core.Net.Tests/Messages/GameEventsInventoryTests.cs
git commit -m "feat(net): D.2b-B B-Wire — ParseViewContents (0x0196)"
```

---

## Task 7: Fix `ParsePutObjInContainer` 4th field (Core.Net)

`0x0022` carries a 4th `containerType` u32 that the current parser drops.

**Files:**
- Modify: `src/AcDream.Core.Net/Messages/GameEvents.cs` (the `InventoryPutObjInContainer` record + `ParsePutObjInContainer`, ~lines 346-359)
- Test: `tests/AcDream.Core.Net.Tests/Messages/GameEventsInventoryTests.cs` (append)

- [ ] **Step 1: Write the failing test**

Append to `GameEventsInventoryTests.cs` (inside the class):

```csharp
    [Fact]
    public void ParsePutObjInContainer_readsAllFourFields()
    {
        var b = new byte[16];
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(0), 0x50000A01u); // itemGuid
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(4), 0x500000C9u); // containerGuid
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(8), 3u);          // placement
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(12), 1u);         // containerType

        var p = GameEvents.ParsePutObjInContainer(b);
        Assert.NotNull(p);
        Assert.Equal(0x50000A01u, p!.Value.ItemGuid);
        Assert.Equal(0x500000C9u, p.Value.ContainerGuid);
        Assert.Equal(3u, p.Value.Placement);
        Assert.Equal(1u, p.Value.ContainerType);
    }
```

- [ ] **Step 2: Run test to verify it fails**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~GameEventsInventoryTests.ParsePutObjInContainer"`
Expected: FAIL — `InventoryPutObjInContainer` record has no `ContainerType`.

- [ ] **Step 3: Write minimal implementation**

In `src/AcDream.Core.Net/Messages/GameEvents.cs`, replace the `InventoryPutObjInContainer` record + parser (~lines 346-359) with:

```csharp
    /// <summary>0x0022 InventoryPutObjInContainer: server puts item into container slot.
    /// 4 fields (ACE GameEventItemServerSaysContainId.cs): itemGuid, containerGuid,
    /// placement, containerType. ContainerType (0=item,1=container,2=foci) confirmed
    /// vs holtburger events.rs fixture (slot=3 type=1).</summary>
    public readonly record struct InventoryPutObjInContainer(
        uint ItemGuid,
        uint ContainerGuid,
        uint Placement,
        uint ContainerType);

    public static InventoryPutObjInContainer? ParsePutObjInContainer(ReadOnlySpan<byte> payload)
    {
        if (payload.Length < 16) return null;
        return new InventoryPutObjInContainer(
            BinaryPrimitives.ReadUInt32LittleEndian(payload),
            BinaryPrimitives.ReadUInt32LittleEndian(payload.Slice(4)),
            BinaryPrimitives.ReadUInt32LittleEndian(payload.Slice(8)),
            BinaryPrimitives.ReadUInt32LittleEndian(payload.Slice(12)));
    }
```

(The `GameEventWiring` caller at ~line 246 uses `.ItemGuid`/`.ContainerGuid`/`.Placement` — unaffected by the added field.)

- [ ] **Step 4: Run test to verify it passes**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~GameEventsInventoryTests.ParsePutObjInContainer"`
Expected: PASS.

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core.Net/Messages/GameEvents.cs tests/AcDream.Core.Net.Tests/Messages/GameEventsInventoryTests.cs
git commit -m "fix(net): D.2b-B B-Wire — ParsePutObjInContainer reads containerType (4th field)"
```

---

## Task 8: Fix `ParseInventoryServerSaveFailed` to read the error (Core.Net)

`0x00A0` carries `itemGuid, weenieError`; the current parser returns only the guid. Change to a record. (Parser is currently unwired — no caller breaks.)

**Files:**
- Modify: `src/AcDream.Core.Net/Messages/GameEvents.cs` (`ParseInventoryServerSaveFailed`, ~line 377)
- Test: `tests/AcDream.Core.Net.Tests/Messages/GameEventsInventoryTests.cs` (append)

- [ ] **Step 1: Write the failing test**

Append to `GameEventsInventoryTests.cs`:

```csharp
    [Fact]
    public void ParseInventoryServerSaveFailed_readsGuidAndError()
    {
        var b = new byte[8];
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(0), 0x50000A01u); // itemGuid
        BinaryPrimitives.WriteUInt32LittleEndian(b.AsSpan(4), 0x0Au);       // weenieError

        var p = GameEvents.ParseInventoryServerSaveFailed(b);
        Assert.NotNull(p);
        Assert.Equal(0x50000A01u, p!.Value.ItemGuid);
        Assert.Equal(0x0Au, p.Value.WeenieError);
    }
```

- [ ] **Step 2: Run test to verify it fails**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~GameEventsInventoryTests.ParseInventoryServerSaveFailed"`
Expected: FAIL — current return type is `uint?`, has no `.ItemGuid`/`.WeenieError`.

- [ ] **Step 3: Write minimal implementation**

In `src/AcDream.Core.Net/Messages/GameEvents.cs`, replace `ParseInventoryServerSaveFailed` (~line 377) with:

```csharp
    /// <summary>0x00A0 InventoryServerSaveFailed: revert a speculative local inventory op.
    /// (itemGuid, weenieError) — ACE GameEventInventoryServerSaveFailed.cs; holtburger
    /// events.rs:147 reads both fields.</summary>
    public readonly record struct InventoryServerSaveFailed(uint ItemGuid, uint WeenieError);

    public static InventoryServerSaveFailed? ParseInventoryServerSaveFailed(ReadOnlySpan<byte> payload)
    {
        if (payload.Length < 8) return null;
        return new InventoryServerSaveFailed(
            BinaryPrimitives.ReadUInt32LittleEndian(payload),
            BinaryPrimitives.ReadUInt32LittleEndian(payload.Slice(4)));
    }
```

- [ ] **Step 4: Run test to verify it passes**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~GameEventsInventoryTests.ParseInventoryServerSaveFailed"`
Expected: PASS.

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core.Net/Messages/GameEvents.cs tests/AcDream.Core.Net.Tests/Messages/GameEventsInventoryTests.cs
git commit -m "fix(net): D.2b-B B-Wire — ParseInventoryServerSaveFailed reads weenieError"
```

---

## Task 9: New C→S builders + `WorldSession.Send*` wrappers (Core.Net)

`DropItem 0x001B` (`itemGuid`), `GetAndWieldItem 0x001A` (`itemGuid, equipMask`), `NoLongerViewingContents 0x0195` (`containerGuid`). All ride the `0xF7B1` GameAction envelope.

**Files:**
- Modify: `src/AcDream.Core.Net/Messages/InventoryActions.cs` (add opcodes + 3 builders)
- Modify: `src/AcDream.Core.Net/WorldSession.cs` (add 3 `Send*` wrappers after `SendRemoveShortcut`, ~line 1157)
- Test: `tests/AcDream.Core.Net.Tests/Messages/InventoryActionsTests.cs` (append)

- [ ] **Step 1: Write the failing test**

Append to `tests/AcDream.Core.Net.Tests/Messages/InventoryActionsTests.cs` (inside the existing class):

```csharp
    [Fact]
    public void BuildDropItem_layout()
    {
        byte[] b = InventoryActions.BuildDropItem(seq: 7, itemGuid: 0x50000A01u);
        Assert.Equal(16, b.Length);
        Assert.Equal(0xF7B1u, BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(0)));
        Assert.Equal(7u,      BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(4)));
        Assert.Equal(0x001Bu, BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(8)));
        Assert.Equal(0x50000A01u, BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(12)));
    }

    [Fact]
    public void BuildGetAndWieldItem_layout()
    {
        byte[] b = InventoryActions.BuildGetAndWieldItem(seq: 7, itemGuid: 0x50000A01u, equipMask: 0x02u);
        Assert.Equal(20, b.Length);
        Assert.Equal(0xF7B1u, BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(0)));
        Assert.Equal(7u,      BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(4)));
        Assert.Equal(0x001Au, BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(8)));
        Assert.Equal(0x50000A01u, BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(12)));
        Assert.Equal(0x02u,   BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(16)));
    }

    [Fact]
    public void BuildNoLongerViewingContents_layout()
    {
        byte[] b = InventoryActions.BuildNoLongerViewingContents(seq: 7, containerGuid: 0x500000C9u);
        Assert.Equal(16, b.Length);
        Assert.Equal(0xF7B1u, BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(0)));
        Assert.Equal(7u,      BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(4)));
        Assert.Equal(0x0195u, BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(8)));
        Assert.Equal(0x500000C9u, BinaryPrimitives.ReadUInt32LittleEndian(b.AsSpan(12)));
    }
```

(If `InventoryActionsTests.cs` lacks `using System.Buffers.Binary;`, add it.)

- [ ] **Step 2: Run test to verify it fails**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~InventoryActionsTests.Build"`
Expected: FAIL — builders don't exist.

- [ ] **Step 3: Write minimal implementation**

In `src/AcDream.Core.Net/Messages/InventoryActions.cs`, add the opcode constants (after `TeleToPoiOpcode`, ~line 24):

```csharp
    public const uint GetAndWieldItemOpcode         = 0x001Au;
    public const uint DropItemOpcode                = 0x001Bu;
    public const uint NoLongerViewingContentsOpcode = 0x0195u;
```

And add the three builders (before the closing brace of the class):

```csharp
    /// <summary>Drop an item on the ground. ACE GameActionDropItem.Handle reads 1 u32.</summary>
    public static byte[] BuildDropItem(uint seq, uint itemGuid)
    {
        byte[] body = new byte[16];
        BinaryPrimitives.WriteUInt32LittleEndian(body,            GameActionEnvelope);
        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(4),  seq);
        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(8),  DropItemOpcode);
        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(12), itemGuid);
        return body;
    }

    /// <summary>Equip an item from inventory onto the doll. holtburger actions.rs
    /// GetAndWieldItemActionData = (itemGuid, equipMask).</summary>
    public static byte[] BuildGetAndWieldItem(uint seq, uint itemGuid, uint equipMask)
    {
        byte[] body = new byte[20];
        BinaryPrimitives.WriteUInt32LittleEndian(body,            GameActionEnvelope);
        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(4),  seq);
        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(8),  GetAndWieldItemOpcode);
        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(12), itemGuid);
        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(16), equipMask);
        return body;
    }

    /// <summary>Close a side-pack / ground-container view. holtburger actions.rs = (containerGuid).</summary>
    public static byte[] BuildNoLongerViewingContents(uint seq, uint containerGuid)
    {
        byte[] body = new byte[16];
        BinaryPrimitives.WriteUInt32LittleEndian(body,            GameActionEnvelope);
        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(4),  seq);
        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(8),  NoLongerViewingContentsOpcode);
        BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(12), containerGuid);
        return body;
    }
```

In `src/AcDream.Core.Net/WorldSession.cs`, after `SendRemoveShortcut` (~line 1157), add:

```csharp
    /// <summary>Send DropItem (0x001B) — drop an item on the ground.</summary>
    public void SendDropItem(uint itemGuid)
    {
        uint seq = NextGameActionSequence();
        SendGameAction(InventoryActions.BuildDropItem(seq, itemGuid));
    }

    /// <summary>Send GetAndWieldItem (0x001A) — equip an item to an equip slot.</summary>
    public void SendGetAndWieldItem(uint itemGuid, uint equipMask)
    {
        uint seq = NextGameActionSequence();
        SendGameAction(InventoryActions.BuildGetAndWieldItem(seq, itemGuid, equipMask));
    }

    /// <summary>Send NoLongerViewingContents (0x0195) — close a container view.</summary>
    public void SendNoLongerViewingContents(uint containerGuid)
    {
        uint seq = NextGameActionSequence();
        SendGameAction(InventoryActions.BuildNoLongerViewingContents(seq, containerGuid));
    }
```

- [ ] **Step 4: Run test to verify it passes**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~InventoryActionsTests.Build"`
Expected: PASS (3 new tests).

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core.Net/Messages/InventoryActions.cs src/AcDream.Core.Net/WorldSession.cs tests/AcDream.Core.Net.Tests/Messages/InventoryActionsTests.cs
git commit -m "feat(net): D.2b-B B-Wire — DropItem/GetAndWieldItem/NoLongerViewingContents builders + Send wrappers"
```

---

## Task 10: Login PD player-property delivery (Core.Net)

`GameEventWiring.WireAll` gains an optional `Func<uint>? playerGuid`; the PD handler upserts the player's parsed `PropertyBundle` into the player `ClientObject`. TDD via the dispatcher harness.

**Files:**
- Modify: `src/AcDream.Core.Net/GameEventWiring.cs` (add param ~line 68; add upsert in the PD handler ~line 408)
- Test: `tests/AcDream.Core.Net.Tests/GameEventWiringTests.cs` (append)

- [ ] **Step 1: Write the failing test**

Append to `GameEventWiringTests.cs` (inside the class):

```csharp
    [Fact]
    public void WireAll_PlayerDescription_UpsertsPlayerPropertiesIntoClientObject()
    {
        // PD with a PropertyInt32 table carrying EncumbranceVal(5)=1500. The handler
        // must land it in the player ClientObject so the burden bar reads the wire value.
        const uint playerGuid = 0x50000001u;
        var dispatcher = new GameEventDispatcher();
        var items = new ClientObjectTable();
        GameEventWiring.WireAll(dispatcher, items, new CombatState(), new Spellbook(),
            new ChatLog(), playerGuid: () => playerGuid);

        var sb = new MemoryStream();
        using var w = new BinaryWriter(sb);
        w.Write(0x00000001u); // propertyFlags = PropertyInt32
        w.Write(0x52u);       // weenieType
        // int table: u16 count, u16 buckets, then key/val pairs
        w.Write((ushort)1);   // count
        w.Write((ushort)8);   // buckets (ignored)
        w.Write(5u);          // key = EncumbranceVal
        w.Write(1500u);       // val
        // vector + has_health (no vector blocks)
        w.Write(0u);          // vectorFlags = None
        w.Write(0u);          // has_health
        // strict trailer
        w.Write(0u);          // option_flags = None
        w.Write(0u);          // options1
        w.Write(0u);          // legacy hotbar count
        w.Write(0u);          // spellbook_filters
        w.Write(0u);          // inventory count
        w.Write(0u);          // equipped count

        var env = GameEventEnvelope.TryParse(WrapEnvelope(GameEventType.PlayerDescription, sb.ToArray()));
        dispatcher.Dispatch(env!.Value);

        var player = items.Get(playerGuid);
        Assert.NotNull(player);
        Assert.Equal(1500, player!.Properties.Ints[5]);
    }
```

- [ ] **Step 2: Run test to verify it fails**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~GameEventWiringTests.WireAll_PlayerDescription_UpsertsPlayerProperties"`
Expected: FAIL — `WireAll` has no `playerGuid` parameter.

- [ ] **Step 3: Write minimal implementation**

In `src/AcDream.Core.Net/GameEventWiring.cs`, add a new optional parameter at the END of the `WireAll` parameter list (after `onShortcuts`, ~line 68):

```csharp
        Action<IReadOnlyList<PlayerDescriptionParser.ShortcutEntry>>? onShortcuts = null,
        // B-Wire: the local player's server guid. When provided, the PD handler upserts
        // the player's own PropertyBundle (EncumbranceVal etc.) into the player ClientObject.
        Func<uint>? playerGuid = null)
```

In the PD handler, immediately after the `if (p is null) return;` guard (~line 290), add:

```csharp
            // B-Wire: deliver the player's OWN properties to the player ClientObject.
            // (PD's "membership manifest" rule is about ITEMS, whose data comes from
            // CreateObject; the player's own stats legitimately come from PD.) Upsert
            // because PD can arrive before the player's CreateObject. Retires AP-48/AP-49.
            if (playerGuid is not null)
                items.UpsertProperties(playerGuid(), p.Value.Properties);
```

- [ ] **Step 4: Run test to verify it passes**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~GameEventWiringTests"`
Expected: PASS (all GameEventWiring tests, including the new one).

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core.Net/GameEventWiring.cs tests/AcDream.Core.Net.Tests/GameEventWiringTests.cs
git commit -m "feat(net): D.2b-B B-Wire — PlayerDescription delivers player properties to ClientObject"
```

---

## Task 11: Register ViewContents (membership) + unwired inventory GameEvents (Core.Net)

Register `ViewContents` (apply membership — testable), and the existing-but-unwired `InventoryPutObjectIn3D (0x019A)` (unparent to world), `InventoryServerSaveFailed (0x00A0)` (log), `CloseGroundContainer (0x0052)` (log).

**Files:**
- Modify: `src/AcDream.Core.Net/GameEventWiring.cs` (add registrations after the `InventoryPutObjInContainer` registration, ~line 248)
- Test: `tests/AcDream.Core.Net.Tests/GameEventWiringTests.cs` (append)

- [ ] **Step 1: Write the failing test**

Append to `GameEventWiringTests.cs`:

```csharp
    [Fact]
    public void WireAll_ViewContents_RecordsMembershipInClientObjectTable()
    {
        var (d, items, _, _, _) = MakeAll();

        // containerGuid 0xC9 + 2 entries
        byte[] payload = new byte[8 + 2 * 8];
        BinaryPrimitives.WriteUInt32LittleEndian(payload.AsSpan(0), 0x500000C9u);
        BinaryPrimitives.WriteUInt32LittleEndian(payload.AsSpan(4), 2u);
        BinaryPrimitives.WriteUInt32LittleEndian(payload.AsSpan(8), 0x50000A01u);
        BinaryPrimitives.WriteUInt32LittleEndian(payload.AsSpan(12), 0u);
        BinaryPrimitives.WriteUInt32LittleEndian(payload.AsSpan(16), 0x50000A02u);
        BinaryPrimitives.WriteUInt32LittleEndian(payload.AsSpan(20), 1u);

        var env = GameEventEnvelope.TryParse(WrapEnvelope(GameEventType.ViewContents, payload));
        d.Dispatch(env!.Value);

        Assert.Equal(0x500000C9u, items.Get(0x50000A01u)!.ContainerId);
        Assert.Equal(0x500000C9u, items.Get(0x50000A02u)!.ContainerId);
    }

    [Fact]
    public void WireAll_InventoryPutObjectIn3D_UnparentsFromContainer()
    {
        var (d, items, _, _, _) = MakeAll();
        items.RecordMembership(0x50000A01u, containerId: 0x500000C9u);

        byte[] payload = new byte[4];
        BinaryPrimitives.WriteUInt32LittleEndian(payload, 0x50000A01u);
        var env = GameEventEnvelope.TryParse(WrapEnvelope(GameEventType.InventoryPutObjectIn3D, payload));
        d.Dispatch(env!.Value);

        Assert.Equal(0u, items.Get(0x50000A01u)!.ContainerId);
    }
```

- [ ] **Step 2: Run test to verify it fails**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~GameEventWiringTests.WireAll_ViewContents|FullyQualifiedName~GameEventWiringTests.WireAll_InventoryPutObjectIn3D"`
Expected: FAIL — these events aren't registered, so nothing changes (the `Get` returns null / ContainerId unchanged).

- [ ] **Step 3: Write minimal implementation**

In `src/AcDream.Core.Net/GameEventWiring.cs`, after the `InventoryPutObjInContainer` registration block (the one ending ~line 248), add:

```csharp
        // B-Wire: ViewContents (0x0196) — the server's full contents list for a
        // container you opened. Record membership for each entry so the table is
        // correct before the container-open UI mounts the second item list.
        dispatcher.Register(GameEventType.ViewContents, e =>
        {
            var p = GameEvents.ParseViewContents(e.Payload.Span);
            if (p is null) return;
            foreach (var entry in p.Value.Items)
                items.RecordMembership(entry.Guid, containerId: p.Value.ContainerGuid);
        });

        // B-Wire: InventoryPutObjectIn3D (0x019A) — server confirms an item dropped
        // to the world. Unparent it from its container (it's now a ground object) so
        // the inventory grid drops the cell; the object itself survives.
        dispatcher.Register(GameEventType.InventoryPutObjectIn3D, e =>
        {
            var guid = GameEvents.ParsePutObjectIn3D(e.Payload.Span);
            if (guid is not null) items.MoveItem(guid.Value, newContainerId: 0u);
        });

        // B-Wire: InventoryServerSaveFailed (0x00A0) — rollback of a speculative move.
        // acdream does not do speculative moves yet (read-only inventory); parse + log
        // so the wire is correct. B-Drag wires the rollback behavior. (Divergence note.)
        dispatcher.Register(GameEventType.InventoryServerSaveFailed, e =>
        {
            var p = GameEvents.ParseInventoryServerSaveFailed(e.Payload.Span);
            if (p is not null)
                Console.WriteLine($"[B-Wire] InventoryServerSaveFailed guid=0x{p.Value.ItemGuid:X8} err=0x{p.Value.WeenieError:X}");
        });

        // B-Wire: CloseGroundContainer (0x0052) — server closed a ground-container
        // view. No table change (the view is UI-only, wired in container-open); log.
        dispatcher.Register(GameEventType.CloseGroundContainer, e =>
        {
            var guid = GameEvents.ParseCloseGroundContainer(e.Payload.Span);
            if (guid is not null)
                Console.WriteLine($"[B-Wire] CloseGroundContainer guid=0x{guid.Value:X8}");
        });
```

- [ ] **Step 4: Run test to verify it passes**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj --filter "FullyQualifiedName~GameEventWiringTests"`
Expected: PASS (all GameEventWiring tests).

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core.Net/GameEventWiring.cs tests/AcDream.Core.Net.Tests/GameEventWiringTests.cs
git commit -m "feat(net): D.2b-B B-Wire — register ViewContents + InventoryPutObjectIn3D/SaveFailed/CloseGroundContainer"
```

---

## Task 12: WorldSession dispatch + events for the 3 top-level GameMessages (Core.Net)

Add events + switch cases for `PrivateUpdatePropertyInt (0x02CD)`, `SetStackSize (0x0197)`, `InventoryRemoveObject (0x0024)`. Glue — no test seam on the switch; verified by build + the parser tests + the live run (per the codebase convention documented in `ObjectTableWiringTests`).

**Files:**
- Modify: `src/AcDream.Core.Net/WorldSession.cs` (add events near `ObjectIntPropertyUpdated` ~line 196; add switch cases after the `PublicUpdatePropertyInt` branch ~line 960)

- [ ] **Step 1: Add the events**

In `src/AcDream.Core.Net/WorldSession.cs`, after the `ObjectIntPropertyUpdated` event (~line 196), add:

```csharp
    /// <summary>Payload for <see cref="PlayerIntPropertyUpdated"/>: a PropertyInt change on
    /// the player's OWN object (from PrivateUpdatePropertyInt 0x02CD — no guid on the wire).</summary>
    public readonly record struct PlayerIntPropertyUpdate(uint Property, int Value);

    /// <summary>Fires when the session parses a PrivateUpdatePropertyInt (0x02CD) — one
    /// PropertyInt updated on the player. B-Wire routes EncumbranceVal (5) to the burden bar.</summary>
    public event Action<PlayerIntPropertyUpdate>? PlayerIntPropertyUpdated;

    /// <summary>Payload for <see cref="StackSizeUpdated"/>: SetStackSize (0x0197) — a stack's
    /// count + value after a merge / split.</summary>
    public readonly record struct StackSizeUpdate(uint Guid, int StackSize, int Value);

    /// <summary>Fires when the session parses a SetStackSize (0x0197) top-level GameMessage.</summary>
    public event Action<StackSizeUpdate>? StackSizeUpdated;

    /// <summary>Fires when the session parses an InventoryRemoveObject (0x0024) — the guid left
    /// the player's inventory view.</summary>
    public event Action<uint>? InventoryObjectRemoved;
```

- [ ] **Step 2: Add the switch cases**

In `src/AcDream.Core.Net/WorldSession.cs`, immediately after the `else if (op == PublicUpdatePropertyInt.Opcode)` branch (the one ending ~line 960), add:

```csharp
            else if (op == PrivateUpdatePropertyInt.Opcode)
            {
                var p = PrivateUpdatePropertyInt.TryParse(body);
                if (p is not null)
                    PlayerIntPropertyUpdated?.Invoke(
                        new PlayerIntPropertyUpdate(p.Value.Property, p.Value.Value));
            }
            else if (op == SetStackSize.Opcode)
            {
                var p = SetStackSize.TryParse(body);
                if (p is not null)
                    StackSizeUpdated?.Invoke(
                        new StackSizeUpdate(p.Value.Guid, p.Value.StackSize, p.Value.Value));
            }
            else if (op == InventoryRemoveObject.Opcode)
            {
                var p = InventoryRemoveObject.TryParse(body);
                if (p is not null) InventoryObjectRemoved?.Invoke(p.Value.Guid);
            }
```

- [ ] **Step 3: Build to verify it compiles**

Run: `dotnet build src/AcDream.Core.Net/AcDream.Core.Net.csproj`
Expected: Build succeeded.

- [ ] **Step 4: Run the full Core.Net test suite (no regressions)**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj`
Expected: PASS (all green).

- [ ] **Step 5: Commit**

```bash
git add src/AcDream.Core.Net/WorldSession.cs
git commit -m "feat(net): D.2b-B B-Wire — WorldSession dispatch for 0x02CD/SetStackSize/InventoryRemoveObject"
```

---

## Task 13: ObjectTableWiring — apply all ints + player-int route + stack/remove (Core.Net)

Loosen the int gate (apply all ints, not just UiEffects), route the player int to the player object, and apply SetStackSize / InventoryRemoveObject. Glue — verified by build + the underlying table-method tests (Tasks 1/2) + run.

**Files:**
- Modify: `src/AcDream.Core.Net/ObjectTableWiring.cs` (the `Wire` method)

- [ ] **Step 1: Replace the `Wire` method body**

In `src/AcDream.Core.Net/ObjectTableWiring.cs`, change the `Wire` signature + subscriptions. Replace the whole method (lines ~19-31) with:

```csharp
    public static void Wire(WorldSession session, ClientObjectTable table, Func<uint>? playerGuid = null)
    {
        ArgumentNullException.ThrowIfNull(session);
        ArgumentNullException.ThrowIfNull(table);

        session.EntitySpawned += s => table.Ingest(ToWeenieData(s));
        session.EntityDeleted += d => table.Remove(d.Guid);

        // B-Wire: apply EVERY PropertyInt update on a visible object (0x02CE), not just
        // UiEffects — the server is the authority on object properties. UpdateIntProperty
        // stores it in the bundle and still mirrors UiEffects → the typed Effects field.
        session.ObjectIntPropertyUpdated += u =>
            table.UpdateIntProperty(u.Guid, u.Property, u.Value);

        // B-Wire: PrivateUpdatePropertyInt (0x02CD) carries no guid — it targets the
        // local player. Route it to the player object so live EncumbranceVal updates the
        // burden bar. (No-op if the player guid isn't wired yet.)
        session.PlayerIntPropertyUpdated += u =>
        {
            if (playerGuid is not null)
                table.UpdateIntProperty(playerGuid(), u.Property, u.Value);
        };

        // B-Wire: SetStackSize (0x0197) — update the object's stack count + value.
        session.StackSizeUpdated += u => table.UpdateStackSize(u.Guid, u.StackSize, u.Value);

        // B-Wire: InventoryRemoveObject (0x0024) — the object left the player's inventory
        // view; drop it from the table (retail ClientUISystem removes it from maintenance).
        session.InventoryObjectRemoved += guid => table.Remove(guid);
    }
```

Also update the class doc-comment (line ~8) to mention the new routes:

```csharp
/// = evict, PublicUpdatePropertyInt (0x02CE) = live int apply, PrivateUpdatePropertyInt
/// (0x02CD) = player int (burden), SetStackSize (0x0197) = stack count, InventoryRemoveObject
/// (0x0024) = inventory-view removal.
```

- [ ] **Step 2: Build to verify it compiles**

Run: `dotnet build src/AcDream.Core.Net/AcDream.Core.Net.csproj`
Expected: Build succeeded.

- [ ] **Step 3: Run the full Core.Net test suite**

Run: `dotnet test tests/AcDream.Core.Net.Tests/AcDream.Core.Net.Tests.csproj`
Expected: PASS (`ObjectTableWiringTests.ToWeenieData_CopiesFieldsFromSpawn` still green — the signature change is source-compatible since `playerGuid` is optional).

- [ ] **Step 4: Commit**

```bash
git add src/AcDream.Core.Net/ObjectTableWiring.cs
git commit -m "feat(net): D.2b-B B-Wire — ObjectTableWiring applies all ints + player int + stack/remove"
```

---

## Task 14: GameWindow — pass the player guid into both wirings (App)

**Files:**
- Modify: `src/AcDream.App/Rendering/GameWindow.cs` (line ~2471 `ObjectTableWiring.Wire`; line ~2569 the `WireAll` `onShortcuts` arg)

- [ ] **Step 1: Pass playerGuid to ObjectTableWiring.Wire**

In `src/AcDream.App/Rendering/GameWindow.cs` at ~line 2471, change:

```csharp
        AcDream.Core.Net.ObjectTableWiring.Wire(session, Objects);
```

to:

```csharp
        AcDream.Core.Net.ObjectTableWiring.Wire(session, Objects, () => _playerServerGuid);
```

- [ ] **Step 2: Pass playerGuid to GameEventWiring.WireAll**

In `src/AcDream.App/Rendering/GameWindow.cs`, in the `WireAll(...)` call (~line 2525-2569), change the final argument line:

```csharp
                onShortcuts: list => Shortcuts = list);
```

to:

```csharp
                onShortcuts: list => Shortcuts = list,
                playerGuid: () => _playerServerGuid);
```

- [ ] **Step 3: Build to verify it compiles**

Run: `dotnet build src/AcDream.App/AcDream.App.csproj`
Expected: Build succeeded.

- [ ] **Step 4: Commit**

```bash
git add src/AcDream.App/Rendering/GameWindow.cs
git commit -m "feat(app): D.2b-B B-Wire — wire player guid into ObjectTableWiring + GameEventWiring"
```

---

## Task 15: InventoryController refreshes burden on player-object update (App)

`Concerns()` excludes the player's own object, so a live `EncumbranceVal` update wouldn't repaint the burden bar. The player object IS the burden source — include it.

**Files:**
- Modify: `src/AcDream.App/UI/Layout/InventoryController.cs` (`Concerns`, ~line 115)

- [ ] **Step 1: Make the change**

In `src/AcDream.App/UI/Layout/InventoryController.cs`, change `Concerns` (~line 115-120):

```csharp
    private bool Concerns(ClientObject o)
    {
        uint p = _playerGuid();
        return o.ContainerId == p || o.WielderId == p
            || (o.ContainerId != 0 && _objects.Get(o.ContainerId)?.ContainerId == p);  // 2-deep
    }
```

to:

```csharp
    private bool Concerns(ClientObject o)
    {
        uint p = _playerGuid();
        return o.ObjectId == p                          // B-Wire: the player object IS the burden source
            || o.ContainerId == p || o.WielderId == p
            || (o.ContainerId != 0 && _objects.Get(o.ContainerId)?.ContainerId == p);  // 2-deep
    }
```

- [ ] **Step 2: Build to verify it compiles**

Run: `dotnet build src/AcDream.App/AcDream.App.csproj`
Expected: Build succeeded.

- [ ] **Step 3: Commit**

```bash
git add src/AcDream.App/UI/Layout/InventoryController.cs
git commit -m "fix(app): D.2b-B B-Wire — burden bar refreshes on player-object property update"
```

---

## Task 16: Full verification + divergence register + ISSUES/roadmap + memory

**Files:**
- Modify: `docs/architecture/retail-divergence-register.md` (retire AP-48, AP-49)
- Modify: `docs/ISSUES.md` (B-Wire SHIPPED note)
- Modify: `docs/plans/2026-04-11-roadmap.md` (B-Wire shipped row)
- Modify: `claude-memory/project_d2b_retail_ui.md` (B-Wire SHIPPED entry + the 0x02CD/no-guid + apply-gate DO-NOT-RETRY)

- [ ] **Step 1: Full build + test (the phase gate)**

Run: `dotnet build` then `dotnet test`
Expected: Build succeeded; all tests green (App + Core + Core.Net). Note the new counts vs the B-Controller baseline (App 532 / Core 1526).

- [ ] **Step 2: Retire the divergence rows**

In `docs/architecture/retail-divergence-register.md`, find rows **AP-48** (client-side `SumCarriedBurden`) and **AP-49** (carry-aug unwired). Delete them (the wire mechanism is now ported), OR if `SumCarriedBurden` remains reachable as a fallback when the wire value is genuinely absent, reword AP-48 to "fallback only when EncumbranceVal absent" rather than deleting. State which you did in the commit. Confirm no other row references them.

- [ ] **Step 3: Update ISSUES + roadmap**

In `docs/ISSUES.md`: add a "Recently closed / shipped" note for D.2b-B B-Wire referencing the commits, and note that the contents-grid overflow + B-Drag remain open.

In `docs/plans/2026-04-11-roadmap.md`: move B-Wire to the shipped column for the D.2b inventory arc.

- [ ] **Step 4: Update the memory digest**

In `claude-memory/project_d2b_retail_ui.md`, add a B-Wire SHIPPED entry (after the B-Controller entry) capturing: EncumbranceVal delivery (login PD upsert + live 0x02CD, no-guid) retires AP-48/AP-49; the apply-gate now passes all ints; SetStackSize 0x0197 / InventoryRemoveObject 0x0024 are top-level GameMessages (not GameEvents); ViewContents 0x0196 is a GameEvent applying membership. Update the MEMORY.md index line if the one-liner changed.

- [ ] **Step 5: Commit**

```bash
git add docs/architecture/retail-divergence-register.md docs/ISSUES.md docs/plans/2026-04-11-roadmap.md claude-memory/
git commit -m "docs(D.2b-B): B-Wire shipped — retire AP-48/AP-49 + ISSUES/roadmap/memory"
```

---

## Post-implementation: visual gate

After Task 16, B-Wire is code-complete and test-green, but the **burden-bar-reads-server-value** behavior is best confirmed live (the project's acceptance model). Launch the client against ACE (per CLAUDE.md "Running the client"), open the inventory (F12, `ACDREAM_RETAIL_UI=1`), and confirm: the burden % matches what a retail client / ACE shows for `+Acdream`, and it updates when you pick up / drop an item (live 0x02CD). Report the observation; do not claim the behavior verified without it.

---

## Self-review notes (coverage vs. spec)

- **C1a** login delivery → Task 10 (+ Task 1 UpsertProperties). **C1b** live 0x02CD → Tasks 3, 12, 13. **C1c** gate → Task 13. **C1d** consumer refresh → Task 15.
- **C2a** 0x0022 4th field → Task 7. **C2b** 0x00A0 error → Task 8.
- **C3** builders → Task 9. **C4a** ViewContents → Tasks 6, 11. **C4b** SetStackSize → Tasks 4, 12, 13 (+ Task 2 UpdateStackSize). **C4c** InventoryRemoveObject → Tasks 5, 12, 13.
- **C5** registration → Tasks 11 (GameEvents) + 12 (WorldSession switch).
- Divergence/AP-48/AP-49 + bookkeeping → Task 16.
- **CreateObject extension** (spec §7): already done (`ToWeenieData`); if Step-1 grep-named of `CreateObject.TryParse` finds a still-discarded inventory field, file it as a follow-up issue — out of scope here.