Governed Typed JSON

Protocol‑Level Governance for Structured, Identity‑Bearing JSON Stored Natively in SQL

json becomes durable when it is governed

Protocol governance, not serialization

NTTECO does not treat JSON as a convenience format for transporting server‑defined objects. It treats JSON as an execution protocol for governed object graphs. This governance spans identity assignment, serialization, SQL storage, and deterministic reconstruction.

The result is JSON that can function as a durable execution substrate rather than a transient transport artifact.

Structured, typed JSON with identity

In NTTECO, JSON is never anonymous. Every object is an INtt with a globally unique OCEXC_NTTUID that forms a stable contract between the database object, emitted serializer, parser, extension surface, and promotion pipeline.

Only protocol‑approved structures are allowed:

  • System primitives (string, int, bool, Guid, DateTime, etc.)
  • INtt classes
  • NttList<INtt> for collections

There are no dictionaries, no untyped arrays, and no anonymous objects. Every structure participates fully in the protocol.

Collections as protocol objects

NttList<INtt> is not a container. It is itself an INtt.

Collections in NTTECO have identity, participate in mapped‑name resolution, support extension fields, and are promotable and deterministically parsed. Nested collections are explicitly disallowed to preserve identity semantics and deterministic promotion.

SQL‑native storage without loss of structure

NTTECO treats SQL as a first‑class execution surface. JSON stored in NVARCHAR(MAX) is not opaque text — it is a serialized NTT object graph.

Serialization is performed by NTTECO‑emitted, reflection‑free serializers bound to specific OCEXC_NTTUID identifiers that correspond directly to database objects.

When JSON is read from SQL, NTTECO reconstructs identity‑bearing object graphs with full mapping, inheritance, and extension support — without schema hints or ad‑hoc parsing.

Deterministic execution across layers

NTTECO enforces determinism end‑to‑end through emitted serializers, mapped names, after‑only inheritance, governed extension fields, and UTF‑8 streaming parsing.

What is written can always be read. What is extended can always be promoted. What is stored can always be reconstructed.

This comparison highlights structural capability differences. It is not a performance comparison.

NTTECO vs Common JSON Models

Capability Traditional JSON NTTECO
Identity‑bearing objects No Yes (NTTUID)
Strong typing end‑to‑end No Yes
Governed schema evolution No Yes
Extension fields without breakage No Yes
SQL‑native JSON storage Opaque Yes
Deterministic parsing No Yes
Reflection‑free serialization No Yes
Protocol‑level governance No Yes

NTTECO makes typed JSON viable as a long‑term execution substrate by governing structure, identity, and evolution — not by adding convenience features.

This is an early public release of the NTTECO platform. Additional components and documentation will be published soon.

For technical discussions or early access inquiries, contact admin@ntteco.com.