@@ -80,6 +80,11 @@ const mutators: Record<string, (tx: Tx, args: Args) => Promise<void>> = {
     await put(tx, args);
     throw new TypeError(String(args.message ?? 'bad type'));
   },
+  // A `details` property only when the args have one, which may be null.
+  'item.detailsError': async (tx, args) => {
+    await put(tx, args);
+    throw Object.assign(new TypeError('with details'), 'details' in args ? {details: args.details} : {});
+  },
   'crud.insert': (tx, args) => tx.mutate[args.table!].insert(args.row),
   'crud.upsert': (tx, args) => tx.mutate[args.table!].upsert(args.row),
   'crud.update': (tx, args) => tx.mutate[args.table!].update(args.row),
@@ -147,6 +152,24 @@ export function mutate({
   return handleMutateRequest({dbProvider: provider(url), handler, query, body: body as never, userID, logLevel: 'error'});
 }
 
+/** handleMutateRequest over a raw request, its body given as base64, answered as the text a server would send. */
+export async function mutateRequest({
+  url,
+  search,
+  body,
+  userID,
+}: {
+  url: string;
+  search: string;
+  body: string;
+  userID: string | null;
+}) {
+  const request = new Request(`http://localhost/mutate?${search}`, {method: 'POST', body: Buffer.from(body, 'base64')});
+  return JSON.stringify(
+    await handleMutateRequest({dbProvider: provider(url), handler, request, userID, logLevel: 'error'}),
+  );
+}
+
 export type {TransactionProviderHooks};
 
 // PushProcessor dispatches by name to a registry from defineMutators, or to plain legacy functions.
 
@@ -9,8 +9,8 @@ import {
   transformRequestMessageSchema,
   v,
 } from './zero.ts';
-import {mutate, mutateWithSchema, pushProcessor, wireSchema} from './mutate.ts';
-import {query, runQuery, schemaJSON} from './query.ts';
+import {mutate, mutateRequest, mutateWithSchema, pushProcessor, wireSchema} from './mutate.ts';
+import {query, queryRequest, runQuery, schemaJSON} from './query.ts';
 
 // The schemas upstream parses requests with, and the mode it parses each in.
 const schemas = {
@@ -23,9 +23,11 @@ const schemas = {
 
 export const ops = {
   mutate,
+  mutateRequest,
   pushProcessor,
   mutateWithSchema,
   query,
+  queryRequest,
   runQuery,
   schema: schemaJSON,
   wireSchema: () => JSON.parse(JSON.stringify(wireSchema)),
@@ -36,6 +38,11 @@ export const ops = {
     return v.test(value, type as v.Type<unknown>, mode).ok;
   },
 
+  /** `JSON.stringify(value)`. */
+  jsonStringify({value}: {value: unknown}) {
+    return JSON.stringify(value);
+  },
+
   /** `String(value)`, for a JSON scalar or array. */
   jsString({value}: {value: unknown}) {
     return String(value);
 
@@ -1,7 +1,7 @@
 // The query half of the wire tier: the published handleQueryRequest over queries that interpret a
 // builder program, which tests/wire/programs.py interprets the same way in Python.
 import {createBuilder, defineQueries, defineQuery, mustGetQuery} from '@rocicorp/zero';
-import {handleQueryRequest} from '@rocicorp/zero/server';
+import {ApplicationError, handleQueryRequest} from '@rocicorp/zero/server';
 import {zeroPostgresJS} from '@rocicorp/zero/server/adapters/postgresjs';
 import postgres from 'postgres';
 import {QueryParseError} from './node_modules/@rocicorp/zero/out/zql/src/query/error.js';
@@ -106,17 +106,46 @@ const queries = defineQueries({
   appError: defineQuery(() => {
     throw new Error('nope');
   }),
+  appDetails: defineQuery((({args}: {args: unknown}) => {
+    throw new ApplicationError('app', {details: args as never});
+  }) as never),
+  returns: defineQuery((({args}: {args: string}) => RETURNS[args]) as never),
 });
 
+/** What a query function may return in place of a query, by name. */
+const RETURNS: Record<string, unknown> = {number: 5, fraction: 1.5, string: 'x', boolean: true, object: {}, array: []};
+
+/**
+ * Queries by name through the registry, except `raw`, which returns `RETURNS[args]` itself, and `gate.wait`,
+ * which finishes only once `gate.open` has run in the same request.
+ */
+function makeHandler() {
+  let open!: () => void;
+  const gate = new Promise<void>(resolve => (open = resolve));
+  return async (name: string, args: unknown) => {
+    if (name === 'raw') return RETURNS[args as string] as never;
+    if (name === 'gate.wait') {
+      await gate;
+      return zql.issue;
+    }
+    if (name === 'gate.open') {
+      open();
+      return zql.user;
+    }
+    return mustGetQuery(queries, name).fn({args, ctx: undefined} as never);
+  };
+}
+
 export function query({body, userID}: {body: unknown; userID: string | null}) {
-  return handleQueryRequest({
-    handler: (name, args) => mustGetQuery(queries, name).fn({args, ctx: undefined} as never),
-    schema,
-    body: body as never,
-    query: {},
-    userID,
-    logLevel: 'error',
-  });
+  const handler = makeHandler();
+  return handleQueryRequest({handler, schema, body: body as never, query: {}, userID, logLevel: 'error'});
+}
+
+/** handleQueryRequest over a raw request body, given as base64, answered as the text a server would send. */
+export async function queryRequest({body, userID}: {body: string; userID: string | null}) {
+  const request = new Request('http://localhost/query', {method: 'POST', body: Buffer.from(body, 'base64')});
+  const handler = makeHandler();
+  return JSON.stringify(await handleQueryRequest({handler, schema, request, userID, logLevel: 'error'}));
 }
 
 export function schemaJSON() {
 
@@ -21,6 +21,7 @@
 from zero_server.schema import Schema
 from zero_server.server.process_mutations import Database, TransactFn, handle_mutate_request
 from zero_server.server.process_queries import handle_query_request
+from zero_server.shared.js import js_stringify
 from zero_server.shared.json import JSONValue
 from zero_server.shared.registry import Registry
 
@@ -30,6 +31,13 @@
 """The `ctx` queries and mutators receive. May be async."""
 
 
+class _JSONResponse(JSONResponse):
+    """The bytes a TypeScript server sends: `JSON.stringify`'s text, which escapes any lone surrogate."""
+
+    def render(self, content: Any) -> bytes:
+        return js_stringify(content).encode()
+
+
 class Unauthorized(Exception):
     """Raised by `authenticate` for a token it rejects. The endpoint answers 401 instead of running."""
 
@@ -64,7 +72,7 @@ async def caller(request: Request) -> tuple[str | None, Any] | Response:
         try:
             user_id = await _maybe_await(authenticate(request))
         except Unauthorized as error:
-            return JSONResponse({"error": str(error) or "Unauthorized"}, status_code=401)
+            return _JSONResponse({"error": str(error) or "Unauthorized"}, status_code=401)
         return user_id, await _maybe_await(context(request, user_id))
 
     if queries is not None:
@@ -80,7 +88,7 @@ async def query(request: Request) -> Response:
                 body=await request.body(),
                 user_id=user_id,
             )
-            return JSONResponse(response.to_json())
+            return _JSONResponse(response.to_json())
 
         routes.append(Route(query_path, query, methods=["POST"]))
 
@@ -108,7 +116,7 @@ async def run(tx: Any, name: str, args: JSONValue | None) -> None:
                 body=await request.body(),
                 user_id=user_id,
             )
-            return JSONResponse(response.to_json())
+            return _JSONResponse(response.to_json())
 
         routes.append(Route(mutate_path, mutate, methods=["POST"]))
 
 
@@ -11,13 +11,13 @@
 
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass
-from typing import Annotated, Literal, Protocol
+from typing import Annotated, Any, Literal, Protocol
 
 from pydantic import Field, StrictBool, StrictStr
 
 from zero_server.protocol.wire import Number, StrictWireModel, WireChecked
 from zero_server.shared.asserts import AssertionFailedError, check
-from zero_server.shared.js import js_sort, js_string
+from zero_server.shared.js import js_keys, js_sort, js_string
 from zero_server.shared.json import JSONValue
 
 SUBQ_PREFIX = "zsubq_"
@@ -73,9 +73,19 @@ class Parameter(StrictWireModel):
 
 class SimpleCondition(StrictWireModel):
     type: Literal["simple"] = "simple"
-    op: WireChecked[SimpleOperator]
     left: ValuePosition
     right: Annotated[Parameter | LiteralReference, Field(discriminator="type")]
+    op: WireChecked[SimpleOperator]
+
+    def negated(self, op: str) -> SimpleCondition:
+        return _NegatedSimpleCondition(op=op, left=self.left, right=self.right)  # ty: ignore[invalid-argument-type]
+
+
+class _NegatedSimpleCondition(SimpleCondition):
+    """Upstream's `not` writes the negated condition with `op` second."""
+
+    def _ordered(self, dumped: dict[str, Any]) -> dict[str, Any]:
+        return {"type": dumped["type"], "op": dumped["op"], "left": dumped["left"], "right": dumped["right"]}
 
 
 class Conjunction(StrictWireModel):
@@ -95,6 +105,12 @@ class CorrelatedSubqueryCondition(StrictWireModel):
     flip: WireChecked[StrictBool | None] = None
     scalar: WireChecked[StrictBool | None] = None
 
+    def _ordered(self, dumped: dict[str, Any]) -> dict[str, Any]:
+        # The builder writes a condition's subquery `system` first, where `related` on the AST has it last.
+        related = dumped["related"]
+        keys = [k for k in ("system", "correlation", "hidden", "subquery") if k in related]
+        return {**dumped, "related": {k: related[k] for k in keys}}
+
 
 type Condition = Annotated[
     SimpleCondition | Conjunction | Disjunction | CorrelatedSubqueryCondition, Field(discriminator="type")
@@ -108,10 +124,10 @@ class Correlation(StrictWireModel):
 
 class CorrelatedSubquery(StrictWireModel):
     correlation: Correlation
-    subquery: AST
-    system: System | None = None
     # A hop the client never sees, such as the junction table of a many-to-many relationship.
     hidden: StrictBool | None = None
+    subquery: AST
+    system: System | None = None
 
 
 class Bound(StrictWireModel):
@@ -126,9 +142,9 @@ class AST(StrictWireModel):
     alias: StrictStr | None = None
     where: Condition | None = None
     related: tuple[CorrelatedSubquery, ...] | None = None
+    start: Bound | None = None
     limit: Number | None = None
     order_by: Ordering | None = Field(default=None, alias="orderBy")
-    start: Bound | None = None
 
 
 for _model in (Conjunction, Disjunction, CorrelatedSubqueryCondition, CorrelatedSubquery, AST):
@@ -201,10 +217,10 @@ def col(column: str) -> str:
 
 
 def _entries(row: Row) -> list[tuple[str, Value]]:
-    """`Object.entries(row)`. The builder takes any row, and an array's keys are its indexes."""
+    """`Object.entries(row)`, index-like keys first. The builder takes any row, and an array's keys are its indexes."""
     if isinstance(row, list):
         return [(str(i), value) for i, value in enumerate(row)]
-    return list(row.items())
+    return [(key, row[key]) for key in js_keys(row)]
 
 
 def _transform_where(where: Condition, table: str, transform: _Transform) -> Condition:
 
@@ -6,7 +6,7 @@
 """
 
 from enum import StrEnum
-from typing import Literal
+from typing import Any, Literal
 
 from pydantic import Field, StrictStr
 
@@ -65,17 +65,27 @@ class ErrorReason(StrEnum):
 
 
 class _PushFailedBase(WireModel):
+    """Fields in the order upstream writes them; each subclass narrows `origin` and `reason` in place."""
+
     kind: Literal[ErrorKind.PUSH_FAILED] = ErrorKind.PUSH_FAILED
-    details: JSONValue | None = None
+    origin: ErrorOrigin
+    reason: ErrorReason
+    message: StrictStr
     # The mutations that went unprocessed, which can be a tail of the request's.
     mutation_ids: list[MutationID] = Field(alias="mutationIDs")
-    message: StrictStr
+    details: JSONValue | None = None
 
 
 class ServerPushFailed(_PushFailedBase):
     origin: Literal[ErrorOrigin.SERVER] = ErrorOrigin.SERVER
     reason: ServerPushFailedReason
 
+    def _ordered(self, dumped: dict[str, Any]) -> dict[str, Any]:
+        if self.reason == ErrorReason.UNSUPPORTED_PUSH_VERSION:
+            # Upstream writes this one failure with `message` last.
+            dumped["message"] = dumped.pop("message")
+        return dumped
+
 
 class ZeroCachePushHTTPFailed(_PushFailedBase):
     origin: Literal[ErrorOrigin.ZERO_CACHE]
@@ -93,10 +103,14 @@ class ZeroCachePushFailed(_PushFailedBase):
 
 
 class _TransformFailedBase(WireModel):
+    """Fields in the order upstream writes them; each subclass narrows `origin` and `reason` in place."""
+
     kind: Literal[ErrorKind.TRANSFORM_FAILED] = ErrorKind.TRANSFORM_FAILED
-    details: JSONValue | None = None
-    query_ids: list[StrictStr] = Field(alias="queryIDs")
+    origin: ErrorOrigin
+    reason: ErrorReason
     message: StrictStr
+    query_ids: list[StrictStr] = Field(alias="queryIDs")
+    details: JSONValue | None = None
 
 
 class ServerTransformFailed(_TransformFailedBase):
 
@@ -20,14 +20,13 @@ class MutateSuccess(WireModel):
     nullable = frozenset({"user_id"})
 
     kind: Literal["MutateResponse"] = "MutateResponse"
-    user_id: StrictStr | None = Field(default=None, alias="userID")
     mutations: list[MutationResponse]
+    user_id: StrictStr | None = Field(default=None, alias="userID")
 
     def to_json(self) -> dict[str, JSONValue]:
-        out: dict[str, JSONValue] = {"kind": self.kind}
+        out: dict[str, JSONValue] = {"kind": self.kind, "mutations": [m.to_json() for m in self.mutations]}
         if self.user_id is not None or "user_id" in self.model_fields_set:
             out["userID"] = self.user_id
-        out["mutations"] = [m.to_json() for m in self.mutations]
         return out
 
 
 
@@ -4,7 +4,7 @@
 zero/v1.10.0 (905d08516ba0caaf314cd28e93a5a47e8acdd482). Apache-2.0, Copyright Rocicorp.
 """
 
-from typing import Annotated, Literal
+from typing import Annotated, Any, Literal
 
 from pydantic import Field, StrictBool, StrictStr
 
@@ -130,4 +130,11 @@ class MutationResponse(WireModel):
     result: MutationResult
 
     def to_json(self) -> dict[str, JSONValue]:
-        return {"id": self.id.to_json(), "result": self.result.to_json()}
+        # Upstream writes a response's ID `clientID` first, unlike the IDs a failed push lists.
+        mutation_id = self.id.to_json()
+        return {"id": {"clientID": mutation_id["clientID"], "id": mutation_id["id"]}, "result": self.result.to_json()}
+
+    def _ordered(self, dumped: dict[str, Any]) -> dict[str, Any]:
+        # Upstream writes a response's ID `clientID` first, unlike the IDs a failed push lists.
+        mutation_id = dumped["id"]
+        return {**dumped, "id": {"clientID": mutation_id["clientID"], "id": mutation_id["id"]}}
@@ -22,8 +22,8 @@ class QuerySuccess(WireModel):
     nullable = frozenset({"user_id"})
 
     kind: Literal["QueryResponse"] = "QueryResponse"
-    user_id: StrictStr | None = Field(default=None, alias="userID")
     queries: TransformResponseBody
+    user_id: StrictStr | None = Field(default=None, alias="userID")
 
 
 type QueryResponse = QuerySuccess | TransformFailedBody