@@ -81,11 +81,16 @@ booted over HTTP) are wired and green for:
   converter refuses polymorphic bodies → HTTP 415), so the Kotlin generated lane
   wires a small Jackson `JsonElement` codec module (the consumer's serialization
   wiring).
-
-Deferred (corpus is ready; follow-up): **Java**, **C#**. Their api-contract
-harnesses bind the per-entity DTO shape statically (the JVM generated harness
-reflects a fixed `Author` constructor arity + ships a hand-written in-memory repo
-source; the C# generated lane is full-stack EF + Kestrel), so adding the
-`Document` entity means a new reference server + generated harness per port
-(mirroring their `m2m/` and `tph/` sub-corpus harnesses) rather than a focused
+- **C#** — reference (hand-rolled `HttpListener` over Postgres testcontainer) +
+  generated (the real `MetaObjects.Codegen` `DocumentRoutes` + `AppDbContext`
+  Roslyn-compiled and booted full-stack on Kestrel over Postgres testcontainer).
+  The generated lane locks the #105 codegen: the `payload` property is typed
+  `System.Text.Json.JsonDocument` (Npgsql ↔ jsonb native), so a posted object
+  binds with no string validator and round-trips parsed.
+
+Deferred (corpus is ready; follow-up): **Java**. Its api-contract harness binds
+the per-entity DTO shape statically (the JVM generated harness reflects a fixed
+`Author` constructor arity + ships a hand-written in-memory repo source), so
+adding the `Document` entity means a new reference server + generated harness
+(mirroring its `m2m/` and `tph/` sub-corpus harnesses) rather than a focused
 fixture edit. Tracked in #98.
@@ -68,6 +68,36 @@ public void Jsonb_field_emits_JsonDocument_property_not_string()
         Assert.Contains("using System.Text.Json;", src);
     }
 
+    [Fact]
+    public void Jsonb_field_carries_no_string_validation_attributes()
+    {
+        // Runtime-write verification (#98): C# has no ObjectManager runtime tier —
+        // EF Core IS the runtime, and the generated minimal-API create route binds the
+        // POST body straight onto the entity. Because the jsonb open-bag property is
+        // typed JsonDocument (not string), the generator must NOT decorate it with any
+        // string type/length validator ([MaxLength]/[StringLength]/[Required]) that would
+        // reject a posted JSON object on write. Assert the emitted Payload property block
+        // carries only [Column("payload")] — no string-validation annotation.
+        var ctx = Ctx(Load(Model));
+        var src = Assert.Single(new EntityGenerator().Generate(ctx)).Content;
+
+        var lines = src.Split('\n');
+        int idx = Array.FindIndex(lines, l => l.Contains("public JsonDocument? Payload"));
+        Assert.True(idx >= 0, "generated source must declare the JsonDocument Payload property");
+
+        // Walk back over the attribute lines immediately preceding the property and
+        // confirm none is a string validator. [Column("payload")] is expected + allowed.
+        for (int i = idx - 1; i >= 0; i--)
+        {
+            string t = lines[i].Trim();
+            if (t.Length == 0) break;
+            if (!t.StartsWith("[")) break;            // reached the prior property body
+            Assert.False(t.StartsWith("[MaxLength"),  "jsonb Payload must not carry [MaxLength] (would reject an object on write)");
+            Assert.False(t.StartsWith("[StringLength"), "jsonb Payload must not carry [StringLength]");
+            Assert.False(t.StartsWith("[Required"),   "jsonb Payload (not @required) must not carry [Required]");
+        }
+    }
+
     [Fact]
     public void Uuid_override_field_stays_string()
     {
 
@@ -32,4 +32,13 @@ internal static class ApiContractCorpusPaths
     public static readonly string TphScenariosDir = Path.Combine(TphDir, "scenarios");
     public static readonly string TphSeedFile = Path.Combine(TphDir, "seed.json");
     public static readonly string TphMetaJson = Path.Combine(TphDir, "meta.json");
+
+    // #98 jsonb open-bag corpus — a single Document entity with one
+    // `field.string @dbColumnType:jsonb` open-JSON column, under jsonb/. The
+    // contract: a posted JSON OBJECT round-trips as an OBJECT (not a stringified
+    // `"{\"k\":\"v\"}"`).
+    public static readonly string JsonbDir = Path.Combine(Corpus, "jsonb");
+    public static readonly string JsonbScenariosDir = Path.Combine(JsonbDir, "scenarios");
+    public static readonly string JsonbSeedFile = Path.Combine(JsonbDir, "seed.json");
+    public static readonly string JsonbMetaJson = Path.Combine(JsonbDir, "meta.json");
 }
@@ -0,0 +1,106 @@
+// ApiContractJsonbConformanceTest — #98: the C# jsonb open-bag api-contract lanes.
+//
+// Drives the fixtures/api-contract-conformance/jsonb/ scenarios over HTTP against
+// BOTH lanes:
+//   1. the HAND-ROLLED reference server (JsonbReferenceServer), and
+//   2. the GENERATED routes artifact (JsonbGeneratedServerFactory) — the emitted
+//      DocumentRoutes over the emitted AppDbContext, booted unmodified on Kestrel.
+//
+// The contract: a `field.string @dbColumnType:jsonb` open bag must accept a posted
+// JSON OBJECT and surface it back as a parsed OBJECT (not a double-encoded string).
+// The generated lane LOCKS the #105 codegen (payload property typed JsonDocument); a
+// regressed port that returned `"{\"k\":\"v\"}"` fails the body.row deep-equal.
+//
+// One Postgres testcontainer per scenario per lane (full isolation, mirrors the TPH +
+// m2m lanes). The two lanes share the corpus + scenario loader + assertion vocabulary.
+//
+// Run on-demand (Docker required):
+//   dotnet test server/csharp/MetaObjects.IntegrationTests/MetaObjects.IntegrationTests.csproj \
+//     --filter "FullyQualifiedName~ApiContractJsonb"
+
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using MetaObjects.IntegrationTests.Runner;
+using Xunit;
+
+namespace MetaObjects.IntegrationTests.Api;
+
+public sealed class ApiContractJsonbConformanceTest
+{
+    [Theory]
+    [MemberData(nameof(Scenarios))]
+    public async Task Api_contract_jsonb_reference(string scenarioPath)
+    {
+        var scenario = ApiContractScenarioLoader.LoadScenario(scenarioPath);
+        await using var pg = await PostgresContainer.StartAsync();
+        await using var server = await JsonbReferenceServer.StartAsync(pg);
+        await server.ApplySeedAsync();
+        await RunAsync(scenario, server.BaseUrl);
+    }
+
+    [Theory]
+    [MemberData(nameof(Scenarios))]
+    public async Task Api_contract_jsonb_generated(string scenarioPath)
+    {
+        var scenario = ApiContractScenarioLoader.LoadScenario(scenarioPath);
+        await using var pg = await PostgresContainer.StartAsync();
+        await using var server = await JsonbGeneratedServerFactory.StartAsync(pg);
+        await server.ApplySeedAsync();
+        await RunAsync(scenario, server.BaseUrl);
+    }
+
+    private static async Task RunAsync(ApiScenario scenario, string baseUrl)
+    {
+        using var client = new HttpClient { BaseAddress = new Uri(baseUrl) };
+        foreach (var req in scenario.Requests)
+        {
+            var request = new HttpRequestMessage(new HttpMethod(req.Method), req.Path);
+            if (req.Body is not null)
+            {
+                string json = JsonSerializer.Serialize(req.Body, JsonOpts);
+                request.Content = new StringContent(json, Encoding.UTF8, "application/json");
+            }
+            var response = await client.SendAsync(request);
+            string bodyText = await response.Content.ReadAsStringAsync();
+            object? parsed = string.IsNullOrEmpty(bodyText) ? null : ToObject(JsonNode.Parse(bodyText));
+            ApiContractAssertions.AssertResponse(scenario.Name, req, (int)response.StatusCode, parsed);
+        }
+    }
+
+    public static IEnumerable<object[]> Scenarios() =>
+        Directory.EnumerateFiles(ApiContractCorpusPaths.JsonbScenariosDir, "*.yaml", SearchOption.TopDirectoryOnly)
+            .OrderBy(p => p, StringComparer.Ordinal)
+            .Select(p => new object[] { p });
+
+    private static readonly JsonSerializerOptions JsonOpts = new()
+    {
+        DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.Never,
+    };
+
+    private static object? ToObject(JsonNode? node)
+    {
+        if (node is null) return null;
+        if (node is JsonObject obj)
+        {
+            var d = new Dictionary<string, object?>(StringComparer.Ordinal);
+            foreach (var kvp in obj) d[kvp.Key] = ToObject(kvp.Value);
+            return d;
+        }
+        if (node is JsonArray arr)
+        {
+            var l = new List<object?>(arr.Count);
+            foreach (var item in arr) l.Add(ToObject(item));
+            return l;
+        }
+        if (node is JsonValue jv)
+        {
+            if (jv.TryGetValue<bool>(out var b)) return b;
+            if (jv.TryGetValue<long>(out var lv)) return lv;
+            if (jv.TryGetValue<double>(out var dv)) return dv;
+            if (jv.TryGetValue<string>(out var sv)) return sv;
+            return jv.ToString();
+        }
+        return null;
+    }
+}
@@ -0,0 +1,83 @@
+// JsonbFixture — schema-provisioning + seed for the #98 jsonb open-bag api-contract
+// lanes (reference + generated). One `documents` table whose `payload` column is a
+// native Postgres `jsonb` (the open-JSON bag). The DDL mirrors what the Document
+// entity's generators describe: id bigserial-style identity, title VARCHAR(200)
+// NOT NULL, payload jsonb (nullable). The seed is jsonb/seed.json — payload rows are
+// JSON objects bound as jsonb.
+
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using Npgsql;
+using NpgsqlTypes;
+
+namespace MetaObjects.IntegrationTests.Api;
+
+internal static class JsonbFixture
+{
+    // BIGINT GENERATED BY DEFAULT AS IDENTITY so the seed can insert explicit ids and
+    // a later implicit insert (create) lands past the seeded max. payload is native
+    // jsonb — Npgsql materializes it into the generated entity's JsonDocument property.
+    public const string SchemaDdl = """
+        CREATE TABLE "documents" (
+          "id" BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
+          "title" VARCHAR(200) NOT NULL,
+          "payload" jsonb,
+          CONSTRAINT "documents_pkey" PRIMARY KEY ("id")
+        );
+        """;
+
+    /// <summary>Create the single `documents` table on a fresh container.</summary>
+    public static async Task ProvisionSchemaAsync(string connString)
+    {
+        await using var c = new NpgsqlConnection(connString);
+        await c.OpenAsync();
+        await using var cmd = c.CreateCommand();
+        cmd.CommandText = SchemaDdl;
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    /// <summary>
+    /// Truncate + apply jsonb/seed.json (explicit ids; payload bound as jsonb), then
+    /// bump the identity sequence past the seeded max so a later create lands at
+    /// max(id)+1 (the create-201 contract depends on a deterministic next id).
+    /// </summary>
+    public static async Task ApplySeedAsync(string connString, string seedPath)
+    {
+        var root = JsonNode.Parse(File.ReadAllText(seedPath)) as JsonObject
+            ?? throw new InvalidOperationException($"{seedPath}: top-level must be an object");
+
+        await using var c = new NpgsqlConnection(connString);
+        await c.OpenAsync();
+
+        await using (var trunc = c.CreateCommand())
+        {
+            trunc.CommandText = "TRUNCATE TABLE \"documents\" RESTART IDENTITY";
+            await trunc.ExecuteNonQueryAsync();
+        }
+
+        if (root["rows"] is JsonArray rows)
+        {
+            foreach (var rowNode in rows)
+            {
+                if (rowNode is not JsonObject row) continue;
+                await using var ins = c.CreateCommand();
+                ins.CommandText =
+                    "INSERT INTO \"documents\" (\"id\", \"title\", \"payload\") VALUES (@id, @title, @payload)";
+                ins.Parameters.AddWithValue("@id", row["id"]!.GetValue<long>());
+                ins.Parameters.AddWithValue("@title", row["title"]!.GetValue<string>());
+                // payload is a JSON object/array/scalar — serialize it and bind as jsonb.
+                var payload = row["payload"];
+                if (payload is null || payload.GetValueKind() == JsonValueKind.Null)
+                    ins.Parameters.Add(new NpgsqlParameter("@payload", NpgsqlDbType.Jsonb) { Value = DBNull.Value });
+                else
+                    ins.Parameters.Add(new NpgsqlParameter("@payload", NpgsqlDbType.Jsonb) { Value = payload.ToJsonString() });
+                await ins.ExecuteNonQueryAsync();
+            }
+        }
+
+        await using var bump = c.CreateCommand();
+        bump.CommandText =
+            "SELECT setval(pg_get_serial_sequence('documents', 'id'), COALESCE((SELECT MAX(id) FROM \"documents\"), 1))";
+        await bump.ExecuteScalarAsync();
+    }
+}