sea: complete neutral-type conformance so the SEA driver builds + runs

Finishes the IOperationBackend neutral-type WIP that blocked the SEA
driver from compiling against the merged abstraction:

- SeaOperationBackend.status() returns the neutral OperationStatus
  (OperationState.{Cancelled,Closed,Succeeded}) instead of a Thrift
  TGetOperationStatusResp; getResultMetadata() returns the neutral
  ResultMetadata (schema + ResultFormat.ArrowBased + arrowSchema) instead
  of TGetResultSetMetadataResp. The IOperationBackend contract is neutral;
  the Thrift backend adapts at its own boundary.
- ArrowResultConverter only consumes `schema`, so its ctor param is
  narrowed from TGetResultSetMetadataResp to `{ schema?: TTableSchema }`
  — now satisfied by BOTH the Thrift resp and the neutral ResultMetadata
  (DRY: no per-backend adapter at the call site).
- SeaBackend casts the SeaAuth options union to the binding's openSession
  param at the single boundary (authMode string-literal vs napi const enum
  — same runtime values; cast localized per SeaAuth's const-enum note).

Validated locally end-to-end: the built DBSQLClient on the SEA backend
runs `SELECT 1, current_catalog()` → correct rows, and the databricks-
driver-test Node comparator (PR #281) runs thrift-vs-SEA with conn1
(Thrift) and conn2 (useSEA) both opening + querying OK.

Co-authored-by: Isaac

Author: msrathore-db

lib/result/ArrowResultConverter.ts

@@ -13,7 +13,7 @@ import {
   RecordBatchReader,
   util as arrowUtils,
 } from 'apache-arrow';
-import { TGetResultSetMetadataResp, TColumnDesc } from '../../thrift/TCLIService_types';
+import { TTableSchema, TColumnDesc } from '../../thrift/TCLIService_types';
 import IClientContext from '../contracts/IClientContext';
 import IResultsProvider, { ResultsProviderFetchNextOptions } from './IResultsProvider';
 import { ArrowBatch, getSchemaColumns, convertThriftValue } from './utils';
@@ -179,7 +179,12 @@ export default class ArrowResultConverter implements IResultsProvider<Array<any>
   // actually return a non-empty result
   private prefetchedRecordBatch?: RecordBatch<TypeMap>;
 
-  constructor(context: IClientContext, source: IResultsProvider<ArrowBatch>, { schema }: TGetResultSetMetadataResp) {
+  // Only the column `schema` is consumed here. Typed as the minimal shape
+  // (not the full Thrift `TGetResultSetMetadataResp`) so both the Thrift
+  // operation backend and the SEA backend's neutral `ResultMetadata` —
+  // which both carry `schema?: TTableSchema` — can construct the converter
+  // without an adapter at the call site.
+  constructor(context: IClientContext, source: IResultsProvider<ArrowBatch>, { schema }: { schema?: TTableSchema }) {
     this.context = context;
     this.source = source;
     this.schema = getSchemaColumns(schema);

lib/sea/SeaBackend.ts

@@ -111,7 +111,15 @@ export default class SeaBackend implements IBackend {
 
     let nativeConnection: SeaNativeConnection;
     try {
-      nativeConnection = (await this.binding.openSession(sessionOptions)) as SeaNativeConnection;
+      // `SeaNativeConnectionOptions.authMode` is a string-literal union
+      // ('Pat' | 'OAuthM2m' | 'OAuthU2m') — deliberately not the binding's
+      // `const enum AuthMode` (see SeaAuth's note on why a const-enum import
+      // is avoided). The literal values are byte-identical to the enum's, so
+      // the only divergence is TS's const-enum strictness; cast to the
+      // binding's parameter type at this single boundary.
+      nativeConnection = (await this.binding.openSession(
+        sessionOptions as unknown as Parameters<SeaNativeBinding['openSession']>[0],
+      )) as SeaNativeConnection;
     } catch (err) {
       throw decodeNapiKernelError(err);
     }

lib/sea/SeaOperationBackend.ts

@@ -37,15 +37,10 @@
  */
 
 import { v4 as uuidv4 } from 'uuid';
-import {
-  TGetOperationStatusResp,
-  TGetResultSetMetadataResp,
-  TOperationState,
-  TSparkRowSetType,
-  TStatusCode,
-  TTableSchema,
-} from '../../thrift/TCLIService_types';
+import { TGetOperationStatusResp, TTableSchema } from '../../thrift/TCLIService_types';
 import IOperationBackend from '../contracts/IOperationBackend';
+import { OperationStatus, OperationState } from '../contracts/OperationStatus';
+import { ResultMetadata, ResultFormat } from '../contracts/ResultMetadata';
 import IClientContext from '../contracts/IClientContext';
 import Status from '../dto/Status';
 import ArrowResultConverter from '../result/ArrowResultConverter';
@@ -101,9 +96,9 @@ export default class SeaOperationBackend implements IOperationBackend {
 
   private resultsProvider?: SeaResultsProvider;
 
-  private metadata?: TGetResultSetMetadataResp;
+  private metadata?: ResultMetadata;
 
-  private metadataPromise?: Promise<TGetResultSetMetadataResp>;
+  private metadataPromise?: Promise<ResultMetadata>;
 
   constructor({ statement, context, id }: SeaOperationBackendOptions) {
     this.statement = statement;
@@ -148,7 +143,7 @@ export default class SeaOperationBackend implements IOperationBackend {
     return slicer.hasMore();
   }
 
-  public async getResultMetadata(): Promise<TGetResultSetMetadataResp> {
+  public async getResultMetadata(): Promise<ResultMetadata> {
     failIfNotActive(this.lifecycle);
     if (this.metadata) {
       return this.metadata;
@@ -162,15 +157,17 @@ export default class SeaOperationBackend implements IOperationBackend {
       }
       const arrowSchemaIpc = await this.statement.schema();
       const arrowSchema = decodeIpcSchema(arrowSchemaIpc.ipcBytes);
+      // `ResultMetadata.schema` keeps the Thrift `TTableSchema` shape for
+      // back-compat with the public `IOperation.getSchema()` surface.
       const thriftSchema: TTableSchema = arrowSchemaToThriftSchema(arrowSchema);
-      const meta: TGetResultSetMetadataResp = {
-        status: { statusCode: TStatusCode.SUCCESS_STATUS },
+      const meta: ResultMetadata = {
         schema: thriftSchema,
         // SEA inline + CloudFetch both surface to JS as Arrow batches;
-        // both flow through the same converter that handles the
-        // ARROW_BASED_SET path on the thrift side.
-        resultFormat: TSparkRowSetType.ARROW_BASED_SET,
+        // both flow through the same Arrow result converter.
+        resultFormat: ResultFormat.ArrowBased,
         lz4Compressed: false,
+        // Carry the raw Arrow IPC schema bytes for ARROW_BASED consumers.
+        arrowSchema: arrowSchemaIpc.ipcBytes,
         isStagingOperation: false,
       };
       this.metadata = meta;
@@ -187,30 +184,20 @@ export default class SeaOperationBackend implements IOperationBackend {
   // Status / lifecycle (owned by the sea-operation lifecycle helpers).
   // ---------------------------------------------------------------------------
 
-  public async status(_progress: boolean): Promise<TGetOperationStatusResp> {
-    // Synthesised — kernel only surfaces terminal-or-running statements
-    // through its public API; we report CANCELED/CLOSED if the lifecycle
-    // flag is set, else FINISHED. Matches the Thrift status shape so
-    // facade-level callers see consistent telemetry across backends.
+  public async status(_progress: boolean): Promise<OperationStatus> {
+    // Synthesised — the kernel resolves `Statement::execute().await` before
+    // it hands back a Statement handle, so by the time a SeaOperationBackend
+    // exists the statement is terminal. Report Cancelled/Closed if the
+    // lifecycle flag is set, else Succeeded. Returns the backend-neutral
+    // OperationStatus the IOperationBackend contract expects, so the
+    // DBSQLOperation facade switches on `state` identically across backends.
     if (this.lifecycle.isCancelled) {
-      return {
-        status: { statusCode: TStatusCode.SUCCESS_STATUS },
-        operationState: TOperationState.CANCELED_STATE,
-        hasResultSet: true,
-      };
+      return { state: OperationState.Cancelled, hasResultSet: true };
     }
     if (this.lifecycle.isClosed) {
-      return {
-        status: { statusCode: TStatusCode.SUCCESS_STATUS },
-        operationState: TOperationState.CLOSED_STATE,
-        hasResultSet: true,
-      };
+      return { state: OperationState.Closed, hasResultSet: true };
     }
-    return {
-      status: { statusCode: TStatusCode.SUCCESS_STATUS },
-      operationState: TOperationState.FINISHED_STATE,
-      hasResultSet: true,
-    };
+    return { state: OperationState.Succeeded, hasResultSet: true };
   }
 
   public async waitUntilReady(options?: {