fix(sea): address review findings + bump KERNEL_REV to kernel main; prettier

Review findings (GopalDB / code-review agent), each validated:

1. DBSQLParameter DATE off-by-one in non-UTC timezones — `toISOString()`
   converts to UTC before slicing, so a local-constructed Date shifts a
   day in offset zones. Use local calendar accessors
   (getFullYear/getMonth/getDate). Validated end-to-end on a live SEA
   warehouse under TZ=Australia/Sydney: a `new Date(2024,2,14)` now
   round-trips as 2024-03-14 (was 2024-03-13). Regression test sabotages
   toISOString so it guards in any timezone (incl. the UTC CI runner).

2. SeaOperationBackend.status() (sync path) could block indefinitely —
   it gated Succeeded on `fetchHandlePromise` *existing*, but that is
   assigned synchronously when getFetchHandle() is first called while
   result() may still be pending; status() would then report Succeeded
   early AND await the pending result() via readRichStatusFields(). Gate
   on `blockingStatement` (set only after result() resolves) instead.

3. Async-path progress callback omitted the rich-status fields on the
   terminal Succeeded tick (the sync path includes them) — parity break
   for DML numModifiedRows. Merge the rich fields into the Succeeded
   callback in waitUntilReadyAsync.

Also:
- KERNEL_REV -> 9c2e2378 (kernel main, #144 merged). Binding contract
  (native/sea/index.d.ts) already matched the bumped surface.
- prettier --write (lint fix) + new regression tests for findings 1-3.

Co-authored-by: Isaac
Signed-off-by: Madhavendra Rathore <madhavendra.rathore@databricks.com>

Author: msrathore-db

KERNEL_REV

@@ -1 +1 @@
-75bfa526cf70c6c37d565e3cbb19c6d922714174
+9c2e2378f9a0bcee7d2750371392c07cac38fc3d

lib/DBSQLParameter.ts

@@ -137,7 +137,17 @@ export class DBSQLParameter {
         name,
         type: wireType ?? DBSQLParameterType.TIMESTAMP,
         value: new TSparkParameterValue({
-          stringValue: isDateType ? this.value.toISOString().slice(0, 10) : this.value.toISOString(),
+          // For DATE, project the *calendar* date using local-time accessors
+          // rather than `toISOString().slice(0, 10)`. `toISOString()` first
+          // converts to UTC, so a `new Date(2024, 2, 14)` constructed in a
+          // positive-offset zone (e.g. UTC+10, internal `2024-03-13T14:00Z`)
+          // would yield "2024-03-13" — off by one. Users reason about a DATE
+          // as the wall-calendar date they constructed, so extract that.
+          stringValue: isDateType
+            ? `${this.value.getFullYear()}-${String(this.value.getMonth() + 1).padStart(2, '0')}-${String(
+                this.value.getDate(),
+              ).padStart(2, '0')}`
+            : this.value.toISOString(),
         }),
       });
     }

lib/sea/SeaOperationBackend.ts

@@ -406,7 +406,15 @@ export default class SeaOperationBackend implements IOperationBackend {
       // server-side; there is no per-status RPC to query while it runs. Report
       // Running until `result()` has materialised the terminal statement, then
       // Succeeded — mirroring the kernel's blocking-then-terminal lifecycle.
-      if (!this.fetchHandlePromise) {
+      //
+      // Gate on `blockingStatement`, NOT on `fetchHandlePromise`: the latter is
+      // assigned synchronously when `getFetchHandle()` is first called (e.g. by
+      // a concurrent fetch or `waitUntilReady`), while `result()` may still be
+      // pending — `blockingStatement` is only set inside the resolve handler.
+      // Using the promise's *existence* as a completion proxy would make a
+      // concurrent `status()` poll both report Succeeded early AND block on the
+      // pending `result()` via `readRichStatusFields()`.
+      if (!this.blockingStatement) {
         return { state: OperationState.Running, hasResultSet: true };
       }
       // The blocking `result()` has resolved a terminal `Statement` — surface
@@ -587,8 +595,16 @@ export default class SeaOperationBackend implements IOperationBackend {
       const state = statusStringToOperationState(await this.asyncStatement!.status());
 
       if (options?.callback) {
+        // On the terminal Succeeded tick, carry the rich status fields
+        // (numModifiedRows / displayMessage / diagnosticInfo / errorDetailsJson)
+        // so the async path's progress callback matches the sync path
+        // (`waitUntilReadyCancellable`). The kernel has populated the
+        // AsyncStatement's accessors off the just-completed terminal poll, and
+        // the read is memoised + does not force result materialisation.
+        // eslint-disable-next-line no-await-in-loop
+        const richFields = state === OperationState.Succeeded ? await this.readRichStatusFields() : {};
         // eslint-disable-next-line no-await-in-loop
-        await Promise.resolve(options.callback({ state, hasResultSet: true }));
+        await Promise.resolve(options.callback({ state, hasResultSet: true, ...richFields }));
       }
 
       switch (state) {

tests/unit/DBSQLParameter.test.ts

@@ -168,4 +168,22 @@ describe('DBSQLParameter', () => {
       }),
     );
   });
+
+  it('binds a typed DATE from local calendar accessors, never via toISOString (no UTC off-by-one)', () => {
+    // A `Date` constructed from local components must bind the wall-calendar
+    // date the user intended, regardless of the process timezone.
+    // `toISOString()` converts to UTC first, so in a positive-offset zone a
+    // local-midnight `new Date(2024, 2, 14)` (internally 2024-03-13T..Z) would
+    // bind "2024-03-13" — off by one. Sabotage `toISOString` to PROVE the DATE
+    // path doesn't use it: this guards the regression in any timezone, including
+    // the UTC CI runner where the two formulations would otherwise agree.
+    const localDate = new Date(2024, 2, 14);
+    (localDate as unknown as { toISOString: () => string }).toISOString = () => '1999-12-31T00:00:00.000Z';
+    expect(new DBSQLParameter({ type: DBSQLParameterType.DATE, value: localDate }).toSparkParameter()).to.deep.equal(
+      new TSparkParameter({
+        type: DBSQLParameterType.DATE,
+        value: new TSparkParameterValue({ stringValue: '2024-03-14' }),
+      }),
+    );
+  });
 });

tests/unit/sea/connectionOptions.test.ts

@@ -288,7 +288,10 @@ describe('SeaAuth HTTP options (buildSeaHttpOptions)', () => {
     ];
     for (const [label, customHeaders] of injections) {
       it(`throws HiveDriverError on ${label}`, () => {
-        expect(() => buildSeaHttpOptions(opts({ customHeaders }))).to.throw(HiveDriverError, /forbidden control character/);
+        expect(() => buildSeaHttpOptions(opts({ customHeaders }))).to.throw(
+          HiveDriverError,
+          /forbidden control character/,
+        );
       });
     }
 
@@ -301,9 +304,10 @@ describe('SeaAuth HTTP options (buildSeaHttpOptions)', () => {
     it('validates a reserved header before dropping it (injection via Authorization is still rejected)', () => {
       // Reserved-name drop must not let a CR/LF-laced reserved header slip past
       // validation — validate first, then drop.
-      expect(() =>
-        buildSeaHttpOptions(opts({ customHeaders: { Authorization: 'Bearer x\r\nInjected: 1' } })),
-      ).to.throw(HiveDriverError, /forbidden control character/);
+      expect(() => buildSeaHttpOptions(opts({ customHeaders: { Authorization: 'Bearer x\r\nInjected: 1' } }))).to.throw(
+        HiveDriverError,
+        /forbidden control character/,
+      );
     });
   });
 });

tests/unit/sea/execution.test.ts

@@ -232,6 +232,16 @@ class FakeCancellableExecution {
       this.pendingResolve = undefined;
     }
   }
+
+  // Resolve a parked (blocked) result() with the terminal statement, modelling
+  // the server-side blocking execute finally completing.
+  public release(): void {
+    if (this.pendingResolve) {
+      this.pendingResolve(this.resultHandle);
+      this.pendingResolve = undefined;
+      this.pendingReject = undefined;
+    }
+  }
 }
 
 class FakeNativeConnection implements SeaConnection {
@@ -1044,6 +1054,26 @@ describe('SeaOperationBackend — async (submitStatement) path', () => {
     expect(states).to.deep.equal([OperationState.Pending, OperationState.Running, OperationState.Succeeded]);
   });
 
+  it('progress callback carries rich-status fields on the terminal Succeeded tick (parity with the sync path)', async () => {
+    // Regression guard: the async poll loop must merge the rich-status fields
+    // into the callback on the Succeeded tick, matching waitUntilReadyCancellable.
+    // Previously the async path fired only { state, hasResultSet } even when
+    // Succeeded, so a DML's numModifiedRows never reached a progress callback.
+    const stmt = new FakeAsyncStatement(['Running', 'Succeeded']);
+    stmt.rich = { numModifiedRows: 13, displayMessage: 'UPDATE 0 13', diagnosticInfo: null, errorDetailsJson: null };
+    const op = makeAsyncOp(stmt);
+    const ticks: Array<{ state: OperationState; numModifiedRows?: number | null; displayMessage?: string | null }> = [];
+    await op.waitUntilReady({ callback: (s) => ticks.push(s) });
+
+    const succeeded = ticks.find((t) => t.state === OperationState.Succeeded);
+    expect(succeeded, 'a Succeeded tick fired').to.not.equal(undefined);
+    expect(succeeded?.numModifiedRows).to.equal(13);
+    expect(succeeded?.displayMessage).to.equal('UPDATE 0 13');
+    // Non-terminal ticks must NOT carry rich fields (only populated when terminal).
+    const running = ticks.find((t) => t.state === OperationState.Running);
+    expect(running?.numModifiedRows).to.equal(undefined);
+  });
+
   it('waitUntilReady() surfaces the kernel error envelope on a Failed statement', async () => {
     const stmt = new FakeAsyncStatement('Failed');
     // The kernel rejects awaitResult() with a sentinel-framed structured error;
@@ -1195,6 +1225,30 @@ describe('SeaOperationBackend — sync (executeStatementCancellable) path', () =
     expect((await op.status(false)).state).to.equal(OperationState.Succeeded);
   });
 
+  it('status() stays Running and does NOT block while a concurrent result() is still in flight', async () => {
+    // Regression guard: status() must gate Succeeded on the *resolved* statement
+    // (blockingStatement), not on the mere existence of fetchHandlePromise.
+    // Once a concurrent path (here, waitUntilReady) has dispatched result(),
+    // fetchHandlePromise is set but still pending; the old `!fetchHandlePromise`
+    // gate would (a) report Succeeded early and (b) block on the pending
+    // result() via readRichStatusFields() -> getFetchHandle().
+    const exec = new FakeCancellableExecution();
+    exec.block = true; // result() parks until released
+    const op = makeSyncOp(exec);
+    const waitPromise = op.waitUntilReady(); // dispatches result() (parks); fetchHandlePromise now pending
+    await Promise.resolve(); // let result() get dispatched + parked
+
+    const status = (await Promise.race([
+      op.status(false),
+      new Promise((_, reject) => setTimeout(() => reject(new Error('status() blocked on the pending result()')), 2000)),
+    ])) as { state: OperationState };
+    expect(status.state).to.equal(OperationState.Running);
+
+    exec.release(); // blocking execute completes
+    await waitPromise;
+    expect((await op.status(false)).state).to.equal(OperationState.Succeeded);
+  });
+
   it('waitUntilReady() drives result() to the terminal statement and fires the callback once', async () => {
     const exec = new FakeCancellableExecution();
     const op = makeSyncOp(exec);