@@ -210,7 +210,20 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
         val uuidGeneratedPk = primary?.isUuid == true && !isView && singlePrimaryFieldName != null
 
         val objectColumns = buildObjectColumns(entity, primaryFieldSet, loader)
-        val needsJsonbImport = objectColumns.any { it.kind == ObjectColumnKind.JSONB }
+        // A `field.string @dbColumnType=jsonb` open bag now decodes to a kotlinx `JsonElement`
+        // (issue #98) via `{ Json.parseToJsonElement(it) }`, so its table file needs the
+        // `kotlinx.serialization.json.Json` import too (same import block as the object/map jsonb
+        // columns below). Detect it on direct fields AND flattened object sub-fields — the same two
+        // surfaces that contribute columns / imports. Folding it into `needsJsonbImport` (rather
+        // than `columnFunctionImports`) keeps the `jsonb` extension import emitted exactly once.
+        val hasStringJsonbOpenBag = entity.metaFields.any { KotlinTypeMapper.isJsonbOpenBag(it) } ||
+            entity.metaFields.any { f ->
+                f is ObjectField && readStorage(f) == STORAGE_FLATTENED &&
+                    (readObjectRef(f)?.let { KotlinGenUtil.resolveObjectByShortOrFqn(loader, it) }
+                        ?.metaFields?.any { KotlinTypeMapper.isJsonbOpenBag(it) } ?: false)
+            }
+        val needsJsonbImport =
+            objectColumns.any { it.kind == ObjectColumnKind.JSONB } || hasStringJsonbOpenBag
         val needsRefOptForDecor = refDecorations.values.any { it.hasReferenceOption }
 
         // Does any column on this table use the TZ-aware `@dbColumnType=timestamp_with_tz`
@@ -252,6 +265,10 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
             // of what the type-mapper would return for a bare column emission — skip it
             // here so it doesn't accidentally drag in a non-applicable import.
             if (field is EnumField) continue
+            // The `field.string @dbColumnType=jsonb` open bag's `jsonb` extension import is
+            // emitted via needsJsonbImport (alongside the `Json` import its codec needs) — skip
+            // here so the `import ...json.jsonb` line isn't emitted twice.
+            if (KotlinTypeMapper.isJsonbOpenBag(field)) continue
             KotlinTypeMapper.exposedColumnImport(field)?.let { columnFunctionImports += it }
         }
         // Flattened object sub-columns also contribute column functions (and thus
@@ -264,6 +281,8 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
             val target = KotlinGenUtil.resolveObjectByShortOrFqn(loader, ref) ?: continue
             for (subField in target.metaFields) {
                 if (subField is EnumField) continue
+                // jsonb open bag → its `jsonb`/`Json` imports come via needsJsonbImport (skip here).
+                if (KotlinTypeMapper.isJsonbOpenBag(subField)) continue
                 KotlinTypeMapper.exposedColumnImport(subField)?.let { columnFunctionImports += it }
             }
         }
 
@@ -120,15 +120,19 @@ object KotlinTypeMapper {
 
     /**
      * The kotlinx-serialization JSON-value type a `field.string @dbColumnType=jsonb` open-bag is
-     * exposed as in the REST/serialization PAYLOAD (issue #98). `JsonElement` is the idiomatic
-     * "any JSON value" type for the `@Serializable` payload data classes [KotlinPayloadGenerator]
-     * emits (kotlinx is already this port's payload substrate — the same `Json` used by the
-     * `jsonb(...)` column codec for `field.map`), so a client sends/receives a real JSON object
-     * rather than a double-encoded string. The PERSISTENCE side is deliberately unaffected: the
-     * entity data-class property ([kotlinTypeName]) stays `String` (raw text from the JDBC driver)
-     * and the Exposed column ([exposedColumnSpec]) stays the identity-codec `jsonb(name,{it},{it})`.
+     * exposed as (issue #98). `JsonElement` is the idiomatic "any JSON value" type for the
+     * `@Serializable` data classes this port emits (kotlinx is already this port's payload
+     * substrate — the same `Json` used by the `jsonb(...)` column codec for `field.map`), so a
+     * client sends/receives a real JSON object rather than a double-encoded string.
+     *
+     * Used UNIFORMLY at every layer — the persistence holder ([kotlinTypeName], i.e. the entity
+     * data class reused as the entity-CRUD DTO), the REST payload ([payloadTypeName]), and the
+     * Exposed column codec ([exposedColumnSpec], which decodes the JSONB text to a `JsonElement`).
+     * Matching the maintainer decision on #98: uniform parsed value at the API boundary across all
+     * ports (TS `z.unknown()`, Python `Any`, C# `JsonDocument`). The wire/serialized form stays
+     * byte-identical to those ports (`{...}`); only the in-process Kotlin type is `JsonElement`.
      */
-    private val PAYLOAD_JSON_VALUE_TYPE = ClassName("kotlinx.serialization.json", "JsonElement")
+    private val JSON_VALUE_TYPE = ClassName("kotlinx.serialization.json", "JsonElement")
 
     /**
      * Name of the generated, file-local Exposed extension function emitted for a
@@ -210,10 +214,14 @@ object KotlinTypeMapper {
     /** Map a MetaField to its KotlinPoet data-class property TypeName. */
     fun kotlinTypeName(field: MetaField<*>): TypeName = when (field) {
         // `@dbColumnType=uuid_array/text_array` makes a field.string a native SQL array,
-        // so the property is a List<UUID> / List<String>. Plain strings stay String.
+        // so the property is a List<UUID> / List<String>. `@dbColumnType=jsonb` is the open
+        // JSON bag — a parsed JSON value (kotlinx `JsonElement`, issue #98), uniform with the
+        // payload + Exposed column codec so the entity-CRUD DTO is never a double-encoded String.
+        // Plain strings stay String.
         is StringField    -> when (dbColumnType(field)) {
             DB_COLUMN_TYPE_UUID_ARRAY -> LIST.parameterizedBy(ClassName("java.util", "UUID"))
             DB_COLUMN_TYPE_TEXT_ARRAY -> LIST.parameterizedBy(STRING)
+            DB_COLUMN_TYPE_JSONB      -> JSON_VALUE_TYPE
             else -> STRING
         }
         is IntegerField   -> INT
@@ -277,17 +285,16 @@ object KotlinTypeMapper {
      * Map a MetaField to its KotlinPoet TypeName for a REST/serialization **payload** property
      * (the `@Serializable` projection data classes emitted by [KotlinPayloadGenerator]).
      *
-     * Identical to [kotlinTypeName] for every subtype EXCEPT the `field.string @dbColumnType=jsonb`
-     * open bag, which becomes the parsed JSON value [PAYLOAD_JSON_VALUE_TYPE] instead of `String`
-     * (issue #98). This is the deliberate payload/persistence split: the persistence holder
-     * ([kotlinTypeName]) and the Exposed column ([exposedColumnSpec]) keep the raw-text `String`
-     * contract; only the API/wire boundary exposes the bag as a real JSON value (matching the
-     * TS `unknown` / Python `Any` ports). Generators that drive PERSISTENCE (entity data class,
-     * Exposed table, the entity-CRUD controller DTO, which reuses the entity data class) must keep
-     * calling [kotlinTypeName], not this.
+     * For the `field.string @dbColumnType=jsonb` open bag this is the parsed JSON value
+     * [JSON_VALUE_TYPE] (issue #98). As of the #98 uniform-parsed-value cutover this now AGREES
+     * with [kotlinTypeName] at every subtype — the persistence holder (entity data class reused as
+     * the entity-CRUD DTO) and the Exposed column ([exposedColumnSpec]) ALSO expose the bag as a
+     * `JsonElement`, so there is no longer a payload/persistence split. Retained as a distinct,
+     * intention-revealing entry point for the payload generators (and to keep them robust if the
+     * two surfaces ever diverge again).
      */
     fun payloadTypeName(field: MetaField<*>): TypeName =
-        if (isJsonbOpenBag(field)) PAYLOAD_JSON_VALUE_TYPE else kotlinTypeName(field)
+        if (isJsonbOpenBag(field)) JSON_VALUE_TYPE else kotlinTypeName(field)
 
     /**
      * The Kotlin value TypeName for a scalar-valued [MapField] (the type named by its
@@ -391,7 +398,14 @@ object KotlinTypeMapper {
             // would never round-trip to JSONB through the introspection corpus.
             when (dbColumnType(field)) {
                 DB_COLUMN_TYPE_UUID  -> "uuid(\"$colName\")"
-                DB_COLUMN_TYPE_JSONB -> "jsonb(\"$colName\", { it }, { it })"
+                // `@dbColumnType=jsonb` open bag (#98): decode the JSONB text to a kotlinx
+                // `JsonElement` (so the data-class property + CRUD DTO is a parsed JSON value, not
+                // a double-encoded String) and encode it back via `toString()` (a JsonElement's
+                // toString is canonical JSON). `Json.parseToJsonElement` returns a concrete
+                // `JsonElement`, which ANCHORS the Exposed column's generic to `Column<JsonElement>`
+                // (the `{ it }` identity codec would have left it `Column<String>`). The table file
+                // imports `kotlinx.serialization.json.Json` (see KotlinExposedTableGenerator).
+                DB_COLUMN_TYPE_JSONB -> "jsonb(\"$colName\", { it.toString() }, { Json.parseToJsonElement(it) })"
                 // Native SQL array columns via Exposed's `array<E>("col", columnType)` Table
                 // member. The element ColumnType is explicit (UUIDColumnType / TextColumnType)
                 // so emission never depends on Exposed's reified resolveColumnType picking
 
@@ -389,11 +389,11 @@ class KotlinApiModelBuilder {
     /**
      * The simple Kotlin type label for a documented field (enum → generated enum class name).
      *
-     * [forPayload] selects the payload type path ([KotlinTypeMapper.payloadTypeName]) so a
-     * `field.string @dbColumnType=jsonb` open bag is documented as the parsed JSON value
-     * (`JsonElement`) the payload data class actually emits (issue #98); the entity model field
-     * (forPayload = false) stays `String`, matching its data-class property. Keeps the documented
-     * type == the generated type on both surfaces.
+     * [forPayload] selects the payload type path ([KotlinTypeMapper.payloadTypeName]); the entity
+     * model field path uses [KotlinTypeMapper.kotlinTypeName]. As of the #98 uniform-parsed-value
+     * cutover BOTH surfaces document a `field.string @dbColumnType=jsonb` open bag as the parsed
+     * JSON value (`JsonElement`) — the payload data class and the entity data class (the reused
+     * entity-CRUD DTO) now agree. Keeps the documented type == the generated type on both surfaces.
      */
     private fun kotlinTypeLabel(field: MetaField<*>, owner: MetaObject, forPayload: Boolean = false): String {
         KotlinTypeMapper.enumTypeName(field, owner)?.let { enumType ->
 
@@ -126,6 +126,42 @@ class KotlinEntityGeneratorTest {
         }
     }
 
+    @Test fun jsonbOpenBagEntityPropertyIsParsedJsonValue() {
+        // Issue #98: the `field.string @dbColumnType=jsonb` open bag is a PARSED JSON value
+        // (kotlinx `JsonElement`) on the entity data class too — not a (double-encoded) raw-JSON
+        // `String`. The entity data class is REUSED as the derived entity-CRUD request/response DTO,
+        // so this is the entity-CRUD REST contract reaching full parity with the payload surface
+        // (and with TS/Python/Java/C#). A sibling plain `field.string` stays `String`.
+        val fx = """{
+          "metadata.root": { "package": "acme::demo", "children": [
+            { "object.entity": { "name": "Rubric", "children": [
+                { "field.long":   { "name": "id" } },
+                { "field.string": { "name": "weights", "@dbColumnType": "jsonb" } },
+                { "field.string": { "name": "label" } }
+            ] } }
+          ] }
+        }""".trimIndent()
+
+        val outDir = Files.createTempDirectory("kgen-jsonb-")
+        try {
+            val gen = KotlinEntityGenerator()
+            gen.setArgs(mapOf("outputDir" to outDir.toString()))
+            gen.execute(loadString("jsonb", fx))
+
+            val src = Files.readString(outDir.resolve("acme/demo/Rubric.kt"))
+            // jsonb open bag → parsed JSON value, imported.
+            assertTrue("val weights: JsonElement" in src, "expected `val weights: JsonElement` in:\n$src")
+            assertTrue("import kotlinx.serialization.json.JsonElement" in src,
+                "expected JsonElement import in:\n$src")
+            // plain string stays String (no double-encoding concern).
+            assertTrue("val label: String" in src, "expected `val label: String` in:\n$src")
+            // must NOT regress to a raw-JSON String holder for the bag.
+            assertFalse("val weights: String" in src, "jsonb open bag must not be String:\n$src")
+        } finally {
+            outDir.toFile().deleteRecursively()
+        }
+    }
+
     // === field.enum coverage ===============================================
 
     private val enumFixture = """{
 
@@ -219,40 +219,45 @@ class KotlinTypeMapperTest {
 
     @Test fun `string field with dbColumnType=jsonb emits real jsonb column not text`() {
         // R6 Plan 2b: `@dbColumnType=jsonb` on a `field.string` selects a native Postgres
-        // JSONB column (matching the other 4 ports). The Exposed column is the
-        // `jsonb(name, encoder, decoder)` extension with identity String functions (the
-        // property stays a raw-JSON `String`), NOT the old `text(...)` — a TEXT column
+        // JSONB column (matching the other 4 ports). NOT the old `text(...)` — a TEXT column
         // never round-trips to JSONB in the introspection corpus.
+        //
+        // Issue #98: the column codec now PARSES the JSONB text to a kotlinx `JsonElement`
+        // (decode `Json.parseToJsonElement`, encode `it.toString()`) instead of the old
+        // identity passthrough `{ it }, { it }`, so the entity data-class property is a parsed
+        // JSON value, not a raw-JSON `String`. The decode anchors the Exposed column's generic
+        // to `JsonElement`. It is STILL a real `jsonb(...)` column — only the codec/type changes.
         val f = StringField("rubricWeights")
         f.addMetaAttr(StringAttribute.create("dbColumnType", "jsonb"))
-        assertEquals("jsonb(\"rubric_weights\", { it }, { it })", KotlinTypeMapper.exposedColumnSpec(f))
-        assertEquals(STRING, KotlinTypeMapper.kotlinTypeName(f))
+        assertEquals(
+            "jsonb(\"rubric_weights\", { it.toString() }, { Json.parseToJsonElement(it) })",
+            KotlinTypeMapper.exposedColumnSpec(f),
+        )
+        assertEquals(ClassName("kotlinx.serialization.json", "JsonElement"), KotlinTypeMapper.kotlinTypeName(f))
         // The column needs the exposed-json `jsonb` extension import.
         assertEquals("org.jetbrains.exposed.sql.json.jsonb", KotlinTypeMapper.exposedColumnImport(f))
     }
 
-    @Test fun `string field with dbColumnType=jsonb exposes a parsed JSON value in the REST payload`() {
+    @Test fun `string field with dbColumnType=jsonb exposes a parsed JSON value at every layer`() {
         // Issue #98 (cross-port jsonb open-bag REST contract). A `field.string @dbColumnType=jsonb`
         // is the sanctioned "open JSON bag": the physical column is JSONB but the LOGICAL subtype
-        // stays `string`. The two layers are deliberately split:
-        //   - PERSISTENCE (kotlinTypeName / exposedColumnSpec): the Exposed column stays the
-        //     identity-codec `jsonb(name, { it }, { it })` and the entity data-class property stays
-        //     `String` — the JDBC driver returns jsonb as raw text, so String is correct here.
-        //   - REST PAYLOAD (payloadTypeName): the typed projection exposes the bag as a PARSED JSON
-        //     value (kotlinx `JsonElement`) so a client sends/receives a real JSON object, never a
-        //     double-encoded string. Matches TS `z.unknown()` (#97) and Python `Any` (#99).
+        // stays `string`. Per the maintainer decision the bag is a PARSED JSON value (kotlinx
+        // `JsonElement`) UNIFORMLY at every layer — payload, entity data class (the reused CRUD DTO),
+        // and the Exposed column codec — so a client sends/receives a real JSON object, never a
+        // double-encoded string. Matches TS `z.unknown()` (#97), Python `Any` (#99), C# `JsonDocument`.
         val f = StringField("rubricWeights")
         f.addMetaAttr(StringAttribute.create("dbColumnType", "jsonb"))
 
-        // REST payload → parsed JSON value (the fix).
+        val jsonElement = ClassName("kotlinx.serialization.json", "JsonElement")
+        // REST payload → parsed JSON value.
+        assertEquals(jsonElement, KotlinTypeMapper.payloadTypeName(f))
+        // Entity data class / entity-CRUD DTO → parsed JSON value (now uniform with payload).
+        assertEquals(jsonElement, KotlinTypeMapper.kotlinTypeName(f))
+        // The Exposed column stays a real jsonb column but parses to JsonElement.
         assertEquals(
-            ClassName("kotlinx.serialization.json", "JsonElement"),
-            KotlinTypeMapper.payloadTypeName(f),
+            "jsonb(\"rubric_weights\", { it.toString() }, { Json.parseToJsonElement(it) })",
+            KotlinTypeMapper.exposedColumnSpec(f),
         )
-        // Persistence stays String — the entity data-class property is the raw-JSON holder for the
-        // identity-codec jsonb column. (This MUST NOT regress; the column assertion above gates it.)
-        assertEquals(STRING, KotlinTypeMapper.kotlinTypeName(f))
-        assertEquals("jsonb(\"rubric_weights\", { it }, { it })", KotlinTypeMapper.exposedColumnSpec(f))
     }
 
     @Test fun `plain string field payload stays String`() {
@@ -267,7 +272,10 @@ class KotlinTypeMapperTest {
         // `"JSONB"` and `"jsonb"` route to the JSONB branch.
         val f = StringField("featureFlags")
         f.addMetaAttr(StringAttribute.create("dbColumnType", "JSONB"))
-        assertEquals("jsonb(\"feature_flags\", { it }, { it })", KotlinTypeMapper.exposedColumnSpec(f))
+        assertEquals(
+            "jsonb(\"feature_flags\", { it.toString() }, { Json.parseToJsonElement(it) })",
+            KotlinTypeMapper.exposedColumnSpec(f),
+        )
     }
 
     @Test fun `string field with dbColumnType=jsonb ignores maxLength`() {
@@ -276,7 +284,10 @@ class KotlinTypeMapperTest {
         val f = StringField("blob")
         f.addMetaAttr(StringAttribute.create("dbColumnType", "jsonb"))
         f.addMetaAttr(IntAttribute.create("maxLength", 64))
-        assertEquals("jsonb(\"blob\", { it }, { it })", KotlinTypeMapper.exposedColumnSpec(f))
+        assertEquals(
+            "jsonb(\"blob\", { it.toString() }, { Json.parseToJsonElement(it) })",
+            KotlinTypeMapper.exposedColumnSpec(f),
+        )
     }
 
     // === Currency / Enum / UUID coverage ===