feat(sea): surface numModifiedRows on the async (runAsync) path

The sync path already reports numModifiedRows for SEA DML; the async
(submitStatement) path returned all-null because readRichStatusFields
short-circuited for asyncStatement (the rich accessors used to live only
on the terminal sync Statement).

Kernel 75bfa52 now derives a DML's count off the terminal GetStatement
poll the async path already makes (no extra fetch, gated so SELECTs are
untouched) and exposes the four extended-status accessors on the napi
AsyncStatement. This change reads them off the async handle:

- readRichStatusFields now reads off this.asyncStatement (extracted into
  a shared readStatusFieldsFrom used by both the sync Statement and the
  async AsyncStatement);
- status() surfaces the fields on the async Succeeded state (the same
  GetStatement poll it just made carried them) — without materialising
  the result, so async streaming is unaffected.

Bumps KERNEL_REV to 75bfa52 and updates the napi contract
(native/sea/index.d.ts) with the new AsyncStatement accessors.

Verified live (pecotesting http_path2): SEA async INSERT/UPDATE/DELETE/
MERGE report numModifiedRows 3/2/1/2 — matching the sync path and Thrift
— with fetchAll() unchanged and SELECT carrying no count.

Co-authored-by: Isaac

Author: msrathore-db

KERNEL_REV

@@ -1 +1 @@
-81c69078f8cbc59391824887a7d4be666ece9510
+75bfa526cf70c6c37d565e3cbb19c6d922714174

lib/sea/SeaOperationBackend.ts

@@ -411,10 +411,15 @@ export default class SeaOperationBackend implements IOperationBackend {
     if (this.asyncStatement) {
       // Async query path: report the real kernel state (single
       // GetStatementStatus RPC — no polling here; `waitUntilReady` owns the
-      // poll loop). The rich status fields (`numModifiedRows` etc.) live on the
-      // terminal sync `Statement`, which the async path never produces, so they
-      // stay undefined here.
+      // poll loop). On a terminal Succeeded state, that same GetStatement poll
+      // carried the rich status fields (the kernel derives a DML's
+      // `numModifiedRows` from the inline count on the terminal response), so
+      // surface them — mirroring the sync path. Reading them does not fetch the
+      // result.
       const state = statusStringToOperationState(await this.asyncStatement.status());
+      if (state === OperationState.Succeeded) {
+        return { state, hasResultSet: true, ...(await this.readRichStatusFields()) };
+      }
       return { state, hasResultSet: true };
     }
     if (this.cancellableExecution) {
@@ -496,12 +501,16 @@ export default class SeaOperationBackend implements IOperationBackend {
       errorDetailsJson: null,
     };
 
-    // The async path never produces a terminal sync `Statement`, so there is
-    // nothing to read these off of. (The constructor guarantees exactly one of
-    // `asyncStatement` / `statement` / `cancellableExecution`, so `asyncStatement`
-    // being set already implies `cancellableExecution` is undefined.)
+    // Async (submit/poll) path: a DML's `numModifiedRows` rides in the result
+    // set, which SEA delivers on the terminal `GetStatement` poll. The kernel
+    // derives it off that poll (no extra fetch) and exposes it on the
+    // `AsyncStatement`'s status accessors — so read them directly. The value is
+    // populated once the statement has reached a terminal state via
+    // `status()` / `waitUntilReady` (which polled it); it stays null before
+    // that and for SELECTs. Reading does NOT force a result materialisation, so
+    // async streaming is untouched.
     if (this.asyncStatement) {
-      return empty;
+      return this.readStatusFieldsFrom(this.asyncStatement);
     }
 
     // Ensure the sync path's blocking `result()` has resolved and stored the
@@ -517,13 +526,31 @@ export default class SeaOperationBackend implements IOperationBackend {
       }
     }
 
-    const handle = this.blockingStatement as Partial<SeaStatusFieldsHandle> | undefined;
-    if (!handle || typeof handle.numModifiedRows !== 'function') {
-      // No resolved statement, or a binding that predates the rich-field
-      // accessors — degrade to all-null.
+    return this.readStatusFieldsFrom(this.blockingStatement);
+  }
+
+  /**
+   * Read the four rich-status accessors (`numModifiedRows` / `displayMessage` /
+   * `diagnosticInfo` / `errorDetailsJson`) off a kernel handle — the terminal
+   * sync `Statement` or the async `AsyncStatement`, which expose the same
+   * accessor shape. Per-field read errors are swallowed to `null`: a failed
+   * status-field read must never turn a successful operation's status query
+   * into a throw. Degrades to all-null for a missing handle or a binding that
+   * predates the accessors.
+   */
+  private async readStatusFieldsFrom(handle: unknown): Promise<SeaRichStatusFields> {
+    const empty: SeaRichStatusFields = {
+      numModifiedRows: null,
+      displayMessage: null,
+      diagnosticInfo: null,
+      errorDetailsJson: null,
+    };
+
+    const candidate = handle as Partial<SeaStatusFieldsHandle> | undefined;
+    if (!candidate || typeof candidate.numModifiedRows !== 'function') {
       return empty;
     }
-    const richHandle = handle as SeaStatusFieldsHandle;
+    const richHandle = candidate as SeaStatusFieldsHandle;
 
     const readOrNull = async <T>(read: () => Promise<T | null>): Promise<T | null> => {
       try {

native/sea/index.d.ts

@@ -148,6 +148,33 @@ class FakeAsyncStatement {
   public async close(): Promise<void> {
     this.closed = true;
   }
+
+  // Extended status accessors exposed on the napi AsyncStatement. The kernel
+  // populates them off the terminal GetStatement poll (a DML's count rides on
+  // that response); configurable here to assert the driver surfaces them
+  // through op.status() on the async path.
+  public rich: SeaRichStatusValues = {
+    numModifiedRows: null,
+    displayMessage: null,
+    diagnosticInfo: null,
+    errorDetailsJson: null,
+  };
+
+  public async numModifiedRows(): Promise<number | null> {
+    return this.rich.numModifiedRows;
+  }
+
+  public async displayMessage(): Promise<string | null> {
+    return this.rich.displayMessage;
+  }
+
+  public async diagnosticInfo(): Promise<string | null> {
+    return this.rich.diagnosticInfo;
+  }
+
+  public async errorDetailsJson(): Promise<string | null> {
+    return this.rich.errorDetailsJson;
+  }
 }
 
 /**
@@ -942,6 +969,36 @@ describe('SeaOperationBackend — async (submitStatement) path', () => {
     expect((await ok.status(false)).state).to.equal(OperationState.Succeeded);
   });
 
+  it('surfaces rich-status fields (numModifiedRows etc.) through op.status() once Succeeded', async () => {
+    // The kernel derives a DML's count off the terminal GetStatement poll and
+    // exposes it on the AsyncStatement accessors; the backend surfaces it on
+    // op.status() at the Succeeded state — parity with the sync path.
+    const stmt = new FakeAsyncStatement('Succeeded');
+    stmt.rich = {
+      numModifiedRows: 7,
+      displayMessage: 'UPDATE 0 7',
+      diagnosticInfo: 'ok',
+      errorDetailsJson: null,
+    };
+    const op = makeAsyncOp(stmt);
+    const status = await op.status(false);
+    expect(status.state).to.equal(OperationState.Succeeded);
+    expect(status.numModifiedRows).to.equal(7);
+    expect(status.displayMessage).to.equal('UPDATE 0 7');
+    expect(status.diagnosticInfo).to.equal('ok');
+    expect(status.errorDetailsJson).to.equal(null);
+  });
+
+  it('does not read rich-status fields before the async statement is terminal', async () => {
+    // A Running async statement must not surface (or fabricate) a count.
+    const stmt = new FakeAsyncStatement('Running');
+    stmt.rich = { numModifiedRows: 99, displayMessage: null, diagnosticInfo: null, errorDetailsJson: null };
+    const op = makeAsyncOp(stmt);
+    const status = await op.status(false);
+    expect(status.state).to.equal(OperationState.Running);
+    expect(status.numModifiedRows).to.equal(undefined);
+  });
+
   it('waitUntilReady() polls status() until terminal, firing the progress callback each tick', async () => {
     const stmt = new FakeAsyncStatement(['Pending', 'Running', 'Succeeded']);
     const op = makeAsyncOp(stmt);