fix: social gate round 2, part 2 - confirmation-dialog sentences + the

refused-drop yellow notice

Item 4 (confirmation dialogs missing text + names): the missing retail
mechanism was StringTable template substitution - an entry is N+1 literal
fragments interleaved with N named variables, composed by
StringTable::GetString @0x004300D0 (no-metalanguage branch @0x004303B7).
ACE sends the bare player name for types 1/4; retail's OWN CLIENT wraps
it. Ported as DatStringResolver.ResolveTemplate (PLAYER hash 0x05506DA2,
the exact compute_str_hash space; Chorizite stores the variable hashes
directly):

- Server-driven type 4 -> ID_Fellowship_FellowshipRequest, type 1 ->
  ID_Allegiance_AcceptSwearConfirmation, injected into
  GameplayConfirmationController; null resolve falls back to the bare
  wire message, never invented English. The 2/3/5/6 " Continue?" family
  never consults the composer.
- Local Swear/Break/Kick: the bind-time fragment-0 latch (which showed
  the dangling "Do you wish to swear to ") is replaced by click-time
  ResolveTemplate with the target's name.

All five templates verified token-free in the installed DAT - this is
NOT a StringTableMetaLanguage port (AD-81's engine caveat stands).

Item 5 (refused drop shows nothing; retail shows yellow top-center
text): the prevRequest latch was ALREADY ported (InventoryTransactionState);
what was missing was the consumer. InventoryTransactionState now raises
RequestFailed(request, weenieError) when a 0x00A0 clears the latch;
ItemInteractionController composes ServerSaysAttemptFailed @0x0058EAE0's
"The <item> can't be <verb>" (verb table + suffix map ported verbatim in
Core's InventoryFailureMessages, NAME_PLURAL for merge/split) and routes
it as LogTextType 0x1A ClientLocal -> the SpewBox, retail's yellow
top-center line. The dispatcher's second leg (@0x0055B342) also runs:
outside the 7-code exclusion set, WeenieErrorMessages resolves per-code
text/destination; 0x426 AttunedItem has no row in either place beyond
the verb line - faithful single-line output.

Register: AD-85 narrowed to its numeric-field item, AD-81 amended (the
token-free interleave is now ported; meta-token engine + FormatName
remain), AD-93 filed (wire-guid-match vs retail's latched-guid
preference; no Move/Wield latch kinds).

Tests: +2 InventoryTransactionState failure-latch, +5 ResolveTemplate
(constructed StringTable fixtures), +1 composer injection, +1 end-to-end
refused-drop line. Core 4,697/1 skip, App 4,983/3 skips.

Research: docs/research/2026-08-13-confirm-and-weenie-error-display.md

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/AcDream.App/UI/Layout/DatStringResolver.cs

@@ -61,6 +61,60 @@ public sealed class DatStringResolver
                 : null;
     }
 
+    /// <summary>Retail's variable-name hash for <c>PLAYER</c> (0x05506DA2) —
+    /// the single substitution slot every social confirmation template uses.</summary>
+    public static readonly uint PlayerVariable = ComputeHash("PLAYER");
+
+    /// <summary>
+    /// Composes a templated StringTable entry: N (or N+1) literal fragments
+    /// interleaved with N named variables, keyed by the entry-key hash.
+    /// </summary>
+    /// <remarks>
+    /// Exact port of <c>StringTable::GetString @ 0x004300D0</c>'s
+    /// no-metalanguage branch <c>@ 0x004303B7</c>: each fragment is appended,
+    /// then the variable in the same slot (resolved through
+    /// <paramref name="variables"/>, keyed by <see cref="ComputeHash"/> of the
+    /// authored variable name; a missing variable substitutes the empty
+    /// string, as retail does). This is NOT a
+    /// <c>StringTableMetaLanguage::RenderString</c> port — callers own
+    /// keeping it to token-free templates (register row AD-81's scope note).
+    /// </remarks>
+    public string? ResolveTemplate(
+        uint tableId,
+        string key,
+        IReadOnlyDictionary<uint, string> variables)
+    {
+        ArgumentNullException.ThrowIfNull(key);
+        ArgumentNullException.ThrowIfNull(variables);
+        if (tableId == 0u)
+            return null;
+
+        if (!_tables.TryGetValue(tableId, out StringTable? table))
+        {
+            table = _dats.Get<StringTable>(tableId);
+            _tables[tableId] = table;
+        }
+
+        if (table is null
+            || !table.Strings.TryGetValue(ComputeHash(key), out var entry)
+            || entry.Strings.Count == 0)
+            return null;
+
+        var composed = new System.Text.StringBuilder();
+        for (int i = 0; i < entry.Strings.Count; i++)
+        {
+            composed.Append(entry.Strings[i].Value);
+            // Variables are stored as the pre-computed name hashes (the same
+            // compute_str_hash space PlayerVariable lives in).
+            if (i < entry.Variables.Count
+                && variables.TryGetValue(entry.Variables[i], out string? value))
+            {
+                composed.Append(value);
+            }
+        }
+        return composed.ToString();
+    }
+
     /// <summary>
     /// Exact retail ELF-style string hash used for StringInfo keys.
     /// Ported line-for-line from <c>compute_str_hash @ 0x00413110</c>.