[SEA-NodeJS] SEA async execute, TLS & connection/statement options

[msrathore-db]

Stacked on #412 (params + metadata + getInfo). Review/merge #412 first; this PR retargets to main once #412 lands.

Consolidates the remaining SEA features into one PR (two commits), each a thin layer over the merged kernel.

Commit 1 — connection & statement options

Connection options (SeaAuth.buildSeaConnectionOptions):

• maxConnections → kernel pool size (validated positive-integer, u32 range).
• TLS: checkServerCertificate (secure-by-default — omit to keep the kernel's verify-on default; false opts into insecure) and customCaCert (PEM string or Buffer; strings PEM-sanity-checked and normalised to a Buffer), via the new buildSeaTlsOptions.
• intervalsAsString: true always set (byte-compatible interval rendering vs Thrift); complexTypesAsJson left at the kernel's native-Arrow default.

Statement options (SeaSessionBackend, via buildExecuteOptions):

• queryTimeout → queryTimeoutSecs; rowLimit → rowLimit (SEA-only cap).
• queryTags serialised (reusing Thrift's serializeQueryTags) into the reserved query_tags conf key, merged with explicit statementConf. queryTags/queryTimeout no longer rejected.
• Still rejected (genuinely unsupported): useCloudFetch, useLZ4Compression, stagingAllowedLocalPath.

Commit 2 — async execute

Switches the query path from blocking executeStatement to the kernel's async submitStatement (matching Thrift's always-async model). SeaOperationBackend becomes dual-mode:

• Query path (asyncStatement): waitUntilReady() polls status() to terminal (100ms cadence), firing the progress callback each tick. Polling rather than blocking on awaitResult() keeps cancel() responsive. On Succeeded it materialises the result handle; on Failed it surfaces the kernel's typed SQL-error envelope via awaitResult(); on Cancelled/Closed it throws clearly. status() reports the real state.
• Metadata path (statement): already-terminal kernel statement; waitUntilReady() stays a one-shot tick.

The fetch pipeline is shared — AsyncResultHandle and the metadata Statement expose the same fetchNextBatch()/schema() surface, consumed via a single memoised fetch handle.

Testing

• Full unit suite green (1140 passing); lib/ lints clean. New unit coverage: TLS/maxConnections validation (connectionOptions.test.ts), statement-option forwarding, and the async lifecycle (poll-to-terminal, real status, Failed→error, server-side Cancelled, cancel-responsiveness).
• Validated against a live warehouse: secure-by-default connect, maxConnections, checkServerCertificate, rowLimit (caps rows), queryTimeout, queryTags, statementConf, non-PEM customCaCert rejection; async fetchAll correctness, 5000-row drain, long-running aggregate over 20M, kernel SQL-error surfacing, and cancellation mid-execution. PR1's params/metadata/getInfo all still pass through the new async path.

This pull request and its description were written by Isaac.

[gopalldb]

🟠 P1 (Important — should fix)

1. queryTimeout is accepted, computed, then silently dropped on the submit path — SeaSessionBackend.ts (buildExecuteOptions, ~710-712). executeStatement now routes through connection.submitStatement(...),
   and per the napi contract queryTimeoutSecs is ignored on submit (submit always sends wait_timeout=0s). The code still sets and forwards it, so a caller setting queryTimeout: 30 gets no server-side timeout —
   the statement can run unbounded. Worse, the prior code rejected queryTimeout with an explicit "deferred" error; this PR makes it a silent no-op. The unit test asserts only JS-side field wiring (the fake
   doesn't model the submit carve-out), giving false confidence. → drop the kernel-ignored field and document SEA query-timeout as caller-driven (Promise.race over waitUntilReady), or implement a client-side
   timeout. Don't silently forward a field the kernel discards.
2. Number(options.queryTimeout) mishandles Int64 inputs — same file, ~711. queryTimeout is typed number | bigint | Int64; the Thrift backend uses numberToInt64(...), but here Number(node-int64 instance)
   yields NaN (node-int64 has toNumber(), no numeric valueOf). Latent today (the field is dropped per P1#1) but a real coercion bug if ever used. → use numberToInt64(...).toNumber().

🟡 P2 (Minor)

• checkServerCertificate inverts Thrift's rejectUnauthorized polarity — InternalConnectionOptions.ts:40-54. Safer direction (SEA defaults secure), but a user migrating Thrift config by analogy could expect
  the opposite. Also these options live only on InternalConnectionOptions and are read via as casts — end users have no typed/published way to discover them. → when SEA goes public, document the polarity
  inversion and surface the options on the public ConnectionOptions.
• maxConnections validation — correct. Rejects NaN/Infinity/floats/<1/>0xffffffff via typed HiveDriverError; 0 intentionally rejected; napi default (100) when omitted. Tests cover 0/-1/1.5/overflow. No
  issue.
• Async poll loop unbounded — SeaOperationBackend.ts (waitUntilReadyAsync, ~471-510). for(;;) exits only on terminal state or JS-side cancel/close; no max-poll/deadline cap. Matches Thrift's unbounded loop
  and cancel stays responsive (lock-free, next-iteration failIfNotActive short-circuits). → consider honoring an overall deadline so a wedged server doesn't hang a caller that didn't wrap in Promise.race. Not
  blocking.
• Memoized rejected fetch promise — intended (a failed result is permanently failed); typed error surfaced via the Failed arm; no use-after-free.