@yuneta/gobj-js 7.26.20 → 7.26.22

package/dist/gobj-js.umd.js

@@ -219,6 +219,13 @@
 	var __yuno__ = null;
 	var __default_service__ = null;
 	var __inside__ = 0;
+	var frame_kind_t = Object.freeze({
+		FRAME_ACTION: 0,
+		FRAME_PUBLICATION: 1,
+		FRAME_METHOD: 2,
+		FRAME_WATCH: 3
+	});
+	var __dispatch_top__ = null;
 	/**************************************************************************
 	*              SData - Structured Data
 	**************************************************************************/
@@ -232,7 +239,15 @@
 		DTP_JSON: 7,
 		DTP_POINTER: 8
 	});
+	var DTP_IS_STRING = (type) => type === data_type_t.DTP_STRING;
+	var DTP_IS_BOOLEAN = (type) => type === data_type_t.DTP_BOOLEAN;
+	var DTP_IS_INTEGER = (type) => type === data_type_t.DTP_INTEGER;
+	var DTP_IS_REAL = (type) => type === data_type_t.DTP_REAL;
+	var DTP_IS_LIST = (type) => type === data_type_t.DTP_LIST;
+	var DTP_IS_DICT = (type) => type === data_type_t.DTP_DICT;
+	var DTP_IS_JSON = (type) => type === data_type_t.DTP_JSON;
 	data_type_t.DTP_POINTER;
+	var DTP_IS_NUMBER = (type) => DTP_IS_INTEGER(type) || DTP_IS_REAL(type) || DTP_IS_BOOLEAN(type);
 	var sdata_flag_t = Object.freeze({
 		SDF_NOTACCESS: 1,
 		SDF_RD: 2,
@@ -254,7 +269,8 @@
 		SDF_AUTHZ_X: 131072,
 		SDF_AUTHZ_P: 262144,
 		SDF_AUTHZ_S: 524288,
-		SDF_AUTHZ_RS: 1048576
+		SDF_AUTHZ_RS: 1048576,
+		SDF_SECRET: 2097152
 	});
 	sdata_flag_t.SDF_RD | sdata_flag_t.SDF_WR | sdata_flag_t.SDF_STATS | sdata_flag_t.SDF_PERSIST | sdata_flag_t.SDF_VOLATIL | sdata_flag_t.SDF_RSTATS | sdata_flag_t.SDF_PSTATS;
 	sdata_flag_t.SDF_WR | sdata_flag_t.SDF_PERSIST;
@@ -842,6 +858,260 @@
 		return 0;
 	}
 	/***************************************************************************
+	*  A value of a type, written as text or given as json, read as the C
+	*  command parser reads a parameter (command_parser.c): the same grammar,
+	*  the same refusals, so that a C client and a JS client read an attribute
+	*  value the same way (json2item()). A refusal says why in a short phrase,
+	*  never the value: it may be a secret.
+	***************************************************************************/
+	var JSON_INTEGER_TEXT = /^-?(0|[1-9][0-9]*)$/;
+	var JSON_NUMBER_TEXT = /^-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?$/;
+	var INT64_MIN = -(2n ** 63n);
+	var INT64_MAX = 2n ** 63n - 1n;
+	var REFUSED_TEXT = "a text that does not read as one";
+	function value_has_shape(type, value) {
+		if (DTP_IS_STRING(type)) return is_string(value);
+		if (DTP_IS_DICT(type)) return is_object(value);
+		if (DTP_IS_LIST(type)) return is_array(value);
+		if (DTP_IS_NUMBER(type)) return typeof value === "number" || typeof value === "boolean";
+		return true;
+	}
+	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 === "boolean") return "a boolean";
+		return "null";
+	}
+	function number_as_type(type, value) {
+		if (typeof value === "number" && !Number.isFinite(value)) return {
+			value: void 0,
+			refused: "a number out of its range"
+		};
+		if (DTP_IS_BOOLEAN(type)) return {
+			value: typeof value === "boolean" ? value : value !== 0,
+			refused: null
+		};
+		if (DTP_IS_REAL(type)) return {
+			value: typeof value === "boolean" ? value ? 1 : 0 : value,
+			refused: null
+		};
+		if (typeof value === "boolean") return {
+			value: value ? 1 : 0,
+			refused: null
+		};
+		if (!(value >= -0x8000000000000000 && value < 0x8000000000000000)) return {
+			value: void 0,
+			refused: "a number out of its range"
+		};
+		if (!Number.isInteger(value)) return {
+			value: void 0,
+			refused: "a real with decimals"
+		};
+		return {
+			value,
+			refused: null
+		};
+	}
+	function text2parameter(type, s, from_kw) {
+		if (!is_string(s)) s = "";
+		if (DTP_IS_STRING(type)) return {
+			value: s,
+			refused: null
+		};
+		if (DTP_IS_NUMBER(type)) {
+			if (s.length === 0) {
+				if (from_kw) return {
+					value: void 0,
+					refused: null
+				};
+				return {
+					value: DTP_IS_BOOLEAN(type) ? false : 0,
+					refused: null
+				};
+			}
+			if (DTP_IS_BOOLEAN(type)) {
+				const lower = s.toLowerCase();
+				if (lower === "true" || lower === "yes" || lower === "on") return {
+					value: true,
+					refused: null
+				};
+				if (lower === "false" || lower === "no" || lower === "off") return {
+					value: false,
+					refused: null
+				};
+			}
+			if (!(DTP_IS_REAL(type) ? JSON_NUMBER_TEXT : JSON_INTEGER_TEXT).test(s)) return {
+				value: void 0,
+				refused: REFUSED_TEXT
+			};
+			if (DTP_IS_REAL(type)) {
+				const d = Number(s);
+				if (!Number.isFinite(d)) return {
+					value: void 0,
+					refused: "a number out of its range"
+				};
+				return {
+					value: d,
+					refused: null
+				};
+			}
+			const n = BigInt(s);
+			if (n < INT64_MIN || n > INT64_MAX) return {
+				value: void 0,
+				refused: "a number out of its range"
+			};
+			if (DTP_IS_BOOLEAN(type)) return {
+				value: n !== 0n,
+				refused: null
+			};
+			return {
+				value: Number(n),
+				refused: null
+			};
+		}
+		if (DTP_IS_DICT(type) || DTP_IS_LIST(type)) {
+			let jn;
+			try {
+				jn = JSON.parse(s);
+			} catch (e) {
+				return {
+					value: void 0,
+					refused: REFUSED_TEXT
+				};
+			}
+			if (!value_has_shape(type, jn)) return {
+				value: void 0,
+				refused: REFUSED_TEXT
+			};
+			return {
+				value: jn,
+				refused: null
+			};
+		}
+		if (DTP_IS_JSON(type)) try {
+			return {
+				value: JSON.parse(s),
+				refused: null
+			};
+		} catch (e) {
+			const t = s.replace(/^[ \t]+/, "");
+			if (t.startsWith("{") || t.startsWith("[") || t.startsWith("\"")) return {
+				value: void 0,
+				refused: REFUSED_TEXT
+			};
+			return {
+				value: s,
+				refused: null
+			};
+		}
+		return {
+			value: void 0,
+			refused: REFUSED_TEXT
+		};
+	}
+	/***************************************************************************
+	*  A value of `type` written as TEXT, read as the C parser reads a
+	*  parameter on the command line (command_parameter_from_text()): an empty
+	*  text is 0 or false. Return {value, refused}: `value` undefined when the
+	*  text does not read as one, `refused` saying why.
+	***************************************************************************/
+	function command_parameter_from_text(type, text) {
+		const r = text2parameter(type, text, false);
+		if (r.value === void 0 && !r.refused) r.refused = REFUSED_TEXT;
+		return r;
+	}
+	/***************************************************************************
+	*  A value of `type` given as JSON, read as the C parser reads a
+	*  parameter given in kw (command_parameter_from_json()): a string as
+	*  command_parameter_from_text() reads a text (a string with a NUL inside
+	*  refused), a number or a boolean as the EXACT type (an integer to a
+	*  DTP_REAL is its real, a boolean to a DTP_INTEGER 1 or 0, 2.7 to a
+	*  DTP_INTEGER refused), an object or a list of its shape as it is, any
+	*  other shape refused. Return {value, refused}: `value` undefined and
+	*  `refused` saying why, or `refused` null when there is NO value (a null,
+	*  undefined, or an empty text given to a number).
+	***************************************************************************/
+	function command_parameter_from_json(type, value) {
+		if (value === void 0 || value === null) {
+			if (DTP_IS_JSON(type) && value === null) return {
+				value: null,
+				refused: null
+			};
+			return {
+				value: void 0,
+				refused: null
+			};
+		}
+		const nul_inside = is_string(value) && value.indexOf("\0") >= 0;
+		if (DTP_IS_JSON(type)) {
+			if (!is_string(value) || nul_inside) return {
+				value,
+				refused: null
+			};
+			const r = text2parameter(type, value, true);
+			return r.value === void 0 ? {
+				value,
+				refused: null
+			} : r;
+		}
+		if (!(DTP_IS_STRING(type) || DTP_IS_DICT(type) || DTP_IS_LIST(type) || DTP_IS_NUMBER(type))) return {
+			value,
+			refused: null
+		};
+		if (nul_inside) return {
+			value: void 0,
+			refused: "a text with a NUL in it"
+		};
+		if (is_string(value) && !DTP_IS_STRING(type)) return text2parameter(type, value, true);
+		if (!value_has_shape(type, value)) return {
+			value: void 0,
+			refused: shape_of_value(value)
+		};
+		if (DTP_IS_NUMBER(type)) return number_as_type(type, value);
+		return {
+			value,
+			refused: null
+		};
+	}
+	/***************************************************************************
+	*  A value json2item() refuses: the attr, its type and why, and the value
+	*  as a log may show it (a SDF_SECRET one never; any other masked, then
+	*  capped on a whole character, as in C)
+	***************************************************************************/
+	var ATTR_VALUE_SHOWN = 64;
+	var TYPES_READ = [
+		data_type_t.DTP_BOOLEAN,
+		data_type_t.DTP_INTEGER,
+		data_type_t.DTP_REAL,
+		data_type_t.DTP_LIST,
+		data_type_t.DTP_DICT
+	];
+	function log_attr_value_refused(gobj, it, value, refused) {
+		const types = {
+			[data_type_t.DTP_BOOLEAN]: "a boolean",
+			[data_type_t.DTP_INTEGER]: "an integer",
+			[data_type_t.DTP_REAL]: "a real",
+			[data_type_t.DTP_LIST]: "a json array",
+			[data_type_t.DTP_DICT]: "a json object"
+		};
+		let shown;
+		if (it.flag & sdata_flag_t.SDF_SECRET) shown = "********";
+		else {
+			shown = is_string(value) ? value : String(JSON.stringify(value === void 0 ? null : value));
+			const masked = mask_secrets_inline(shown);
+			if (masked !== null) shown = masked;
+			if (shown.length > ATTR_VALUE_SHOWN) {
+				let n = ATTR_VALUE_SHOWN;
+				const code = shown.charCodeAt(n);
+				if (code >= 56320 && code <= 57343) n--;
+				shown = shown.substring(0, n);
+			}
+		}
+		log_error(`${gobj_short_name(gobj)}: Attribute value of the wrong type, not written: attr '${it.name}', type ${types[it.type] || "a value of its type"}, got ${refused || "no value (a null, or an empty text)"}, value '${shown}'`);
+	}
+	/***************************************************************************
 	*  Set array values to sdata, from json or binary
 	***************************************************************************/
 	function json2item(gobj, sdata, it, jn_value_) {
@@ -856,44 +1126,18 @@
 				}
 				break;
 			case data_type_t.DTP_BOOLEAN:
-				jn_value2 = parseBoolean(jn_value_);
-				break;
 			case data_type_t.DTP_INTEGER:
-				jn_value2 = parseInt(jn_value_);
-				if (isNaN(jn_value2)) {
-					log_error(`${gobj_short_name(gobj)}: attr NaN: ${it.name}`);
-					return -1;
-				}
-				break;
 			case data_type_t.DTP_REAL:
-				jn_value2 = Number(jn_value_);
-				if (isNaN(jn_value2)) {
-					log_error(`${gobj_short_name(gobj)}: attr NaN: ${it.name}`);
-					return -1;
-				}
-				break;
 			case data_type_t.DTP_LIST:
-				if (is_string(jn_value_)) try {
-					jn_value2 = JSON.parse(jn_value_);
-				} catch (error) {
-					log_error(`JSON parse error: ${error.message}`);
-				}
-				else jn_value2 = jn_value_;
-				if (!is_array(jn_value2)) {
-					log_error(`attr must be an array: ${it.name}`);
-					return -1;
-				}
-				break;
 			case data_type_t.DTP_DICT:
-				if (is_string(jn_value_)) try {
-					jn_value2 = JSON.parse(jn_value_);
-				} catch (error) {
-					log_error(`JSON parse error: ${error.message}`);
-				}
-				else jn_value2 = jn_value_;
-				if (!is_object(jn_value2)) {
-					log_error(`attr must be an object: ${it.name}`);
-					return -1;
+				{
+					if (jn_value_ === void 0) return 0;
+					const r = command_parameter_from_json(it.type, jn_value_);
+					if (r.value === void 0) {
+						log_attr_value_refused(gobj, it, jn_value_, r.refused);
+						return -1;
+					}
+					jn_value2 = r.value;
 				}
 				break;
 			case data_type_t.DTP_JSON:
@@ -1468,6 +1712,8 @@
 			return;
 		}
 		if (gobj.__refs__ > 0) log_error(`${gobj_short_name(gobj)}: gobj DESTROYING with references: ${gobj.__refs__}`);
+		if (!(gobj.parent && gobj_is_destroying(gobj.parent))) check_destroy_under_running_code(gobj);
+		mark_dispatch_frames_destroyed(gobj);
 		if (gobj.playing) {
 			log_error(`Destroying a PLAYING gobj: ${gobj_full_name(gobj)}`);
 			gobj_pause(gobj);
@@ -1532,10 +1778,44 @@
 		if (__trace_gobj_start_stop__(gobj)) trace_machine(sprintf("⏺ ⏺ start: %s", gobj_full_name(gobj)));
 		gobj.running = true;
 		let ret = 0;
-		if (gobj.gclass.gmt.mt_start) ret = gobj.gclass.gmt.mt_start(gobj);
+		if (gobj.gclass.gmt.mt_start) {
+			const frame = push_dispatch_frame(gobj, "mt_start", frame_kind_t.FRAME_METHOD);
+			try {
+				ret = gobj.gclass.gmt.mt_start(gobj);
+			} finally {
+				pop_dispatch_frame(frame);
+			}
+		}
 		return ret;
 	}
 	/***************************************************************************
+	*  Start a gobj in a walk of its tree, and say whether that destroyed it.
+	*
+	*  A gclass may end itself in its own mt_start or mt_stop, and a walk of
+	*  the tree must not go down into the children of a gobj that is gone.
+	***************************************************************************/
+	function start_destroys_it(gobj) {
+		const frame = push_dispatch_frame(gobj, "gobj_start", frame_kind_t.FRAME_WATCH);
+		try {
+			gobj_start(gobj);
+		} finally {
+			pop_dispatch_frame(frame);
+		}
+		return frame.destroyed;
+	}
+	/***************************************************************************
+	*  Stop a gobj in a walk of its tree, and say whether that destroyed it.
+	***************************************************************************/
+	function stop_destroys_it(gobj) {
+		const frame = push_dispatch_frame(gobj, "gobj_stop", frame_kind_t.FRAME_WATCH);
+		try {
+			gobj_stop(gobj);
+		} finally {
+			pop_dispatch_frame(frame);
+		}
+		return frame.destroyed;
+	}
+	/***************************************************************************
 	*  Start all children of the gobj.
 	***************************************************************************/
 	function cb_start_child(child, user_data, user_data2) {
@@ -1556,7 +1836,9 @@
 	function cb_start_child_tree(child, user_data, user_data2) {
 		if (child.gclass.gclass_flag & gclass_flag_t.gcflag_manual_start) return 1;
 		if (gobj_is_disabled(child)) return 1;
-		if (!gobj_is_running(child)) gobj_start(child);
+		if (!gobj_is_running(child)) {
+			if (start_destroys_it(child)) return 1;
+		}
 		return 0;
 	}
 	function gobj_start_tree(gobj) {
@@ -1567,7 +1849,9 @@
 		if (__trace_gobj_start_stop__(gobj)) trace_machine(sprintf("⏺ ⏺ ⏺ ⏺ start_tree: %s", gobj_full_name(gobj)));
 		if (gobj.gclass.gclass_flag & gclass_flag_t.gcflag_manual_start) return 0;
 		else if (gobj.disabled) return 0;
-		else if (!gobj.running) gobj_start(gobj);
+		else if (!gobj.running) {
+			if (start_destroys_it(gobj)) return 0;
+		}
 		return gobj_walk_gobj_children_tree(gobj, walk_type_t.WALK_TOP2BOTTOM, cb_start_child_tree, 0, 0);
 	}
 	/************************************************************
@@ -1589,14 +1873,23 @@
 		if (__trace_gobj_start_stop__(gobj)) trace_machine(sprintf("⏹ ⏹ stop: %s", gobj_full_name(gobj)));
 		gobj.running = false;
 		let ret = 0;
-		if (gobj.gclass.gmt.mt_stop) ret = gobj.gclass.gmt.mt_stop(gobj);
+		if (gobj.gclass.gmt.mt_stop) {
+			const frame = push_dispatch_frame(gobj, "mt_stop", frame_kind_t.FRAME_METHOD);
+			try {
+				ret = gobj.gclass.gmt.mt_stop(gobj);
+			} finally {
+				pop_dispatch_frame(frame);
+			}
+		}
 		return ret;
 	}
 	/***************************************************************************
 	*  Stop all children of the gobj.
 	***************************************************************************/
 	function cb_stop_child(child, user_data, user_data2) {
-		if (gobj_is_running(child)) gobj_stop(child);
+		if (gobj_is_running(child)) {
+			if (stop_destroys_it(child)) return 1;
+		}
 		return 0;
 	}
 	function gobj_stop_children(gobj) {
@@ -1615,7 +1908,9 @@
 			return -1;
 		}
 		if (__trace_gobj_start_stop__(gobj)) trace_machine(sprintf("⏹ ⏹ ⏹ ⏹ stop_tree: %s", gobj_full_name(gobj)));
-		if (gobj_is_running(gobj)) gobj_stop(gobj);
+		if (gobj_is_running(gobj)) {
+			if (stop_destroys_it(gobj)) return 0;
+		}
 		return gobj_walk_gobj_children_tree(gobj, walk_type_t.WALK_TOP2BOTTOM, cb_stop_child, 0, 0);
 	}
 	/************************************************************
@@ -1647,8 +1942,13 @@
 		gobj.playing = true;
 		let ret = 0;
 		if (gobj.gclass.gmt.mt_play) {
-			ret = gobj.gclass.gmt.mt_play(gobj);
-			if (ret < 0 || ret === false) gobj.playing = false;
+			const frame = push_dispatch_frame(gobj, "mt_play", frame_kind_t.FRAME_METHOD);
+			try {
+				ret = gobj.gclass.gmt.mt_play(gobj);
+			} finally {
+				pop_dispatch_frame(frame);
+			}
+			if ((ret < 0 || ret === false) && !frame.destroyed) gobj.playing = false;
 		}
 		return ret;
 	}
@@ -1666,8 +1966,14 @@
 		}
 		if (__trace_gobj_start_stop__(gobj)) trace_machine(sprintf("⏸ ⏸ pause: %s", gobj_full_name(gobj)));
 		gobj.playing = false;
-		if (gobj.gclass.gmt.mt_pause) return gobj.gclass.gmt.mt_pause(gobj);
-		else return 0;
+		if (gobj.gclass.gmt.mt_pause) {
+			const frame = push_dispatch_frame(gobj, "mt_pause", frame_kind_t.FRAME_METHOD);
+			try {
+				return gobj.gclass.gmt.mt_pause(gobj);
+			} finally {
+				pop_dispatch_frame(frame);
+			}
+		} else return 0;
 	}
 	/************************************************************
 	*
@@ -2220,14 +2526,7 @@
 		if (ss.length <= 1) {
 			let key = path;
 			if (key in jn_attrs) {
-				if (Object.prototype.hasOwnProperty.call(jn_attrs, key)) {
-					jn_attrs[key] = value;
-					if (is_object(gobj.priv) && Object.prototype.hasOwnProperty.call(gobj.priv, key)) gobj.priv[key] = value;
-					if (gobj.obflag & obflag_t.obflag_created && !(gobj.obflag & obflag_t.obflag_destroyed)) {
-						if (gobj.gclass.gmt.mt_writing) gobj.gclass.gmt.mt_writing(gobj, key);
-					}
-					return 0;
-				}
+				if (Object.prototype.hasOwnProperty.call(jn_attrs, key)) return write_attr_value(gobj, key, value);
 			}
 			log_error(sprintf("gobj_write_attr(%s): attr not found '%s'", gobj_short_name(gobj), key));
 			return -1;
@@ -2243,14 +2542,7 @@
 			}
 			let jn_attrs = gobj.jn_attrs;
 			if (key in jn_attrs) {
-				if (Object.prototype.hasOwnProperty.call(jn_attrs, key)) {
-					jn_attrs[key] = value;
-					if (is_object(gobj.priv) && Object.prototype.hasOwnProperty.call(gobj.priv, key)) gobj.priv[key] = value;
-					if (gobj.obflag & obflag_t.obflag_created && !(gobj.obflag & obflag_t.obflag_destroyed)) {
-						if (gobj.gclass.gmt.mt_writing) gobj.gclass.gmt.mt_writing(gobj, key);
-					}
-					return 0;
-				}
+				if (Object.prototype.hasOwnProperty.call(jn_attrs, key)) return write_attr_value(gobj, key, value);
 			}
 			break;
 		}
@@ -2258,6 +2550,49 @@
 		return -1;
 	}
 	/***************************************************************************
+	*  The value written to the attr `key` of `gobj`, read as its type as the C
+	*  kernel reads it (json2item(): it writes priv and calls mt_writing too).
+	*  Up to 7.26.21 gobj_write_attr() wrote it raw.
+	***************************************************************************/
+	function write_attr_value(gobj, key, value) {
+		const it = gobj_attr_desc(gobj, key, false);
+		if (!it) {
+			log_error(sprintf("gobj_write_attr(%s): attr without description '%s'", gobj_short_name(gobj), key));
+			return -1;
+		}
+		if (value === void 0 && TYPES_READ.includes(it.type)) {
+			log_attr_value_refused(gobj, it, value, null);
+			return -1;
+		}
+		return json2item(gobj, gobj.jn_attrs, it, value);
+	}
+	/***************************************************************************
+	*  The value a typed writer writes, read as ITS type by the grammar of
+	*  json2item() (a C writer takes its C type: a string is never read as a
+	*  number there). Return {value} or {refused} (logged): the attr keeps its
+	*  value. A string writer never refuses: null and undefined are "", any
+	*  other json its text, as a DTP_STRING attr reads them.
+	***************************************************************************/
+	function typed_writer_value(gobj, name, type, value) {
+		if (DTP_IS_STRING(type)) {
+			if (value === null || value === void 0) return { value: "" };
+			return { value: is_string(value) ? value : String(JSON.stringify(value)) };
+		}
+		const r = command_parameter_from_json(type, value);
+		if (r.value === void 0) {
+			let holder = gobj;
+			while (holder && !gobj_has_attr(holder, name)) holder = holder.bottom_gobj;
+			const it = holder ? gobj_attr_desc(holder, name, false) : null;
+			log_attr_value_refused(gobj, {
+				name,
+				type,
+				flag: it ? it.flag : 0
+			}, value, r.refused);
+			return { refused: true };
+		}
+		return { value: r.value };
+	}
+	/***************************************************************************
 	*  WRITE - high level
 	***************************************************************************/
 	function sdata_write_default_values(gobj, include_flag, exclude_flag) {
@@ -2305,7 +2640,9 @@
 	function gobj_write_bool_attr(gobj, name, value) {
 		let hs = gobj_hsdata2(gobj, name, false);
 		if (hs) {
-			hs[name] = parseBoolean(value);
+			const v = typed_writer_value(gobj, name, data_type_t.DTP_BOOLEAN, value);
+			if (v.refused) return -1;
+			hs[name] = v.value;
 			if (is_object(gobj.priv) && Object.prototype.hasOwnProperty.call(gobj.priv, name)) gobj.priv[name] = hs[name];
 			if (gobj.obflag & obflag_t.obflag_created && !(gobj.obflag & obflag_t.obflag_destroyed)) {
 				if (gobj.gclass.gmt.mt_writing) gobj.gclass.gmt.mt_writing(gobj, name);
@@ -2321,7 +2658,9 @@
 	function gobj_write_integer_attr(gobj, name, value) {
 		let hs = gobj_hsdata2(gobj, name, false);
 		if (hs) {
-			hs[name] = parseInt(value);
+			const v = typed_writer_value(gobj, name, data_type_t.DTP_INTEGER, value);
+			if (v.refused) return -1;
+			hs[name] = v.value;
 			if (is_object(gobj.priv) && Object.prototype.hasOwnProperty.call(gobj.priv, name)) gobj.priv[name] = hs[name];
 			if (gobj.obflag & obflag_t.obflag_created && !(gobj.obflag & obflag_t.obflag_destroyed)) {
 				if (gobj.gclass.gmt.mt_writing) gobj.gclass.gmt.mt_writing(gobj, name);
@@ -2337,7 +2676,9 @@
 	function gobj_write_str_attr(gobj, name, value) {
 		let hs = gobj_hsdata2(gobj, name, false);
 		if (hs) {
-			hs[name] = String(value);
+			const v = typed_writer_value(gobj, name, data_type_t.DTP_STRING, value);
+			if (v.refused) return -1;
+			hs[name] = v.value;
 			if (is_object(gobj.priv) && Object.prototype.hasOwnProperty.call(gobj.priv, name)) gobj.priv[name] = hs[name];
 			if (gobj.obflag & obflag_t.obflag_created && !(gobj.obflag & obflag_t.obflag_destroyed)) {
 				if (gobj.gclass.gmt.mt_writing) gobj.gclass.gmt.mt_writing(gobj, name);
@@ -2547,6 +2888,84 @@
 		__dl_posted_events__ = __dl_posted_events__.filter((msg) => msg.dst !== gobj);
 	}
 	/************************************************************
+	*  A dispatch begins: its frame goes on top of the chain.
+	*  Every push is paired with a pop in a `finally`: an action
+	*  that throws must not leave its frame on the chain.
+	************************************************************/
+	function push_dispatch_frame(gobj, event, kind) {
+		const frame = {
+			prev: __dispatch_top__,
+			gobj,
+			event,
+			kind,
+			destroyed: false
+		};
+		__dispatch_top__ = frame;
+		return frame;
+	}
+	function pop_dispatch_frame(frame) {
+		__dispatch_top__ = frame.prev;
+	}
+	/************************************************************
+	*  Every dispatch in progress of `gobj` learns that it is
+	*  destroyed. Only its own frames: each child destroyed with
+	*  it marks its own, in its own gobj_destroy().
+	************************************************************/
+	function mark_dispatch_frames_destroyed(gobj) {
+		for (let f = __dispatch_top__; f; f = f.prev) if (f.gobj === gobj) f.destroyed = true;
+	}
+	/************************************************************
+	*  Is the innermost live publication of `gobj` its EV_STOPPED?
+	*  Then the stop contract holds for it: that is the last thing
+	*  it does with itself.
+	************************************************************/
+	function said_farewell(gobj) {
+		for (let f = __dispatch_top__; f; f = f.prev) if (f.kind === frame_kind_t.FRAME_PUBLICATION && !f.destroyed && f.gobj === gobj) return f.event === "EV_STOPPED";
+		return false;
+	}
+	/************************************************************
+	*  A gobj must not be destroyed under code that is still
+	*  running on it -- the C kernel's check, with its exemptions
+	*  and its fields, so both runtimes report the same defect the
+	*  same way.
+	*
+	*  `gobj` is about to be destroyed, and with it its whole
+	*  subtree. Every live frame of a gobj of that subtree is code
+	*  that goes on when the destroy returns, on a gobj that is gone
+	*  (C_TIMER right after its EV_TIMEOUT). It is an ERROR, except
+	*  for:
+	*
+	*  - the innermost frame: it is the code that destroys, and
+	*    knows it (a gobj that destroys itself in its own action);
+	*
+	*  - the frames of a gobj whose innermost publication is
+	*    EV_STOPPED: the stop contract, its host destroys it there;
+	*
+	*  - the watch frames, which run no gclass code of their own.
+	*
+	*  The destroy goes on: this only says it, once. The fix is to
+	*  defer the destroy with gobj_post_event().
+	************************************************************/
+	function check_destroy_under_running_code(gobj) {
+		const top = __dispatch_top__;
+		if (!top) return;
+		for (let f = top.prev; f; f = f.prev) {
+			if (f.destroyed || f.kind === frame_kind_t.FRAME_WATCH) continue;
+			let in_tree = false;
+			for (let p = f.gobj; p; p = p.parent) if (p === gobj) {
+				in_tree = true;
+				break;
+			}
+			if (!in_tree) continue;
+			if (said_farewell(f.gobj)) continue;
+			const destroyer = top.destroyed ? "(destroyed)" : gobj_full_name(top.gobj);
+			const stack = String((/* @__PURE__ */ new Error()).stack || "").split("\n").slice(2).join("\n");
+			if (f.kind === frame_kind_t.FRAME_PUBLICATION) log_error(`Destroying a gobj while its tree is publishing: destroying ${gobj_full_name(gobj)}, publisher ${gobj_full_name(f.gobj)}, event ${f.event || ""}, destroyer ${destroyer}, inner_event ${top.event || ""}. Defer it with gobj_post_event(): a subscriber must not destroy the tree of its publisher synchronously. stack:\n${stack}`);
+			else log_error(`Destroying a gobj while one of its actions is still running: destroying ${gobj_full_name(gobj)}, running ${gobj_full_name(f.gobj)}, event ${f.event || ""}, destroyer ${destroyer}, inner_event ${top.event || ""}. Defer it with gobj_post_event(): an inner dispatch must not destroy a gobj that an outer one is running on. stack:\n${stack}`);
+			return;
+		}
+	}
+	/************************************************************
 	*      send_event
 	************************************************************/
 	function gobj_send_event(dst, event, kw, src) {
@@ -2578,7 +2997,12 @@
 						}
 					}
 				}
-				return dst.gclass.gmt.mt_inject_event(dst, event, kw, src);
+				const frame = push_dispatch_frame(dst, event, frame_kind_t.FRAME_ACTION);
+				try {
+					return dst.gclass.gmt.mt_inject_event(dst, event, kw, src);
+				} finally {
+					pop_dispatch_frame(frame);
+				}
 			}
 			if (tracea) trace_machine(sprintf("📛 mach(%s%s^%s), st: %s, ev: %s, 📛📛ERROR Event NOT DEFINED in state📛📛, from(%s%s^%s)", !dst.running ? "!!" : "", gobj_gclass_name(dst), gobj_name(dst), state.state_name, event ? event : "", src && !src.running ? "!!" : "", gobj_gclass_name(src), gobj_name(src)));
 			log_error(`📛📛 Event NOT DEFINED in state 📛📛: ${gobj_short_name(dst)}, ${state.state_name}, ${event}`);
@@ -2598,6 +3022,7 @@
 				}
 			}
 		}
+		const frame = push_dispatch_frame(dst, event, frame_kind_t.FRAME_ACTION);
 		if (event_action.next_state) gobj_change_state(dst, event_action.next_state);
 		let ret = -1;
 		try {
@@ -2611,8 +3036,10 @@
 				} catch (e2) {}
 			}
 			throw e;
+		} finally {
+			pop_dispatch_frame(frame);
 		}
-		if (tracea && __trace_machine_format__ !== 1 && !(dst.obflag & obflag_t.obflag_destroyed)) trace_machine(sprintf("<- mach(%s%s^%s), st: %s, ev: %s, ret: %d", !dst.running ? "!!" : "", gobj_gclass_name(dst), gobj_name(dst), dst.current_state.state_name, event ? event : "", is_number(ret) ? ret : 0));
+		if (tracea && __trace_machine_format__ !== 1 && !frame.destroyed) trace_machine(sprintf("<- mach(%s%s^%s), st: %s, ev: %s, ret: %d", !dst.running ? "!!" : "", gobj_gclass_name(dst), gobj_name(dst), dst.current_state.state_name, event ? event : "", is_number(ret) ? ret : 0));
 		__inside__--;
 		return ret;
 	}
@@ -3075,62 +3502,67 @@
 		let dl_subs = [...publisher.dl_subscriptions];
 		let sent_count = 0;
 		let ret = 0;
-		for (let idx = 0; idx < dl_subs.length; idx++) {
-			let subs = dl_subs[idx];
-			if (publisher.gclass.gmt.mt_publication_pre_filter) {
-				let topublish = publisher.gclass.gmt.mt_publication_pre_filter(publisher, subs, event, kw);
-				if (topublish < 0) break;
-				else if (!topublish) continue;
-			}
-			let subscriber = kw_get_pointer(publisher, subs, "subscriber", null, kw_flag_t.KW_REQUIRED);
-			if (!(subscriber && !gobj_is_destroying(subscriber))) continue;
-			let subs_flag = kw_get_int(publisher, subs, "subs_flag", 0, kw_flag_t.KW_REQUIRED);
-			let event_ = kw_get_str(publisher, subs, "event", "", kw_flag_t.KW_REQUIRED);
-			if (empty_string(event_) || strcasecmp(event_, event) === 0) {
-				let __config__ = kw_get_dict(publisher, subs, "__config__", null, 0);
-				let __global__ = kw_get_dict(publisher, subs, "__global__", null, 0);
-				let __local__ = kw_get_dict(publisher, subs, "__local__", null, 0);
-				let __filter__ = kw_get_dict_value(publisher, subs, "__filter__", null, 0);
-				let event_name = subs.renamed_event;
-				if (empty_string(event_name)) event_name = event;
-				let topublish = 1;
-				if (publisher.gclass.gmt.mt_publication_filter) topublish = publisher.gclass.gmt.mt_publication_filter(publisher, event, kw, subscriber);
-				else if (json_size(__filter__) > 0) {
-					topublish = kw_match_simple(kw, __filter__) ? 1 : 0;
+		const frame = push_dispatch_frame(publisher, event, frame_kind_t.FRAME_PUBLICATION);
+		try {
+			for (let idx = 0; idx < dl_subs.length; idx++) {
+				let subs = dl_subs[idx];
+				if (publisher.gclass.gmt.mt_publication_pre_filter) {
+					let topublish = publisher.gclass.gmt.mt_publication_pre_filter(publisher, subs, event, kw);
+					if (topublish < 0) break;
+					else if (!topublish) continue;
+				}
+				let subscriber = kw_get_pointer(publisher, subs, "subscriber", null, kw_flag_t.KW_REQUIRED);
+				if (!(subscriber && !gobj_is_destroying(subscriber))) continue;
+				let subs_flag = kw_get_int(publisher, subs, "subs_flag", 0, kw_flag_t.KW_REQUIRED);
+				let event_ = kw_get_str(publisher, subs, "event", "", kw_flag_t.KW_REQUIRED);
+				if (empty_string(event_) || strcasecmp(event_, event) === 0) {
+					let __config__ = kw_get_dict(publisher, subs, "__config__", null, 0);
+					let __global__ = kw_get_dict(publisher, subs, "__global__", null, 0);
+					let __local__ = kw_get_dict(publisher, subs, "__local__", null, 0);
+					let __filter__ = kw_get_dict_value(publisher, subs, "__filter__", null, 0);
+					let event_name = subs.renamed_event;
+					if (empty_string(event_name)) event_name = event;
+					let topublish = 1;
+					if (publisher.gclass.gmt.mt_publication_filter) topublish = publisher.gclass.gmt.mt_publication_filter(publisher, event, kw, subscriber);
+					else if (json_size(__filter__) > 0) {
+						topublish = kw_match_simple(kw, __filter__) ? 1 : 0;
+						if (tracea) {
+							trace_machine(sprintf("💜💜🔄%s publishing with filter, event '%s', subscriber'%s', publisher %s", topublish ? "👍" : "👎", event ? event : "", gobj_short_name(subscriber), gobj_short_name(publisher)));
+							trace_json(__filter__);
+						}
+					}
+					if (topublish < 0) break;
+					else if (!topublish) continue;
+					let ev_ = gobj_event_type(subscriber, event, true);
+					if (ev_) {
+						if (ev_.event_flag & event_flag_t.EVF_SYSTEM_EVENT) {
+							if (!gobj_has_event(subscriber, ev_.event_name, 0)) continue;
+						}
+					}
+					let kw2publish = kw;
+					if (json_size(__local__) > 0 || json_size(__global__) > 0) kw2publish = json_object_update({}, kw);
+					if (json_size(__local__) > 0) kw_pop(kw2publish, __local__);
+					if (__config__) {}
+					if (json_size(__global__) > 0) json_object_update(kw2publish, json_deep_copy(__global__));
 					if (tracea) {
-						trace_machine(sprintf("💜💜🔄%s publishing with filter, event '%s', subscriber'%s', publisher %s", topublish ? "👍" : "👎", event ? event : "", gobj_short_name(subscriber), gobj_short_name(publisher)));
-						trace_json(__filter__);
+						if (__trace_machine_format__ === 1) trace_machine(sprintf("🔝🔄 %s (%s) %s%s", event ? event : "", event_name ? event_name : "", !subscriber.running ? "!!" : "", gobj_short_name(subscriber)));
+						else trace_machine(sprintf("🔝🔄 mach(%s%s), st: %s, ev: %s (%s), from(%s%s)", !subscriber.running ? "!!" : "", gobj_short_name(subscriber), gobj_current_state(subscriber), event ? event : "", event_name ? event_name : "", publisher && !publisher.running ? "!!" : "", gobj_short_name(publisher)));
+						if (__trace_gobj_ev_kw__(publisher) && json_object_size(kw2publish)) trace_json_masked(kw2publish);
 					}
-				}
-				if (topublish < 0) break;
-				else if (!topublish) continue;
-				let ev_ = gobj_event_type(subscriber, event, true);
-				if (ev_) {
-					if (ev_.event_flag & event_flag_t.EVF_SYSTEM_EVENT) {
-						if (!gobj_has_event(subscriber, ev_.event_name, 0)) continue;
+					let ret_ = gobj_send_event(subscriber, event_name, kw2publish, publisher);
+					if (ret_ < 0 && subs_flag & subs_flag_t.__own_event__) {
+						sent_count = -1;
+						break;
 					}
+					ret += ret_;
+					sent_count++;
+					if (frame.destroyed || gobj_is_destroying(publisher)) break;
 				}
-				let kw2publish = kw;
-				if (json_size(__local__) > 0 || json_size(__global__) > 0) kw2publish = json_object_update({}, kw);
-				if (json_size(__local__) > 0) kw_pop(kw2publish, __local__);
-				if (__config__) {}
-				if (json_size(__global__) > 0) json_object_update(kw2publish, json_deep_copy(__global__));
-				if (tracea) {
-					if (__trace_machine_format__ === 1) trace_machine(sprintf("🔝🔄 %s (%s) %s%s", event ? event : "", event_name ? event_name : "", !subscriber.running ? "!!" : "", gobj_short_name(subscriber)));
-					else trace_machine(sprintf("🔝🔄 mach(%s%s), st: %s, ev: %s (%s), from(%s%s)", !subscriber.running ? "!!" : "", gobj_short_name(subscriber), gobj_current_state(subscriber), event ? event : "", event_name ? event_name : "", publisher && !publisher.running ? "!!" : "", gobj_short_name(publisher)));
-					if (__trace_gobj_ev_kw__(publisher) && json_object_size(kw2publish)) trace_json_masked(kw2publish);
-				}
-				let ret_ = gobj_send_event(subscriber, event_name, kw2publish, publisher);
-				if (ret_ < 0 && subs_flag & subs_flag_t.__own_event__) {
-					sent_count = -1;
-					break;
-				}
-				ret += ret_;
-				sent_count++;
-				if (gobj_is_destroying(publisher)) break;
 			}
+		} finally {
+			pop_dispatch_frame(frame);
 		}
-		if (!sent_count) {
+		if (!sent_count && !frame.destroyed) {
 			if (!ev || !(ev.event_flag & event_flag_t.EVF_NO_WARN_SUBS)) log_warning(`${gobj_short_name(publisher)}: Publish event WITHOUT subscribers, ev ${event}`);
 		}
 		return ret;
@@ -3439,12 +3871,12 @@
 		"sessionkey",
 		"authdata"
 	];
-	var SECRET_NAME_SEGMENTS = /* @__PURE__ */ new Set([
+	var SECRET_NAME_SEGMENTS = [
 		"pass",
 		"pin",
 		"otp"
-	]);
-	var NOT_SECRET_SEGMENTS = /* @__PURE__ */ new Set([
+	];
+	var NOT_SECRET_SEGMENTS = [
 		"endpoint",
 		"url",
 		"uri",
@@ -3467,36 +3899,130 @@
 		"expiry",
 		"expires",
 		"mode"
-	]);
+	];
+	function words_by_letter(list) {
+		const by_letter = new Array(128).fill(null);
+		for (const word of list) {
+			const c = word.charCodeAt(0);
+			if (!by_letter[c]) by_letter[c] = [];
+			by_letter[c].push(word);
+		}
+		return by_letter;
+	}
+	var SECRET_PARTS_BY_LETTER = words_by_letter(SECRET_NAME_PARTS);
+	var SECRET_JOINED_BY_LETTER = words_by_letter(SECRET_NAME_JOINED);
+	var SECRET_SEGMENTS_BY_LETTER = words_by_letter(SECRET_NAME_SEGMENTS);
+	var NOT_SECRET_BY_LETTER = words_by_letter(NOT_SECRET_SEGMENTS);
+	function ascii_lower_code(code) {
+		return code >= 65 && code <= 90 ? code + 32 : code;
+	}
+	function is_name_joiner_code(code) {
+		return code === 95 || code === 45 || code === 46 || code === 32 || code === 9;
+	}
+	function name_segment_in(str, from, to, by_letter) {
+		const n = to - from;
+		if (n === 0) return false;
+		const c0 = ascii_lower_code(str.charCodeAt(from));
+		const words = c0 < 128 ? by_letter[c0] : null;
+		if (!words) return false;
+		for (let w = 0; w < words.length; w++) {
+			const word = words[w];
+			if (word.length !== n) continue;
+			let i = 1;
+			while (i < n && ascii_lower_code(str.charCodeAt(from + i)) === word.charCodeAt(i)) i++;
+			if (i === n) return true;
+		}
+		return false;
+	}
+	function name_part_at(str, to, i, part, joined) {
+		let j = i;
+		let k = 0;
+		while (k < part.length) {
+			if (j >= to) return false;
+			const code = str.charCodeAt(j);
+			if (joined && k > 0 && is_name_joiner_code(code)) {
+				j++;
+				continue;
+			}
+			if (ascii_lower_code(code) !== part.charCodeAt(k)) return false;
+			j++;
+			k++;
+		}
+		return true;
+	}
+	function secret_name_check(str, from, to, about_wins, by_segments) {
+		if (to - from < 3) return false;
+		if (about_wins) {
+			let seg = from;
+			for (let i = from; i <= to; i++) {
+				if (i < to && !is_name_joiner_code(str.charCodeAt(i))) continue;
+				if (name_segment_in(str, seg, i, NOT_SECRET_BY_LETTER)) return false;
+				seg = i + 1;
+			}
+		}
+		if (by_segments) {
+			let seg = from;
+			for (let i = from; i <= to; i++) {
+				if (i < to && is_ascii_alnum_code(str.charCodeAt(i))) continue;
+				if (name_segment_in(str, seg, i, SECRET_SEGMENTS_BY_LETTER)) return true;
+				seg = i + 1;
+			}
+		}
+		let has_priv = false;
+		let has_key = false;
+		for (let i = from; i < to; i++) {
+			const c = ascii_lower_code(str.charCodeAt(i));
+			if (c >= 128) continue;
+			const parts = SECRET_PARTS_BY_LETTER[c];
+			for (let k = 0; parts && k < parts.length; k++) if (name_part_at(str, to, i, parts[k], false)) return true;
+			const joined = SECRET_JOINED_BY_LETTER[c];
+			for (let k = 0; joined && k < joined.length; k++) if (name_part_at(str, to, i, joined[k], true)) return true;
+			if (c === 112 && !has_priv) has_priv = name_part_at(str, to, i, "priv", false);
+			else if (c === 107 && !has_key) has_key = name_part_at(str, to, i, "key", false);
+		}
+		return has_priv && has_key;
+	}
 	/************************************************************
 	*  TRUE if `name` is the name of a secret: a password, a token,
 	*  a key... Any case. As the C kernel's is_secret_name().
 	************************************************************/
 	function is_secret_name(name) {
-		if (typeof name !== "string" || name.length < 3) return false;
-		let lower = name.toLowerCase();
-		let hit = false;
-		for (const segment of lower.split(/[^a-z0-9]+/)) if (SECRET_NAME_SEGMENTS.has(segment)) {
-			hit = true;
-			break;
-		}
-		if (!hit) {
-			for (const part of SECRET_NAME_PARTS) if (lower.indexOf(part) >= 0) {
-				hit = true;
-				break;
+		if (typeof name !== "string") return false;
+		return secret_name_check(name, 0, name.length, true, true);
+	}
+	var NAMES_NOW = 0;
+	var NAMES_7_26_9 = 1;
+	function is_secret_name_tail(str, from, to, names) {
+		const by_segments = names === NAMES_NOW;
+		if ((to - from) * 3 <= MASK_MAX_NAME) return secret_name_check(str, from, to, true, by_segments);
+		let bytes = 0;
+		let i = to;
+		let partial = false;
+		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 (!hit) {
-			let joined = lower.replace(/[_\-. \t]/g, "");
-			for (const part of SECRET_NAME_JOINED) if (joined.indexOf(part) >= 0) {
-				hit = true;
+			if (bytes + n > MASK_MAX_NAME) {
+				partial = bytes < MASK_MAX_NAME;
 				break;
 			}
+			bytes += n;
+			i -= units;
 		}
-		if (!hit) hit = lower.indexOf("priv") >= 0 && lower.indexOf("key") >= 0;
-		if (!hit) return false;
-		for (const segment of lower.split(/[_\-. \t]/)) if (NOT_SECRET_SEGMENTS.has(segment)) return false;
-		return true;
+		if (partial) {
+			const name = "€" + str.substring(i, to);
+			return secret_name_check(name, 0, name.length, true, by_segments);
+		}
+		return secret_name_check(str, i, to, true, by_segments);
 	}
 	/************************************************************
 	*  Where an unquoted secret value that begins at `p` ends: at
@@ -3524,77 +4050,255 @@
 	}
 	/************************************************************
 	*  A credential by its SHAPE, whatever names it -- the C kernel's
-	*  jwt_len() / bearer_token_len(), the shapes the agent's audit
-	*  record redacts:
-	*    - a JWT: "eyJ" (the base64url of '{"') at the start of a
-	*      word, and three parts of base64url joined by '.'; the dots
-	*      at the end of the run are not its own (a JWT ends a
-	*      sentence: "... eyJ.eyJ.sig.");
-	*    - the token after "Bearer " (any case, a word of its own).
-	************************************************************/
+	*  jwt_len() / scheme_credential(), the shapes the agent's audit
+	*  record redacts, and the schemes of an HTTP Authorization:
+	*    - a JWT or a JWE: "eyJ" (the base64url of '{"') at the start
+	*      of a word, base64url, and a '.' of its own after it -- three
+	*      parts joined by '.' (a JWS), five (a JWE), or fewer when a cap
+	*      cut it; the dots at the end of the run are not its own (a JWT
+	*      ends a sentence: "... eyJ.eyJ.sig."), so a run whose only
+	*      dots end it is a header and no JWT ("eyJhIjoxfQ.");
+	*    - the credential after the scheme word "Bearer" or "Basic"
+	*      (any case, a word of its own): scheme_credential().
+	************************************************************/
+	var MASK_TOKEN_MIN = 8;
+	var MASK_PROSE_MAX = 24;
 	function is_ascii_alnum_code(code) {
 		return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
 	}
+	function is_ascii_letter_code(code) {
+		return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+	}
+	function is_ascii_upper_code(code) {
+		return code >= 65 && code <= 90;
+	}
 	function is_base64url_code(code) {
 		return is_ascii_alnum_code(code) || code === 45 || code === 95;
 	}
+	function ascii_case_equal(str, p, word) {
+		if (str.length - p < word.length) return false;
+		for (let i = 0; i < word.length; i++) {
+			let code = str.charCodeAt(p + i);
+			if (code >= 65 && code <= 90) code += 32;
+			if (code !== word.charCodeAt(i)) return false;
+		}
+		return true;
+	}
 	function jwt_len(str, p) {
 		if (str.length - p < 3 || str[p] !== "e" || str[p + 1] !== "y" || str[p + 2] !== "J") return 0;
 		if (p > 0 && (is_base64url_code(str.charCodeAt(p - 1)) || str[p - 1] === ".")) return 0;
 		let e = p;
-		let dots = 0;
+		let dotted = false;
 		while (e < str.length && (is_base64url_code(str.charCodeAt(e)) || str[e] === ".")) {
-			if (str[e] === ".") dots++;
+			if (e > p && str[e] !== "." && str[e - 1] === ".") dotted = true;
 			e++;
 		}
-		while (str[e - 1] === ".") {
-			e--;
-			dots--;
+		if (!dotted) return 0;
+		while (str[e - 1] === ".") e--;
+		return e - p;
+	}
+	function scheme_word_len(str, p) {
+		if (p > 0 && is_ascii_alnum_code(str.charCodeAt(p - 1))) return 0;
+		for (const scheme of ["bearer", "basic"]) {
+			const n = scheme.length;
+			if (str.length - p > n && ascii_case_equal(str, p, scheme) && (str[p + n] === " " || str[p + n] === "	")) return n;
+		}
+		return 0;
+	}
+	function code_points(str, w, n) {
+		let count = 0;
+		for (let i = w; i < w + n; i++) {
+			const code = str.charCodeAt(i);
+			if (code < 56320 || code > 57343) count++;
+		}
+		return count;
+	}
+	function is_prose_word(str, w, n) {
+		if (n === 0 || n >= MASK_PROSE_MAX) return false;
+		let i = w;
+		const end = w + n;
+		while (true) {
+			let r = i;
+			let upper_rest = true;
+			let lower_rest = true;
+			while (r < end && is_ascii_letter_code(str.charCodeAt(r))) {
+				if (r > i) {
+					if (is_ascii_upper_code(str.charCodeAt(r))) lower_rest = false;
+					else upper_rest = false;
+				}
+				r++;
+			}
+			if (r === i) return false;
+			if (!lower_rest && !(upper_rest && is_ascii_upper_code(str.charCodeAt(i)))) return false;
+			if (r === end) return true;
+			if (str[r] !== "-" && str[r] !== "." && str[r] !== "/" || r + 1 === end) return false;
+			i = r + 1;
+		}
+	}
+	function base64_digit(code) {
+		if (code >= 65 && code <= 90) return code - 65;
+		if (code >= 97 && code <= 122) return code - 97 + 26;
+		if (code >= 48 && code <= 57) return code - 48 + 52;
+		if (code === 43) return 62;
+		if (code === 47) return 63;
+		return -1;
+	}
+	function is_basic_credential(str, w, n) {
+		let bits = 0;
+		let n_bits = 0;
+		for (let i = 0; i < n; i++) {
+			const v = base64_digit(str.charCodeAt(w + i));
+			if (v < 0) return false;
+			bits = (bits << 6 | v) & 16383;
+			n_bits += 6;
+			if (n_bits >= 8) {
+				n_bits -= 8;
+				if ((bits >> n_bits & 255) === 58) return true;
+			}
 		}
-		return dots === 2 ? e - p : 0;
+		return false;
 	}
-	var BEARER_STOPS = " 	\r\n'\",;}]\0";
-	function bearer_token(str, p) {
-		const word_len = 6;
-		if (str.length - p <= word_len || str.slice(p, p + word_len).toLowerCase() !== "bearer") return [0, 0];
-		if (p > 0 && is_ascii_alnum_code(str.charCodeAt(p - 1))) return [0, 0];
-		let t = p + word_len;
-		if (str[t] !== " " && str[t] !== "	") return [0, 0];
+	var SCHEME_WORD_STOPS = " 	\r\n\"',;}]\0";
+	function scheme_credential(str, p) {
+		const n = scheme_word_len(str, p);
+		if (!n) return [0, 0];
+		const scheme = n === 5 ? "basic" : "bearer";
+		let context = false;
+		let t = p + n;
 		while (t < str.length && (str[t] === " " || str[t] === "	")) t++;
+		if (t < str.length && scheme_word_len(str, t) === n && ascii_case_equal(str, t, scheme)) {
+			t += n;
+			context = true;
+			while (t < str.length && (str[t] === " " || str[t] === "	")) t++;
+		}
+		if (t >= str.length) return [0, 0];
+		if (str[t] === "\"" || str[t] === "'") {
+			let q = t + 1;
+			while (q < str.length && str[q] !== str[t] && str[q] !== " " && str[q] !== "	" && str[q] !== "\r" && str[q] !== "\n" && str[q] !== "\0") q++;
+			if (q < str.length && str[q] === str[t] && q > t + 1) return [t - p, q + 1 - t];
+			return [0, 0];
+		}
 		let e = t;
-		while (e < str.length && BEARER_STOPS.indexOf(str[e]) < 0) e++;
+		while (e < str.length && SCHEME_WORD_STOPS.indexOf(str[e]) < 0) e++;
+		if (e === t) return [0, 0];
+		if (!context) {
+			let w_end = e;
+			while (w_end > t && str[w_end - 1] === ".") w_end--;
+			const len = w_end - t;
+			if (len === 0 || is_prose_word(str, t, len)) return [0, 0];
+			if (n === 5) {
+				if (!is_basic_credential(str, t, len)) return [0, 0];
+			} else if (code_points(str, t, len) < MASK_TOKEN_MIN) return [0, 0];
+		}
 		return [t - p, e - t];
 	}
-	/************************************************************
-	*  A text (a command line) with the value of every "name=value"
-	*  whose name is a secret's written as "********", quoted or not
-	*  (and the "value" of a write-attr whose attribute names a
-	*  secret); and a JWT or the token after "Bearer ", wherever they
-	*  are, whatever names them. The rest as it is. Return null when
-	*  there was nothing to mask. As the C kernel's
-	*  mask_secrets_inline().
-	************************************************************/
+	function shape_len(str, p) {
+		const c = str[p];
+		if (c === "e") return [0, jwt_len(str, p)];
+		if (c === "b" || c === "B") return scheme_credential(str, p);
+		return [0, 0];
+	}
+	function shape_len_js_7_26_20(str, p) {
+		const c = str[p];
+		if (c === "e") {
+			if (str.length - p < 3 || str[p + 1] !== "y" || str[p + 2] !== "J") return [0, 0];
+			if (p > 0 && (is_base64url_code(str.charCodeAt(p - 1)) || str[p - 1] === ".")) return [0, 0];
+			let e = p;
+			let dots = 0;
+			while (e < str.length && (is_base64url_code(str.charCodeAt(e)) || str[e] === ".")) {
+				if (str[e] === ".") dots++;
+				e++;
+			}
+			while (str[e - 1] === ".") {
+				e--;
+				dots--;
+			}
+			return dots === 2 ? [0, e - p] : [0, 0];
+		}
+		if (c === "b" || c === "B") {
+			if (str.length - p <= 6 || !ascii_case_equal(str, p, "bearer")) return [0, 0];
+			if (p > 0 && is_ascii_alnum_code(str.charCodeAt(p - 1))) return [0, 0];
+			let t = p + 6;
+			if (str[t] !== " " && str[t] !== "	") return [0, 0];
+			while (t < str.length && (str[t] === " " || str[t] === "	")) t++;
+			let e = t;
+			while (e < str.length && " 	\r\n'\",;}]\0".indexOf(str[e]) < 0) e++;
+			return [t - p, e - t];
+		}
+		return [0, 0];
+	}
+	var COLON_VALUE_STOPS = " 	\r\n,;&)]}<>\"'\0";
+	function colon_value_end(str, v) {
+		if (v >= str.length) return v;
+		const c = str[v];
+		if (c === "\"" || c === "'") {
+			let e = v + 1;
+			while (e < str.length && str[e] !== c) {
+				if (str[e] === "\\" && e + 1 < str.length) e++;
+				e++;
+			}
+			return e < str.length ? e + 1 : str.length;
+		}
+		if (c === "{" || c === "[") {
+			let depth = 0;
+			let in_string = false;
+			for (let e = v; e < str.length; e++) if (in_string) {
+				if (str[e] === "\\" && e + 1 < str.length) e++;
+				else if (str[e] === "\"") in_string = false;
+			} else if (str[e] === "\"") in_string = true;
+			else if (str[e] === "{" || str[e] === "[") depth++;
+			else if (str[e] === "}" || str[e] === "]") {
+				depth--;
+				if (depth === 0) return e + 1;
+			}
+			return str.length;
+		}
+		if (c === "\\") {
+			let q = v;
+			while (q < str.length && str[q] === "\\") q++;
+			if (q < str.length && (str[q] === "\"" || str[q] === "'")) {
+				const level = q - v;
+				let run = 0;
+				for (let e = q + 1; e < str.length; e++) {
+					if (str[e] === "\\") {
+						run++;
+						continue;
+					}
+					if (str[e] === str[q] && run === level) return e + 1;
+					run = 0;
+				}
+				return str.length;
+			}
+		}
+		let e = v;
+		const n = scheme_word_len(str, v);
+		if (n) {
+			e = v + n;
+			while (e < str.length && (str[e] === " " || str[e] === "	")) e++;
+			if (e < str.length && (str[e] === "\"" || str[e] === "'")) return colon_value_end(str, e);
+		}
+		while (e < str.length && COLON_VALUE_STOPS.indexOf(str[e]) < 0) e++;
+		return e;
+	}
 	var MASK_MAX_NAME = 128;
 	var MASK_MAX_BYTES = 4194304;
 	var MASK_TOO_LARGE = "<not shown: too large to mask>";
-	function mask_secrets_inline(str) {
-		if (typeof str !== "string") return null;
-		if (str.indexOf("=") < 0 && str.indexOf("eyJ") < 0 && !/bearer/i.test(str)) return null;
-		if (str.length > MASK_MAX_BYTES) return MASK_TOO_LARGE;
-		let value_is_secret = false;
-		let re_attr = /(^|[ \t])attribute=["']?([^ \t"']*)/g;
-		let m;
-		while ((m = re_attr.exec(str)) !== null) if (is_secret_name(m[2].slice(-128))) value_is_secret = true;
-		let parts = [];
-		let copied = 0;
-		let changed = false;
+	function mark_range(marks, from, to) {
+		for (let i = from; i < to; i++) marks[i] = 1;
+	}
+	var READ_NOW = 0;
+	var READ_AS_GOBJ_JS_7_26_20 = 1;
+	var READ_AS_7_26_9 = 2;
+	function mark_params(str, value_is_secret, reading, marks, judged) {
+		const names = reading === READ_AS_7_26_9 ? NAMES_7_26_9 : NAMES_NOW;
+		let not_7_26_9 = false;
+		const is_blank_or_end = (i) => i >= str.length || str[i] === " " || str[i] === "	" || str[i] === "\0";
 		let outer = "";
 		let word = 0;
 		let p = 0;
-		const is_blank_or_end = (i) => i >= str.length || str[i] === " " || str[i] === "	";
 		while (p < str.length) {
-			let c = str[p];
-			if (c === " " || c === "	") {
+			const c = str[p];
+			if (c === " " || c === "	" || c === "\0") {
 				p++;
 				word = p;
 				continue;
@@ -3603,48 +4307,205 @@
 				if (!outer && (p === 0 || str[p - 1] === " " || str[p - 1] === "	" || str[p - 1] === "=")) outer = c;
 				else if (c === outer && is_blank_or_end(p + 1)) outer = "";
 			}
-			let shape = c === "e" ? jwt_len(str, p) : 0;
-			let token_offset = 0;
-			if (c === "b" || c === "B") [token_offset, shape] = bearer_token(str, p);
-			if (shape) {
-				parts.push(str.substring(copied, p + token_offset));
-				parts.push("********");
-				p += token_offset + shape;
-				copied = p;
-				changed = true;
-				word = p;
-				continue;
+			if (reading === READ_AS_GOBJ_JS_7_26_20 && (c === "e" || c === "b" || c === "B")) {
+				const [offset, n] = shape_len_js_7_26_20(str, p);
+				if (n) {
+					p += offset + n;
+					word = p;
+					continue;
+				}
 			}
 			if (c !== "=") {
 				p++;
 				continue;
 			}
-			let name = str.substring(Math.max(word, p - MASK_MAX_NAME), p);
+			const name_from = word;
 			word = p + 1;
-			if (!(is_secret_name(name) || value_is_secret && name.toLowerCase() === "value")) {
+			const secret = is_secret_name_tail(str, name_from, p, names);
+			if (secret && names === NAMES_NOW && !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] = 1;
 				p++;
 				continue;
 			}
 			p++;
-			let quote = str[p] === "\"" || str[p] === "'" ? str[p] : "";
 			let end;
+			const quote = p < str.length && (str[p] === "\"" || str[p] === "'") ? str[p] : "";
 			if (quote) {
 				end = p + 1;
-				while (end < str.length && str[end] !== quote) end++;
-				if (str[end] === quote) end++;
+				while (end < str.length && str[end] !== quote && str[end] !== "\0") end++;
+				if (end < str.length && str[end] === quote) end++;
 			} else end = inline_secret_value_end(str, p, outer);
-			if (end > p) {
-				parts.push(str.substring(copied, p));
+			mark_range(marks, p, end);
+			p = end;
+			word = p;
+		}
+		return not_7_26_9;
+	}
+	function has_shape_js_7_26_20(str) {
+		for (let p = 0; p < str.length; p++) {
+			const code = str.charCodeAt(p);
+			if ((code === 101 || code === 98 || code === 66) && shape_len_js_7_26_20(str, p)[1]) return true;
+		}
+		return false;
+	}
+	function stop_table(chars) {
+		const table = /* @__PURE__ */ new Uint8Array(128);
+		for (const c of chars + "\r\n\0") table[c.charCodeAt(0)] = 1;
+		return table;
+	}
+	var PARAM_VALUE_STOPS = stop_table("&; 	,\"'<>");
+	var QUOTE_STOPS = {
+		"\"": stop_table("\""),
+		"'": stop_table("'")
+	};
+	function mark_run(str, p, stops, marks) {
+		let e = p;
+		while (e < str.length) {
+			const code = str.charCodeAt(e);
+			if (code < 128 && stops[code]) break;
+			e++;
+		}
+		mark_range(marks, p, e);
+		return e;
+	}
+	function mark_scheme_value(str, v, stops, marks) {
+		const n = scheme_word_len(str, v);
+		if (!n) return -1;
+		let w = v + n;
+		while (w < str.length && (str[w] === " " || str[w] === "	")) w++;
+		mark_range(marks, v, w);
+		if (w < str.length && (str[w] === "\"" || str[w] === "'")) {
+			const e = colon_value_end(str, w);
+			mark_range(marks, w, e);
+			return e;
+		}
+		return mark_run(str, w, stops, marks);
+	}
+	function is_name_char_code(code) {
+		return is_ascii_alnum_code(code) || code === 95 || code === 45 || code === 46;
+	}
+	function query_name_from(str, eq) {
+		let n = eq;
+		while (n > 0 && eq - n < MASK_MAX_NAME && is_name_char_code(str.charCodeAt(n - 1))) n--;
+		return n;
+	}
+	function mark_query_params(str, marks, judged) {
+		let frontier = 0;
+		for (let p = 1; p < str.length; p++) {
+			if (p < frontier) {
+				p = frontier - 1;
+				continue;
+			}
+			if (str.charCodeAt(p) !== 61) continue;
+			if (judged[p]) continue;
+			const n = query_name_from(str, p);
+			if (n === p || !secret_name_check(str, n, p, true, true)) continue;
+			const v = p + 1;
+			if (v < str.length && (str[v] === "\"" || str[v] === "'")) frontier = mark_run(str, v + 1, QUOTE_STOPS[str[v]], marks);
+			else {
+				mark_scheme_value(str, v, PARAM_VALUE_STOPS, marks);
+				frontier = mark_run(str, v, PARAM_VALUE_STOPS, marks);
+			}
+		}
+	}
+	function mark_shapes(str, marks) {
+		for (let p = 0; p < str.length; p++) {
+			const code = str.charCodeAt(p);
+			if (code !== 101 && code !== 98 && code !== 66) continue;
+			const [offset, n] = shape_len(str, p);
+			if (n) mark_range(marks, p + offset, p + offset + n);
+		}
+	}
+	function mark_labels(str, marks) {
+		let word = 0;
+		let p = 0;
+		while (p < str.length) {
+			const code = str.charCodeAt(p);
+			if (code === 32 || code === 9 || code === 0 || code === 61) {
+				p++;
+				word = p;
+				continue;
+			}
+			if (code !== 58) {
+				p++;
+				continue;
+			}
+			if (!is_secret_name_tail(str, word, p, NAMES_NOW)) {
+				p++;
+				word = p;
+				continue;
+			}
+			let v = p + 1;
+			while (v < str.length && (str[v] === " " || str[v] === "	")) v++;
+			const e = colon_value_end(str, v);
+			mark_range(marks, v, e);
+			const n_scheme = scheme_word_len(str, v);
+			if (n_scheme) p = v + n_scheme;
+			else p = e > v ? e : p + 1;
+			word = p;
+		}
+	}
+	function inline_value_is_secret(str, names) {
+		let p = str.indexOf("attribute=");
+		while (p >= 0) {
+			if (p === 0 || str[p - 1] === " " || str[p - 1] === "	") {
+				let v = p + 10;
+				if (v < str.length && (str[v] === "\"" || str[v] === "'")) v++;
+				let e = v;
+				while (e < str.length && " 	\"'\0".indexOf(str[e]) < 0) e++;
+				if (is_secret_name_tail(str, v, e, names)) return true;
+			}
+			p = str.indexOf("attribute=", p + 1);
+		}
+		return false;
+	}
+	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);
+		const judged = new Uint8Array(str.length);
+		if (mark_params(str, value_is_secret, READ_NOW, marks, judged) || value_is_secret !== value_is_secret_7_26_9) mark_params(str, value_is_secret_7_26_9, READ_AS_7_26_9, marks, null);
+		if (has_shape_js_7_26_20(str)) mark_params(str, value_is_secret, READ_AS_GOBJ_JS_7_26_20, marks, null);
+		mark_query_params(str, marks, judged);
+		mark_shapes(str, marks);
+		mark_labels(str, marks);
+	}
+	/************************************************************
+	*  A text (a command line) with the secrets that can be told
+	*  written as "********" (each run of them as one), the rest as it
+	*  is: the value of every "name=value" whose name is a secret's,
+	*  quoted or not (and the "value" of a write-attr whose attribute
+	*  names a secret) -- the name is the word before the '=', and also
+	*  the run of name characters before it, as in a query string; the
+	*  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().
+	************************************************************/
+	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.length > MASK_MAX_BYTES) return MASK_TOO_LARGE;
+		const marks = new Uint8Array(str.length);
+		mark_inline_secrets(str, marks);
+		let parts = [];
+		let changed = false;
+		let i = 0;
+		while (i < str.length) {
+			let j = i;
+			if (marks[i]) {
+				while (j < str.length && marks[j]) j++;
 				parts.push("********");
-				copied = end;
 				changed = true;
+			} else {
+				while (j < str.length && !marks[j]) j++;
+				parts.push(str.substring(i, j));
 			}
-			p = end;
-			word = p;
+			i = j;
 		}
-		if (!changed) return null;
-		parts.push(str.substring(copied));
-		return parts.join("");
+		return changed ? parts.join("") : null;
 	}
 	/************************************************************
 	*  A json as a log or a trace may show it: at any depth, the
@@ -3712,7 +4573,12 @@
 			if (truncated) result.push(MASK_TOO_LARGE);
 		} else {
 			result = Object.create(Object.getPrototypeOf(jn));
-			let value_is_secret = typeof jn.attribute === "string" && is_secret_name(jn.attribute.slice(-128));
+			let value_is_secret = false;
+			if (typeof jn.attribute === "string") {
+				let nul = jn.attribute.indexOf("\0");
+				let attribute = nul >= 0 ? jn.attribute.substring(0, nul) : jn.attribute;
+				value_is_secret = is_secret_name_tail(attribute, 0, attribute.length, NAMES_NOW);
+			}
 			for (const key in jn) {
 				if (!Object.prototype.hasOwnProperty.call(jn, key)) continue;
 				if (budget.left <= 0) {
@@ -3722,7 +4588,7 @@
 				budget.left -= 1 + key.length;
 				let value = jn[key];
 				let shown;
-				if ((is_secret_name(key.slice(-128)) || value_is_secret && key === "value") && value !== void 0 && value !== null && value !== "") shown = "********";
+				if ((is_secret_name_tail(key, 0, key.length, NAMES_NOW) || value_is_secret && key === "value") && value !== void 0 && value !== null && value !== "") shown = "********";
 				else shown = _json_mask_secrets(value, memo, depth + 1, budget);
 				if (shown !== value) changed = true;
 				set_own_key(result, key, shown);
@@ -6871,8 +7737,12 @@
 	***************************************************************/
 	function mt_create$2(gobj) {
 		let priv = gobj.priv;
-		const subscriber = gobj_read_pointer_attr(gobj, "subscriber");
+		let subscriber = gobj_read_pointer_attr(gobj, "subscriber");
 		if (subscriber) gobj_subscribe_event(gobj, null, {}, subscriber);
+		else if (gobj_is_pure_child(gobj)) {
+			subscriber = gobj_parent(gobj);
+			gobj_subscribe_event(gobj, null, {}, subscriber);
+		}
 		priv.periodic = gobj_read_bool_attr(gobj, "periodic");
 		priv.msec = gobj_read_integer_attr(gobj, "msec");
 	}
@@ -6929,8 +7799,7 @@
 			gobj_send_event(gobj, "EV_TIMEOUT", {}, gobj);
 		}, priv.msec);
 		else priv.timer_id = -1;
-		if (gobj_is_pure_child(gobj)) gobj_send_event(gobj_parent(gobj), ev, {}, gobj);
-		else gobj_publish_event(gobj, ev, {});
+		gobj_publish_event(gobj, ev, {});
 		if (!priv.periodic && priv.timer_id === -1) {
 			if (gobj_is_running(gobj)) gobj_stop(gobj);
 		}
@@ -6977,6 +7846,15 @@
 	*      Helpers
 	***************************/
 	/***************************************************************************
+	*  A number of milliseconds as the integer `msec` holds it: C takes an
+	*  integer, and a time computed in JS can carry a float error (0.3 * 1000
+	*  is 300.00000000000006, which an integer attr refuses). Anything that is
+	*  not a number goes as it is, to be refused loudly by the attr.
+	***************************************************************************/
+	function whole_msec(msec) {
+		return typeof msec === "number" && Number.isFinite(msec) ? Math.round(msec) : msec;
+	}
+	/***************************************************************************
 	*  Set timeout
 	***************************************************************************/
 	function set_timeout(gobj, msec) {
@@ -6989,7 +7867,7 @@
 			return -1;
 		}
 		gobj_write_bool_attr(gobj, "periodic", false);
-		gobj_write_integer_attr(gobj, "msec", msec);
+		gobj_write_integer_attr(gobj, "msec", whole_msec(msec));
 	}
 	/***************************************************************************
 	*  Set periodic timeout
@@ -7004,7 +7882,7 @@
 			return -1;
 		}
 		gobj_write_bool_attr(gobj, "periodic", true);
-		gobj_write_integer_attr(gobj, "msec", msec);
+		gobj_write_integer_attr(gobj, "msec", whole_msec(msec));
 	}
 	/***************************************************************************
 	*  Clear timeout
@@ -7391,8 +8269,12 @@
 		gobj_write_str_attr(gobj, "wanted_yuno_name", priv.remote_yuno_name);
 		gobj_write_str_attr(gobj, "wanted_yuno_role", priv.remote_yuno_role);
 		gobj_write_str_attr(gobj, "wanted_yuno_service", priv.remote_yuno_service);
-		const subscriber = gobj_read_pointer_attr(gobj, "subscriber");
+		let subscriber = gobj_read_pointer_attr(gobj, "subscriber");
 		if (subscriber) gobj_subscribe_event(gobj, null, {}, subscriber);
+		else if (gobj_is_pure_child(gobj)) {
+			subscriber = gobj_parent(gobj);
+			gobj_subscribe_event(gobj, null, {}, subscriber);
+		}
 	}
 	/***************************************************************
 	*          Framework Method: Writing
@@ -7617,6 +8499,27 @@
 		}
 	}
 	/***************************************************************
+	*  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
+	*  show its first characters). As the C kernel shows the name of an
+	*  event that is not public (mask_secrets_inline_capped()).
+	***************************************************************/
+	var PEER_NAME_SHOWN = 64;
+	var PEER_FRAME_SHOWN = 256;
+	function peer_text_shown(text, max) {
+		let s = String(text);
+		let masked = mask_secrets_inline(s);
+		if (masked !== null) s = masked;
+		if (s.length > max) {
+			let n = max;
+			let code = s.charCodeAt(n);
+			if (code >= 56320 && code <= 57343) n--;
+			s = s.substring(0, n);
+		}
+		return s;
+	}
+	/***************************************************************
 	*      Trace intra event
 	***************************************************************/
 	function trace_inter_event(gobj, prefix, iev) {
@@ -7739,7 +8642,8 @@
 		try {
 			x = JSON.parse(data);
 		} catch (e) {
-			log_warning(`${gobj_short_name(gobj)}: parsing inter_event json: ${e}`);
+			let at = /position (\d+)/.exec(String(e && e.message));
+			log_warning(`${gobj_short_name(gobj)}: parsing inter_event json: frame is not json${at ? ", at position " + at[1] : ""}, ${String(data).length} characters`);
 			return null;
 		}
 		if (!(x instanceof Object)) {
@@ -7824,7 +8728,7 @@
 		let url = kw.url;
 		if (kw.ws_seq !== void 0 && kw.ws_seq !== priv.ws_seq) return 0;
 		set_remote_log_functions();
-		log_warning(`${gobj_short_name(gobj)}: WebSocket closed ${url} (Code: ${kw.code}, Reason: "${kw.reason}", Clean: ${kw.was_clean})`);
+		log_warning(`${gobj_short_name(gobj)}: WebSocket closed ${url} (Code: ${kw.code}, Reason: "${peer_text_shown(kw.reason, PEER_FRAME_SHOWN)}", Clean: ${kw.was_clean})`);
 		if (priv.websocket) {
 			priv.websocket.onopen = null;
 			priv.websocket.onmessage = null;
@@ -7909,7 +8813,7 @@
 		let services_roles = kw_get_dict_value(gobj, kw, "services_roles", {});
 		if (result < 0) {
 			close_websocket(gobj);
-			let kw_nak = {
+			gobj_publish_event(gobj, "EV_ON_ID_NAK", {
 				"url": gobj_read_str_attr(gobj, "url"),
 				"result": result,
 				"comment": comment,
@@ -7917,24 +8821,20 @@
 				"remote_yuno_name": src_yuno,
 				"remote_yuno_role": src_role,
 				"remote_yuno_service": src_service
-			};
-			if (gobj_is_pure_child(gobj)) gobj_send_event(gobj_parent(gobj), "EV_ON_ID_NAK", kw_nak, gobj);
-			else gobj_publish_event(gobj, "EV_ON_ID_NAK", kw_nak);
+			});
 		} else {
 			gobj_change_state(gobj, "ST_SESSION");
 			priv.inside_on_open = true;
 			priv.retry_ms = 0;
 			if (!priv.inform_on_close) {
 				priv.inform_on_close = true;
-				let kw_on_open = {
+				gobj_publish_event(gobj, "EV_ON_OPEN", {
 					"username": username_,
 					"remote_yuno_name": src_yuno,
 					"remote_yuno_role": src_role,
 					"remote_yuno_service": src_service,
 					"services_roles": services_roles
-				};
-				if (gobj_is_pure_child(gobj)) gobj_send_event(gobj_parent(gobj), "EV_ON_OPEN", kw_on_open, gobj);
-				else gobj_publish_event(gobj, "EV_ON_OPEN", kw_on_open);
+				});
 			}
 			priv.inside_on_open = false;
 			resend_subscriptions(gobj);
@@ -7948,7 +8848,7 @@
 		let url = gobj.priv.url;
 		let iev_msg = iev_create_from_json(gobj, kw.data);
 		if (!iev_msg) {
-			log_warning(`${gobj_short_name(gobj)}: frame dropped from ${url}: ${String(kw.data).substring(0, 256)}`);
+			log_warning(`${gobj_short_name(gobj)}: frame dropped from ${url}: ${peer_text_shown(kw.data, PEER_FRAME_SHOWN)}`);
 			return -1;
 		}
 		if (is_traffic_tracing(gobj)) {
@@ -7963,7 +8863,7 @@
 		if (gobj_current_state(gobj) !== "ST_SESSION") {
 			if (gobj_has_event(gobj, iev_event, event_flag_t.EVF_PUBLIC_EVENT)) {
 				if (!(gobj_send_event(gobj, iev_event, iev_kw, gobj) < 0)) return 0;
-			} else log_error(`${gobj_short_name(gobj)}: event UNKNOWN in not-session state ${iev_event}`);
+			} else log_error(`${gobj_short_name(gobj)}: event UNKNOWN in not-session state ${peer_text_shown(iev_event, PEER_NAME_SHOWN)}`);
 			close_websocket(gobj);
 			return -1;
 		}
@@ -7972,16 +8872,16 @@
 		let event_id = msg_iev_get_stack(gobj, iev_kw, IEVENT_STACK_ID);
 		let iev_dst_role = kw_get_str(gobj, event_id, "dst_role", "");
 		if (iev_dst_role.toLowerCase() !== gobj_yuno_role().toLowerCase()) {
-			log_error(`"It's not my role, dst_role: ${iev_dst_role}, my_role: ${gobj_yuno_role()}`);
+			log_error(`"It's not my role, dst_role: ${peer_text_shown(iev_dst_role, PEER_NAME_SHOWN)}, my_role: ${gobj_yuno_role()}`);
 			return 0;
 		}
 		let iev_dst_service = kw_get_str(gobj, event_id, "dst_service", "");
 		if (msg_type === "__subscribing__") {
-			log_warning(`${gobj_short_name(gobj)}: subscription event ignored, I'm client (service: ${iev_dst_service}, event: ${iev_event})`);
+			log_warning(`${gobj_short_name(gobj)}: subscription 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 (msg_type === "__unsubscribing__") {
-			log_warning(`${gobj_short_name(gobj)}: unsubscription event ignored, I'm client (service: ${iev_dst_service}, event: ${iev_event})`);
+			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)) {
@@ -7991,18 +8891,17 @@
 		if (!empty_string(iev_dst_service)) {
 			let gobj_service = gobj_find_service(iev_dst_service, false);
 			if (!gobj_service) {
-				log_warning(`${gobj_short_name(gobj)}: event for a service that is gone, DROPPED: service '${iev_dst_service}', ev '${iev_event}'`);
+				log_warning(`${gobj_short_name(gobj)}: event for a service that is gone, DROPPED: service '${peer_text_shown(iev_dst_service, PEER_NAME_SHOWN)}', ev '${peer_text_shown(iev_event, PEER_NAME_SHOWN)}'`);
 				return 0;
 			}
 			if (!gobj_has_event(gobj_service, iev_event, event_flag_t.EVF_PUBLIC_EVENT)) {
-				log_error(`${gobj_short_name(gobj)}: Service found but no event or not public, service '${gobj_short_name(gobj_service)}', ev '${iev_event}'`);
+				log_error(`${gobj_short_name(gobj)}: Service found but no event or not public, service '${gobj_short_name(gobj_service)}', ev '${peer_text_shown(iev_event, PEER_NAME_SHOWN)}'`);
 				return -1;
 			}
 			gobj_send_event(gobj_service, iev_event, iev_kw, gobj);
 			return 0;
 		}
-		if (gobj_is_pure_child(gobj)) gobj_send_event(gobj_parent(gobj), iev_event, iev_kw, gobj);
-		else gobj_publish_event(gobj, iev_event, iev_kw);
+		gobj_publish_event(gobj, iev_event, iev_kw);
 		return 0;
 	}
 	/***************************************************************************
@@ -8164,6 +9063,8 @@
 	exports.clean_name = clean_name;
 	exports.clear_timeout = clear_timeout;
 	exports.cmp_two_simple_json = cmp_two_simple_json;
+	exports.command_parameter_from_json = command_parameter_from_json;
+	exports.command_parameter_from_text = command_parameter_from_text;
 	exports.command_parser = command_parser;
 	exports.createElement2 = createElement2;
 	exports.createOneHtml = createOneHtml;