The original client taught me what not to put in a domain object.

public InstructionScreen? RemoveInstructionScreen(InstructionScreen screen)
{
    if (screen is null) return null;
    if (!InstructionScreens.Remove(screen))
        return null;

    _instructionCache.Remove(screen.Id);

    foreach (var block in Blocks)
        block.InstructionsIds.Remove(screen.Id);

    return screen;
}

/// Reset in place so child ViewModels that hold this
/// singleton stay valid; ObservableCollections raise
/// CollectionChanged as items are removed.
public void Reset()
{
    Id = Guid.NewGuid();
    Name = "New IAT Test";
    Stimuli.Clear();
    Blocks.Clear();
    Trials.Clear();
    Keys.Clear();
    InstructionScreens.Clear();
}

Removing an instruction screen is a domain operation: drop it from the collection, drop the cache entry, and strip the Guid from every block. Children hold Ids, not object graphs. No network, no file I/O, no window.

protected override void OnStartup(StartupEventArgs e)
{
    var services = new ServiceCollection();
    services.AddSingleton<TransactionState>();
    services.AddMediatR(cfg =>
        cfg.RegisterServicesFromAssembly(
            typeof(TransactionSuccessHandler).Assembly));

    services.AddSingleton<IWebSocketService, WebSocketService>();
    services.AddSingleton<ILayoutCalculatorService, LayoutCalculatorService>();
    services.AddSingleton<IProjectPackageService, ProjectPackageService>();
    services.AddSingleton<ITestDeploymentService, TestDeploymentService>();
    services.AddSingleton<IValidator<IatTest>, IatTestValidator>();

    services.AddSingleton<IatTest>();
    services.AddSingleton<LayoutViewModel>();
    services.AddSingleton<InstructionManagerViewModel>();
    services.AddSingleton<DeployManagerViewModel>();
    services.AddSingleton<TestDesignerViewModel>();

    Services = services.BuildServiceProvider();
    new MainWindow().Show();
}

One place to wire the graph. Domain singleton shared by every designer tab. Validators, export processors, and the WebSocket client are injected. ViewModels never new up infrastructure.

public async Task SendMessage(object message)
{
    await EnsureConnectedAndReceivingAsync();

    await using var memStream = new MemoryStream();
    var settings = new XmlWriterSettings
    {
        Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false),
        OmitXmlDeclaration = false,
        Indent = false
    };
    using (var writer = XmlWriter.Create(memStream, settings))
        new XmlSerializer(message.GetType()).Serialize(writer, message);

    await _sendLock.WaitAsync();
    try
    {
        await _socket!.SendAsync(
            new ArraySegment<byte>(memStream.ToArray()),
            WebSocketMessageType.Text,
            endOfMessage: true,
            timeoutCts.Token);
    }
    finally { _sendLock.Release(); }
}

private async Task<bool> TryReconnectAsync(CancellationToken ct)
{
    if (_intentionalClose) return false;
    _reconnectAttempt++;
    var delay = Math.Min(MaxBackoffSeconds,
        (int)Math.Pow(2, Math.Min(_reconnectAttempt, 5)));
    ConnectionState = WebSocketConnectionState.Reconnecting;
    await Task.Delay(TimeSpan.FromSeconds(delay), ct);
    await ConnectCoreAsync(ct);
    return true;
}

Java’s handler only implements handleTextMessage. Binary frames never arrive. XmlSerializer’s default UTF-16 is wrong for text frames. Send is semaphore-guarded; reconnect uses exponential backoff capped at 30s.

public static Rect ComputeTextInstructionsRect(Rect interior)
{
    const double pad = 15;
    return new Rect(
        interior.X + pad, interior.Y + pad,
        Math.Max(0, interior.Width - 2 * pad),
        Math.Max(0, interior.Height - 2 * pad));
}

public static Rect ComputeKeyedInstructionsRect(
    Rect interior, Rect leftKey, Rect rightKey)
{
    const double pad = 15;
    var top = Math.Max(leftKey.Bottom, rightKey.Bottom) + pad;
    var bottom = interior.Bottom - pad;
    return new Rect(interior.X + pad, top,
        Math.Max(0, interior.Width - 2 * pad),
        Math.Max(0, bottom - top));
}

public static Rect ComputeMockItemInstructionsRect(
    Rect interior, Rect errorMark, Rect continueInstructions)
{
    var top = errorMark.Bottom;
    var bottom = Math.Max(top, continueInstructions.Top);
    return new Rect(0, top, Math.Max(0, interior.Width),
        Math.Max(0, bottom - top));
}

Text, keyed, mock-item, and continue regions are functions of the interior and key bottoms. The preview and the administered test share the same math. Designers may override; defaults still come from the calculator.

private void OnServerReportChanged(ServerReport report)
{
    Application.Current.Dispatcher.Invoke(() =>
    {
        if (!_isActive) return;
        ApplyServerReport(report);
        LastSyncText = "just now";
    });
}

private void ApplyServerReport(ServerReport report)
{
    var hasIats = report.IATReport is { Count: > 0 };
    var hasIdentity = !string.IsNullOrWhiteSpace(report.ContactFName)
                      || !string.IsNullOrWhiteSpace(report.Organization);

    // A mid-transaction reset must never blank the tab.
    if (!hasIats && !hasIdentity && DeployedTests.Count > 0)
        return;

    AccountName = $"{report.ContactFName} {report.ContactLName}".Trim();
    AdministrationsRemaining = report.NumAdministrations < 0
        ? "Unlimited"
        : report.NumAdministrations.ToString();
}

ServerReport is a serializable payload. The ViewModel applies it on the dispatcher and refuses to replace a populated list with an empty report. XAML never binds to TransactionState.