@genesislcap/mock-server 15.48.0 → 15.50.0

package/src/handlers/dataLogon.ts

@@ -1,30 +1,116 @@
 import { compileCriteria, filterByCriteria } from '../db/criteria.ts';
 import type { Store } from '../db/store.ts';
-import type { Connection } from '../protocol/connection.ts';
+import type { Connection, Subscription } from '../protocol/connection.ts';
+import { isLegacyFidelity } from '../protocol/fidelity.ts';
 import { MESSAGE_TYPE, ERROR_CODE } from '../protocol/messageTypes.ts';
+import {
+  nonExistentSubscriptionNack,
+  resourceNotMappedNack,
+  subscriptionAlreadyExistsNack,
+} from '../protocol/msgNack.ts';
 import { stampRow } from '../protocol/rowUpdate.ts';
 import type { GenesisMessage, MockServerConfig, Row } from '../types.ts';
 import { applyResourceAuth, requestingUser } from './resourceAuth.ts';
 
-// DATA_LOGON opens a persistent subscription keyed by SOURCE_REF: reply with an
-// initial snapshot, then keep the SOURCE_REF registered so later inserts/amends/
-// deletes on this resource can be pushed on the same channel (see server.ts
-// broadcast()) until the client sends DATA_LOGOFF.
+// The real dataserver's defaults (genesis-pal-dataserver ClientOptions,
+// GSF 8.15.x) — also what foundation-comms' DatasourceDefaults send.
+const DEFAULT_MAX_ROWS = 250;
+const DEFAULT_MAX_VIEW = 1000;
+
+function readCount(value: unknown, fallback: number): number {
+  const count = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+  return typeof count === 'number' && Number.isInteger(count) && count >= 0 ? count : fallback;
+}
+
+// MAX_ROWS is the page size, MAX_VIEW the most rows the client's view may
+// hold across all pages. 0 means "no limit" for either, and MAX_ROWS is
+// clamped to MAX_VIEW — both exactly as ClientOptions.parse does.
+export function pagingOptions(details: Row): { maxRows: number; maxView: number } {
+  const maxView = readCount(details.MAX_VIEW, DEFAULT_MAX_VIEW) || Infinity;
+  const maxRows = readCount(details.MAX_ROWS, DEFAULT_MAX_ROWS) || Infinity;
+  return { maxRows: Math.min(maxRows, maxView), maxView };
+}
+
+// The key a row is tracked under in Subscription.pending / held — undefined
+// for a row without a ROW_REF, which no live change could ever be matched
+// against (and which the client can't identify either).
+export function pendingKey(rowRef: unknown): string | undefined {
+  return rowRef === undefined || rowRef === null ? undefined : String(rowRef);
+}
+
+function buildPending(rows: Row[]): Map<string, Row> {
+  const pending = new Map<string, Row>();
+  rows.forEach((row, index) => {
+    const key = pendingKey(row.DETAILS?.ROW_REF);
+    // A row with no ROW_REF (or a duplicate one) still has to be delivered;
+    // park it under a key no ROW_REF can produce rather than dropping it.
+    // Live changes can't reach it there, which is as much as the client
+    // could make of them: to it, rows sharing a ROW_REF are one row.
+    pending.set(key === undefined || pending.has(key) ? `\u0000${index}` : key, row);
+  });
+  return pending;
+}
+
+// The next page: up to MAX_ROWS waiting rows, but never more than the view
+// has room for. The real NextRowsStrategy reads while the client index is
+// below MAX_VIEW, so a full view gets an empty page, and a slot freed by a
+// DELETE is filled by the next row waiting. Delivered rows move to `held`.
+function takePage(subscription: Subscription): Row[] {
+  const { pending, held } = subscription;
+  if (!pending) return [];
+  const room = Math.max(
+    0,
+    Math.min(
+      subscription.maxRows ?? Infinity,
+      (subscription.maxView ?? Infinity) - (held?.size ?? 0),
+    ),
+  );
+  const page: Row[] = [];
+  for (const [key, row] of pending) {
+    if (page.length >= room) break;
+    page.push(row);
+    pending.delete(key);
+    held?.add(key);
+  }
+  return page;
+}
+
+// DATA_LOGON opens a persistent subscription keyed by SOURCE_REF: reply with
+// LOGON_ACK and the first page of the snapshot, then keep the SOURCE_REF
+// registered so MORE_ROWS can page the rest and later inserts/amends/deletes
+// on this resource are pushed on the same channel (see server.ts broadcast())
+// until the client sends DATA_LOGOFF.
 export function handleDataLogon(
   message: GenesisMessage,
   connection: Connection,
   config: MockServerConfig,
   store: Store,
 ): void {
+  const legacy = isLegacyFidelity(config);
   const details = message.DETAILS ?? {};
   const resourceName = details.DATASOURCE_NAME;
   const query = config.queries?.[resourceName];
 
   if (!query) {
-    connection.reply(message, {
-      MESSAGE_TYPE: MESSAGE_TYPE.QUERY_UPDATE,
-      ERROR: [{ CODE: ERROR_CODE.UNKNOWN_RESOURCE, TEXT: `Unknown datasource: ${resourceName}` }],
-    });
+    connection.reply(
+      message,
+      legacy
+        ? {
+            MESSAGE_TYPE: MESSAGE_TYPE.QUERY_UPDATE,
+            ERROR: [
+              { CODE: ERROR_CODE.UNKNOWN_RESOURCE, TEXT: `Unknown datasource: ${resourceName}` },
+            ],
+          }
+        : resourceNotMappedNack(resourceName),
+    );
+    return;
+  }
+
+  const sourceRef = message.SOURCE_REF!;
+  // The router refuses a second logon on a live SOURCE_REF and leaves the
+  // first subscription running. (Legacy mode silently replaced it.)
+  if (!legacy && connection.subscriptions.has(sourceRef)) {
+    connection.reply(message, subscriptionAlreadyExistsNack());
     return;
   }
 
@@ -33,8 +119,15 @@ export function handleDataLogon(
   // Order matters: the query's own filter (the where-clause equivalent) and
   // the user's row permissioning narrow the set BEFORE the client's
   // CRITERIA_MATCH; hidden fields are stripped last, off the final rows.
+  // Paging applies after all of them.
   let rows = store.getResourceRows(query.source);
   if (query.filter) rows = rows.filter(query.filter);
+  // ROWS_COUNT is the real dataserver's index count: it ignores
+  // CRITERIA_MATCH and the user's rowFilter (recorded: ROWS_COUNT 10 with 6
+  // rows matching), which grid-pro and the AI assistant already allow for.
+  // The query's own filter is the where clause the index is built over, so
+  // the count is taken after it — an assumption, as no recording covers it.
+  const rowsCount = rows.length;
   rows = filterByCriteria(rows, criteria);
   // Permissioning is applied per row so the ROW_REF can still be computed from
   // the UNSTRIPPED row — pk fields may themselves be hidden from this user,
@@ -47,22 +140,115 @@ export function handleDataLogon(
     stampedRows.push(stampRow(permitted, store.getRowRef(query.source, row), 'INSERT'));
   }
 
-  connection.subscribe(message.SOURCE_REF!, {
+  const subscription: Subscription = {
     resourceName,
     getRowRef: (row) => store.getRowRef(query.source, row),
     predicate: compileCriteria(criteria),
     sequenceId: 1,
-  });
+  };
 
-  connection.reply(message, {
+  if (legacy) {
+    connection.subscribe(sourceRef, subscription);
+    connection.reply(message, {
+      MESSAGE_TYPE: MESSAGE_TYPE.QUERY_UPDATE,
+      ROW: stampedRows,
+      ROWS_COUNT: stampedRows.length,
+      SEQUENCE_ID: 1,
+      MORE_ROWS: false,
+    });
+    return;
+  }
+
+  // Every matched row starts out waiting; the first page moves up to
+  // MAX_ROWS of them into `held`. Rows the view has no room for (past
+  // MAX_VIEW) keep waiting, so MORE_ROWS stays true — as on the real server,
+  // which then answers every MORE_ROWS with an empty {MORE_ROWS: true} page.
+  const { maxRows, maxView } = pagingOptions(details);
+  const tracked: Subscription = {
+    ...subscription,
+    pending: buildPending(stampedRows),
+    held: new Set<string>(),
+    maxRows,
+    maxView,
+  };
+  const firstPage = takePage(tracked);
+  const pending = tracked.pending!;
+  connection.subscribe(sourceRef, tracked);
+
+  connection.reply(message, { MESSAGE_TYPE: MESSAGE_TYPE.LOGON_ACK, SEQUENCE_ID: 0 });
+  // No matching rows: the real dataserver sends neither ROW nor ROWS_COUNT.
+  connection.reply(
+    message,
+    firstPage.length === 0
+      ? { MESSAGE_TYPE: MESSAGE_TYPE.QUERY_UPDATE, MORE_ROWS: false, SEQUENCE_ID: 1 }
+      : {
+          MESSAGE_TYPE: MESSAGE_TYPE.QUERY_UPDATE,
+          ROW: firstPage,
+          MORE_ROWS: pending.size > 0,
+          // Only on this first page (see rowsCount above).
+          ROWS_COUNT: rowsCount,
+          SEQUENCE_ID: 1,
+        },
+  );
+}
+
+// MORE_ROWS names its subscription in DETAILS.SOURCE_REF (foundation-comms'
+// createMoreRowsMessage gives the request a SOURCE_REF of its own) or, when
+// that is absent, in its own SOURCE_REF. The page goes out as a QUERY_UPDATE
+// on the subscription's SOURCE_REF without ROWS_COUNT; MORE_ROWS_ACK answers
+// the request's own SOURCE_REF, and only when DETAILS.SOURCE_REF was given —
+// both as the real ConnectionManager.processMoreRows does. The ack goes first
+// because the real server writes it while its dataserver is still reading the
+// page. Subscriptions are per connection, so another socket can never page
+// this one: its lookup misses and it gets the 404.
+export function handleMoreRows(
+  message: GenesisMessage,
+  connection: Connection,
+  config: MockServerConfig,
+): void {
+  if (isLegacyFidelity(config)) {
+    // Up to 15.47 MORE_ROWS was unrouted: logged, never answered.
+    console.warn(`[mock-server] Unhandled MESSAGE_TYPE: ${message.MESSAGE_TYPE}`);
+    return;
+  }
+  const detailsSourceRef: string | undefined = message.DETAILS?.SOURCE_REF;
+  const streamSourceRef = detailsSourceRef ?? message.SOURCE_REF;
+  const subscription =
+    streamSourceRef === undefined ? undefined : connection.subscriptions.get(streamSourceRef);
+  if (!subscription) {
+    connection.reply(message, nonExistentSubscriptionNack());
+    return;
+  }
+  if (detailsSourceRef !== undefined) {
+    connection.reply(message, { MESSAGE_TYPE: MESSAGE_TYPE.MORE_ROWS_ACK });
+  }
+
+  const page = takePage(subscription);
+  subscription.sequenceId += 1;
+  // No rows to send still gets an answer — an empty QUERY_UPDATE, as the real
+  // QueryClient sends when a read finds nothing: MORE_ROWS: false at the end
+  // of the data, true while rows are waiting for room in a full view.
+  connection.send({
     MESSAGE_TYPE: MESSAGE_TYPE.QUERY_UPDATE,
-    ROW: stampedRows,
-    ROWS_COUNT: stampedRows.length,
-    SEQUENCE_ID: 1,
-    MORE_ROWS: false,
+    SOURCE_REF: streamSourceRef,
+    ...(page.length > 0 ? { ROW: page } : {}),
+    MORE_ROWS: (subscription.pending?.size ?? 0) > 0,
+    SEQUENCE_ID: subscription.sequenceId,
   });
 }
 
-export function handleDataLogoff(message: GenesisMessage, connection: Connection): void {
-  connection.unsubscribe(message.SOURCE_REF!);
+export function handleDataLogoff(
+  message: GenesisMessage,
+  connection: Connection,
+  config: MockServerConfig,
+): void {
+  const sourceRef = message.SOURCE_REF;
+  const subscribed = sourceRef !== undefined && connection.subscriptions.has(sourceRef);
+  if (subscribed) connection.unsubscribe(sourceRef);
+  // Legacy mode never answered a logoff.
+  if (isLegacyFidelity(config)) return;
+  connection.reply(
+    message,
+    subscribed ? { MESSAGE_TYPE: MESSAGE_TYPE.LOGOFF_ACK } : nonExistentSubscriptionNack(),
+  );
 }

package/src/handlers/jsonSchema.ts

@@ -1,7 +1,9 @@
 import { deriveFields } from '../db/metadata.ts';
 import type { Store } from '../db/store.ts';
 import type { Connection } from '../protocol/connection.ts';
-import { ERROR_CODE } from '../protocol/messageTypes.ts';
+import { isLegacyFidelity } from '../protocol/fidelity.ts';
+import { ERROR_CODE, MESSAGE_TYPE } from '../protocol/messageTypes.ts';
+import { resourceNotMappedNack } from '../protocol/msgNack.ts';
 import type { FieldMetadata, GenesisMessage, MockServerConfig, Row } from '../types.ts';
 
 // JSON_SCHEMA_REQUEST shares its request envelope with META_REQUEST (same
@@ -14,7 +16,9 @@ import type { FieldMetadata, GenesisMessage, MockServerConfig, Row } from '../ty
 // (it reads Object.keys(...properties) to know which fields to copy from the
 // selected row into the commit DETAILS). Route this to handleMetaRequest by
 // mistake and forms silently render with zero fields, and delete can never
-// build a payload — no error, just a dead button.
+// build a payload — no error, just a dead button. The real success reply is
+// JSON_SCHEMA_FEATURE_ACK with INBOUND/OUTBOUND at the top level (legacy mode
+// echoed JSON_SCHEMA_REQUEST).
 
 function jsonSchemaType(fieldType: string): string {
   switch (fieldType) {
@@ -89,11 +93,17 @@ export function handleJsonSchemaRequest(
     resourceSource ??
     inferEventTable(eventName, Object.keys(config.tables ?? {}));
 
+  const legacy = isLegacyFidelity(config);
   if (!table) {
-    connection.reply(message, {
-      MESSAGE_TYPE: message.MESSAGE_TYPE,
-      ERROR: [{ CODE: ERROR_CODE.UNKNOWN_RESOURCE, TEXT: `Unknown resource: ${eventName}` }],
-    });
+    connection.reply(
+      message,
+      legacy
+        ? {
+            MESSAGE_TYPE: message.MESSAGE_TYPE,
+            ERROR: [{ CODE: ERROR_CODE.UNKNOWN_RESOURCE, TEXT: `Unknown resource: ${eventName}` }],
+          }
+        : resourceNotMappedNack(eventName),
+    );
     return;
   }
 
@@ -105,7 +115,7 @@ export function handleJsonSchemaRequest(
   const schema = buildSchema(fields, pkOnly ? pkFields : []);
 
   connection.reply(message, {
-    MESSAGE_TYPE: message.MESSAGE_TYPE,
+    MESSAGE_TYPE: legacy ? message.MESSAGE_TYPE : MESSAGE_TYPE.JSON_SCHEMA_FEATURE_ACK,
     INBOUND: schema,
     OUTBOUND: schema,
   });

package/src/handlers/meta.ts

@@ -1,7 +1,9 @@
 import { deriveFields } from '../db/metadata.ts';
 import type { Store } from '../db/store.ts';
 import type { Connection } from '../protocol/connection.ts';
-import { ERROR_CODE } from '../protocol/messageTypes.ts';
+import { isLegacyFidelity } from '../protocol/fidelity.ts';
+import { ERROR_CODE, MESSAGE_TYPE } from '../protocol/messageTypes.ts';
+import { resourceNotMappedNack } from '../protocol/msgNack.ts';
 import type { GenesisMessage, MockServerConfig, Row } from '../types.ts';
 import { hiddenFields, requestingUser } from './resourceAuth.ts';
 
@@ -19,6 +21,8 @@ function resolveResourceName(message: GenesisMessage): string {
 // DATASERVER resources need DETAILS.FIELD, REQUEST_SERVER ones need
 // DETAILS.REPLY_FIELD. Get either wrong and every grid silently reports
 // "Metadata Fetch failed" / "Unsupported resource type: undefined".
+// The real reply is FEATURE_ACK (getMetadata reads only DETAILS, so the type
+// is for fidelity; legacy mode echoed META_REQUEST).
 export function handleMetaRequest(
   message: GenesisMessage,
   connection: Connection,
@@ -29,11 +33,19 @@ export function handleMetaRequest(
   const query = config.queries?.[resourceName];
   const requestReply = config.requestReplies?.[resourceName];
 
+  const legacy = isLegacyFidelity(config);
   if (!query && !requestReply) {
-    connection.reply(message, {
-      MESSAGE_TYPE: message.MESSAGE_TYPE,
-      ERROR: [{ CODE: ERROR_CODE.UNKNOWN_RESOURCE, TEXT: `Unknown resource: ${resourceName}` }],
-    });
+    connection.reply(
+      message,
+      legacy
+        ? {
+            MESSAGE_TYPE: message.MESSAGE_TYPE,
+            ERROR: [
+              { CODE: ERROR_CODE.UNKNOWN_RESOURCE, TEXT: `Unknown resource: ${resourceName}` },
+            ],
+          }
+        : resourceNotMappedNack(resourceName),
+    );
     return;
   }
 
@@ -49,7 +61,7 @@ export function handleMetaRequest(
   const fields = deriveFields(rows, resolved.fieldTypes).filter((field) => !hidden.has(field.NAME));
 
   connection.reply(message, {
-    MESSAGE_TYPE: message.MESSAGE_TYPE,
+    MESSAGE_TYPE: legacy ? message.MESSAGE_TYPE : MESSAGE_TYPE.FEATURE_ACK,
     DETAILS: query
       ? { NAME: resourceName, TYPE: 'DATASERVER', FIELD: fields, KEY: [] }
       : { NAME: resourceName, TYPE: 'REQUEST_SERVER', REPLY_FIELD: fields },

package/src/handlers/requestReply.ts

@@ -2,7 +2,9 @@ import { filterByCriteria } from '../db/criteria.ts';
 import type { Store } from '../db/store.ts';
 import type { Connection } from '../protocol/connection.ts';
 import { NackError } from '../protocol/errors.ts';
+import { isLegacyFidelity } from '../protocol/fidelity.ts';
 import { ERROR_CODE } from '../protocol/messageTypes.ts';
+import { resourceNotMappedNack } from '../protocol/msgNack.ts';
 import type { GenesisMessage, MockServerConfig, Row } from '../types.ts';
 import { applyResourceAuth, requestingUser } from './resourceAuth.ts';
 
@@ -29,15 +31,20 @@ export function handleRequestReply(
   const requestReply = config.requestReplies?.[resourceName];
 
   if (!requestReply || (!requestReply.resolver && !requestReply.source)) {
-    connection.reply(message, {
-      MESSAGE_TYPE: `REP_${resourceName}`,
-      ERROR: [
-        {
-          CODE: ERROR_CODE.UNKNOWN_RESOURCE,
-          TEXT: `Unknown request-reply resource: ${resourceName}`,
-        },
-      ],
-    });
+    connection.reply(
+      message,
+      isLegacyFidelity(config)
+        ? {
+            MESSAGE_TYPE: `REP_${resourceName}`,
+            ERROR: [
+              {
+                CODE: ERROR_CODE.UNKNOWN_RESOURCE,
+                TEXT: `Unknown request-reply resource: ${resourceName}`,
+              },
+            ],
+          }
+        : resourceNotMappedNack(resourceName),
+    );
     return;
   }
 

package/src/index.ts

@@ -13,6 +13,7 @@ export type {
   EventHandlerCtx,
   EventHandlerResult,
   EventSchemaOverride,
+  FidelityMode,
   FieldMetadata,
   GenesisMessage,
   HttpRouteDef,

package/src/protocol/connection.ts

@@ -10,7 +10,23 @@ export interface Subscription {
   // the joined composite key) — bound to Store.getRowRef at subscribe time.
   getRowRef: (row: Row) => unknown;
   predicate: Predicate;
+  // SEQUENCE_ID of the last QUERY_UPDATE sent on this subscription (the
+  // snapshot is 1); every later page or live push takes the next one.
   sequenceId: number;
+  // The client's view, tracked like the real dataserver's client index (set
+  // on 'gsf'-fidelity subscriptions; legacy ones have none). Every row is in
+  // at most one of:
+  // - pending: matched but not sent yet — past this page, or past MAX_VIEW —
+  //   in delivery order, stamped and permission-stripped. A live change to a
+  //   waiting row updates or drops it here instead of being pushed.
+  //   MORE_ROWS drains it, maxRows at a time, while the view has room.
+  // - held: sent to the client (on a page, or pushed as an INSERT). Only
+  //   these get MODIFY and DELETE pushes.
+  // Both are keyed by String(ROW_REF) (see dataLogon.ts pendingKey).
+  pending?: Map<string, Row>;
+  held?: Set<string>;
+  maxRows?: number;
+  maxView?: number;
 }
 
 // Wraps one WebSocket client connection: auth state and its live DATA_LOGON

package/src/protocol/fidelity.ts

@@ -0,0 +1,8 @@
+import type { MockServerConfig } from '../types.ts';
+
+// True when the config opts back into the envelopes this engine sent up to
+// 15.47 (see FidelityMode in types.ts). Read per message, like every other
+// config field, so flipping it on a running server takes effect immediately.
+export function isLegacyFidelity(config: MockServerConfig): boolean {
+  return config.fidelity === 'legacy';
+}

package/src/protocol/messageTypes.ts

@@ -17,10 +17,19 @@ export const MESSAGE_TYPE = {
   HEARTBEAT_PING: 'HEARTBEAT_PING',
   HEARTBEAT_PONG: 'HEARTBEAT_PONG',
   DATA_LOGON: 'DATA_LOGON',
+  LOGON_ACK: 'LOGON_ACK',
   DATA_LOGOFF: 'DATA_LOGOFF',
+  LOGOFF_ACK: 'LOGOFF_ACK',
   QUERY_UPDATE: 'QUERY_UPDATE',
+  MORE_ROWS: 'MORE_ROWS',
+  MORE_ROWS_ACK: 'MORE_ROWS_ACK',
   META_REQUEST: 'META_REQUEST',
+  FEATURE_ACK: 'FEATURE_ACK',
   JSON_SCHEMA_REQUEST: 'JSON_SCHEMA_REQUEST',
+  JSON_SCHEMA_FEATURE_ACK: 'JSON_SCHEMA_FEATURE_ACK',
+  // The router's generic rejection (unknown resource, missing or duplicate
+  // dataserver subscription) — see protocol/msgNack.ts.
+  MSG_NACK: 'MSG_NACK',
   RESOURCES_REQUEST: 'RESOURCES_REQUEST',
   RESOURCES_REQUEST_ACK: 'RESOURCES_REQUEST_ACK',
   RESOURCES_REQUEST_NACK: 'RESOURCES_REQUEST_NACK',

package/src/protocol/msgNack.ts

@@ -0,0 +1,50 @@
+import type { Row } from '../types.ts';
+import { MESSAGE_TYPE } from './messageTypes.ts';
+
+const HTTP_NOT_FOUND = 404;
+const HTTP_CONFLICT = 409;
+
+// The real router's rejection frame (genesis-router MsgType.Outbound.Error,
+// GSF 8.15.x): an integer HTTP status CODE, and the status line as
+// STATUS_CODE, repeated under DETAILS. It is a different family from the
+// handler-level EVENT_NACK/REP_ errors (string CODEs such as
+// VALIDATION_ERROR) — the router sends it before a request ever reaches a
+// service. foundation-comms' socket REJECTS the pending promise on MSG_NACK
+// (connect/socket.ts), where a typed reply carrying ERROR resolves it.
+function routerNack(code: number, reason: string, text: string): Row {
+  const STATUS_CODE = `${code} ${reason}`;
+  return {
+    MESSAGE_TYPE: MESSAGE_TYPE.MSG_NACK,
+    ERROR: [{ CODE: code, TEXT: text, STATUS_CODE }],
+    DETAILS: { ERROR: text, STATUS_CODE },
+  };
+}
+
+// The router resolves every message to a resource name first and answers this
+// when no service serves it: DETAILS.DATASOURCE_NAME for DATA_LOGON, the name
+// after REQ_ for request servers, DETAILS.FEATURE for META_REQUEST /
+// JSON_SCHEMA_REQUEST, and the MESSAGE_TYPE itself for commit events. A
+// missing name is the empty string, as on the real router.
+export function resourceNotMappedNack(resourceName: string | undefined): Row {
+  return routerNack(
+    HTTP_NOT_FOUND,
+    'Not Found',
+    `Resource ${resourceName ?? ''} is not mapped to a service`,
+  );
+}
+
+// MORE_ROWS or DATA_LOGOFF naming a SOURCE_REF this connection has no live
+// subscription on (never logged on, already logged off, or another socket's).
+export function nonExistentSubscriptionNack(): Row {
+  return routerNack(HTTP_NOT_FOUND, 'Not Found', 'Dataserver subscription does not exist');
+}
+
+// DATA_LOGON on a SOURCE_REF that already has a live subscription on this
+// connection. The existing subscription is left untouched.
+export function subscriptionAlreadyExistsNack(): Row {
+  return routerNack(
+    HTTP_CONFLICT,
+    'Conflict',
+    'Subscription exists for source ref. If using HTTP, try HTTP GET instead of HTTP POST',
+  );
+}

package/src/protocol/router.ts

@@ -1,7 +1,7 @@
 import type { Store } from '../db/store.ts';
 import { handleLogin, handleLogout, type TokenRegistry } from '../handlers/auth.ts';
 import { handleCommitEvent, type CommitEventCtx } from '../handlers/commitEvent.ts';
-import { handleDataLogon, handleDataLogoff } from '../handlers/dataLogon.ts';
+import { handleDataLogon, handleDataLogoff, handleMoreRows } from '../handlers/dataLogon.ts';
 import { handleHeartbeat } from '../handlers/heartbeat.ts';
 import { handleJsonSchemaRequest } from '../handlers/jsonSchema.ts';
 import { handleMetaRequest } from '../handlers/meta.ts';
@@ -9,6 +9,7 @@ import { handleRequestReply } from '../handlers/requestReply.ts';
 import { handleResourcesRequest } from '../handlers/resources.ts';
 import type { GenesisMessage, MockServerConfig } from '../types.ts';
 import type { Connection } from './connection.ts';
+import { isLegacyFidelity } from './fidelity.ts';
 import { MESSAGE_TYPE, ERROR_CODE, isCommitEvent, isRequestReply } from './messageTypes.ts';
 
 // Message types a connection may send before authenticating when the OPT-IN
@@ -17,7 +18,11 @@ import { MESSAGE_TYPE, ERROR_CODE, isCommitEvent, isRequestReply } from './messa
 // requires the connection to have logged in over WS — or to present a
 // SESSION_AUTH_TOKEN this server issued (over either transport).
 // RESOURCES_REQUEST is allowed pre-auth so resource discovery can't deadlock
-// a client that fetches it before (or while) logging in.
+// a client that fetches it before (or while) logging in. MORE_ROWS, like
+// DATA_LOGOFF, can only act on a subscription the connection already opened
+// through the gate (logout clears them), so it answers with its own precise
+// 404 rather than a NOT_LOGGED_ON echo — except under fidelity: 'legacy',
+// which keeps the 15.47 gate (see isPreAuth).
 //
 // The gate is OFF by default because real clients can't be assumed to
 // satisfy it: browser frame captures show that after logging in over
@@ -34,6 +39,11 @@ const PRE_AUTH_MESSAGE_TYPES = new Set<string>([
   MESSAGE_TYPE.RESOURCES_REQUEST,
 ]);
 
+function isPreAuth(messageType: string, config: MockServerConfig): boolean {
+  if (messageType === MESSAGE_TYPE.MORE_ROWS) return !isLegacyFidelity(config);
+  return PRE_AUTH_MESSAGE_TYPES.has(messageType);
+}
+
 function ensureAuthenticated(
   message: GenesisMessage,
   connection: Connection,
@@ -86,11 +96,7 @@ export function routeMessage(
   // away; the gate itself only applies to data traffic.
   ensureAuthenticated(message, connection, tokens);
   const requireAuth = config.auth?.requireAuth ?? false;
-  if (
-    requireAuth &&
-    !PRE_AUTH_MESSAGE_TYPES.has(message.MESSAGE_TYPE) &&
-    !connection.authenticated
-  ) {
+  if (requireAuth && !isPreAuth(message.MESSAGE_TYPE, config) && !connection.authenticated) {
     return replyNotLoggedOn(message, connection);
   }
 
@@ -104,7 +110,9 @@ export function routeMessage(
     case MESSAGE_TYPE.DATA_LOGON:
       return handleDataLogon(message, connection, config, store);
     case MESSAGE_TYPE.DATA_LOGOFF:
-      return handleDataLogoff(message, connection);
+      return handleDataLogoff(message, connection, config);
+    case MESSAGE_TYPE.MORE_ROWS:
+      return handleMoreRows(message, connection, config);
     case MESSAGE_TYPE.META_REQUEST:
       return handleMetaRequest(message, connection, config, store);
     case MESSAGE_TYPE.JSON_SCHEMA_REQUEST: