@yuneta/gobj-js 7.26.26 → 7.26.28

package/README.md

@@ -308,10 +308,12 @@ string, a `DTP_DICT` or a `DTP_LIST` (7.26.25): a cycle anywhere inside, a
 of a class. They were written, and burst (or turned into `"{}"`) when the value
 was serialized, far from the write. And so is a value whose text would say
 another value (7.26.26): an object with a `toJSON()`, `NaN` or `Infinity` inside
-(the text says `null`; jansson holds no such real), a function, `undefined` or a
-symbol inside an array (the text says `null`), and a value nested deeper than
-2048 levels (a scalar is a level too), which C would not read back and which
-bursts `JSON.stringify()` a little further on. A getter or a `Proxy` trap that
+(the text says `null`; jansson holds no such real), a function, `undefined`, a
+symbol or a hole inside an array (`[1, , 3]`: the text says `null`), and a value
+nested deeper than 2048 levels (a scalar is a level too), which C would not read
+back and which bursts `JSON.stringify()` a little further on. Every version
+before 7.26.26 wrote them, so this is a BREAKING change for a caller that wrote
+one. A getter or a `Proxy` trap that
 throws is a refusal too, never an exception (7.26.26). A key whose value is
 `undefined`, a function or a symbol is dropped, as `JSON.stringify()` drops it:
 an absent key. A plain object of another realm (a `vm` context, an iframe) is a
@@ -324,6 +326,7 @@ gobj_write_attr(gobj, "settings", new Map([["a", 1]]));     // -1, ERROR "a valu
 gobj_write_str_attr(gobj, "name", new Map());               // -1: it was the text "{}"
 gobj_write_attr(gobj, "settings", {ratio: NaN});            // -1: it was the text {"ratio":null}
 gobj_write_attr(gobj, "items", [1, undefined]);             // -1: it was the text [1,null]
+gobj_write_attr(gobj, "items", [1, , 3]);                   // -1: a hole, it was the text [1,null,3]
 gobj_write_str_attr(gobj, "name", NaN);                     // -1: it was the text "null"
 ```
 
@@ -457,7 +460,10 @@ gobj_create_volatil(name, gclass_name, attrs, parent)
 gobj_create_pure_child(name, gclass_name, attrs, parent)
 
 // Start / Stop
-gobj_start(gobj)           // calls mt_start
+gobj_start(gobj)           // calls mt_start; -1 with an ERROR if a
+                           // SDF_REQUIRED attr is empty, as in C
+                           // (BREAKING in 7.26.28: "" string, empty_json()
+                           // list/dict/json, null pointer)
 gobj_stop(gobj)            // calls mt_stop
 gobj_start_children(gobj)
 gobj_stop_children(gobj)
@@ -596,6 +602,9 @@ gobj_search_path(gobj, path)
 
 gobj_walk_gobj_children(gobj, walk_type, cb_walking, user_data, user_data2)
 gobj_walk_gobj_children_tree(gobj, walk_type, cb_walking, user_data, user_data2)
+// A callback may destroy or move (gobj_change_parent()) any gobj: a
+// destroyed one is never handed, a moved one is handed where the walk
+// finds it now, and no gobj is handed twice in one walk (7.26.28).
 ```
 
 ### Persistence
@@ -723,13 +732,30 @@ kw_clone_by_not_keys(gobj, kw, keys, verbose)
 
 // Local storage helpers (browser localStorage, no "store" parameter)
 kw_get_local_storage_value(key, default_value, create)   // create=false
-kw_set_local_storage_value(key, value)
+kw_set_local_storage_value(key, value)                   // 0, or -1 logged
 kw_remove_local_storage_value(key)
+// BREAKING in 7.26.26: kw_get_local_storage_value() answers default_value
+// where it answered null (an absent entry, a json null) or undefined (no
+// browser), and an entry that is not json is REMOVED, with one WARNING
+// that never shows its text. A store the browser blocks (cookies blocked,
+// a sandboxed iframe: reading window.localStorage throws) answers the
+// default, warned once per key, and a write to it is -1 (7.26.27: before,
+// every helper and node_uuid() threw). A value with no json text is
+// refused by the writer, -1 with an ERROR, as a typed writer refuses it
+// (7.26.27; a function was stored as the text "undefined"):
+//   kw_set_local_storage_value("k", () => 1)     → -1
+//   kw_set_local_storage_value("k", {w: NaN})    → -1 (it was {"w":null})
+//   kw_set_local_storage_value("k", [1, , 3])    → -1 (a hole: [1,null,3])
+// A full store (read, not written) with `create`: the default, warned
+// once per key (7.26.28: an ERROR on every read).
 
 // Misc utilities
 current_timestamp()          // ISO string
 get_now()                    // Date object
-node_uuid()                  // generate UUID
+node_uuid()                  // uuid of this browser, the SAME for the
+                             // life of the page (kept in localStorage
+                             // "host_uuid"; a page uuid if the store
+                             // cannot keep it; never null: 7.26.28)
 parseBoolean(v)              // coerce to boolean
 empty_string(s)              // true if null/undefined/""
 str_in_list(list, str, ci)   // case-insensitive optional
@@ -1091,7 +1117,11 @@ 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 -- unless
 the session outlived `timeout_retry_max`: a session that long was served, and its
 fault starts the backoff over, as a clean end does (7.26.26). For the old fixed-interval behaviour set `timeout_retry_max` equal to
-`timeout_retry`.
+`timeout_retry`. The BASE of the first delay is **at least 1000 ms** (7.26.27;
+the ±20% jitter puts the first delay itself between 800 and 1200 ms): a lower
+`timeout_retry` is raised to 1000 with one WARNING, because 0 never doubled
+away from 0 and a server that closes before the ack was reconnected in a loop
+with no wait, hundreds of times a second.
 
 **A refused identity card** (`result < 0` in its ack) publishes `EV_ON_ID_NAK`
 and closes the channel with 1000; no session was reached, so the close is then

package/dist/gobj-js.cjs.js

@@ -1949,6 +1949,31 @@ function gobj_destroy_children(gobj) {
 	}
 }
 /************************************************************
+*  The SDF_REQUIRED attributes with no value, or null when there
+*  is none: what is empty is asked type by type, as in C.
+************************************************************/
+function gobj_check_required_attrs(gobj) {
+	const hs = gobj_hsdata(gobj);
+	const missing = [];
+	if (!is_array(gobj.gclass.attrs_table)) return null;
+	for (const it of gobj.gclass.attrs_table) {
+		if (!it.name || !(it.flag & sdata_flag_t.SDF_REQUIRED)) continue;
+		const value = hs[it.name];
+		switch (it.type) {
+			case data_type_t.DTP_STRING:
+				if (!is_string(value) || empty_string(value)) missing.push(it.name);
+				break;
+			case data_type_t.DTP_LIST:
+			case data_type_t.DTP_DICT:
+			case data_type_t.DTP_JSON:
+				if (empty_json(value)) missing.push(it.name);
+				break;
+			case data_type_t.DTP_POINTER: if (!value) missing.push(it.name);
+		}
+	}
+	return missing.length ? missing : null;
+}
+/************************************************************
 *
 ************************************************************/
 function gobj_start(gobj) {
@@ -1964,6 +1989,11 @@ function gobj_start(gobj) {
 		log_error(`${gobj_short_name(gobj)}: GObj DISABLED`);
 		return -1;
 	}
+	const required_attrs = gobj_check_required_attrs(gobj);
+	if (required_attrs) {
+		log_error(`${gobj_short_name(gobj)}: Cannot start without all required attributes: ` + JSON.stringify(required_attrs));
+		return -1;
+	}
 	if (__trace_gobj_start_stop__(gobj)) trace_machine(sprintf("⏺ ⏺ start: %s", gobj_full_name(gobj)));
 	gobj.running = true;
 	let ret = 0;
@@ -2350,7 +2380,7 @@ function gobj_walk_gobj_children(gobj, walk_type, cb_walking, user_data, user_da
 		log_error(`gobj NULL, destroying, or bad type`);
 		return 0;
 	}
-	return rc_walk_by_list(gobj.dl_children, walk_type, cb_walking, user_data, user_data2);
+	return rc_walk_by_list(gobj, /* @__PURE__ */ new Set(), walk_type, cb_walking, user_data, user_data2);
 }
 /***************************************************************************
 *
@@ -2360,7 +2390,7 @@ function gobj_walk_gobj_children_tree(gobj, walk_type, cb_walking, user_data, us
 		log_error(`gobj NULL, destroying, or bad type`);
 		return 0;
 	}
-	return rc_walk_by_tree(gobj.dl_children, walk_type, cb_walking, user_data, user_data2);
+	return rc_walk_by_tree(gobj, /* @__PURE__ */ new Set(), walk_type, cb_walking, user_data, user_data2);
 }
 /***************************************************************
 *  Walking
@@ -2387,16 +2417,33 @@ function walk_ret(ret) {
 	log_error(`walk callback must return a NUMBER (-1 stop, 0 descend, >0 skip children), got ${typeof ret}: taken as 0`);
 	return 0;
 }
-function rc_walk_by_list(iter_, walk_type, cb_walking, user_data, user_data2) {
-	let iter = [...iter_];
+/***************************************************************
+*  Whether a walk steps over this gobj of the list of `owner`.
+*
+*  Each list is walked over a COPY of it, because a callback may destroy
+*  any gobj of the list, the current one included, or move one with
+*  gobj_change_parent(). One it destroyed is stepped over, as the C walk
+*  does; one it moved is no longer in this list, and is handed where the
+*  walk finds it now (7.26.27 handed it here AND there); and a gobj is
+*  never handed twice in one walk (`seen`), wherever it was moved.
+***************************************************************/
+function walk_steps_over(child, owner, seen) {
+	return gobj_is_destroying(child) || child.parent !== owner || seen.has(child);
+}
+function rc_walk_by_list(owner, seen, walk_type, cb_walking, user_data, user_data2) {
+	let iter = [...owner.dl_children];
 	let child;
 	if (walk_type & walk_type_t.WALK_LAST2FIRST) for (let i = iter.length; i > 0; i--) {
 		child = iter[i - 1];
+		if (walk_steps_over(child, owner, seen)) continue;
+		seen.add(child);
 		let ret = walk_ret(cb_walking(child, user_data, user_data2));
 		if (ret < 0) return ret;
 	}
 	else for (let i = 0; i < iter.length; i++) {
 		child = iter[i];
+		if (walk_steps_over(child, owner, seen)) continue;
+		seen.add(child);
 		let ret = walk_ret(cb_walking(child, user_data, user_data2));
 		if (ret < 0) return ret;
 	}
@@ -2411,21 +2458,23 @@ function rc_walk_by_list(iter_, walk_type, cb_walking, user_data, user_data2) {
 *          or
 *          WALK_LAST2FIRST
 ***************************************************************/
-function rc_walk_by_level(iter, walk_type, cb_walking, user_data, user_data2) {
-	let ret = rc_walk_by_list(iter, walk_type, cb_walking, user_data, user_data2);
-	if (ret < 0) return ret;
-	let child;
-	if (walk_type & walk_type_t.WALK_LAST2FIRST) for (let i = iter.length; i > 0; i--) {
-		child = iter[i - 1];
-		ret = rc_walk_by_level([...child.dl_children], walk_type, cb_walking, user_data, user_data2);
+function rc_walk_by_level(owner, seen, walk_type, cb_walking, user_data, user_data2) {
+	let iter = [...owner.dl_children];
+	if (walk_type & walk_type_t.WALK_LAST2FIRST) iter.reverse();
+	let handed = [];
+	for (const child of iter) {
+		if (walk_steps_over(child, owner, seen)) continue;
+		seen.add(child);
+		handed.push(child);
+		let ret = walk_ret(cb_walking(child, user_data, user_data2));
 		if (ret < 0) return ret;
 	}
-	else for (let i = 0; i < iter.length; i++) {
-		child = iter[i];
-		ret = rc_walk_by_level([...child.dl_children], walk_type, cb_walking, user_data, user_data2);
+	for (const child of handed) {
+		if (gobj_is_destroying(child)) continue;
+		let ret = rc_walk_by_level(child, seen, walk_type, cb_walking, user_data, user_data2);
 		if (ret < 0) return ret;
 	}
-	return ret;
+	return 0;
 }
 /***************************************************************
 *  Walking
@@ -2442,23 +2491,29 @@ function rc_walk_by_level(iter, walk_type, cb_walking, user_data, user_data2) {
 *          or
 *          WALK_LAST2FIRST
 ***************************************************************/
-function rc_walk_by_tree(iter, walk_type, cb_walking, user_data, user_data2) {
-	if (walk_type & walk_type_t.WALK_BYLEVEL) return rc_walk_by_level(iter, walk_type, cb_walking, user_data, user_data2);
+function rc_walk_by_tree(owner, seen, walk_type, cb_walking, user_data, user_data2) {
+	if (walk_type & walk_type_t.WALK_BYLEVEL) return rc_walk_by_level(owner, seen, walk_type, cb_walking, user_data, user_data2);
+	let iter = [...owner.dl_children];
 	let ret;
 	let child;
 	if (walk_type & walk_type_t.WALK_BOTTOM2TOP) for (let i = iter.length; i > 0; i--) {
 		child = iter[i - 1];
-		ret = rc_walk_by_tree([...child.dl_children], walk_type, cb_walking, user_data, user_data2);
+		if (walk_steps_over(child, owner, seen)) continue;
+		ret = rc_walk_by_tree(child, seen, walk_type, cb_walking, user_data, user_data2);
 		if (ret < 0) return ret;
+		if (gobj_is_destroying(child)) continue;
+		seen.add(child);
 		ret = walk_ret(cb_walking(child, user_data, user_data2));
 		if (ret < 0) return ret;
 	}
 	else for (let i = 0; i < iter.length; i++) {
 		child = iter[i];
+		if (walk_steps_over(child, owner, seen)) continue;
+		seen.add(child);
 		ret = walk_ret(cb_walking(child, user_data, user_data2));
 		if (ret < 0) return ret;
-		else if (ret === 0) {
-			ret = rc_walk_by_tree([...child.dl_children], walk_type, cb_walking, user_data, user_data2);
+		else if (ret === 0 && !gobj_is_destroying(child)) {
+			ret = rc_walk_by_tree(child, seen, walk_type, cb_walking, user_data, user_data2);
 			if (ret < 0) return ret;
 		}
 	}
@@ -6043,44 +6098,99 @@ function kw_clone_by_not_keys(gobj, kw, keys, verbose) {
 	return kw_clone;
 }
 /********************************************
+*  The browser's localStorage, or null when there is none (outside a
+*  browser).
+*
+*  With the site's data blocked (Chrome with cookies blocked, a sandboxed
+*  iframe), READING the window.localStorage property already throws a
+*  SecurityError, not only its getItem(): every app reads its locale at
+*  start, so the app did not start. Such a store is answered as one whose
+*  every call throws that error, so each helper fails as it fails for any
+*  store that refuses it: a read gives the default, a write -1.
+********************************************/
+function local_store() {
+	if (typeof window === "undefined") return null;
+	let store;
+	try {
+		store = window.localStorage;
+	} catch (e) {
+		const refuse = () => {
+			throw e;
+		};
+		return {
+			getItem: refuse,
+			setItem: refuse,
+			removeItem: refuse
+		};
+	}
+	return store || null;
+}
+/********************************************
+*  A failure of the store that would repeat on every read is warned
+*  once per key, until a read of the key goes well again.
+********************************************/
+var local_storage_warned = /* @__PURE__ */ new Set();
+function warn_local_storage_once(key, msg) {
+	if (local_storage_warned.has(key)) return;
+	local_storage_warned.add(key);
+	log_warning(msg);
+}
+/********************************************
 *  Get a local attribute
 *
 *  The json the entry holds, or `default_value` when there is none
 *  (written there too with `create`). A json null is no value, as
 *  json_absent() in C: the default. An entry that is not json (a
-*  corrupt or foreign write) is one WARNING and is REMOVED, so the
+*  corrupt or foreign write) is a WARNING and is REMOVED, so the
 *  next read finds no entry: it used to console.warn on every read,
-*  for ever. Its text is never shown (JSON.parse() quotes it in its
-*  error, and an entry can hold a token). A store that cannot be read
-*  is warned once per key. Outside a browser: the default.
+*  for ever; a new corrupt entry is a new WARNING. Its text is never
+*  shown (JSON.parse() quotes it in its error, and an entry can hold a
+*  token). A store that cannot be read (blocked) is warned once per
+*  key, and the default is NOT written there; one that cannot be
+*  written (full) is warned once per key too: with `create` it was an
+*  ERROR on every read, the default tried again each time. A key is
+*  warned again after a read that goes well. Outside a browser: the
+*  default.
 ********************************************/
-var local_storage_warned = /* @__PURE__ */ new Set();
-function warn_local_storage_once(key, what) {
-	if (local_storage_warned.has(key)) return;
-	local_storage_warned.add(key);
-	log_warning(`kw_get_local_storage_value(): localStorage key "${key}" ${what}`);
-}
 function kw_get_local_storage_value(key, default_value, create = false) {
-	if (typeof window === "undefined" || !window.localStorage) return default_value;
+	const store = local_store();
+	if (!store) return default_value;
+	const where = `kw_get_local_storage_value(): localStorage key "${key}"`;
 	let text;
 	try {
-		text = window.localStorage.getItem(key);
+		text = store.getItem(key);
 	} catch (e) {
-		warn_local_storage_once(key, "cannot be read (storage blocked?): the default is used");
+		warn_local_storage_once(key, `${where} cannot be read (storage blocked?): the default is used`);
 		return default_value;
 	}
+	let went_well = true;
 	let value = null;
 	if (text !== null) try {
 		value = JSON.parse(text);
 	} catch (e) {
-		warn_local_storage_once(key, "does not hold json: removed, the default is used");
-		kw_remove_local_storage_value(key);
 		value = null;
+		try {
+			store.removeItem(key);
+			log_warning(`${where} does not hold json: removed, the default is used`);
+		} catch (e2) {
+			went_well = false;
+			warn_local_storage_once(key, `${where} does not hold json and cannot be removed: the default is used`);
+		}
 	}
 	if (value === null) {
-		if (create) kw_set_local_storage_value(key, default_value);
-		return default_value;
+		value = default_value;
+		if (create) {
+			const default_text = json_text_of(default_value);
+			if (default_text === void 0) log_error(`${where}: cannot write the default: a value with no json text`);
+			else try {
+				store.setItem(key, default_text);
+			} catch (e) {
+				went_well = false;
+				warn_local_storage_once(key, `${where} cannot be written (storage full or blocked?): the default is used, not kept`);
+			}
+		}
 	}
+	if (went_well) local_storage_warned.delete(key);
 	return value;
 }
 /********************************************
@@ -6092,15 +6202,26 @@ function kw_get_local_storage_value(key, default_value, create = false) {
 *  reported success on a store that had rejected the write: a full or blocked
 *  localStorage (quota, private mode) silently discarded the change while the
 *  UI showed it as saved.
+*
+*  A value with no json text is refused with an ERROR, as a typed writer
+*  refuses it (json_text_of()): a function was stored as the text
+*  "undefined", and a NaN, a Date or a Map as a text that reads back as
+*  another value. Checked in Node.js too, where there is no store.
 ********************************************/
 function kw_set_local_storage_value(key, value) {
-	if (typeof window === "undefined" || !window.localStorage) return 0;
-	if (!key || value === void 0) {
-		log_error(`kw_set_local_storage_value(): invalid key or value: key=${key}`);
+	if (!key) {
+		log_error(`kw_set_local_storage_value(): invalid key: key=${key}`);
+		return -1;
+	}
+	const text = json_text_of(value);
+	if (text === void 0) {
+		log_error(`kw_set_local_storage_value(): cannot save "${key}": a value with no json text`);
 		return -1;
 	}
+	const store = local_store();
+	if (!store) return 0;
 	try {
-		window.localStorage.setItem(key, JSON.stringify(value));
+		store.setItem(key, text);
 		return 0;
 	} catch (e) {
 		log_error(`kw_set_local_storage_value(): cannot save "${key}" (storage full or blocked?): ${e && e.message ? e.message : e}`);
@@ -6111,15 +6232,16 @@ function kw_set_local_storage_value(key, value) {
 *  Remove local attribute
 ********************************************/
 function kw_remove_local_storage_value(key) {
-	if (typeof window === "undefined" || !window.localStorage) return;
+	const store = local_store();
+	if (!store) return;
 	if (!key) {
-		window.console.warn(`Invalid key for localStorage removal: ${key}`);
+		log_error(`kw_remove_local_storage_value(): invalid key: key=${key}`);
 		return;
 	}
 	try {
-		window.localStorage.removeItem(key);
+		store.removeItem(key);
 	} catch (e) {
-		window.console.warn(`Error removing localStorage key "${key}":`, e);
+		log_warning(`kw_remove_local_storage_value(): cannot remove "${key}" (storage blocked?): ${e && e.message ? e.message : e}`);
 	}
 }
 /*************************************************************
@@ -7308,19 +7430,62 @@ function index_in_list(list, elm) {
 	return -1;
 }
 /************************************************************
+*  A new uuid v4 (RFC 9562).
 *
+*  crypto.randomUUID() exists only in a secure context, so a page
+*  served over http without TLS has none; crypto.getRandomValues()
+*  exists there too. With no crypto at all, Math.random(): not fit
+*  for a secret, and a uuid that names a node is not one.
 ************************************************************/
+function new_uuid() {
+	const c = typeof window !== "undefined" && window.crypto || globalThis.crypto;
+	if (c && typeof c.randomUUID === "function") return c.randomUUID();
+	const b = /* @__PURE__ */ new Uint8Array(16);
+	if (c && typeof c.getRandomValues === "function") c.getRandomValues(b);
+	else for (let i = 0; i < b.length; i++) b[i] = Math.floor(Math.random() * 256);
+	b[6] = b[6] & 15 | 64;
+	b[8] = b[8] & 63 | 128;
+	const h = Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+	return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+/************************************************************
+*  The uuid of this node: ONE for the life of the page.
+*
+*  The one the store keeps ("host_uuid"), made and written there when
+*  there is none. When the store cannot keep it (blocked, full, no
+*  localStorage, outside a browser) the one this page made, warned
+*  once. It goes in the node_uuid attribute of the yuno, the id of the
+*  identity card and the `host` of every message the client sends, so
+*  the first answer is kept and answered again: 7.26.27 made a new
+*  uuid on every call when the store could not keep it, and answered
+*  null without crypto.randomUUID().
+************************************************************/
+var uuid_of_this_page = null;
 function node_uuid() {
-	let uuid = "";
-	if (typeof window !== "undefined" && window.localStorage) {
-		uuid = window.localStorage.getItem("host_uuid");
-		if (!uuid && window.crypto?.randomUUID) {
-			uuid = window.crypto.randomUUID();
-			window.localStorage.setItem("host_uuid", uuid);
+	if (uuid_of_this_page) return uuid_of_this_page;
+	const store = local_store();
+	if (!store) {
+		uuid_of_this_page = new_uuid();
+		return uuid_of_this_page;
+	}
+	let uuid = null;
+	try {
+		uuid = store.getItem("host_uuid");
+	} catch (e) {
+		warn_local_storage_once("host_uuid", "node_uuid(): localStorage cannot be read (storage blocked?): a uuid of this page only");
+		uuid_of_this_page = new_uuid();
+		return uuid_of_this_page;
+	}
+	if (!uuid) {
+		uuid = new_uuid();
+		try {
+			store.setItem("host_uuid", uuid);
+		} catch (e) {
+			warn_local_storage_once("host_uuid", "node_uuid(): localStorage cannot be written (storage full or blocked?): a uuid of this page only");
 		}
-	} else if (typeof globalThis !== "undefined" && globalThis.crypto?.randomUUID) uuid = globalThis.crypto.randomUUID();
-	else uuid = "00000000-0000-0000-0000-000000000000";
-	return uuid;
+	}
+	uuid_of_this_page = uuid;
+	return uuid_of_this_page;
 }
 /************************************************************
 *   Build a cleaned name
@@ -8605,7 +8770,7 @@ var attrs_table = [
 	SDATA(data_type_t.DTP_STRING, "cert_pem", sdata_flag_t.SDF_PERSIST, "", "SSL server certification, PEM str format"),
 	SDATA(data_type_t.DTP_JSON, "extra_info", sdata_flag_t.SDF_RD, "{}", "dict data set by user, added to the identity card msg."),
 	SDATA(data_type_t.DTP_LIST, "required_services", sdata_flag_t.SDF_RD, "[]", "Services this LINK requires (identity card). Empty = the yuno's `required_services`, as before. A yuno with several links to DIFFERENT backends must set it per link: the yuno-wide list is the union, so every backend is told the service names of all the others."),
-	SDATA(data_type_t.DTP_INTEGER, "timeout_retry", sdata_flag_t.SDF_RD, "5000", "First reconnect delay (ms). It BACKS OFF from here, doubling up to timeout_retry_max, and resets when a session is reached"),
+	SDATA(data_type_t.DTP_INTEGER, "timeout_retry", sdata_flag_t.SDF_RD, "5000", "Base of the first reconnect delay (ms, ±20% jitter), at least 1000. It BACKS OFF from here, doubling up to timeout_retry_max, and resets when a session is reached"),
 	SDATA(data_type_t.DTP_INTEGER, "timeout_retry_max", sdata_flag_t.SDF_RD, "60000", "Cap of the reconnect backoff (ms). Set it equal to timeout_retry for the old fixed-interval behaviour"),
 	SDATA(data_type_t.DTP_INTEGER, "timeout_idack", sdata_flag_t.SDF_RD, "5000", "timeout waiting idAck"),
 	SDATA(data_type_t.DTP_POINTER, "subscriber", 0, 0, "subscriber of output-events. If null then subscriber is the parent"),
@@ -8630,7 +8795,8 @@ var PRIVATE_DATA = {
 	inside_on_open: false,
 	retry_ms: 0,
 	retry_ms_before_session: 0,
-	session_since: 0
+	session_since: 0,
+	retry_floor_warned: false
 };
 var __gclass__ = null;
 /******************************
@@ -8902,7 +9068,7 @@ var CLOSE_PEER_FAULT = 4002;
 function close_for_peer_fault(gobj, reason) {
 	let priv = gobj.priv;
 	if (gobj_current_state(gobj) === "ST_SESSION") {
-		if (performance.now() - priv.session_since < Math.max(gobj_read_integer_attr(gobj, "timeout_retry"), gobj_read_integer_attr(gobj, "timeout_retry_max"))) priv.retry_ms = priv.retry_ms_before_session;
+		if (performance.now() - priv.session_since < retry_bounds(gobj).max) priv.retry_ms = priv.retry_ms_before_session;
 		priv.retry_ms_before_session = 0;
 	}
 	close_websocket(gobj, CLOSE_PEER_FAULT, reason);
@@ -9174,6 +9340,32 @@ function ac_on_close(gobj, event, kw, src) {
 	return 0;
 }
 /***************************************************************
+*  The first delay of the backoff and its cap.
+*
+*  A first delay below RETRY_FLOOR_MS is raised to it, with a WARNING
+*  once: `timeout_retry` 0 never left 0 (0 doubled is 0), so a server
+*  that closed before the ack was reconnected in a loop with no wait,
+*  hundreds of connections a second.
+***************************************************************/
+var RETRY_FLOOR_MS = 1e3;
+function retry_bounds(gobj) {
+	let priv = gobj.priv;
+	let base = gobj_read_integer_attr(gobj, "timeout_retry");
+	let max = gobj_read_integer_attr(gobj, "timeout_retry_max");
+	if (!(base >= RETRY_FLOOR_MS)) {
+		if (!priv.retry_floor_warned) {
+			priv.retry_floor_warned = true;
+			log_warning(`${gobj_short_name(gobj)}: timeout_retry ${base} ms is below ${RETRY_FLOOR_MS} ms: ${RETRY_FLOOR_MS} ms is used`);
+		}
+		base = RETRY_FLOOR_MS;
+	}
+	if (!(max >= base)) max = base;
+	return {
+		base,
+		max
+	};
+}
+/***************************************************************
 *  How long to wait before the next reconnect attempt.
 *
 *  The delay used to be a constant (`timeout_retry`, 5s), for ever. A
@@ -9194,9 +9386,7 @@ function ac_on_close(gobj, event, kw, src) {
 ***************************************************************/
 function next_retry(gobj) {
 	let priv = gobj.priv;
-	let base = gobj_read_integer_attr(gobj, "timeout_retry");
-	let max = gobj_read_integer_attr(gobj, "timeout_retry_max");
-	if (max < base) max = base;
+	const { base, max } = retry_bounds(gobj);
 	priv.retry_ms = priv.retry_ms ? Math.min(priv.retry_ms * 2, max) : base;
 	let jitter = priv.retry_ms * .2;
 	let ms = priv.retry_ms - jitter + Math.random() * 2 * jitter;
@@ -9694,6 +9884,7 @@ exports.json_object_update = json_object_update;
 exports.json_object_update_existing = json_object_update_existing;
 exports.json_object_update_missing = json_object_update_missing;
 exports.json_size = json_size;
+exports.json_text_of = json_text_of;
 exports.jwt2json = jwt2json;
 exports.jwtDecode = jwtDecode;
 exports.kw_clone_by_keys = kw_clone_by_keys;