@eliware/elera-lib 0.1.3 → 0.1.5

package/README.md

@@ -2,8 +2,9 @@
 
 The alternative SQL client for Eliware applications. It provides generic
 primary/balanced MySQL or MariaDB routing without embedding Elera, HAProxy,
-backup, or GitOps policy. It is a v0.1.3 alternative to `@eliware/mysql`; the
-existing package is intentionally unchanged.
+backup, or GitOps policy. It is a v0.1.5 alternative to `@eliware/mysql`; the
+existing package is intentionally unchanged. The current package version is
+0.1.5.
 
 `primary` is the preferred connection path. `balanced` is an optional alternate
 path. Both may accept writes; automatic routing sends only conservative,
@@ -26,12 +27,17 @@ accounts. Pool settings may be supplied with `MYSQL_CONNECT_TIMEOUT`,
 `MYSQL_SSL`. Configure primary and balanced routes explicitly; applications
 should not rely on ambiguous single-endpoint aliases.
 
+See examples/basic-client.mjs for a complete consumer example using only the
+public package API. Its usage notes are in examples/README.md.
+
 Routing bundles passed to `createDbFromBundle` use the normalized shape
 `routes.primary` and `routes.balanced`, each containing ordered `{ host, port,
-weight }` nodes. A bundle also carries `database`, `identity`, optional
-`credentials`, and `expiresAt`; `validateBundle` rejects expired or malformed
-route data. The checked-in contract fixture documents the supervisor-facing
-wire representation separately.
+weight }` nodes. A bundle may also carry an explicit `writer`, ordered
+`failover`, and `readers` assignment. The bundle carries `database`,
+`identity`, optional `credentials`, and `expiresAt`; `validateBundle` rejects
+expired, malformed, duplicated, or conflicting route data. The checked-in
+contract fixture documents the supervisor-facing wire representation
+separately.
 
 The implementation accepts optional routing bundles and injected credential
 providers, maintains bounded pools per route, supports ordered writer/reader
@@ -44,13 +50,13 @@ CLI commands. Applications provide those integrations through ordinary
 configuration and callbacks.
 
 When a route node is drained, the client immediately stops assigning new work
-to that node while existing operations continue. The default drain window is
-45 seconds and can be changed with `drainTimeoutMs`; remaining pool
-connections are then force-closed. `client.drain(host)` returns `wait()` and
-`forceClose()` operations, while `client.nodeStates()` exposes lifecycle and
-active-operation state. Only conservative, single-statement reads are eligible
-for automatic retry after a connection failure; uncertain writes are never
-retried automatically.
+to that node while existing operations continue. The drain window defaults to
+45 seconds and is capped at 45 seconds; remaining pool connections are then
+force-closed. `client.drain(host)` returns `wait()` and `forceClose()`
+operations, while `client.nodeStates()` exposes lifecycle and active-operation
+state. Only conservative, single-statement reads are eligible for automatic
+retry after a connection failure; uncertain writes are never retried
+automatically.
 
 The public client intentionally exposes SQL operations, health, routing,
 lifecycle, and optional routing-event synchronization methods. REST and
@@ -63,6 +69,12 @@ schema, account, and grant checks. Neither API transports or orchestrates dump
 contents. The stream reports `websocket`, `rest`, or `disconnected` mode so
 callers can observe transport health without implementing transport policy.
 
+Applications may opt into generic in-memory telemetry with
+`createDb({ ..., telemetry: true })`. Query counts, failures, retries,
+in-flight work, and latency are exposed through `client.telemetry` and sent
+over an attached routing stream once per second. Telemetry is observational
+only; it does not carry SQL or credentials.
+
 `createMaterializer` supports bounded plaintext use for a caller-provided
 operation. It creates a mode-restricted temporary file and removes its entire
 temporary directory in a `finally` block; this limits lifetime and cleanup but

package/RELEASE_NOTES.md

@@ -1,5 +1,65 @@
 # Release notes
 
+## 0.1.5 — Telemetry and convention alignment
+
+### Added
+
+- Adds opt-in generic in-memory client telemetry for query counts, failures,
+  retries, in-flight work, and latency.
+- Sends telemetry over an attached routing stream once per second without
+  sending SQL text or credentials.
+- Adds public TypeScript declarations and smoke coverage for the telemetry and
+  public client surface.
+- Uses Snowflake identifiers for non-security temporary materialization paths.
+
+### Refactored
+
+- Extracts telemetry timing into a focused client module.
+- Reorganizes `create-db` tests under the mirrored `tests/client/create-db/`
+  hierarchy while retaining a small cross-cutting contract test.
+
+### Validation
+
+- Tests pass with 100% statements, branches, functions, and lines coverage.
+- TypeScript typecheck passes with zero lint warnings.
+
+## 0.1.4 — Explicit writer and failover routing
+
+This release strengthens generic client-side routing for supervisor-provided
+bundles. Applications still use the public library API; supervisor and CLI
+policy remain outside the package.
+
+### Added
+
+- Supports explicit `writer`, ordered `failover`, and `readers` assignments in
+  routing bundles.
+- Replaces active writer and reader pools immediately when a valid routing
+  update arrives through WebSocket or REST resynchronization.
+- Keeps application clients independent so updating one application's bundle
+  does not change another client's assignment.
+- Selects the writer first and fails over in the supplied order when a node is
+  drained or explicitly unavailable.
+- Completes in-flight work during drain while excluding the node from new work.
+- Enforces a 45-second maximum client-side drain window.
+
+### Fixed and hardened
+
+- Compares numeric and string bundle versions numerically and rejects stale
+  updates, including versions such as `v10` versus `v9`.
+- Validates routing hosts, ports, weights, duplicate nodes, and writer/failover
+  overlap before pool creation.
+- Preserves explicit writer, failover, and reader assignments during stream
+  refreshes.
+
+### Validation
+
+- Adds integration-style coverage for pool replacement, per-client assignment
+  isolation, writer failover, in-flight drain behavior, version ordering,
+  WebSocket reconnect, and REST fallback.
+- Maintains 100% statements, branches, functions, and lines coverage with zero
+  lint warnings.
+- Diff validation passes.
+
 ## 0.1.3 — Client-side routing drain lifecycle
 
 This patch adds generic client-side handling for supervisor-published routing

package/examples/README.md

@@ -0,0 +1,13 @@
+# Elera library example
+
+basic-client.mjs is a minimal consumer application. It imports only the
+public @eliware/elera-lib package API, opens a bounded SQL client from
+environment configuration, performs a health check and query, and closes the
+client in a finally block.
+
+Run it from a published-package consumer project with:
+
+    MYSQL_PRIMARY_HOST=127.0.0.1 MYSQL_USER=app MYSQL_PASSWORD=secret MYSQL_DATABASE=app node examples/basic-client.mjs
+
+The example is intentionally infrastructure-neutral. It does not contain
+Docker, Kubernetes, Supervisor, CLI, Galera, or test-lab setup.

package/examples/basic-client.mjs

@@ -0,0 +1,14 @@
+import { createDbFromEnvironment } from '@eliware/elera-lib';
+
+// Set MYSQL_PRIMARY_HOST, MYSQL_USER, MYSQL_PASSWORD, and MYSQL_DATABASE
+// before running this example. The same public API works with a routing bundle.
+const db = await createDbFromEnvironment();
+
+try {
+  const health = await db.health('primary');
+  if (!health.ok) throw new Error('primary SQL route is not healthy');
+  const [rows] = await db.query('SELECT 1 AS healthy');
+  console.log(JSON.stringify({ health, rows }));
+} finally {
+  await db.close();
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@eliware/elera-lib",
-    "version": "0.1.3",
-    "description": "Generic MySQL and MariaDB client with resilient routing, client-side drains, and failover",
+    "version": "0.1.5",
+    "description": "Generic MySQL and MariaDB client with resilient routing, telemetry, client-side drains, and failover",
     "keywords": [
         "eliware",
         "elera",
@@ -11,6 +11,7 @@
         "database",
         "routing",
         "failover",
+        "telemetry",
         "websocket",
         "connection-pool"
     ],
@@ -35,6 +36,7 @@
     },
     "files": [
         "src",
+        "examples",
         "README.md",
         "RELEASE_NOTES.md",
         "LICENSE",
@@ -52,6 +54,7 @@
     },
     "dependencies": {
         "@eliware/common": "^2.0.0",
+        "@eliware/snowflake": "^2.0.0",
         "mysql2": "^3.24.2"
     },
     "devDependencies": {

package/src/bundle.mjs

@@ -1,13 +1,17 @@
+import { validateRoutingNode, validateRoutingNodes } from './routing/node-validation.mjs';
 const routes = ['primary', 'balanced'];
 
 export function validateBundle(bundle) {
   if (!bundle || typeof bundle !== 'object') throw new TypeError('routing bundle is required');
   if (!bundle.expiresAt || Number.isNaN(Date.parse(bundle.expiresAt))) throw new TypeError('routing bundle expiresAt is required');
+  const writer = bundle.writer !== undefined ? validateRoutingNode(bundle.writer, 'routing bundle writer') : undefined;
+  const failover = bundle.failover !== undefined ? validateRoutingNodes(bundle.failover, 'routing bundle failover') : [];
+  if (writer && failover.some((node) => node.host === writer.host && node.port === writer.port)) throw new TypeError('routing bundle failover duplicates writer');
+  if (bundle.readers !== undefined) validateRoutingNodes(bundle.readers, 'routing bundle readers');
   for (const route of routes) {
     if (bundle.routes?.[route] !== undefined && !Array.isArray(bundle.routes[route])) throw new TypeError(`bundle.routes.${route} must be an array`);
     for (const node of bundle.routes?.[route] ?? []) {
-      if (!node.host || !Number.isInteger(Number(node.port)) || Number(node.port) < 1 || Number(node.port) > 65535) throw new TypeError(`invalid ${route} bundle node`);
-      if (node.weight !== undefined && (!Number.isFinite(Number(node.weight)) || Number(node.weight) < 0)) throw new TypeError(`invalid ${route} bundle weight`);
+      validateRoutingNode(node, `routing bundle ${route} node`);
     }
   }
   return bundle;

package/src/client/bundle-profiles.mjs

@@ -0,0 +1,7 @@
+import { validateRoutingNode } from '../routing/node-validation.mjs';
+
+export function bundleProfiles(bundle, route, base) {
+  if (route === 'primary' && bundle.writer?.host) return [bundle.writer, ...(bundle.failover ?? [])].map((node, index) => { const valid = validateRoutingNode(node, `primary assignment[${index}]`); return { ...base, host: valid.host, port: valid.port, weight: valid.weight }; });
+  const nodes = route === 'balanced' && bundle.readers?.length ? bundle.readers : bundle.routes?.[route] ?? [];
+  return nodes.map((node) => { const valid = validateRoutingNode(node, `${route} route node`); return { ...base, host: valid.host, port: valid.port, weight: valid.weight }; });
+}

package/src/client/create-db.mjs

@@ -6,13 +6,14 @@ import { resolveCredentials, credentialContext } from '../credential-provider.mj
 import { validateBundle, bundleExpired, bundleNeedsRefresh } from '../bundle.mjs';
 import { createRouteFactory } from './route-factory.mjs';
 import { classifyQuery, routeFor } from '../routing.mjs';
+import { compareBundleVersions } from '../routing/bundle-version.mjs';
+import { clientDrainTimeout } from '../lifecycle/drain-policy.mjs';
+import { createTelemetry } from '../telemetry.mjs';
+import { createTimedOperation } from './telemetry-wrapper.mjs';
 
-const olderVersion = (candidate, current) => {
-  if (candidate === undefined || current === undefined) return false;
-  return String(candidate) < String(current);
-};
+const olderVersion = (candidate, current) => compareBundleVersions(candidate, current) < 0;
 
-export async function createDb({ primary, balanced, bundle, credentialProvider, mysqlLib = mysql, log = defaultLog, routing = 'auto', identity, quarantineMs = 5000, drainTimeoutMs = 45000, now = () => Date.now() } = {}) {
+export async function createDb({ primary, balanced, bundle, credentialProvider, mysqlLib = mysql, log = defaultLog, routing = 'auto', identity, quarantineMs = 5000, drainTimeoutMs = 45000, now = () => Date.now(), telemetry } = {}) {
   if (!primary || typeof primary !== 'object') throw new TypeError('primary connection profile is required');
   const credentials = await resolveCredentials(credentialProvider, credentialContext(primary, { identity }));
   let primaryConfig = validateProfile({ ...primary, ...credentials }, 'primary');
@@ -27,20 +28,22 @@ export async function createDb({ primary, balanced, bundle, credentialProvider,
   let primaryPool = makeRoute('primary', primaryConfig);
   let balancedPool = balancedConfig || activeBundle?.routes?.balanced ? makeRoute('balanced', balancedConfig ?? primaryConfig) : null;
   const choose = (sql, options = {}) => options.connection ?? (routeFor(sql, options.route ?? routing) === 'balanced' && balancedPool ? balancedPool : primaryPool);
+  const metrics = telemetry === true ? createTelemetry({ application: bundle?.application ?? identity ?? 'default', now }) : telemetry;
+  const timed = createTimedOperation({ metrics, now });
   const client = {
-    async query(sql, values, options) { const selected = choose(sql, options); try { return await selected.query(sql, values); } catch (error) { const requestedRoute = options?.route ?? routing; if (error.retryable && balancedPool && routeFor(sql, requestedRoute) === 'balanced' && classifyQuery(sql) === 'balanced') return balancedPool.query(sql, values); throw error; } },
+    async query(sql, values, options) { return timed(async () => { const selected = choose(sql, options); try { return await selected.query(sql, values); } catch (error) { const requestedRoute = options?.route ?? routing; if (error.retryable && balancedPool && routeFor(sql, requestedRoute) === 'balanced' && classifyQuery(sql) === 'balanced') { metrics?.record?.({ retry: true }); return balancedPool.query(sql, values); } throw error; } }); },
     async execute(sql, values, options) { return choose(sql, options).execute(sql, values); },
     async transaction(callback) { const node = primaryPool.choose(); const connection = await node.getConnection(); try { await connection.beginTransaction(); const tx = { query: (sql, values) => connection.query(sql, values), execute: (sql, values) => connection.execute(sql, values) }; const result = await callback(tx); await connection.commit(); return result; } catch (error) { await connection.rollback().catch(() => {}); throw asSqlError(error); } finally { connection.release(); } },
     async health(route = 'primary') { const started = now(); const selected = route === 'balanced' && balancedPool ? balancedPool : primaryPool; const nodes = await selected.health(); return { ok: nodes.some((node) => node.ok), route: selected === balancedPool ? 'balanced' : 'primary', nodes, latencyMs: now() - started }; },
-    async refresh(nextBundle) { const candidate = validateBundle(nextBundle); if (bundleExpired(candidate, now())) throw new Error('routing bundle is expired'); if (olderVersion(candidate.bundleVersion, activeBundle?.bundleVersion)) return { bundleVersion: activeBundle?.bundleVersion, refreshRequired: bundleNeedsRefresh(activeBundle, now()) }; const previous = [primaryPool, balancedPool]; const credentials = candidate.credentials ?? { username: primaryConfig.user, password: primaryConfig.password }; primaryConfig = validateProfile({ ...primaryConfig, host: candidate.routes.primary[0]?.host, port: candidate.routes.primary[0]?.port, user: credentials.username, password: credentials.password, database: candidate.database }, 'primary'); balancedConfig = candidate.routes.balanced?.[0] ? validateProfile({ ...primaryConfig, host: candidate.routes.balanced[0].host, port: candidate.routes.balanced[0].port }, 'balanced') : undefined; activeBundle = candidate; primaryPool = makeRoute('primary', primaryConfig); balancedPool = balancedConfig ? makeRoute('balanced', balancedConfig) : null; await Promise.all(previous.filter(Boolean).map((pool) => pool.close())); return { bundleVersion: activeBundle.bundleVersion ?? null, refreshRequired: bundleNeedsRefresh(activeBundle, now()) }; },
-    async attachRoutingStream(stream) { if (!stream?.connect) throw new TypeError('routing stream is required'); stream.setOnUpdate?.(async (event) => { const update = event.type === 'routing.update' ? event : event.type === 'routing.resync' ? event.bundle : undefined; if (update?.routes?.primary?.length) await client.refresh({ ...activeBundle, database: update.database ?? activeBundle?.database ?? primaryConfig.database, credentials: update.credentials ?? activeBundle?.credentials, routes: update.routes, bundleVersion: update.bundleVersion ?? update.version ?? activeBundle?.bundleVersion, expiresAt: update.expiresAt ?? activeBundle?.expiresAt ?? new Date(now() + 60000).toISOString() }); if (event.type === 'routing.drain' || event.type === 'routing.recovery') for (const pool of [primaryPool, balancedPool].filter(Boolean)) (event.type === 'routing.drain' ? pool.drain : pool.recover)(event.node, drainTimeoutMs); }); await stream.connect(); return () => stream.close?.(); },
-    drain(host, timeoutMs = drainTimeoutMs) { const pools = [primaryPool, balancedPool].filter(Boolean); pools.forEach((pool) => pool.drain(host, timeoutMs)); return { host, timeoutMs, wait: () => Promise.all(pools.map((pool) => pool.waitForIdle(timeoutMs))), forceClose: () => Promise.all(pools.map((pool) => pool.forceClose(host))) }; },
+    async refresh(nextBundle) { const candidate = validateBundle(nextBundle); if (bundleExpired(candidate, now())) throw new Error('routing bundle is expired'); if (olderVersion(candidate.bundleVersion, activeBundle?.bundleVersion)) return { bundleVersion: activeBundle?.bundleVersion, refreshRequired: bundleNeedsRefresh(activeBundle, now()) }; const previous = [primaryPool, balancedPool]; const credentials = candidate.credentials ?? { username: primaryConfig.user, password: primaryConfig.password }; const writer = candidate.writer ?? candidate.routes.primary?.[0]; const reader = candidate.readers?.[0] ?? candidate.routes.balanced?.[0]; primaryConfig = validateProfile({ ...primaryConfig, host: writer?.host, port: writer?.port, user: credentials.username, password: credentials.password, database: candidate.database }, 'primary'); balancedConfig = reader ? validateProfile({ ...primaryConfig, host: reader.host, port: reader.port }, 'balanced') : undefined; activeBundle = candidate; primaryPool = makeRoute('primary', primaryConfig); balancedPool = balancedConfig ? makeRoute('balanced', balancedConfig) : null; await Promise.all(previous.filter(Boolean).map((pool) => pool.close())); return { bundleVersion: activeBundle.bundleVersion ?? null, refreshRequired: bundleNeedsRefresh(activeBundle, now()) }; },
+    async attachRoutingStream(stream) { if (!stream?.connect) throw new TypeError('routing stream is required'); metrics?.start?.(stream); stream.setOnUpdate?.(async (event) => { const update = event.type === 'routing.update' ? event : event.type === 'routing.resync' ? event.bundle : undefined; if (update && (update.writer || update.routes?.primary?.length)) await client.refresh({ ...activeBundle, ...update, database: update.database ?? activeBundle?.database ?? primaryConfig.database, credentials: update.credentials ?? activeBundle?.credentials, routes: update.routes ?? activeBundle?.routes, bundleVersion: update.bundleVersion ?? update.version ?? activeBundle?.bundleVersion, expiresAt: update.expiresAt ?? activeBundle?.expiresAt ?? new Date(now() + 60000).toISOString() }); if (event.type === 'routing.drain' || event.type === 'routing.recovery') for (const pool of [primaryPool, balancedPool].filter(Boolean)) (event.type === 'routing.drain' ? pool.drain : pool.recover)(event.node, drainTimeoutMs); }); await stream.connect(); return () => stream.close?.(); },
+    drain(host, timeoutMs = drainTimeoutMs) { const effectiveTimeout = clientDrainTimeout(timeoutMs); const pools = [primaryPool, balancedPool].filter(Boolean); pools.forEach((pool) => pool.drain(host, effectiveTimeout)); return { host, timeoutMs: effectiveTimeout, wait: () => Promise.all(pools.map((pool) => pool.waitForIdle(effectiveTimeout))), forceClose: () => Promise.all(pools.map((pool) => pool.forceClose(host))) }; },
     nodeStates() { return [primaryPool, balancedPool].filter(Boolean).flatMap((pool) => pool.nodes.map((node) => ({ host: node.host, port: node.port, route: pool === primaryPool ? 'primary' : 'balanced', state: node.state, active: node.active, available: node.available }))); },
     setNodeAvailability(route, host, available) { const pool = route === 'balanced' ? balancedPool : primaryPool; pool?.setAvailability(host, available); },
     bundle: () => activeBundle,
-    async close() { await Promise.all([primaryPool.close(), balancedPool?.close()]); },
+    async close() { metrics?.stop?.(); await Promise.all([primaryPool.close(), balancedPool?.close()]); },
     classify: classifyQuery,
-    config: { primary: redactedProfile(primaryConfig), balanced: balancedConfig && redactedProfile(balancedConfig) }
+    telemetry: metrics, config: { primary: redactedProfile(primaryConfig), balanced: balancedConfig && redactedProfile(balancedConfig) }
   };
   log.debug?.('SQL client created', { balanced: Boolean(balancedPool), routing });
   return client;

package/src/client/route-factory.mjs

@@ -1,10 +1,6 @@
 import { bundleExpired } from '../bundle.mjs';
 import { createNodePool, createRoutePool } from '../pools.mjs';
-
-const bundleProfiles = (bundle, route, base) => {
-  const routes = bundle.routes?.[route] ?? [];
-  return routes.map((node) => ({ ...base, host: node.host, port: node.port, weight: node.weight }));
-};
+import { bundleProfiles } from './bundle-profiles.mjs';
 
 const routeProfiles = (bundle, route, fallback, now) => {
   if (!bundle) return [fallback];
@@ -14,5 +10,5 @@ const routeProfiles = (bundle, route, fallback, now) => {
 };
 
 export function createRouteFactory({ bundle, now, mysqlLib, log, quarantineMs }) {
-  return (route, fallback) => createRoutePool(routeProfiles(bundle, route, fallback, now).map((profile) => createNodePool({ profile, mysqlLib, log, now, quarantineMs })));
+  return (route, fallback) => createRoutePool(routeProfiles(bundle, route, fallback, now).map((profile) => createNodePool({ profile, mysqlLib, log, now, quarantineMs })), { preferred: route === 'primary' });
 }

package/src/client/telemetry-wrapper.mjs

@@ -0,0 +1,15 @@
+const emptyMetrics = { begin: () => undefined, record: () => {} };
+
+export function createTimedOperation({ metrics = emptyMetrics, now = () => Date.now() } = {}) {
+  return async function timed(operation) {
+    const started = metrics.begin();
+    try {
+      const result = await operation();
+      metrics.record({ latencyMs: started === undefined ? 0 : now() - started });
+      return result;
+    } catch (error) {
+      metrics.record({ latencyMs: started === undefined ? 0 : now() - started, failed: true });
+      throw error;
+    }
+  };
+}

package/src/index.d.ts

@@ -10,6 +10,7 @@ export interface ConnectionProfile {
 }
 
 export interface RoutingNode { host: string; port: number | string; weight?: number; }
+export interface WriterAssignment { host: string; port: number | string; }
 export interface RoutingBundle {
   apiVersion?: string;
   database?: string;
@@ -19,17 +20,22 @@ export interface RoutingBundle {
   expiresAt: string;
   refreshAfter?: string;
   routes: { primary?: RoutingNode[]; balanced?: RoutingNode[] };
+  writer?: WriterAssignment;
+  failover?: WriterAssignment[];
+  readers?: WriterAssignment[];
 }
 export interface CredentialProviderResult { user: string; password: string; }
 export type CredentialProvider = (context: { database: string; identity: string | null; route: string }) => Promise<CredentialProviderResult> | CredentialProviderResult;
 export type QueryFunction = (sql: string, values?: unknown) => Promise<any>;
 export interface DbOptions { route?: 'auto' | 'primary' | 'balanced'; connection?: unknown; }
+export interface TelemetrySnapshot { type: 'client.telemetry'; application: string; queries: number; failures: number; retries: number; reconnects: number; failoverCount: number; inflight: number; totalLatencyMs: number; maxLatencyMs: number; avgLatencyMs: number; sentAt: string; }
+export interface Telemetry { begin(): number; record(event?: { latencyMs?: number; failed?: boolean; retry?: boolean; reconnect?: boolean; failover?: boolean }): void; snapshot(): TelemetrySnapshot; start(stream: Pick<RoutingStream, 'sendTelemetry'>): void; stop(): void; }
 
 export interface DbClient {
   query(sql: string, values?: unknown, options?: DbOptions): Promise<unknown>;
   execute(sql: string, values?: unknown, options?: DbOptions): Promise<unknown>;
   transaction<T>(callback: (transaction: Pick<DbClient, 'query' | 'execute'>) => Promise<T>): Promise<T>;
-  health(route?: 'primary' | 'balanced'): Promise<{ ok: boolean; route: string; latencyMs: number }>;
+  health(route?: 'primary' | 'balanced'): Promise<{ ok: boolean; route: string; latencyMs: number; telemetry?: TelemetrySnapshot }>;
   close(): Promise<void>;
   refresh(bundle: RoutingBundle): Promise<{ bundleVersion: number | string | null; refreshRequired: boolean }>;
   bundle(): RoutingBundle | undefined;
@@ -39,17 +45,19 @@ export interface DbClient {
   drain(host: string, timeoutMs?: number): { host: string; timeoutMs: number; wait(): Promise<unknown[]>; forceClose(): Promise<unknown[]> };
   nodeStates(): Array<{ host: string; port: number; route: 'primary' | 'balanced'; state: 'ready' | 'draining' | 'unavailable' | 'recovering'; active: number; available: boolean }>;
   config: { primary: ConnectionProfile; balanced?: ConnectionProfile };
+  telemetry?: Telemetry;
 }
 
 export interface RoutingStream {
   connect(): Promise<void>;
   setOnUpdate(handler: (event: unknown) => void | Promise<void>): void;
   close(): void;
-  state(): { connected: boolean; mode: 'websocket' | 'rest' | 'disconnected'; expectedVersion: number };
+  sendTelemetry(payload: unknown): void;
+  state(): { connected: boolean; mode: 'websocket' | 'rest' | 'disconnected'; expectedVersion: number | string };
 }
 
-export function createDb(options: { primary: ConnectionProfile; balanced?: Partial<ConnectionProfile>; bundle?: RoutingBundle; credentialProvider?: CredentialProvider; identity?: string; mysqlLib?: unknown; log?: unknown; routing?: 'auto' | 'primary' | 'balanced'; quarantineMs?: number; drainTimeoutMs?: number; now?: () => number }): Promise<DbClient>;
-export function createDbFromEnvironment(options?: { env?: Record<string, string | undefined>; mysqlLib?: unknown; log?: unknown; routing?: 'auto' | 'primary' | 'balanced'; bundle?: RoutingBundle; credentialProvider?: CredentialProvider; identity?: string }): Promise<DbClient>;
+export function createDb(options: { primary: ConnectionProfile; balanced?: Partial<ConnectionProfile>; bundle?: RoutingBundle; credentialProvider?: CredentialProvider; identity?: string; mysqlLib?: unknown; log?: unknown; routing?: 'auto' | 'primary' | 'balanced'; quarantineMs?: number; drainTimeoutMs?: number; now?: () => number; telemetry?: true | Telemetry }): Promise<DbClient>;
+export function createDbFromEnvironment(options?: { env?: Record<string, string | undefined>; mysqlLib?: unknown; log?: unknown; routing?: 'auto' | 'primary' | 'balanced'; bundle?: RoutingBundle; credentialProvider?: CredentialProvider; identity?: string; telemetry?: true | Telemetry }): Promise<DbClient>;
 export function classifyQuery(sql: unknown): 'primary' | 'balanced';
 export function routeFor(sql: unknown, requested?: 'auto' | 'primary' | 'balanced'): 'primary' | 'balanced';
 export function validateProfile(profile: ConnectionProfile, name?: string): ConnectionProfile;
@@ -64,6 +72,12 @@ export function createAdminSql(options: { query: QueryFunction }): { transaction
 export function createMigrationRunner(options: { query: QueryFunction; migrations?: Array<{ version: number; name: string; statements: string[] }> }): { status(): Promise<{ applied: unknown[] }>; migrate(): Promise<unknown> };
 export function selectRouteNodes(options: { bundle: RoutingBundle; route?: 'primary' | 'balanced'; now?: number }): RoutingNode[];
 export function createRoutingStream(options: { endpoint: string; token?: string; application?: string; fetchBundle: (application: string) => Promise<RoutingBundle>; onUpdate?: (event: unknown) => void; onError?: (error: unknown) => void; reconnectMs?: number; maxReconnectMs?: number; heartbeatMs?: number }): RoutingStream;
+export function writerAssignment(bundle: RoutingBundle): WriterAssignment;
+export function failoverNodes(bundle: RoutingBundle): WriterAssignment[];
+export function compareBundleVersions(left: number | string | undefined, right: number | string | undefined): number;
+export const CLIENT_DRAIN_TIMEOUT_MS: 45000;
+export function clientDrainTimeout(timeoutMs?: number): number;
 export function createQuiesceController(options?: { close?: () => Promise<void>; onChange?: (state: string) => void }): { state(): { state: string; active: number }; enter(): () => void; begin(): Promise<void>; end(): Promise<void>; close(): Promise<void> };
 export function createSqlVerifier(options: { query: QueryFunction }): { connectivity(): Promise<{ verified: boolean }>; schema(database: string): Promise<{ database: string; verified: boolean }>; account(user: string, host?: string): Promise<{ user: string; host: string; verified: boolean; grants: string[] }>; all(options?: { database?: string; user?: string; host?: string }): Promise<unknown> };
 export function createMaterializer(options?: Record<string, unknown>): unknown;
+export function createTelemetry(options?: { application?: string; intervalMs?: number; now?: () => number; setIntervalImpl?: typeof setInterval; clearIntervalImpl?: typeof clearInterval }): Telemetry;

package/src/index.mjs

@@ -9,6 +9,10 @@ export { createAdminSql } from './admin/sql.mjs';
 export { createMigrationRunner } from './admin/migrations.mjs';
 export { selectRouteNodes } from './routing/node-set.mjs';
 export { createRoutingStream } from './routing/stream-client.mjs';
+export { writerAssignment, failoverNodes } from './routing/assignment.mjs';
+export { compareBundleVersions } from './routing/bundle-version.mjs';
+export { CLIENT_DRAIN_TIMEOUT_MS, clientDrainTimeout } from './lifecycle/drain-policy.mjs';
 export { createQuiesceController } from './lifecycle/quiesce.mjs';
 export { createSqlVerifier } from './verification/sql.mjs';
 export { createMaterializer } from './lifecycle/materializer.mjs';
+export { createTelemetry } from './telemetry.mjs';

package/src/lifecycle/drain-policy.mjs

@@ -0,0 +1,7 @@
+export const CLIENT_DRAIN_TIMEOUT_MS = 45000;
+
+export function clientDrainTimeout(timeoutMs = CLIENT_DRAIN_TIMEOUT_MS) {
+  const requested = Number(timeoutMs);
+  if (!Number.isFinite(requested) || requested < 0) throw new TypeError('drain timeout must be a non-negative number');
+  return Math.min(requested, CLIENT_DRAIN_TIMEOUT_MS);
+}

package/src/lifecycle/materializer.mjs

@@ -1,9 +1,9 @@
-import { randomUUID } from "node:crypto";
+import { generate as generateSnowflake } from "@eliware/snowflake";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-export function createMaterializer({ makeTemp = mkdtemp, write = writeFile, remove = rm, id = randomUUID } = {}) {
+export function createMaterializer({ makeTemp = mkdtemp, write = writeFile, remove = rm, id = generateSnowflake } = {}) {
   return {
     async withFile(content, operation) {
       if (typeof operation !== "function") throw new TypeError("materializer operation is required");

package/src/pools/route-pool.mjs

@@ -1,9 +1,10 @@
-export function createRoutePool(nodes) {
+export function createRoutePool(nodes, { preferred = false } = {}) {
   let cursor = 0;
   const candidates = () => nodes.filter((node) => node.available);
   const choose = () => {
     const available = candidates();
     if (!available.length) throw new Error('no eligible SQL nodes available');
+    if (preferred) return available[0];
     const total = available.reduce((sum, node) => sum + Math.max(0, node.weight), 0);
     if (!total) return available[cursor++ % available.length];
     let target = cursor++ % total;

package/src/routing/assignment.mjs

@@ -0,0 +1,9 @@
+export function writerAssignment(bundle) {
+  if (!bundle?.writer?.host) throw new TypeError('routing bundle writer is required');
+  return { host: bundle.writer.host, port: Number(bundle.writer.port ?? 3306) };
+}
+
+export function failoverNodes(bundle) {
+  if (!Array.isArray(bundle?.failover)) throw new TypeError('routing bundle failover is required');
+  return bundle.failover.map(({ host, port = 3306 }) => ({ host, port: Number(port) }));
+}

package/src/routing/bundle-version.mjs

@@ -0,0 +1,11 @@
+export function compareBundleVersions(left, right) {
+  if (left === undefined || right === undefined) return 0;
+  const a = String(left).match(/\d+/g)?.map(Number);
+  const b = String(right).match(/\d+/g)?.map(Number);
+  if (!a || !b) return String(left).localeCompare(String(right));
+  for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+    const difference = (a[index] ?? 0) - (b[index] ?? 0);
+    if (difference) return Math.sign(difference);
+  }
+  return 0;
+}

package/src/routing/node-validation.mjs

@@ -0,0 +1,14 @@
+export function validateRoutingNode(node, name = 'routing node') {
+  if (!node || typeof node !== 'object' || typeof node.host !== 'string' || node.host.trim() === '') throw new TypeError(`${name} host is required`);
+  const port = Number(node.port ?? 3306);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new TypeError(`${name} port is invalid`);
+  if (node.weight !== undefined && (!Number.isFinite(Number(node.weight)) || Number(node.weight) < 0)) throw new TypeError(`${name} weight is invalid`);
+  return { ...node, host: node.host.trim(), port };
+}
+
+export function validateRoutingNodes(nodes, name) {
+  if (!Array.isArray(nodes)) throw new TypeError(`${name} must be an array`);
+  const validated = nodes.map((node, index) => validateRoutingNode(node, `${name}[${index}]`));
+  if (new Set(validated.map(({ host, port }) => `${host}:${port}`)).size !== validated.length) throw new TypeError(`${name} contains duplicate nodes`);
+  return validated;
+}

package/src/routing/stream-client.mjs

@@ -1,4 +1,5 @@
 import { log as defaultLog } from '@eliware/common';
+import { compareBundleVersions } from './bundle-version.mjs';
 
 export function createRoutingStream({ endpoint, token, application = 'default', fetchBundle, WebSocketImpl = globalThis.WebSocket, onUpdate, onError, reconnectMs = 1000, maxReconnectMs = 30000, heartbeatMs = 45000, now = () => Date.now() } = {}) {
   if (!endpoint || typeof fetchBundle !== 'function') throw new TypeError('endpoint and fetchBundle are required');
@@ -14,15 +15,17 @@ export function createRoutingStream({ endpoint, token, application = 'default',
       socket.onopen = () => { mode = 'websocket'; delay = reconnectMs; heartbeat = setInterval(() => socket?.send?.(JSON.stringify({ type: 'heartbeat', sentAt: now() })), heartbeatMs); };
       socket.onmessage = async ({ data }) => {
         try {
-          const event = JSON.parse(data); const version = Number(event.version ?? 0);
-          if (version && expectedVersion && version <= expectedVersion) return;
-          if (expectedVersion && version > expectedVersion + 1) await fallback();
-          expectedVersion = Math.max(expectedVersion, version); updateHandler?.(event);
+          const event = JSON.parse(data); const version = event.version;
+          if (version !== undefined && expectedVersion !== 0 && compareBundleVersions(version, expectedVersion) <= 0) return;
+          const numericVersion = Number(version); const numericExpected = Number(expectedVersion);
+          if (Number.isInteger(numericVersion) && Number.isInteger(numericExpected) && numericExpected > 0 && numericVersion > numericExpected + 1) await fallback();
+          if (version !== undefined && (expectedVersion === 0 || compareBundleVersions(version, expectedVersion) > 0)) expectedVersion = version;
+          updateHandler?.(event);
         } catch (error) { onError?.(error); }
       };
       socket.onerror = (error) => { onError?.(error); };
       socket.onclose = () => { clearInterval(heartbeat); heartbeat = undefined; socket = undefined; mode = 'disconnected'; if (!closed) { void fallback(); schedule(); } };
     } catch (error) { mode = 'disconnected'; onError?.(error); await fallback(); schedule(); }
   }
-  return { connect, setOnUpdate: (handler) => { updateHandler = handler; }, close: () => { closed = true; mode = 'disconnected'; clearTimeout(timer); clearInterval(heartbeat); socket?.close?.(); }, state: () => ({ connected: socket?.readyState === 1, mode, expectedVersion }) };
+  return { connect, sendTelemetry: (payload) => { if (socket?.readyState === 1) socket.send(JSON.stringify(payload)); }, setOnUpdate: (handler) => { updateHandler = handler; }, close: () => { closed = true; mode = 'disconnected'; clearTimeout(timer); clearInterval(heartbeat); socket?.close?.(); }, state: () => ({ connected: socket?.readyState === 1, mode, expectedVersion }) };
 }

package/src/telemetry.mjs

@@ -0,0 +1,8 @@
+export function createTelemetry({ application = 'default', intervalMs = 1000, now = () => Date.now(), setIntervalImpl = setInterval, clearIntervalImpl = clearInterval } = {}) {
+  const stats = { queries: 0, failures: 0, retries: 0, reconnects: 0, failoverCount: 0, inflight: 0, totalLatencyMs: 0, maxLatencyMs: 0 };
+  let timer;
+  const begin = () => { stats.inflight += 1; return now(); };
+  const record = ({ latencyMs = 0, failed = false, retry = false, reconnect = false, failover = false } = {}) => { stats.queries += 1; stats.inflight = Math.max(0, stats.inflight - 1); stats.totalLatencyMs += latencyMs; stats.maxLatencyMs = Math.max(stats.maxLatencyMs, latencyMs); if (failed) stats.failures += 1; if (retry) stats.retries += 1; if (reconnect) stats.reconnects += 1; if (failover) stats.failoverCount += 1; };
+  const snapshot = () => ({ type: 'client.telemetry', application, ...stats, avgLatencyMs: stats.queries ? stats.totalLatencyMs / stats.queries : 0, sentAt: new Date(now()).toISOString() });
+  return { begin, record, snapshot, start(stream) { if (timer) return; timer = setIntervalImpl(() => stream.sendTelemetry?.(snapshot()), intervalMs); timer.unref?.(); }, stop() { if (timer) clearIntervalImpl(timer); timer = undefined; } };
+}