diff --git a/src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Management/ResolvedTemplateMembers.cs b/src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Management/ResolvedTemplateMembers.cs
new file mode 100644
index 00000000..abb99456
--- /dev/null
+++ b/src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Management/ResolvedTemplateMembers.cs
@@ -0,0 +1,117 @@
+namespace ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
+
+///
+/// Read-only response for : 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.
+///
+///
+///
+/// The precedence used to compute the effective member set MIRRORS
+/// FlatteningService.ResolveInherited* exactly (derived wins;
+/// IsInherited 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.
+///
+///
+/// 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.
+///
+///
+public sealed record ResolvedTemplateMembers
+{
+ /// The template the member set was resolved for.
+ public int TemplateId { get; init; }
+ /// The template's name.
+ public string TemplateName { get; init; } = string.Empty;
+ /// The immediate parent template id, or null when this is a root template.
+ public int? ParentTemplateId { get; init; }
+
+ /// The effective resolved attributes (own + transitively inherited).
+ public IReadOnlyList Attributes { get; init; } = [];
+ /// The effective resolved alarms (own + transitively inherited).
+ public IReadOnlyList Alarms { get; init; } = [];
+ /// The effective resolved scripts (own + transitively inherited).
+ public IReadOnlyList Scripts { get; init; } = [];
+ /// The effective resolved native alarm source bindings (own + transitively inherited).
+ public IReadOnlyList NativeAlarmSources { get; init; } = [];
+
+ ///
+ /// 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.
+ ///
+ public ResolvedTemplateStaleness Staleness { get; init; } = new();
+}
+
+///
+/// One effective member in a set,
+/// annotated with where its winning definition came from and its lock state.
+///
+public sealed record ResolvedTemplateMemberInfo
+{
+ /// The member name (bare; inheritance-resolved members are never path-qualified).
+ public string Name { get; init; } = string.Empty;
+
+ ///
+ /// True when the winning definition lives on an ANCESTOR template rather
+ /// than on the resolved template itself — i.e. this member is inherited.
+ ///
+ public bool IsInherited { get; init; }
+
+ /// The id of the template that supplied the winning definition.
+ public int OriginTemplateId { get; init; }
+ /// The name of the template that supplied the winning definition.
+ public string OriginTemplateName { get; init; } = string.Empty;
+
+ ///
+ /// True when the member is locked from override (IsLocked on the
+ /// winning row) — a derived template cannot change it.
+ ///
+ public bool IsLocked { get; init; }
+
+ ///
+ /// True when an ANCESTOR marked this member LockedInDerived — the
+ /// derived template may not override it (rendered read-only with a lock in
+ /// the editor). Distinct from : a base may forbid
+ /// override (LockedInDerived) without the member itself being a
+ /// locked composition member.
+ ///
+ public bool IsBaseLocked { get; init; }
+
+ ///
+ /// 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.
+ ///
+ public string? EffectiveValue { get; init; }
+}
+
+///
+/// Staleness summary comparing a template's STORED member rows against the
+/// freshly-resolved inherited member set.
+///
+public sealed record ResolvedTemplateStaleness
+{
+ ///
+ /// 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.
+ ///
+ public bool IsStale { get; init; }
+
+ ///
+ /// 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.
+ ///
+ public int DifferingMemberCount { get; init; }
+}
diff --git a/src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Management/TemplateCommands.cs b/src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Management/TemplateCommands.cs
index 875d3758..7493d77c 100644
--- a/src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Management/TemplateCommands.cs
+++ b/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);
+///
+/// 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: .
+///
+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);
diff --git a/src/ZB.MOM.WW.ScadaBridge.ManagementService/ManagementActor.cs b/src/ZB.MOM.WW.ScadaBridge.ManagementService/ManagementActor.cs
index 85f0b005..9fdb49aa 100644
--- a/src/ZB.MOM.WW.ScadaBridge.ManagementService/ManagementActor.cs
+++ b/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;
}
+ ///
+ /// 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.
+ ///
+ private static async Task HandleGetResolvedTemplateMembers(IServiceProvider sp, GetResolvedTemplateMembersCommand cmd)
+ {
+ var repo = sp.GetRequiredService();
+ var allTemplates = await repo.GetAllTemplatesAsync();
+ return TemplateInheritanceResolver.Resolve(cmd.TemplateId, allTemplates);
+ }
+
// ========================================================================
// Template folder handlers
// ========================================================================
diff --git a/src/ZB.MOM.WW.ScadaBridge.TemplateEngine/TemplateInheritanceResolver.cs b/src/ZB.MOM.WW.ScadaBridge.TemplateEngine/TemplateInheritanceResolver.cs
new file mode 100644
index 00000000..098aa955
--- /dev/null
+++ b/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;
+
+///
+/// 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
+/// ), 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.
+///
+///
+/// The inheritance precedence here MIRRORS
+/// 's ResolveInherited* methods
+/// EXACTLY so the editor preview agrees with what a deploy would produce:
+/// walk base → derived (derived wins); an IsInherited 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
+/// LockedInDerived flag is propagated so the editor can render the
+/// member read-only.
+///
+///
+///
+/// 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.
+///
+///
+public static class TemplateInheritanceResolver
+{
+ ///
+ /// Resolves the effective inherited member set for .
+ ///
+ /// The template to resolve members for.
+ /// The complete set of templates (for chain lookups).
+ ///
+ /// 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.
+ ///
+ public static ResolvedTemplateMembers Resolve(int templateId, IReadOnlyList 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) ──
+
+ /// The winning row for a member, plus where it came from.
+ private sealed record Winner(T Row, Template Origin, bool BaseLocked);
+
+ ///
+ /// Generic base → derived walk that picks the winning row per member name,
+ /// replicating FlatteningService precedence:
+ /// derived wins; an IsInherited placeholder does not shadow a live
+ /// ancestor value; a locked member is not overridden downstream; the
+ /// ancestor LockedInDerived flag is tracked.
+ ///
+ private static Dictionary> ResolveWinners(
+ IReadOnlyList chain,
+ Func> select,
+ Func nameOf,
+ Func isInherited,
+ Func isLocked,
+ Func lockedInDerived)
+ {
+ var result = new Dictionary>(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(row, template, baseLocked);
+ }
+ }
+
+ return result;
+ }
+
+ private static IReadOnlyList ResolveAttributes(
+ IReadOnlyList 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 ResolveAlarms(
+ IReadOnlyList 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 ResolveScripts(
+ IReadOnlyList 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 ResolveNativeAlarmSources(
+ IReadOnlyList 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 Project(
+ Dictionary> winners,
+ int selfId,
+ Func, 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 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 row) => row switch
+ {
+ TemplateAttribute a => a.IsLocked,
+ TemplateAlarm a => a.IsLocked,
+ TemplateScript s => s.IsLocked,
+ TemplateNativeAlarmSource s => s.IsLocked,
+ _ => false
+ };
+
+ // ── staleness ──
+
+ ///
+ /// 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.
+ ///
+ private static ResolvedTemplateStaleness ComputeStaleness(
+ Template self,
+ IReadOnlyList attributes,
+ IReadOnlyList alarms,
+ IReadOnlyList scripts,
+ IReadOnlyList 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 resolved,
+ IReadOnlyDictionary 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;
+ }
+}
diff --git a/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateInheritanceResolverTests.cs b/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/TemplateInheritanceResolverTests.cs
new file mode 100644
index 00000000..1267b933
--- /dev/null
+++ b/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;
+
+///
+/// Tests for the read-only authoring resolve service (M9/T26a). The resolved
+/// inherited member set MUST agree with what
+/// produces on deploy — the precedence is exercised both directly and via a
+/// cross-check against the flattener.
+///
+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());
+ 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 { c, b, a }; // most-derived first
+ var flat = new FlatteningService().Flatten(
+ instance,
+ chain,
+ new Dictionary>(),
+ new Dictionary>(),
+ new Dictionary());
+
+ 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);
+ }
+}