@@ -248,6 +248,42 @@ edit (two registered `description` strings) and was ruled a hold, as 1.0.4's was
 
 ### Fixed
 
+- **TypeScript: a `field.timestamp` reached the wire as Postgres' own text,
+  `"2026-09-20 12:00:00+00"`, not ISO 8601.** `docs/features/api-contract.md` (and
+  `normalization.md` behind it) promise `YYYY-MM-DDTHH:MM:SS[.fff]Z`, always UTC, and the
+  other four ports answer the same row that way. Codegen maps a Postgres `field.timestamp` to
+  `timestamp(…, { mode: "string" })`, and in string mode Drizzle returns exactly what
+  node-postgres received: Postgres' OUTPUT format, with a space for the `T` and the offset of
+  whatever time zone the session runs in. A strict ISO 8601 client rejects it, and under a
+  non-UTC session it is not even a UTC value. The comment in `column-mapper.ts` claimed the
+  column "round-trips ISO-8601 strings"; it never did. `@metaobjectsdev/runtime-ts`'s Fastify
+  and Hono mounts — list, get, create, update, the TPH base and subtype routes, projections
+  and M:N traversal — now put every timestamp column in the contract's spelling before they
+  send a row. The offset is converted to UTC, the fraction is truncated to milliseconds with
+  trailing zeros stripped, a zero fraction is omitted, and an `@localTime` column keeps its
+  wall clock with no `Z`. Which columns count is read from the Drizzle column objects, never
+  guessed from a value, so a text column holding timestamp-shaped text is left alone. Under
+  `timestampMode: "date"` the same code drops the `.000` that `Date#toJSON` pads.
+  **No regen needed**: the generated routes delegate to these mounts. A hand-written route
+  that sends a row itself can map it through the newly exported `timestampWire(table)`
+  (`@metaobjectsdev/runtime-ts/drizzle-fastify` or `/hono`). Two limits, stated: SQLite and
+  D1 store a `field.timestamp` in a plain `text` column, so the value goes back as it was
+  written; and a projection over an opaque `@sql` view has no declared columns to read.
+  No api-contract scenario could see this: none asserts a timestamp literally, and the
+  runners normalize `createdAt` before comparing. An adopter estate's strict client found
+  it. It is now gated on a real Postgres whose session runs in `America/New_York`, so
+  relabelling `+00` as `Z` would not pass. The test covers both adapters and both entry
+  points (`runtime-ts/test/timestamp-wire-pg.test.ts`). `ci-local.sh`'s `ts-slow` lane now
+  runs that file and `read-only-raw-sql-pg.test.ts`. The second file needed a database and
+  had skipped everywhere.
+
+- **TypeScript (Hono): an empty `PATCH` body was a 500.** `@metaobjectsdev/runtime-ts/hono`'s
+  update handler passed `{}` straight to Drizzle's `.set()`, which throws `No values to set`.
+  The redaction path turned that into `500 {"error":"database error"}`. The Fastify mount has
+  answered an empty patch as a read (200 with the row, or 404) since the TPH discriminator
+  work, and Hono now does the same. The generated api-contract lane runs on Fastify, so the
+  corpus's `patch-empty-noop` scenario never reached Hono.
+
 - **Web client: every filtered request 400'd against a Spring Boot backend.**
   `@metaobjectsdev/runtime-web`'s `buildFilterQs` — which every generated TanStack hook
   calls — sent the filter grammar with raw brackets (`filter[email][like]=…`). RFC 3986
 
@@ -109,6 +109,14 @@ Runners are responsible for normalizing `createdAt` (and any other
 non-deterministic fields) before comparison. The keys listed above are
 the only ones a runner must understand to be conformant.
 
+A consequence worth stating: this corpus does **not** gate the SPELLING of a
+`field.timestamp` on the wire (`docs/features/api-contract.md`, "Type
+encodings"). No scenario asserts a timestamp literally, and the reference
+servers store `createdAt` in whatever column type each port chose. The TS
+generated routes shipped Postgres' output text (`2026-09-20 12:00:00+00`)
+through a fully green corpus for that reason. TS now gates the spelling in
+`server/typescript/packages/runtime-ts/test/timestamp-wire-pg.test.ts`.
+
 ## Filter operator coverage (FR-009)
 
 The `filter-*` scenarios pin the 9 cross-port filter operators declared in
 
@@ -469,8 +469,14 @@ gate_migrate_ts_pg() { bun_install && ( cd server/typescript/packages/migrate-ts
 # while Fastify (fixed for the same thing) stayed green (#286). Runs here because ts-slow is
 # the lane with the sidecar; METAOBJECTS_TEST_PG_URL + RUNTIME_TS_PG_EXPECT=1 come from the
 # CI job, and without them the suite self-skips exactly as before.
+#
+# Every PG-gated runtime-ts file is listed here, because ts-unit has no database and a
+# file this lane does not name is a file that only ever skips: read-only-raw-sql-pg ran
+# nowhere with a database until it was added. timestamp-wire-pg is the only gate on the
+# field.timestamp wire spelling — the api-contract runners normalize `createdAt` first.
 gate_runtime_ts_pg() {
-  bun_install && ( cd server/typescript/packages/runtime-ts && bun test test/dialect-matrix-pg.test.ts )
+  bun_install && ( cd server/typescript/packages/runtime-ts && bun test \
+    test/dialect-matrix-pg.test.ts test/read-only-raw-sql-pg.test.ts test/timestamp-wire-pg.test.ts )
 }
 
 # ── conformance.yml — per-port conformance corpora (exact CI commands) ────────
 
@@ -589,13 +589,19 @@ export function mapColumnType(
           // value opts out with @localTime:true → timestamp({ withTimezone:
           // false }) = `timestamp without time zone`.
           //
-          // mode:"string" so the column round-trips ISO-8601 strings — the
+          // mode:"string" so the column binds and returns STRINGS — the
           // generated Zod schema validates timestamp fields as z.string() and
           // the cross-port wire format carries timestamps as JSON strings.
           // Drizzle's default timestamp mode is "date" (expects/returns a JS
           // Date and calls value.toISOString() on write), which is internally
           // inconsistent with the string-typed schema + wire contract and
           // throws on a string write. See SP-B api-contract-generated lane.
+          //
+          // A string read back is NOT ISO 8601: it is Postgres' output text,
+          // `2026-09-20 12:00:00+00`, in the session's time zone. The runtime-ts
+          // mounts the generated routes delegate to put it in the wire spelling;
+          // a hand-written route that sends a row itself should map it through
+          // `timestampWire(table)` from the same runtime-ts entry point.
           fnName = "timestamp";
           fnOptions = {
             mode: timestampMode,
 
@@ -22,8 +22,10 @@ import qs from "qs";
 import type { FilterAllowlist, SortAllowlist } from "./filter-allowlist.js";
 export type { FilterAllowlist, SortAllowlist } from "./filter-allowlist.js";
 import { parseFilterParams, FilterParseError } from "./filter-parser.js";
-import { isTruthyFlag, contractErrorCode, coerceIdForColumn } from "./util.js";
+import { isTruthyFlag, contractErrorCode, coerceIdForColumn, firstRow } from "./util.js";
+import { timestampWire } from "../timestamp-wire.js";
 export { isTruthyFlag, contractErrorCode, parseId, coerceIdForColumn } from "./util.js";
+export { timestampWire, canonicalTimestamp } from "../timestamp-wire.js";
 
 // ---------------------------------------------------------------------------
 // Loose types — we don't bind to a specific Drizzle backend so the helper
@@ -106,6 +108,24 @@ function readSource(opts: VerbOptions): AnyTable {
   return opts.readView ?? opts.table;
 }
 
+/**
+ * Wire mapper for rows READ through `readSource` — canonicalized against
+ * exactly that source, since a view may shadow a table column with a
+ * non-timestamp of the same name.
+ */
+function readWire(opts: VerbOptions): (row: unknown) => unknown {
+  return timestampWire(readSource(opts));
+}
+
+/**
+ * Wire mapper for a WRITE ECHO: `reReadThroughView` answers with the replica
+ * view's row but falls back to the table row, so the echo is canonicalized
+ * against the union of both sources.
+ */
+function echoWire(opts: VerbOptions): (row: unknown) => unknown {
+  return timestampWire(opts.table, opts.readView);
+}
+
 /** #214 — after a write to the base table, re-read the row THROUGH the replica
  *  view by PK so the response carries derived (origin.passthrough) columns. When
  *  there is no `readView`, return the write row unchanged (current behaviour). */
@@ -141,6 +161,7 @@ function routeOpts(opts: VerbOptions): RouteShorthandOptions {
 }
 
 export function mountListRoute(opts: VerbOptions): void {
+  const toWire = readWire(opts);
   opts.fastify.get(opts.path, routeOpts(opts), async (req, reply) => {
     try {
       // #214 — a write-through entity reads through its replica view.
@@ -196,7 +217,7 @@ export function mountListRoute(opts: VerbOptions): void {
       // drizzle-orm node-postgres query builder is thenable but has no `.all()`
       // method (that is a libsql/better-sqlite3-only API). Awaiting works on
       // both dialects and is what makes this helper genuinely Postgres-capable.
-      const rows = await q;
+      const rows = (await q as unknown[]).map(toWire);
 
       if (!withCount) return rows;
 
@@ -216,6 +237,7 @@ export function mountListRoute(opts: VerbOptions): void {
 }
 
 export function mountGetRoute(opts: VerbOptions): void {
+  const toWire = readWire(opts);
   opts.fastify.get(`${opts.path}/:id`, routeOpts(opts), async (req, reply) => {
     const { id } = req.params as { id: string };
     const discCond = discriminatorCond(opts);
@@ -228,20 +250,13 @@ export function mountGetRoute(opts: VerbOptions): void {
       return reply.code(400).send({ error: "invalid_id" });
     }
     const idCond = eq(src.id, idValue);
-    // Await + take the first row rather than `.get()` — `.get()` is a
-    // libsql/better-sqlite3-only method; the node-postgres builder is thenable
-    // but has no `.get()`. Awaiting works on both dialects.
-    const rows = await opts.db
-      .select()
-      .from(src)
-      .where(discCond ? and(idCond, discCond) : idCond)
-      .limit(1);
-    const row = (rows as unknown[])[0];
-    return row ?? reply.code(404).send({ error: "not_found" });
+    const row = await firstRow(opts.db, src, discCond ? and(idCond, discCond) : idCond);
+    return row ? toWire(row) : reply.code(404).send({ error: "not_found" });
   });
 }
 
 export function mountCreateRoute(opts: VerbOptions): void {
+  const toWire = echoWire(opts);
   opts.fastify.post(opts.path, routeOpts(opts), async (req, reply) => {
     const parsed = opts.insertSchema.safeParse(req.body);
     if (!parsed.success) {
@@ -265,11 +280,12 @@ export function mountCreateRoute(opts: VerbOptions): void {
     const row = (result as unknown[])[0];
     // #214 — read-your-writes: re-read through the replica view so the response
     // carries derived (origin.passthrough) columns the base table excludes.
-    return reply.code(201).send(await reReadThroughView(opts, row));
+    return reply.code(201).send(toWire(await reReadThroughView(opts, row)));
   });
 }
 
 export function mountUpdateRoute(opts: VerbOptions): void {
+  const toWire = echoWire(opts);
   const handler = async (
     req: { params: unknown; body: unknown },
     reply: { code: (n: number) => { send: (b: unknown) => unknown } },
@@ -304,13 +320,8 @@ export function mountUpdateRoute(opts: VerbOptions): void {
         return reply.code(400).send({ error: "invalid_id" });
       }
       const noopCond = eq(src.id, noopId);
-      const rows = await opts.db
-        .select()
-        .from(src)
-        .where(discCond ? and(noopCond, discCond) : noopCond)
-        .limit(1);
-      const row = (rows as unknown[])[0];
-      return row ?? reply.code(404).send({ error: "not_found" });
+      const row = await firstRow(opts.db, src, discCond ? and(noopCond, discCond) : noopCond);
+      return row ? toWire(row) : reply.code(404).send({ error: "not_found" });
     }
     // Compare against the PK's real type (see mountGetRoute) — a numeric-
     // LOOKING id on a TEXT pk would otherwise UPDATE the wrong row.
@@ -334,7 +345,7 @@ export function mountUpdateRoute(opts: VerbOptions): void {
     const row = (result as unknown[])[0];
     if (row == null) return reply.code(404).send({ error: "not_found" });
     // #214 — re-read through the replica view so the response carries derived columns.
-    return await reReadThroughView(opts, row);
+    return toWire(await reReadThroughView(opts, row));
   };
   const path = `${opts.path}/:id`;
   const ro = routeOpts(opts);
 
@@ -33,6 +33,7 @@
 import type { FastifyInstance, RouteShorthandOptions } from "fastify";
 import { and, eq, or, inArray } from "drizzle-orm";
 import { coerceIdForColumn } from "./util.js";
+import { timestampWire } from "../timestamp-wire.js";
 
 // Loose Drizzle types — the helper works across libsql / better-sqlite3 / pg.
 // biome-ignore lint/suspicious/noExplicitAny: dynamic dispatch over user's Drizzle instance
@@ -84,6 +85,7 @@ export function mountM2mRoute(opts: M2mRouteOptions): void {
   const targetPk = opts.targetPkColumn ?? "id";
   const route = `${opts.path}/:id/${opts.relationName}`;
   const ro = opts.routeOptions ?? {};
+  const toWire = timestampWire(opts.targetTable);
 
   opts.fastify.get(route, ro, async (req, reply) => {
     const { id } = req.params as { id: string };
@@ -148,10 +150,11 @@ export function mountM2mRoute(opts: M2mRouteOptions): void {
     const pkCol = columnRef(opts.targetTable, targetPk);
     const byPk = inArray(pkCol, [...relatedIds]);
     const disc = opts.targetDiscriminator;
-    return await opts.db
+    const rows = await opts.db
       .select()
       .from(opts.targetTable)
       .where(disc ? and(byPk, eq(columnRef(opts.targetTable, disc.column), disc.value)) : byPk);
+    return (rows as unknown[]).map(toWire);
   });
 }
 
 
@@ -3,19 +3,12 @@ import { sql, eq, and, count } from "drizzle-orm";
 import qs from "qs";
 import { parseFilterParams, FilterParseError } from "./filter-parser.js";
 import type { FilterAllowlist, SortAllowlist } from "./filter-allowlist.js";
-import { isTruthyFlag, contractErrorCode, coerceIdForColumn, rawIdLiteral } from "./util.js";
+import { isTruthyFlag, contractErrorCode, coerceIdForColumn, rawIdLiteral, viewBaseConfig } from "./util.js";
+import { timestampWire } from "../timestamp-wire.js";
 
 // biome-ignore lint/suspicious/noExplicitAny: dynamic dispatch over user-supplied views
 type AnyView = any;
 
-/**
- * Drizzle v0.45 stores view config under this well-known Symbol.
- * Accessing `view._` on a proxy-wrapped view (empty-column .existing()) throws
- * because the proxy tries to spread `subquery._.selectedFields` which is undefined.
- * Using the symbol bypasses the proxy entirely.
- */
-const VIEW_BASE_CONFIG = Symbol.for("drizzle:ViewBaseConfig");
-
 export interface MountReadOnlyOptions {
   readonly fastify: FastifyInstance;
   readonly path: string;
@@ -49,18 +42,8 @@ const REJECT_MUTATION = async (
     .send({ error: "method_not_allowed", message: `${request.method} is not supported on a projection (read-only).` });
 };
 
-function getViewConfig(view: AnyView): Record<string, unknown> | undefined {
-  try {
-    const cfg = (view as Record<symbol, unknown>)[VIEW_BASE_CONFIG];
-    if (cfg && typeof cfg === "object") return cfg as Record<string, unknown>;
-  } catch {
-    // ignore — proxy handler may throw on unexpected shapes
-  }
-  return undefined;
-}
-
 function resolveViewName(view: AnyView): string | undefined {
-  const cfg = getViewConfig(view);
+  const cfg = viewBaseConfig(view);
   if (cfg) {
     if (typeof cfg["name"] === "string") return cfg["name"] as string;
   }
@@ -78,7 +61,7 @@ function resolveViewName(view: AnyView): string | undefined {
  * `SELECT  FROM ...` (invalid SQL), and we must fall back to raw SQL.
  */
 function isEmptyColumnView(view: AnyView): boolean {
-  const cfg = getViewConfig(view);
+  const cfg = viewBaseConfig(view);
   if (cfg) {
     const fields = cfg["selectedFields"] as Record<string, unknown> | undefined;
     return fields !== undefined && Object.keys(fields).length === 0;
@@ -139,6 +122,8 @@ export function mountReadOnlyCrudRoutes(opts: MountReadOnlyOptions): void {
 
   const viewName = resolveViewName(view);
   const useRawSql = isEmptyColumnView(view) && !!viewName;
+  // The raw-SQL branch has no declared columns, so nothing names a timestamp there.
+  const toWire = timestampWire(view);
 
   // ── List ──────────────────────────────────────────────────────────────────
   fastify.get(path, ro, async (req, reply) => {
@@ -189,7 +174,7 @@ export function mountReadOnlyCrudRoutes(opts: MountReadOnlyOptions): void {
       // node-postgres builder is thenable. (The useRawSql branch above keeps
       // db.all(sql.raw(...)) because that is the libsql raw-exec API, only
       // reachable for `.existing()` empty-column views which are sqlite-only.)
-      const rows = await q;
+      const rows = (await q as unknown[]).map(toWire);
 
       if (!withCount) return rows;
 
@@ -231,7 +216,7 @@ export function mountReadOnlyCrudRoutes(opts: MountReadOnlyOptions): void {
       colRef !== undefined ? eq(colRef, idValue) : undefined
     ).limit(1);
     const row = (rows as unknown[])[0];
-    return row ?? reply.code(404).send({ error: "not_found" });
+    return row ? toWire(row) : reply.code(404).send({ error: "not_found" });
   });
 
   // ── Mutations explicitly rejected (405) ───────────────────────────────────
 
@@ -81,3 +81,36 @@ export function contractErrorCode(internal: string): string {
       return internal;
   }
 }
+
+/**
+ * Drizzle v0.45 stores view config under this well-known Symbol. Accessing
+ * `view._` on a proxy-wrapped view (empty-column `.existing()`) throws because
+ * the proxy tries to spread `subquery._.selectedFields` which is undefined; the
+ * symbol read bypasses the proxy. The proxy handler can still throw on
+ * unexpected shapes, so the read is guarded. One reader for the private shape —
+ * the two read-only mounts and the timestamp-wire column lookup share it.
+ */
+const VIEW_BASE_CONFIG = Symbol.for("drizzle:ViewBaseConfig");
+
+export function viewBaseConfig(view: unknown): Record<string, unknown> | undefined {
+  try {
+    const cfg = (view as Record<symbol, unknown>)[VIEW_BASE_CONFIG];
+    if (cfg && typeof cfg === "object") return cfg as Record<string, unknown>;
+  } catch {
+    // ignore — proxy handler may throw on unexpected shapes
+  }
+  return undefined;
+}
+
+/**
+ * The portable one-row read: `.limit(1)` + await + first element. Awaiting is
+ * what makes this work on both dialects — the node-postgres query builder is
+ * thenable but has no `.get()` (that is a libsql/better-sqlite3-only API, #286).
+ * The caller builds the WHERE (including any TPH discriminator), so the
+ * condition stays with the mount that owns it.
+ */
+export async function firstRow(db: unknown, src: unknown, cond: unknown): Promise<unknown> {
+  // biome-ignore lint/suspicious/noExplicitAny: dynamic dispatch over the user's Drizzle client
+  const rows: unknown = await (db as any).select().from(src).where(cond).limit(1);
+  return (rows as unknown[])[0];
+}