diff --git a/di/serverselect/init.q b/di/serverselect/init.q
new file mode 100644
index 00000000..135b1e20
--- /dev/null
+++ b/di/serverselect/init.q
@@ -0,0 +1,10 @@
+\l ::serverselect.q
+
+/ logging is an injected dependency: the start-up script that wires the modules together -
+/ or the user at run time - must call init with a required `log dependency before using the
+/ module. kx.log is intentionally NOT loaded here.
+/ note: the injected log dict is stored in .z.m.log and called as .z.m.log[`info][`ctx;"msg"]
+
+export:([init;
+  addserverfull;addserverattr;addserver;setserveractive;getserverstable;addserversfromtable;
+  getservers;selector;getserverbytype;gethandlebytype;gethpbytype;getserverids])
diff --git a/di/serverselect/integration.q b/di/serverselect/integration.q
new file mode 100644
index 00000000..1975277a
--- /dev/null
+++ b/di/serverselect/integration.q
@@ -0,0 +1,271 @@
+/ ===========================================================================
+/ di.serverselect integration test (real processes)
+/ Spawns child q listeners, opens REAL IPC handles to them, and drives every
+/ exported function through a realistic gateway lifecycle - register ->
+/ query -> select -> route a live query to the chosen handle -> bulk-register
+/ -> disconnect -> error handling -> init. Unlike a simulated test, the
+/ selection functions hand back handles that are actually queried, so the
+/ assertions prove queries reach the expected backend process.
+/ .
+/ Self-contained: no helper files. The child backends are bare `q` listeners
+/ whose identity (`whoami`) and `ping` api are injected over IPC at setup; the
+/ test launches and tears them down itself.
+/ .
+/ Requirements:
+/   - run THIS script with KDB-X q (needs `use`)
+/   - a q on PATH (override with $QBIN) to launch the child listeners
+/   - some free TCP ports: the test scans for free ports from a pid-derived
+/     base (so concurrent runs don't collide); set $SSPORT to pin the base
+/ Run (QPATH must include this repo and the kx module dir):
+/   QPATH=/path/to/kx/mod:/path/to/kdbx-modules <kdbx>/q integration.q
+/ Exits with a non-zero code equal to the number of failed assertions.
+/ ===========================================================================
+
+srvsel:use`di.serverselect;
+
+/ ---- tiny assertion harness ----
+/ note: avoid `desc`/`exp`/`log` as names - they are reserved words in KDB-X
+PASS:0; FAIL:0;
+lbl:{[ok] $[ok;"  ok   | ";"  FAIL | "]};
+chk:{[nm;got;expd]
+  ok:got~expd;
+  $[ok;PASS+:1;FAIL+:1];
+  m:lbl[ok],nm;
+  if[not ok; m:m," || got=",(.Q.s1 got),"  exp=",.Q.s1 expd];
+  -1 m;
+  };
+errtok:`$"__ERRORED__";
+chkerr:{[nm;f]
+  r:@[f;();{[e](errtok;e)}];
+  ok:(0<count r) and errtok~first r;
+  $[ok;PASS+:1;FAIL+:1];
+  m:lbl[ok],nm;
+  m:m,$[ok;" || signalled: ",(r 1);" || NO ERROR raised, got=",.Q.s1 r];
+  -1 m;
+  };
+hdr:{[t] -1""; -1"==== ",t," ===="; };
+
+d1:2024.01.01; d2:2024.01.02; d3:2024.01.03;
+
+/ ---- child-process management ----
+qbin:$[0<count s:getenv`QBIN; s; "q"];
+/ fleet: 0,1 rdb | 2,3 hdb (attr) | 4 gateway | 5,6 bulk-registered rdb/hdb
+names:`rdb1`rdb2`hdb1`hdb2`gw1`rdb3`hdb3;
+pids:`int$();
+
+/ no hardcoded ports: derive a starting point from this pid (so concurrent runs
+/ on a shared host don't collide) - or take an explicit base from $SSPORT - then
+/ scan upward for ports that are actually free. nothing assumes a fixed port.
+/ probe whether a localhost port is in use: a free port refuses instantly, so this short
+/ timeout only bounds the wait for a filtered (silently-dropped) port - keep it small so a
+/ full scan of 10*count names candidates cannot stall for many seconds
+inuse:{[p] @[{hclose hopen x; 1b}; (`$":localhost:",string p;50); 0b]};
+baseport:$[0<count s:getenv`SSPORT; "I"$s; 20000+`int$.z.i mod 20000];
+findfree:{[start;n]
+  / take the first n free ports from a generous candidate window above start
+  cand:start+til 10*n;
+  free:cand where not inuse each cand;
+  if[n>count free;
+    '"could not find ",string[n]," free ports scanning up from ",string start];
+  :n#free;
+  };
+ports:findfree[baseport;count names];
+
+launch:{[port]
+  / start a bare q listener detached and capture its shell background pid ($!) - so every
+  / child can be reaped by exact pid later, whether or not we ever connect to it, and with
+  / no dependence on the qbin path (identity/api are injected over IPC once connected)
+  :"I"$first system qbin," -p ",string[port]," -q </dev/null >/dev/null 2>&1 & echo $!";
+  };
+
+connect:{[port]
+  / open a handle, retrying for up to ~10s while the child binds and accepts
+  hp:`$":localhost:",string port;
+  step:{[hp;h] if[not null h; :h]; system"sleep 0.2"; @[hopen;(hp;500);{0Ni}]}[hp];
+  :50 step/ 0Ni;
+  };
+
+teardown:{[]
+  / always-run cleanup. kill every launched child by its captured pid (exact). the pkill
+  / fallback is a last resort for the rare case a pid was never captured - keyed on our own
+  / unique port and -q flag (NOT the qbin path, which is configurable), so a custom qbin
+  / cannot break it. the [-]p bracket keeps the pattern from matching this very kill command.
+  live:pids where not null pids;
+  if[count live; @[system;"kill ",(" " sv string live)," 2>/dev/null; true";{}]];
+  {@[system;"pkill -f \"[-]p ",string[x]," -q\" 2>/dev/null; true";{}]} each ports;
+  @[hclose;;{}] each handles where not null handles;
+  };
+
+/ launch the fleet (capturing each child's shell pid for exact-pid teardown), then connect
+-1 "selected free ports: ",.Q.s1 ports;
+pids:launch each ports;
+handles:connect each ports;
+/ guarantee the fleet is reaped on ANY exit (normal, error-abort, or exit code)
+.z.exit:{teardown[]};
+if[any null handles;
+  -2 "failed to connect to child processes on ports: ",(" " sv string ports where null handles);
+  exit 3];
+/ inject each backend's identity + ping api over IPC
+{[h;nm] h "whoami:`",string nm; h "ping:{whoami}";}'[handles;names];
+-1 "spawned ",(string count handles)," backend processes; real handles: ",.Q.s1 handles;
+
+/ route: select a server of type t via strategy sel, then SEND ping[] over the chosen handle
+route:{[t;sel] h:srvsel.gethandlebytype[t;sel]; $[()~h; `NONE; h "ping[]"]};
+/ map serverids -> their handles (to route attribute-path selections)
+sidhandles:{[sids] exec handle from srvsel.getserverstable[] where serverid in sids};
+/ the gateway's host/port for the hpup column - its real (dynamically chosen) address
+gwhp:`$":localhost:",string ports 4;
+
+/ test steps run at top level (a single enclosing function would exceed q's
+/ per-function constant limit). chk/chkerr trap their own assertion failures;
+/ .z.exit guarantees teardown regardless of how the script ends.
+
+/ init must be called before use (log is a required injected dependency, no default)
+srvsel.init[enlist[`log]!enlist `info`warn`error!({[c;m]};{[c;m]};{[c;m]})];
+
+/ =========================================================================
+hdr"STEP 1  initial empty state";
+chk["fresh module: server table empty";0=count srvsel.getserverstable[];1b];
+chk["schema columns correct";`serverid`handle`procname`servertype`hpup`active`lastp`hits`attributes;cols srvsel.getserverstable[]];
+
+/ =========================================================================
+hdr"STEP 2  registration of live handles (addserver / addserverattr / addserverfull)";
+srvsel.addserver[handles 0;`rdb];
+srvsel.addserver[handles 1;`rdb];
+srvsel.addserverattr[handles 2;`hdb;`date`sym!((d1;d2);`A`B)];
+srvsel.addserverattr[handles 3;`hdb;`date`sym!((d2;d3);`B`C)];
+srvsel.addserverfull[handles 4;`gw1;`gateway;gwhp;(enlist`region)!enlist`EU];
+chk["five servers registered";5=count srvsel.getserverstable[];1b];
+chk["serverids autoincrement 1..5";1 2 3 4 5i;exec serverid from srvsel.getserverstable[]];
+chk["handles stored are the real open handles";handles til 5;exec handle from srvsel.getserverstable[]];
+chk["servertypes as registered";`rdb`rdb`hdb`hdb`gateway;exec servertype from srvsel.getserverstable[]];
+chk["addserverfull populated procname";`gw1;first exec procname from srvsel.getserverstable[] where servertype=`gateway];
+chk["addserverfull populated hpup";gwhp;first exec hpup from srvsel.getserverstable[] where servertype=`gateway];
+chk["addserver -> empty attributes";(()!());first exec attributes from srvsel.getserverstable[] where handle=handles 0];
+chk["all active by default";1b;all exec active from srvsel.getserverstable[]];
+
+/ =========================================================================
+hdr"STEP 3  getservers (lookup + attribute match scoring)";
+chk["lookups=` returns all active";5;count srvsel.getservers[`;`;()!()]];
+chk["servertype=hdb returns 2";2;count srvsel.getservers[`servertype;`hdb;()!()]];
+chk["servertype list rdb,hdb returns 4";4;count srvsel.getservers[`servertype;`rdb`hdb;()!()]];
+chk["procname=gw1 returns the gateway handle";enlist handles 4;exec handle from srvsel.getservers[`procname;`gw1;()!()]];
+chk["unknown servertype returns empty";0;count srvsel.getservers[`servertype;`nope;()!()]];
+chk["attribmatch column present";1b;`attribmatch in cols srvsel.getservers[`;`;()!()]];
+chk["complete date match flagged for some hdb on d1";1b;
+  any {x[`date]0} each (srvsel.getservers[`servertype;`hdb;(enlist`date)!enlist enlist d1])`attribmatch];
+
+/ =========================================================================
+hdr"STEP 4  selector (strategies on a known table)";
+seltab:([]serverid:101 102 103i;handle:201 202 203i;lastp:(2024.01.03D0;2024.01.01D0;2024.01.02D0));
+chk["roundrobin picks oldest lastp";202i;(srvsel.selector[seltab;`roundrobin])`handle];
+chk["last picks newest lastp";201i;(srvsel.selector[seltab;`last])`handle];
+chk["any picks a row from the table";1b;((srvsel.selector[seltab;`any])`handle) in 201 202 203i];
+empt:([]serverid:`int$();handle:`int$();lastp:`timestamp$());
+chk["empty table -> null handle";0Ni;(srvsel.selector[empt;`roundrobin])`handle];
+
+/ =========================================================================
+hdr"STEP 5  live routing (gethandlebytype / gethpbytype / getserverbytype)";
+/ round-robin across the two live rdbs: both start with null lastp, so LRU
+/ visits rdb1, rdb2, rdb1, rdb2 - and each query is answered by that process
+resp:{[i] route[`rdb;`roundrobin]} each til 4;
+chk["round-robin routes to live rdbs in LRU order";`rdb1`rdb2`rdb1`rdb2;resp];
+chk["only the two live rdbs ever answer";`rdb1`rdb2;asc distinct resp];
+chk["gethpbytype gateway returns its hpup";gwhp;srvsel.gethpbytype[`gateway;`roundrobin]];
+chk["getserverbytype returns requested column";`gw1;srvsel.getserverbytype[`gateway;`procname;`roundrobin]];
+chk["gethandlebytype unknown type -> ()";();srvsel.gethandlebytype[`nope;`roundrobin]];
+chk["a single hdb query is answered by an hdb";1b;(route[`hdb;`roundrobin]) in `hdb1`hdb2];
+hitsbefore:exec sum hits from srvsel.getserverstable[] where servertype=`gateway;
+srvsel.gethandlebytype[`gateway;`roundrobin];
+chk["selection increments hits";1b;(hitsbefore+1)=exec sum hits from srvsel.getserverstable[] where servertype=`gateway];
+
+/ =========================================================================
+hdr"STEP 6  getserverids - servertype (symbol) path";
+chk["rdb -> the two rdb serverids";1 2i;asc raze srvsel.getserverids[`rdb]];
+chk["rdb,hdb -> all four serverids";1 2 3 4i;asc raze srvsel.getserverids[`rdb`hdb]];
+srvsel.setserveractive[handles 0;0b]; srvsel.setserveractive[handles 1;0b];
+chkerr["all requested servertype inactive -> error";{srvsel.getserverids[`rdb]}];
+srvsel.setserveractive[handles 0;1b]; srvsel.setserveractive[handles 1;1b];
+
+/ =========================================================================
+hdr"STEP 7  getserverids - attribute path + routing to the matched backend";
+/ hdb1 covers (d1,d2)/(A,B); hdb2 covers (d2,d3)/(B,C)
+chk["date=d1 -> hdb1 only";enlist`hdb1;
+  distinct {x"ping[]"} each sidhandles raze srvsel.getserverids[enlist[`date]!enlist enlist d1]];
+chk["cross (d1,d2)x(A,B) -> hdb1 alone covers it";enlist`hdb1;
+  distinct {x"ping[]"} each sidhandles raze srvsel.getserverids[`date`sym!((d1;d2);`A`B)]];
+chk["independent over d1,d2,d3 + A,B,C -> both hdbs contribute";`hdb1`hdb2;
+  asc distinct {x"ping[]"} each sidhandles raze srvsel.getserverids[`date`sym`attributetype!((d1;d2;d3);`A`B`C;`independent)]];
+chk["servertype key scopes attribute filter to hdbs";3 4i;asc raze srvsel.getserverids[`servertype`date!(`hdb;enlist d2)]];
+chk["empty requirement dict -> all active serverids";1 2 3 4 5i;asc raze srvsel.getserverids[()!()]];
+chkerr["besteffort=0b impossible -> error";{srvsel.getserverids[`date`besteffort!(enlist 2099.01.01;0b)]}];
+chkerr["no server has requested attribute value -> error";{srvsel.getserverids[enlist[`date]!enlist enlist 2099.01.01]}];
+
+/ =========================================================================
+hdr"STEP 8  addserversfromtable (bulk registration of live handles)";
+conntab:([]w:handles 5 6;proctype:`rdb`hdb;attributes:(()!();`date`sym!((d1;d3);`A`C)));
+srvsel.addserversfromtable[`rdb`hdb;conntab];
+chk["bulk-registered handles 5,6 now present";2=count select from srvsel.getserverstable[] where handle in handles 5 6;1b];
+chk["bulk-registered rdb3 is reachable via its handle";`rdb3;(handles 5)"ping[]"];
+chk["bulk-registered rdb3 now appears in rdb serverids";1b;6i in raze srvsel.getserverids[`rdb]];
+/ skip-already-active: re-offering a live handle must not duplicate it
+n0:count srvsel.getserverstable[];
+srvsel.addserversfromtable[`rdb;([]w:enlist handles 0;proctype:enlist`rdb;attributes:enlist()!())];
+chk["already-active handle skipped (no new row)";n0;count srvsel.getserverstable[]];
+/ (proctype filter, `ALL, and optional procname/hpup columns are covered in test.csv)
+
+/ =========================================================================
+hdr"STEP 9  disconnect: kill a backend, deactivate it, prove routing adapts";
+/ a real gateway's .z.pc handler would call setserveractive[h;0b] on the dropped handle
+/ guard: the kill is only a genuine test if rdb1's pid was captured. if pids 0 were null,
+/ string 0Ni -> "0Ni" and the kill silently no-ops, degrading STEP 9 into a deactivation-only
+/ test. fail loudly here rather than pass on a half-exercised path.
+chk["rdb1 pid captured (so the kill below is real)";1b;not null pids 0];
+@[system;"kill ",string[pids 0]," 2>/dev/null; true";{}]; system"sleep 0.3";
+srvsel.setserveractive[handles 0;0b];
+/ active rdbs are now rdb2 (live) and rdb3 (live); the dead rdb1 must never be picked
+postresp:{[i] route[`rdb;`roundrobin]} each til 6;
+chk["killed/deactivated rdb1 is never selected";1b;not `rdb1 in postresp];
+chk["no routed query hits a dead handle (all answered)";1b;not `NONE in postresp];
+chk["the two remaining live rdbs both serve";`rdb2`rdb3;asc distinct postresp];
+
+/ =========================================================================
+hdr"STEP 10  error handling (every guarded path signals + logs)";
+chkerr["addserverfull rejects non-int handle";{srvsel.addserverfull[`bad;`;`rdb;`;()!()]}];
+chkerr["addserverfull rejects non-symbol servertype";{srvsel.addserverfull[71i;`;"rdb";`;()!()]}];
+chkerr["addserver rejects bad handle";{srvsel.addserver[`bad;`rdb]}];
+chkerr["addserverattr rejects bad servertype";{srvsel.addserverattr[73i;"hdb";()!()]}];
+chkerr["setserveractive rejects non-int handle";{srvsel.setserveractive["bad";0b]}];
+chkerr["setserveractive rejects non-boolean flag";{srvsel.setserveractive[1i;`yes]}];
+chkerr["getservers rejects bad nameortype";{srvsel.getservers[`badname;`x;()!()]}];
+chkerr["selector rejects unknown strategy";{srvsel.selector[seltab;`bogus]}];
+chkerr["getserverids rejects null servertype";{srvsel.getserverids[`]}];
+chkerr["getserverids rejects unregistered servertype";{srvsel.getserverids[`nope]}];
+chkerr["getserverids rejects non-symbol non-dict arg";{srvsel.getserverids[42]}];
+chkerr["getserverids rejects nested/malformed attribute value";{srvsel.getserverids[(enlist`date)!enlist enlist d1,d2]}];
+chkerr["addserversfromtable rejects missing columns";{srvsel.addserversfromtable[`rdb;([]x:enlist 1i)]}];
+
+/ =========================================================================
+hdr"STEP 11  init (required log dependency - bespoke + kx.log)";
+caplog:([]lvl:`symbol$();msg:());
+caplogger:`info`warn`error!({[c;m]`caplog upsert(`info;m)};{[c;m]`caplog upsert(`warn;m)};{[c;m]`caplog upsert(`error;m)});
+srvsel.init[enlist[`log]!enlist caplogger];
+caplog:0#caplog;
+srvsel.addserver[40i;`rdb];
+chk["injected logger captures an info message";1b;0<count select from caplog where lvl=`info];
+chk["injected logger receives the message text";1b;any caplog[`msg] like "*registering server*"];
+caplog:0#caplog;
+@[{srvsel.selector[([]handle:1 2i;lastp:2#.z.p);`bogus]};();{}];
+chk["injected logger captures an error message";1b;0<count select from caplog where lvl=`error];
+chkerr["init rejects non-dictionary deps";{srvsel.init[(::)]}];
+chkerr["init rejects deps missing log key";{srvsel.init[()!()]}];
+chkerr["init rejects log value that is not a dict";{srvsel.init[enlist[`log]!enlist(::)]}];
+chkerr["init rejects log dict missing error key";{srvsel.init[enlist[`log]!enlist(`info`warn!({[c;m]};{[c;m]}))]}];
+srvsel.init[enlist[`log]!enlist (use`kx.log)[`createLog][]];
+srvsel.addserver[41i;`rdb];
+chk["kx.log logger wired and usable";1b;41i in exec handle from srvsel.getservers[`servertype;`rdb;()!()]];
+
+-1"";-1"===========================================================";
+-1"  TOTAL: ",(string PASS+FAIL)," | PASS: ",(string PASS)," | FAIL: ",string FAIL;
+-1"===========================================================";
+exit FAIL
diff --git a/di/serverselect/serverselect.md b/di/serverselect/serverselect.md
new file mode 100644
index 00000000..4e7147e4
--- /dev/null
+++ b/di/serverselect/serverselect.md
@@ -0,0 +1,239 @@
+# Server Selection
+
+`serverselect.q` maintains a pool of registered backend servers and selects from them by servertype or attribute requirements. Extracted from the `.gw` namespace in TorQ's `gatewaylib.q` and `gateway.q`, it provides the server-selection layer of a gateway — decoupled from query execution and connection management.
+
+---
+
+## Features
+
+- Register backend servers with servertype, procname, host/port, and attribute dictionaries
+- Track active/inactive state per server, updated on connect and disconnect
+- Select servers using round-robin, most-recently-used, or random strategy
+- Query servers by servertype list or attribute requirement dictionary
+- Attribute matching supports cross-product and independent strategies with configurable best-effort mode
+- Bulk registration from a TorQ-compatible connection table
+- Injected logging — supply your own logger (a `kx.log` instance or bespoke) via `init`; required, no default
+
+---
+
+## Initialisation & Dependencies
+
+`init` wires the module's injected dependencies and **must be called before any other function**. The `log` dependency is **required** — there is no fallback, and the module does not load `kx.log` itself. Initialising the logging framework is the job of the start-up script that ties the modules together, or of the user at run time.
+
+The injected logger is normalised by `normlog` to a binary `` `info`warn`error!{[c;m]} `` dict — each function takes a context symbol `c` and a message string `m`, called as `.z.m.log[\`info][\`ctx;"msg"]`. Pass **either** form:
+
+| Form | What to pass | Behaviour |
+|---|---|---|
+| `kx.log` instance | the full `(use\`kx.log)[\`createLog][]` dict | detected by its `getlvl`/`sinks`/`fmts` keys; its monadic functions are wrapped to `{[c;m]}`, folding the context in as a `"ctx: msg"` prefix |
+| bespoke logger | a `` `info`warn`error!({[c;m]};{[c;m]};{[c;m]}) `` dict | already binary — passed through unchanged |
+
+```q
+srvsel:use`di.serverselect
+
+/ option 1: wire in kx.log (the standard logger; typically done once in the start-up script)
+/ pass the WHOLE instance so normlog can detect and wrap it - do NOT strip it to a 3-key dict
+srvsel.init[enlist[`log]!enlist (use`kx.log)[`createLog][]]
+
+/ option 2: a bespoke binary logger {[c;m]} (context symbol, message string)
+mylog:`info`warn`error!(
+  {[c;m] .my.log.info  string[c],": ",m};
+  {[c;m] .my.log.warn  string[c],": ",m};
+  {[c;m] .my.log.error string[c],": ",m});
+srvsel.init[enlist[`log]!enlist mylog]
+```
+
+`init` throws with prefix `di.serverselect:` if `deps` is not a dictionary, is missing the `` `log `` key, or the `log` value is not a dictionary exposing `` `info`warn`error ``. All other `di.serverselect:` error conditions are logged via `.z.m.log[\`error]` (with the function as context) before being signalled.
+
+---
+
+## Server Table Schema
+
+Servers are tracked in the `servers` keyed table (keyed on `serverid`):
+
+| Column | Type | Description |
+|---|---|---|
+| `serverid` | `int` (key) | Unique auto-assigned server ID |
+| `handle` | `int` | Connection handle |
+| `procname` | `symbol` | Process name (null if not provided) |
+| `servertype` | `symbol` | Process type e.g. `` `rdb ``, `` `hdb `` |
+| `hpup` | `symbol` | Host/port symbol e.g. `` `:host:5010 `` (null if not provided) |
+| `active` | `boolean` | Whether the server is currently active |
+| `lastp` | `timestamp` | Last time this server was selected |
+| `hits` | `int` | Number of times this server has been selected |
+| `attributes` | `any` | Attribute dictionary registered with the server |
+
+---
+
+## Functions
+
+### Registration
+
+| Function | Description |
+|---|---|
+| `addserverfull[h;pname;st;hp;att]` | Register a server with full details: handle, procname, servertype, hpup, attributes |
+| `addserverattr[h;st;att]` | Register a server with servertype and attributes; procname and hpup default to null |
+| `addserver[h;st]` | Register a server with no attributes |
+| `setserveractive[h;active]` | Mark a server active (`1b`) or inactive (`0b`) |
+| `addserversfromtable[proctypes;conntable]` | Bulk-register from a connection table, filtered by proctype |
+| `getserverstable[]` | Return the full registered server table |
+
+`addserversfromtable` skips handles that are already active. Pass `` `ALL `` as `proctypes` to register all process types. The `conntable` must have columns `w` (int handle), `proctype` (symbol), `attributes` (dict per row); `procname` and `hpup` are optional.
+
+```q
+/ register on connect
+srvsel.addserverattr[h; getproctype[h]; getattributes[h]]
+
+/ mark inactive on disconnect
+srvsel.setserveractive[h; 0b]
+
+/ bulk registration from TorQ connection table
+srvsel.addserversfromtable[`rdb`hdb; .servers.SERVERS]
+```
+
+---
+
+### Query and Selection
+
+| Function | Description |
+|---|---|
+| `getservers[nameortype;lookups;req]` | Return active servers matching a servertype or procname filter, with per-attribute match scoring |
+| `selector[servertable;selection]` | Pick one row from a server table using a selection strategy |
+| `getserverbytype[ptype;col;sel]` | Return one column value for a servertype using the given strategy; updates `lastp` and `hits` |
+| `gethandlebytype[ptype;sel]` | Convenience projection of `getserverbytype` returning `handle` |
+| `gethpbytype[ptype;sel]` | Convenience projection of `getserverbytype` returning `hpup` |
+
+`getservers` returns a table including an `attribmatch` column — a dictionary of `attrname!(complete_match_bool;matched_values)` per attribute key in `req`. When `lookups` is not `` ` ``, `nameortype` must be `` `servertype `` or `` `procname ``; any other value throws (and logs) a `di.serverselect:` error rather than silently falling through to a `procname` lookup.
+
+All `di.serverselect:` error conditions — including the input-type checks on `addserverfull`/`setserveractive` and the connection-table column check on `addserversfromtable` — are logged via `.z.m.log[\`error]` before being signalled.
+
+`selector` supports three strategies:
+
+| Strategy | Behaviour |
+|---|---|
+| `` `roundrobin `` | Pick server with the oldest `lastp` (least recently used) |
+| `` `any `` | Pick a random server |
+| `` `last `` | Pick server with the newest `lastp` (most recently used) |
+
+`selector` expects a non-empty table; called on an empty table it returns a row of nulls (e.g. a null `handle`). The `getserverbytype`/`gethandlebytype`/`gethpbytype` helpers guard against this and return `()` when no active server matches the requested type.
+
+```q
+/ get a handle, round-robin across rdbs
+srvsel.gethandlebytype[`rdb; `roundrobin]
+
+/ get host/port for an hdb
+srvsel.gethpbytype[`hdb; `roundrobin]
+```
+
+---
+
+### Server ID Lookup
+
+```q
+srvsel.getserverids[att]
+```
+
+Returns server IDs matching a servertype list or attribute requirement dictionary. Used as the primary dispatch input — pass the result to your async or sync query handler to target specific servers.
+
+#### Symbol list path
+
+Pass a symbol or symbol list of servertypes. Validates that all requested types are registered and currently active.
+
+```q
+srvsel.getserverids[`rdb]
+srvsel.getserverids[`rdb`hdb]
+```
+
+Throws if any requested type is null, unregistered, or all-inactive.
+
+#### Attribute dict path
+
+Pass a dictionary of attribute requirements. Servers whose attribute dictionaries satisfy the requirements are returned. Each requirement value must be an **atom or a simple (flat) vector** of the attribute's type — a nested/general-list value (e.g. from a stray `enlist`, giving `` `date!enlist enlist 2024.01.01 2024.01.02 ``) is rejected with a clear `di.serverselect:` error rather than failing deep in the matcher.
+
+```q
+/ cross match (default): every date must be available for every sym
+srvsel.getserverids[`date`sym!(2024.01.01 2024.01.02; `AAPL`MSFT)]
+
+/ independent match: each date and sym just needs one server somewhere
+srvsel.getserverids[`date`sym`attributetype!(2024.01.01 2024.01.02; `AAPL`MSFT; `independent)]
+
+/ scope to a specific servertype then apply attribute filter
+srvsel.getserverids[`servertype`date!(`hdb; enlist 2024.01.01)]
+
+/ strict mode: error if requirements cannot be fully satisfied
+srvsel.getserverids[`date`besteffort!(enlist 2024.01.01; 0b)]
+```
+
+##### Attribute matching strategies
+
+| `` `attributetype `` | Behaviour |
+|---|---|
+| `` `cross `` (default) | Every combination of attribute values must be coverable by a single server |
+| `` `independent `` | Each individual attribute value only needs to be matched by at least one server |
+
+The reserved key `` `besteffort `` (boolean, default `1b`) controls whether a partial match is acceptable. Set to `0b` to throw if requirements cannot be fully satisfied.
+
+---
+
+## Example
+
+```q
+/ load and initialise - init must be called before any other function
+/ pass the whole kx.log instance; normlog wraps it to the binary {[c;m]} contract
+srvsel:use`di.serverselect
+srvsel.init[enlist[`log]!enlist (use`kx.log)[`createLog][]]
+
+/ register servers as they connect / mark inactive on disconnect
+/   on connect:    srvsel.addserverattr[h; getproctype[h]; getattributes[h]]
+/   on disconnect: srvsel.setserveractive[h; 0b]
+
+/ bulk register from TorQ stack on startup
+srvsel.addserversfromtable[`rdb`hdb; .servers.SERVERS]
+
+/ get server IDs for a query by servertype
+serverids:srvsel.getserverids[`rdb`hdb]
+
+/ get server IDs by attribute requirement
+serverids:srvsel.getserverids[`date`sym!(enlist 2024.01.01; enlist `AAPL)]
+
+/ get a handle directly (round-robin across rdbs)
+h:srvsel.gethandlebytype[`rdb; `roundrobin]
+
+/ inspect registered server pool
+srvsel.getserverstable[]
+```
+
+---
+
+## Testing
+
+Both test suites require KDB-X (the `use` module system). Set `QPATH` so `di.*` and `kx.*` modules resolve — it must include this repository and the `kx` module directory:
+
+```bash
+export QPATH=/path/to/kx/mod:/path/to/kdbx-modules
+```
+
+### Unit tests (k4unit)
+
+`test.csv` is a k4unit manifest covering every exported function. Run it from a q session (or script):
+
+```q
+k4unit:use`di.k4unit;
+k4unit.moduletest`di.serverselect;   / prints the results table; "All tests passed" on success
+```
+
+The `before` rows load the module and `init` it with a no-op logger, so the tests run standalone with no external logging framework.
+
+### Integration test
+
+`integration.q` is an end-to-end test that drives every exported function against **real backend processes**. It spawns a fleet of child `q` listeners, opens genuine IPC handles to them, and exercises a realistic gateway lifecycle (register → query → select → **route a live query to the selected handle** → bulk-register → disconnect → error handling → init). Because the handle returned by `gethandlebytype`/`getserverids` is actually queried, the assertions prove queries reach the *expected* backend process — e.g. round-robin alternates between the live rdbs, attribute selection routes to the hdb whose attributes match, and a killed/deactivated server drops out of selection. Run it directly:
+
+```bash
+QPATH=/path/to/kx/mod:/path/to/kdbx-modules q integration.q
+```
+
+It exits with a non-zero code equal to the number of failed assertions (`0` when all pass), and prints a `PASS`/`FAIL` summary.
+
+The test is self-contained — no helper files: child backends are bare `q` listeners whose identity and `ping` api are injected over IPC, and the test launches and tears them down itself (cleanup is guaranteed via `.z.exit`, even on failure). It additionally requires:
+
+- a `q` on `PATH` to launch the child listeners (override with `$QBIN`);
+- some free TCP ports. There are **no hardcoded ports**: the test derives a base from its own pid (so concurrent runs don't collide) and scans upward for ports that are actually free. Set `$SSPORT` to pin the base if you need a known range.
diff --git a/di/serverselect/serverselect.q b/di/serverselect/serverselect.q
new file mode 100644
index 00000000..0d057f46
--- /dev/null
+++ b/di/serverselect/serverselect.q
@@ -0,0 +1,275 @@
+/ library for selecting backend servers from a registered pool based on servertype or attribute requirements
+
+/ registered server pool - populated by addserverfull / addserverattr / addserver
+servers:([serverid:`u#`int$()]
+  handle:`int$();
+  procname:`symbol$();
+  servertype:`symbol$();
+  hpup:`symbol$();
+  active:`boolean$();
+  lastp:`timestamp$();
+  hits:`int$();
+  attributes:());
+
+/ autoincrement counter for server IDs
+serverid:0i;
+
+init:{[deps]
+  / wire injectable dependencies (and any optional config) - must be called before any other function
+  / the log dependency is required; there is no fallback
+  / deps: a dict with a `log key; the log value is either a kx.log instance or a `info`warn`error
+  /   dict of binary {[c;m]} loggers (context symbol, message string) - normalised via normlog
+  / example: di.serverselect.init[enlist[`log]!enlist logdep]
+  if[99h<>type deps;
+    '"di.serverselect: deps must be a dict with `log key"];
+  if[not `log in key deps;
+    '"di.serverselect: log dependency is required; pass `info`warn`error functions keyed on `log"];
+  if[99h<>type deps`log;
+    '"di.serverselect: log value must be a dict; pass `info`warn`error functions"];
+  if[not all (`info`warn`error) in key deps`log;
+    '"di.serverselect: log dict must have `info`warn`error keys; got: ",(", " sv string key deps`log)];
+  .z.m.log:normlog deps`log;
+  };
+
+normlog:{[logdict]
+  / internal - normalise the injected logger to a binary `info`warn`error!{[c;m]} dict
+  / detect kx.log instance by presence of kx.log-specific keys (getlvl, sinks, fmts)
+  / kx.log functions are monadic - wrap each into binary {[c;m]} and embed context in the message
+  / plain {[c;m]} log dicts (info`warn`error only) pass through unchanged
+  $[any `getlvl`sinks`fmts in key logdict;
+    `info`warn`error!(
+      {[fn;c;m] fn[string[c],": ",m]}[logdict`info;];
+      {[fn;c;m] fn[string[c],": ",m]}[logdict`warn;];
+      {[fn;c;m] fn[string[c],": ",m]}[logdict`error;]);
+    logdict]
+  };
+
+raiseerror:{[ctx;msg]
+  / internal - log an error under ctx then signal it, so failures are observable as well as thrown
+  .z.m.log[`error][ctx;msg];
+  '"di.serverselect: ",string[ctx],": ",msg;
+  };
+
+nextserverid:{
+  / internal - increment and return the next unique server ID
+  .z.m.serverid:serverid+1i;
+  :.z.m.serverid;
+  };
+
+updatestats:{[sid]
+  / internal - update last-access timestamp and hit count for a single server
+  / keyed on serverid (unique) rather than handle, which may be shared by multiple servers
+  .z.m.servers:update lastp:.z.p,hits:hits+1i from servers where serverid=sid;
+  };
+
+addserverfull:{[h;pname;st;hp;att]
+  / register a server with full details: handle, procname, servertype, hpup and attribute dictionary
+  if[not -6h=type h;raiseerror[`addserverfull;"handle must be an int; got type ",string type h]];
+  if[not -11h=type st;raiseerror[`addserverfull;"servertype must be a symbol; got type ",string type st]];
+  .z.m.log[`info][`addserverfull;"registering server: handle=",(string h),", procname=",string[pname],", type=",string st];
+  .z.m.servers:servers upsert (nextserverid[];h;pname;st;hp;1b;0Np;0i;att);
+  };
+
+addserverattr:{[h;st;att]
+  / register a server with servertype and attributes; procname and hpup default to null
+  addserverfull[h;`;st;`;att];
+  };
+
+addserver:{[h;st]
+  / register a server with no attributes; procname and hpup default to null
+  addserverfull[h;`;st;`;()!()];
+  };
+
+setserveractive:{[h;a]
+  / mark a registered server active (1b) or inactive (0b); called on connect and disconnect
+  if[not -6h=type h;raiseerror[`setserveractive;"handle must be an int; got type ",string type h]];
+  if[not -1h=type a;raiseerror[`setserveractive;"active flag must be a boolean; got type ",string type a]];
+  .z.m.log[`info][`setserveractive;"marking handle=",(string h)," active=",string a];
+  .z.m.servers:update active:a from servers where handle=h;
+  };
+
+getserverstable:{[]
+  / return the current registered server table
+  :servers;
+  };
+
+addserversfromtable:{[proctypes;conntable]
+  / register active servers from a connection table filtered by proctype
+  / conntable must have columns: w (int handle), proctype (symbol), attributes (dict per row)
+  / optional columns: procname (symbol), hpup (symbol) - populated from conntable if present
+  / pass proctypes:`ALL to register all process types
+  if[not all `w`proctype`attributes in cols conntable;
+    raiseerror[`addserversfromtable;"conntable must have columns w, proctype and attributes; got: ",", " sv string cols conntable];
+  ];
+  activehandles:(0i;0Ni),exec handle from servers where active;
+  rows:select from conntable where
+    ((proctype in proctypes) or proctypes~`ALL),
+    not w in activehandles;
+  .z.m.log[`info][`addserversfromtable;"registering ",(string count rows)," servers from connection table"];
+  pnames:$[`procname in cols rows; rows`procname; count[rows]#`];
+  hpups:$[`hpup in cols rows; rows`hpup; count[rows]#`];
+  addserverfull'[rows`w;pnames;rows`proctype;hpups;rows`attributes];
+  };
+
+attributematch:{[req;avail]
+  / compute match result for each key in req against what avail advertises
+  / returns dict of attrname!(complete_match_bool;matched_values) for each required attribute key
+  / keys present in req but absent in avail return (0b;())
+  vals:key[req] inter key avail;
+  notpresent:noval!(count noval:key[req] except key avail)#enlist(0b;());
+  :notpresent,vals!{($[0>type y;x~y;all x in y];(x,()) inter y,())}'[req vals;avail vals];
+  };
+
+getservers:{[nameortype;lookups;req]
+  / look up active servers by servertype or procname with per-attribute match scoring
+  / nameortype: `servertype or `procname; pass ` as lookups to return all active servers
+  / req: attribute requirements dict - use ()!() for no attribute filtering
+  / returns table with attribmatch column showing (complete_bool;matched_values) per attribute key
+  r:$[`~lookups;
+    select serverid,procname,servertype,hpup,handle,lastp,attributes from servers where active;
+    nameortype~`servertype;
+    select serverid,procname,servertype,hpup,handle,lastp,attributes from servers where active,servertype in lookups;
+    nameortype~`procname;
+    select serverid,procname,servertype,hpup,handle,lastp,attributes from servers where active,procname in lookups;
+    raiseerror[`getservers;"nameortype must be `servertype or `procname; got: ",string nameortype]];
+  if[0=count r;:update attribmatch:attributes from r];
+  am:attributematch[req] each r`attributes;
+  :update attribmatch:am from r;
+  };
+
+selector:{[servertable;selection]
+  / pick one row from servertable using the given strategy
+  / selection: `roundrobin (least recently used), `any (random), `last (most recently used)
+  :$[selection=`roundrobin; first `lastp xasc servertable;
+     selection=`any;        rand servertable;
+     selection=`last;       last `lastp xasc servertable;
+     raiseerror[`selector;"unknown selection strategy: ",string selection]];
+  };
+
+getserverbytype:{[ptype;serverval;selection]
+  / return a single server attribute value for a servertype using the given selection strategy
+  / ptype: servertype symbol; serverval: column to return e.g. `handle or `hpup; selection: `roundrobin`any`last
+  r:getservers[`servertype;ptype;()!()];
+  if[not count r;:()];
+  r:selector[r;selection];
+  updatestats[r`serverid];
+  :r serverval;
+  };
+
+gethandlebytype:getserverbytype[;`handle;];
+gethpbytype:getserverbytype[;`hpup;];
+
+getserverids:{[att]
+  / return server IDs matching a servertype list or attribute requirement dictionary
+  / att: symbol list of servertypes, or dict of attribute requirements (optionally keyed on `servertype)
+  / dispatch the symbol-list path to getserveridsbytype and the dict path to getserveridstype
+  if[99h<>type att; :getserveridsbytype att];
+  / validate attribute-requirement values are atoms or simple vectors (control keys excepted);
+  / a nested/general-list value (type 0h) would otherwise crash the cross matcher with a raw 'type
+  reqkeys:key[att] except `servertype`attributetype`besteffort;
+  if[count badkeys:reqkeys where 0h=type each att reqkeys;
+    raiseerror[`getserverids;"attribute requirement values must be atoms or simple vectors; nested/mixed for: ",", " sv string badkeys]];
+  serverids:$[`servertype in key att;
+    raze getserveridstype[delete servertype from att] each (),att`servertype;
+    getserveridstype[att;`all]];
+  if[all 0=count each serverids;
+    raiseerror[`getserverids;"no servers match requested attributes"];
+  ];
+  :serverids;
+  };
+
+getserveridsbytype:{[att]
+  / internal - resolve server IDs for a servertype symbol or symbol list
+  / validates each requested type is registered and currently active
+  if[not 11h=abs type att;
+    raiseerror[`getserveridsbytype;"servertype must be a symbol list (11h) or attribute dict (99h)"];
+  ];
+  servertype:distinct att,();
+  activeservers:exec distinct servertype from servers where active;
+  allservers:exec distinct servertype from servers;
+  activeserversmsg:". available servers: ",", " sv string activeservers;
+  if[any null att;
+    raiseerror[`getserveridsbytype;"null servertype passed as argument",activeserversmsg];
+  ];
+  if[count servertype except activeservers;
+    raiseerror[`getserveridsbytype;
+      $[max not servertype in allservers;
+        "not valid servers: ",", " sv string servertype except allservers;
+        "requested servers currently inactive: ",", " sv string servertype except activeservers
+      ],activeserversmsg];
+  ];
+  :(exec serverid by servertype from servers where active)[servertype];
+  };
+
+getserveridstype:{[att;typ]
+  / internal - filter active servers by servertype and attribute requirements
+  / resolves besteffort and attributetype control keys then dispatches to cross or independent matching
+  besteffort:1b;
+  attype:`cross;
+  svrs:$[typ=`all;
+    exec serverid!attributes from servers where active;
+    exec serverid!attributes from servers where active,servertype=typ];
+  if[`besteffort in key att;
+    if[-1h=type att`besteffort; besteffort:att`besteffort];
+    att:delete besteffort from att;
+  ];
+  if[`attributetype in key att;
+    if[-11h=type att`attributetype; attype:att`attributetype];
+    att:delete attributetype from att;
+  ];
+  res:$[attype=`independent;
+    getserversindependent[att;svrs;besteffort];
+    getserverscross[att;svrs;besteffort]];
+  serverids:first value flip $[99h=type res; key res; res];
+  if[all 0=count each serverids;
+    raiseerror[`getserveridstype;"no servers match ",string[typ]," requested attributes"];
+  ];
+  :serverids;
+  };
+
+/ internal - build a cross product table from a nested dictionary
+buildcross:{(cross/){flip (enlist y)#x}[x] each key x};
+
+getserversinitial:{[req;att]
+  / internal - initial filter shared by cross and independent matching
+  / drops servers missing any required attribute key, ranks survivors by coverage
+  if[0=count req; :([]serverid:enlist key att)];
+  att:(where all each (key req) in/: key each att)#att;
+  if[not count att;raiseerror[`getserversinitial;"no servers report all requested attributes"]];
+  s:update serverid:key att from value req in'/: (key req)#/:att;
+  s:s idesc value min each sum each' `serverid xkey s;
+  s:`serverid xkey 0!(key req) xgroup s;
+  :s;
+  };
+
+getserverscross:{[req;att;besteffort]
+  / internal - find servers satisfying the cross product of all attribute requirements
+  / each attribute combination must be coverable by a single server
+  if[0=count req; :([]serverid:enlist key att)];
+  s:getserversinitial[req;att];
+  reqcross:buildcross[req];
+  / scan through each server group accumulating which cross-product rows have been covered
+  util:flip `remaining`found!flip (
+    {[x;y;z] (y[0] except found; y[0] inter found:$[0=count y[0];y[0];buildcross x@'where each z])}[req]\
+    )[(reqcross;());value s];
+  if[(count last util`remaining) and not besteffort;
+    raiseerror[`getserverscross;"cannot satisfy query - cross product of all attributes cannot be matched"];
+  ];
+  s:1!(0!s) w:where not 0=count each util`found;
+  :(key s)!distinct each' flip each util[w]`found;
+  };
+
+getserversindependent:{[req;att;besteffort]
+  / internal - find servers satisfying attribute requirements independently
+  / each individual requirement only needs to be matched by one server
+  if[0=count req; :([]serverid:enlist key att)];
+  s:getserversinitial[req;att];
+  / mask out server groups whose contribution is already covered by earlier groups
+  filter:(value s)&not -1 _ (0b&(value s) enlist 0),maxs value s;
+  alldone:1+first where all each all each' maxs value s;
+  if[(null alldone) and not besteffort;
+    raiseerror[`getserversindependent;"cannot satisfy query - not all attributes can be matched"];
+  ];
+  s:1!(0!s) w:where any each any each' filter;
+  :(key s)!{(key x)!(value x)@'where each y key x}[req] each value s&filter w;
+  };
diff --git a/di/serverselect/test.csv b/di/serverselect/test.csv
new file mode 100644
index 00000000..1db409d5
--- /dev/null
+++ b/di/serverselect/test.csv
@@ -0,0 +1,194 @@
+action,ms,bytes,lang,code,repeat,minver,comment
+before,0,0,q,srvsel:use`di.serverselect,1,1,load module
+before,0,0,q,"noop:`info`warn`error!({[c;m]};{[c;m]};{[c;m]})",1,1,define a no-op binary logger {[c;m]}
+before,0,0,q,srvsel.init[enlist[`log]!enlist noop],1,1,init the module with the required log dependency before use
+
+/ ---- getserverstable: initial state ----
+comment,,,,,,,getserverstable - initial state before any addserverattr
+true,0,0,q,0=count srvsel.getserverstable[],1,1,servers empty on fresh module load
+true,0,0,q,`serverid`handle`procname`servertype`hpup`active`lastp`hits`attributes~cols srvsel.getserverstable[],1,1,servers has correct schema
+
+/ ---- addserverattr / addserver / addserverfull: registration ----
+comment,,,,,,,addserverattr and addserver - server registration
+run,0,0,q,srvsel.addserver[1i;`rdb],1,1,register rdb server with no attributes
+run,0,0,q,srvsel.addserver[2i;`rdb],1,1,register second rdb server
+run,0,0,q,"srvsel.addserverattr[3i;`hdb;`date`sym!(2024.01.01 2024.01.02;`AAPL`MSFT)]",1,1,register hdb server with date and sym attributes
+true,0,0,q,3=count srvsel.getserverstable[],1,1,three servers registered
+true,0,0,q,all exec active from srvsel.getserverstable[],1,1,all registered servers are active by default
+true,0,0,q,`rdb`rdb`hdb~exec servertype from srvsel.getserverstable[],1,1,servertypes match registered order
+true,0,0,q,(1i;2i;3i)~exec handle from srvsel.getserverstable[],1,1,handles match registered order
+true,0,0,q,1 2 3i~exec serverid from srvsel.getserverstable[],1,1,server IDs autoincrement from 1
+true,0,0,q,all null exec procname from srvsel.getserverstable[],1,1,procname is null when registered via addserverattr
+true,0,0,q,all null exec hpup from srvsel.getserverstable[],1,1,hpup is null when registered via addserverattr
+run,0,0,q,"srvsel.addserverfull[4i;`myproc;`hdb;`:localhost:5555;(enlist`date)!enlist 2024.12.01]",1,1,register server with full details via addserverfull
+true,0,0,q,4=count srvsel.getserverstable[],1,1,fourth server registered via addserverfull
+true,0,0,q,`myproc~first exec procname from srvsel.getserverstable[] where handle=4i,1,1,procname populated via addserverfull
+true,0,0,q,`:localhost:5555~first exec hpup from srvsel.getserverstable[] where handle=4i,1,1,hpup populated via addserverfull
+
+/ ---- setserveractive: marking active/inactive ----
+comment,,,,,,,setserveractive - active flag management
+run,0,0,q,srvsel.setserveractive[2i;0b],1,1,mark second rdb server inactive
+true,0,0,q,not (exec active from srvsel.getserverstable[] where handle=2i)[0],1,1,handle 2 is now inactive
+true,0,0,q,(exec active from srvsel.getserverstable[] where handle=1i)[0],1,1,handle 1 remains active
+run,0,0,q,srvsel.setserveractive[2i;1b],1,1,mark second rdb server active again
+true,0,0,q,(exec active from srvsel.getserverstable[] where handle=2i)[0],1,1,handle 2 is active again
+
+
+/ ---- getservers ----
+comment,,,,,,,getservers - server lookup with attribute match scoring
+true,0,0,q,`serverid`procname`servertype`hpup`handle`lastp`attributes`attribmatch~cols srvsel.getservers[`;`;()!()],1,1,getservers returns table with correct columns
+true,0,0,q,count[select from srvsel.getserverstable[] where active]=count srvsel.getservers[`;`;()!()],1,1,getservers with ` lookups returns all active servers
+true,0,0,q,all `hdb=exec servertype from srvsel.getservers[`servertype;`hdb;()!()],1,1,getservers filters by servertype correctly
+true,0,0,q,0=count srvsel.getservers[`servertype;`nonexistent;()!()],1,1,getservers returns empty table for unknown servertype
+true,0,0,q,0<count srvsel.getservers[`procname;`;()!()],1,1,getservers with null procname lookups returns all active servers
+true,0,0,q,"any {(first value x)[0]}each (srvsel.getservers[`servertype;`hdb;(enlist`date)!enlist 2024.01.01])`attribmatch",1,1,getservers attribmatch shows complete match for registered date
+
+/ ---- selector ----
+comment,,,,,,,selector - selection strategy
+run,0,0,q,"seltab:([]handle:1 2i;lastp:(2024.01.01D00:00;2024.01.02D00:00))",1,1,create test server table for selector
+true,0,0,q,1i~(srvsel.selector[seltab;`roundrobin])`handle,1,1,selector roundrobin picks least recently used (oldest lastp)
+true,0,0,q,2i~(srvsel.selector[seltab;`last])`handle,1,1,selector last picks most recently used (newest lastp)
+true,0,0,q,((srvsel.selector[seltab;`any])`handle) in 1 2i,1,1,selector any picks a handle from the table
+fail,0,0,q,srvsel.selector[seltab;`unknown],1,1,selector rejects unknown strategy
+
+/ ---- getserverbytype / gethandlebytype / gethpbytype ----
+comment,,,,,,,getserverbytype and convenience projections
+true,0,0,q,(srvsel.gethandlebytype[`rdb;`roundrobin]) in exec handle from srvsel.getserverstable[] where servertype=`rdb,active,1,1,gethandlebytype returns a live rdb handle
+true,0,0,q,(srvsel.gethandlebytype[`hdb;`roundrobin]) in exec handle from srvsel.getserverstable[] where servertype=`hdb,active,1,1,gethandlebytype returns a live hdb handle
+true,0,0,q,()~srvsel.gethandlebytype[`nonexistent;`roundrobin],1,1,gethandlebytype returns () for unknown servertype
+true,0,0,q,(srvsel.gethpbytype[`hdb;`roundrobin]) in exec hpup from srvsel.getserverstable[] where servertype=`hdb,active,1,1,gethpbytype returns hpup for matching server
+run,0,0,q,srvsel.gethandlebytype[`rdb;`roundrobin],1,1,gethandlebytype call updates lastp and hits via updatestats
+true,0,0,q,"0<(exec hits from srvsel.getserverstable[] where handle in exec handle from srvsel.getserverstable[] where servertype=`rdb,active)[0]",1,1,hits incremented after gethandlebytype call
+
+/ ---- updatestats: keyed on serverid not handle ----
+comment,,,,,,,updatestats - a selection updates only the chosen serverid even when a handle is shared
+run,0,0,q,"srvsel.addserverfull[60i;`dupa;`zdb;`:h:1;()!()]",1,1,register first server on shared handle 60 (unique servertype zdb)
+run,0,0,q,"srvsel.addserverfull[60i;`dupb;`zdb;`:h:2;()!()]",1,1,register second server on same handle 60
+run,0,0,q,srvsel.gethandlebytype[`zdb;`roundrobin],1,1,select one zdb server by handle
+true,0,0,q,1=sum exec hits from srvsel.getserverstable[] where servertype=`zdb,1,1,exactly one hit recorded across both shared-handle servers (not two)
+true,0,0,q,"1=count select from srvsel.getserverstable[] where servertype=`zdb,not null lastp",1,1,only the selected serverid had its lastp updated
+
+/ ---- getserverids: symbol list path ----
+comment,,,,,,,getserverids - symbol list (servertype) path
+true,0,0,q,0<count srvsel.getserverids[`rdb],1,1,getserverids returns IDs for registered rdb type
+true,0,0,q,0<count srvsel.getserverids[`hdb],1,1,getserverids returns IDs for registered hdb type
+fail,0,0,q,srvsel.getserverids[`],1,1,getserverids rejects null servertype
+fail,0,0,q,srvsel.getserverids[`nonexistent],1,1,getserverids errors on unregistered servertype
+fail,0,0,q,srvsel.getserverids[42],1,1,getserverids rejects non-symbol non-dict argument
+run,0,0,q,srvsel.setserveractive[1i;0b],1,1,mark rdb handle 1 inactive for inactive-server test
+run,0,0,q,srvsel.setserveractive[2i;0b],1,1,mark rdb handle 2 inactive - all rdbs now inactive
+fail,0,0,q,srvsel.getserverids[`rdb],1,1,getserverids errors when all requested servers are inactive
+run,0,0,q,srvsel.setserveractive[1i;1b],1,1,restore rdb handle 1
+run,0,0,q,srvsel.setserveractive[2i;1b],1,1,restore rdb handle 2
+
+/ ---- getserverids: attribute dict path ----
+comment,,,,,,,getserverids - attribute dict path
+true,0,0,q,"0<count srvsel.getserverids[enlist[`date]!enlist enlist 2024.01.01]",1,1,getserverids matches hdb with date attribute
+true,0,0,q,"0<count srvsel.getserverids[enlist[`sym]!enlist enlist`AAPL]",1,1,getserverids matches hdb with sym attribute
+fail,0,0,q,"srvsel.getserverids[enlist[`date]!enlist enlist 1999.01.01]",1,1,getserverids errors when no server matches attribute value
+true,0,0,q,"0<count srvsel.getserverids[`servertype`date!(`hdb;enlist 2024.01.01)]",1,1,getserverids handles servertype key in attribute dict
+
+/ ---- addserversfromtable ----
+comment,,,,,,,addserversfromtable - bulk registration from connection table
+run,0,0,q,"conntab:([]w:10 11 12i;proctype:`rdb`hdb`rdb;attributes:(()!();`date`sym!(enlist 2024.12.01;enlist`IBM);()!()))",1,1,define test connection table without optional columns
+run,0,0,q,srvsel.addserversfromtable[`rdb`hdb;conntab],1,1,register rdb and hdb from connection table
+true,0,0,q,3<=count select from srvsel.getserverstable[] where handle in 10 11 12i,1,1,all three handles registered
+run,0,0,q,"conntab2:([]w:10 11i;proctype:`rdb`hdb;attributes:(()!();()!()))",1,1,define connection table with already-active handles
+run,0,0,q,srvsel.addserversfromtable[`rdb`hdb;conntab2],1,1,addserversfromtable skips already-active handles
+run,0,0,q,"conntab3:([]w:20 21i;proctype:`tickerplant`rdb;attributes:(()!();()!()))",1,1,define connection table with mixed proctypes
+run,0,0,q,srvsel.addserversfromtable[`rdb;conntab3],1,1,addserversfromtable filters by proctype - only rdb registered
+true,0,0,q,0<count select from srvsel.getserverstable[] where handle=21i,1,1,rdb handle 21 was registered
+true,0,0,q,0=count select from srvsel.getserverstable[] where handle=20i,1,1,tickerplant handle 20 was not registered
+run,0,0,q,"conntab4:([]w:30 31i;proctype:`rdb`hdb;procname:`p1`p2;hpup:`:host:1001`:host:1002;attributes:(()!();()!()))",1,1,define connection table with optional procname and hpup columns
+run,0,0,q,srvsel.addserversfromtable[`ALL;conntab4],1,1,addserversfromtable with `ALL and optional columns
+true,0,0,q,`p1~first exec procname from srvsel.getserverstable[] where handle=30i,1,1,procname populated from connection table
+true,0,0,q,`:host:1002~first exec hpup from srvsel.getserverstable[] where handle=31i,1,1,hpup populated from connection table
+fail,0,0,q,"srvsel.addserversfromtable[`rdb;([]x:enlist 1i;y:enlist`rdb)]",1,1,addserversfromtable rejects connection table missing required columns
+
+/ ---- addserverfull: edge cases ----
+comment,,,,,,,addserverfull - edge cases
+run,0,0,q,"srvsel.addserverfull[70i;`first;`rdb;`:first:7000;()!()]",1,1,register first entry at handle 70
+run,0,0,q,"srvsel.addserverfull[70i;`second;`hdb;`:second:7070;()!()]",1,1,register second entry at same handle (keyed by serverid not handle)
+true,0,0,q,2=count select from srvsel.getserverstable[] where handle=70i,1,1,addserverfull with duplicate handle creates two distinct rows (new serverid each time)
+fail,0,0,q,"srvsel.addserverfull[`badhandle;`;`rdb;`;()!()]",1,1,addserverfull rejects symbol handle (type error on int column)
+fail,0,0,q,"srvsel.addserverfull[71i;`;""rdb"";`;()!()]",1,1,addserverfull rejects string servertype (type error on symbol column)
+
+/ ---- addserver: edge cases ----
+comment,,,,,,,addserver - edge cases
+true,0,0,q,(()!())~first exec attributes from srvsel.getserverstable[] where handle=1i,1,1,addserver stores empty attributes dict
+true,0,0,q,null first exec procname from srvsel.getserverstable[] where handle=1i,1,1,addserver stores null procname
+true,0,0,q,null first exec hpup from srvsel.getserverstable[] where handle=1i,1,1,addserver stores null hpup
+fail,0,0,q,"srvsel.addserver[`badhandle;`rdb]",1,1,addserver rejects symbol handle (type error)
+fail,0,0,q,"srvsel.addserver[72i;""rdb""]",1,1,addserver rejects string servertype (type error)
+
+/ ---- addserverattr: edge cases ----
+comment,,,,,,,addserverattr - edge cases
+true,0,0,q,null first exec procname from srvsel.getserverstable[] where handle=3i,1,1,addserverattr stores null procname
+true,0,0,q,null first exec hpup from srvsel.getserverstable[] where handle=3i,1,1,addserverattr stores null hpup
+fail,0,0,q,"srvsel.addserverattr[`badhandle;`hdb;()!()]",1,1,addserverattr rejects symbol handle (type error)
+fail,0,0,q,"srvsel.addserverattr[73i;""hdb"";()!()]",1,1,addserverattr rejects string servertype (type error)
+
+/ ---- setserveractive: edge cases ----
+comment,,,,,,,setserveractive - edge cases
+run,0,0,q,srvsel.setserveractive[9999i;0b],1,1,setserveractive on non-existent handle is a no-op
+true,0,0,q,0=count select from srvsel.getserverstable[] where handle=9999i,1,1,non-existent handle not inserted by setserveractive
+fail,0,0,q,"srvsel.setserveractive[1i;`yes]",1,1,setserveractive rejects symbol active flag (type error)
+fail,0,0,q,"srvsel.setserveractive[""badhandle"";0b]",1,1,setserveractive rejects string handle (type error)
+
+/ ---- getservers: edge cases ----
+comment,,,,,,,getservers - edge cases
+run,0,0,q,srvsel.setserveractive[1i;0b],1,1,mark handle 1 inactive for getservers inactive-exclusion test
+true,0,0,q,not (1i) in exec handle from srvsel.getservers[`servertype;`rdb;()!()],1,1,getservers excludes inactive servers from results
+run,0,0,q,srvsel.setserveractive[1i;1b],1,1,restore handle 1 active after inactive-exclusion test
+true,0,0,q,"all (exec servertype from srvsel.getservers[`servertype;`rdb`hdb;()!()]) in `rdb`hdb",1,1,getservers accepts symbol list as lookups
+true,0,0,q,4i in exec handle from srvsel.getservers[`procname;`myproc;()!()],1,1,getservers procname filter returns server with matching procname
+fail,0,0,q,srvsel.getservers[`badname;`x;()!()],1,1,getservers rejects nameortype that is not servertype or procname
+
+/ ---- selector: edge cases ----
+comment,,,,,,,selector - edge cases
+run,0,0,q,"singleseltab:([]handle:enlist 77i;lastp:enlist 2024.01.15D00:00)",1,1,create single-row selector table
+true,0,0,q,77i~(srvsel.selector[singleseltab;`roundrobin])`handle,1,1,selector roundrobin on single row returns that row
+true,0,0,q,77i~(srvsel.selector[singleseltab;`last])`handle,1,1,selector last on single row returns that row
+true,0,0,q,77i~(srvsel.selector[singleseltab;`any])`handle,1,1,selector any on single row returns that row
+run,0,0,q,"emptyseltab:([]handle:`int$();lastp:`timestamp$())",1,1,create empty selector table
+true,0,0,q,0Ni~(srvsel.selector[emptyseltab;`roundrobin])`handle,1,1,selector roundrobin on empty table returns null handle
+true,0,0,q,0Ni~(srvsel.selector[emptyseltab;`last])`handle,1,1,selector last on empty table returns null handle
+
+/ ---- getserverbytype: direct tests ----
+comment,,,,,,,getserverbytype - direct tests
+true,0,0,q,`rdb~srvsel.getserverbytype[`rdb;`servertype;`roundrobin],1,1,getserverbytype returns correct column value for servertype
+true,0,0,q,()~srvsel.getserverbytype[`nonexistent;`handle;`roundrobin],1,1,getserverbytype returns () for unknown servertype
+true,0,0,q,"(srvsel.getserverbytype[`hdb;`hpup;`roundrobin]) in exec hpup from srvsel.getserverstable[] where servertype=`hdb",1,1,getserverbytype returns hpup value for hdb type
+
+/ ---- gethpbytype: edge cases ----
+comment,,,,,,,gethpbytype - edge cases
+true,0,0,q,()~srvsel.gethpbytype[`nonexistent;`roundrobin],1,1,gethpbytype returns () for unknown servertype
+
+/ ---- getserverids: edge cases ----
+comment,,,,,,,getserverids - edge cases
+run,0,0,q,srvsel.getserverids[`symbol$()],1,1,getserverids with empty symbol list runs without error
+true,0,0,q,"0<count srvsel.getserverids[`rdb`hdb]",1,1,getserverids with multiple servertypes returns results for all types
+true,0,0,q,"0<count srvsel.getserverids[`date`attributetype!(enlist 2024.01.01;`independent)]",1,1,getserverids supports independent attribute matching strategy
+fail,0,0,q,"srvsel.getserverids[`date`besteffort!(enlist 1990.01.01;0b)]",1,1,getserverids throws when no servers have requested attribute value
+fail,0,0,q,"srvsel.getserverids[`servertype`date!(`nonexistent;enlist 2024.01.01)]",1,1,getserverids throws for unknown servertype in attribute dict
+fail,0,0,q,"srvsel.getserverids[(enlist`date)!enlist enlist 2024.01.01 2024.01.02]",1,1,getserverids rejects a nested/malformed attribute requirement value with a clear error
+
+/ ---- init: dependency injection (required log) ----
+comment,,,,,,,init - inject and validate the required log dependency
+run,0,0,q,"caplog:([]lvl:`symbol$();msg:())",1,1,initialise log capture table
+run,0,0,q,"caplogger:`info`warn`error!({[c;m]`caplog upsert(`info;m)};{[c;m]`caplog upsert(`warn;m)};{[c;m]`caplog upsert(`error;m)})",1,1,define a bespoke capturing binary logger {[c;m]}
+run,0,0,q,srvsel.init[enlist[`log]!enlist caplogger],1,1,re-init with the bespoke capturing logger
+run,0,0,q,caplog:0#caplog,1,1,reset capture
+run,0,0,q,"srvsel.addserver[40i;`rdb]",1,1,register a server while the capturing logger is active
+true,0,0,q,0<count select from caplog where lvl=`info,1,1,injected logger received an info message
+true,0,0,q,"any caplog[`msg] like ""*registering server*""",1,1,injected logger received the registration message text
+run,0,0,q,caplog:0#caplog,1,1,reset capture
+run,0,0,q,"@[{srvsel.selector[([]handle:1 2i;lastp:2#.z.p);`bogus]};();{}]",1,1,trigger an error path (signal swallowed)
+true,0,0,q,0<count select from caplog where lvl=`error,1,1,injected logger received the error message via .z.m.log[`error]
+fail,0,0,q,srvsel.init[(::)],1,1,init rejects a non-dictionary deps
+fail,0,0,q,srvsel.init[()!()],1,1,init rejects deps missing the log key
+fail,0,0,q,srvsel.init[enlist[`other]!enlist noop],1,1,init rejects deps without a log key
+fail,0,0,q,srvsel.init[enlist[`log]!enlist(::)],1,1,init rejects a log value that is not a dict
+fail,0,0,q,"srvsel.init[enlist[`log]!enlist(`info`warn!({[c;m]};{[c;m]}))]",1,1,init rejects a log dict missing the error key
+true,0,0,q,"""di.serverselect""~15#@[srvsel.init;(::);{x}]",1,1,init error message is prefixed di.serverselect
+run,0,0,q,srvsel.init[enlist[`log]!enlist noop],1,1,restore the no-op logger