chore(codegen-csharp): relabel package-binding off "FR-021" (number reused for api-metadata)

The cross-port package→namespace binding (PackageBindingResolver + GenConfig
PackageNamespaces/Convention/TypeOverrides) was tagged "FR-021" in comments, one
user-facing error message, and a test file/class name. The FR-021 number now
designates the new `api` metadata + contract-projections design (roadmap), so
those tags collided. This drops the stale "FR-021" tag in favor of a plain
"package-binding" description — no dangling spec reference, no behavior change.

- 15 comment/doc refs across PackageBindingResolver/Generator/EntityGenerator/
  DbContextGenerator/CallableGenerator → "Package-binding"
- the unmapped-package InvalidOperationException message no longer says "FR-021 —"
- Fr021PackageBindingResolverTests.cs → PackageBindingResolverTests.cs (+ class)
- FR-019 references (the provided-enum feature) left intact — still valid

Pure relabel; Codegen 208/0, no functional change.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

…ests/Fr021PackageBindingResolverTests.cs …gen.Tests/PackageBindingResolverTests.csserver/csharp/MetaObjects.Codegen.Tests/Fr021PackageBindingResolverTests.cs renamed to server/csharp/MetaObjects.Codegen.Tests/PackageBindingResolverTests.cs server/csharp/MetaObjects.Codegen.Tests/Fr021PackageBindingResolverTests.cs renamed to server/csharp/MetaObjects.Codegen.Tests/PackageBindingResolverTests.cs

@@ -1,4 +1,4 @@
-// FR-021 — central package-binding resolver tests.
+// Package-binding resolver tests (package-binding renumbered away — api-metadata reused that number).
 // Covers each layer of the resolution order:
 //   1. TypeOverrides (most specific)
 //   2. PackageNamespaces (package-level overrides)
@@ -11,7 +11,7 @@
 
 namespace MetaObjects.Codegen.Tests;
 
-public class Fr021PackageBindingResolverTests
+public class PackageBindingResolverTests
 {
     private static GenConfig CfgWithDefaults() => new()
     {

server/csharp/MetaObjects.Codegen/Generator.cs

@@ -58,15 +58,15 @@ public sealed record GenConfig
     public Dictionary<string, string> PackageNamespaces { get; init; } = new();
 
     /// <summary>
-    /// FR-021 — convention rule that derives a C# namespace from a metadata package
+    /// Package-binding — convention rule that derives a C# namespace from a metadata package
     /// when no explicit override matches. Covers the 90% case so an adopter with N
     /// domains needs ~1 line of config, not N. Unset (null) ⇒ no convention applied;
     /// resolution falls through to <see cref="UnmappedStrategy"/>.
     /// </summary>
     public PackageBindingConvention? Convention { get; init; }
 
     /// <summary>
-    /// FR-021 — type-level overrides keyed by fully-qualified type name
+    /// Package-binding — type-level overrides keyed by fully-qualified type name
     /// (<c>&lt;package&gt;::&lt;typeName&gt;</c>). Wins over package-level
     /// <see cref="PackageNamespaces"/> and the <see cref="Convention"/> rule. Use when
     /// a single entity / value-object / enum in an otherwise-uniform package needs to
@@ -75,7 +75,7 @@ public sealed record GenConfig
     public Dictionary<string, string> TypeOverrides { get; init; } = new();
 
     /// <summary>
-    /// FR-021 — what to do when neither overrides nor the <see cref="Convention"/> rule
+    /// Package-binding — what to do when neither overrides nor the <see cref="Convention"/> rule
     /// resolves a metadata package. Defaults to <see cref="UnmappedPackageStrategy.Flatten"/>
     /// (today's behavior: fall back to <see cref="Namespace"/>). Setting to
     /// <see cref="UnmappedPackageStrategy.Error"/> forces explicit mapping (recommended
@@ -85,7 +85,7 @@ public sealed record GenConfig
     public UnmappedPackageStrategy UnmappedStrategy { get; init; } = UnmappedPackageStrategy.Flatten;
 }
 
-/// <summary>FR-021 — convention rule that derives a target namespace from a metadata
+/// <summary>Package-binding — convention rule that derives a target namespace from a metadata
 /// package. Resolution: split the package on <c>::</c>, strip the leading
 /// <see cref="Strip"/> prefix (if matched), transform each remaining segment per
 /// <see cref="Case"/>, join by <see cref="Separator"/>, prepend <see cref="Prepend"/>.
@@ -111,7 +111,7 @@ public sealed record PackageBindingConvention
     /// the metadata package on <c>::</c>, BEFORE joining by <see cref="Separator"/>.</summary>
     public PackageCase Case { get; init; } = PackageCase.PascalCase;
 
-    /// <summary>FR-021 — alternate <see cref="Prepend"/> applied when resolving an
+    /// <summary>Package-binding — alternate <see cref="Prepend"/> applied when resolving an
     /// abstract <c>field.enum</c> with <c>@provided: true</c> (the FR-019 shared-enum
     /// reference case). When set, the convention rule's strip / case / separator stay
     /// the same; only the prepended root differs. Lets adopters route <c>@provided</c>

server/csharp/MetaObjects.Codegen/Generators/CallableGenerator.cs

@@ -72,7 +72,7 @@ protected override EmittedFile GenerateOne(MetaObject entity, GenContext ctx)
         sb.AppendLine("using System.Collections.Generic;");
         sb.AppendLine("using System.Threading.Tasks;");
         sb.AppendLine("using Microsoft.EntityFrameworkCore;");
-        // FR-021 — the callable's home namespace + the args VO's namespace, when split.
+        // Package-binding — the callable's home namespace + the args VO's namespace, when split.
         // The callable file declares a `static class {cls}Callable` referencing the
         // result type and the args type; both can live in different per-package
         // namespaces from where AppDbContext lives.

server/csharp/MetaObjects.Codegen/Generators/DbContextGenerator.cs

@@ -182,7 +182,7 @@ protected virtual void EmitUsings(StringBuilder sb, bool needsMetadataUsing, Gen
         sb.AppendLine("using Microsoft.EntityFrameworkCore;");
         if (needsMetadataUsing)
             sb.AppendLine("using Microsoft.EntityFrameworkCore.Metadata;");
-        // FR-021 — pull in every per-package namespace the model uses. The DbContext
+        // Package-binding — pull in every per-package namespace the model uses. The DbContext
         // references EVERY entity by short name (DbSet<X>, modelBuilder.Entity<X>()),
         // so it needs a `using` for each distinct namespace the entities resolve to.
         var dbCtxNs = ctx.Config.Namespace;

server/csharp/MetaObjects.Codegen/Generators/EntityGenerator.cs

@@ -114,7 +114,7 @@ protected virtual EmittedFile EmitMappedClass(MetaObject entity, GenContext ctx)
         // host project's ImplicitUsings.
         if (pkFields.Count > 1)
             sb.AppendLine("using Microsoft.EntityFrameworkCore;");
-        // FR-021 — usings for OTHER packages this entity references (object navs + TPH base).
+        // Package-binding — usings for OTHER packages this entity references (object navs + TPH base).
         foreach (var ns in PackageBindingResolver.CrossPackageReferencedNamespaces(entity, ctx.Root, ctx.Config))
             sb.AppendLine($"using {ns};");
         EmitFileUsings(sb, entity, ctx);
@@ -294,7 +294,7 @@ protected virtual EmittedFile EmitTphSubtypeClass(MetaObject entity, GenContext
         sb.AppendLine("using System.Collections.Generic;");
         sb.AppendLine("using System.ComponentModel.DataAnnotations;");
         sb.AppendLine("using System.ComponentModel.DataAnnotations.Schema;");
-        // FR-021 — usings for OTHER packages this entity references (object navs + TPH base).
+        // Package-binding — usings for OTHER packages this entity references (object navs + TPH base).
         foreach (var ns in PackageBindingResolver.CrossPackageReferencedNamespaces(entity, ctx.Root, ctx.Config))
             sb.AppendLine($"using {ns};");
         EmitFileUsings(sb, entity, ctx);
@@ -419,7 +419,7 @@ protected virtual EmittedFile EmitAbstractShapeClass(MetaObject entity, GenConte
         sb.AppendLine("#nullable enable");
         sb.AppendLine("using System;");
         sb.AppendLine("using System.Collections.Generic;");
-        // FR-021 — usings for OTHER packages this entity references (object navs + TPH base).
+        // Package-binding — usings for OTHER packages this entity references (object navs + TPH base).
         foreach (var ns in PackageBindingResolver.CrossPackageReferencedNamespaces(entity, ctx.Root, ctx.Config))
             sb.AppendLine($"using {ns};");
         EmitFileUsings(sb, entity, ctx);
@@ -474,7 +474,7 @@ protected virtual EmittedFile EmitValueObjectPoco(MetaObject vo, GenContext ctx)
         sb.AppendLine("#nullable enable");
         sb.AppendLine("using System;");
         sb.AppendLine("using System.Collections.Generic;");
-        // FR-021 — usings for OTHER packages this value-object references (object navs + super).
+        // Package-binding — usings for OTHER packages this value-object references (object navs + super).
         foreach (var ns in PackageBindingResolver.CrossPackageReferencedNamespaces(vo, ctx.Root, ctx.Config))
             sb.AppendLine($"using {ns};");
         EmitFileUsings(sb, vo, ctx);

server/csharp/MetaObjects.Codegen/PackageBindingResolver.cs

@@ -1,4 +1,4 @@
-// FR-021 — central resolver from (metadataPackage, typeName?) to per-port output
+// Package-binding — central resolver from (metadataPackage, typeName?) to per-port output
 // identity (in C#, the namespace). Resolution order, evaluated for every named type:
 //
 //   1. Type-level override        — config.TypeOverrides["<pkg>::<typeName>"]
@@ -15,7 +15,7 @@
 
 namespace MetaObjects.Codegen;
 
-/// <summary>FR-021 — central package-binding resolver.</summary>
+/// <summary>Package-binding — central package-binding resolver.</summary>
 public static class PackageBindingResolver
 {
     /// <summary>The metaobjects-standard package separator (cross-port invariant). Always <c>::</c>.</summary>
@@ -70,7 +70,7 @@ void Consider(MetaObjects.Meta.MetaObject? target)
 
     /// <summary>
     /// Resolve a metadata package (and optional type name) to its target C# namespace per the
-    /// FR-021 resolution order. Throws <see cref="InvalidOperationException"/> when the package
+    /// package-binding resolution order. Throws <see cref="InvalidOperationException"/> when the package
     /// is unresolvable and <see cref="GenConfig.UnmappedStrategy"/> is
     /// <see cref="UnmappedPackageStrategy.Error"/>.
     /// </summary>
@@ -289,7 +289,7 @@ private static InvalidOperationException BuildErrorForUnmapped(string? package,
         var typeRef = string.IsNullOrEmpty(typeName) ? "" : $" (type \"{typeName}\")";
         var contextSuffix = string.IsNullOrEmpty(context) ? "" : $" — referenced from {context}";
         return new InvalidOperationException(
-            $"FR-021 — metadata package \"{pkgRef}\"{typeRef} has no namespace binding{contextSuffix}. " +
+            $"Package-binding — metadata package \"{pkgRef}\"{typeRef} has no namespace binding{contextSuffix}. " +
             $"Add an entry to PackageNamespaces (e.g. {{ \"{pkgRef}\", \"YourApp.Namespace\" }}), " +
             $"a TypeOverrides entry, or a Convention rule that matches this package — " +
             $"or set UnmappedStrategy = Flatten to fall back to the default Namespace.");