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.

private void CopyItemsToBlock(CIATBlock dest, CIATBlock src, bool reverse)
{
    for (int ctr = 0; ctr < src.NumItems; ctr++)
    {
        if (src[ctr].GetKeyedDirection(src.URI) == KeyedDirection.None)
            dest.AddItem(src[ctr], KeyedDirection.None);
        else if (src[ctr].GetKeyedDirection(src.URI) == KeyedDirection.Left)
            dest.AddItem(src[ctr], reverse ? KeyedDirection.Right : KeyedDirection.Left);
        else if (src[ctr].GetKeyedDirection(src.URI) == KeyedDirection.Right)
            dest.AddItem(src[ctr], reverse ? KeyedDirection.Left : KeyedDirection.Right);
        else if (src[ctr].GetKeyedDirection(src.URI) == KeyedDirection.DynamicLeft)
            dest.AddItem(src[ctr], reverse ? KeyedDirection.DynamicRight : KeyedDirection.DynamicLeft);
        else if (src[ctr].GetKeyedDirection(src.URI) == KeyedDirection.DynamicRight)
            dest.AddItem(src[ctr], reverse ? KeyedDirection.DynamicLeft : KeyedDirection.DynamicRight);
    }
}

public bool Generate(bool bAlternate)
{
    CIATBlock b3 = new CIATBlock(IAT);
    b3.Key = GenerateResponseKeyForBlock(3);
    CopyItemsToBlock(b3, IAT.Blocks[0], false);
    CopyItemsToBlock(b3, IAT.Blocks[1], false);
    b3.AddToIAT(insertionNdx++);

    CIATBlock b5 = new CIATBlock(IAT);
    b5.Key = GenerateResponseKeyForBlock(5);
    CopyItemsToBlock(b5, IAT.Blocks[1], true);
    b5.AddToIAT(insertionNdx++);

    CIATBlock b6 = new CIATBlock(IAT);
    b6.Key = GenerateResponseKeyForBlock(6);
    CopyItemsToBlock(b6, IAT.Blocks[0], false);
    CopyItemsToBlock(b6, IAT.Blocks[1], true);
    b6.AddToIAT(insertionNdx++);

    if (bAlternate)
    {
        new AlternationGroup(b3, b6);
        new AlternationGroup(b4, b7);
    }
    return true;
}

Greenwald’s procedure is a generator, not a wizard. Blocks 3–4 combine the two practice keys; block 5 reverses the target; 6–7 recombine. CopyItemsToBlock flips keyed direction when the target is reversed. Optional AlternationGroup swaps compatible/incompatible blocks across participants.

public void Start()
{
    CCompositeImageGenerator.StartGeneration();
    StartResizer();
    StartThumbnailGenerator();
    StartNonUserImageGenerator();
    this.Running = true;
}

public void Halt(bool bIsHaltingForSave)
{
    CCompositeImageGenerator.EndGeneration();
    var resizer = new ManualResetEvent(false);
    var thumbs = new ManualResetEvent(false);
    var generated = new ManualResetEvent(false);
    CIATImage.HaltResizer(resizer);
    CThumbnail.HaltThumbnailGenerator(thumbs);
    HaltNonUserImageGenerator(generated);
    resizer.WaitOne();
    thumbs.WaitOne();
    generated.WaitOne();
    this.Running = false;
}

private void CompactImageDictionary()
{
    lock (dictionaryLock)
    {
        foreach (var id in UserImages.Keys.ToList())
            if (UserImages[id]?.NumInstances == 0)
            {
                UserImages[id].Dispose();
                UserImages.Remove(id);
            }
        foreach (var id in NonUserImages.Keys.ToList())
            if (NonUserImages[id]?.NumInstances == 0)
            {
                NonUserImages[id].Dispose();
                NonUserImages.Remove(id);
            }
    }
}

Thumbnails, resizes, and generated stimuli run on timers off the UI thread. CompactImageDictionary drops images with zero remaining instances. This is how peak memory went from nearly 1 GB to 55 MB — reuse the bitmap, don’t keep every size around forever.

static public void StartGeneration()
{
    halted = new ManualResetEvent(false);
    halting = false;
    ImageGenerationTimer = new System.Threading.Timer((n) =>
    {
        if (!Monitor.TryEnter(generatorLock))
            return;
        try
        {
            List<CCompositeImage> stale;
            lock (listLockObj)
                stale = ImageDictionary.Keys
                    .Where(ci => !ci.IsValid).ToList();
            foreach (var ci in stale)
                ci.TryGenerate(false);
            if (halting)
                halted.Set();
        }
        finally { Monitor.Exit(generatorLock); }
    }, null, 0, 100);
}

static public void AddCompositeImage(CCompositeImage ci)
{
    lock (listLockObj)
    {
        ImageDictionary[ci] = ImageDictionary.ContainsKey(ci)
            ? ImageDictionary[ci] + 1 : 1;
        ci.Invalidate();
    }
}

Composite keys and instruction screens are regenerated on a 100 ms timer. TryEnter so a slow generate never piles up. AddCompositeImage increments a count; RemoveImage drops the entry at zero. The UI binds to the cached bitmap, not the generator.