Make schema drift a compile-time error.

From one schema, five languages.

A typed entity in metadata, side-by-side with what every port actually generates. Each output is idiomatic for that language — Drizzle + Zod for TypeScript, JPA + Spring records for Java, Exposed + KotlinPoet data classes for Kotlin, EF Core + ASP.NET records for C#, SQLAlchemy + Pydantic for Python. Same metadata; five idiomatic outputs; conformance-gated to byte-identical canonical form.

The source: one YAML file in metaobjects/

# metaobjects/meta.subscriber.yaml
metadata.root:
  package: acme
  children:
    - object.entity:
        name: Subscriber
        children:
          - source.rdb:      { "@table": subscribers }
          - field.long:      { name: id }
          - field.string:    { name: email, "@maxLength": 320, "@required": true }
          - field.string:    { name: name }
          - field.enum:
              name: status
              "@values": [active, paused, cancelled]
              "@required": true
          - field.timestamp: { name: createdAt, "@autoSet": onCreate }
          - identity.primary: { "@fields": [id], "@generation": increment }

TypeScript — Drizzle + Zod from codegen-ts

// generated/Subscriber.ts
import { sqliteTable, integer, text } from "drizzle-orm/sqlite-core";
import { z } from "zod";

export const subscribers = sqliteTable("subscribers", {
  id:        integer("id").primaryKey({ autoIncrement: true }),
  email:     text("email", { length: 320 }).notNull(),
  name:      text("name"),
  status:    text("status", { enum: ["active", "paused", "cancelled"] as const }).notNull(),
  createdAt: text("created_at").notNull(),
});

export const SubscriberInsertSchema = z.object({
  email:  z.string().max(320),
  name:   z.string().optional(),
  status: z.enum(["active", "paused", "cancelled"]),
});

export type Subscriber = typeof subscribers.$inferSelect;
export type SubscriberInsert = z.infer<typeof SubscriberInsertSchema>;

Java — Spring + JPA record from codegen-spring

// generated/SubscriberDto.java
package acme;

public record SubscriberDto(
    Long id,
    String email,
    String name,
    SubscriberStatus status,
    java.time.Instant createdAt
) {}

public enum SubscriberStatus { ACTIVE, PAUSED, CANCELLED }

// generated/SubscriberController.java (excerpt)
@RestController
@RequestMapping("/api/subscribers")
public class SubscriberController {
    @GetMapping("/{id}")
    public SubscriberDto findById(@PathVariable Long id) { /* ... */ }

    @GetMapping
    public Page<SubscriberDto> list(@RequestParam Map<String, String> filter,
                                    Pageable pageable) { /* ... */ }

    @PostMapping public SubscriberDto create(@RequestBody SubscriberDto dto) { /* ... */ }
    @PutMapping("/{id}") public SubscriberDto update(...) { /* ... */ }
    @DeleteMapping("/{id}") public void delete(@PathVariable Long id) { /* ... */ }
}

Kotlin — Exposed + KotlinPoet data class from codegen-kotlin

// generated/Subscriber.kt
package acme

import java.time.Instant
import kotlinx.serialization.Serializable

@Serializable
public data class Subscriber(
  public val id: Long? = null,
  public val email: String,
  public val name: String? = null,
  public val status: SubscriberStatus,
  public val createdAt: Instant? = null,
)

@Serializable
public enum class SubscriberStatus { ACTIVE, PAUSED, CANCELLED }

// generated/SubscriberTable.kt
object SubscriberTable : Table("subscribers") {
    val id        = long("id").autoIncrement()
    val email     = varchar("email", 320)
    val name      = varchar("name", 255).nullable()
    val status    = enumerationByName("status", 20, SubscriberStatus::class)
    val createdAt = timestamp("created_at").nullable()

    override val primaryKey = PrimaryKey(id)
}

C#.NET — EF Core + ASP.NET from MetaObjects.Codegen

// generated/Subscriber.cs
namespace Acme;

public partial class Subscriber {
    public long Id { get; set; }
    public string Email { get; set; } = null!;
    public string? Name { get; set; }
    public SubscriberStatus Status { get; set; }
    public DateTimeOffset CreatedAt { get; set; }
}

public enum SubscriberStatus { Active, Paused, Cancelled }

// generated/AppDbContext.cs (excerpt)
public partial class AppDbContext : DbContext {
    public DbSet<Subscriber> Subscribers => Set<Subscriber>();

    protected override void OnModelCreating(ModelBuilder b) {
        b.Entity<Subscriber>(e => {
            e.HasKey(s => s.Id);
            e.Property(s => s.Email).IsRequired().HasMaxLength(320);
            e.Property(s => s.Status).HasConversion<string>();
        });
    }
}

Python — SQLAlchemy + Pydantic + FastAPI from metaobjects.codegen

# generated/subscriber.py
from datetime import datetime
from enum import Enum
from typing import Optional
from pydantic import BaseModel, Field
from sqlalchemy import String
from sqlalchemy.orm import Mapped, mapped_column
from .base import Base

class SubscriberStatus(str, Enum):
    ACTIVE = "active"
    PAUSED = "paused"
    CANCELLED = "cancelled"

class Subscriber(Base):
    __tablename__ = "subscribers"
    id:         Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
    email:      Mapped[str] = mapped_column(String(320))
    name:       Mapped[Optional[str]]
    status:     Mapped[SubscriberStatus]
    created_at: Mapped[datetime]

class SubscriberInsert(BaseModel):
    email:  str = Field(max_length=320)
    name:   Optional[str] = None
    status: SubscriberStatus

Plus a migration — dialect-aware (Postgres / SQLite / Cloudflare D1)

-- migrations/0001_create_subscribers.up.sql (SQLite dialect)
CREATE TABLE subscribers (
  id         INTEGER PRIMARY KEY AUTOINCREMENT,
  email      VARCHAR(320) NOT NULL,
  name       TEXT,
  status     VARCHAR(20)  NOT NULL CHECK (status IN ('active', 'paused', 'cancelled')),
  created_at TIMESTAMP   NOT NULL
);

And the three CLI commands you actually run

# Scaffold metaobjects/ + .metaobjects/ + metaobjects.config.ts
$ meta init

# Generate code (entities, validators, queries, routes, payload VOs, output parsers)
$ meta gen

# Diff metadata vs live DB; emit migration SQL (up + down)
$ meta migrate --db file:./dev.db --slug add-subscriber

Conformance fixtures (JSON form): fixtures/conformance/. YAML and JSON are equivalent — pick whichever your stack prefers.

The metamodel goes deep.

Fields aren't just columns. They carry validators, views, and currency formatting as child metadata. Entities derive read-only projections — passthrough fields and aggregates over relationships — that generate as database views, not tables. Everything below is real meta gen output, conformance-gated, not hand-wired annotations.

The source: rich child metadata on fields + a derived projection

# metaobjects/meta.blog.yaml
metadata.root:
  package: blog
  children:
    - object.entity:
        name: Author
        children:
          - field.string:
              name: email
              "@required": true
              children:                                       # child metadata on a field
                - validator.required: { name: req }
                - validator.regex:    { name: emailFmt, "@pattern": "^[^@]+@[^@]+$" }
          - field.string:
              name: bio
              children:
                - validator.length: { name: bioLen, "@min": 0, "@max": 500 }
          - relationship.composition: { name: posts, "@objectRef": Post, "@cardinality": many }
          - identity.primary: { "@fields": [id], "@generation": increment }   # name optional → defaults to "primary"
    - object.entity:
        name: Post
        children:
          - field.currency:
              name: price
              "@currency": USD
              children:
                - view.currency: { name: money, "@locale": en-US }   # Intl formatting, integer minor units
          # … id, title, authorId, identity.reference (FK to Author) …
    - object.projection:                                  # derived, read-only
        name: AuthorSummary
        children:
          - source.rdb: { "@kind": view, "@view": v_author_summary }
          - field.long: { name: id, extends: blog::Author.id,
                        children: [ { origin.passthrough: { "@from": Author.id } } ] }
          - field.int:  { name: postCount,
                        children: [ { origin.aggregate: { "@agg": count, "@of": Post.id, "@via": Author.posts } } ] }
          - identity.primary: { extends: blog::Author.primary, "@fields": [id] }

Field validators → Zod refinements (generated/Author.ts)

// validator.required + validator.regex + validator.length, straight from the field children
export const AuthorInsertSchema = z.object({
  email: z.string().min(1).regex(new RegExp("^[^@]+@[^@]+$")),
  bio:   z.string().min(0).max(500).optional(),
});

Currency view → typed formatting metadata (generated/Post.ts)

// field.currency stores integer minor units; view.currency carries the Intl config
price: {
  name: "price", label: "Price",
  view: "currency", currency: "USD", locale: "en-US",
},

Projection → a read-only database view, not a table (generated/AuthorSummary.ts)

// No Insert/Update schema — a projection is read-only by construction.
export const authorSummaryView = sqliteView("v_author_summary", {}).existing();
export const AuthorSummarySchema = z.object({
  id:        z.number().int(),
  postCount: z.number().int(),   // COUNT(Post.id) via the Author→posts relationship
});

Run it yourself: this exact model loads and generates a full typed stack in the TypeScript reference implementation with zero errors and zero warnings — and every construct it uses (projections, origins, currency views, field-level validators) is conformance-gated across all five ports.