@genesislcap/mock-server 15.57.0 → 15.58.0

package/README.md

@@ -347,9 +347,9 @@ and a `"<code> <reason>"` `STATUS_CODE`, and the envelope carries `WARNING`:
 `new NackError([...])` reports several errors at once. Anything else a handler
 throws is `StandardError INTERNAL_ERROR` with its message. A handler can
 return `{ warnings: [...] }` for a NACK with an empty `ERROR` and those
-warnings, or pass `{ warnings }` to `NackError`; `IGNORE_WARNINGS` is not
-modelled yet. `VALIDATE: true` reaches a handler as `ctx.validate` (see
-[Generic CRUD events](#generic-crud-events-tabledefevents)). A request server
+warnings, which `IGNORE_WARNINGS: true` turns into a commit, or pass
+`{ warnings }` to `NackError` to send them with its errors (see
+[Commit semantics](#commit-semantics-validate-warnings-and-ignore_warnings)). A request server
 that fails answers a service `MSG_NACK` carrying the same items:
 `{WARNING, ERROR, MESSAGE_TYPE: 'MSG_NACK'}` (genesis-messages `MsgNack`). The
 router's `MSG_NACK` keeps its own shape (no `@type`,
@@ -399,12 +399,14 @@ key fields names the primary key, else it is `<TABLE>_BY_<fields>` without the
 the table and on views over it.
 
 **`VALIDATE: true`** reaches every handler as `ctx.validate`, and nothing is
-written. The generic events have no `onValidate`, so they ack `GENERATED: []`
-straight away (recorded for `COUNTERPARTY_INSERT`): no duplicate check, no
+written (except under `fidelity: 'legacy'`). The generic events have no
+`onValidate`, so they ack `GENERATED: []` straight away (recorded for
+`COUNTERPARTY_INSERT`): no duplicate check, no
 sequence value used, no lookup for a modify or delete. A hand-written handler
 should run its checks and return before writing when `ctx.validate` is set
-(recorded: `TRADE_INSERT`'s `onValidate` NACK still comes back).
-`IGNORE_WARNINGS` is not modelled.
+(recorded: `TRADE_INSERT`'s `onValidate` NACK still comes back); the engine
+rolls back anything it writes anyway (see
+[Commit semantics](#commit-semantics-validate-warnings-and-ignore_warnings)).
 
 **An `eventHandlers` entry of the same name wins**, so a table can list all
 three verbs and still write out the one with business rules.
@@ -446,6 +448,56 @@ field's errors in field order, then missing fields, then unknown ones.
 on the recorded schemas. A modify therefore needs every required field, as on
 the real server. `fidelity: 'legacy'` checks nothing.
 
+## Commit semantics: `VALIDATE`, warnings and `IGNORE_WARNINGS`
+
+A handler stands for a GSF event handler's `onValidate` and `onCommit` at
+once. The engine gives its outcome the semantics of GSF's
+`TransactionalEventHandlerContainer` (genesis-pal-eventhandler, v8.15.29; the
+typed `SyncValidatingEventHandler` is the same): `VALIDATE` runs `onValidate`
+only; otherwise `onCommit` runs when `onValidate` acks, or when it NACKs with
+warnings only (`error.isEmpty()`) and the message has `IGNORE_WARNINGS: true`;
+any other NACK is the reply. So each handler runs in a transaction, and the
+event commits only when it acks:
+
+| The handler… | Without `IGNORE_WARNINGS` | With `IGNORE_WARNINGS: true` | Under `VALIDATE: true` |
+|---|---|---|---|
+| Returns `{ generated? }` | `EVENT_ACK`, committed | The same | `EVENT_ACK {GENERATED: []}`, rolled back |
+| Returns `{ warnings, generated? }` | `EVENT_NACK {ERROR: [], WARNING}`, rolled back | `EVENT_ACK {GENERATED}` (no `WARNING`), committed | `EVENT_NACK {ERROR: [], WARNING}`, rolled back |
+| Throws `NackError` (errors, warnings or both), or anything else | `EVENT_NACK`, rolled back | The same | The same |
+
+*Rolled back* means every row the handler inserted, changed or deleted is
+put back, and the live pushes it asked for through `ctx.broadcast` /
+`ctx.broadcastTableChange` are dropped. They go out only once the event has
+committed, right after its `EVENT_ACK`, the order the real server's
+recordings show: a client can't count on its grid holding the change when
+the ACK arrives. A push that fails then is logged, and the event stays
+committed. Sequence and auto-increment values a rolled-back insert used stay
+used, as a database sequence's do. A `VALIDATE` ack has `GENERATED: []`, as
+the recorded ones do.
+
+So a handler writes, then returns its warnings, and lets the engine decide.
+A handler that returns its warnings *before* writing, as this README advised
+before `IGNORE_WARNINGS` was modelled, now acks an ignored warning without
+having written anything. `ctx.ignoreWarnings` is the message's flag (also
+under `VALIDATE`, where warnings still NACK): read it to skip work, or before
+throwing `NackError.warning(...)`, which always NACKs (the handler stopped
+there, before its writes; GSF exceptions are always errors). Keep
+`ctx.broadcastTableChange` for later (a timer, as the showcase's price ticker
+does) and it pushes straight away once the event is over. The transaction
+covers the store and the `ctx` broadcast functions only, not the server's
+own `broadcast` / `broadcastTableChange` or side effects like timers. It
+saves a table on the event's first write to it, a copy of its rows: cheap for
+a mock's tables, noticeable only with very large ones and many events.
+
+Where this differs from GSF: a GSF handler without `transactional = true`
+keeps whatever its `onCommit` wrote before failing, and a transactional one
+commits writes made before it *returns* `nack(...)`; here every NACK rolls
+back. `IGNORE_WARNINGS` was not recorded (the showcase has no handler that
+warns): `test/commitSemantics.test.ts` follows the Kotlin.
+`fidelity: 'legacy'` keeps the old behaviour: no transaction (a handler's
+writes stay whatever it replies), warnings always NACK (in `ERROR`), and
+`ctx.ignoreWarnings` is always `false`.
+
 ## Running several servers in parallel (and one-command dev stacks)
 
 Every `createMockServer()` instance is fully isolated — its own store,
@@ -668,6 +720,7 @@ createMockServer({ ...config, fidelity: 'legacy' });
 | `META_REQUEST` content | The GSF shapes below; event META too | `{NAME, TYPE}` fields, `KEY: []` on dataservers, `REPLY_FIELD` alone on request servers; events are unknown |
 | `JSON_SCHEMA_REQUEST` content | Per resource type, as below | One minimal `{DETAILS: {properties: {F: {type}}, required}}` as both INBOUND and OUTBOUND; a query or request-server name resolves to its source table |
 | Declared schemas (`TableDef.fields`, query and view `fields`, `derivedTypes`) | Used for metadata and rows | Ignored: metadata is inferred, rows go out as stored |
+| Commit events | Committed only on `EVENT_ACK`; `IGNORE_WARNINGS` lets returned warnings commit ([Commit semantics](#commit-semantics-validate-warnings-and-ignore_warnings)) | A handler's writes stay whatever it replies; warnings always NACK |
 | A change to a table a view joins | Pushed only through joins with `backwardsJoin: true`, as the view rows it inserts, deletes or changes ([Views](#views-the-join-model)) | Every view row pushed as a MODIFY, whatever the join |
 | `DATA_LOGON` `ORDER_BY` / `REVERSE` / `FIELDS`, criteria on unexposed fields | Honoured / `LOGON_NACK` | Ignored |
 | `REQ_` | As in [Request servers](#request-servers-req_): `PARAMETRIC_TYPE`, criteria-only paging and ordering, `REQUEST` wildcards, ranges and arrays, a reply block, `MSG_NACK` failures | Every matching row in insertion order; `REQUEST` from the top level or `DETAILS`, `'*'`/`null`/`''` match anything, an array value any of its values; `CRITERIA_MATCH` fails open; no `RECORD_ID`/`TIMESTAMP`; errors as a `REP_` with `ERROR` |
@@ -1151,7 +1204,8 @@ plus end-to-end WS/HTTP tests (auth gating, filtered-subscription DELETE
 delivery, keyed `REQ_*` lookups, session reuse, clean shutdown — and, in
 `test/dataserver.test.ts`, the GSF envelopes, paging and the `'legacy'`
 fidelity mode; `test/requestReply.test.ts` covers both kinds of request server,
-`test/views.test.ts` the view join model and its live pushes)
+`test/views.test.ts` the view join model and its live pushes,
+`test/commitSemantics.test.ts` when an event commits)
 via `node --test`, no build step. Only `test/**/*.test.ts`
 files are run, so shared helpers (`test/support.ts`) can sit beside them.
 

package/dist/db/store.d.ts

@@ -14,7 +14,13 @@ export declare class Store {
     private seedRows;
     private removedRows;
     private previousRows;
+    private savepoint;
     readonly views: Map<string, ViewDef>;
+    begin(): void;
+    commit(): void;
+    rollback(): void;
+    get inTransaction(): boolean;
+    private save;
     registerTable(tableName: string, definition: TableDef): this;
     private counterOf;
     private countersFor;

package/dist/db/store.js

@@ -67,6 +67,12 @@ function counterKey(prefix, format) {
 }
 // An AUTO_INCREMENT counter belongs to its table's field.
 const autoIncrementKey = (tableName, field) => `${tableName}\u0000${field}`;
+function restoreEntry(maps, tableName, saved) {
+    if (saved === undefined)
+        maps.delete(tableName);
+    else
+        maps.set(tableName, saved);
+}
 export class Store {
     tables = new Map();
     tableConfig = new Map();
@@ -87,7 +93,56 @@ export class Store {
     // it, as it was before the first such modify (by RECORD_ID) — see
     // takePreviousRecord. Bounded like removedRows.
     previousRows = new Map();
+    // While a transaction is open (see begin), each table it has written to,
+    // as it was before.
+    savepoint;
     views = new Map();
+    // Opens a transaction: the commit-event path wraps every handler in one
+    // (handlers/commitEvent.ts), so an event that NACKs leaves the tables as
+    // they were, as a GSF event whose onValidate NACKs never reaches its
+    // onCommit. Writes go through as usual; the first write to a table saves
+    // it, and rollback() puts back every table the transaction wrote to.
+    // Sequence and auto-increment counters and the RECORD_ID clock are not put
+    // back: a value used stays used, as a database sequence's does. Not nested,
+    // and the engine's own: an event that finds one open answers INTERNAL_ERROR.
+    // Saving copies the table's row map, O(rows) per event and table written.
+    begin() {
+        if (this.savepoint)
+            throw new Error('A store transaction is already open');
+        this.savepoint = new Map();
+    }
+    // Keeps every write since begin().
+    commit() {
+        this.savepoint = undefined;
+    }
+    // Undoes every write since begin().
+    rollback() {
+        const savepoint = this.savepoint;
+        this.savepoint = undefined;
+        for (const [tableName, saved] of savepoint ?? []) {
+            this.tables.set(tableName, saved.rows);
+            restoreEntry(this.removedRows, tableName, saved.removed);
+            restoreEntry(this.previousRows, tableName, saved.previous);
+        }
+    }
+    get inTransaction() {
+        return this.savepoint !== undefined;
+    }
+    // Saves a table before the open transaction's first change to it.
+    save(tableName) {
+        if (!this.savepoint || this.savepoint.has(tableName))
+            return;
+        const rows = this.tables.get(tableName);
+        if (!rows)
+            return;
+        const removed = this.removedRows.get(tableName);
+        const previous = this.previousRows.get(tableName);
+        this.savepoint.set(tableName, {
+            rows: new Map(rows),
+            removed: removed && new Map(removed),
+            previous: previous && new Map(previous),
+        });
+    }
     registerTable(tableName, definition) {
         const { pkField, sequencePrefix, sequenceWidth = 3, sequenceFormat = 'prefix', rows = [], } = definition;
         const pkFields = normalizePkFields(pkField);
@@ -113,6 +168,8 @@ export class Store {
         }
         this.tables.set(tableName, table);
         this.tableConfig.set(tableName, config);
+        // Registering a table again replaces it whole: a rollback leaves it be.
+        this.savepoint?.delete(tableName);
         this.removedRows.delete(tableName);
         this.previousRows.delete(tableName);
         this.seedRows.set(tableName, rows.map((row) => ({ ...row })));
@@ -326,6 +383,7 @@ export class Store {
         const config = this.tableConfig.get(tableName);
         if (!table || !config)
             throw new Error(`Unknown table: ${tableName}`);
+        this.save(tableName);
         const row = { ...record };
         this.generateValues(tableName, config, row);
         const missing = config.pkFields.filter((field) => row[field] === undefined);
@@ -348,6 +406,7 @@ export class Store {
         const config = this.tableConfig.get(tableName);
         if (!table || !config || !table.has(pk))
             return undefined;
+        this.save(tableName);
         const existing = table.get(pk);
         this.notePrevious(tableName, existing);
         const updated = { ...existing, ...patch };
@@ -373,6 +432,7 @@ export class Store {
         const existing = table?.get(pk);
         if (!table || !existing)
             return false;
+        this.save(tableName);
         table.delete(pk);
         this.noteRemoved(tableName, pk, existing);
         return true;
@@ -383,6 +443,7 @@ export class Store {
     // doesn't), including the old record when a key's row was replaced before
     // one broadcast.
     takeRemovedRows(tableName, key) {
+        this.save(tableName);
         const removed = this.removedRows.get(tableName);
         const records = removed?.get(key) ?? [];
         removed?.delete(key);
@@ -396,6 +457,7 @@ export class Store {
         const previous = this.previousRows.get(tableName);
         if (id === undefined || !previous)
             return undefined;
+        this.save(tableName);
         const record = previous.get(id);
         previous.delete(id);
         return record;

package/dist/handlers/commitEvent.js

@@ -12,12 +12,70 @@ function resolveEventHandler(eventName, config) {
         crudEventHandler(eventName, config) ??
         config.defaultEventHandler);
 }
+function openTransaction(store, ctx) {
+    const pending = [];
+    let open = true;
+    store.begin();
+    const hold = (push) => {
+        if (open)
+            pending.push(push);
+        else
+            push();
+    };
+    return {
+        broadcast: (resourceName, operation, row) => hold(() => ctx.broadcast(resourceName, operation, row)),
+        broadcastTableChange: (tableName, operation, pk) => hold(() => ctx.broadcastTableChange(tableName, operation, pk)),
+        commit() {
+            open = false;
+            store.commit();
+        },
+        flush() {
+            for (const push of pending.splice(0)) {
+                try {
+                    push();
+                }
+                catch (error) {
+                    console.error('[mock-server] Error pushing a committed change:', error);
+                }
+            }
+        },
+        rollback() {
+            if (!open)
+                return;
+            open = false;
+            pending.length = 0;
+            store.rollback();
+        },
+    };
+}
 // Commit events (EVENT_<ENTITY>_INSERT/_AMEND/_DELETE, or whatever suffix
 // convention your project uses) are looked up by exact MESSAGE_TYPE against
 // config.eventHandlers, then the tables' generic CRUD events. A handler
-// receives (details, ctx) and either returns { generated?: [...] } on
-// success, { warnings: [...] } to NACK with warnings only, or throws
-// NackError(errors) on failure.
+// receives (details, ctx) and either returns { generated?, warnings? } or
+// throws NackError(errors) on failure.
+//
+// A handler stands for a GSF event handler's onValidate and onCommit at once,
+// and the engine gives its outcome the commit semantics of GSF's
+// TransactionalEventHandlerContainer (genesis-pal-eventhandler, GSF v8.15.29,
+// transactionalEventFlow/defaultEventFlow; the typed handlers'
+// SyncValidatingEventHandler.process is the same):
+//
+//   VALIDATE: true       → onValidate only: its reply, nothing committed
+//   onValidate ACKs      → onCommit runs: its reply
+//   onValidate NACKs with warnings only (`result.error.isEmpty()`)
+//     and IGNORE_WARNINGS: true → onCommit runs: its reply (an ACK carries
+//                          no WARNING)
+//   any other NACK       → that NACK, nothing committed
+//
+// So the handler runs in a transaction (openTransaction), and the event
+// commits only when it acks: returned warnings without IGNORE_WARNINGS, a
+// thrown NackError (errors, with or without warnings), any other exception,
+// and VALIDATE all roll back what the handler wrote, and drop the live pushes
+// it asked for. Returned warnings with IGNORE_WARNINGS commit and ack with
+// the handler's GENERATED. A thrown NackError always NACKs, warnings-only
+// ones included: the handler stopped there, before its writes (a GSF
+// exception is always an error). A VALIDATE ack has GENERATED: [], as the
+// recorded ones do: whatever the handler generated was rolled back.
 export function handleCommitEvent(message, connection, config, store, ctx) {
     const eventName = message.MESSAGE_TYPE;
     // defaultEventHandler catches anything unregistered — lets projects with
@@ -47,15 +105,21 @@ export function handleCommitEvent(message, connection, config, store, ctx) {
     }
     // Before any handler runs, the message is checked against the event's
     // declared schema (eventValidation.ts), as GSF's decoder does; each failure
-    // is a FieldError in one EVENT_NACK. Legacy fidelity never checked.
-    // A handler's failure is an EVENT_NACK with GSF's error items (see
-    // protocol/errors.ts): a thrown NackError gives its own, anything else is
-    // StandardError INTERNAL_ERROR. Returned warnings NACK too, with an empty
-    // ERROR — the IGNORE_WARNINGS flow that would let them through is not
-    // modelled yet. VALIDATE: true reaches the handler as ctx.validate; a
-    // handler that honours it acks without writing.
+    // is a FieldError in one EVENT_NACK. A handler's failure is an EVENT_NACK
+    // with GSF's error items (see protocol/errors.ts): a thrown NackError gives
+    // its own, anything else is StandardError INTERNAL_ERROR.
+    // Legacy fidelity keeps what this engine did before: no schema check, no
+    // transaction (a handler's writes stay whatever it replies), and warnings
+    // always NACK, IGNORE_WARNINGS or not.
     const legacy = isLegacyFidelity(config);
+    const validate = message.VALIDATE === true;
+    const ignoreWarnings = !legacy && message.IGNORE_WARNINGS === true;
+    let transaction;
     try {
+        // Inside the try: a store transaction someone else left open fails this
+        // event (INTERNAL_ERROR) instead of leaving it unanswered.
+        if (!legacy)
+            transaction = openTransaction(store, ctx);
         const schemaErrors = legacy ? [] : validateEventMessage(message, connection, config, store);
         if (schemaErrors.length > 0)
             throw new NackError(schemaErrors);
@@ -63,22 +127,36 @@ export function handleCommitEvent(message, connection, config, store, ctx) {
             connection,
             store,
             message,
-            ...ctx,
-            validate: message.VALIDATE === true,
+            broadcast: transaction?.broadcast ?? ctx.broadcast,
+            broadcastTableChange: transaction?.broadcastTableChange ?? ctx.broadcastTableChange,
+            validate,
+            ignoreWarnings,
         }) ?? {};
-        if (result.warnings?.length) {
+        if (result.warnings?.length && (validate || !ignoreWarnings)) {
+            transaction?.rollback();
             connection.reply(message, {
                 MESSAGE_TYPE: MESSAGE_TYPE.EVENT_NACK,
                 ...warningPayload(result.warnings, legacy),
             });
             return;
         }
-        connection.reply(message, {
-            MESSAGE_TYPE: MESSAGE_TYPE.EVENT_ACK,
-            GENERATED: result.generated ?? [],
-        });
+        const generated = validate && !legacy ? [] : (result.generated ?? []);
+        // A GENERATED that can't go on the wire (a BigInt, a cycle) fails the
+        // event here, before anything is committed.
+        JSON.stringify(generated);
+        if (validate)
+            transaction?.rollback();
+        else
+            transaction?.commit();
+        try {
+            connection.reply(message, { MESSAGE_TYPE: MESSAGE_TYPE.EVENT_ACK, GENERATED: generated });
+        }
+        finally {
+            transaction?.flush();
+        }
     }
     catch (error) {
+        transaction?.rollback();
         connection.reply(message, {
             MESSAGE_TYPE: MESSAGE_TYPE.EVENT_NACK,
             ...nackPayload(error, legacy),

package/dist/protocol/errors.js

@@ -264,7 +264,9 @@ export class NackError extends Error {
     static nack(text) {
         return new NackError({ '@type': 'StandardError', CODE: ErrorCode.INTERNAL_ERROR, TEXT: text });
     }
-    // A NACK that only warns: ERROR stays empty, WARNING carries these.
+    // A NACK that only warns: ERROR stays empty, WARNING carries these. Thrown,
+    // it NACKs even under IGNORE_WARNINGS (the handler stopped there); check
+    // ctx.ignoreWarnings first, or return { warnings } instead.
     static warning(warnings) {
         return new NackError([], { warnings: asList(warnings) });
     }

package/dist/types.d.ts

@@ -164,6 +164,7 @@ export interface EventHandlerCtx {
     broadcast: BroadcastFn;
     broadcastTableChange: BroadcastTableChangeFn;
     validate: boolean;
+    ignoreWarnings: boolean;
 }
 export type EventHandlerResult = {
     generated?: Row[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genesislcap/mock-server",
-  "version": "15.57.0",
+  "version": "15.58.0",
   "description": "Reusable in-memory Genesis WebSocket protocol mock server for client automation/CI, without a JVM or database.",
   "type": "module",
   "main": "dist/index.js",

package/src/db/store.ts

@@ -116,6 +116,21 @@ function counterKey(prefix: string, format: SequenceFormat): string {
 // An AUTO_INCREMENT counter belongs to its table's field.
 const autoIncrementKey = (tableName: string, field: string) => `${tableName}\u0000${field}`;
 
+// What a transaction keeps of a table from before its first write in it: the
+// rows, and the removed and previous records the write's bookkeeping changes.
+// Row objects are never changed in place once stored, so copying the maps
+// is enough.
+interface TableSavepoint {
+  rows: Map<Pk, Row>;
+  removed: Map<Pk, Row[]> | undefined;
+  previous: Map<string, Row> | undefined;
+}
+
+function restoreEntry<V>(maps: Map<string, V>, tableName: string, saved: V | undefined): void {
+  if (saved === undefined) maps.delete(tableName);
+  else maps.set(tableName, saved);
+}
+
 export class Store {
   private tables = new Map<string, Map<Pk, Row>>();
   private tableConfig = new Map<string, TableConfig>();
@@ -136,8 +151,59 @@ export class Store {
   // it, as it was before the first such modify (by RECORD_ID) — see
   // takePreviousRecord. Bounded like removedRows.
   private previousRows = new Map<string, Map<string, Row>>();
+  // While a transaction is open (see begin), each table it has written to,
+  // as it was before.
+  private savepoint: Map<string, TableSavepoint> | undefined;
   readonly views = new Map<string, ViewDef>();
 
+  // Opens a transaction: the commit-event path wraps every handler in one
+  // (handlers/commitEvent.ts), so an event that NACKs leaves the tables as
+  // they were, as a GSF event whose onValidate NACKs never reaches its
+  // onCommit. Writes go through as usual; the first write to a table saves
+  // it, and rollback() puts back every table the transaction wrote to.
+  // Sequence and auto-increment counters and the RECORD_ID clock are not put
+  // back: a value used stays used, as a database sequence's does. Not nested,
+  // and the engine's own: an event that finds one open answers INTERNAL_ERROR.
+  // Saving copies the table's row map, O(rows) per event and table written.
+  begin(): void {
+    if (this.savepoint) throw new Error('A store transaction is already open');
+    this.savepoint = new Map();
+  }
+
+  // Keeps every write since begin().
+  commit(): void {
+    this.savepoint = undefined;
+  }
+
+  // Undoes every write since begin().
+  rollback(): void {
+    const savepoint = this.savepoint;
+    this.savepoint = undefined;
+    for (const [tableName, saved] of savepoint ?? []) {
+      this.tables.set(tableName, saved.rows);
+      restoreEntry(this.removedRows, tableName, saved.removed);
+      restoreEntry(this.previousRows, tableName, saved.previous);
+    }
+  }
+
+  get inTransaction(): boolean {
+    return this.savepoint !== undefined;
+  }
+
+  // Saves a table before the open transaction's first change to it.
+  private save(tableName: string): void {
+    if (!this.savepoint || this.savepoint.has(tableName)) return;
+    const rows = this.tables.get(tableName);
+    if (!rows) return;
+    const removed = this.removedRows.get(tableName);
+    const previous = this.previousRows.get(tableName);
+    this.savepoint.set(tableName, {
+      rows: new Map(rows),
+      removed: removed && new Map(removed),
+      previous: previous && new Map(previous),
+    });
+  }
+
   registerTable(tableName: string, definition: TableDef): this {
     const {
       pkField,
@@ -170,6 +236,8 @@ export class Store {
     }
     this.tables.set(tableName, table);
     this.tableConfig.set(tableName, config);
+    // Registering a table again replaces it whole: a rollback leaves it be.
+    this.savepoint?.delete(tableName);
     this.removedRows.delete(tableName);
     this.previousRows.delete(tableName);
     this.seedRows.set(
@@ -398,6 +466,7 @@ export class Store {
     const config = this.tableConfig.get(tableName);
     if (!table || !config) throw new Error(`Unknown table: ${tableName}`);
 
+    this.save(tableName);
     const row = { ...record };
     this.generateValues(tableName, config, row);
     const missing = config.pkFields.filter((field) => row[field] === undefined);
@@ -421,6 +490,7 @@ export class Store {
     const table = this.tables.get(tableName);
     const config = this.tableConfig.get(tableName);
     if (!table || !config || !table.has(pk)) return undefined;
+    this.save(tableName);
     const existing = table.get(pk)!;
     this.notePrevious(tableName, existing);
     const updated = { ...existing, ...patch };
@@ -445,6 +515,7 @@ export class Store {
     const table = this.tables.get(tableName);
     const existing = table?.get(pk);
     if (!table || !existing) return false;
+    this.save(tableName);
     table.delete(pk);
     this.noteRemoved(tableName, pk, existing);
     return true;
@@ -456,6 +527,7 @@ export class Store {
   // doesn't), including the old record when a key's row was replaced before
   // one broadcast.
   takeRemovedRows(tableName: string, key: Pk): Row[] {
+    this.save(tableName);
     const removed = this.removedRows.get(tableName);
     const records = removed?.get(key) ?? [];
     removed?.delete(key);
@@ -469,6 +541,7 @@ export class Store {
     const id = recordKey(row);
     const previous = this.previousRows.get(tableName);
     if (id === undefined || !previous) return undefined;
+    this.save(tableName);
     const record = previous.get(id);
     previous.delete(id);
     return record;

package/src/handlers/commitEvent.ts

@@ -33,12 +33,90 @@ function resolveEventHandler(
   );
 }
 
+// One event's transaction: the store's (Store.begin), plus the live pushes
+// the handler asks for, held back until the event has committed and acked —
+// a client must never see a change that is then rolled back, and on the real
+// server the dataserver's update reaches the client after the EVENT_ACK (the
+// recordings' order), so a client can't count on its grid holding the change
+// when the ACK arrives. Once the transaction is over, the broadcast
+// functions push straight away again, so a handler can keep them for later
+// (the showcase's price ticker does).
+interface EventTransaction {
+  broadcast: BroadcastFn;
+  broadcastTableChange: BroadcastTableChangeFn;
+  // Keeps the writes; the held pushes wait for flush().
+  commit(): void;
+  // Sends the held pushes. The event is committed whatever a push does: a
+  // failing one is logged, and the rest still go out.
+  flush(): void;
+  // Undoes the writes and drops the held pushes. Does nothing once the
+  // transaction is over.
+  rollback(): void;
+}
+
+function openTransaction(store: Store, ctx: CommitEventCtx): EventTransaction {
+  const pending: Array<() => void> = [];
+  let open = true;
+  store.begin();
+  const hold = (push: () => void) => {
+    if (open) pending.push(push);
+    else push();
+  };
+  return {
+    broadcast: (resourceName, operation, row) =>
+      hold(() => ctx.broadcast(resourceName, operation, row)),
+    broadcastTableChange: (tableName, operation, pk) =>
+      hold(() => ctx.broadcastTableChange(tableName, operation, pk)),
+    commit() {
+      open = false;
+      store.commit();
+    },
+    flush() {
+      for (const push of pending.splice(0)) {
+        try {
+          push();
+        } catch (error) {
+          console.error('[mock-server] Error pushing a committed change:', error);
+        }
+      }
+    },
+    rollback() {
+      if (!open) return;
+      open = false;
+      pending.length = 0;
+      store.rollback();
+    },
+  };
+}
+
 // Commit events (EVENT_<ENTITY>_INSERT/_AMEND/_DELETE, or whatever suffix
 // convention your project uses) are looked up by exact MESSAGE_TYPE against
 // config.eventHandlers, then the tables' generic CRUD events. A handler
-// receives (details, ctx) and either returns { generated?: [...] } on
-// success, { warnings: [...] } to NACK with warnings only, or throws
-// NackError(errors) on failure.
+// receives (details, ctx) and either returns { generated?, warnings? } or
+// throws NackError(errors) on failure.
+//
+// A handler stands for a GSF event handler's onValidate and onCommit at once,
+// and the engine gives its outcome the commit semantics of GSF's
+// TransactionalEventHandlerContainer (genesis-pal-eventhandler, GSF v8.15.29,
+// transactionalEventFlow/defaultEventFlow; the typed handlers'
+// SyncValidatingEventHandler.process is the same):
+//
+//   VALIDATE: true       → onValidate only: its reply, nothing committed
+//   onValidate ACKs      → onCommit runs: its reply
+//   onValidate NACKs with warnings only (`result.error.isEmpty()`)
+//     and IGNORE_WARNINGS: true → onCommit runs: its reply (an ACK carries
+//                          no WARNING)
+//   any other NACK       → that NACK, nothing committed
+//
+// So the handler runs in a transaction (openTransaction), and the event
+// commits only when it acks: returned warnings without IGNORE_WARNINGS, a
+// thrown NackError (errors, with or without warnings), any other exception,
+// and VALIDATE all roll back what the handler wrote, and drop the live pushes
+// it asked for. Returned warnings with IGNORE_WARNINGS commit and ack with
+// the handler's GENERATED. A thrown NackError always NACKs, warnings-only
+// ones included: the handler stopped there, before its writes (a GSF
+// exception is always an error). A VALIDATE ack has GENERATED: [], as the
+// recorded ones do: whatever the handler generated was rolled back.
 export function handleCommitEvent(
   message: GenesisMessage,
   connection: Connection,
@@ -79,15 +157,20 @@ export function handleCommitEvent(
 
   // Before any handler runs, the message is checked against the event's
   // declared schema (eventValidation.ts), as GSF's decoder does; each failure
-  // is a FieldError in one EVENT_NACK. Legacy fidelity never checked.
-  // A handler's failure is an EVENT_NACK with GSF's error items (see
-  // protocol/errors.ts): a thrown NackError gives its own, anything else is
-  // StandardError INTERNAL_ERROR. Returned warnings NACK too, with an empty
-  // ERROR — the IGNORE_WARNINGS flow that would let them through is not
-  // modelled yet. VALIDATE: true reaches the handler as ctx.validate; a
-  // handler that honours it acks without writing.
+  // is a FieldError in one EVENT_NACK. A handler's failure is an EVENT_NACK
+  // with GSF's error items (see protocol/errors.ts): a thrown NackError gives
+  // its own, anything else is StandardError INTERNAL_ERROR.
+  // Legacy fidelity keeps what this engine did before: no schema check, no
+  // transaction (a handler's writes stay whatever it replies), and warnings
+  // always NACK, IGNORE_WARNINGS or not.
   const legacy = isLegacyFidelity(config);
+  const validate = message.VALIDATE === true;
+  const ignoreWarnings = !legacy && message.IGNORE_WARNINGS === true;
+  let transaction: EventTransaction | undefined;
   try {
+    // Inside the try: a store transaction someone else left open fails this
+    // event (INTERNAL_ERROR) instead of leaving it unanswered.
+    if (!legacy) transaction = openTransaction(store, ctx);
     const schemaErrors = legacy ? [] : validateEventMessage(message, connection, config, store);
     if (schemaErrors.length > 0) throw new NackError(schemaErrors);
     const result =
@@ -95,21 +178,32 @@ export function handleCommitEvent(
         connection,
         store,
         message,
-        ...ctx,
-        validate: message.VALIDATE === true,
+        broadcast: transaction?.broadcast ?? ctx.broadcast,
+        broadcastTableChange: transaction?.broadcastTableChange ?? ctx.broadcastTableChange,
+        validate,
+        ignoreWarnings,
       }) ?? {};
-    if (result.warnings?.length) {
+    if (result.warnings?.length && (validate || !ignoreWarnings)) {
+      transaction?.rollback();
       connection.reply(message, {
         MESSAGE_TYPE: MESSAGE_TYPE.EVENT_NACK,
         ...warningPayload(result.warnings, legacy),
       });
       return;
     }
-    connection.reply(message, {
-      MESSAGE_TYPE: MESSAGE_TYPE.EVENT_ACK,
-      GENERATED: result.generated ?? [],
-    });
+    const generated = validate && !legacy ? [] : (result.generated ?? []);
+    // A GENERATED that can't go on the wire (a BigInt, a cycle) fails the
+    // event here, before anything is committed.
+    JSON.stringify(generated);
+    if (validate) transaction?.rollback();
+    else transaction?.commit();
+    try {
+      connection.reply(message, { MESSAGE_TYPE: MESSAGE_TYPE.EVENT_ACK, GENERATED: generated });
+    } finally {
+      transaction?.flush();
+    }
   } catch (error) {
+    transaction?.rollback();
     connection.reply(message, {
       MESSAGE_TYPE: MESSAGE_TYPE.EVENT_NACK,
       ...nackPayload(error, legacy),

package/src/protocol/errors.ts

@@ -245,8 +245,9 @@ function asList(inputs: string | NackErrorInput | NackErrorInput[] | undefined):
 }
 
 export interface NackErrorOptions {
-  // Sent in the NACK's WARNING list. (Acting on IGNORE_WARNINGS is a later
-  // item; for now a warning always fails the event.)
+  // Sent in the NACK's WARNING list. A thrown NackError always fails the
+  // event, IGNORE_WARNINGS or not: return warnings from the handler instead
+  // ({ warnings }) for ones that should give way to it.
   warnings?: NackErrorInput | NackErrorInput[];
 }
 
@@ -334,7 +335,9 @@ export class NackError extends Error {
     return new NackError({ '@type': 'StandardError', CODE: ErrorCode.INTERNAL_ERROR, TEXT: text });
   }
 
-  // A NACK that only warns: ERROR stays empty, WARNING carries these.
+  // A NACK that only warns: ERROR stays empty, WARNING carries these. Thrown,
+  // it NACKs even under IGNORE_WARNINGS (the handler stopped there); check
+  // ctx.ignoreWarnings first, or return { warnings } instead.
   static warning(warnings: string | NackErrorInput | NackErrorInput[]): NackError {
     return new NackError([], { warnings: asList(warnings) });
   }

package/src/types.ts

@@ -426,14 +426,29 @@ export interface EventHandlerCtx {
   // succeed. GSF then runs only the handler's onValidate and answers its NACK,
   // or an EVENT_ACK with GENERATED: [] — nothing is written. A handler that
   // writes should run its checks and return before writing when this is set;
-  // the generic CRUD events do.
+  // the generic CRUD events do. The engine rolls back whatever it writes
+  // anyway, and acks with GENERATED: [] whatever the handler returns (see
+  // handlers/commitEvent.ts; not under fidelity: 'legacy').
   validate: boolean;
+  // `IGNORE_WARNINGS: true` on the message: warnings the handler returns
+  // don't stop the event. The engine applies it: outside VALIDATE, returned
+  // warnings commit the handler's writes and ACK when this is set, and roll
+  // them back and NACK when it isn't. So write, then return the warnings:
+  // a handler that returns them before writing (as advised before this
+  // flag was modelled) now ACKs an ignored warning without writing. Read it
+  // to skip work that only matters when the event will commit, or before
+  // throwing NackError.warning(...), which always NACKs. Always false under
+  // fidelity: 'legacy', which doesn't model it.
+  ignoreWarnings: boolean;
 }
 
-// `warnings` turns the reply into an EVENT_NACK carrying them in WARNING
-// (with an empty ERROR), as a GSF handler's warning-only EventNack does.
-// Return them from a handler that has not written anything yet: the mock has
-// no transaction to roll back, and doesn't honour IGNORE_WARNINGS yet.
+// `warnings` (a non-empty list) is a GSF onValidate's warning-only
+// EventNack: without IGNORE_WARNINGS, or under VALIDATE, the reply is an
+// EVENT_NACK carrying them in WARNING with an empty ERROR, and nothing the
+// handler wrote is kept; with IGNORE_WARNINGS it is an EVENT_ACK with
+// `generated` (no WARNING), and the writes are kept. Errors are thrown
+// (NackError), never returned: a thrown NackError NACKs with its errors and
+// any warnings it carries, and rolls back too.
 export type EventHandlerResult = { generated?: Row[]; warnings?: NackErrorInput[] } | void;
 
 export type EventHandler = (details: Row, ctx: EventHandlerCtx) => EventHandlerResult;