v-ecosystem: receive three more V-tree arrivals for donation

Chains the V-source move pattern onto aerie, volumod, and
emergency-button — each has a build-green Zig replacement on the
hyperpolymath side. V sources are packaged for donation to the V
community.

- v-api-interfaces/v-aerie/            (from aerie/src/api/v/; GraphQL+REST CF-NDS gateway)
- v-api-interfaces/v-volumod/          (from verification-ecosystem/volumod/src/; audio DSP + Bebop FFI)
- v-api-interfaces/v-ambientops-emergency-button/  (from systems-ecosystem/ambientops/emergency-button/src/; panic-safe CLI)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

v-ecosystem/v-api-interfaces/v-aerie/MIGRATION.adoc

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
+= V-lang → Zig Migration Record
+:toc:
+
+== Status
+
+*Port complete 2026-04-17; deletion pending build + integration verification.*
+
+The V-lang API gateway (`src/api/v/`) has been fully ported to idiomatic Zig
+at `src/api/zig/`. The V sources are retained read-only for reference.
+V-lang was banned estate-wide 2026-04-10; see
+link:https://github.com/hyperpolymath/standards/blob/main/VLANG-BAN.adoc[VLANG-BAN.adoc].
+
+== V → Zig File Mapping
+
+[cols="2,2,3"]
+|===
+| V source | Zig replacement | Notes
+
+| `main.v`
+| `src/api/zig/main.zig`
+| Entry point, HTTP server, gRPC listener, protocol dispatch
+
+| `policy.v`
+| `src/api/zig/policy.zig`
+| Policy gate, `PolicyDecision`, `AuditEvent`
+
+| `proof.v`
+| `src/api/zig/proof.zig`
+| SHA-256 proof envelope, UUID v4 generation, RFC 3339 timestamps
+
+| `resolvers.v`
+| `src/api/zig/resolvers.zig`
+| Shared resolution logic for GraphQL/REST/gRPC
+
+| `verb_governance.v`
+| `src/api/zig/verb_governance.zig`
+| Verb governance, trie-prefix matching, stealth timing jitter
+
+| `redis_client.v`
+| `src/api/zig/redis_client.zig`
+| Raw RESP protocol over TCP, cache + audit log
+
+| `librespeed_client.v`
+| `src/api/zig/librespeed_client.zig`
+| HTTP GET to LibreSpeed; shared `httpGet` helper
+
+| `hyperglass_client.v`
+| `src/api/zig/hyperglass_client.zig`
+| HTTP POST to Hyperglass; BGP route hop parsing
+
+| `smokeping_client.v`
+| `src/api/zig/smokeping_client.zig`
+| HTTP GET to SmokePing; CSV + RRD XML parsing
+
+| `verisim_client.v`
+| `src/api/zig/verisim_client.zig`
+| VerisimDB bitemporal client; `dualLogAudit`; shared `auditEventToJson`
+
+| _(inline in V modules)_
+| `src/api/zig/types.zig`
+| All shared domain types extracted into one place
+
+|===
+
+== Build
+
+```bash
+# From repo root:
+zig build              # → zig-out/bin/aerie-gateway
+zig build run          # build + run
+zig build test         # unit tests
+```
+
+== Judgment Calls During Port
+
+V uses garbage-collected heap strings everywhere. The Zig port uses fixed-size
+stack buffers (e.g. `[256]u8` for messages) and per-request arena allocators for
+dynamic data (audit log slices, GraphQL argument strings). This avoids heap
+fragmentation in a long-running server.
+
+V's `TrieNode` with heap map children was replaced by a simple linear scan of
+the 6 hardcoded `RULES` with longest-prefix-wins logic. With only 6 rules this
+is O(6) and avoids pointer-heavy allocation. Phase 2 (YAML-loaded rules) may
+reinstate a trie.
+
+`std.Thread.sleep` is used in place of V's `time.sleep` (the function moved in
+Zig 0.15.2). `std.ArrayList(T)` in 0.15.2 is the unmanaged form (allocator
+passed at each `append` call).
+
+`v_grpc` dependency was dropped entirely. The Phase 1 gRPC layer (4-byte
+length-prefixed JSON) is implemented directly over `std.net.Stream` — no
+external gRPC crate needed at this phase.

v-ecosystem/v-api-interfaces/v-aerie/SIDELINED.adoc

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
+= Aerie API — V-lang Implementation SIDELINED
+:toc:
+
+== Status
+
+The V-lang implementation of the Aerie API service (`src/api/v/`) is *sidelined*
+as of 2026-04-12 following the estate-wide V-lang ban (2026-04-10).
+
+V-lang is banned across all hyperpolymath repositories. See
+link:https://github.com/hyperpolymath/standards/blob/main/VLANG-BAN.adoc[VLANG-BAN.adoc]
+for rationale and migration guidance.
+
+== Migration Target
+
+The replacement is a **Rust + Axum** API service with **Idris2 ABI / Zig FFI**
+for formally verified subsystems. Target location: `src/api/rust/`.
+
+[cols="1,1,1"]
+|===
+| V module (sidelined) | Replacement | Status
+
+| `main.v`             | `src/api/rust/main.rs`      | Planned
+| `proof.v`            | `src/api/rust/proof.rs`     | Planned — Idris2 ABI / Zig FFI
+| `policy.v`           | `src/api/rust/policy.rs`    | Planned
+| `resolvers.v`        | `src/api/rust/resolvers.rs` | Planned
+| `verb_governance.v`  | `src/api/rust/governance.rs`| Planned
+| `verisim_client.v`   | VeriSimDB Rust client        | See `nextgen-databases/verisimdb/connectors/clients/rust/`
+| `redis_client.v`     | `deadpool-redis` crate       | Planned
+| `librespeed_client.v`| Rust HTTP client             | Planned
+| `hyperglass_client.v`| Rust HTTP client             | Planned
+| `smokeping_client.v` | Rust HTTP client             | Planned
+| `aerie.pb.v`         | `tonic` gRPC codegen         | Planned
+|===
+
+== Note on V-grpc Dependency
+
+The `v.mod` lists `v_grpc` as a dependency. The gRPC layer should be
+ported to `tonic` (Rust) or `grpc-web` (ReScript/Deno) depending on the
+transport requirements.
+
+The V-lang source is retained in-tree for reference during migration but
+MUST NOT be compiled, deployed, or extended.

v-ecosystem/v-api-interfaces/v-aerie/hyperglass_client.v

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+//
+// hyperglass_client.v — HTTP Client for Hyperglass Probe
+//
+// Queries the Hyperglass BGP looking glass at HYPERGLASS_URL
+// (default http://hyperglass:8082) for route forensics data.
+// Parses responses into RouteHop records matching the Idris2 ABI
+// and protobuf definitions.
+//
+// Hyperglass provides BGP route path analysis, showing each hop
+// in the network path with ASN ownership and round-trip latency.
+
+module main
+
+import net.http
+import os
+import x.json2
+
+// RouteHop represents a single hop in a BGP route path.
+// Fields match src/abi/Types.idr and src/api/proto/aerie.proto.
+pub struct RouteHop {
+pub:
+	hop    int
+	ip     string
+	asn    string
+	rtt_ms f64
+}
+
+// RouteForensicsPayload is the response wrapper for route forensics queries.
+pub struct RouteForensicsPayload {
+pub:
+	target string
+	path   []RouteHop
+}
+
+// get_hyperglass_url returns the configured Hyperglass endpoint.
+fn get_hyperglass_url() string {
+	url := os.getenv('HYPERGLASS_URL')
+	if url.len > 0 {
+		return url
+	}
+	return 'http://hyperglass:8082'
+}
+
+// get_route_forensics queries Hyperglass for BGP route information
+// to the specified target (IP address or hostname).
+//
+// Attempts to call the Hyperglass API for a BGP route lookup.
+// If the probe is unreachable, returns an empty path list with
+// the target preserved (rather than failing the entire request).
+//
+// In production, Hyperglass runs as a container in the aerie-net
+// network and exposes its API on internal port 80 (mapped to host 8082).
+pub fn get_route_forensics(target string) RouteForensicsPayload {
+	base_url := get_hyperglass_url()
+
+	// Hyperglass API query endpoint
+	response := http.fetch(http.FetchConfig{
+		url:    '${base_url}/api/query/'
+		method: .post
+		header: http.new_header(key: .content_type, value: 'application/json')
+		data:   '{"query_location":"","query_target":"${target}","query_type":"bgp_route"}'
+	}) or {
+		eprintln('hyperglass: probe unreachable at ${base_url}: ${err}')
+		return RouteForensicsPayload{
+			target: target
+			path:   []
+		}
+	}
+
+	if response.status_code != 200 {
+		eprintln('hyperglass: unexpected status ${response.status_code} for target ${target}')
+		return RouteForensicsPayload{
+			target: target
+			path:   []
+		}
+	}
+
+	// Parse the Hyperglass response into RouteHop records
+	parsed := json2.decode[json2.Any](response.body) or {
+		eprintln('hyperglass: failed to parse response JSON')
+		return RouteForensicsPayload{
+			target: target
+			path:   []
+		}
+	}
+
+	// Extract route hops from the parsed JSON
+	hops := parse_route_hops(parsed)
+
+	return RouteForensicsPayload{
+		target: target
+		path:   hops
+	}
+}
+
+// parse_route_hops extracts RouteHop records from a Hyperglass JSON response.
+// The exact structure depends on the Hyperglass version and device type.
+fn parse_route_hops(data json2.Any) []RouteHop {
+	mut hops := []RouteHop{}
+
+	// Hyperglass returns route data in various formats depending on
+	// the router type. We attempt to extract hop-by-hop information.
+	arr := data.as_array()
+	for i, item in arr {
+		obj := item.as_map()
+		ip := if 'prefix' in obj {
+			obj['prefix'] or { json2.Any('') }.str()
+		} else if 'ip' in obj {
+			obj['ip'] or { json2.Any('') }.str()
+		} else {
+			''
+		}
+
+		asn := if 'as_path' in obj {
+			obj['as_path'] or { json2.Any('') }.str()
+		} else if 'asn' in obj {
+			obj['asn'] or { json2.Any('') }.str()
+		} else {
+			''
+		}
+
+		hops << RouteHop{
+			hop:    i + 1
+			ip:     ip
+			asn:    asn
+			rtt_ms: 0
+		}
+	}
+
+	return hops
+}
+
+// route_forensics_to_json serialises a RouteForensicsPayload to JSON.
+pub fn route_forensics_to_json(payload RouteForensicsPayload) string {
+	mut hops_json := []string{}
+	for h in payload.path {
+		asn_field := if h.asn.len > 0 { '"${h.asn}"' } else { 'null' }
+		rtt_field := if h.rtt_ms > 0 { '${h.rtt_ms}' } else { 'null' }
+		hops_json << '{"hop":${h.hop},"ip":"${h.ip}","asn":${asn_field},"rttMs":${rtt_field}}'
+	}
+	return '{"target":"${payload.target}","path":[${hops_json.join(",")}]}'
+}