@yuneta/gobj-ui 7.23.140 → 7.23.142

package/dist/gobj-ui.es.js

@@ -13106,7 +13106,7 @@ function ac_find_nodes$3(gobj, event, kw, src) {
 /************************************************************
 *  EV_EXPAND_ALL
 ************************************************************/
-function ac_expand_all$4(gobj, event, kw, src) {
+function ac_expand_all$2(gobj, event, kw, src) {
 	let priv = gobj.priv;
 	if (priv.collapsed.size === 0) return 0;
 	priv.collapsed.clear();
@@ -13118,7 +13118,7 @@ function ac_expand_all$4(gobj, event, kw, src) {
 /************************************************************
 *  EV_COLLAPSE_ALL — fold every card but the root.
 ************************************************************/
-function ac_collapse_all$4(gobj, event, kw, src) {
+function ac_collapse_all$2(gobj, event, kw, src) {
 	let priv = gobj.priv;
 	let json_data = gobj_read_attr(gobj, "json_data");
 	if (!json_data) return 0;
@@ -13418,12 +13418,12 @@ function create_gclass$13(gclass_name) {
 		],
 		[
 			"EV_EXPAND_ALL",
-			ac_expand_all$4,
+			ac_expand_all$2,
 			null
 		],
 		[
 			"EV_COLLAPSE_ALL",
-			ac_collapse_all$4,
+			ac_collapse_all$2,
 			null
 		],
 		[
@@ -14495,7 +14495,7 @@ function ac_search$2(gobj, event, kw, src) {
 /************************************************************
 *   EV_EXPAND_ALL — expand every already-loaded container
 ************************************************************/
-function ac_expand_all$3(gobj, event, kw, src) {
+function ac_expand_all$1(gobj, event, kw, src) {
 	let priv = gobj.priv;
 	if (priv.root === null || priv.root === void 0) return 0;
 	let paths = [];
@@ -14513,7 +14513,7 @@ function ac_expand_all$3(gobj, event, kw, src) {
 /************************************************************
 *   EV_COLLAPSE_ALL
 ************************************************************/
-function ac_collapse_all$3(gobj, event, kw, src) {
+function ac_collapse_all$1(gobj, event, kw, src) {
 	gobj.priv.expanded.clear();
 	render_view$1(gobj);
 	return 0;
@@ -14698,12 +14698,12 @@ function create_gclass$12(gclass_name) {
 		],
 		[
 			"EV_EXPAND_ALL",
-			ac_expand_all$3,
+			ac_expand_all$1,
 			null
 		],
 		[
 			"EV_COLLAPSE_ALL",
-			ac_collapse_all$3,
+			ac_collapse_all$1,
 			null
 		],
 		[
@@ -19725,7 +19725,7 @@ function ac_toggle_collapse(gobj, event, kw, src) {
 /************************************************************
 *  Force every node visible (overrides threshold).
 ************************************************************/
-function ac_expand_all$2(gobj, event, kw, src) {
+function ac_expand_all(gobj, event, kw, src) {
 	let priv = gobj.priv;
 	if (!priv.collapse_state) priv.collapse_state = {};
 	if (priv.node_by_id) for (let id of Object.keys(priv.node_by_id)) {
@@ -19738,7 +19738,7 @@ function ac_expand_all$2(gobj, event, kw, src) {
 /************************************************************
 *  Collapse every node that has children.
 ************************************************************/
-function ac_collapse_all$2(gobj, event, kw, src) {
+function ac_collapse_all(gobj, event, kw, src) {
 	let priv = gobj.priv;
 	if (!priv.collapse_state) priv.collapse_state = {};
 	if (priv.node_by_id) for (let id of Object.keys(priv.node_by_id)) {
@@ -20090,12 +20090,12 @@ function create_gclass$9(gclass_name) {
 		],
 		[
 			"EV_EXPAND_ALL",
-			ac_expand_all$2,
+			ac_expand_all,
 			null
 		],
 		[
 			"EV_COLLAPSE_ALL",
-			ac_collapse_all$2,
+			ac_collapse_all,
 			null
 		],
 		[
@@ -27670,7 +27670,9 @@ function fold_build_model(descs, records, opts) {
 	opts = is_object(opts) ? opts : {};
 	let hidden = new Set(is_array(opts.hidden_topics) ? opts.hidden_topics : []);
 	let loose_shown = new Set(is_array(opts.loose_topics) ? opts.loose_topics : []);
-	let main_topic = opts.main_topic || fold_main_topic(descs);
+	let main_topic = opts.main_topic || "";
+	if (main_topic && !fold_is_hierarchical(descs, main_topic)) main_topic = "";
+	if (!main_topic) main_topic = fold_main_topic(descs);
 	if (main_topic && (!descs[main_topic] || hidden.has(main_topic))) main_topic = "";
 	let linked = fold_linked_topics(descs, main_topic);
 	let totals = {};
@@ -27734,7 +27736,7 @@ function fold_build_model(descs, records, opts) {
 		for (let k of reach_from(nodes, [node.key])) reached.add(k);
 	}
 	for (let topic_name of topics) if (roots[topic_name].length > 0) groups.set(fold_root_group_key(topic_name), roots[topic_name]);
-	return {
+	let model = {
 		nodes,
 		groups,
 		topics,
@@ -27743,32 +27745,97 @@ function fold_build_model(descs, records, opts) {
 		main_topic,
 		linked,
 		loose,
-		loose_shown
+		loose_shown,
+		level_of: null,
+		levels: 0
 	};
+	count_levels(model);
+	return model;
 }
 /************************************************************
-*  The topic the schema hangs the others from: the one whose hooks
-*  reach the most OTHER topics, a self-referent hook breaking a tie
-*  (a tree of places over a flat list of groups), schema order
-*  breaking the rest. "" when no topic reaches another -- a treedb of
-*  unrelated lists has no trunk, and every topic is a tree of its own.
+*  The LEVELS of the main tree: the roots of the main topic --
+*  and of the topics hung from it, whose roots are the loose
+*  records the reader asked for -- are level 1, their children
+*  level 2, and so on down every hook of every topic that is not
+*  hidden. A node reached by two paths takes the shallowest.
+*
+*  With no main topic every topic is a tree of its own and all
+*  of them count. A topic the schema does not tie to the main
+*  one is a separate tree, and has no level: the stepper of the
+*  toolbar speaks for the main tree and nothing else, those
+*  trees are opened by their own pills.
+************************************************************/
+function count_levels(model) {
+	let level_of = /* @__PURE__ */ new Map();
+	let queue = [];
+	let deepest = 0;
+	for (let topic_name of model.topics) {
+		if (model.main_topic && !model.linked.has(topic_name)) continue;
+		let roots = model.groups.get(fold_root_group_key(topic_name)) || [];
+		for (let key of roots) if (!level_of.has(key)) {
+			level_of.set(key, 1);
+			queue.push(key);
+		}
+	}
+	let head = 0;
+	while (head < queue.length) {
+		let key = queue[head++];
+		let lv = level_of.get(key);
+		if (lv > deepest) deepest = lv;
+		let node = model.nodes.get(key);
+		if (!node) continue;
+		for (let hook of Object.keys(node.hooks)) for (let child of node.hooks[hook]) if (!level_of.has(child)) {
+			level_of.set(child, lv + 1);
+			queue.push(child);
+		}
+	}
+	model.level_of = level_of;
+	model.levels = deepest;
+}
+/************************************************************
+*  A HIERARCHICAL topic: one hooked to ITSELF -- places inside
+*  places, groups inside groups, roles inside roles. It is the
+*  only kind of topic a tree can hang from: a topic that only
+*  reaches OTHER topics is a list with children, and making it
+*  the trunk drew the agent's treedb from `yunos` instead of
+*  `realms`.
+*
+*  (Not the engine's `entity` tier, which is any topic with
+*  hooks AND fkeys: that one sizes a card and says nothing about
+*  where a tree starts.)
+************************************************************/
+function fold_is_hierarchical(descs, topic_name) {
+	if (!is_object(descs) || !descs[topic_name]) return false;
+	return hook_targets(descs, topic_name).has(topic_name);
+}
+/************************************************************
+*  The topic the tree hangs from. Only a HIERARCHICAL topic can
+*  be it, and in this order:
+*
+*      the one the schema MARKS (`main_topic: true` on the topic,
+*      sent by the backend in its desc since SDK 7.19; the first
+*      one in schema order if a schema marks two);
+*      else the one whose hooks reach the most OTHER topics,
+*      schema order breaking a tie.
+*
+*  "" when no topic is hooked to itself: there is no trunk, and
+*  every topic is a tree of its own. (A pick by the reader comes
+*  first of all, and is fold_build_model's business.)
 ************************************************************/
 function fold_main_topic(descs) {
 	descs = is_object(descs) ? descs : {};
+	let candidates = Object.keys(descs).filter((topic_name) => {
+		return topic_name.substring(0, 2) !== "__" && fold_is_hierarchical(descs, topic_name);
+	});
+	for (let topic_name of candidates) if (descs[topic_name].main_topic === true) return topic_name;
 	let best = "";
-	let best_score = 0;
-	let best_self = false;
-	for (let topic_name of Object.keys(descs)) {
-		if (topic_name.substring(0, 2) === "__") continue;
+	let best_score = -1;
+	for (let topic_name of candidates) {
 		let reach = hook_targets(descs, topic_name);
-		let self = reach.has(topic_name);
 		reach.delete(topic_name);
-		let score = reach.size;
-		if (score === 0) continue;
-		if (score > best_score || score === best_score && self && !best_self) {
+		if (reach.size > best_score) {
 			best = topic_name;
-			best_score = score;
-			best_self = self;
+			best_score = reach.size;
 		}
 	}
 	return best;
@@ -27870,14 +27937,6 @@ function fold_show_more(model, state, group_key) {
 	return n;
 }
 /************************************************************
-*  Every group open on ALL its children. This is the reader
-*  asking for the whole thing; the pages are for the other way in.
-************************************************************/
-function fold_expand_all(model, state) {
-	state.shown.clear();
-	for (let [group_key, list] of model.groups) if (list.length > 0) state.shown.set(group_key, list.length);
-}
-/************************************************************
 *  The roots and nothing else -- the first page of each topic's
 *  roots, the way the graph looks before anything is opened.
 ************************************************************/
@@ -27889,40 +27948,51 @@ function fold_collapse_all(model, state) {
 	}
 }
 /************************************************************
-*  Open the tree down to `depth` levels: the roots are level 1,
-*  their children level 2. A node reached by two paths takes the
-*  shallowest. Each group opens on its first page. `depth` of 1
-*  is the roots alone; anything below that is treated as 1.
+*  The toolbar's STEPPER over the levels of the main tree (see
+*  count_levels): level N shows the roots and N-1 levels under
+*  them. A level is a floor of what is open, not a picture that
+*  replaces it:
+*
+*      opening to N   opens, on its first page, every hook of
+*                     every node above level N that is folded;
+*                     what the reader opened, and every page
+*                     already shown, stays
+*      closing to N   folds every hook of every node at level N
+*                     or below, and touches nothing above it
+*
+*  A separate tree (a topic not tied to the main one) has no
+*  level, so neither ever touches it.
 ************************************************************/
-function fold_expand_to_depth(model, state, depth) {
-	fold_collapse_all(model, state);
-	if (!(depth > 1)) return;
-	let level = /* @__PURE__ */ new Map();
-	let queue = [];
-	for (let topic_name of model.topics) {
-		let roots = model.groups.get(fold_root_group_key(topic_name)) || [];
-		for (let key of roots) if (!level.has(key)) {
-			level.set(key, 1);
-			queue.push(key);
-		}
-	}
-	while (queue.length) {
-		let key = queue.shift();
-		let lv = level.get(key);
-		if (lv >= depth) continue;
+function fold_level_clamp(model, level) {
+	let top = model.levels > 0 ? model.levels : 1;
+	level = Math.floor(Number(level)) || 1;
+	if (level < 1) return 1;
+	if (level > top) return top;
+	return level;
+}
+function fold_open_levels(model, state, level) {
+	for (let [key, lv] of model.level_of) {
+		if (lv >= level) continue;
 		let node = model.nodes.get(key);
 		if (!node) continue;
 		for (let hook of Object.keys(node.hooks)) {
-			let children = node.hooks[hook];
-			if (children.length === 0) continue;
-			state.shown.set(fold_group_key(key, hook), state.page_size);
-			for (let child of children) if (!level.has(child)) {
-				level.set(child, lv + 1);
-				queue.push(child);
-			}
+			let group_key = fold_group_key(key, hook);
+			if (node.hooks[hook].length > 0 && !fold_is_open(state, group_key)) state.shown.set(group_key, state.page_size);
 		}
 	}
 }
+function fold_close_levels(model, state, level) {
+	for (let [key, lv] of model.level_of) {
+		if (lv < level) continue;
+		let node = model.nodes.get(key);
+		if (!node) continue;
+		for (let hook of Object.keys(node.hooks)) state.shown.delete(fold_group_key(key, hook));
+	}
+}
+function fold_expand_to_level(model, state, level) {
+	fold_collapse_all(model, state);
+	fold_open_levels(model, state, fold_level_clamp(model, level));
+}
 /************************************************************
 *  The set of node keys on screen, from the roots down through
 *  every open group -- and only through open groups whose parent
@@ -55165,8 +55235,9 @@ function ensure_brush_select_owned() {
 *          The graph opens FOLDED, like a JSON viewer.
 *
 *          Every record of every topic is fetched, but only the ones on
-*          screen become G6 nodes: the roots, `expand_depth` levels under
-*          them, one page (`fold_page_size`) of children per hook. Each
+*          screen become G6 nodes: the roots, and the MAIN tree open to
+*          the reader's level (`fold_level`, `expand_depth` until they
+*          step it), one page (`fold_page_size`) of children per hook. Each
 *          card carries a pill per hook that has children -- `▸ devices
 *          142` -- which opens or folds that hook; an open hook with more
 *          children than its page ends in a `+N` chip that opens the next
@@ -55250,13 +55321,13 @@ var NODE_MODES$1 = [
 	"shape"
 ];
 var PILL_SIZE = {
-	hierarchical: [200, 30],
+	entity: [200, 30],
 	extended: [180, 28],
 	child: [160, 26]
 };
 var PORT_R_PILL = 6;
 var SHAPE_SIZE = {
-	hierarchical: 32,
+	entity: 32,
 	extended: 28,
 	child: 22
 };
@@ -55344,7 +55415,8 @@ var attrs_table$4 = [
 	SDATA(data_type_t.DTP_LIST, "layout_names", sdata_flag_t.SDF_RD, JSON.stringify(Object.keys(_layouts)), "Available layout names (read-only, for parent to query)"),
 	SDATA(data_type_t.DTP_STRING, "hook_port_position", 0, "bottom", "Hook port position"),
 	SDATA(data_type_t.DTP_STRING, "fkey_port_position", 0, "top", "Fkey port position"),
-	SDATA(data_type_t.DTP_INTEGER, "expand_depth", 0, 2, "Levels open when a treedb loads: 1 = the roots alone, 2 = the roots and their children. Every open hook shows its first page"),
+	SDATA(data_type_t.DTP_INTEGER, "expand_depth", 0, 1, "Levels open when a treedb loads, until the reader steps (`fold_level`): 1 = the roots alone (the default), 2 = the roots and their children. Every open hook shows its first page"),
+	SDATA(data_type_t.DTP_INTEGER, "fold_level", 0, 0, "The level of the MAIN tree the toolbar's stepper stands on: 1 = its roots, N = N-1 levels under them; 0 = `expand_depth`. The host persists it and sends EV_SET_FOLD_LEVEL; it is published back in EV_LEGEND_STATE (`fold`) with the levels the tree has"),
 	SDATA(data_type_t.DTP_INTEGER, "fold_page_size", 0, 24, "Children of one hook shown per page; the `+N` chip after the page opens the next one"),
 	SDATA(data_type_t.DTP_LIST, "hidden_topics", 0, "[]", "Topics left out of the tree: no card, no pill counts them, no edge reaches them"),
 	SDATA(data_type_t.DTP_STRING, "main_topic", 0, "", "The topic the tree hangs from; empty = deduced (the one whose hooks reach the most others). Its parentless records are the roots; a parentless record of a topic linked to it is LOOSE and shown only on request"),
@@ -55435,7 +55507,8 @@ var PRIVATE_DATA$4 = {
 	_layout_asked: "",
 	_nodes_total: 0,
 	_nodes_placed: 0,
-	expand_depth: 2,
+	expand_depth: 1,
+	fold_level: 0,
 	fold_page_size: 24,
 	hidden_topics: null,
 	main_topic: "",
@@ -56158,7 +56231,12 @@ function configure_behaviour(gobj) {
 	graph_write_behaviors(gobj, behaviors);
 }
 /************************************************************
-*  Count hooks and fkeys in topic desc, classify node type
+*  Count hooks and fkeys in topic desc, classify node type:
+*  `child` (no hooks), `extended` (hooks, no fkeys), `entity`
+*  (both). It sizes the card and nothing else. It used to be
+*  called `hierarchical`, and that word means something else now:
+*  a topic hooked to ITSELF, the only kind a tree can hang from
+*  (treedb_fold_model).
 ************************************************************/
 function calculate_hooks_fkeys_counter(desc) {
 	let cols = desc.cols;
@@ -56175,7 +56253,7 @@ function calculate_hooks_fkeys_counter(desc) {
 	}
 	if (desc.hooks_counter === 0) desc.node_treedb_type = "child";
 	else if (desc.fkeys_counter === 0) desc.node_treedb_type = "extended";
-	else desc.node_treedb_type = "hierarchical";
+	else desc.node_treedb_type = "entity";
 }
 /************************************************************
 *  Build ports for a topic desc
@@ -56548,7 +56626,7 @@ function dress_ports(gobj, style, ports, geometry, topic_defaults, r_default, fi
 ************************************************************/
 function pill_shape_of(gobj, desc, record, geometry) {
 	let priv = gobj.priv;
-	let size = PILL_SIZE[desc.node_treedb_type] || PILL_SIZE.hierarchical;
+	let size = PILL_SIZE[desc.node_treedb_type] || PILL_SIZE.entity;
 	let ports = build_ports(gobj, desc);
 	let paint = node_paint_of(gobj, desc, geometry);
 	let style = {
@@ -56597,7 +56675,7 @@ function figure_shape_of(gobj, desc, record, geometry, flags) {
 	let dark = priv.theme === "dark";
 	let f = flags || {};
 	let tier = desc.node_treedb_type;
-	let side = SHAPE_SIZE[tier] || SHAPE_SIZE.hierarchical;
+	let side = SHAPE_SIZE[tier] || SHAPE_SIZE.entity;
 	let labels = gobj_read_bool_attr(gobj, "node_labels");
 	let figure = node_figure_of(gobj, desc, geometry || {});
 	let paint = node_paint_of(gobj, desc, geometry);
@@ -59663,7 +59741,7 @@ function show_node_detail_popover(gobj, node_id) {
 	clamp_popover_position(gobj, popover);
 }
 /************************************************************
-*  Re-render every HTML (hierarchical) node so its card adopts
+*  Re-render every HTML (entity) node so its card adopts
 *  the given theme: entity cards and leaf chips (baked innerHTML,
 *  not re-themed by setTheme()) are regenerated; structural
 *  junction diamonds get their neutral fill/stroke re-themed.
@@ -59782,7 +59860,7 @@ function refresh_minimap(gobj) {
 }
 /************************************************************
 *  The innerHTML of ONE node, in the given theme and highlight state.
-*  The three treedb tiers (hierarchical / extended / child) each have
+*  The three treedb tiers (entity / extended / child) each have
 *  their own card, and both the theme refresh and the highlight need the
 *  same three-way choice — it lived inline in the theme refresh and is
 *  shared now. Returns null for a node that carries no desc.
@@ -59799,7 +59877,7 @@ function node_innerHTML_of(nd, theme, highlight, selected, anchored, pills_html)
 	switch (desc.node_treedb_type) {
 		case "child": return build_chip_innerHTML(fill, theme, record.icon, label, record.id, highlight, selected, anchored);
 		case "extended": return build_node_innerHTML(fill, theme, record.icon, label, desc.topic_name, true, record.id, highlight, selected, anchored, pills_html);
-		case "hierarchical": return build_node_innerHTML(fill, theme, record.icon, label, desc.topic_name, false, record.id, highlight, selected, anchored, pills_html);
+		case "entity": return build_node_innerHTML(fill, theme, record.icon, label, desc.topic_name, false, record.id, highlight, selected, anchored, pills_html);
 	}
 	return null;
 }
@@ -59996,7 +60074,7 @@ function build_chip_innerHTML(color, theme, icon, label, key, highlight, selecte
 `;
 }
 /************************************************************
-*  Build innerHTML for hierarchical (HTML) nodes.
+*  Build innerHTML for entity (HTML) nodes.
 *
 *  Card style modelled on the documentation schema graphs
 *  (docs gen_treedb_graphs.py): rounded card, soft tint of the
@@ -61314,13 +61392,19 @@ function publish_legend_state(gobj, visible) {
 			loose: loose.length,
 			loose_shown: model.loose_shown.has(topic_name),
 			hidden: model.hidden.has(topic_name),
-			linked: model.linked.has(topic_name)
+			linked: model.linked.has(topic_name),
+			hierarchical: fold_is_hierarchical(priv.descs, topic_name)
 		});
 	}
 	gobj_publish_event(gobj, "EV_LEGEND_STATE", {
 		main_topic: model.main_topic,
-		main_chosen: !!gobj_read_str_attr(gobj, "main_topic"),
-		topics
+		main_chosen: !!model.main_topic && gobj_read_str_attr(gobj, "main_topic") === model.main_topic,
+		topics,
+		fold: {
+			topic: model.main_topic,
+			level: current_fold_level(gobj),
+			levels: model.levels
+		}
 	});
 }
 async function reconcile_fold_apply(gobj, opts, visible) {
@@ -61625,7 +61709,7 @@ function ac_load_data(gobj, event, kw, src) {
 	}
 	if (all_loaded && priv.graph) {
 		rebuild_fold_model(gobj);
-		fold_expand_to_depth(priv._fold_model, priv._fold_state, gobj_read_integer_attr(gobj, "expand_depth"));
+		fold_expand_to_level(priv._fold_model, priv._fold_state, current_fold_level(gobj));
 		count_placed_records(gobj);
 		let auto_laid = false;
 		try {
@@ -62029,19 +62113,46 @@ function ac_show_more(gobj, event, kw, src) {
 	return 0;
 }
 /************************************************************
-*  The whole treedb, every hook open on all its children. This
-*  is the reader asking for the pile on purpose; the pages are
-*  the other way in.
+*  The level of the main tree the toolbar's stepper stands on:
+*  `fold_level` once the reader has stepped, `expand_depth`
+*  until then, clamped to the levels the tree has.
 ************************************************************/
-function ac_expand_all$1(gobj, event, kw, src) {
+function current_fold_level(gobj) {
 	let priv = gobj.priv;
-	if (!priv._fold_model) {
-		log_error(`${gobj_short_name(gobj)}: expand all with no tree loaded`);
+	let level = gobj_read_integer_attr(gobj, "fold_level");
+	if (!(level > 0)) level = gobj_read_integer_attr(gobj, "expand_depth");
+	if (!priv._fold_model) return level;
+	return fold_level_clamp(priv._fold_model, level);
+}
+/************************************************************
+*  The toolbar's stepper: one level more or one less of the
+*  MAIN tree (the host owns the number and persists it; this
+*  applies it). Deeper opens the hooks above the new level,
+*  shallower folds from it down -- a level is a floor, not a
+*  picture, so what the reader opened by its pill stays (see
+*  treedb_fold_model). Replaces expand all / collapse all
+*  (7.23.141): the whole treedb at once was the pile, and
+*  closing threw away everything the reader had opened.
+************************************************************/
+function ac_set_fold_level(gobj, event, kw, src) {
+	let priv = gobj.priv;
+	let level = Number(kw && kw.level);
+	if (!(level > 0)) {
+		log_error(`${gobj_short_name(gobj)}: fold level '${kw && kw.level}' is not a level`);
 		return -1;
 	}
+	if (!priv._fold_model) {
+		gobj_write_attr(gobj, "fold_level", level);
+		return 0;
+	}
+	let from = current_fold_level(gobj);
+	level = fold_level_clamp(priv._fold_model, level);
+	gobj_write_attr(gobj, "fold_level", level);
+	if (level === from) return 0;
 	let keep = fold_keep_node(gobj);
 	let vp = yui_graph_viewport_of(priv.graph, keep);
-	fold_expand_all(priv._fold_model, priv._fold_state);
+	if (level > from) fold_open_levels(priv._fold_model, priv._fold_state, level);
+	else fold_close_levels(priv._fold_model, priv._fold_state, level);
 	reconcile_fold(gobj, {
 		keep,
 		keep_vp: vp
@@ -62069,29 +62180,11 @@ function fold_keep_node(gobj) {
 	return "";
 }
 /************************************************************
-*  The roots alone.
-************************************************************/
-function ac_collapse_all$1(gobj, event, kw, src) {
-	let priv = gobj.priv;
-	if (!priv._fold_model) {
-		log_error(`${gobj_short_name(gobj)}: collapse all with no tree loaded`);
-		return -1;
-	}
-	let keep = fold_keep_node(gobj);
-	let vp = yui_graph_viewport_of(priv.graph, keep);
-	fold_collapse_all(priv._fold_model, priv._fold_state);
-	reconcile_fold(gobj, {
-		keep,
-		keep_vp: vp
-	});
-	return 0;
-}
-/************************************************************
 *  The legend's three settings, from the host, which persists
 *  them. Each rebuilds the tree; the fold state is kept -- it is
 *  keyed by group, and a group that is gone is never read -- except
 *  for a new MAIN topic, whose roots are other roots: the tree
-*  opens again at `expand_depth`.
+*  opens again at the reader's level, now counted from them.
 ************************************************************/
 function ac_set_hidden_topics(gobj, event, kw, src) {
 	let priv = gobj.priv;
@@ -62109,7 +62202,7 @@ function ac_set_main_topic(gobj, event, kw, src) {
 	let keep = fold_keep_node(gobj);
 	let vp = yui_graph_viewport_of(priv.graph, keep);
 	rebuild_fold_model(gobj);
-	fold_expand_to_depth(priv._fold_model, priv._fold_state, gobj_read_integer_attr(gobj, "expand_depth"));
+	fold_expand_to_level(priv._fold_model, priv._fold_state, current_fold_level(gobj));
 	reconcile_fold(gobj, {
 		relayout: true,
 		keep,
@@ -62670,13 +62763,8 @@ function create_gclass$4(gclass_name) {
 			null
 		],
 		[
-			"EV_EXPAND_ALL",
-			ac_expand_all$1,
-			null
-		],
-		[
-			"EV_COLLAPSE_ALL",
-			ac_collapse_all$1,
+			"EV_SET_FOLD_LEVEL",
+			ac_set_fold_level,
 			null
 		],
 		[
@@ -62819,8 +62907,7 @@ function create_gclass$4(gclass_name) {
 		["EV_CAMERA_CHANGED", event_flag_t.EVF_OUTPUT_EVENT | event_flag_t.EVF_NO_WARN_SUBS],
 		["EV_TOGGLE_FOLD", 0],
 		["EV_SHOW_MORE", 0],
-		["EV_EXPAND_ALL", 0],
-		["EV_COLLAPSE_ALL", 0],
+		["EV_SET_FOLD_LEVEL", 0],
 		["EV_SET_HIDDEN_TOPICS", 0],
 		["EV_SET_MAIN_TOPIC", 0],
 		["EV_SET_LOOSE_TOPICS", 0],
@@ -62887,7 +62974,7 @@ var attrs_table$3 = [
 	SDATA(data_type_t.DTP_POINTER, "subscriber", 0, null, "Subscriber of output events"),
 	SDATA(data_type_t.DTP_LIST, "operation_modes", 0, "[\"reading\", \"operation\", \"writing\", \"edition\"]", "Available **permission** or behaviour modes. These operation modes are required to be accomplish by the graph handler (G6 child). TODO permissions must match treedb permissions."),
 	SDATA(data_type_t.DTP_BOOLEAN, "with_treedb_tables", 0, false, "Include treedb tables"),
-	SDATA(data_type_t.DTP_INTEGER, "expand_depth", 0, 2, "Levels of the treedb open when it loads: 1 = the roots alone, 2 = the roots and their children. Forwarded to the G6 child"),
+	SDATA(data_type_t.DTP_INTEGER, "expand_depth", 0, 1, "Levels of the treedb open when it loads, until the reader steps (`fold_level`): 1 = the roots alone (the default), 2 = the roots and their children. Forwarded to the G6 child"),
 	SDATA(data_type_t.DTP_INTEGER, "fold_page_size", 0, 24, "Children of one hook shown per page in the graph; a `+N` chip opens the next page. Forwarded to the G6 child"),
 	SDATA(data_type_t.DTP_INTEGER, "minimap_min_nodes", 0, 30, "Show the minimap from this many nodes on (0 = never). Forwarded to the G6 child"),
 	SDATA(data_type_t.DTP_BOOLEAN, "with_gridline", 0, true, "Draw the grid under the graph. Forwarded to the G6 child"),
@@ -62904,6 +62991,7 @@ var attrs_table$3 = [
 	SDATA(data_type_t.DTP_STRING, "node_mode", sdata_flag_t.SDF_PERSIST, "expanded", "How the records are drawn: `expanded` = the cards with their pills and ports, `compact` = one-line pills with the name, `shape` = coloured figures, the topology alone. User preference"),
 	SDATA(data_type_t.DTP_BOOLEAN, "node_labels", sdata_flag_t.SDF_PERSIST, true, "A `shape` node says its name under its figure. User preference"),
 	SDATA(data_type_t.DTP_DICT, "camera", sdata_flag_t.SDF_PERSIST, "{}", "Where the reader left the viewport: {zoom, x, y}. Handed to the engine on creation and written back when a move settles, so the graph opens where it was left. User preference, per treedb"),
+	SDATA(data_type_t.DTP_INTEGER, "fold_level", sdata_flag_t.SDF_PERSIST, 0, "The level of the MAIN tree the toolbar's stepper stands on: 1 = the main topic's roots, N = N-1 levels under them; 0 = never stepped, `expand_depth`. Handed to the engine on creation, so the graph opens at the level it was left. User preference, per treedb"),
 	SDATA(data_type_t.DTP_POINTER, "gobj_remote_yuno", 0, null, "Remote Yuno to request data"),
 	SDATA(data_type_t.DTP_STRING, "treedb_name", 0, null, "Remote service treedb name"),
 	SDATA(data_type_t.DTP_DICT, "descs", 0, null, "Descriptions of topics obtained"),
@@ -62979,6 +63067,7 @@ function mt_create$3(gobj) {
 		hook_port_position: "bottom",
 		fkey_port_position: "top",
 		expand_depth: gobj_read_integer_attr(gobj, "expand_depth"),
+		fold_level: gobj_read_integer_attr(gobj, "fold_level"),
 		fold_page_size: gobj_read_integer_attr(gobj, "fold_page_size"),
 		minimap_min_nodes: gobj_read_integer_attr(gobj, "minimap_min_nodes"),
 		with_gridline: gobj_read_bool_attr(gobj, "with_gridline"),
@@ -63286,6 +63375,127 @@ function refresh_node_shape_buttons(gobj, $root) {
 		$labels.disabled = mode !== "shape";
 	}
 }
+/************************************************************
+*  The fold STEPPER: one level less, where the tree stands, one
+*  level more.
+*
+*  It replaces the fold pair (7.23.141). `expand all` opened every
+*  hook of the treedb -- the pile, on purpose, which on a treedb
+*  of thousands is a pile nobody reads -- and `collapse all` threw
+*  away everything the reader had opened. The stepper walks the
+*  MAIN tree a level at a time, the way the frontend view opens
+*  one level per press: `+` opens the next level under the main
+*  topic's roots, through every topic that is not hidden; `-`
+*  folds the deepest one. Pages and pills the reader opened stay.
+*
+*  The readout says what the two buttons act on, which no chevron
+*  can: the main topic -- its swatch and its name, which is DATA
+*  and never translated -- and `level/levels`. On a phone the name
+*  goes and the numbers stay. The level is the reader's, per
+*  treedb: persisted (`fold_level`) and handed to the engine on
+*  creation, so a reload opens where it was left.
+*
+*  Both buttons are born disabled: nothing can be stepped until
+*  the engine has said how deep the tree goes (EV_LEGEND_STATE).
+************************************************************/
+function fold_level_items(gobj, wide) {
+	let step_button = (cls, icon, key, event_name) => {
+		return [
+			"button",
+			{
+				class: `${cls} button`,
+				type: "button",
+				style: {
+					height: wide,
+					width: "2.5em"
+				},
+				disabled: true,
+				title: t(key),
+				"data-i18n-title": key,
+				"aria-label": t(key),
+				"data-i18n-aria-label": key
+			},
+			yui_toolbar_icon(icon),
+			{ click: (evt) => {
+				evt.stopPropagation();
+				gobj_send_event(gobj, event_name, {}, gobj);
+			} }
+		];
+	};
+	return [[
+		"div",
+		{
+			class: "GRAPH_FOLD_STEPPER buttons has-addons",
+			style: "margin:0; flex:0 0 auto; flex-wrap:nowrap; align-items:stretch;"
+		},
+		[
+			step_button("GRAPH_FOLD_COLLAPSE", "yi-chevron-right", "collapse one level", "EV_COLLAPSE_LEVEL"),
+			[
+				"div",
+				{
+					class: "GRAPH_FOLD_LEVEL button",
+					style: {
+						height: wide,
+						cursor: "default",
+						gap: ".35rem"
+					},
+					role: "status",
+					title: t("fold level"),
+					"data-i18n-title": "fold level"
+				},
+				[
+					["span", {
+						class: "GRAPH_FOLD_SWATCH",
+						style: "display:none; width:.8rem; height:.8rem; border-radius:3px; flex:0 0 auto; border:1px solid rgba(0,0,0,.25);"
+					}],
+					["span", {
+						class: "GRAPH_FOLD_TOPIC is-hidden-mobile",
+						style: "max-width:10em; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; font-weight:600;"
+					}],
+					[
+						"span",
+						{
+							class: "GRAPH_FOLD_WORD",
+							i18n: "level"
+						},
+						"level"
+					],
+					[
+						"span",
+						{
+							class: "GRAPH_FOLD_COUNT",
+							style: "font-variant-numeric:tabular-nums;"
+						},
+						"–"
+					]
+				]
+			],
+			step_button("GRAPH_FOLD_EXPAND", "yi-chevron-down", "expand one level", "EV_EXPAND_LEVEL")
+		]
+	]];
+}
+function refresh_fold_level(gobj) {
+	let priv = gobj.priv;
+	let $container = gobj_read_attr(gobj, "$container");
+	if (!$container) return;
+	let $readout = $container.querySelector(".GRAPH_FOLD_LEVEL");
+	if (!$readout) return;
+	let state = priv._legend_state || {};
+	let fold = state.fold || {};
+	let levels = fold.levels > 0 ? fold.levels : 0;
+	let level = fold.level > 0 ? fold.level : 0;
+	let topic = fold.topic || "";
+	let entry = (is_array(state.topics) ? state.topics : []).find((e) => e.topic === topic);
+	let $swatch = $readout.querySelector(".GRAPH_FOLD_SWATCH");
+	$swatch.style.display = topic ? "inline-block" : "none";
+	$swatch.style.background = entry && entry.color || "#94a3b8";
+	$readout.querySelector(".GRAPH_FOLD_TOPIC").textContent = topic;
+	$readout.querySelector(".GRAPH_FOLD_COUNT").textContent = levels ? `${level}/${levels}` : "–";
+	let $collapse = $container.querySelector(".GRAPH_FOLD_COLLAPSE");
+	let $expand = $container.querySelector(".GRAPH_FOLD_EXPAND");
+	if ($collapse) $collapse.disabled = !(levels && level > 1);
+	if ($expand) $expand.disabled = !(levels && level < levels);
+}
 function make_toolbar(gobj) {
 	let priv = gobj.priv;
 	let modes = gobj_read_attr(gobj, "operation_modes");
@@ -63352,7 +63562,7 @@ function make_toolbar(gobj) {
 			} }
 		]
 	];
-	let center_items = [...yui_graph_fold_items(gobj, gobj_read_str_attr(gobj, "wide")), ...node_shape_items(gobj, gobj_read_str_attr(gobj, "wide"))];
+	let center_items = [...fold_level_items(gobj, gobj_read_str_attr(gobj, "wide")), ...node_shape_items(gobj, gobj_read_str_attr(gobj, "wide"))];
 	let backend_items = [[
 		"button",
 		{
@@ -64415,6 +64625,7 @@ function refresh_legend(gobj) {
 	let topics = state.topics.slice().sort((a, b) => {
 		return String(a.topic).localeCompare(String(b.topic));
 	});
+	let hierarchical_count = topics.filter((e) => e.hierarchical && !e.hidden).length;
 	for (let entry of topics) {
 		let topic_name = entry.topic;
 		let is_main = topic_name === state.main_topic;
@@ -64509,7 +64720,7 @@ function refresh_legend(gobj) {
 				"★"
 			]]
 		]);
-		else if (!hidden) extras.push([
+		else if (!hidden && entry.hierarchical && hierarchical_count > 1) extras.push([
 			"button",
 			{
 				class: "GRAPH_LEGEND_STAR button",
@@ -64608,6 +64819,7 @@ function ac_legend_state(gobj, event, kw, src) {
 	let priv = gobj.priv;
 	priv._legend_state = kw || null;
 	refresh_legend(gobj);
+	refresh_fold_level(gobj);
 	return 0;
 }
 /************************************************************
@@ -64720,17 +64932,33 @@ function ac_find_nodes(gobj, event, kw, src) {
 	return 0;
 }
 /************************************************************
-*  The fold pair of the toolbar, forwarded to the G6 child,
-*  which owns the tree.
+*  One press of the fold stepper (EV_EXPAND_LEVEL /
+*  EV_COLLAPSE_LEVEL): the level moves by one, is SAVED (the
+*  reader's, per treedb) and reaches the G6 child, which owns
+*  the tree.
+*
+*  The readout moves at once, not when the engine speaks again:
+*  a reconcile is asynchronous, and a second press that came
+*  before it would step from the level already left -- two
+*  presses, one level.
 ************************************************************/
-function ac_expand_all(gobj, event, kw, src) {
-	let priv = gobj.priv;
-	if (priv.gobj_nodes_tree) gobj_send_event(priv.gobj_nodes_tree, "EV_EXPAND_ALL", {}, gobj);
-	return 0;
-}
-function ac_collapse_all(gobj, event, kw, src) {
+function ac_fold_level_step(gobj, event, kw, src) {
 	let priv = gobj.priv;
-	if (priv.gobj_nodes_tree) gobj_send_event(priv.gobj_nodes_tree, "EV_COLLAPSE_ALL", {}, gobj);
+	let fold = priv._legend_state && priv._legend_state.fold;
+	if (!fold || !(fold.levels > 0)) {
+		log_error(`${gobj_short_name(gobj)}: ${event} with no tree to step through`);
+		return -1;
+	}
+	let level = fold.level + (event === "EV_EXPAND_LEVEL" ? 1 : -1);
+	if (level < 1 || level > fold.levels) {
+		log_error(`${gobj_short_name(gobj)}: ${event}: level ${level} out of 1..${fold.levels}`);
+		return -1;
+	}
+	gobj_write_attr(gobj, "fold_level", level);
+	gobj_save_persistent_attrs(gobj, "fold_level");
+	fold.level = level;
+	refresh_fold_level(gobj);
+	if (priv.gobj_nodes_tree) gobj_send_event(priv.gobj_nodes_tree, "EV_SET_FOLD_LEVEL", { level }, gobj);
 	return 0;
 }
 /************************************************************
@@ -64967,13 +65195,13 @@ function create_gclass$3(gclass_name) {
 			null
 		],
 		[
-			"EV_EXPAND_ALL",
-			ac_expand_all,
+			"EV_EXPAND_LEVEL",
+			ac_fold_level_step,
 			null
 		],
 		[
-			"EV_COLLAPSE_ALL",
-			ac_collapse_all,
+			"EV_COLLAPSE_LEVEL",
+			ac_fold_level_step,
 			null
 		],
 		[
@@ -65058,8 +65286,8 @@ function create_gclass$3(gclass_name) {
 		["EV_SET_OPERATION_MODE", 0],
 		["EV_SET_FOCUS_TOPIC", 0],
 		["EV_FIND_NODES", 0],
-		["EV_EXPAND_ALL", 0],
-		["EV_COLLAPSE_ALL", 0],
+		["EV_EXPAND_LEVEL", 0],
+		["EV_COLLAPSE_LEVEL", 0],
 		["EV_SET_NODE_MODE", 0],
 		["EV_TOGGLE_NODE_LABELS", 0],
 		["EV_FIND_RESULT", 0],
@@ -65841,7 +66069,7 @@ function sort_by_order(list) {
 *              schema_version, c_schema_version, system_schema_version,
 *              topics: [{
 *                  id, name, order, record,
-*                  pkey, topic_version, system_topic,
+*                  pkey, topic_version, system_topic, main_topic,
 *                  cols: [{id, name, order, record}]
 *              }]
 *          }],
@@ -65890,6 +66118,7 @@ function build_schema_model(records) {
 			tkey: record.tkey || "",
 			topic_version: record.topic_version,
 			system_topic: !!record.system_topic,
+			main_topic: !!record.main_topic,
 			cols: []
 		};
 		by_topic_id[entry.id] = entry;
@@ -66186,6 +66415,12 @@ function validate_schema(treedb, options) {
 			if (is_fkey && FKEY_TYPES.indexOf(type) < 0) add("error", "fkey has a bad type", topic.name, col.name, type);
 		}
 	}
+	let marked = treedb.topics.filter((topic) => topic.main_topic);
+	if (marked.length > 1) add("error", "more than one main topic", marked[1].name, "", marked.map((topic) => topic.name).join(", "));
+	for (let topic of marked) if (!topic.cols.some((col) => {
+		let hook = col_hook(col.record);
+		return col_flags(col.record).indexOf("hook") >= 0 && !!hook && Object.prototype.hasOwnProperty.call(hook, topic.name);
+	})) add("error", "main topic not hooked to itself", topic.name, "", "");
 	let hooked = {};
 	for (let topic of treedb.topics) for (let col of topic.cols) {
 		let hook = col_hook(col.record);
@@ -66377,7 +66612,8 @@ var TOPIC_KEY_ORDER = [
 	"system_flag",
 	"tkey",
 	"topic_version",
-	"system_topic"
+	"system_topic",
+	"main_topic"
 ];
 var COL_KEY_ORDER = [
 	"header",
@@ -66635,7 +66871,8 @@ var TOPIC_FIELDS = [
 	"system_flag",
 	"tkey",
 	"topic_version",
-	"system_topic"
+	"system_topic",
+	"main_topic"
 ];
 var COL_FIELDS = [
 	"header",
@@ -68252,6 +68489,20 @@ function render_topics(gobj, $body) {
 							{},
 							""
 						],
+						topic.main_topic ? [
+							"span",
+							{
+								class: "SCHEMA_TOPIC_MAIN ml-2",
+								style: "color:#d4a017;",
+								title: t("main topic"),
+								"data-i18n-title": "main topic"
+							},
+							"★"
+						] : [
+							"span",
+							{},
+							""
+						],
 						ambiguous ? [
 							"div",
 							{ class: "SCHEMA_TOPIC_ID is-size-7 yui-text-quiet" },
@@ -69246,6 +69497,26 @@ function open_topic_form(gobj, treedb, topic) {
 					]]
 				]]
 			],
+			[
+				"div",
+				{ class: "SCHEMA_TOPIC_FORM_MAIN field mb-3" },
+				[[
+					"label",
+					{ class: "checkbox" },
+					[["input", el_attrs({
+						type: "checkbox",
+						"data-name": "main_topic",
+						checked: record.main_topic ? "checked" : void 0
+					})], [
+						"span",
+						{
+							class: "ml-1",
+							i18n: "main topic"
+						},
+						t("main topic")
+					]]
+				]]
+			],
 			[
 				"div",
 				{
@@ -70038,6 +70309,7 @@ function topic_record(gobj, treedb, topic, values) {
 	record.tkey = values.tkey || "";
 	record.topic_version = values.topic_version === "" ? 1 : Number(values.topic_version);
 	record.system_topic = !!values.system_topic;
+	record.main_topic = !!values.main_topic;
 	return record;
 }
 /***************************