Implement operation-time D&D NPC artifact handoff

internal/modules/dnd/npcs/registry/registry_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"sync"
 	"testing"
 	"unicode/utf8"
 
@@ -168,6 +169,95 @@ func TestRegistryAccessorsAndLookupAreDefensive(t *testing.T) {
 	}
 }
 
+func TestResolverUsesSeededFallbackAndCachesGeneratedCanonicalRegistry(t *testing.T) {
+	staticContent := encodeRegistry(t, validRegistryList())
+	resolver, err := NewResolver(registryReference(staticContent, "file:///static.json"))
+	if err != nil {
+		t.Fatalf("NewResolver() error = %v", err)
+	}
+	if got, err := resolver.Resolve(contracts.ReferenceSet{}); err != nil || got != resolver.Seeded() {
+		t.Fatalf("Resolve(absent) = %p, %v, want seeded %p", got, err, resolver.Seeded())
+	}
+
+	generated := registryReference(append([]byte("\n"), staticContent...), "file:///generated.json")
+	first, err := resolver.Resolve(generated)
+	if err != nil {
+		t.Fatalf("Resolve(generated) error = %v", err)
+	}
+	second, err := resolver.Resolve(generated)
+	if err != nil {
+		t.Fatalf("Resolve(generated second) error = %v", err)
+	}
+	if first != resolver.Seeded() || second != first {
+		t.Fatalf("resolved registries = %p, %p, seeded %p; want seeded reuse", first, second, resolver.Seeded())
+	}
+
+	changed := validRegistryList()
+	changed.NPCs[0].Description = "A changed generated description."
+	changedContent := encodeRegistry(t, changed)
+	changedReferences := registryReference(changedContent, "file:///changed.json")
+	resolved, err := resolver.Resolve(changedReferences)
+	if err != nil {
+		t.Fatalf("Resolve(changed) error = %v", err)
+	}
+	changedReferences.Slots[ReferenceSlot].Items[0].Content[0] = 'X'
+	if resolved == first || string(resolved.CanonicalBytes()) != string(changedContent) {
+		t.Fatalf("changed registry = %p/%s, want independent canonical cache entry", resolved, resolved.CanonicalBytes())
+	}
+}
+
+func TestResolverSharesOneCachedRegistryAcrossConcurrentOperations(t *testing.T) {
+	content := encodeRegistry(t, validRegistryList())
+	resolver, err := NewResolver(contracts.ReferenceSet{})
+	if err != nil {
+		t.Fatalf("NewResolver() error = %v", err)
+	}
+	references := registryReference(content, "file:///generated.json")
+	const callers = 32
+	results := make(chan *Registry, callers)
+	errors := make(chan error, callers)
+	var wait sync.WaitGroup
+	for index := 0; index < callers; index++ {
+		wait.Add(1)
+		go func() {
+			defer wait.Done()
+			resolved, resolveErr := resolver.Resolve(references)
+			if resolveErr != nil {
+				errors <- resolveErr
+				return
+			}
+			results <- resolved
+		}()
+	}
+	wait.Wait()
+	close(results)
+	close(errors)
+	for err := range errors {
+		t.Fatalf("concurrent Resolve() error = %v", err)
+	}
+	var first *Registry
+	for resolved := range results {
+		if first == nil {
+			first = resolved
+		} else if resolved != first {
+			t.Fatalf("concurrent resolved registry %p differs from cached %p", resolved, first)
+		}
+	}
+}
+
+func TestNewResolverAllowsGeneratedDeclarationButRejectsMalformedStaticItem(t *testing.T) {
+	placeholder := contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{
+		ReferenceSlot: {Slot: contracts.ReferenceSlot{Name: ReferenceSlot, AcceptedArtifactKinds: []contracts.ArtifactKind{dnd.NPCListKind}}},
+	}}
+	if _, err := NewResolver(placeholder); err != nil {
+		t.Fatalf("NewResolver(generated declaration) error = %v, want nil", err)
+	}
+	malformed := registryReference([]byte(`{"npcs":[`), "file:///runtime.json")
+	if _, err := NewResolver(malformed); err == nil || !strings.Contains(err.Error(), "invalid approved NPC JSON") {
+		t.Fatalf("NewResolver(malformed) error = %v, want bounded decode failure", err)
+	}
+}
+
 func validRegistryList() dnd.NPCList {
 	return dnd.NPCList{NPCs: []dnd.NPC{{
 		ID:          identity.DeriveID("Mira Thorn"),