[SEA-NodeJS] Sync execute via directResults: fix CREATE, drop close-drives, keep mid-run cancel

The default sync path now calls the kernel's folded directResults `execute()`
(`Connection.executeStatement`), which returns a SINGLE `AsyncStatement` handle.
The session wraps it with the operation backend's existing `asyncStatement` arm —
no arm to feature-detect.

The returned handle always corresponds to a server-owned statement:
  - fire-and-forget `CREATE`/`INSERT` commits (the server runs it inline during
    the POST) — fixes the prior lazy-execute "CREATE didn't run" bug;
  - `close()` is a clean release, never a drive-to-terminal — the eager-handle +
    close-drives workaround is gone;
  - a long query is cancellable via `op.cancel()` (`asyncStatement.cancel()`)
    once the handle is held (~80-300ms), at parity with the Thrift backend;
  - errors surface at `executeStatement`, matching Thrift / Python use_kernel.

On the fast path the kernel handle is seeded with the inline result, so the
first fetch/status is served with zero extra round-trips (and is 404-proof — a
terminal handle never polls a released statement). A warehouse that auto-closes
the statement (`state=CLOSED`) after delivering its inline result is handled by
the kernel mapping `CLOSED -> Succeeded`, so this path no longer throws
`OperationStateError(Closed)` on those warehouses.

Requires the kernel folded directResults execute
(databricks/databricks-sql-kernel#136). Regenerated napi router types
(`executeStatement` now returns `AsyncStatement`); fallback package names stay on
the driver's canonical `@databricks/sql-kernel-*`.

Validated e2e (pecotesting) against auto-closing AND non-auto-closing warehouses:
CREATE fire-and-forget commits (12/12 = Thrift parity), fetch-then-close (12/12),
mid-run cancel, close() cheap (~140ms) on an abandoned long query, SELECT 1 p50
179ms vs Thrift 168ms. Unit: SEA suite 247 passing; eslint clean.

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

Author: msrathore-db

lib/sea/SeaSessionBackend.ts

@@ -183,24 +183,31 @@ export default class SeaSessionBackend implements ISessionBackend {
       options.queryTimeout !== undefined ? numberToInt64(options.queryTimeout).toNumber() : undefined;
 
     if (!runAsync) {
-      // Sync path: forward `queryTimeoutSecs` to the napi options — the kernel
-      // `execute()` honours it (server statement timeout).
+      // DEFAULT — directResults (the Thrift / JDBC / Python use_sea model). The
+      // kernel sends ExecuteStatement with the server inline wait (~10s default
+      // + on_wait_timeout=CONTINUE) and returns WITHOUT polling past it, as a
+      // single `AsyncStatement` handle:
+      //   - a fast query comes back seeded with the inline result, so the first
+      //     fetch/status is served with zero extra round-trips (and is
+      //     404-proof — a terminal handle never polls a released statement);
+      //   - a slow query comes back as a poll/cancel handle.
+      // Either way the handle is tied to a server-owned statement, so a long
+      // query stays cancellable (`asyncStatement.cancel()`) and `close()` is a
+      // clean release — no eager-handle / close-drives workaround. Fire-and-
+      // forget DDL/DML commits because the server runs it inline during the POST.
       const execOptions = this.buildExecuteOptions(options, queryTimeoutSecs);
-      let cancellableExecution;
+      let asyncStatement;
       try {
-        cancellableExecution =
+        asyncStatement =
           execOptions === undefined
-            ? await this.connection.executeStatementCancellable(statement)
-            : await this.connection.executeStatementCancellable(statement, execOptions);
+            ? await this.connection.executeStatement(statement)
+            : await this.connection.executeStatement(statement, execOptions);
       } catch (err) {
         throw this.logAndMapError('executeStatement', err);
       }
       return new SeaOperationBackend({
-        cancellableExecution: cancellableExecution!,
+        asyncStatement,
         context: this.context,
-        // The kernel honours `queryTimeoutSecs` on the sync `execute` path, so
-        // it is forwarded via the napi options (see `buildExecuteOptions`); the
-        // backend also keeps it as a deadline guard for parity with async.
         queryTimeoutSecs,
       });
     }

native/sea/index.d.ts

@@ -210,28 +210,32 @@ class FakeNativeConnection implements SeaConnection {
   // sync `runAsync: false` query path — the DEFAULT).
   public lastCancellableExecution?: FakeCancellableExecution;
 
-  // The bare blocking executeStatement path: the SEA backend's sync default
-  // routes through executeStatementCancellable (below), but the binding still
-  // exposes this for completeness.
-  public async executeStatement(sql: string, options?: unknown): Promise<SeaStatement> {
+  // Sync (`runAsync: false`) cancellable query path (retained for the
+  // executeStatementCancellable binding; the default execute path is the
+  // directResults `executeStatement` below).
+  public async executeStatementCancellable(sql: string, options?: unknown): Promise<any> {
     if (this.throwOnExecute) {
       throw this.throwOnExecute;
     }
     this.lastSql = sql;
     this.lastOptions = options;
-    return this.statementToReturn;
+    this.lastCancellableExecution = new FakeCancellableExecution();
+    return this.lastCancellableExecution;
   }
 
-  // Sync (`runAsync: false`, the DEFAULT) query path: records sql + options and
-  // returns a pending CancellableExecution whose result() drives the execute.
-  public async executeStatementCancellable(sql: string, options?: unknown): Promise<any> {
+  // directResults (`runAsync: false`, the DEFAULT) query path: records sql +
+  // options and returns a single `AsyncStatement` handle — the kernel `execute()`
+  // sends the inline-wait POST and returns one handle (seeded with the inline
+  // result on the fast path, a poll/cancel handle otherwise). `submitStatusValue`
+  // configures the state it reports.
+  public async executeStatement(sql: string, options?: unknown): Promise<any> {
     if (this.throwOnExecute) {
       throw this.throwOnExecute;
     }
     this.lastSql = sql;
     this.lastOptions = options;
-    this.lastCancellableExecution = new FakeCancellableExecution();
-    return this.lastCancellableExecution;
+    this.lastAsyncStatement = new FakeAsyncStatement(this.submitStatusValue);
+    return this.lastAsyncStatement;
   }
 
   // Async-submit path: records sql + per-statement options (for forwarding