feat(m9/T26a): read-only inheritance resolve service + GetResolvedTemplateMembersCommand

src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Management/ResolvedTemplateMembers.cs

@@ -0,0 +1,117 @@
+namespace ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
+
+/// <summary>
+/// Read-only response for <see cref="GetResolvedTemplateMembersCommand"/>: the
+/// EFFECTIVE inherited member set for a template, computed fresh from the full
+/// inheritance chain (root → leaf, arbitrary depth) and annotated per member
+/// with its origin and lock state — plus a staleness summary comparing the
+/// template's STORED member rows against this freshly-resolved set.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The precedence used to compute the effective member set MIRRORS
+/// <c>FlatteningService.ResolveInherited*</c> exactly (derived wins;
+/// <c>IsInherited</c> placeholders never shadow the live base value; locked
+/// members flagged), so the editor preview agrees with what a deploy would
+/// produce. This is the AUTHORING view only — it never mutates stored rows and
+/// is not on the deploy path.
+/// </para>
+/// <para>
+/// Member values surfaced here are the inheritance-resolved values BEFORE any
+/// composition or instance override is applied — composition is a separate
+/// concern owned by the instance flattener, and there are no instances in the
+/// template-authoring context.
+/// </para>
+/// </remarks>
+public sealed record ResolvedTemplateMembers
+{
+    /// <summary>The template the member set was resolved for.</summary>
+    public int TemplateId { get; init; }
+    /// <summary>The template's name.</summary>
+    public string TemplateName { get; init; } = string.Empty;
+    /// <summary>The immediate parent template id, or null when this is a root template.</summary>
+    public int? ParentTemplateId { get; init; }
+
+    /// <summary>The effective resolved attributes (own + transitively inherited).</summary>
+    public IReadOnlyList<ResolvedTemplateMemberInfo> Attributes { get; init; } = [];
+    /// <summary>The effective resolved alarms (own + transitively inherited).</summary>
+    public IReadOnlyList<ResolvedTemplateMemberInfo> Alarms { get; init; } = [];
+    /// <summary>The effective resolved scripts (own + transitively inherited).</summary>
+    public IReadOnlyList<ResolvedTemplateMemberInfo> Scripts { get; init; } = [];
+    /// <summary>The effective resolved native alarm source bindings (own + transitively inherited).</summary>
+    public IReadOnlyList<ResolvedTemplateMemberInfo> NativeAlarmSources { get; init; } = [];
+
+    /// <summary>
+    /// Staleness summary: whether the template's stored member rows differ from
+    /// this freshly-resolved set (e.g. a base member added after the derived
+    /// template was created, or a multi-level inherited member not present in
+    /// the stored rows), and how many inherited members differ.
+    /// </summary>
+    public ResolvedTemplateStaleness Staleness { get; init; } = new();
+}
+
+/// <summary>
+/// One effective member in a <see cref="ResolvedTemplateMembers"/> set,
+/// annotated with where its winning definition came from and its lock state.
+/// </summary>
+public sealed record ResolvedTemplateMemberInfo
+{
+    /// <summary>The member name (bare; inheritance-resolved members are never path-qualified).</summary>
+    public string Name { get; init; } = string.Empty;
+
+    /// <summary>
+    /// True when the winning definition lives on an ANCESTOR template rather
+    /// than on the resolved template itself — i.e. this member is inherited.
+    /// </summary>
+    public bool IsInherited { get; init; }
+
+    /// <summary>The id of the template that supplied the winning definition.</summary>
+    public int OriginTemplateId { get; init; }
+    /// <summary>The name of the template that supplied the winning definition.</summary>
+    public string OriginTemplateName { get; init; } = string.Empty;
+
+    /// <summary>
+    /// True when the member is locked from override (<c>IsLocked</c> on the
+    /// winning row) — a derived template cannot change it.
+    /// </summary>
+    public bool IsLocked { get; init; }
+
+    /// <summary>
+    /// True when an ANCESTOR marked this member <c>LockedInDerived</c> — the
+    /// derived template may not override it (rendered read-only with a lock in
+    /// the editor). Distinct from <see cref="IsLocked"/>: a base may forbid
+    /// override (<c>LockedInDerived</c>) without the member itself being a
+    /// locked composition member.
+    /// </summary>
+    public bool IsBaseLocked { get; init; }
+
+    /// <summary>
+    /// The effective value for the member, type-appropriate: attribute value,
+    /// script code, alarm priority/trigger summary, or native-source reference.
+    /// Provided so the editor preview shows the live (post-resolution) value
+    /// without re-walking the chain itself. Null when the member type carries
+    /// no single scalar value.
+    /// </summary>
+    public string? EffectiveValue { get; init; }
+}
+
+/// <summary>
+/// Staleness summary comparing a template's STORED member rows against the
+/// freshly-resolved inherited member set.
+/// </summary>
+public sealed record ResolvedTemplateStaleness
+{
+    /// <summary>
+    /// True when the stored derived rows differ from the freshly-resolved set —
+    /// the base changed after the derived template was created, so the editor
+    /// should surface a "base changed" banner.
+    /// </summary>
+    public bool IsStale { get; init; }
+
+    /// <summary>
+    /// The number of inherited members whose freshly-resolved state differs
+    /// from what the stored rows reflect (missing rows, added base members,
+    /// changed inherited values). This is the count the editor banner shows.
+    /// </summary>
+    public int DifferingMemberCount { get; init; }
+}

src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Management/TemplateCommands.cs

@@ -7,6 +7,16 @@ public record UpdateTemplateCommand(int TemplateId, string Name, string? Descrip
 public record DeleteTemplateCommand(int TemplateId);
 public record ValidateTemplateCommand(int TemplateId);
 
+/// <summary>
+/// Read-only authoring query (M9/T26a): returns the EFFECTIVE inherited member
+/// set for a template — computed fresh from the full inheritance chain
+/// (arbitrary depth), annotated per member with origin + lock state — plus a
+/// staleness summary comparing the template's stored rows against the resolved
+/// set. Feeds the template editor's inheritance preview + base-change banner;
+/// never mutates stored rows. Response: <see cref="ResolvedTemplateMembers"/>.
+/// </summary>
+public record GetResolvedTemplateMembersCommand(int TemplateId);
+
 // Template member operations
 public record AddTemplateAttributeCommand(int TemplateId, string Name, string DataType, string? Value, string? Description, string? DataSourceReference, bool IsLocked, string? ElementDataType = null);
 public record UpdateTemplateAttributeCommand(int AttributeId, string Name, string DataType, string? Value, string? Description, string? DataSourceReference, bool IsLocked, string? ElementDataType = null);

src/ZB.MOM.WW.ScadaBridge.ManagementService/ManagementActor.cs

@@ -244,6 +244,7 @@ public class ManagementActor : ReceiveActor
             UpdateTemplateCommand cmd => await HandleUpdateTemplate(sp, cmd, user.Username),
             DeleteTemplateCommand cmd => await HandleDeleteTemplate(sp, cmd, user.Username),
             ValidateTemplateCommand cmd => await HandleValidateTemplate(sp, cmd),
+            GetResolvedTemplateMembersCommand cmd => await HandleGetResolvedTemplateMembers(sp, cmd),
 
             // Template members
             AddTemplateAttributeCommand cmd => await HandleAddAttribute(sp, cmd, user.Username),
@@ -599,6 +600,20 @@ public class ManagementActor : ReceiveActor
         return validationResult;
     }
 
+    /// <summary>
+    /// Read-only authoring resolve (M9/T26a): returns the effective inherited
+    /// member set for a template — computed fresh from the full inheritance
+    /// chain — plus a staleness summary. Loads every template (children
+    /// eager-loaded) so the resolver can walk an arbitrary-depth chain; never
+    /// mutates stored rows.
+    /// </summary>
+    private static async Task<object?> HandleGetResolvedTemplateMembers(IServiceProvider sp, GetResolvedTemplateMembersCommand cmd)
+    {
+        var repo = sp.GetRequiredService<ITemplateEngineRepository>();
+        var allTemplates = await repo.GetAllTemplatesAsync();
+        return TemplateInheritanceResolver.Resolve(cmd.TemplateId, allTemplates);
+    }
+
     // ========================================================================
     // Template folder handlers
     // ========================================================================

src/ZB.MOM.WW.ScadaBridge.TemplateEngine/TemplateInheritanceResolver.cs

@@ -0,0 +1,285 @@
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
+using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
+
+namespace ZB.MOM.WW.ScadaBridge.TemplateEngine;
+
+/// <summary>
+/// Read-only AUTHORING resolver (M9/T26a). Given a template id and the full
+/// template lookup, computes the EFFECTIVE inherited member set fresh from the
+/// whole inheritance chain (root → leaf, arbitrary depth, cycle-guarded via
+/// <see cref="TemplateResolver.BuildInheritanceChain"/>), annotated per member
+/// with origin (own / inherited-from-X) and lock state, plus a staleness
+/// summary comparing the template's STORED member rows against the resolved set.
+///
+/// <para>
+/// The inheritance precedence here MIRRORS
+/// <see cref="Flattening.FlatteningService"/>'s <c>ResolveInherited*</c> methods
+/// EXACTLY so the editor preview agrees with what a deploy would produce:
+/// walk base → derived (derived wins); an <c>IsInherited</c> placeholder row on
+/// a derived template never shadows the live base value (it only contributes a
+/// row when no ancestor defines the member); a locked member, once seen, is not
+/// overridden by a downstream template; and an ancestor's
+/// <c>LockedInDerived</c> flag is propagated so the editor can render the
+/// member read-only.
+/// </para>
+///
+/// <para>
+/// This is inheritance only — composition and instance overrides are the
+/// instance flattener's concern (there are no instances in the
+/// template-authoring context). It NEVER mutates stored rows and is not on the
+/// deploy path.
+/// </para>
+/// </summary>
+public static class TemplateInheritanceResolver
+{
+    /// <summary>
+    /// Resolves the effective inherited member set for <paramref name="templateId"/>.
+    /// </summary>
+    /// <param name="templateId">The template to resolve members for.</param>
+    /// <param name="allTemplates">The complete set of templates (for chain lookups).</param>
+    /// <returns>
+    /// The resolved member set (attributes / alarms / scripts / native alarm
+    /// sources), each annotated with origin + lock state, plus the staleness
+    /// summary. Returns an empty set when the template id is not found.
+    /// </returns>
+    public static ResolvedTemplateMembers Resolve(int templateId, IReadOnlyList<Template> allTemplates)
+    {
+        // Duplicate-tolerant lookup (matches TemplateResolver.ResolveAllMembers):
+        // an Id of 0 is a valid node (import-staging / not-yet-saved rows).
+        var lookup = CycleDetector.BuildLookup(allTemplates);
+        if (!lookup.TryGetValue(templateId, out var self))
+            return new ResolvedTemplateMembers { TemplateId = templateId };
+
+        // Root → leaf (derived last). The OWN template is the last element.
+        var chain = TemplateResolver.BuildInheritanceChain(templateId, lookup);
+
+        var attributes = ResolveAttributes(chain, templateId);
+        var alarms = ResolveAlarms(chain, templateId);
+        var scripts = ResolveScripts(chain, templateId);
+        var nativeAlarmSources = ResolveNativeAlarmSources(chain, templateId);
+
+        var staleness = ComputeStaleness(self, attributes, alarms, scripts, nativeAlarmSources);
+
+        return new ResolvedTemplateMembers
+        {
+            TemplateId = templateId,
+            TemplateName = self.Name,
+            ParentTemplateId = self.ParentTemplateId,
+            Attributes = attributes,
+            Alarms = alarms,
+            Scripts = scripts,
+            NativeAlarmSources = nativeAlarmSources,
+            Staleness = staleness
+        };
+    }
+
+    // ── per-member-type winners (origin-tracking) ──
+
+    /// <summary>The winning row for a member, plus where it came from.</summary>
+    private sealed record Winner<T>(T Row, Template Origin, bool BaseLocked);
+
+    /// <summary>
+    /// Generic base → derived walk that picks the winning row per member name,
+    /// replicating FlatteningService precedence:
+    /// derived wins; an <c>IsInherited</c> placeholder does not shadow a live
+    /// ancestor value; a locked member is not overridden downstream; the
+    /// ancestor <c>LockedInDerived</c> flag is tracked.
+    /// </summary>
+    private static Dictionary<string, Winner<T>> ResolveWinners<T>(
+        IReadOnlyList<Template> chain,
+        Func<Template, IEnumerable<T>> select,
+        Func<T, string> nameOf,
+        Func<T, bool> isInherited,
+        Func<T, bool> isLocked,
+        Func<T, bool> lockedInDerived)
+    {
+        var result = new Dictionary<string, Winner<T>>(StringComparer.Ordinal);
+
+        // chain is root-first; walk root → derived so the derived template
+        // (last) wins, mirroring FlatteningService (which walks its
+        // most-derived-first chain back-to-front for the same effect).
+        foreach (var template in chain)
+        {
+            foreach (var row in select(template))
+            {
+                var name = nameOf(row);
+                if (result.TryGetValue(name, out var existing))
+                {
+                    // A locked ancestor row is not overridden by a downstream template.
+                    if (isLocked(existing.Row))
+                    {
+                        if (lockedInDerived(row))
+                            result[name] = existing with { BaseLocked = true };
+                        continue;
+                    }
+                    // IsInherited placeholders never shadow the live ancestor row.
+                    if (isInherited(row))
+                    {
+                        if (lockedInDerived(row))
+                            result[name] = existing with { BaseLocked = true };
+                        continue;
+                    }
+                }
+
+                var baseLocked = (existing?.BaseLocked ?? false) || lockedInDerived(row);
+                result[name] = new Winner<T>(row, template, baseLocked);
+            }
+        }
+
+        return result;
+    }
+
+    private static IReadOnlyList<ResolvedTemplateMemberInfo> ResolveAttributes(
+        IReadOnlyList<Template> chain, int selfId)
+    {
+        var winners = ResolveWinners(
+            chain,
+            t => t.Attributes,
+            a => a.Name,
+            a => a.IsInherited,
+            a => a.IsLocked,
+            a => a.LockedInDerived);
+
+        return Project(winners, selfId, w => w.Row.Value);
+    }
+
+    private static IReadOnlyList<ResolvedTemplateMemberInfo> ResolveAlarms(
+        IReadOnlyList<Template> chain, int selfId)
+    {
+        var winners = ResolveWinners(
+            chain,
+            t => t.Alarms,
+            a => a.Name,
+            a => a.IsInherited,
+            a => a.IsLocked,
+            a => a.LockedInDerived);
+
+        // No single scalar value for an alarm; surface the priority as the preview value.
+        return Project(winners, selfId, w => w.Row.PriorityLevel.ToString());
+    }
+
+    private static IReadOnlyList<ResolvedTemplateMemberInfo> ResolveScripts(
+        IReadOnlyList<Template> chain, int selfId)
+    {
+        var winners = ResolveWinners(
+            chain,
+            t => t.Scripts,
+            s => s.Name,
+            s => s.IsInherited,
+            s => s.IsLocked,
+            s => s.LockedInDerived);
+
+        return Project(winners, selfId, w => w.Row.Code);
+    }
+
+    private static IReadOnlyList<ResolvedTemplateMemberInfo> ResolveNativeAlarmSources(
+        IReadOnlyList<Template> chain, int selfId)
+    {
+        var winners = ResolveWinners(
+            chain,
+            t => t.NativeAlarmSources,
+            s => s.Name,
+            s => s.IsInherited,
+            s => s.IsLocked,
+            s => s.LockedInDerived);
+
+        return Project(winners, selfId, w => w.Row.SourceReference);
+    }
+
+    private static IReadOnlyList<ResolvedTemplateMemberInfo> Project<T>(
+        Dictionary<string, Winner<T>> winners,
+        int selfId,
+        Func<Winner<T>, string?> effectiveValue)
+    {
+        return winners.Values
+            .Select(w => new ResolvedTemplateMemberInfo
+            {
+                Name = NameOf(w.Row),
+                IsInherited = w.Origin.Id != selfId,
+                OriginTemplateId = w.Origin.Id,
+                OriginTemplateName = w.Origin.Name,
+                IsLocked = IsLockedOf(w.Row),
+                IsBaseLocked = w.BaseLocked && w.Origin.Id != selfId,
+                EffectiveValue = effectiveValue(w)
+            })
+            .OrderBy(m => m.Name, StringComparer.Ordinal)
+            .ToList();
+    }
+
+    private static string NameOf<T>(T row) => row switch
+    {
+        TemplateAttribute a => a.Name,
+        TemplateAlarm a => a.Name,
+        TemplateScript s => s.Name,
+        TemplateNativeAlarmSource s => s.Name,
+        _ => string.Empty
+    };
+
+    private static bool IsLockedOf<T>(T row) => row switch
+    {
+        TemplateAttribute a => a.IsLocked,
+        TemplateAlarm a => a.IsLocked,
+        TemplateScript s => s.IsLocked,
+        TemplateNativeAlarmSource s => s.IsLocked,
+        _ => false
+    };
+
+    // ── staleness ──
+
+    /// <summary>
+    /// Compares the template's STORED member rows against the freshly-resolved
+    /// set and counts how many INHERITED members drift: a freshly-resolved
+    /// inherited member with no stored row, or whose stored placeholder value
+    /// differs from the live resolved value. Own (non-inherited) members never
+    /// count toward staleness — they are authoritative by definition.
+    /// </summary>
+    private static ResolvedTemplateStaleness ComputeStaleness(
+        Template self,
+        IReadOnlyList<ResolvedTemplateMemberInfo> attributes,
+        IReadOnlyList<ResolvedTemplateMemberInfo> alarms,
+        IReadOnlyList<ResolvedTemplateMemberInfo> scripts,
+        IReadOnlyList<ResolvedTemplateMemberInfo> nativeAlarmSources)
+    {
+        int differing = 0;
+
+        differing += CountDrift(attributes,
+            self.Attributes.ToDictionary(a => a.Name, a => (string?)a.Value, StringComparer.Ordinal));
+        differing += CountDrift(alarms,
+            self.Alarms.ToDictionary(a => a.Name, a => (string?)a.PriorityLevel.ToString(), StringComparer.Ordinal));
+        differing += CountDrift(scripts,
+            self.Scripts.ToDictionary(s => s.Name, s => (string?)s.Code, StringComparer.Ordinal));
+        differing += CountDrift(nativeAlarmSources,
+            self.NativeAlarmSources.ToDictionary(s => s.Name, s => (string?)s.SourceReference, StringComparer.Ordinal));
+
+        return new ResolvedTemplateStaleness
+        {
+            IsStale = differing > 0,
+            DifferingMemberCount = differing
+        };
+    }
+
+    private static int CountDrift(
+        IReadOnlyList<ResolvedTemplateMemberInfo> resolved,
+        IReadOnlyDictionary<string, string?> storedValuesByName)
+    {
+        int count = 0;
+        foreach (var m in resolved)
+        {
+            if (!m.IsInherited)
+                continue; // own rows are authoritative — never stale
+
+            if (!storedValuesByName.TryGetValue(m.Name, out var storedValue))
+            {
+                // Inherited member with no stored placeholder row (e.g. a base
+                // member added after the derived template was created).
+                count++;
+                continue;
+            }
+
+            if (!string.Equals(storedValue, m.EffectiveValue, StringComparison.Ordinal))
+                count++; // stored placeholder is stale vs. the live base value
+        }
+
+        return count;
+    }
+}

tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateInheritanceResolverTests.cs

@@ -0,0 +1,293 @@
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
+using ZB.MOM.WW.ScadaBridge.TemplateEngine.Flattening;
+
+namespace ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests;
+
+/// <summary>
+/// Tests for the read-only authoring resolve service (M9/T26a). The resolved
+/// inherited member set MUST agree with what <see cref="FlatteningService"/>
+/// produces on deploy — the precedence is exercised both directly and via a
+/// cross-check against the flattener.
+/// </summary>
+public class TemplateInheritanceResolverTests
+{
+    private static TemplateAttribute Attr(string name, int id, int templateId, string? value = null,
+        bool isInherited = false, bool isLocked = false, bool lockedInDerived = false) =>
+        new(name)
+        {
+            Id = id,
+            TemplateId = templateId,
+            DataType = DataType.String,
+            Value = value,
+            IsInherited = isInherited,
+            IsLocked = isLocked,
+            LockedInDerived = lockedInDerived
+        };
+
+    // ── (a) A→B→C chain: resolving C returns members inherited transitively from A ──
+
+    [Fact]
+    public void Resolve_ThreeLevelChain_IncludesTransitivelyInheritedGrandparentMember()
+    {
+        var a = new Template("A") { Id = 1 };
+        a.Attributes.Add(Attr("FromGrandparent", id: 10, templateId: 1, value: "gp"));
+
+        var b = new Template("B") { Id = 2, ParentTemplateId = 1 };
+        b.Attributes.Add(Attr("FromParent", id: 20, templateId: 2, value: "p"));
+
+        var c = new Template("C") { Id = 3, ParentTemplateId = 2 };
+        c.Attributes.Add(Attr("FromChild", id: 30, templateId: 3, value: "c"));
+
+        var resolved = TemplateInheritanceResolver.Resolve(3, new[] { a, b, c });
+
+        Assert.Equal(3, resolved.Attributes.Count);
+
+        var fromGp = Assert.Single(resolved.Attributes, m => m.Name == "FromGrandparent");
+        Assert.True(fromGp.IsInherited);
+        Assert.Equal(1, fromGp.OriginTemplateId);
+        Assert.Equal("A", fromGp.OriginTemplateName);
+        Assert.Equal("gp", fromGp.EffectiveValue);
+
+        var fromParent = Assert.Single(resolved.Attributes, m => m.Name == "FromParent");
+        Assert.True(fromParent.IsInherited);
+        Assert.Equal("B", fromParent.OriginTemplateName);
+
+        var fromChild = Assert.Single(resolved.Attributes, m => m.Name == "FromChild");
+        Assert.False(fromChild.IsInherited);
+        Assert.Equal(3, fromChild.OriginTemplateId);
+    }
+
+    // ── (b) a base member ADDED to A after C was created appears in C's resolved set ──
+
+    [Fact]
+    public void Resolve_BaseMemberAddedAfterDerivedCreated_AppearsInResolvedSet()
+    {
+        // C was created carrying a single inherited placeholder for "Original".
+        // "AddedLater" was then added to the grandparent A; it has NO stored row
+        // on C, yet must surface in C's freshly-resolved set.
+        var a = new Template("A") { Id = 1 };
+        a.Attributes.Add(Attr("Original", id: 10, templateId: 1, value: "v1"));
+        a.Attributes.Add(Attr("AddedLater", id: 11, templateId: 1, value: "new"));
+
+        var b = new Template("B") { Id = 2, ParentTemplateId = 1 };
+
+        var c = new Template("C") { Id = 3, ParentTemplateId = 2 };
+        // Stale placeholder for the one member C knew about at creation time.
+        c.Attributes.Add(Attr("Original", id: 30, templateId: 3, value: "v1", isInherited: true));
+
+        var resolved = TemplateInheritanceResolver.Resolve(3, new[] { a, b, c });
+
+        Assert.Contains(resolved.Attributes, m => m.Name == "AddedLater" && m.EffectiveValue == "new" && m.IsInherited);
+        Assert.Contains(resolved.Attributes, m => m.Name == "Original");
+    }
+
+    // ── (c) a locked member is flagged ──
+
+    [Fact]
+    public void Resolve_LockedAndBaseLockedMembers_Flagged()
+    {
+        var baseT = new Template("Base") { Id = 1 };
+        baseT.Attributes.Add(Attr("Locked", id: 10, templateId: 1, value: "x", isLocked: true));
+        baseT.Attributes.Add(Attr("BaseLocked", id: 11, templateId: 1, value: "y", lockedInDerived: true));
+
+        var derived = new Template("Derived") { Id = 2, ParentTemplateId = 1 };
+
+        var resolved = TemplateInheritanceResolver.Resolve(2, new[] { baseT, derived });
+
+        var locked = Assert.Single(resolved.Attributes, m => m.Name == "Locked");
+        Assert.True(locked.IsLocked);
+
+        var baseLocked = Assert.Single(resolved.Attributes, m => m.Name == "BaseLocked");
+        Assert.True(baseLocked.IsBaseLocked);
+        Assert.True(baseLocked.IsInherited);
+    }
+
+    // ── (d) own override wins over inherited ──
+
+    [Fact]
+    public void Resolve_OwnOverride_WinsOverInherited()
+    {
+        var baseT = new Template("Base") { Id = 1 };
+        baseT.Attributes.Add(Attr("Speed", id: 10, templateId: 1, value: "100"));
+
+        var derived = new Template("Derived") { Id = 2, ParentTemplateId = 1 };
+        // Explicit override (IsInherited=false) — must win, value 200, origin = derived.
+        derived.Attributes.Add(Attr("Speed", id: 20, templateId: 2, value: "200", isInherited: false));
+
+        var resolved = TemplateInheritanceResolver.Resolve(2, new[] { baseT, derived });
+
+        var speed = Assert.Single(resolved.Attributes, m => m.Name == "Speed");
+        Assert.Equal("200", speed.EffectiveValue);
+        Assert.Equal(2, speed.OriginTemplateId);
+        Assert.False(speed.IsInherited);
+    }
+
+    [Fact]
+    public void Resolve_InheritedPlaceholder_DoesNotShadowLiveBaseValue()
+    {
+        // Derived carries an IsInherited placeholder whose value is stale ("old").
+        // The base value has since changed to "fresh"; the live base value wins.
+        var baseT = new Template("Base") { Id = 1 };
+        baseT.Attributes.Add(Attr("Speed", id: 10, templateId: 1, value: "fresh"));
+
+        var derived = new Template("Derived") { Id = 2, ParentTemplateId = 1 };
+        derived.Attributes.Add(Attr("Speed", id: 20, templateId: 2, value: "old", isInherited: true));
+
+        var resolved = TemplateInheritanceResolver.Resolve(2, new[] { baseT, derived });
+
+        var speed = Assert.Single(resolved.Attributes, m => m.Name == "Speed");
+        Assert.Equal("fresh", speed.EffectiveValue);
+        Assert.True(speed.IsInherited);
+        Assert.Equal(1, speed.OriginTemplateId); // base supplied the live value
+    }
+
+    // ── (e) staleness summary true when stored rows differ; false when in sync ──
+
+    [Fact]
+    public void Resolve_StalenessSummary_TrueWhenBaseAddedMemberMissingFromStoredRows()
+    {
+        var baseT = new Template("Base") { Id = 1 };
+        baseT.Attributes.Add(Attr("Original", id: 10, templateId: 1, value: "v"));
+        baseT.Attributes.Add(Attr("AddedLater", id: 11, templateId: 1, value: "new"));
+
+        var derived = new Template("Derived") { Id = 2, ParentTemplateId = 1 };
+        // Only the original placeholder is stored; "AddedLater" is missing → stale.
+        derived.Attributes.Add(Attr("Original", id: 20, templateId: 2, value: "v", isInherited: true));
+
+        var resolved = TemplateInheritanceResolver.Resolve(2, new[] { baseT, derived });
+
+        Assert.True(resolved.Staleness.IsStale);
+        Assert.Equal(1, resolved.Staleness.DifferingMemberCount);
+    }
+
+    [Fact]
+    public void Resolve_StalenessSummary_FalseWhenStoredRowsInSync()
+    {
+        var baseT = new Template("Base") { Id = 1 };
+        baseT.Attributes.Add(Attr("Speed", id: 10, templateId: 1, value: "100"));
+
+        var derived = new Template("Derived") { Id = 2, ParentTemplateId = 1 };
+        // Stored placeholder matches the live base value exactly.
+        derived.Attributes.Add(Attr("Speed", id: 20, templateId: 2, value: "100", isInherited: true));
+
+        var resolved = TemplateInheritanceResolver.Resolve(2, new[] { baseT, derived });
+
+        Assert.False(resolved.Staleness.IsStale);
+        Assert.Equal(0, resolved.Staleness.DifferingMemberCount);
+    }
+
+    [Fact]
+    public void Resolve_StalenessSummary_TrueWhenStoredInheritedValueIsStale()
+    {
+        var baseT = new Template("Base") { Id = 1 };
+        baseT.Attributes.Add(Attr("Speed", id: 10, templateId: 1, value: "fresh"));
+
+        var derived = new Template("Derived") { Id = 2, ParentTemplateId = 1 };
+        derived.Attributes.Add(Attr("Speed", id: 20, templateId: 2, value: "old", isInherited: true));
+
+        var resolved = TemplateInheritanceResolver.Resolve(2, new[] { baseT, derived });
+
+        Assert.True(resolved.Staleness.IsStale);
+        Assert.Equal(1, resolved.Staleness.DifferingMemberCount);
+    }
+
+    // ── (f) a composition-derived template resolves sanely ──
+
+    [Fact]
+    public void Resolve_CompositionDerivedTemplate_ResolvesOwnAndInheritedMembers()
+    {
+        // IsDerived templates back a composition slot; they still inherit from a
+        // base via ParentTemplateId. The resolver must handle them like any
+        // other derived template (inheritance only — composition is the
+        // flattener's concern).
+        var baseT = new Template("ComposedBase") { Id = 1 };
+        baseT.Attributes.Add(Attr("Pressure", id: 10, templateId: 1, value: "10"));
+
+        var derived = new Template("Slot") { Id = 2, ParentTemplateId = 1, IsDerived = true, OwnerCompositionId = 99 };
+        derived.Attributes.Add(Attr("LocalTweak", id: 20, templateId: 2, value: "t"));
+
+        var resolved = TemplateInheritanceResolver.Resolve(2, new[] { baseT, derived });
+
+        Assert.Equal(2, resolved.TemplateId);
+        Assert.Contains(resolved.Attributes, m => m.Name == "Pressure" && m.IsInherited);
+        Assert.Contains(resolved.Attributes, m => m.Name == "LocalTweak" && !m.IsInherited);
+    }
+
+    [Fact]
+    public void Resolve_UnknownTemplate_ReturnsEmptySet()
+    {
+        var resolved = TemplateInheritanceResolver.Resolve(999, Array.Empty<Template>());
+        Assert.Empty(resolved.Attributes);
+        Assert.False(resolved.Staleness.IsStale);
+    }
+
+    // ── Cross-member-type coverage: alarms, scripts, native alarm sources ──
+
+    [Fact]
+    public void Resolve_AllMemberTypes_TransitivelyInherited()
+    {
+        var a = new Template("A") { Id = 1 };
+        a.Attributes.Add(Attr("Attr", id: 10, templateId: 1, value: "v"));
+        a.Alarms.Add(new TemplateAlarm("Alarm") { Id = 11, TemplateId = 1, PriorityLevel = 5, TriggerType = AlarmTriggerType.ValueMatch });
+        a.Scripts.Add(new TemplateScript("Script", "code") { Id = 12, TemplateId = 1 });
+        a.NativeAlarmSources.Add(new TemplateNativeAlarmSource("Native") { Id = 13, TemplateId = 1, ConnectionName = "conn", SourceReference = "ns=2;s=Alarm" });
+
+        var b = new Template("B") { Id = 2, ParentTemplateId = 1 };
+        var c = new Template("C") { Id = 3, ParentTemplateId = 2 };
+
+        var resolved = TemplateInheritanceResolver.Resolve(3, new[] { a, b, c });
+
+        Assert.Contains(resolved.Attributes, m => m.Name == "Attr" && m.IsInherited && m.OriginTemplateName == "A");
+        Assert.Contains(resolved.Alarms, m => m.Name == "Alarm" && m.IsInherited && m.OriginTemplateName == "A");
+        Assert.Contains(resolved.Scripts, m => m.Name == "Script" && m.IsInherited && m.OriginTemplateName == "A");
+        Assert.Contains(resolved.NativeAlarmSources, m => m.Name == "Native" && m.IsInherited && m.OriginTemplateName == "A");
+    }
+
+    // ── Cross-check: the resolved inherited values MUST equal the flattener's
+    //    output for a no-override instance over the same chain. This is the
+    //    guarantee that the editor preview agrees with deploy. ──
+
+    [Fact]
+    public void Resolve_AgreesWithFlatteningService_ForNoOverrideInstance()
+    {
+        var a = new Template("A") { Id = 1 };
+        a.Attributes.Add(Attr("Speed", id: 10, templateId: 1, value: "100"));
+        a.Attributes.Add(Attr("BaseOnly", id: 11, templateId: 1, value: "b"));
+
+        var b = new Template("B") { Id = 2, ParentTemplateId = 1 };
+        // Override Speed; inherited placeholder for BaseOnly (stale value to prove live base wins).
+        b.Attributes.Add(Attr("Speed", id: 20, templateId: 2, value: "200", isInherited: false));
+        b.Attributes.Add(Attr("BaseOnly", id: 21, templateId: 2, value: "stale", isInherited: true));
+
+        var c = new Template("C") { Id = 3, ParentTemplateId = 2 };
+        c.Attributes.Add(Attr("ChildOnly", id: 30, templateId: 3, value: "c"));
+
+        var all = new[] { a, b, c };
+
+        // Resolver view.
+        var resolved = TemplateInheritanceResolver.Resolve(3, all);
+
+        // Flattener view: most-derived-first chain, no overrides, no compositions.
+        var instance = new Instance("inst") { Id = 1, TemplateId = 3, SiteId = 1 };
+        var chain = new List<Template> { c, b, a }; // most-derived first
+        var flat = new FlatteningService().Flatten(
+            instance,
+            chain,
+            new Dictionary<int, IReadOnlyList<TemplateComposition>>(),
+            new Dictionary<int, IReadOnlyList<Template>>(),
+            new Dictionary<int, DataConnection>());
+
+        Assert.True(flat.IsSuccess, flat.IsFailure ? flat.Error : null);
+
+        // Every flattened attribute value must equal the resolver's effective value.
+        foreach (var fa in flat.Value.Attributes)
+        {
+            var r = Assert.Single(resolved.Attributes, m => m.Name == fa.CanonicalName);
+            Assert.Equal(fa.Value, r.EffectiveValue);
+        }
+        Assert.Equal(flat.Value.Attributes.Count, resolved.Attributes.Count);
+    }
+}