@yuneta/gobj-js 7.26.24 → 7.26.25

package/README.md

@@ -302,12 +302,31 @@ gobj_write_bool_attr(gobj, "selectable", kw.selectable === true);  // false
 
 A value with no json text (a circular object such as a gobj or a DOM node, a
 `BigInt`) given to a string attribute is refused the same way, and is never
-thrown (7.26.24). A json TEXT is read as the C parser reads it: one that C
+thrown (7.26.24). So is a value that is not json ALL THE WAY DOWN given to a
+string, a `DTP_DICT` or a `DTP_LIST` (7.26.25): a cycle anywhere inside, a
+`BigInt` inside (`[1n]`), a `Map`, a `Set`, a `Date`, a typed array, an instance
+of a class. They were written, and burst (or turned into `"{}"`) when the value
+was serialized, far from the write. A key whose value is `undefined` or a
+function is dropped, as `JSON.stringify()` drops it:
+
+```javascript
+gobj_write_attr(gobj, "settings", {a: 1, b: undefined});    // 0: b goes when serialized
+gobj_write_attr(gobj, "settings", new Map([["a", 1]]));     // -1, ERROR "a value with no json text"
+gobj_write_str_attr(gobj, "name", new Map());               // -1: it was the text "{}"
+```
+
+A `DTP_JSON` attribute is not checked: it takes any value, as before.
+
+A json TEXT is read as the C parser reads it: one that C
 refuses is refused in JS too -- an escaped NUL (`"\u0000"`), a lone surrogate,
 an integer out of int64, a real that overflows (`1e309`; to a `DTP_JSON` it is
-the text `"1e309"`, not `Infinity`). Two differences remain, because a JS number
-cannot carry them: an integer beyond 2^53 is rounded, and `2.0` is the integer
-2 (see `tests/fixtures/attr_types_parity.json`).
+the text `"1e309"`, not `Infinity`), a text nested deeper than 2048 levels (a
+scalar is a level too; 7.26.25). A number beyond int64 is "a real" to a dict,
+as in C (`1e20`), and `9223372036854775807` is taken by an integer (JSON.parse()
+makes it 2^63, kept as such). Two differences remain, because a JS number
+cannot carry them: an integer beyond 2^53 is rounded, and `2.0` (and `-0.0`) is
+the integer (see `tests/fixtures/attr_types_parity.json`, which the C test
+`tests/c/attr_types` of yunetas reads too).
 
 ### Events & Pub-Sub
 
@@ -1014,7 +1033,14 @@ Key attributes: `url`, `jwt`, `wanted_yuno_role`, `wanted_yuno_name`, `wanted_yu
 
 Its events (`EV_ON_OPEN`, `EV_ON_CLOSE`, `EV_ON_OPEN_ERROR`, `EV_ON_ID_NAK` and every message that names no service) are PUBLISHED: to the `subscriber` attr, else, for a pure child, to its parent, which it subscribes in `mt_create` — one subscription, as the C transport. Up to 7.26.21 a pure child SENT three of them to its parent and subscribed nobody, so its parent never heard `EV_ON_CLOSE` / `EV_ON_OPEN_ERROR`: a host of a pure child must declare both in its FSM (BREAKING in 7.26.22).
 
-A message that names no service is published only when its event is declared by some registered gclass (`gobj_find_event_type()`); any other is dropped with a WARNING, its name masked (7.26.24). What the server gets wrong is a WARNING, never an ERROR. Before the session only `EV_IDENTITY_CARD_ACK` is taken; a `dst_role` or `dst_yuno` that is not this yuno's closes the channel too (an empty one is legal: anybody's), as the C transport does; an event that the named service does not take as public is dropped (7.26.24).
+A message that names no service is published only when its event is declared PUBLIC by some registered gclass (`gobj_find_event_type(name, EVF_PUBLIC_EVENT)`, as C's `gclass_find_public_event()`; 7.26.24 took any declaration, 7.26.25 requires it public); any other is dropped with a WARNING, its name masked. The events the transport says itself (`EV_ON_OPEN`, `EV_ON_CLOSE`, `EV_ON_OPEN_ERROR`, `EV_ON_ID_NAK`, `EV_TIMEOUT`, `EV_ON_MESSAGE`, and `EV_IDENTITY_CARD_ACK` in session) are never taken from the server, in any case of letters and whatever service the message names: a WARNING, dropped (7.26.25). A backend event an app receives must therefore be declared `EVF_PUBLIC_EVENT` in the gclass that receives it:
+
+```javascript
+const event_types = [
+    ["EV_MT_COMMAND_ANSWER",    event_flag_t.EVF_PUBLIC_EVENT],
+    ["EV_REALTIME_ALARM",       event_flag_t.EVF_PUBLIC_EVENT],
+];
+``` What the server gets wrong is a WARNING, never an ERROR. Before the session only `EV_IDENTITY_CARD_ACK` is taken; a `dst_role` or `dst_yuno` that is not this yuno's closes the channel too (an empty one is legal: anybody's), as the C transport does; an event that the named service does not take as public is dropped (7.26.24). A channel closed for a fault of the server is closed with **4002**, not 1000 (a browser may send only 1000 or 3000-4999, so 1002 cannot be used), so `EV_ON_CLOSE` says the session was cut (7.26.25).
 
 `EV_ON_CLOSE` carries `code`, `reason` (masked) and `was_clean`, and so does `EV_ON_OPEN_ERROR` (7.26.24). A session that ends cleanly (a stop, a logout, the server closing with 1000 or 1001) is logged by nobody; a session CUT -- not clean, or any other code (1006, 1008, 1011) -- is one WARNING with the code and the reason masked:
 
@@ -1038,7 +1064,9 @@ naming services it does not host.
 what breaks lockstep, so N links that dropped together do not stampede a backend
 that is just coming back. The backoff resets when a session is actually reached,
 and on `mt_start` — a deliberate reconnect never inherits a previous run's
-penalty. For the old fixed-interval behaviour set `timeout_retry_max` equal to
+penalty. A session the transport closes for a fault of the server (4002) does not
+count as reached: the backoff goes on from where it was (7.26.25), so a server
+that breaks every session is not reconnected at the first delay for ever. For the old fixed-interval behaviour set `timeout_retry_max` equal to
 `timeout_retry`.
 
 ---

package/dist/gobj-js.cjs.js

@@ -870,12 +870,48 @@ var JSON_NUMBER_TOKEN = /-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/y;
 function is_surrogate_pair(high, low) {
 	return high >= 55296 && high <= 56319 && low >= 56320 && low <= 57343;
 }
+var JSON_MAX_DEPTH = 2048;
 function json_text_refused_by_c(s) {
 	const n = s.length;
 	let i = 0;
+	let depth = 0;
+	const in_object = [];
+	let key_next = false;
 	while (i < n) {
 		const c = s.charCodeAt(i);
+		if (c === 123 || c === 91) {
+			depth++;
+			if (depth > JSON_MAX_DEPTH) return true;
+			in_object.push(c === 123);
+			key_next = c === 123;
+			i++;
+			continue;
+		}
+		if (c === 125 || c === 93) {
+			depth--;
+			in_object.pop();
+			key_next = false;
+			i++;
+			continue;
+		}
+		if (c === 44) {
+			key_next = in_object.length > 0 && in_object[in_object.length - 1];
+			i++;
+			continue;
+		}
+		if (c === 58) {
+			key_next = false;
+			i++;
+			continue;
+		}
+		if (c === 116 || c === 102 || c === 110) {
+			if (depth + 1 > JSON_MAX_DEPTH) return true;
+			i += c === 102 ? 5 : 4;
+			continue;
+		}
 		if (c === 34) {
+			if (!key_next && depth + 1 > JSON_MAX_DEPTH) return true;
+			key_next = false;
 			i++;
 			while (i < n) {
 				const d = s.charCodeAt(i);
@@ -908,6 +944,7 @@ function json_text_refused_by_c(s) {
 			continue;
 		}
 		if (c === 45 || c >= 48 && c <= 57) {
+			if (depth + 1 > JSON_MAX_DEPTH) return true;
 			JSON_NUMBER_TOKEN.lastIndex = i;
 			const m = JSON_NUMBER_TOKEN.exec(s);
 			if (!m) return true;
@@ -946,7 +983,7 @@ function shape_of_value(value) {
 	if (is_array(value)) return "an array";
 	if (is_object(value)) return "an object";
 	if (is_string(value)) return REFUSED_TEXT;
-	if (typeof value === "number") return Number.isInteger(value) ? "an integer" : "a real";
+	if (typeof value === "number") return Number.isInteger(value) && Math.abs(value) <= 0x8000000000000000 ? "an integer" : "a real";
 	if (typeof value === "boolean") return "a boolean";
 	return "null";
 }
@@ -967,7 +1004,7 @@ function number_as_type(type, value) {
 		value: value ? 1 : 0,
 		refused: null
 	};
-	if (!(value >= -0x8000000000000000 && value < 0x8000000000000000)) return {
+	if (!(value >= -0x8000000000000000 && value <= 0x8000000000000000)) return {
 		value: void 0,
 		refused: "a number out of its range"
 	};
@@ -1128,6 +1165,10 @@ function command_parameter_from_json(type, value) {
 		refused: shape_of_value(value)
 	};
 	if (DTP_IS_NUMBER(type)) return number_as_type(type, value);
+	if (!is_json_value(value)) return {
+		value: void 0,
+		refused: NO_JSON_TEXT
+	};
 	return {
 		value,
 		refused: null
@@ -1146,8 +1187,34 @@ var TYPES_READ = [
 	data_type_t.DTP_LIST,
 	data_type_t.DTP_DICT
 ];
+var LEAVE_NODE = Symbol("leave");
+function is_json_value(value) {
+	const on_path = /* @__PURE__ */ new Set();
+	const stack = [value];
+	while (stack.length) {
+		const v = stack.pop();
+		if (v === LEAVE_NODE) {
+			on_path.delete(stack.pop());
+			continue;
+		}
+		if (typeof v === "bigint") return false;
+		if (v === null || typeof v !== "object") continue;
+		if (on_path.has(v)) return false;
+		const array = Array.isArray(v);
+		if (!array) {
+			const proto = Object.getPrototypeOf(v);
+			if (proto !== Object.prototype && proto !== null) return false;
+		}
+		on_path.add(v);
+		stack.push(v, LEAVE_NODE);
+		if (array) for (let i = 0; i < v.length; i++) stack.push(v[i]);
+		else for (const key of Object.keys(v)) stack.push(v[key]);
+	}
+	return true;
+}
 var NO_JSON_TEXT = "a value with no json text";
 function json_text_of(value) {
+	if (!is_json_value(value)) return;
 	try {
 		const s = JSON.stringify(value);
 		return is_string(s) ? s : void 0;
@@ -4106,6 +4173,35 @@ function is_secret_name_tail(str, from, to, names) {
 	}
 	return secret_name_check(str, i, to, true, by_segments);
 }
+function param_name_tail_from(str, from, to) {
+	let bytes = 0;
+	let i = to;
+	while (i > from) {
+		const code = str.charCodeAt(i - 1);
+		let n = 3;
+		let units = 1;
+		if (code < 128) n = 1;
+		else if (code < 2048) n = 2;
+		else if (code >= 56320 && code <= 57343 && i - 2 >= from) {
+			const high = str.charCodeAt(i - 2);
+			if (high >= 55296 && high <= 56319) {
+				n = 4;
+				units = 2;
+			}
+		}
+		if (bytes + n > MASK_MAX_NAME) return -1;
+		if (code === 38 || code === 63 || code === 59) return i;
+		bytes += n;
+		i -= units;
+	}
+	return -1;
+}
+function is_param_name_secret(str, from, to, names) {
+	const tail = names === NAMES_NOW ? param_name_tail_from(str, from, to) : -1;
+	if (tail < 0) return is_secret_name_tail(str, from, to, names);
+	if (is_secret_name_tail(str, from, to, NAMES_7_26_9)) return true;
+	return is_secret_name_tail(str, from, to, NAMES_NOW) && secret_name_check(str, tail, to, false, true);
+}
 /************************************************************
 *  Where an unquoted secret value that begins at `p` ends: at
 *  the end, at the quote that closes an outer quoted value, or
@@ -4403,7 +4499,7 @@ function mark_params(str, value_is_secret, reading, marks, judged) {
 		}
 		const name_from = word;
 		word = p + 1;
-		const secret = is_secret_name_tail(str, name_from, p, names);
+		const secret = is_param_name_secret(str, name_from, p, names);
 		if (secret && names === NAMES_NOW && !not_7_26_9 && !is_secret_name_tail(str, name_from, p, NAMES_7_26_9)) not_7_26_9 = true;
 		if (!(secret || value_is_secret && p - name_from === 5 && ascii_case_equal(str, name_from, "value"))) {
 			if (judged && query_name_from(str, p) === name_from) judged[p] = JUDGED_NOT_SECRET;
@@ -4590,7 +4686,7 @@ function mark_labels(str, marks) {
 			p++;
 			continue;
 		}
-		if (!is_secret_name_tail(str, word, p, NAMES_NOW)) {
+		if (!is_param_name_secret(str, word, p, NAMES_NOW)) {
 			p++;
 			word = p;
 			continue;
@@ -4619,6 +4715,50 @@ function inline_value_is_secret(str, names) {
 	}
 	return false;
 }
+function mark_inline_rules_of_now(str, marks) {
+	const value_is_secret = inline_value_is_secret(str, NAMES_NOW);
+	const judged = new Uint8Array(str.length);
+	mark_params(str, value_is_secret, READ_NOW, marks, judged);
+	mark_query_params(str, marks, judged);
+	mark_url_passwords(str, marks);
+	mark_shapes(str, marks);
+	mark_labels(str, marks);
+}
+var MASK_MAX_DECODINGS = 2;
+function encoded_ascii_at(str, p) {
+	if (p + 3 > str.length || str.charCodeAt(p) !== 37) return -1;
+	const hi = hex_digit_value(str.charCodeAt(p + 1));
+	const lo = hi >= 0 ? hex_digit_value(str.charCodeAt(p + 2)) : -1;
+	if (lo < 0) return -1;
+	const c = hi * 16 + lo;
+	return c > 0 && c < 128 ? c : -1;
+}
+function mark_decoded_view(str, marks, decodings) {
+	if (decodings >= MASK_MAX_DECODINGS) return;
+	const pieces = [];
+	let last = 0;
+	let p = str.indexOf("%");
+	while (p >= 0) {
+		const c = encoded_ascii_at(str, p);
+		if (c >= 0) {
+			pieces.push(str.substring(last, p), String.fromCharCode(c));
+			last = p + 3;
+			p = str.indexOf("%", last);
+		} else p = str.indexOf("%", p + 1);
+	}
+	if (pieces.length === 0) return;
+	pieces.push(str.substring(last));
+	const view = pieces.join("");
+	const view_marks = new Uint8Array(view.length);
+	mark_inline_rules_of_now(view, view_marks);
+	mark_decoded_view(view, view_marks, decodings + 1);
+	let q = 0;
+	for (let i = 0; i < view.length; i++) {
+		const n = encoded_ascii_at(str, q) >= 0 ? 3 : 1;
+		if (view_marks[i]) mark_range(marks, q, q + n);
+		q += n;
+	}
+}
 function mark_inline_secrets(str, marks) {
 	const value_is_secret = inline_value_is_secret(str, NAMES_NOW);
 	const value_is_secret_7_26_9 = inline_value_is_secret(str, NAMES_7_26_9);
@@ -4629,6 +4769,7 @@ function mark_inline_secrets(str, marks) {
 	mark_url_passwords(str, marks);
 	mark_shapes(str, marks);
 	mark_labels(str, marks);
+	mark_decoded_view(str, marks, 0);
 }
 /************************************************************
 *  A text (a command line) with the secrets that can be told
@@ -4640,13 +4781,14 @@ function mark_inline_secrets(str, marks) {
 *  same for a "name: value", its name in quotes or not (a json, a
 *  header, a label: "password": x, Authorization: Basic x, bearer:
 *  tok); and a JWT or the credential after "Bearer " or "Basic ",
-*  wherever they are, whatever names them. Each rule judges the text
-*  as it came. Return null when there was nothing to mask. As the C
-*  kernel's mask_secrets_inline().
+*  wherever they are, whatever names them; in a URL or a query
+*  %-encoded inside a value, the same read decoded (mark_decoded_view()).
+*  Each rule judges the text as it came. Return null when there was
+*  nothing to mask. As the C kernel's mask_secrets_inline().
 ************************************************************/
 function mask_secrets_inline(str) {
 	if (typeof str !== "string") return null;
-	if (str.indexOf("=") < 0 && str.indexOf(":") < 0 && str.indexOf("eyJ") < 0 && !/bearer|basic/i.test(str)) return null;
+	if (str.indexOf("=") < 0 && str.indexOf(":") < 0 && str.indexOf("%") < 0 && str.indexOf("eyJ") < 0 && !/bearer|basic/i.test(str)) return null;
 	if (str.length > MASK_MAX_BYTES) return MASK_TOO_LARGE;
 	const marks = new Uint8Array(str.length);
 	mark_inline_secrets(str, marks);
@@ -8409,7 +8551,8 @@ var PRIVATE_DATA = {
 	inform_on_close: false,
 	websocket: null,
 	inside_on_open: false,
-	retry_ms: 0
+	retry_ms: 0,
+	retry_ms_before_session: 0
 };
 var __gclass__ = null;
 /******************************
@@ -8460,6 +8603,7 @@ function mt_writing(gobj, path) {
 function mt_start(gobj) {
 	let priv = gobj.priv;
 	priv.retry_ms = 0;
+	priv.retry_ms_before_session = 0;
 	if (gobj_current_state(gobj) !== "ST_DISCONNECTED") {
 		gobj_send_event(gobj, "EV_ON_CLOSE", {
 			url: priv.url,
@@ -8659,6 +8803,26 @@ function close_websocket(gobj, code = 1e3, reason = "") {
 	}
 }
 /***************************************************************
+*  Close the channel for a fault of the server: a message for a role
+*  or a yuno that is not this one, an event out of its place.
+*
+*  Not with 1000: EV_ON_CLOSE would say the session ended well. A
+*  browser closes a WebSocket only with 1000 or 3000-4999 (1002, the
+*  protocol error, throws there), so it is 4002 -- and the server
+*  echoes it, so EV_ON_CLOSE carries it.
+*
+*  And a session the server broke was not a session reached: the
+*  backoff the ack reset is put back, or a server that breaks every
+*  session is reconnected at the first delay for ever, with an
+*  EV_ON_OPEN and an EV_ON_CLOSE in the app per round.
+***************************************************************/
+var CLOSE_PEER_FAULT = 4002;
+function close_for_peer_fault(gobj, reason) {
+	let priv = gobj.priv;
+	if (gobj_current_state(gobj) === "ST_SESSION") priv.retry_ms = priv.retry_ms_before_session;
+	close_websocket(gobj, CLOSE_PEER_FAULT, reason);
+}
+/***************************************************************
 *  A text of the server -- a frame, the name of an event, of a
 *  service, of a role -- as a log shows it: masked, then capped on a
 *  whole character (capped first, a credential the cap cut would
@@ -8940,7 +9104,8 @@ function ac_on_close(gobj, event, kw, src) {
 *
 *  Reset to zero when a session is actually reached
 *  (ac_identity_card_ack), so a link that flaps once does not carry a
-*  minute-long penalty into its next real drop.
+*  minute-long penalty into its next real drop -- and put back when the
+*  server breaks that session (close_for_peer_fault()).
 ***************************************************************/
 function next_retry(gobj) {
 	let priv = gobj.priv;
@@ -8990,6 +9155,7 @@ function ac_identity_card_ack(gobj, event, kw, src) {
 	} else {
 		gobj_change_state(gobj, "ST_SESSION");
 		priv.inside_on_open = true;
+		priv.retry_ms_before_session = priv.retry_ms;
 		priv.retry_ms = 0;
 		if (!priv.inform_on_close) {
 			priv.inform_on_close = true;
@@ -9029,7 +9195,7 @@ function ac_on_message(gobj, event, kw, src) {
 		if (String(iev_event).toLowerCase() === "ev_identity_card_ack") {
 			if (!(gobj_send_event(gobj, "EV_IDENTITY_CARD_ACK", iev_kw, gobj) < 0)) return 0;
 		} else log_warning(`${gobj_short_name(gobj)}: event UNKNOWN in not-session state ${peer_text_shown(iev_event, PEER_NAME_SHOWN)}`);
-		close_websocket(gobj);
+		close_for_peer_fault(gobj, "event out of session");
 		return -1;
 	}
 	iev_msg = null;
@@ -9038,13 +9204,13 @@ function ac_on_message(gobj, event, kw, src) {
 	let iev_dst_role = kw_get_str(gobj, event_id, "dst_role", "");
 	if (!empty_string(iev_dst_role) && iev_dst_role.toLowerCase() !== String(gobj_yuno_role()).toLowerCase()) {
 		log_warning(`${gobj_short_name(gobj)}: It's not my role, dst_role: ${peer_text_shown(iev_dst_role, PEER_NAME_SHOWN)}, my_role: ${gobj_yuno_role()}, event: ${peer_text_shown(iev_event, PEER_NAME_SHOWN)}`);
-		close_websocket(gobj);
+		close_for_peer_fault(gobj, "not my role");
 		return -1;
 	}
 	let iev_dst_yuno = kw_get_str(gobj, event_id, "dst_yuno", "");
 	if (!empty_string(iev_dst_yuno) && iev_dst_yuno.toLowerCase() !== String(gobj_yuno_name()).toLowerCase()) {
 		log_warning(`${gobj_short_name(gobj)}: It's not my name, dst_yuno: ${peer_text_shown(iev_dst_yuno, PEER_NAME_SHOWN)}, my_name: ${gobj_yuno_name()}, event: ${peer_text_shown(iev_event, PEER_NAME_SHOWN)}`);
-		close_websocket(gobj);
+		close_for_peer_fault(gobj, "not my name");
 		return -1;
 	}
 	let iev_dst_service = kw_get_str(gobj, event_id, "dst_service", "");
@@ -9056,8 +9222,14 @@ function ac_on_message(gobj, event, kw, src) {
 		log_warning(`${gobj_short_name(gobj)}: unsubscription event ignored, I'm client (service: ${peer_text_shown(iev_dst_service, PEER_NAME_SHOWN)}, event: ${peer_text_shown(iev_event, PEER_NAME_SHOWN)})`);
 		return -1;
 	}
-	if (gobj_has_event(gobj, iev_event, event_flag_t.EVF_PUBLIC_EVENT)) {
-		gobj_send_event(gobj, iev_event, iev_kw, gobj);
+	const declared = gobj_find_event_type(iev_event, 0, false);
+	if (declared && gobj_has_event(gobj, declared.event_name, 0)) {
+		const own_event = declared.event_name;
+		if (!gobj_has_event(gobj, own_event, event_flag_t.EVF_PUBLIC_EVENT) || own_event === "EV_IDENTITY_CARD_ACK") {
+			log_warning(`${gobj_short_name(gobj)}: event of the transport itself, or out of its place, DROPPED: ev '${peer_text_shown(iev_event, PEER_NAME_SHOWN)}'`);
+			return -1;
+		}
+		gobj_send_event(gobj, own_event, iev_kw, gobj);
 		return 0;
 	}
 	if (!empty_string(iev_dst_service)) {
@@ -9073,9 +9245,9 @@ function ac_on_message(gobj, event, kw, src) {
 		gobj_send_event(gobj_service, iev_event, iev_kw, gobj);
 		return 0;
 	}
-	let event_type = gobj_find_event_type(iev_event, 0, false);
+	let event_type = gobj_find_event_type(iev_event, event_flag_t.EVF_PUBLIC_EVENT, false);
 	if (!event_type) {
-		log_warning(`${gobj_short_name(gobj)}: event that no gclass declares, DROPPED: ev '${peer_text_shown(iev_event, PEER_NAME_SHOWN)}'`);
+		log_warning(`${gobj_short_name(gobj)}: event that no gclass declares public, DROPPED: ev '${peer_text_shown(iev_event, PEER_NAME_SHOWN)}'`);
 		return -1;
 	}
 	gobj_publish_event(gobj, event_type.event_name, iev_kw);
@@ -9198,7 +9370,7 @@ function create_gclass(gclass_name) {
 	__gclass__ = gclass_create(gclass_name, [
 		["EV_ON_MESSAGE", event_flag_t.EVF_OUTPUT_EVENT],
 		["EV_IDENTITY_CARD_ACK", event_flag_t.EVF_PUBLIC_EVENT],
-		["EV_ON_ID_NAK", event_flag_t.EVF_PUBLIC_EVENT | event_flag_t.EVF_OUTPUT_EVENT],
+		["EV_ON_ID_NAK", event_flag_t.EVF_OUTPUT_EVENT],
 		["EV_MT_STATS", event_flag_t.EVF_PUBLIC_EVENT],
 		["EV_MT_COMMAND", event_flag_t.EVF_PUBLIC_EVENT],
 		["EV_ON_OPEN", event_flag_t.EVF_OUTPUT_EVENT | event_flag_t.EVF_NO_WARN_SUBS],