diff --git a/CHANGELOG.md b/CHANGELOG.md
index 52761022d..7a565b40c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,8 +9,13 @@ this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ### Added
 - **`@convert` on `origin.passthrough` — acknowledge a deliberate passthrough type change (#185).** A new optional boolean attr. Absent/false (the default), a passthrough is type-preserving (see Changed, below); `@convert: true` opts a field out of the type-equality check when its type intentionally differs from its `@from` source. It is an **acknowledgement only — it does NOT generate a cast**; the value flows through unchanged and the consumer owns any coercion. Real type-converting projections remain `origin.expression`'s job (#159). Registered on `origin.passthrough` in all five ports (cross-port registry-conformance gated).
+- **Typed value-object jsonb columns work end-to-end across all persistence ports (single + array-of-VO).** A `field.object @storage:jsonb` column — a single value-object OR an `@isArray` array-of-VO — now round-trips through every port's runtime/ORM write+read codec (TS Kysely, C# EF Core, Java OMDB/Gson, Kotlin Exposed, Python pg8000). Gated by a new array-of-VO dimension in the persistence-conformance `AllTypes` `op: roundtrip` scenario: a `labels` column (`field.object @isArray @storage:jsonb`) written as a 2-element, empty-`[]` (≠ `null`), and single-element array across three rows — the gap that had let a non-compiling / wrong array serializer ship in three ports. The single-VO jsonb path was already cross-port green; this closes the array-of-VO half.
+
+### Fixed
+- **C# / Java / Python array-of-VO jsonb write+read codecs.** C# EF Core model finalization threw `'ICollection must be a non-interface reference type'` on an `@isArray` `field.object @storage:jsonb` column — `DbContextGenerator` now emits `.OwnsMany(...).ToJson(...)` when `field.ResolvedIsArray()` (the `EntityGenerator` emits `ICollection<VO>`), with a coupled empty-`[]`-vs-`null` nullability fix. Java OMDB threw `Expected BEGIN_OBJECT but was BEGIN_ARRAY` — `GenericSQLDriver.deserializeJsonb` now branches on `isArray` (target `TypeToken.getParameterized(List.class, VO)` via `jsonbTargetType`) and the read path stores the resulting `List` through `setObjectArray` (not the scalar `setObject`). Python's `_coerce_write_value` now `json.dumps`s both dict and list jsonb-storage `field.object`/`field.map` values to a JSON text string — pg8000 binds a native `dict` to jsonb fine, but adapts a native `list` as a Postgres ARRAY literal (`{...,...}`) which the JSONB column rejects with `22P02`.
 
 ### Changed
+- **Kotlin codegen moved to Jackson for typed jsonb columns; entity/value/projection classes dropped `@Serializable`.** `KotlinExposedTableGenerator` now emits a per-package `MetaJsonbMapper.kt` — a `com.fasterxml.jackson.databind.ObjectMapper` (`kotlinModule()` + `JavaTimeModule()`, `WRITE_DATES_AS_TIMESTAMPS` disabled) — that the generated `jsonb()` column codecs read/write through (a `TypeReference<List<VO>>` captures the array-of-VO generic). Jackson (not kotlinx) is the codec precisely so generated entity/value/projection data classes carry **NO `@Serializable`** and need **NO `kotlin("plugin.serialization")` compiler plugin**: a kotlinx `VO.serializer()` would require the plugin, and once it is on, every VO carrying a `java.util.UUID` / `java.time.*` / `java.math.BigDecimal` / `java.net.*` field fails to compile (kotlinx has no serializer for those `java.*` types). `@Serializable` is **kept** only on prompt payloads + enums (genuinely kotlinx-decoded by the FR-006 output parser). Consumers generating any typed jsonb/`field.map` column add `jackson-databind` + `jackson-module-kotlin` + `jackson-datatype-jsr310` (documented in `docs/ports/kotlin.md` + `codegen-kotlin/KNOWN_GAPS.md`); the open-bag `field.string @dbColumnType:jsonb` column stays on the kotlinx `JsonElement` lane. New gate: compile-WITHOUT-the-serialization-plugin + Testcontainers-PG roundtrip of a GENERATED typed-jsonb table (`GeneratedTypedJsonbRoundTripTest`).
 - **BREAKING — `origin.passthrough` is now type-preserving: a passthrough field must match its `@from` source's type (#185).** A field carrying `origin.passthrough @from: "Entity.field"` forwards another field's value unchanged, so its declared `field.<subType>` and array-ness must be identical to the resolved source field. A divergence now fails load with `ERR_PASSTHROUGH_TYPE_MISMATCH` (e.g. a `field.uuid` source surfaced by a projection as `field.string` — the exact mismodeling that forces hand-written `String↔UUID` bridging and defeats a UUID migration). The check compares **subType and array-ness only — nullability is deliberately not judged** (a view over an outer join legitimately widens `NOT NULL` → nullable). Opt out of a deliberate type change with `@convert: true` (see Added). This **generalizes and retires** the narrow, stored-proc-parameter-ref-only `ERR_PARAMETER_REF_PASSTHROUGH_TYPE_MISMATCH` (FR-015) into one host-agnostic invariant covering projections, entities, values, and parameter refs alike. Enforced in the loader/verify in all five ports (TS / Python / C# / Java / Kotlin), cross-port conformance-gated. **Migration:** if load newly fails, the error names both the declared type and the source type — declare the source type (usually the fix — the projection was wrong), or add `@convert: true` if the divergence is intentional.
 
 ## [0.15.15] — 2026-07-07
diff --git a/CLAUDE.md b/CLAUDE.md
index 89256374f..3bc0e501d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -32,7 +32,7 @@ _Last refreshed 2026-07-04._
 **Cross-port conformance corpora** (every port runs the shared corpus):
 - Metamodel: `fixtures/conformance/` (~90 fixtures). TS / C# / Java / Python all green.
 - Render: `fixtures/render-conformance/`. TS / C# / Java / Kotlin / Python byte-identical.
-- Persistence: `fixtures/persistence-conformance/`. **Query** scenarios run on every port (TS / C# / Java / Kotlin / Python), each provisioning its test DB by executing the committed, TS-produced `canonical/schema.postgres.sql` (Postgres only — Derby dropped for the cross-port query corpus, ADR-0015). The **migration** scenarios are exercised by **TS only** (TS owns schema migrations). **The corpus now gates WRITES, not just reads (SP-H):** an `op: roundtrip` scenario type INSERTs through each port's runtime/ORM write codec (NOT raw SQL), reads the row back, and asserts the wire-normalized value. The `AllTypes` entity (`roundtrip-all-types.yaml`) carries one field of **every** persistable `field.*` subtype — string/int/long/double/float/decimal/boolean/date/time/timestamp(+tz)/currency/enum/uuid/object — so every subtype write+read round-trips through every port against Testcontainers PG. (`field.byte`/`field.short`/`field.class` were cut as non-functional registration-only stubs — the matrix tracks only genuinely-supported subtypes; see `fixtures/registry-conformance/README.md` → "Per-subtype write-round-trip matrix".)
+- Persistence: `fixtures/persistence-conformance/`. **Query** scenarios run on every port (TS / C# / Java / Kotlin / Python), each provisioning its test DB by executing the committed, TS-produced `canonical/schema.postgres.sql` (Postgres only — Derby dropped for the cross-port query corpus, ADR-0015). The **migration** scenarios are exercised by **TS only** (TS owns schema migrations). **The corpus now gates WRITES, not just reads (SP-H):** an `op: roundtrip` scenario type INSERTs through each port's runtime/ORM write codec (NOT raw SQL), reads the row back, and asserts the wire-normalized value. The `AllTypes` entity (`roundtrip-all-types.yaml`) carries one field of **every** persistable `field.*` subtype — string/int/long/double/float/decimal/boolean/date/time/timestamp(+tz)/currency/enum/uuid/object — plus an **array-of-VO** `field.object @isArray @storage:jsonb` column (`labels`, written as 2-element / empty-`[]` / single-element arrays across the three rows) — so every subtype write+read (incl. the array-of-value-object jsonb codec) round-trips through every port against Testcontainers PG. (`field.byte`/`field.short`/`field.class` were cut as non-functional registration-only stubs — the matrix tracks only genuinely-supported subtypes; see `fixtures/registry-conformance/README.md` → "Per-subtype write-round-trip matrix".)
 - API-contract: `fixtures/api-contract-conformance/`. TS / C# / Java / Kotlin / Python all 20/20 — each port runs **two lanes**: a hand-rolled reference server AND its **generated** API artifact booted over HTTP (the deployed controller/routes; TS+C# full-stack vs Testcontainers PG, Java/Kotlin/Python generated controller + in-memory repo behind the consumer seam). The generated fan-out found 10 real deployment bugs golden snapshots missed.
 - YAML / verify corpora green across the ports that ship those layers.
 
diff --git a/README.md b/README.md
index d34265f0e..bd686107f 100644
--- a/README.md
+++ b/README.md
@@ -82,7 +82,7 @@ building blocks are complete in all five ports; MCP exposure of declared
 prompts/tools is the one remaining roadmap item:
 
 1. **Codegen** — emit idiomatic per-language code (Drizzle/Zod + Fastify for TS,
-   POJO + OMDB for Java, `@Serializable data class` + Exposed for Kotlin, EF Core
+   POJO + OMDB for Java, `data class` + Exposed for Kotlin, EF Core
    record + ASP.NET routes for C#, `@dataclass` for Python). Hand-edit-preserving
    regen via three-way merge.
 2. **Runtime metadata** — load metadata at runtime, drive behavior dynamically
diff --git a/agent-context/skills/metaobjects-audit/references/kotlin.md b/agent-context/skills/metaobjects-audit/references/kotlin.md
index ec774cb68..2aca79e50 100644
--- a/agent-context/skills/metaobjects-audit/references/kotlin.md
+++ b/agent-context/skills/metaobjects-audit/references/kotlin.md
@@ -2,7 +2,8 @@
 
 The Kotlin port is a **codegen tier built on top of the Java port** — the loader,
 render engine, and Maven plugin are all Java; `metaobjects-codegen-kotlin` emits
-idiomatic Kotlin (KotlinPoet: `@Serializable data class`, Exposed `Table` objects,
+idiomatic Kotlin (KotlinPoet: `data class` (no `@Serializable` — entities are
+Jackson-compatible, not kotlinx-serialized), Exposed `Table` objects,
 Spring `@RestController`). Codegen runs as the same Maven plugin goal the Java port
 uses (`mvn metaobjects:generate`). Schema migration and live-DB drift are
 **Node-`meta`-only** (ADR-0015). The runtime persistence tier is **JetBrains Exposed**
diff --git a/agent-context/skills/metaobjects-codegen/references/kotlin.md b/agent-context/skills/metaobjects-codegen/references/kotlin.md
index 953f5f0ae..3be6588d3 100644
--- a/agent-context/skills/metaobjects-codegen/references/kotlin.md
+++ b/agent-context/skills/metaobjects-codegen/references/kotlin.md
@@ -2,7 +2,8 @@
 
 The Kotlin port is a **codegen tier built on top of the Java port**. The loader,
 render engine, and Maven plugin are all Java; `codegen-kotlin` emits idiomatic
-Kotlin (`@Serializable data class`, Exposed `Table` objects, Spring
+Kotlin (`data class` (no `@Serializable` — entities are Jackson-compatible, not
+kotlinx-serialized), Exposed `Table` objects, Spring
 `@RestController`/`@Configuration`) via KotlinPoet. Codegen runs as the same
 build-time Maven plugin goal the Java port uses — there is no standalone `meta`
 binary on the JVM side (the Node `meta` is for schema migrations only; see the
@@ -94,7 +95,7 @@ All live in `metaobjects-codegen-kotlin` under
 
 | Generator | Output |
 |---|---|
-| `KotlinEntityGenerator` | `<Entity>.kt` — `@Serializable data class` per `object.entity` / `object.value`. A TPH `@discriminator` base's data class is the **union** of every subtype's columns (each folded nullable, validation dropped) so one wire shape backs the polymorphic + per-subtype endpoints. |
+| `KotlinEntityGenerator` | `<Entity>.kt` — `data class` (no `@Serializable`; Jackson-compatible) per `object.entity` / `object.value`. A TPH `@discriminator` base's data class is the **union** of every subtype's columns (each folded nullable, validation dropped) so one wire shape backs the polymorphic + per-subtype endpoints. |
 | `KotlinExposedTableGenerator` | `<Entity>Table.kt` — Exposed `Table` object (PK + FK + `@storage` columns) for entities with `source.rdb`. A TPH `@discriminator` base emits ONE `Table` for the whole hierarchy — every subtype-only column folded in `.nullable()` (a row of another subtype stores null there) — single-table inheritance; subtype entities emit no table of their own. |
 | `KotlinRelationsGenerator` | `<Entity>Relations.kt` — extension fns for `@cardinality="many"` query helpers |
 | `KotlinSpringControllerGenerator` | `<Entity>Controller.kt` — Spring `@RestController`, five CRUD endpoints on the cross-port REST contract, for writable entities (`source.rdb` `@kind="table"`). A TPH `@discriminator` base emits ONE controller: polymorphic `GET /<base>(+/{id})` plus a per-subtype CRUD set at `/<base>/<discriminatorValue lowercased>` — create injects the discriminator from the URL (never the body); get/update/delete are scoped to the subtype (cross-subtype → 404); the discriminator is immutable. |
diff --git a/agent-context/skills/metaobjects-runtime-ui/references/kotlin.md b/agent-context/skills/metaobjects-runtime-ui/references/kotlin.md
index fb13e2c3a..208217866 100644
--- a/agent-context/skills/metaobjects-runtime-ui/references/kotlin.md
+++ b/agent-context/skills/metaobjects-runtime-ui/references/kotlin.md
@@ -4,7 +4,7 @@ The Kotlin port runtime is **generated Exposed `Table` objects plus your own
 JetBrains Exposed transactions** — there is no Kotlin-specific persistence engine.
 `KotlinExposedTableGenerator` emits one `<Entity>Table.kt` per entity with a
 `source.rdb`; you hand-write the (trivial) transaction bodies, since the table
-column definitions and the `@Serializable` entity data class are both generated
+column definitions and the generated `data class` entity are both generated
 from the same metadata.
 
 (If you want a fully metadata-driven engine instead of hand-written Exposed, the
@@ -20,7 +20,6 @@ emit a data class and an Exposed `Table`:
 
 ```kotlin
 // generated/acme/blog/Author.kt
-@Serializable
 data class Author(
     val id: Long,
     val name: String,
diff --git a/docs/features/entities.md b/docs/features/entities.md
index 4a317ac73..2ff5b9c1d 100644
--- a/docs/features/entities.md
+++ b/docs/features/entities.md
@@ -169,16 +169,15 @@ public class Author {
 
 ### Kotlin
 
-`metaobjects-codegen-kotlin` (`KotlinEntityGenerator`) emits a `@Serializable
-data class` and (with `KotlinExposedTableGenerator`) an Exposed `Table` object.
+`metaobjects-codegen-kotlin` (`KotlinEntityGenerator`) emits a plain
+`data class` (no `@Serializable` — entities are Jackson-compatible, not
+kotlinx-serialized) and (with `KotlinExposedTableGenerator`) an Exposed
+`Table` object.
 
 ```kotlin
 // generated/acme/blog/Author.kt
 package acme.blog
 
-import kotlinx.serialization.Serializable
-
-@Serializable
 data class Author(
     val id: Long,
     val name: String,
diff --git a/docs/features/field-types.md b/docs/features/field-types.md
index cbd8cb49f..bf4c6790f 100644
--- a/docs/features/field-types.md
+++ b/docs/features/field-types.md
@@ -141,7 +141,6 @@ public enum Status { DRAFT, PUBLISHED, ARCHIVED }
 
 ```kotlin
 // generated/acme/blog/Author.kt
-@Serializable
 data class Author(
     val id: Long,
     val name: String,
diff --git a/docs/ports/csharp.md b/docs/ports/csharp.md
index 8fdb4f37a..aff2fcfe4 100644
--- a/docs/ports/csharp.md
+++ b/docs/ports/csharp.md
@@ -94,7 +94,8 @@ The codegen emits:
 
 - `Author.cs` — record per entity.
 - `AppDbContext.cs` — `DbSet<Author>`, projection `.ToView()`, `@storage` owned
-  types via `OwnsOne`, enum-as-string via `HasConversion<string>()`.
+  types via `OwnsOne` (single) / `OwnsMany(...).ToJson(...)` (`@isArray` array-of-VO),
+  enum-as-string via `HasConversion<string>()`.
 - `Author.routes.cs` — CRUD minimal-API endpoints.
 
 ## Use
@@ -270,7 +271,7 @@ are not yet generated — see
 | Entities + fields | Yes |
 | Relationships + FK | Yes (EF Core + Postgres FK clause) |
 | Source kinds (table / view / storedProc) | `table` + `view` fully shipped; `storedProc` / `tableFunction` / `materializedView` partial |
-| `field.currency` / `field.enum` / `field.object` + `@storage` | Yes (incl. EF Core `OwnsOne` for `flattened`) |
+| `field.currency` / `field.enum` / `field.object` + `@storage` | Yes (incl. EF Core `OwnsOne` for `flattened`; `OwnsMany(...).ToJson(...)` for `@isArray` array-of-VO jsonb) |
 | Templates + render (FR-004) | Yes (`MetaObjects.Render`) |
 | Output parser codegen (FR-006) | Yes (`OutputParserGenerator` — `Parse`/`TryParse` BCL pattern) |
 | Payload-VO codegen | Yes (`MetaObjects.Codegen`) |
diff --git a/docs/ports/kotlin.md b/docs/ports/kotlin.md
index 6a3cce77a..b08937969 100644
--- a/docs/ports/kotlin.md
+++ b/docs/ports/kotlin.md
@@ -3,7 +3,7 @@
 Idiomatic Kotlin codegen target for Spring-Boot-Kotlin consumers on Exposed +
 Flyway. The Kotlin port is a **codegen tier built on top of the Java port** — the
 loader, OMDB persistence engine, render engine, Maven plugin, and conformance
-runners are all Java; Kotlin emits idiomatic Kotlin (`@Serializable data class`,
+runners are all Java; Kotlin emits idiomatic Kotlin (`data class`,
 Exposed `Table` objects, extension-fn relationship helpers, Spring `@Configuration`
 wiring) via KotlinPoet.
 
@@ -39,6 +39,26 @@ Two modules:
     <artifactId>exposed-core</artifactId>
     <version>${exposed.version}</version>
   </dependency>
+  <!-- Generated typed `field.object @storage:jsonb` / `field.map` columns serialize through a
+       generated per-package `MetaJsonbMapper.kt` Jackson `ObjectMapper` (no kotlinx-serialization
+       compiler plugin required). -->
+  <dependency>
+    <groupId>com.fasterxml.jackson.core</groupId>
+    <artifactId>jackson-databind</artifactId>
+    <version>${jackson.version}</version>
+  </dependency>
+  <dependency>
+    <groupId>com.fasterxml.jackson.module</groupId>
+    <artifactId>jackson-module-kotlin</artifactId>
+    <version>${jackson.version}</version>
+  </dependency>
+  <dependency>
+    <groupId>com.fasterxml.jackson.datatype</groupId>
+    <artifactId>jackson-datatype-jsr310</artifactId>
+    <version>${jackson.version}</version>
+  </dependency>
+  <!-- FR-006 output parser + prompt-payload lane; also backs the open-bag
+       `field.string @dbColumnType:jsonb` → kotlinx `JsonElement` path. -->
   <dependency>
     <groupId>org.jetbrains.kotlinx</groupId>
     <artifactId>kotlinx-serialization-json</artifactId>
@@ -53,7 +73,7 @@ The 9 generators in `codegen-kotlin`:
 
 | Generator | Output | Per |
 |---|---|---|
-| `KotlinEntityGenerator` | `<Entity>.kt` — `@Serializable data class` | every `object.entity` + `object.value` |
+| `KotlinEntityGenerator` | `<Entity>.kt` — Kotlin `data class` (Jackson-compatible; no `@Serializable`) | every `object.entity` + `object.value` |
 | `KotlinExposedTableGenerator` | `<Entity>Table.kt` — Exposed `Table` object with PK + FK + `@storage` columns | entities with `source.rdb` |
 | `KotlinRelationsGenerator` | `<Entity>Relations.kt` — extension fns for `cardinality=many` query helpers | entities with to-many relationships |
 | `KotlinPayloadGenerator` | `<Template>Payload.kt` — `@Serializable` payload from `@payloadRef` view-object | every `template.prompt` / `template.output` |
@@ -139,7 +159,6 @@ emits:
 
 ```kotlin
 // generated/acme/blog/Author.kt
-@Serializable
 data class Author(
     val id: Long,
     val name: String,
diff --git a/fixtures/persistence-conformance/README.md b/fixtures/persistence-conformance/README.md
index 53d433cbe..c62d7f388 100644
--- a/fixtures/persistence-conformance/README.md
+++ b/fixtures/persistence-conformance/README.md
@@ -213,8 +213,12 @@ native-uuid-write.
 - The `AllTypes` entity (`all_types` table) in the canonical model exists to cover
   **every persistable field subtype** in one row — string / int / long / double /
   float / decimal / boolean / date / time / timestamp / timestamp(tz) / currency /
-  enum / uuid / object(`@objectRef`, jsonb storage). No read scenario references
-  it, so it is inert for the read runners (it just adds a table to the schema).
+  enum / uuid / object(`@objectRef`, jsonb storage) — plus an **array-of-VO**
+  `field.object @isArray @storage:jsonb` column (`labels`) written as a 2-element,
+  empty-`[]`, and single-element array across the three roundtrip rows, exercising
+  each port's array-of-value-object write+read jsonb codec (the gap that once let a
+  non-compiling / wrong array serializer ship). No read scenario references it, so
+  it is inert for the read runners (it just adds a table to the schema).
 - **Full int64 fidelity:** one roundtrip query writes the BIGINT max
   (`9223372036854775807`, > 2^53) to `field.long` AND `field.currency` as a
   numeric **string** — the write contract for those two subtypes accepts a base-10
diff --git a/fixtures/persistence-conformance/canonical/meta.fitness.json b/fixtures/persistence-conformance/canonical/meta.fitness.json
index 39b6c0183..de39f2e59 100644
--- a/fixtures/persistence-conformance/canonical/meta.fitness.json
+++ b/fixtures/persistence-conformance/canonical/meta.fitness.json
@@ -216,6 +216,13 @@
           { "field.int":     { "name": "retries" } }
         ]
       }},
+      { "object.value": {
+        "name": "Label",
+        "children": [
+          { "field.string": { "name": "key" } },
+          { "field.int":    { "name": "weight" } }
+        ]
+      }},
       { "object.entity": {
         "name": "AllTypes",
         "children": [
@@ -239,6 +246,7 @@
           { "field.inet":      { "name": "inetVal",  "@required": true } },
           { "field.inet":      { "name": "inet6Val", "@required": true } },
           { "field.object":    { "name": "settings", "@objectRef": "Settings", "@storage": "jsonb" } },
+          { "field.object":    { "name": "labels", "@objectRef": "Label", "@storage": "jsonb", "isArray": true } },
           { "identity.primary": { "name": "id", "@fields": "id", "@generation": "uuid" } }
         ]
       }}
diff --git a/fixtures/persistence-conformance/canonical/schema.postgres.sql b/fixtures/persistence-conformance/canonical/schema.postgres.sql
index eeee1080d..4f9a60cbe 100644
--- a/fixtures/persistence-conformance/canonical/schema.postgres.sql
+++ b/fixtures/persistence-conformance/canonical/schema.postgres.sql
@@ -117,6 +117,7 @@ CREATE TABLE "all_types" (
   "inetVal" INET NOT NULL,
   "inet6Val" INET NOT NULL,
   "settings" JSONB,
+  "labels" JSONB,
   CONSTRAINT "all_types_pkey" PRIMARY KEY ("id"),
   CONSTRAINT "all_types_enumVal_chk" CHECK ("enumVal" IN ('LOW', 'MEDIUM', 'HIGH'))
 );
diff --git a/fixtures/persistence-conformance/queries/roundtrip-all-types.yaml b/fixtures/persistence-conformance/queries/roundtrip-all-types.yaml
index 1bb41d488..85ef825f9 100644
--- a/fixtures/persistence-conformance/queries/roundtrip-all-types.yaml
+++ b/fixtures/persistence-conformance/queries/roundtrip-all-types.yaml
@@ -37,6 +37,11 @@ description: |
       renders the identical minimal plain-decimal string (see normalization.md).
     - object: a typed @objectRef value-object stored as JSONB → re-serialized
       with sorted keys.
+    - object array: a typed @objectRef value-object with isArray:true stored as
+      JSONB (`labels`) → a JSON array of sorted-key objects; element order is
+      preserved. Row 1 writes 2 elements, row 2 an empty array ([] ≠ null), row 3
+      a single element — exercising the array-of-VO write+read codec each port
+      must implement (the gap that let a non-compiling/wrong array serializer ship).
     - uri: field.uri → TEXT column; round-trips as the verbatim URI string
       (no normalization — the port stores/returns it unchanged).
     - inet: field.inet → Postgres-native INET column. A HOST address (no CIDR
@@ -72,6 +77,11 @@ queries:
       inetVal: "192.168.1.1"
       inet6Val: "2001:db8::1"
       settings: { theme: "dark", notify: true, retries: 3 }
+      # array-of-VO stored as JSONB (field.object @isArray @storage:jsonb). Element
+      # order is preserved; each element's keys are sorted on read (like settings).
+      labels:
+        - { key: "alpha", weight: 10 }
+        - { key: "beta",  weight: 20 }
     expect:
       sVal: "hello"
       iVal: 42
@@ -91,6 +101,9 @@ queries:
       inetVal: "192.168.1.1"
       inet6Val: "2001:db8::1"
       settings: { notify: true, retries: 3, theme: "dark" }
+      labels:
+        - { key: "alpha", weight: 10 }
+        - { key: "beta",  weight: 20 }
 
   - name: write-whole-second-temporal-then-read-back
     op: roundtrip
@@ -114,6 +127,8 @@ queries:
       inetVal: "10.0.0.5"
       inet6Val: "fe80::1"
       settings: { theme: "light", notify: false, retries: 0 }
+      # empty array-of-VO: an empty JSON array must round-trip as [] (distinct from null).
+      labels: []
     expect:
       sVal: "second row"
       iVal: -7
@@ -133,6 +148,7 @@ queries:
       inetVal: "10.0.0.5"
       inet6Val: "fe80::1"
       settings: { notify: false, retries: 0, theme: "light" }
+      labels: []
 
   - name: write-full-int64-then-read-back
     description: |
@@ -170,6 +186,8 @@ queries:
       # compressed form, so the expected read-back is `2001:db8::8a2e:370:7334`.
       inet6Val: "2001:0db8:0000:0000:0000:8a2e:0370:7334"
       settings: { theme: "dark", notify: true, retries: 9 }
+      labels:
+        - { key: "solo", weight: 99 }
     expect:
       sVal: "int64 row"
       iVal: 1
@@ -189,3 +207,5 @@ queries:
       inetVal: "255.255.255.255"
       inet6Val: "2001:db8::8a2e:370:7334"
       settings: { notify: true, retries: 9, theme: "dark" }
+      labels:
+        - { key: "solo", weight: 99 }
diff --git a/fixtures/persistence-conformance/queries/update-delete-all-types.yaml b/fixtures/persistence-conformance/queries/update-delete-all-types.yaml
index 6f4f6b38e..8683ac16d 100644
--- a/fixtures/persistence-conformance/queries/update-delete-all-types.yaml
+++ b/fixtures/persistence-conformance/queries/update-delete-all-types.yaml
@@ -100,6 +100,8 @@ queries:
       inetVal: "192.168.10.20"
       inet6Val: "2001:db8::dead:beef"
       settings: { notify: true, retries: 7, theme: "dark" }
+      # labels (array-of-VO jsonb) is neither seeded nor updated here → reads back null.
+      labels: null
 
   - name: read-back-after-update
     description: re-read by PK; the persisted row carries every re-encoded value.
@@ -126,6 +128,8 @@ queries:
       inetVal: "192.168.10.20"
       inet6Val: "2001:db8::dead:beef"
       settings: { notify: true, retries: 7, theme: "dark" }
+      # labels (array-of-VO jsonb) is neither seeded nor updated here → reads back null.
+      labels: null
 
   - name: delete-by-pk
     description: DELETE the row through the runtime; true = a row was deleted.
diff --git a/server/csharp/MetaObjects.Codegen.Tests/EntityGeneratorRound2Tests.cs b/server/csharp/MetaObjects.Codegen.Tests/EntityGeneratorRound2Tests.cs
index 86cc08281..e9e1353a1 100644
--- a/server/csharp/MetaObjects.Codegen.Tests/EntityGeneratorRound2Tests.cs
+++ b/server/csharp/MetaObjects.Codegen.Tests/EntityGeneratorRound2Tests.cs
@@ -132,7 +132,9 @@ public void ObjectField_with_isArray_emits_a_collection_not_a_single_ref()
         ]}}
         """;
         var customer = File(new EntityGenerator().Generate(Ctx(Load(model))), "Customer.g.cs");
-        Assert.Contains("public ICollection<ContactInfo> Contacts { get; set; } = new List<ContactInfo>();", customer);
+        // A NON-required array-of-VO is a NULLABLE collection (no empty-list initializer) so
+        // an absent value stays a NULL jsonb column, distinct from an explicit empty `[]`.
+        Assert.Contains("public ICollection<ContactInfo>? Contacts { get; set; }", customer);
         Assert.DoesNotContain("public ContactInfo? Contacts", customer);
     }
 
diff --git a/server/csharp/MetaObjects.Codegen.Tests/ExtendsAbstractFieldInheritanceCodegenTests.cs b/server/csharp/MetaObjects.Codegen.Tests/ExtendsAbstractFieldInheritanceCodegenTests.cs
index a172de024..59e109070 100644
--- a/server/csharp/MetaObjects.Codegen.Tests/ExtendsAbstractFieldInheritanceCodegenTests.cs
+++ b/server/csharp/MetaObjects.Codegen.Tests/ExtendsAbstractFieldInheritanceCodegenTests.cs
@@ -68,8 +68,9 @@ public void Generated_entity_honors_every_inherited_field_property()
         Assert.DoesNotContain("public string Tags ", contact);
 
         // `addresses` extends field.object(isArray:true, @objectRef:Address, @storage:jsonb):
-        // array-of-Address, honoring the inherited @objectRef + isArray.
-        Assert.Contains("ICollection<Address> Addresses", contact);
+        // array-of-Address, honoring the inherited @objectRef + isArray. Non-required (the
+        // abstract AddressBag has no @required) → a NULLABLE collection (null-vs-empty distinct).
+        Assert.Contains("ICollection<Address>? Addresses", contact);
 
         // `balance` extends field.decimal(@precision:12, @scale:2) -> decimal property.
         Assert.Contains("Balance", contact);
diff --git a/server/csharp/MetaObjects.Codegen.Tests/ObjectFieldCodegenTests.cs b/server/csharp/MetaObjects.Codegen.Tests/ObjectFieldCodegenTests.cs
index 7d9adb5c3..6f10c1e9e 100644
--- a/server/csharp/MetaObjects.Codegen.Tests/ObjectFieldCodegenTests.cs
+++ b/server/csharp/MetaObjects.Codegen.Tests/ObjectFieldCodegenTests.cs
@@ -25,6 +25,7 @@ public class ObjectFieldCodegenTests
         { "field.string": { "name": "name", "@required": true } },
         { "field.object": { "name": "homeAddress", "@objectRef": "Address", "@storage": "flattened" } },
         { "field.object": { "name": "config", "@objectRef": "Address" } },
+        { "field.object": { "name": "tags", "@objectRef": "Address", "@storage": "jsonb", "isArray": true } },
         { "identity.primary": { "@fields": "id" } }
       ]}}
     ]}}
@@ -85,6 +86,20 @@ public void DbContext_configures_owned_types_flattened_and_json()
         Assert.Contains("modelBuilder.Entity<Customer>().OwnsOne(x => x.Config, b => b.ToJson(\"config\"));", dbContext);
     }
 
+    [Fact]
+    public void DbContext_configures_array_of_value_object_jsonb_as_OwnsMany()
+    {
+        var ctx = Ctx(Load());
+        var dbContext = new DbContextGenerator().Generate(ctx).Single().Content;
+
+        // An @isArray object field is a COLLECTION of the value object (ICollection<Address>),
+        // so EF must map it with .OwnsMany(...).ToJson(...) — .OwnsOne over a collection fails
+        // at EF model finalization ("must be a non-interface reference type to be used as an
+        // entity type"). Regression gate for the array-of-VO jsonb path.
+        Assert.Contains("modelBuilder.Entity<Customer>().OwnsMany(x => x.Tags, b => b.ToJson(\"tags\"));", dbContext);
+        Assert.DoesNotContain("OwnsOne(x => x.Tags", dbContext);
+    }
+
     [Fact]
     public void Generated_entities_and_value_objects_compile_together()
     {
diff --git a/server/csharp/MetaObjects.Codegen/Generators/DbContextGenerator.cs b/server/csharp/MetaObjects.Codegen/Generators/DbContextGenerator.cs
index 0fb65b49d..12e71f272 100644
--- a/server/csharp/MetaObjects.Codegen/Generators/DbContextGenerator.cs
+++ b/server/csharp/MetaObjects.Codegen/Generators/DbContextGenerator.cs
@@ -379,6 +379,16 @@ private static string UsingEntityConfig(M2MNavigation nav)
         var nav = CSharpNaming.Pascal(field.Name);
         var parentCol = CSharpNaming.Column(field, strategy);
 
+        // An @isArray object field is a COLLECTION of the value object (the EntityGenerator
+        // emits it as ICollection<VO>), so EF must map it with .OwnsMany(...).ToJson(...) —
+        // .OwnsOne over a collection compiles but fails at EF model finalization ("must be a
+        // non-interface reference type to be used as an entity type"). An array is always a
+        // single JSON column (flattening N objects onto fixed columns is nonsensical), so it
+        // never takes the flattened branch below. ResolvedIsArray per ADR-0039 (array-ness is
+        // inheritable via extends).
+        if (field.ResolvedIsArray())
+            return $"        modelBuilder.Entity<{owner}>().OwnsMany(x => x.{nav}, b => b.ToJson(\"{parentCol}\"));";
+
         if (field.Storage != STORAGE_FLATTENED)
             return $"        modelBuilder.Entity<{owner}>().OwnsOne(x => x.{nav}, b => b.ToJson(\"{parentCol}\"));";
 
diff --git a/server/csharp/MetaObjects.Codegen/Generators/EntityGenerator.cs b/server/csharp/MetaObjects.Codegen/Generators/EntityGenerator.cs
index 993b421c5..ffb8290c4 100644
--- a/server/csharp/MetaObjects.Codegen/Generators/EntityGenerator.cs
+++ b/server/csharp/MetaObjects.Codegen/Generators/EntityGenerator.cs
@@ -965,12 +965,18 @@ protected static string EscapeAttrString(string s) =>
         }
         var typeName = CSharpNaming.Pascal(target.Name);
         var propName = PropertyName(field);
-        // An object-typed field with @isArray:true is a COLLECTION of the value object,
-        // not a single nullable ref. Emit a non-nullable ICollection<T> with an empty-list
-        // initializer (matching the scalar/enum array convention — the list is never null).
-        if (field.ResolvedIsArray()) // ADR-0039: resolving — array-ness inheritable via extends
-            return $"    public ICollection<{typeName}> {propName} {{ get; set; }} = new List<{typeName}>();";
         var required = CSharpNaming.IsRequired(owner, field);
+        // An object-typed field with @isArray:true is a COLLECTION of the value object
+        // (EF maps it via .OwnsMany(...).ToJson(...)), not a single nullable ref. A REQUIRED
+        // array is a non-null collection with an empty-list initializer (never null). A
+        // NON-required array is a NULLABLE collection with NO initializer, so an absent value
+        // stays a NULL jsonb column (distinct from an explicit empty `[]`) — mirroring the
+        // single-VO nullability below. A non-null empty-list default would erase that
+        // null-vs-empty distinction (EF re-serializes the empty list to `[]` on write).
+        if (field.ResolvedIsArray()) // ADR-0039: resolving — array-ness inheritable via extends
+            return required
+                ? $"    public ICollection<{typeName}> {propName} {{ get; set; }} = new List<{typeName}>();"
+                : $"    public ICollection<{typeName}>? {propName} {{ get; set; }}";
         return required
             ? $"    public {typeName} {propName} {{ get; set; }} = default!;"
             : $"    public {typeName}? {propName} {{ get; set; }}";
diff --git a/server/csharp/MetaObjects.IntegrationTests/Generated/AllTypes.g.cs b/server/csharp/MetaObjects.IntegrationTests/Generated/AllTypes.g.cs
index 4450d1493..9ddea118a 100644
--- a/server/csharp/MetaObjects.IntegrationTests/Generated/AllTypes.g.cs
+++ b/server/csharp/MetaObjects.IntegrationTests/Generated/AllTypes.g.cs
@@ -56,4 +56,5 @@ public enum AllTypesEnumVal { LOW, MEDIUM, HIGH }
     [Required]
     public IPAddress Inet6Val { get; set; } = default!;
     public Settings? Settings { get; set; }
+    public ICollection<Label>? Labels { get; set; }
 }
diff --git a/server/csharp/MetaObjects.IntegrationTests/Generated/AppDbContext.g.cs b/server/csharp/MetaObjects.IntegrationTests/Generated/AppDbContext.g.cs
index afc316b5b..1db4de773 100644
--- a/server/csharp/MetaObjects.IntegrationTests/Generated/AppDbContext.g.cs
+++ b/server/csharp/MetaObjects.IntegrationTests/Generated/AppDbContext.g.cs
@@ -31,6 +31,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         modelBuilder.Entity<ProgramView>().ToView("v_program");
         modelBuilder.Entity<ProgramView>().Property(x => x.Status).HasConversion<string>();
         modelBuilder.Entity<AllTypes>().OwnsOne(x => x.Settings, b => b.ToJson("settings"));
+        modelBuilder.Entity<AllTypes>().OwnsMany(x => x.Labels, b => b.ToJson("labels"));
         modelBuilder.Entity<AllTypes>().Property(x => x.EnumVal).HasConversion<string>();
         modelBuilder.Entity<AllTypes>().Property(x => x.DecVal).HasPrecision(18, 6);
         modelBuilder.Entity<AllTypes>().Property(x => x.TsVal).HasColumnType("timestamp without time zone");
diff --git a/server/csharp/MetaObjects.IntegrationTests/Generated/Label.g.cs b/server/csharp/MetaObjects.IntegrationTests/Generated/Label.g.cs
new file mode 100644
index 000000000..0a192b1f1
--- /dev/null
+++ b/server/csharp/MetaObjects.IntegrationTests/Generated/Label.g.cs
@@ -0,0 +1,14 @@
+// <auto-generated/>
+// Generated by MetaObjects entity-generator (owned value object). Do not edit by hand.
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace MetaObjects.IntegrationTests.Generated;
+
+public class Label
+{
+    public string? Key { get; set; }
+    public int? Weight { get; set; }
+}
diff --git a/server/csharp/MetaObjects.IntegrationTests/Runner/EntityRow.cs b/server/csharp/MetaObjects.IntegrationTests/Runner/EntityRow.cs
index 617c6f8b7..d95ffb661 100644
--- a/server/csharp/MetaObjects.IntegrationTests/Runner/EntityRow.cs
+++ b/server/csharp/MetaObjects.IntegrationTests/Runner/EntityRow.cs
@@ -56,6 +56,16 @@ public static class EntityRow
         // pass it through so Normalization re-serializes the parsed value with sorted keys,
         // exactly as a string-typed jsonb column does. NOT a POCO to reflect over.
         if (value is JsonDocument or JsonElement) return value;
+        // An @isArray owned field materializes as a COLLECTION of POCOs (EF OwnsMany.ToJson) →
+        // a JSON ARRAY string: each element field-keyed, array ORDER preserved (Normalization
+        // sorts each element's keys but keeps element order). Mirrors the single-POCO jsonb
+        // projection. `string` is excluded above; other IEnumerables are the owned collection.
+        if (value is System.Collections.IEnumerable seq)
+        {
+            var arr = new JsonArray();
+            foreach (var item in seq) arr.Add(item is null ? null : LeafToJsonNode(item));
+            return arr.ToJsonString();
+        }
         // A nested owned POCO → field-keyed JSON string (Normalization sorts the keys).
         return PocoToJsonNode(value).ToJsonString();
     }
diff --git a/server/csharp/MetaObjects.IntegrationTests/Runner/WriteCoercion.cs b/server/csharp/MetaObjects.IntegrationTests/Runner/WriteCoercion.cs
index 079a52e50..2e0f63aa4 100644
--- a/server/csharp/MetaObjects.IntegrationTests/Runner/WriteCoercion.cs
+++ b/server/csharp/MetaObjects.IntegrationTests/Runner/WriteCoercion.cs
@@ -47,6 +47,22 @@ public static PropertyInfo Property(Type entity, string fieldName) =>
         if (node is YamlMappingNode map)
             return BuildPoco(map, Nullable.GetUnderlyingType(targetType) ?? targetType);
 
+        // An @isArray object/scalar field authoring form: a YAML sequence → a List<TElement>.
+        // The generated property is ICollection<TElement> (EF maps a VO collection via
+        // .OwnsMany(...).ToJson(...)). Each element is coerced to the collection's element type
+        // (a mapping → an owned POCO; a scalar → its CLR value). An empty sequence yields an
+        // empty (non-null) list — distinct from a null/absent value.
+        if (node is YamlSequenceNode seq)
+        {
+            var elementType = CollectionElementType(targetType)
+                ?? throw new InvalidOperationException(
+                    $"'{prop.Name}' received a YAML sequence but its CLR type {targetType.Name} is not a supported collection");
+            var list = (System.Collections.IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(elementType))!;
+            foreach (var item in seq.Children)
+                list.Add(CoerceToProperty(item, elementType, prop));
+            return list;
+        }
+
         if (node is not YamlScalarNode scalar)
             throw new InvalidOperationException(
                 $"unsupported write value for '{prop.Name}' (kind {node.GetType().Name})");
@@ -83,6 +99,25 @@ public static PropertyInfo Property(Type entity, string fieldName) =>
             $"no write coercion for '{prop.Name}' of CLR type {underlying.Name}");
     }
 
+    // The element type of a generic collection property (ICollection<T>/IList<T>/List<T>/
+    // IEnumerable<T>), or null if targetType is not such a collection. `string` is excluded
+    // (it is IEnumerable<char> but a scalar here). The generated array property is exactly
+    // ICollection<T>, so the direct generic-definition check covers it.
+    private static Type? CollectionElementType(Type targetType)
+    {
+        if (targetType == typeof(string)) return null;
+        if (targetType.IsGenericType)
+        {
+            var def = targetType.GetGenericTypeDefinition();
+            if (def == typeof(ICollection<>) || def == typeof(IList<>) || def == typeof(List<>) ||
+                def == typeof(IEnumerable<>) || def == typeof(IReadOnlyList<>) || def == typeof(IReadOnlyCollection<>))
+                return targetType.GetGenericArguments()[0];
+        }
+        return targetType.GetInterfaces()
+            .FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(ICollection<>))
+            ?.GetGenericArguments()[0];
+    }
+
     private static bool ParseBool(string raw) => raw switch
     {
         "true" or "True" or "TRUE" => true,
diff --git a/server/java/codegen-kotlin/KNOWN_GAPS.md b/server/java/codegen-kotlin/KNOWN_GAPS.md
index 6cd75a8d2..82f180edd 100644
--- a/server/java/codegen-kotlin/KNOWN_GAPS.md
+++ b/server/java/codegen-kotlin/KNOWN_GAPS.md
@@ -31,6 +31,41 @@ tests; **consumer-side wiring is the consumer's responsibility**, in line
 with the cross-port pattern (TS consumers add `zod`; C# uses BCL
 `System.Text.Json` — no add needed there; Python consumers add `pydantic`).
 
+## Consumer dependency: Jackson is required for typed jsonb columns
+
+**Status:** consumer-wired, not a code gap — documented here so adopters know what to add.
+
+`KotlinExposedTableGenerator` emits one shared `MetaJsonbMapper.kt` support file per
+package that declares at least one typed `field.object @storage:jsonb` (single or
+`@isArray` array-of-VO) or `field.map` column. That file holds an
+`internal metaJsonbMapper` — a `com.fasterxml.jackson.databind.ObjectMapper` built from
+`JsonMapper.builder().addModule(kotlinModule()).addModule(JavaTimeModule())
+.disable(WRITE_DATES_AS_TIMESTAMPS)` — that the generated `jsonb()` column codecs
+read/write through (a `TypeReference<List<VO>>` captures the array-of-VO generic).
+
+Jackson — not kotlinx — is the codec precisely so the generated entity/value/projection
+data classes carry NO `@Serializable` and need NO per-type serializer plumbing: a kotlinx
+serializer (`VO.serializer()`) would require the `kotlin("plugin.serialization")`
+compiler plugin, and the moment that plugin is on, every VO carrying a
+`java.util.UUID` / `java.time.*` / `java.math.BigDecimal` / `java.net.*` field fails to
+compile (kotlinx has no serializer for those `java.*` types). Jackson round-trips them
+via its kotlin + jsr310 modules with zero per-type wiring. Consumers generating any typed
+jsonb/map column must add to their build:
+
+```kotlin
+dependencies {
+    implementation("com.fasterxml.jackson.core:jackson-databind:2.17.x")
+    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.17.x")
+    implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.17.x")
+}
+```
+
+No `kotlin("plugin.serialization")` compiler plugin is needed for this path — the
+generated codec is pure runtime Jackson. The separate `field.string @dbColumnType:jsonb`
+"open-bag" column stays on the kotlinx lane above (it round-trips through the runtime
+`Json.parseToJsonElement` → kotlinx `JsonElement` API, which also needs no compiler
+plugin); only the typed object/map jsonb columns pull in Jackson.
+
 ## Single-field, `Long`-typed primary keys only
 
 **Status:** assumption baked into Day 1 — same rationale as codegen-spring.
diff --git a/server/java/codegen-kotlin/README.md b/server/java/codegen-kotlin/README.md
index 0d18b08b0..628421203 100644
--- a/server/java/codegen-kotlin/README.md
+++ b/server/java/codegen-kotlin/README.md
@@ -6,7 +6,7 @@ Kotlin codegen target for Spring-Boot-Kotlin consumers on Exposed + Flyway. Emit
 
 | Generator | Output | Per |
 |---|---|---|
-| `KotlinEntityGenerator` | `<Entity>.kt` — `@Serializable data class` | every `object.entity` AND `object.value` |
+| `KotlinEntityGenerator` | `<Entity>.kt` — Kotlin `data class` (Jackson-compatible; no `@Serializable`) | every `object.entity` AND `object.value` |
 | `KotlinExposedTableGenerator` | `<Entity>Table.kt` — Exposed `Table` object with PK + FK + `@storage` columns | every entity with `source.rdb` |
 | `KotlinRelationsGenerator` | `<Entity>Relations.kt` — extension fns for `cardinality=many` query helpers | entities with `cardinality=many` composition relationships |
 | `KotlinPayloadGenerator` | `<Template>Payload.kt` — `@Serializable` payload from `@payloadRef` view-object | every `template.prompt` / `template.output` |
@@ -28,7 +28,7 @@ Kotlin codegen target for Spring-Boot-Kotlin consumers on Exposed + Flyway. Emit
 | `field.uuid` | `java.util.UUID` | `uuid(name)` |
 | `field.enum` | typed Kotlin `enum class` (separate `<Entity><Field>.kt` file with `@Serializable`) | `enumerationByName(name, 64, <Entity><Field>::class)` |
 | `field.object` (`@storage="flattened"`) | reference to the generated VO data class | per-sub-field columns: `<parent>_<sub>` |
-| `field.object` (`@storage="jsonb"` or default) | reference to the generated VO data class | single `jsonb(name, { Json.encodeToString(it) }, { Json.decodeFromString(it) })` |
+| `field.object` (`@storage="jsonb"` or default) | reference to the generated VO data class | single `jsonb(name, { metaJsonbMapper.writeValueAsString(it) }, { metaJsonbMapper.readValue(it, VO::class.java) })` — backed by a generated per-package `MetaJsonbMapper.kt` Jackson `ObjectMapper` (array-of-VO uses a `TypeReference<List<VO>>`); consumers add `jackson-databind` + `jackson-module-kotlin` + `jackson-datatype-jsr310` (no `kotlin("plugin.serialization")` compiler plugin) |
 
 ## Relationships → FK columns
 
@@ -196,4 +196,4 @@ The shared cross-language codegen conformance corpus is **FR-007** — see [`doc
 
 ## Test count
 
-75 tests in this module (`mvn -pl codegen-kotlin test`). Snapshot tests gate within-Java output stability; `kotlin-compile-testing` gates generated-code validity; an E2E test exercises the full loop including the Java `Renderer`.
+272 tests in this module (`mvn -pl codegen-kotlin test`). Snapshot tests gate within-Java output stability; `kotlin-compile-testing` gates generated-code validity; an E2E test exercises the full loop including the Java `Renderer`.
diff --git a/server/java/codegen-kotlin/pom.xml b/server/java/codegen-kotlin/pom.xml
index 8029cc3c7..285572f04 100644
--- a/server/java/codegen-kotlin/pom.xml
+++ b/server/java/codegen-kotlin/pom.xml
@@ -117,6 +117,15 @@
       <version>2.18.1</version>
       <scope>test</scope>
     </dependency>
+    <!-- The generated typed-jsonb Exposed columns emit a shared `metaJsonbMapper` (MetaJsonbMapper.kt)
+         that wires jackson-datatype-jsr310 for java.time round-tripping. Test-scoped so any compile
+         harness that emits a typed jsonb table can resolve it. -->
+    <dependency>
+      <groupId>com.fasterxml.jackson.datatype</groupId>
+      <artifactId>jackson-datatype-jsr310</artifactId>
+      <version>2.18.2</version>
+      <scope>test</scope>
+    </dependency>
     <!-- Required at test scope so kotlin-compile-testing can resolve @Serializable on generated code -->
     <dependency>
       <groupId>org.jetbrains.kotlinx</groupId>
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinEntityGenerator.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinEntityGenerator.kt
index b06ece30d..b52424b49 100644
--- a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinEntityGenerator.kt
+++ b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinEntityGenerator.kt
@@ -35,7 +35,8 @@ import java.nio.file.Path
 import java.nio.file.Paths
 
 /**
- * Generator: one @Serializable Kotlin data class per `object.entity` and `object.value`.
+ * Generator: one plain Kotlin data class (Jackson-compatible) per `object.entity` and
+ * `object.value`. No kotlinx `@Serializable` — see [emit] for why.
  *
  * <p>Skips abstract objects and any subType other than `entity` or `value`. KotlinPoet emits
  * whole files; the parent class's print-style writer machinery is bypassed in favour of a
@@ -72,7 +73,7 @@ open class KotlinEntityGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
             getArg("providedEnumNamespace"), getArg("providedEnumPackages"))
         // emitAbstractShapes (default OFF): when ON, an abstract entity is emitted as a Kotlin
         // `interface` shape (read-only properties) instead of being suppressed. It is NEVER
-        // emitted as an instantiable @Serializable data class — abstracts are scaffolding.
+        // emitted as an instantiable data class — abstracts are scaffolding.
         val emitAbstractShapes = (getArg("emitAbstractShapes", "false") ?: "false").toBoolean()
         // Run-level dedupe of emitted enum-class files by enum FQN: two fields sharing an
         // abstract enum super (resolved by KotlinTypeMapper.enumTypeName) collapse onto one file.
@@ -114,11 +115,17 @@ open class KotlinEntityGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         }
 
         val (pkg, shortName) = PackageMapping.splitFqn(obj.name)
-        val serializable = ClassName("kotlinx.serialization", "Serializable")
 
+        // NO kotlinx @Serializable: entity/value/projection data classes are plain
+        // (Jackson-compatible) data classes. The annotation was decorative — no build enables
+        // the kotlinx-serialization compiler plugin for these, and the moment one did, every
+        // class carrying a java.util.UUID / java.time.* / java.math.BigDecimal / java.net.* field
+        // would fail to compile (kotlinx has no built-in serializer for those). Jackson (the codec
+        // every consumer actually uses) round-trips them with zero per-type plumbing. Only
+        // KotlinPayloadGenerator's prompt payloads + KotlinEnumEmitter's enums keep @Serializable
+        // (FR-006 parse()/safeParse() genuinely kotlinx-decode those).
         val typeBuilder = TypeSpec.classBuilder(shortName)
             .addModifiers(KModifier.DATA)
-            .addAnnotation(serializable)
             .addKdoc("GENERATED — do not hand-edit. Regenerated from metadata.\n")
 
         // FR-017 TPH: a discriminator base's data class is the UNION of subtype columns and serves
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExposedTableGenerator.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExposedTableGenerator.kt
index 095a7eec1..1909bd778 100644
--- a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExposedTableGenerator.kt
+++ b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExposedTableGenerator.kt
@@ -3,6 +3,7 @@ package com.metaobjects.generator.kotlin
 import com.metaobjects.database.CoreDBMetaDataProvider
 import com.metaobjects.field.EnumField
 import com.metaobjects.field.MapField
+import com.metaobjects.field.MetaField
 import com.metaobjects.field.ObjectField
 import com.metaobjects.generator.GeneratorIOWriter
 import com.metaobjects.generator.direct.MultiFileDirectGeneratorBase
@@ -71,6 +72,12 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
         // pass 3 — same multi-table-per-package sharing rationale as the instant-tz helper.
         val packagesNeedingInetUriHelper = sortedSetOf<String>()
 
+        // Packages that emit at least one table carrying a typed `field.object @storage:jsonb`
+        // or `field.map` column. Each such package gets ONE shared `MetaJsonbMapper.kt` support
+        // file (the `internal metaJsonbMapper` ObjectMapper the generated jsonb() codecs call) —
+        // same `internal` per-package sharing rationale as the instant-tz / inet-uri helpers.
+        val packagesNeedingJacksonMapper = sortedSetOf<String>()
+
         // Pass 2: emit one Table per entity using its own metadata + the
         // inbound FKs accumulated in Pass 1.
         // FR-024 (ADR-0028): object.projection is emitted too — a projection with
@@ -121,6 +128,11 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
             if (entityNeedsInetUriHelper(entity, loader)) {
                 packagesNeedingInetUriHelper += PackageMapping.splitFqn(entity.name).first
             }
+            // Does this table carry a typed jsonb column (field.object non-flattened, or field.map)?
+            // If so its package needs the shared metaJsonbMapper support file.
+            if (entityNeedsJacksonMapper(entity, loader)) {
+                packagesNeedingJacksonMapper += PackageMapping.splitFqn(entity.name).first
+            }
         }
 
         // Pass 3: emit ONE shared `MetaInstantWithTimeZoneColumnType.kt` per package
@@ -138,6 +150,13 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
         for (pkg in packagesNeedingInetUriHelper) {
             emitInetUriSupportFile(pkg, outRoot)
         }
+
+        // Pass 3c: emit ONE shared `MetaJsonbMapper.kt` per package that has at least one typed
+        // `field.object @storage:jsonb` / `field.map` column. The `internal metaJsonbMapper`
+        // ObjectMapper is package+module-private, so every `*Table.kt` in the package shares it.
+        for (pkg in packagesNeedingJacksonMapper) {
+            emitJsonbMapperSupportFile(pkg, outRoot)
+        }
     }
 
     /**
@@ -159,6 +178,44 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
         return false
     }
 
+    /**
+     * True iff [entity] contributes at least one typed jsonb column that calls the shared
+     * `metaJsonbMapper` — a `field.map` (always jsonb) OR a `field.object` with jsonb/default
+     * storage (`@storage` != `flattened`) on a direct field, OR a `field.map` nested inside a
+     * flattened `object.value` sub-field. Mirrors what [buildObjectColumns] + the flattened
+     * sub-field path actually emit, so the support file is present exactly when referenced.
+     */
+    private fun entityNeedsJacksonMapper(entity: MetaObject, loader: MetaDataLoader): Boolean {
+        for (field in entity.metaFields) {
+            if (field is MapField) return true          // field.map is always a jsonb Jackson column
+            if (field is ObjectField) {
+                if (readStorage(field) != STORAGE_FLATTENED) return true   // typed jsonb object column
+                // A flattened object.value sub-field can itself be a field.map (a jsonb Jackson column).
+                val ref = readObjectRef(field) ?: continue
+                val target = KotlinGenUtil.resolveObjectByShortOrFqn(loader, ref) ?: continue
+                if (target.metaFields.any { it is MapField }) return true
+            }
+        }
+        return false
+    }
+
+    /**
+     * Emit the per-package `MetaJsonbMapper.kt` support file: an `internal` shared Jackson
+     * [com.fasterxml.jackson.databind.ObjectMapper] (`metaJsonbMapper`) that the generated typed
+     * `jsonb()` column codecs call to encode/decode `field.object @storage:jsonb` value objects
+     * and `field.map` maps. Jackson (kotlin + jsr310 modules) is used INSTEAD of kotlinx so the
+     * generated data classes stay plain (no `@Serializable`, no compiler plugin) — every java.time
+     * / java.util / java.math / java.net field a jsonb VO may carry round-trips with no per-type
+     * plumbing. `internal` keeps it package+module-private while every `*Table.kt` shares it.
+     *
+     * Consumer classpath: the generated code needs `com.fasterxml.jackson.core:jackson-databind`,
+     * `com.fasterxml.jackson.module:jackson-module-kotlin`, and
+     * `com.fasterxml.jackson.datatype:jackson-datatype-jsr310` on its runtime classpath.
+     */
+    private fun emitJsonbMapperSupportFile(pkg: String, outRoot: Path) =
+        // The jsonb block is fully-qualified (no imports needed).
+        emitSupportFile(pkg, outRoot, JSONB_MAPPER_SUPPORT_FILE_NAME, imports = "", block = JSONB_MAPPER_SUPPORT_BLOCK)
+
     /**
      * Emit the per-package `MetaInetUriColumnType.kt` support file (ADR-0036/0037 Wave 3):
      * `internal` custom Exposed column types for `field.uri` (a `Column<java.net.URI>` over
@@ -167,20 +224,8 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
      * extensions the generated tables call. `internal` keeps it package+module-private while
      * every `*Table.kt` in the package shares the one declaration.
      */
-    private fun emitInetUriSupportFile(pkg: String, outRoot: Path) {
-        val body = buildString {
-            if (pkg.isNotEmpty()) {
-                append("package $pkg\n\n")
-            }
-            append(INET_URI_SUPPORT_FILE_IMPORTS)
-            append("\n")
-            append(INET_URI_SUPPORT_BLOCK)
-            append("\n")
-        }
-        val outFile = outRoot.resolve(pkg.replace('.', '/')).resolve("$INET_URI_SUPPORT_FILE_NAME.kt")
-        outFile.parent?.let { Files.createDirectories(it) }
-        Files.writeString(outFile, body)
-    }
+    private fun emitInetUriSupportFile(pkg: String, outRoot: Path) =
+        emitSupportFile(pkg, outRoot, INET_URI_SUPPORT_FILE_NAME, INET_URI_SUPPORT_FILE_IMPORTS, INET_URI_SUPPORT_BLOCK)
 
     /**
      * Emit the per-package `MetaInstantWithTimeZoneColumnType.kt` support file for
@@ -191,17 +236,23 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
      * the single shared declaration — fixing the multi-table-per-package redeclaration that the
      * earlier inline-per-file emission caused.
      */
-    private fun emitInstantTzSupportFile(pkg: String, outRoot: Path) {
+    private fun emitInstantTzSupportFile(pkg: String, outRoot: Path) =
+        emitSupportFile(pkg, outRoot, INSTANT_TZ_SUPPORT_FILE_NAME, INSTANT_TZ_SUPPORT_FILE_IMPORTS, INSTANT_TZ_SUPPORT_BLOCK)
+
+    /**
+     * Emit one `internal` per-package support file (`<fileName>.kt`): a package header (when the
+     * package is non-empty), optional import lines, then the declaration block. Shared by the
+     * jsonb-mapper / inet-uri / instant-tz emitters, which differ only in file name, imports, and
+     * block — the `internal` declarations let every `*Table.kt` in the package reuse one copy.
+     */
+    private fun emitSupportFile(pkg: String, outRoot: Path, fileName: String, imports: String, block: String) {
         val body = buildString {
-            if (pkg.isNotEmpty()) {
-                append("package $pkg\n\n")
-            }
-            append(INSTANT_TZ_SUPPORT_FILE_IMPORTS)
-            append("\n")
-            append(INSTANT_TZ_SUPPORT_BLOCK)
+            if (pkg.isNotEmpty()) append("package $pkg\n\n")
+            if (imports.isNotEmpty()) { append(imports); append("\n") }
+            append(block)
             append("\n")
         }
-        val outFile = outRoot.resolve(pkg.replace('.', '/')).resolve("$INSTANT_TZ_SUPPORT_FILE_NAME.kt")
+        val outFile = outRoot.resolve(pkg.replace('.', '/')).resolve("$fileName.kt")
         outFile.parent?.let { Files.createDirectories(it) }
         Files.writeString(outFile, body)
     }
@@ -282,18 +333,25 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
         val objectColumns = buildObjectColumns(entity, primaryFieldSet, loader)
         // 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.
+        // `kotlinx.serialization.json.Json` import too (that open bag is the ONLY column that still
+        // uses kotlinx — the object/map jsonb columns use the Jackson metaJsonbMapper). Detect it on
+        // direct fields AND flattened object sub-fields — the same two surfaces that contribute
+        // columns / imports. Folding it into the jsonb-import decision (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
+        // Object/map jsonb columns → the Jackson metaJsonbMapper codec (a same-package `internal`
+        // val in MetaJsonbMapper.kt); the open-bag `field.string @dbColumnType=jsonb` → kotlinx
+        // `Json.parseToJsonElement` (a runtime API needing NO compiler plugin). They share the
+        // `jsonb` extension import but need DIFFERENT codec support: the object/map path needs the
+        // Jackson mapper file, the open-bag path needs the `kotlinx...Json` import.
+        val hasJacksonJsonbColumn = objectColumns.any { it.kind == ObjectColumnKind.JSONB }
+        val needsJsonbExtensionImport = hasJacksonJsonbColumn || hasStringJsonbOpenBag
+        val needsKotlinxJsonImport = hasStringJsonbOpenBag
         val needsRefOptForDecor = refDecorations.values.any { it.hasReferenceOption }
 
         // Does any column on this table use the TZ-aware instant (default, non-`@localTime`)
@@ -328,16 +386,17 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
         // object sub-fields are walked too — they emit columns of their own.
         val columnFunctionImports = sortedSetOf<String>()
         for (field in entity.metaFields) {
-            // field.object AND field.map columns are produced by buildObjectColumns
-            // (single jsonb column) — their imports are handled via needsJsonbImport, not here.
+            // field.object AND field.map columns are produced by buildObjectColumns (single jsonb
+            // column) — their imports (the `jsonb` extension + the metaJsonbMapper support file) are
+            // handled via the jsonb-import decision above, not here.
             if (field is ObjectField || field is MapField) continue
             // EnumField uses enumerationByName (a Table member) when generated, regardless
             // 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.
+            // emitted via the jsonb-import decision (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 }
         }
@@ -351,7 +410,7 @@ 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).
+                // jsonb open bag → its `jsonb`/`Json` imports come via the jsonb-import decision (skip here).
                 if (KotlinTypeMapper.isJsonbOpenBag(subField)) continue
                 KotlinTypeMapper.exposedColumnImport(subField)?.let { columnFunctionImports += it }
             }
@@ -391,8 +450,12 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
             for (imp in crossPackageTableImports) {
                 append("import $imp\n")
             }
-            if (needsJsonbImport) {
+            if (needsJsonbExtensionImport) {
                 append("import org.jetbrains.exposed.sql.json.jsonb\n")
+            }
+            // Only the open-bag `field.string @dbColumnType=jsonb` (JsonElement) uses kotlinx Json.
+            // Object/map jsonb columns use the same-package `metaJsonbMapper` (no import needed).
+            if (needsKotlinxJsonImport) {
                 append("import kotlinx.serialization.json.Json\n")
             }
             // R6 Plan 2a: the gen_random_uuid() server default uses CustomFunction +
@@ -543,7 +606,8 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
      *       physical column {@code <parentField>_<subField>} (snake-joined). Nullable
      *       sub-fields → nullable columns.</li>
      *   <li>{@code @storage="jsonb"} or absent (default-to-jsonb per CLAUDE.md):
-     *       one {@code jsonb(name, encoder, decoder)} column using kotlinx.serialization Json.</li>
+     *       one {@code jsonb(name, encoder, decoder)} column encoded/decoded through the shared
+     *       Jackson {@code metaJsonbMapper} (the per-package MetaJsonbMapper.kt support file).</li>
      * </ul>
      *
      * Skips field.object children whose `@objectRef` cannot be resolved (defensive — the loader's
@@ -564,7 +628,13 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
                 val parentNullable = parentName !in primaryFieldNames &&
                     !KotlinGenUtil.isRequiredField(field)
                 val colName = KotlinGenUtil.camelToSnake(parentName)
-                val expr = "jsonb(\"$colName\", { Json.encodeToString(it) }, { Json.decodeFromString(it) })"
+                // Jackson codec: a Map<String, V> stored in one JSONB column, encoded/decoded via
+                // the shared metaJsonbMapper (MetaJsonbMapper.kt support file). A TypeReference
+                // captures the erased generic so the read decodes back to Map<String, V> — NOT the
+                // reified `Json.encodeToString(it)` (which needs the kotlinx compiler plugin).
+                val valueType = mapValueTypeFqn(field, loader)
+                val expr = "jsonb(\"$colName\", { metaJsonbMapper.writeValueAsString(it) }, " +
+                    "{ metaJsonbMapper.readValue(it, object : com.fasterxml.jackson.core.type.TypeReference<Map<String, $valueType>>() {}) })"
                 val full = if (parentNullable) "$expr.nullable()" else expr
                 result.add(ObjectColumnSpec(parentName, full, ObjectColumnKind.JSONB))
                 continue
@@ -591,8 +661,32 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
             } else {
                 // jsonb (explicit) OR absent (default per CLAUDE.md back-compat rule).
                 // Physical column name snake_case-d to match the rest of the column emission.
+                // The column stores the referenced value object (or List<VO> for @isArray) as a
+                // single JSONB column, encoded/decoded through the shared Jackson metaJsonbMapper
+                // (the per-package MetaJsonbMapper.kt support file). Jackson — NOT kotlinx — because
+                // the generated entity/value data classes are plain (no @Serializable): a kotlinx
+                // serializer (`VO.serializer()`) would require the compiler plugin, and the moment
+                // that plugin is enabled every VO carrying a java.util.UUID / java.time.* /
+                // java.math.BigDecimal / java.net.* field fails to compile. Jackson round-trips them
+                // via its kotlin + jsr310 modules with zero per-type plumbing.
                 val colName = KotlinGenUtil.camelToSnake(parentName)
-                val expr = "jsonb(\"$colName\", { Json.encodeToString(it) }, { Json.decodeFromString(it) })"
+                val ref = readObjectRef(field)
+                val target = ref?.let { KotlinGenUtil.resolveObjectByShortOrFqn(loader, it) }
+                val decode = if (target != null) {
+                    // Fully-qualify the VO (Kotlin dotted form) so the emitted column needs no extra import.
+                    val voFqn = PackageMapping.toKotlin(target.name)
+                    if (field.isArrayType) {
+                        // List<VO> → a Jackson TypeReference captures the erased generic.
+                        "metaJsonbMapper.readValue(it, object : com.fasterxml.jackson.core.type.TypeReference<List<$voFqn>>() {})"
+                    } else {
+                        "metaJsonbMapper.readValue(it, $voFqn::class.java)"
+                    }
+                } else {
+                    // No resolvable @objectRef (defensive — validation gates the attr): decode to a
+                    // generic Jackson tree so the column still type-checks without kotlinx.
+                    "metaJsonbMapper.readValue(it, com.fasterxml.jackson.databind.JsonNode::class.java)"
+                }
+                val expr = "jsonb(\"$colName\", { metaJsonbMapper.writeValueAsString(it) }, { $decode })"
                 val full = if (parentNullable) "$expr.nullable()" else expr
                 result.add(ObjectColumnSpec(parentName, full, ObjectColumnKind.JSONB))
             }
@@ -600,20 +694,37 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
         return result
     }
 
-    /** Read the `@storage` attr (own-only); null when absent. */
-    private fun readStorage(field: ObjectField): String? {
+    /** Read the `@storage` attr (own-only); null when absent. `protected` so subclasses that
+     *  override [buildObjectColumns] can reuse it. */
+    protected fun readStorage(field: ObjectField): String? {
         if (!field.hasMetaAttr(ATTR_STORAGE, true)) return null
         return runCatching { field.getMetaAttr(ATTR_STORAGE, true).valueAsString }.getOrNull()
     }
 
-    /** Read the `@objectRef` attr (own-only); null when absent. */
-    private fun readObjectRef(field: ObjectField): String? {
+    /** Read the `@objectRef` attr (resolving); null when absent. Accepts any [MetaField] so both
+     *  `field.object` and an `@objectRef`-valued `field.map` can share the lookup. `protected` so
+     *  subclasses that override [buildObjectColumns] can reuse it. */
+    protected fun readObjectRef(field: MetaField<*>): String? {
         if (!field.hasMetaAttr(ObjectField.ATTR_OBJECTREF, true)) return null
         return runCatching { field.getMetaAttr(ObjectField.ATTR_OBJECTREF, true).valueAsString }
             .getOrNull()
     }
 
-    private companion object {
+    /**
+     * The Kotlin/Java source type of a [MapField]'s value V (the `V` in `Map<String, V>`),
+     * fully-qualified so the emitted Jackson `TypeReference` needs no import. An `@objectRef` map →
+     * the referenced VO's FQN; a scalar `@valueType` map → the scalar's canonical name (e.g.
+     * `kotlin.String`, `java.math.BigDecimal`); neither resolvable → `Any` (an untyped JSON bag).
+     */
+    private fun mapValueTypeFqn(field: MapField, loader: MetaDataLoader): String {
+        val target = readObjectRef(field)?.let { KotlinGenUtil.resolveObjectByShortOrFqn(loader, it) }
+        if (target != null) return PackageMapping.toKotlin(target.name)
+        return KotlinTypeMapper.mapValueScalarTypeName(field)?.toString() ?: "Any"
+    }
+
+    // `protected companion` (was `private`) so subclasses overriding [buildObjectColumns] can
+    // reference the @storage vocabulary constants.
+    protected companion object {
         /** Cross-language @storage attr on field.object — values: flattened | jsonb (default). */
         const val ATTR_STORAGE = "storage"
         const val STORAGE_FLATTENED = "flattened"
@@ -788,6 +899,41 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
             |internal fun Table.inetColumn(name: String): Column<InetAddress> =
             |    registerColumn(name, MetaInetColumnType())
             |""".trimMargin()
+
+        /**
+         * File name (sans `.kt`) of the per-package support file holding the shared Jackson
+         * `metaJsonbMapper`. One per package that emits ≥1 typed `field.object @storage:jsonb`
+         * or `field.map` column.
+         */
+        const val JSONB_MAPPER_SUPPORT_FILE_NAME = "MetaJsonbMapper"
+
+        /**
+         * Shared support body emitted ONCE PER PACKAGE (into [JSONB_MAPPER_SUPPORT_FILE_NAME].kt).
+         * Declares the `internal metaJsonbMapper` [com.fasterxml.jackson.databind.ObjectMapper] the
+         * generated typed `jsonb()` codecs call. Fully-qualified references so the file needs no
+         * imports. The kotlin module binds Kotlin data classes; jsr310 handles java.time; dates
+         * serialize as ISO-8601 strings (not epoch millis). `internal` → package+module-private,
+         * shared by every `*Table.kt` in the package.
+         */
+        val JSONB_MAPPER_SUPPORT_BLOCK: String = """
+            |/**
+            | * GENERATED — do not hand-edit.
+            | * Shared Jackson ObjectMapper backing the typed `field.object @storage:jsonb` and
+            | * `field.map` Exposed `jsonb()` columns in this package. Jackson (not kotlinx) is the
+            | * codec, so the generated entity/value data classes carry NO `@Serializable` and need
+            | * NO per-type serializer plumbing — every java.time / java.util / java.math / java.net
+            | * field a jsonb value object may carry round-trips through the kotlin + jsr310 modules
+            | * with no compiler plugin.
+            | *
+            | * Consumer classpath: jackson-databind, jackson-module-kotlin, jackson-datatype-jsr310.
+            | */
+            |internal val metaJsonbMapper: com.fasterxml.jackson.databind.ObjectMapper =
+            |    com.fasterxml.jackson.databind.json.JsonMapper.builder()
+            |        .addModule(com.fasterxml.jackson.module.kotlin.kotlinModule())
+            |        .addModule(com.fasterxml.jackson.datatype.jsr310.JavaTimeModule())
+            |        .disable(com.fasterxml.jackson.databind.SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
+            |        .build()
+            |""".trimMargin()
     }
 
     // === FK column emission from relationship.composition ====================
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinGenUtil.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinGenUtil.kt
index dc34777e6..09ca07058 100644
--- a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinGenUtil.kt
+++ b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinGenUtil.kt
@@ -7,11 +7,16 @@ import com.metaobjects.`object`.MetaObject
 import com.metaobjects.source.RdbSource
 
 /**
- * Internal helpers shared by the codegen-kotlin generators. Extracted to keep
+ * Helpers shared by the codegen-kotlin generators. Extracted to keep
  * the three generators (entity / exposed-table / payload) from carrying near-identical
  * private copies of the same lookups.
+ *
+ * `public` (was `internal`) so that adopters subclassing a generator — e.g. overriding
+ * [KotlinExposedTableGenerator.buildObjectColumns] in another module — can reuse these
+ * lookups instead of re-implementing them (the sibling `KotlinNaming` / `KotlinTypeMapper` /
+ * `PackageMapping` helper objects are already public for the same reason).
  */
-internal object KotlinGenUtil {
+public object KotlinGenUtil {
 
     /**
      * Resolve a MetaObject (entity OR value) by exact FQN match or by short-name match
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapper.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapper.kt
index a7cd3795b..d9a19ae90 100644
--- a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapper.kt
+++ b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapper.kt
@@ -100,7 +100,7 @@ object KotlinTypeMapper {
      * Note: this is the **raw-string** open-JSON path for `field.string`. The
      * typed-object JSONB path on `field.object` (`@storage=jsonb`) lives in
      * [KotlinExposedTableGenerator]'s object-column emission and uses
-     * `jsonb("col", encoder, decoder)` with kotlinx.serialization.
+     * `jsonb("col", encoder, decoder)` with the shared Jackson `metaJsonbMapper`.
      */
     private val DB_COLUMN_TYPE_JSONB = CoreDBMetaDataProvider.DB_COLUMN_TYPE_JSONB
 
@@ -109,9 +109,10 @@ object KotlinTypeMapper {
 
     /**
      * The kotlinx-serialization JSON-value type a `field.string @dbColumnType=jsonb` open-bag is
-     * 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
+     * exposed as (issue #98). `JsonElement` is the idiomatic "any JSON value" type — kotlinx is
+     * still this port's payload substrate (the FR-006 prompt payloads + enums), and its runtime
+     * `Json.parseToJsonElement` needs no compiler plugin. (The typed `field.object` / `field.map`
+     * jsonb columns, by contrast, now use the shared Jackson `metaJsonbMapper`, not kotlinx.) 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
@@ -492,14 +493,20 @@ object KotlinTypeMapper {
         // whose DDL is the Postgres-native `inet`. The helper lives in the package-shared
         // MetaInetUriColumnType.kt support file (emitted once per package).
         is InetField      -> "$EXPOSED_INET_FN(\"$colName\")"
-        // field.map → a single Postgres `JSONB` column holding the JSON object. Same
-        // emission as a `field.object` jsonb column (the typed-object JSONB path) — the
-        // Exposed `jsonb(name, encoder, decoder)` extension with kotlinx.serialization
-        // Json. Never flattened; isArray does not apply to a map. (Map columns are
-        // normally produced by KotlinExposedTableGenerator.buildObjectColumns; this arm
-        // keeps the mapper total for direct callers.)
-        is MapField       ->
-            "jsonb(\"$colName\", { Json.encodeToString(it) }, { Json.decodeFromString(it) })"
+        // field.map → a single Postgres `JSONB` column holding the JSON object. Same emission
+        // as a `field.object` jsonb column (the typed-object JSONB path) — the Exposed
+        // `jsonb(name, encoder, decoder)` extension encoded/decoded through the shared Jackson
+        // `metaJsonbMapper` (NOT kotlinx — the generated data classes are plain, no compiler
+        // plugin). Never flattened; isArray does not apply to a map. The value type V decodes
+        // via a Jackson `TypeReference<Map<String, V>>`; this loader-free arm can only name the
+        // scalar `@valueType` (an `@objectRef` map falls back to `Any`) — the loader-aware
+        // KotlinExposedTableGenerator.buildObjectColumns is where a typed VO map is emitted, and
+        // is the normal producer of map columns; this arm keeps the mapper total for direct callers.
+        is MapField       -> {
+            val valueType = mapValueScalarTypeName(field)?.toString() ?: "Any"
+            "jsonb(\"$colName\", { metaJsonbMapper.writeValueAsString(it) }, " +
+                "{ metaJsonbMapper.readValue(it, object : com.fasterxml.jackson.core.type.TypeReference<Map<String, $valueType>>() {}) })"
+        }
         else -> throw IllegalArgumentException(
             "unsupported Exposed column mapping for ${field::class.simpleName} '${field.name}'"
         )
diff --git a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/apidocs/KotlinApiModelBuilder.kt b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/apidocs/KotlinApiModelBuilder.kt
index a51a06724..954311735 100644
--- a/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/apidocs/KotlinApiModelBuilder.kt
+++ b/server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/apidocs/KotlinApiModelBuilder.kt
@@ -31,7 +31,7 @@ import com.metaobjects.template.TemplateConstants
  * **Per-category enumeration** (mirrors the Java `JavaApiModelBuilder` / C# / Python builders,
  * Kotlin/Exposed-flavored):
  * - **Objects** (`loader.metaObjects`): each concrete object → a [ApiSymbolKind.MODEL] symbol (the
- *   `@Serializable data class` from `KotlinEntityGenerator`). A writable-table entity additionally
+ *   plain (Jackson-compatible) `data class` from `KotlinEntityGenerator`). A writable-table entity additionally
  *   yields DATA_ACCESS (the Exposed `Table` object) / VALIDATION (the jakarta constraints on the
  *   data class, the controller's `@Valid @RequestBody`) / REST (one per controller route + each M:N
  *   traversal) / FILTER (the `<Entity>FilterAllowlist` object). A read-only `object.projection` →
@@ -102,7 +102,8 @@ class KotlinApiModelBuilder {
         // MODEL — documented only for concrete objects. An abstract object cannot be instantiated,
         // so we do not document a MODEL symbol for it (documented ⊆ generated). A concrete value
         // object / projection → MODEL only (plus a read-only data-access surface for a projection,
-        // below). The data class is the @Serializable model AND (for an entity) the controller body.
+        // below). The data class is a plain (Jackson-compatible) model AND (for an entity) the
+        // controller body — no kotlinx @Serializable.
         if (!KotlinGenUtil.isAbstractEntity(obj)) {
             symbols.add(
                 ApiSymbol(
@@ -111,9 +112,9 @@ class KotlinApiModelBuilder {
                     importLine = importLine(pkg, shortName),
                     signature = "data class $shortName",
                     usage = when {
-                        entity -> "the @Serializable entity model (also the controller request/response body)"
-                        projection -> "the @Serializable read-model (read-only projection of query results)"
-                        else -> "the @Serializable value-object model"
+                        entity -> "the entity model (plain Kotlin data class, Jackson-compatible; also the controller request/response body)"
+                        projection -> "the read-model (plain Kotlin data class, Jackson-compatible; read-only projection of query results)"
+                        else -> "the value-object model (plain Kotlin data class, Jackson-compatible)"
                     },
                 )
             )
diff --git a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinEntityGeneratorTest.kt b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinEntityGeneratorTest.kt
index 40befc08f..b3f735e9a 100644
--- a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinEntityGeneratorTest.kt
+++ b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinEntityGeneratorTest.kt
@@ -19,7 +19,11 @@ class KotlinEntityGeneratorTest {
       ] }
     }""".trimIndent()
 
-    @Test fun `emits data class with Serializable annotation`() {
+    @Test fun `emits plain data class without Serializable annotation`() {
+        // Entity/value/projection data classes are Jackson-compatible plain data classes —
+        // NO kotlinx @Serializable (that annotation was decorative, and enabling the
+        // kotlinx compiler plugin it needs would break every entity with a java.* field).
+        // Only KotlinPayloadGenerator's payloads + KotlinEnumEmitter's enums keep @Serializable.
         val outDir = Files.createTempDirectory("kgen-")
         try {
             val gen = KotlinEntityGenerator()
@@ -31,12 +35,12 @@ class KotlinEntityGeneratorTest {
                 "expected $emitted to exist; files=${Files.walk(outDir).toList()}")
 
             val src = Files.readString(emitted)
-            assertTrue("@Serializable" in src, "expected @Serializable in:\n$src")
+            assertFalse("@Serializable" in src, "expected NO @Serializable on entity in:\n$src")
+            assertFalse("kotlinx.serialization" in src,
+                "expected NO kotlinx.serialization import on entity in:\n$src")
             assertTrue("data class Author" in src, "expected data class in:\n$src")
             assertTrue("val id: Long" in src, "expected id: Long in:\n$src")
             assertTrue("val name: String" in src, "expected name: String in:\n$src")
-            assertTrue("kotlinx.serialization.Serializable" in src,
-                "expected kotlinx.serialization import in:\n$src")
         } finally {
             outDir.toFile().deleteRecursively()
         }
@@ -45,7 +49,7 @@ class KotlinEntityGeneratorTest {
     @Test fun fieldObjectEmitsTypedNestedReference() {
         // User has a field.object → Address; Address is an object.value with three fields.
         // Expected: User.kt has `val address: Address?` AND Address.kt is also emitted
-        // as a @Serializable data class.
+        // as a plain (Jackson-compatible) data class.
         val fx = """{
           "metadata.root": { "package": "acme::demo", "children": [
             { "object.value": { "name": "Address", "children": [
diff --git a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinExposedTableGeneratorTest.kt b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinExposedTableGeneratorTest.kt
index b69008419..bc6f92307 100644
--- a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinExposedTableGeneratorTest.kt
+++ b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinExposedTableGeneratorTest.kt
@@ -268,12 +268,20 @@ class KotlinExposedTableGeneratorTest {
             val src = Files.readString(userTable)
             assertTrue("import org.jetbrains.exposed.sql.json.jsonb" in src,
                 "expected jsonb import; saw:\n$src")
-            assertTrue("import kotlinx.serialization.json.Json" in src,
-                "expected Json import; saw:\n$src")
+            // A typed-VO jsonb column now uses the shared Jackson metaJsonbMapper — NOT kotlinx
+            // (that would require the serialization compiler plugin, which breaks any java.* field).
+            assertTrue("import kotlinx.serialization.json.Json" !in src,
+                "a typed-VO jsonb column must NOT drag in kotlinx Json; saw:\n$src")
             assertTrue(
-                "val address = jsonb(\"address\", { Json.encodeToString(it) }, { Json.decodeFromString(it) }).nullable()" in src,
-                "expected jsonb column initializer; saw:\n$src",
+                "val address = jsonb(\"address\", { metaJsonbMapper.writeValueAsString(it) }, { metaJsonbMapper.readValue(it, acme.demo.Address::class.java) }).nullable()" in src,
+                "expected Jackson jsonb column initializer; saw:\n$src",
             )
+            // The per-package shared Jackson mapper support file is emitted alongside the table.
+            val mapperFile = outDir.resolve("acme/demo/MetaJsonbMapper.kt")
+            assertTrue(Files.exists(mapperFile),
+                "expected per-package MetaJsonbMapper.kt support file; files=${Files.walk(outDir).toList()}")
+            assertTrue("val metaJsonbMapper" in Files.readString(mapperFile),
+                "expected metaJsonbMapper declaration in the support file")
             // Flattened sub-columns must NOT appear in the jsonb case.
             assertTrue("addressStreet" !in src,
                 "should NOT emit flattened sub-columns when storage=jsonb; saw:\n$src")
@@ -294,9 +302,11 @@ class KotlinExposedTableGeneratorTest {
             val src = Files.readString(userTable)
             assertTrue("import org.jetbrains.exposed.sql.json.jsonb" in src,
                 "expected jsonb import (default storage); saw:\n$src")
+            assertTrue("import kotlinx.serialization.json.Json" !in src,
+                "a typed-VO jsonb column must NOT drag in kotlinx Json; saw:\n$src")
             assertTrue(
-                "val address = jsonb(\"address\", { Json.encodeToString(it) }, { Json.decodeFromString(it) }).nullable()" in src,
-                "expected jsonb column when @storage absent; saw:\n$src",
+                "val address = jsonb(\"address\", { metaJsonbMapper.writeValueAsString(it) }, { metaJsonbMapper.readValue(it, acme.demo.Address::class.java) }).nullable()" in src,
+                "expected Jackson jsonb column when @storage absent; saw:\n$src",
             )
         } finally {
             outDir.toFile().deleteRecursively()
diff --git a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapperTest.kt b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapperTest.kt
index 1b07e36e7..c0020c628 100644
--- a/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapperTest.kt
+++ b/server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapperTest.kt
@@ -454,12 +454,15 @@ class KotlinTypeMapperTest {
     }
 
     @Test fun `map field emits a single jsonb exposed column`() {
-        // field.map → ONE jsonb column (same emission as a jsonb-stored field.object).
+        // field.map → ONE jsonb column (same emission as a jsonb-stored field.object), encoded
+        // through the shared Jackson metaJsonbMapper (NOT kotlinx — the generated data classes are
+        // plain, no compiler plugin). A TypeReference<Map<String, V>> captures the erased generic.
         // Never flattened, never a native array.
         val f = MapField("labels")
         f.addMetaAttr(StringAttribute.create(MapField.ATTR_VALUE_TYPE, "string"))
         assertEquals(
-            "jsonb(\"labels\", { Json.encodeToString(it) }, { Json.decodeFromString(it) })",
+            "jsonb(\"labels\", { metaJsonbMapper.writeValueAsString(it) }, " +
+                "{ metaJsonbMapper.readValue(it, object : com.fasterxml.jackson.core.type.TypeReference<Map<String, kotlin.String>>() {}) })",
             KotlinTypeMapper.exposedColumnSpec(f),
         )
         // The jsonb column needs the exposed-json import.
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-bidirectional-fk/acme/blog/Author.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-bidirectional-fk/acme/blog/Author.kt
index d304465fb..047818358 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-bidirectional-fk/acme/blog/Author.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-bidirectional-fk/acme/blog/Author.kt
@@ -3,12 +3,10 @@ package acme.blog
 import jakarta.validation.constraints.Size
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class Author(
   public val id: Long? = null,
   @field:Size(max = 100)
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-bidirectional-fk/acme/blog/Post.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-bidirectional-fk/acme/blog/Post.kt
index 602e84d6f..91618849f 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-bidirectional-fk/acme/blog/Post.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-bidirectional-fk/acme/blog/Post.kt
@@ -3,12 +3,10 @@ package acme.blog
 import jakarta.validation.constraints.Size
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class Post(
   public val id: Long? = null,
   @field:Size(max = 200)
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-controller/acme/blog/Author.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-controller/acme/blog/Author.kt
index 09283dc33..aab16b9a9 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-controller/acme/blog/Author.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-controller/acme/blog/Author.kt
@@ -5,12 +5,10 @@ import jakarta.validation.constraints.NotNull
 import jakarta.validation.constraints.Size
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class Author(
   public val id: Long? = null,
   @field:NotNull
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-enum/acme/game/Player.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-enum/acme/game/Player.kt
index b00c014b8..aeedd1ada 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-enum/acme/game/Player.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-enum/acme/game/Player.kt
@@ -3,12 +3,10 @@ package acme.game
 import jakarta.validation.constraints.Size
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class Player(
   public val id: Long? = null,
   @field:Size(max = 50)
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-fk/acme/blog/Author.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-fk/acme/blog/Author.kt
index d304465fb..047818358 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-fk/acme/blog/Author.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-fk/acme/blog/Author.kt
@@ -3,12 +3,10 @@ package acme.blog
 import jakarta.validation.constraints.Size
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class Author(
   public val id: Long? = null,
   @field:Size(max = 100)
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-fk/acme/blog/Post.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-fk/acme/blog/Post.kt
index 324c702da..0c7c377e1 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-fk/acme/blog/Post.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-fk/acme/blog/Post.kt
@@ -3,12 +3,10 @@ package acme.blog
 import jakarta.validation.constraints.Size
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class Post(
   public val id: Long? = null,
   @field:Size(max = 255)
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/Address.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/Address.kt
index 55339f8b8..e487e1e45 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/Address.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/Address.kt
@@ -2,12 +2,10 @@ package acme.commerce
 
 import jakarta.validation.constraints.Size
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class Address(
   @field:Size(max = 200)
   public val street: String? = null,
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/MetaJsonbMapper.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/MetaJsonbMapper.kt
new file mode 100644
index 000000000..dd5233382
--- /dev/null
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/MetaJsonbMapper.kt
@@ -0,0 +1,20 @@
+package acme.commerce
+
+/**
+ * GENERATED — do not hand-edit.
+ * Shared Jackson ObjectMapper backing the typed `field.object @storage:jsonb` and
+ * `field.map` Exposed `jsonb()` columns in this package. Jackson (not kotlinx) is the
+ * codec, so the generated entity/value data classes carry NO `@Serializable` and need
+ * NO per-type serializer plumbing — every java.time / java.util / java.math / java.net
+ * field a jsonb value object may carry round-trips through the kotlin + jsr310 modules
+ * with no compiler plugin.
+ *
+ * Consumer classpath: jackson-databind, jackson-module-kotlin, jackson-datatype-jsr310.
+ */
+internal val metaJsonbMapper: com.fasterxml.jackson.databind.ObjectMapper =
+    com.fasterxml.jackson.databind.json.JsonMapper.builder()
+        .addModule(com.fasterxml.jackson.module.kotlin.kotlinModule())
+        .addModule(com.fasterxml.jackson.datatype.jsr310.JavaTimeModule())
+        .disable(com.fasterxml.jackson.databind.SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
+        .build()
+
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/User.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/User.kt
index df72c9dc6..4cd33f41a 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/User.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/User.kt
@@ -3,12 +3,10 @@ package acme.commerce
 import jakarta.validation.constraints.Size
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class User(
   public val id: Long? = null,
   @field:Size(max = 255)
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/UserMetadata.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/UserMetadata.kt
index a03a2bbfd..9739c4030 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/UserMetadata.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/UserMetadata.kt
@@ -1,12 +1,10 @@
 package acme.commerce
 
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class UserMetadata(
   public val locale: String? = null,
   public val timezone: String? = null,
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/UserTable.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/UserTable.kt
index fc96b3f62..37ca07578 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/UserTable.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-storage/acme/commerce/UserTable.kt
@@ -2,7 +2,6 @@ package acme.commerce
 
 import org.jetbrains.exposed.sql.Table
 import org.jetbrains.exposed.sql.json.jsonb
-import kotlinx.serialization.json.Json
 
 /** GENERATED — do not hand-edit. Regenerated from metadata. */
 object UserTable : Table("users") {
@@ -11,7 +10,7 @@ object UserTable : Table("users") {
     val addressStreet = varchar("address_street", 200).nullable()
     val addressCity = varchar("address_city", 100).nullable()
     val addressZip = varchar("address_zip", 20).nullable()
-    val preferences = jsonb("preferences", { Json.encodeToString(it) }, { Json.decodeFromString(it) }).nullable()
+    val preferences = jsonb("preferences", { metaJsonbMapper.writeValueAsString(it) }, { metaJsonbMapper.readValue(it, acme.commerce.UserMetadata::class.java) }).nullable()
 
     override val primaryKey = PrimaryKey(id)
 }
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-stored-proc/acme/ops/OrderReport.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-stored-proc/acme/ops/OrderReport.kt
index 48b731e56..9fcf56a93 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-stored-proc/acme/ops/OrderReport.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-stored-proc/acme/ops/OrderReport.kt
@@ -3,12 +3,10 @@ package acme.ops
 import jakarta.validation.constraints.Size
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class OrderReport(
   public val orderId: Long? = null,
   @field:Size(max = 50)
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-tph/acme/auth/Auth.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-tph/acme/auth/Auth.kt
index 4da50b26a..e7da58bb1 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-tph/acme/auth/Auth.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-tph/acme/auth/Auth.kt
@@ -4,12 +4,10 @@ import java.math.BigDecimal
 import kotlin.Int
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class Auth(
   public val id: Long? = null,
   public val type: AuthType? = null,
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-tph/acme/auth/AuthLine.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-tph/acme/auth/AuthLine.kt
index e4f718622..3ee37748e 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-tph/acme/auth/AuthLine.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-tph/acme/auth/AuthLine.kt
@@ -3,12 +3,10 @@ package acme.auth
 import jakarta.validation.constraints.Size
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class AuthLine(
   public val id: Long? = null,
   @field:Size(max = 40)
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-view/acme/report/SalesReport.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-view/acme/report/SalesReport.kt
index 33b8d50a8..2a8e384ed 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-view/acme/report/SalesReport.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/entity-with-view/acme/report/SalesReport.kt
@@ -3,12 +3,10 @@ package acme.report
 import jakarta.validation.constraints.Size
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class SalesReport(
   public val id: Long? = null,
   @field:Size(max = 100)
diff --git a/server/java/codegen-kotlin/src/test/resources/snapshots/single-entity-primitives/acme/demo/Author.kt b/server/java/codegen-kotlin/src/test/resources/snapshots/single-entity-primitives/acme/demo/Author.kt
index 36d38d160..517043081 100644
--- a/server/java/codegen-kotlin/src/test/resources/snapshots/single-entity-primitives/acme/demo/Author.kt
+++ b/server/java/codegen-kotlin/src/test/resources/snapshots/single-entity-primitives/acme/demo/Author.kt
@@ -10,12 +10,10 @@ import kotlin.Double
 import kotlin.Int
 import kotlin.Long
 import kotlin.String
-import kotlinx.serialization.Serializable
 
 /**
  * GENERATED — do not hand-edit. Regenerated from metadata.
  */
-@Serializable
 public data class Author(
   public val id: Long? = null,
   @field:NotNull
diff --git a/server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/QueryScenarioRunner.kt b/server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/QueryScenarioRunner.kt
index 2dcdd436b..88ec7e9ed 100644
--- a/server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/QueryScenarioRunner.kt
+++ b/server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/QueryScenarioRunner.kt
@@ -654,11 +654,13 @@ object QueryScenarioRunner {
             if (v is Timestamp) v = v.toLocalDateTime()
             // `@dbColumnType:jsonb` open-JSON column (#98) reads back as a parsed kotlinx
             // JsonElement (or, for an object/map jsonb column, a raw JSON String). Convert
-            // whatever it is to a Map (via its JSON text — JsonElement.toString() is canonical
-            // JSON) so Normalization sorts the keys and the `expect` block (a YAML object) compares
-            // byte-equal. Detected by the column's SQL type (`jsonb`) so it stays generic.
+            // whatever it is to a plain JSON value (via its JSON text — JsonElement.toString() is
+            // canonical JSON) so Normalization sorts object keys / recurses into arrays and the
+            // `expect` block (a YAML object OR array) compares byte-equal. Read as `Any` (NOT
+            // `Map`) so both a JSON object (→ LinkedHashMap) and a JSON array (→ ArrayList, e.g. the
+            // `labels` array-of-VO column) round-trip. Detected by the column SQL type (`jsonb`).
             if (v != null && col.columnType.sqlType().lowercase().contains("jsonb")) {
-                v = JSON.readValue(v.toString(), Map::class.java)
+                v = JSON.readValue(v.toString(), Any::class.java)
             }
             out[col.name] = v
         }
diff --git a/server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/tables/AllTypesTable.kt b/server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/tables/AllTypesTable.kt
index 2d24737bc..5c1a86473 100644
--- a/server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/tables/AllTypesTable.kt
+++ b/server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/tables/AllTypesTable.kt
@@ -31,6 +31,7 @@ import org.jetbrains.exposed.sql.json.jsonb
  *   - `field.enum` (@values LOW/MEDIUM/HIGH)            → `varchar("enumVal", 64)` (text + CHECK in DDL)
  *   - `field.uuid` (non-key, @required)                 → `uuid("uuidVal")` (Postgres native uuid)
  *   - `field.object` (@objectRef Settings, @storage jsonb) → `jsonb("settings", …)` (real Postgres JSONB)
+ *   - `field.object` (@objectRef Label, @storage jsonb, isArray) → `jsonb("labels", …)` (JSONB array)
  *
  * The PK's server-side `gen_random_uuid()` DEFAULT lets a row be inserted with NO id
  * (Postgres mints it) — the server-generated-PK proof in `roundtrip-all-types.yaml`.
@@ -76,7 +77,24 @@ object AllTypesTable : Table("all_types") {
     // the JSON text; the runner serializes the authoring map on write and parses it back to a
     // Map on read so it re-serializes with sorted keys per the normalization contract. Nullable
     // to match the canonical DDL (`settings JSONB`, no NOT NULL).
+    //
+    // NOTE ON CODEC DIVERGENCE: this cross-port persistence oracle uses the RAW-JSON-STRING
+    // identity `jsonb(name, { it }, { it })` codec (Column<String>) — the generic runner
+    // pre-serializes the authoring value to a JSON string on write and re-parses it on read, so
+    // the column is String-typed by design and shared across every jsonb column here. The GENERATED
+    // KotlinExposedTableGenerator now emits a TYPED Jackson codec instead
+    // (`jsonb(name, { metaJsonbMapper.writeValueAsString(it) }, { metaJsonbMapper.readValue(...) })`,
+    // Column<VO>/Column<List<VO>>). That generated form is compiled + round-tripped against
+    // Testcontainers PG by com.metaobjects.integration.kotlin.tables.jsonb.GeneratedTypedJsonbRoundTripTest;
+    // reproducing the typed codec here would require the generic runner to bind typed VO instances,
+    // which it deliberately does not.
     val settings = jsonb("settings", { it }, { it }).nullable()
 
+    // `@storage:jsonb` @isArray owned-object column (`labels`, an array of the `Label` VO). Same
+    // raw-JSON-String identity codec as `settings`: the runner serializes the authoring List on
+    // write and parses it back to a List on read. An empty JSON array `[]` round-trips distinct
+    // from null. Nullable to match the canonical DDL (`labels JSONB`, no NOT NULL).
+    val labels = jsonb("labels", { it }, { it }).nullable()
+
     override val primaryKey = PrimaryKey(id)
 }
diff --git a/server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/tables/jsonb/GeneratedTypedJsonbRoundTripTest.kt b/server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/tables/jsonb/GeneratedTypedJsonbRoundTripTest.kt
new file mode 100644
index 000000000..b0e33879f
--- /dev/null
+++ b/server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/tables/jsonb/GeneratedTypedJsonbRoundTripTest.kt
@@ -0,0 +1,196 @@
+package com.metaobjects.integration.kotlin.tables.jsonb
+
+import com.metaobjects.generator.kotlin.KotlinEntityGenerator
+import com.metaobjects.generator.kotlin.KotlinExposedTableGenerator
+import com.metaobjects.integration.kotlin.PostgresContainer
+import com.metaobjects.metadata.ktx.loadString
+import com.tschuchort.compiletesting.KotlinCompilation
+import com.tschuchort.compiletesting.SourceFile
+import org.junit.jupiter.api.Test
+import java.nio.file.Files
+import kotlin.io.path.isRegularFile
+import kotlin.io.path.readText
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+/**
+ * The gate that was missing (the hole that let the broken kotlinx `VO.serializer()` jsonb form
+ * ship): a **compile + run** proof of the GENERATED typed-`field.object @storage:jsonb` Exposed
+ * table against a real Testcontainers Postgres. Before this, only a string-assert snapshot gated the
+ * generated form — so a codec that needs the kotlinx-serialization compiler plugin (and would break
+ * every entity carrying a `UUID`/`Instant`/… field the moment that plugin is enabled) passed review.
+ *
+ * What this proves end-to-end:
+ *  1. The generated entity/value data classes carry NO `@Serializable`, and the generated
+ *     `DemoTable`'s typed jsonb columns use the shared Jackson `metaJsonbMapper` (MetaJsonbMapper.kt
+ *     support file) — so the whole generated bundle **compiles via kctfork with NO serialization
+ *     compiler plugin** (`inheritClassPath = true` only). That is the point: the Jackson codec has
+ *     zero per-type plumbing and needs no plugin, even though the entity carries `UUID` + `Instant`
+ *     scalar fields that a kotlinx serializer could not resolve.
+ *  2. A single-VO jsonb column AND an array-of-VO jsonb column (`@isArray`) encode → persist → read
+ *     back byte-faithfully through Exposed against real Postgres JSONB, including the empty-array
+ *     (`[]` ≠ null) and null cases.
+ *
+ * Mechanism mirrors [com.metaobjects.integration.kotlin.api.generated] harnesses: generate → compile
+ * (generated sources + a tiny type-safe round-trip driver, same package) → invoke the driver against
+ * a fresh Postgres container.
+ */
+@OptIn(org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi::class)
+class GeneratedTypedJsonbRoundTripTest {
+
+    /**
+     * package `demo`: two value objects (`Settings`, `Label`) + an entity `Demo` whose columns
+     * include a UUID PK, an `Instant` timestamp, a single-VO jsonb (`settings`), and an
+     * array-of-VO jsonb (`labels`, `@isArray`). The UUID/Instant scalars are exactly the fields a
+     * kotlinx `.serializer()` could not resolve — so their presence is the compile-time proof.
+     */
+    private val fixture = """{
+      "metadata.root": { "package": "demo", "children": [
+        { "object.value": { "name": "Settings", "children": [
+            { "field.string": { "name": "theme" } },
+            { "field.int":    { "name": "retries" } }
+        ] } },
+        { "object.value": { "name": "Label", "children": [
+            { "field.string": { "name": "key" } },
+            { "field.int":    { "name": "weight" } }
+        ] } },
+        { "object.entity": { "name": "Demo", "children": [
+            { "source.rdb":   { "@table": "demo" } },
+            { "field.uuid":      { "name": "id", "@required": true } },
+            { "field.timestamp": { "name": "createdAt", "@required": true } },
+            { "field.object":    { "name": "settings", "@objectRef": "Settings", "@storage": "jsonb" } },
+            { "field.object":    { "name": "labels", "@objectRef": "Label", "@storage": "jsonb", "isArray": true } },
+            { "identity.primary": { "name": "id", "@fields": "id" } }
+        ] } }
+      ] }
+    }""".trimIndent()
+
+    /**
+     * A type-safe round-trip driver compiled ALONGSIDE the generated sources (same `demo` package),
+     * so it references the generated `DemoTable` / `Settings` / `Label` directly — no reflection into
+     * the typed columns. Returns "OK" on a clean round-trip, else a diagnostic string.
+     */
+    private val driverSource = """
+        package demo
+
+        import org.jetbrains.exposed.sql.Database
+        import org.jetbrains.exposed.sql.SchemaUtils
+        import org.jetbrains.exposed.sql.insert
+        import org.jetbrains.exposed.sql.selectAll
+        import org.jetbrains.exposed.sql.transactions.transaction
+        import java.time.Instant
+        import java.util.UUID
+
+        object TypedJsonbRoundTripDriver {
+            fun run(jdbcUrl: String, user: String, pass: String): String {
+                val db = Database.connect(jdbcUrl, driver = "org.postgresql.Driver", user = user, password = pass)
+                return transaction(db) {
+                    SchemaUtils.create(DemoTable)
+
+                    val ts = Instant.parse("2020-01-02T03:04:05Z")
+
+                    // Row 1: a 2-element array-of-VO + a single VO.
+                    val id1 = UUID.randomUUID()
+                    val settings1 = Settings(theme = "dark", retries = 3)
+                    val labels1 = listOf(Label(key = "alpha", weight = 10), Label(key = "beta", weight = 20))
+                    DemoTable.insert {
+                        it[DemoTable.id] = id1
+                        it[DemoTable.createdAt] = ts
+                        it[DemoTable.settings] = settings1
+                        it[DemoTable.labels] = labels1
+                    }
+
+                    // Row 2: an EMPTY array must round-trip as [] (distinct from null).
+                    val id2 = UUID.randomUUID()
+                    DemoTable.insert {
+                        it[DemoTable.id] = id2
+                        it[DemoTable.createdAt] = ts
+                        it[DemoTable.settings] = Settings(theme = "light", retries = 0)
+                        it[DemoTable.labels] = emptyList()
+                    }
+
+                    // Row 3: null jsonb columns stay null.
+                    val id3 = UUID.randomUUID()
+                    DemoTable.insert {
+                        it[DemoTable.id] = id3
+                        it[DemoTable.createdAt] = ts
+                        it[DemoTable.settings] = null
+                        it[DemoTable.labels] = null
+                    }
+
+                    val r1 = DemoTable.selectAll().where { DemoTable.id eq id1 }.single()
+                    val r2 = DemoTable.selectAll().where { DemoTable.id eq id2 }.single()
+                    val r3 = DemoTable.selectAll().where { DemoTable.id eq id3 }.single()
+
+                    when {
+                        r1[DemoTable.settings] != settings1 -> "settings mismatch: got ${'$'}{r1[DemoTable.settings]}"
+                        r1[DemoTable.labels] != labels1 -> "labels mismatch: got ${'$'}{r1[DemoTable.labels]}"
+                        r1[DemoTable.createdAt] != ts -> "timestamp mismatch: got ${'$'}{r1[DemoTable.createdAt]}"
+                        r2[DemoTable.labels] == null -> "empty array read back as null (must stay [])"
+                        r2[DemoTable.labels] != emptyList<Label>() -> "empty-array mismatch: got ${'$'}{r2[DemoTable.labels]}"
+                        r3[DemoTable.labels] != null -> "null labels not null: got ${'$'}{r3[DemoTable.labels]}"
+                        r3[DemoTable.settings] != null -> "null settings not null: got ${'$'}{r3[DemoTable.settings]}"
+                        else -> "OK"
+                    }
+                }
+            }
+        }
+    """.trimIndent()
+
+    @Test
+    fun `generated typed-jsonb table compiles without the serialization plugin and round-trips against Postgres`() {
+        val outDir = Files.createTempDirectory("typed-jsonb-rt-")
+        try {
+            val loader = loadString("typed-jsonb-rt", fixture)
+            for (g in listOf(KotlinEntityGenerator(), KotlinExposedTableGenerator())) {
+                g.setArgs(mapOf("outputDir" to outDir.toString()))
+                g.execute(loader)
+            }
+
+            // The generated entity/value classes must be plain (Jackson) — NO kotlinx @Serializable —
+            // and the table's typed jsonb columns must use the shared Jackson metaJsonbMapper.
+            val demoEntity = outDir.resolve("demo/Demo.kt").readText()
+            assertFalse("@Serializable" in demoEntity, "generated entity must carry NO @Serializable:\n$demoEntity")
+            val demoTable = outDir.resolve("demo/DemoTable.kt").readText()
+            assertTrue("metaJsonbMapper.writeValueAsString" in demoTable,
+                "generated table must use the Jackson metaJsonbMapper codec:\n$demoTable")
+            assertTrue("import kotlinx.serialization.json.Json" !in demoTable,
+                "typed-VO jsonb columns must NOT drag in kotlinx Json:\n$demoTable")
+            assertTrue(Files.exists(outDir.resolve("demo/MetaJsonbMapper.kt")),
+                "expected the per-package MetaJsonbMapper.kt support file")
+
+            // Compile every generated source + the round-trip driver. inheritClassPath only — NO
+            // serialization compiler plugin. This is the gate: the OLD `VO.serializer()` form would
+            // fail here (unresolved serializer / plugin required).
+            val sources = Files.walk(outDir).use { s ->
+                s.filter { it.isRegularFile() && it.toString().endsWith(".kt") }
+                    .map { SourceFile.kotlin(outDir.relativize(it).toString().replace('/', '_'), it.readText()) }
+                    .toList()
+            }.toMutableList()
+            sources.add(SourceFile.kotlin("TypedJsonbRoundTripDriver.kt", driverSource))
+
+            val result = KotlinCompilation().apply {
+                this.sources = sources
+                inheritClassPath = true
+                messageOutputStream = System.out
+            }.compile()
+            assertEquals(KotlinCompilation.ExitCode.OK, result.exitCode,
+                "generated typed-jsonb table (Jackson codec, no @Serializable) failed to compile " +
+                    "WITHOUT the kotlinx serialization plugin:\n${result.messages}")
+
+            // Round-trip against a real Postgres (JSONB) via the compiled driver.
+            PostgresContainer().use { pg ->
+                val driver = result.classLoader.loadClass("demo.TypedJsonbRoundTripDriver")
+                val instance = driver.getField("INSTANCE").get(null)
+                val outcome = driver
+                    .getMethod("run", String::class.java, String::class.java, String::class.java)
+                    .invoke(instance, pg.jdbcUrl, pg.username, pg.password) as String
+                assertEquals("OK", outcome,
+                    "generated Jackson typed-jsonb codec failed its Postgres round-trip: $outcome")
+            }
+        } finally {
+            outDir.toFile().deleteRecursively()
+        }
+    }
+}
diff --git a/server/java/integration-tests/src/test/java/com/metaobjects/integration/QueryScenarioTests.java b/server/java/integration-tests/src/test/java/com/metaobjects/integration/QueryScenarioTests.java
index d28b15eba..d592ba899 100644
--- a/server/java/integration-tests/src/test/java/com/metaobjects/integration/QueryScenarioTests.java
+++ b/server/java/integration-tests/src/test/java/com/metaobjects/integration/QueryScenarioTests.java
@@ -93,6 +93,7 @@ static void beforeAll() {
         // SP-H Unit 5 op:roundtrip — the every-subtype write keystone + its jsonb value object.
         bindings.put("fitness::AllTypes",    ValueObject.class);
         bindings.put("fitness::Settings",    ValueObject.class);
+        bindings.put("fitness::Label",       ValueObject.class);
         // FR-017 TPH corpus entities — the discriminator base + its three subtypes (single table).
         bindings.put("fitness::Auth",         ValueObject.class);
         bindings.put("fitness::BridgeAuth",   ValueObject.class);
diff --git a/server/java/integration-tests/src/test/java/com/metaobjects/integration/RoundtripWriter.java b/server/java/integration-tests/src/test/java/com/metaobjects/integration/RoundtripWriter.java
index f0a3ade9d..4b1a33892 100644
--- a/server/java/integration-tests/src/test/java/com/metaobjects/integration/RoundtripWriter.java
+++ b/server/java/integration-tests/src/test/java/com/metaobjects/integration/RoundtripWriter.java
@@ -194,6 +194,16 @@ private static void setNative(ValueObject vo, MetaField<?> mf, Object raw) {
                 ? Instant.parse(s)
                 : java.time.LocalDateTime.parse(s).toInstant(ZoneOffset.UTC);
             vo.setDate(name, java.util.Date.from(instant));
+        } else if (mf instanceof ObjectField && mf.isArrayType() && raw instanceof java.util.List<?> list) {
+            // An @isArray @objectRef jsonb column → a List<ValueObject> the jsonb write path
+            // serializes as a JSON array (each element built from its nested authoring map, like
+            // the single-VO branch below). setObjectArray (NOT setObject) so the array shape is
+            // preserved through the OMDB write codec.
+            java.util.List<ValueObject> elements = new java.util.ArrayList<>();
+            for (Object element : list) {
+                elements.add(buildValueObject((ObjectField) mf, (Map<String, Object>) element));
+            }
+            vo.setObjectArray(name, elements);
         } else if (mf instanceof ObjectField && raw instanceof Map<?, ?> map) {
             // The @objectRef jsonb value object → a ValueObject the jsonb write path serializes.
             vo.setObject(name, buildValueObject((ObjectField) mf, (Map<String, Object>) map));
diff --git a/server/java/omdb/src/main/java/com/metaobjects/manager/db/driver/GenericSQLDriver.java b/server/java/omdb/src/main/java/com/metaobjects/manager/db/driver/GenericSQLDriver.java
index becf60514..4b27ac1d4 100644
--- a/server/java/omdb/src/main/java/com/metaobjects/manager/db/driver/GenericSQLDriver.java
+++ b/server/java/omdb/src/main/java/com/metaobjects/manager/db/driver/GenericSQLDriver.java
@@ -175,17 +175,27 @@ protected int jsonbNullSqlType() {
      *       JSON written by Gson's default reflection (e.g. a Map) round-trips cleanly.</li>
      * </ol>
      *
-     * @param f    the jsonb MetaField (carries {@code @objectRef} and the loader)
+     * <p>Array-of-VO ({@code isArray:true} + {@code @storage:jsonb}): the column holds a JSON
+     * <em>array</em> of the referenced value-object, so the target type is {@code List<VO>} —
+     * built here via {@link com.google.gson.reflect.TypeToken#getParameterized}. Gson applies the
+     * per-element class (the registry-bound POJO in step 1, or the MetaObject's declared class via
+     * the {@link MetaObjectDeserializer} adapter in step 2) to each array element, yielding a typed
+     * {@code List}. This mirrors the single-VO branches; the write side already serializes a
+     * {@code List} natively (Gson handles it), so this closes the read half of the round-trip.
+     *
+     * @param f    the jsonb MetaField (carries {@code @objectRef}, {@code isArray}, and the loader)
      * @param json the JSON string read from the database column
-     * @return deserialized object
+     * @return deserialized object — a single VO, or a {@code List<VO>} for an {@code isArray} field
      */
     protected Object deserializeJsonb(MetaField f, String json) {
         try {
+            // isArray:true → the JSON is an array of the referenced VO; target List<VO> instead of VO.
+            boolean isArray = f.isArrayType();
             // Step 1: registry-bound typed POJO wins, deserialized via Gson reflection.
             if (MetaDataUtil.hasObjectRef(f)) {
                 Class<?> bound = ObjectClassRegistry.global().resolve(resolveObjectRefFqn(f));
                 if (bound != null) {
-                    return buildGson(f.getLoader()).fromJson(json, bound);
+                    return buildGson(f.getLoader()).fromJson(json, jsonbTargetType(bound, isArray));
                 }
             }
             // Step 2: fall back to the MetaObject's declared class (e.g. ValueObject).
@@ -197,12 +207,23 @@ protected Object deserializeJsonb(MetaField f, String json) {
                     m -> new GsonBuilder()
                             .registerTypeAdapter(refClass, new MetaObjectDeserializer(m))
                             .create());
-            return fallbackGson.fromJson(json, refClass);
+            return fallbackGson.fromJson(json, jsonbTargetType(refClass, isArray));
         } catch (Exception e) {
             throw new IllegalStateException("jsonb deserialize failed for field [" + f + "]: " + e, e);
         }
     }
 
+    /**
+     * The Gson target type for a jsonb value-object: {@code List<elementClass>} when the field is an
+     * array ({@code isArray:true}), else the bare {@code elementClass}. The parameterized {@code List}
+     * type drives Gson to apply the element deserializer per array element (see {@link #deserializeJsonb}).
+     */
+    private static java.lang.reflect.Type jsonbTargetType(Class<?> elementClass, boolean isArray) {
+        return isArray
+            ? com.google.gson.reflect.TypeToken.getParameterized(java.util.List.class, elementClass).getType()
+            : elementClass;
+    }
+
     /**
      * Returns the canonical FQN for the field's {@code @objectRef}, reusing the cached
      * {@link MetaDataUtil#getObjectRef} resolution rather than duplicating the expansion logic.
@@ -1698,6 +1719,10 @@ protected void parseField(Object o, MetaField f, ResultSet rs, int j) throws SQL
             String json = rs.getString(j);
             if (json == null || rs.wasNull()) {
                 f.setObject(o, null);
+            } else if (f.isArrayType()) {
+                // isArray:true → deserializeJsonb returns a List<VO>; store it via the array
+                // setter (setObject would coerce against the scalar OBJECT type and drop the List).
+                f.setObjectArray(o, (java.util.List<?>) deserializeJsonb(f, json));
             } else {
                 f.setObject(o, deserializeJsonb(f, json));
             }
diff --git a/server/java/omdb/src/test/java/com/metaobjects/manager/db/JsonbFieldDBTest.java b/server/java/omdb/src/test/java/com/metaobjects/manager/db/JsonbFieldDBTest.java
index a04b43c97..9a3f1d1a8 100644
--- a/server/java/omdb/src/test/java/com/metaobjects/manager/db/JsonbFieldDBTest.java
+++ b/server/java/omdb/src/test/java/com/metaobjects/manager/db/JsonbFieldDBTest.java
@@ -40,8 +40,10 @@
 import javax.sql.DataSource;
 import java.io.PrintWriter;
 import java.sql.*;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.logging.Logger;
 
@@ -75,6 +77,24 @@ public Prefs(String theme, int fontSize) {
         public void setFontSize(int fontSize) { this.fontSize = fontSize; }
     }
 
+    /** Public mutable POJO matching jsonbtest::Label fields (the array-of-VO element). */
+    public static class Label {
+        private String key;
+        private int weight;
+
+        public Label() {}
+
+        public Label(String key, int weight) {
+            this.key = key;
+            this.weight = weight;
+        }
+
+        public String getKey() { return key; }
+        public void setKey(String key) { this.key = key; }
+        public int getWeight() { return weight; }
+        public void setWeight(int weight) { this.weight = weight; }
+    }
+
     // ---------------------------------------------------------------------------
     // Static test infrastructure
     // ---------------------------------------------------------------------------
@@ -126,7 +146,8 @@ public static void setupDB() throws Exception {
             s.execute(
                 "CREATE TABLE JSONB_ITEM (\n"
                     + "  id BIGINT GENERATED ALWAYS AS IDENTITY CONSTRAINT JSONB_ITEM_id_PK PRIMARY KEY,\n"
-                    + "  prefs VARCHAR(4000)\n"
+                    + "  prefs VARCHAR(4000),\n"
+                    + "  labels VARCHAR(4000)\n"
                     + ")");
         }
     }
@@ -154,6 +175,7 @@ public void startTx() throws Exception {
             public Map<String, Class<?>> bindings() {
                 Map<String, Class<?>> m = new LinkedHashMap<>();
                 m.put("jsonbtest::Prefs", Prefs.class);
+                m.put("jsonbtest::Label", Label.class);
                 return m;
             }
         });
@@ -257,4 +279,92 @@ public void testValueObjectFallbackWhenNoBinding() throws Exception {
         assertEquals("solarized", fallbackVo.getString("theme"));
         assertEquals(12, ((Number) fallbackVo.getObject("fontSize")).intValue());
     }
+
+    // ---------------------------------------------------------------------------
+    // Test: typed array-of-VO (field.object @storage:jsonb isArray:true) round-trip
+    //
+    // Proves the array-of-VO write+read codec: a List<Label> is serialized to a JSON
+    // array on write and reconstructed into a typed List<Label> on read (element order
+    // preserved). This is the SP-H labels-array wire contract exercised by the
+    // persistence-conformance roundtrip corpus, gated here against a live SQL table.
+    // ---------------------------------------------------------------------------
+
+    @Test
+    public void testTypedJsonbArrayRoundTrip() throws Exception {
+        MetaObject mo = registry.findMetaObjectByName("jsonbtest::Item");
+        assertNotNull("Item MetaObject not found", mo);
+
+        // Create an Item with a typed List<Label> value (2 elements, order significant).
+        ValueObject item = (ValueObject) mo.newInstance();
+        List<Label> labels = new ArrayList<>();
+        labels.add(new Label("alpha", 10));
+        labels.add(new Label("beta", 20));
+        item.setObjectArray("labels", labels);
+        omdb.createObject(oc, item);
+
+        // Reload and assert the array round-tripped as a typed List<Label>, order preserved.
+        Collection<?> items = omdb.getObjects(oc, mo);
+        assertFalse("Expected at least one Item", items.isEmpty());
+        ValueObject loaded = (ValueObject) items.iterator().next();
+
+        Object labelsObj = loaded.getObject("labels");
+        assertNotNull("labels field should not be null", labelsObj);
+        assertTrue("labels should be a List, got: " + labelsObj.getClass().getName(),
+            labelsObj instanceof List);
+        List<?> loadedLabels = (List<?>) labelsObj;
+        assertEquals("labels should have 2 elements", 2, loadedLabels.size());
+
+        assertTrue("element 0 should be a Label, got: " + loadedLabels.get(0).getClass().getName(),
+            loadedLabels.get(0) instanceof Label);
+        Label first = (Label) loadedLabels.get(0);
+        assertEquals("alpha", first.getKey());
+        assertEquals(10, first.getWeight());
+
+        Label second = (Label) loadedLabels.get(1);
+        assertEquals("beta", second.getKey());
+        assertEquals(20, second.getWeight());
+    }
+
+    // ---------------------------------------------------------------------------
+    // Test: empty-array (`[]` distinct from null) + single-element round-trips.
+    // ---------------------------------------------------------------------------
+
+    @Test
+    public void testJsonbEmptyAndSingleArrayRoundTrip() throws Exception {
+        MetaObject mo = registry.findMetaObjectByName("jsonbtest::Item");
+
+        // (a) empty array must round-trip as an empty List (distinct from null).
+        ValueObject empty = (ValueObject) mo.newInstance();
+        empty.setObjectArray("labels", new ArrayList<Label>());
+        omdb.createObject(oc, empty);
+
+        Collection<?> items = omdb.getObjects(oc, mo);
+        assertFalse("Expected the empty-array row", items.isEmpty());
+        ValueObject loadedEmpty = (ValueObject) items.iterator().next();
+        Object emptyObj = loadedEmpty.getObject("labels");
+        assertNotNull("empty labels array must round-trip as [] not null", emptyObj);
+        assertTrue("empty array must round-trip as a List", emptyObj instanceof List);
+        assertEquals("empty array round-trips as empty List", 0, ((List<?>) emptyObj).size());
+
+        // Clean the row so the single-element assertion below sees exactly one row.
+        try (Connection c = getConnection(); Statement s = c.createStatement()) {
+            s.execute("DELETE FROM JSONB_ITEM");
+        }
+
+        // (b) single-element array.
+        ValueObject solo = (ValueObject) mo.newInstance();
+        List<Label> one = new ArrayList<>();
+        one.add(new Label("solo", 99));
+        solo.setObjectArray("labels", one);
+        omdb.createObject(oc, solo);
+
+        items = omdb.getObjects(oc, mo);
+        assertFalse("Expected the single-element row", items.isEmpty());
+        ValueObject loadedSolo = (ValueObject) items.iterator().next();
+        List<?> soloLabels = (List<?>) loadedSolo.getObject("labels");
+        assertEquals("single-element array size", 1, soloLabels.size());
+        Label only = (Label) soloLabels.get(0);
+        assertEquals("solo", only.getKey());
+        assertEquals(99, only.getWeight());
+    }
 }
diff --git a/server/java/omdb/src/test/resources/meta.jsonb.json b/server/java/omdb/src/test/resources/meta.jsonb.json
index e031f4e2e..3af3e414b 100644
--- a/server/java/omdb/src/test/resources/meta.jsonb.json
+++ b/server/java/omdb/src/test/resources/meta.jsonb.json
@@ -26,6 +26,15 @@
                 "@objectRef": "jsonbtest::Prefs"
               }
             },
+            {
+              "field.object": {
+                "name": "labels",
+                "@column": "labels",
+                "@storage": "jsonb",
+                "@objectRef": "jsonbtest::Label",
+                "isArray": true
+              }
+            },
             {
               "identity.primary": {
                 "name": "primary",
@@ -55,6 +64,26 @@
             }
           ]
         }
+      },
+      {
+        "object.value": {
+          "name": "Label",
+          "@object": "com.metaobjects.object.value.ValueObject",
+          "children": [
+            {
+              "field.string": {
+                "name": "key",
+                "@column": "key"
+              }
+            },
+            {
+              "field.int": {
+                "name": "weight",
+                "@column": "weight"
+              }
+            }
+          ]
+        }
       }
     ]
   }
diff --git a/server/python/src/metaobjects/runtime/object_manager.py b/server/python/src/metaobjects/runtime/object_manager.py
index 93d527fb5..abff5a8b6 100644
--- a/server/python/src/metaobjects/runtime/object_manager.py
+++ b/server/python/src/metaobjects/runtime/object_manager.py
@@ -27,6 +27,7 @@
 
 import datetime as _dt
 import decimal as _decimal
+import json as _json
 import uuid as _uuid
 from collections.abc import Iterable
 from typing import Any, Protocol
@@ -693,9 +694,24 @@ def _coerce_write_value(field: MetaField, value: Any) -> Any:
         is_tz = field.get_meta_attr(dbc.FIELD_ATTR_LOCAL_TIME) is not True  # ADR-0039 resolving: @localTime may be inherited
         return _parse_datetime(str(value), tz_aware=is_tz)
 
-    # field.object (jsonb storage): a dict/list passes through — pg8000 binds it
-    # to the jsonb column natively (no manual JSON.stringify, unlike node-pg).
-    # A field.string pinned to a jsonb column behaves the same way.
+    # field.object / field.map stored as a single jsonb column: serialize to a
+    # JSON text string so pg8000 sends it as jsonb text (PG assignment-casts text
+    # → jsonb). pg8000 binds a native *dict* to jsonb natively, but a native
+    # *list* (array-of-VO, isArray:true) it adapts as a Postgres ARRAY literal
+    # `{...,...}` which the JSONB column rejects with 22P02 'invalid input syntax
+    # for type json' — so we cannot rely on driver magic for the list form.
+    # Serializing both shapes to a JSON string is the explicit codec every other
+    # port has (Java/Gson, C#/System.Text.Json, TS/JSON.stringify, Kotlin/Jackson)
+    # and handles dict (single VO), list (array-of-VO), and [] uniformly.
+    #
+    # Scope: only jsonb-storage field.object/field.map. A *flattened* field.object
+    # is expanded to separate scalar columns (never reaches here as the object
+    # node) and must not be touched; a field.string pinned to a jsonb column via
+    # @dbColumnType already carries a string value and is left alone above.
+    if sub in (fc.FIELD_SUBTYPE_OBJECT, fc.FIELD_SUBTYPE_MAP):
+        storage = field.get_meta_attr(fc.FIELD_ATTR_STORAGE)  # ADR-0039 resolving
+        if storage != "flattened":  # None / "jsonb" / "subdocument" → single jsonb column
+            return _json.dumps(value)
     # Everything else (string / int / long / double / float / boolean / enum)
     # is already the native type pg8000 binds directly.
     return value