@ai-ecoverse/slicc-spectrum 1.111.3 → 1.111.4

package/README.md

@@ -681,7 +681,7 @@ const name = await prompt({ title: 'New cone', label: 'Name', action: 'Create',
 It takes a sudo request's command (without `sudo` and its options) and working folder, and returns `{ certain, maybe, once }`:
 
 - `certain` is an absolute path when the command names a file or folder holding SLICC's secret rules (`/etc/fnox`, `/etc/fnox/config.toml`, `/etc/slicc/secrets-policy.toml`), a folder above them it changes as a whole (`/`, `/etc`, `/etc/slicc`), a glob or brace that matches one, or a file named like them (`fnox`, `secrets-policy`) anywhere, as `/tmp/fnox/config.toml`.
-  It sees through quotes, backslashes, `$'…'` and `$"…"`, `cd` and `pushd` (also inside `bash -c`), relative paths and `..`, extglobs, `/proc/self/root` and `/proc/self/cwd`, option clusters like `-t/etc/fnox`, and comma lists.
+  It sees through quotes, backslashes, `$'…'` and `$"…"`, `cd` and `pushd` where a command starts (also inside `bash -c`, `bash -lc` or `su -c`, and after `if`, `then`, `do`, `{`, `!`, `function NAME` and the like, but not after a `-c` of another program, such as `chown -c cd /etc`), relative paths and `..`, extglobs, `/proc/self/root` and `/proc/self/cwd`, option clusters like `-t/etc/fnox`, and comma lists.
   When every command in it is read-only and nothing in it expands, quoted text is data: a jq or yq program such as `'.a // .b | {x: .y}'` isn't split into paths, and `*`, `?`, `[` and `{` in quotes (and `$` in single quotes) are literal, as the shell treats them. Other commands, such as `sh -c '…'`, are still looked into.
 - `maybe` is the token when the command may reach one of them and the check can't tell where it leads: an expansion (`$X`, `$(…)`, backticks), a `~user/..`, `~+` or `~-` path, a `/proc/<pid>/cwd` or `/dev/fd` path, or a command over 4096 characters (its first 40 followed by `…`).
   It's also set, only when nothing above applies (a separate check that never clears or changes those verdicts), when an explicit write names its target from data the check can't see: `yq -s`, `--split-exp` or `--split-exp-file` (`yq -s`), or `xargs` running a command that can write or run others, such as `xargs rm < list` (`xargs rm`). `xargs` running a read-only command (`xargs cat < list`, `xargs grep x -- < list`, `xargs --replace=X cat X < list`, and `xargs sort`, `xargs find`, `xargs uniq -c` or `xargs yq .` with no write flag in the command; with `--replace` or `--eof` split from its value, both readings must be read-only) is a plain read and stays clean.
@@ -970,7 +970,7 @@ Later backed by: BIOS.
 `list()` returns waiting `Approval`s; emit `approvals` when the list changes.
 A `sudo` approval has `id`, `requester` (`kind` `agent` or `user`, `name`, optional `agentId` and `where`, such as a terminal's title), `command` (without `sudo`; bios joins the kernel's argv shell-quoted), optional `target` (the user to run as; shown as `sudo -u {target}` unless `root`), optional `cwd` and `verdict` (`{ decision: 'allow' | 'deny' | 'unsure', reason }`, the automatic check’s view), `createdAt`, `expiresAt` (epoch ms) and `always` (offer Always allow, which covers the requester's user and this exact command).
 With `decide(id, 'once' | 'always' | 'deny')`, which resolves once the decision is recorded and then drops the request from `list()`, the tab shows a warning alert dialog (`dialog[data-approval][data-kind][data-requester]`): "Allow sudo?", "{name} wants to run this with sudo[ in {where}]:" for an agent or "You ran this with sudo[ in {where}] (as {name}):" for a user, the command, "In {cwd}", a notice when the command changes secret rules, what Always allow does, "Denied automatically in m:ss." and how many more wait, with **Deny** (`data-action="deny"`, focused; Escape also denies), **Always allow** (`always`) and **Allow once** (`once`).
-A command that names `/etc/fnox` (or anything in it) or `/etc/slicc/secrets-policy.toml`, resolved against `cwd`, globs included (with quotes and backslashes removed, operands after `--` included; a path with `[`, `{` or `$` counts when the part before it could lead to them), or that names `/`, `/etc` or `/etc/slicc` in a command other than a read-only one (such as `ls`, `cat`, `stat`, `grep`, `jq`, `cut`, `od`, `sha256sum` or `md5sum`, and coreutils' pure output programs, which take no output file and run nothing: `basename`, `dirname`, `printf`, `seq`, `tr`, `fold`, `paste`, `comm`, `join`, `expand`, `unexpand`, `fmt`, `numfmt`, `pr`, `expr`, `factor`, `sum`, `tsort`, `pathchk`, `base32`, `basenc`, `true`, `false`, `id`, `groups`, `whoami`, `logname`, `printenv`, `uname` and `nproc`, so `ls | xargs -n1 basename` is a read; `find` without `-exec`, `-execdir`, `-ok`, `-okdir`, `-delete` or `-fprint`/`-fls`; `sort` without `-o`, `-T` or `--compress-program`; `yq` without `-i`, `-s` or `--split-exp-file`; `base64` without `-o`; `tree` without `-o` or `-R`; `file` without `-C`; `uniq` and `xxd` with one operand at most, counting everything after `--`; a flag counts inside a short cluster, with a value attached (`-o/x`, `-i.bak`), as `--name=value` and abbreviated (the data-write check below reads clusters more exactly: there a cluster ends at `=` or at an option that takes a value, so `yq -o=json` isn't `yq -s`, and an option's value isn't a `uniq` or `xxd` operand); `less` and other pagers aren't, since they run commands), or runs with `cwd` in `/etc/fnox`, or names a relative path with `fnox` or `secrets-policy` in it wherever `cd` may have led, gets "This changes secret rules." with the path (`[data-secret-rules]`, the path in the attribute).
+A command that names `/etc/fnox` (or anything in it) or `/etc/slicc/secrets-policy.toml`, resolved against `cwd`, globs included (with quotes and backslashes removed, operands after `--` included; a path with `[`, `{` or `$` counts when the part before it could lead to them), or that names `/`, `/etc` or `/etc/slicc` in a command other than a read-only one (such as `ls`, `cat`, `stat`, `grep`, `jq`, `cut`, `od`, `sha256sum` or `md5sum`, and coreutils' pure output programs, which take no output file and run nothing: `basename`, `dirname`, `printf`, `seq`, `tr`, `fold`, `paste`, `comm`, `join`, `expand`, `unexpand`, `fmt`, `numfmt`, `pr`, `expr`, `factor`, `sum`, `tsort`, `pathchk`, `base32`, `basenc`, `true`, `false`, `id`, `groups`, `whoami`, `logname`, `printenv`, `uname` and `nproc`, so `ls | xargs -n1 basename` is a read; `find` without `-exec`, `-execdir`, `-ok`, `-okdir`, `-delete` or `-fprint`/`-fls`; `sort` without `-o`, `-T` or `--compress-program`; `yq` without `-i`, `-s` or `--split-exp-file`; `base64` without `-o`; `tree` without `-o` or `-R`; `file` without `-C`; `uniq` and `xxd` with one operand at most, counting everything after `--`; a flag counts inside a short cluster, with a value attached (`-o/x`, `-i.bak`), as `--name=value` and abbreviated, but for getopt-style programs (`sort`, `uniq`, `base64`, `file`, `yq`) a cluster ends at `=` or at an option that takes a value, so `sort -to /etc` and `yq -o=json` don't count as writes; `tree` takes each option's value from the next word and reads on in the cluster, so any `o` or `R` in a `tree` cluster counts (`tree -Ho /tmp/x /etc` writes); `xxd` is read with its own rules (one option per word, values attached or in the next word, options end at the first operand), and an option's value isn't a `uniq` or `xxd` operand (`uniq -f 1 /etc`, `xxd -l 16 /etc`); `xargs` counts as read-only when every command it may run is read-only and has no gated write flags (`find /etc … | xargs grep x`, but not `xargs sort`, whose input could add `-o`); `less` and other pagers aren't, since they run commands), or runs with `cwd` in `/etc/fnox`, or names a relative path with `fnox` or `secrets-policy` in it wherever `cd` may have led, gets "This changes secret rules." with the path (`[data-secret-rules]`, the path in the attribute).
 Read-only commands count only by bare name or from `/bin` and `/usr/bin`.
 In a command made only of read-only commands and with no live expansion, the quoted words count whole: `jq '.a // .b' f` doesn't name `/`, and `jq '{a: .b}' f` in `/etc` isn't a brace that could lead to the rules.
 `/proc/<pid>/root` counts as `/` and `/proc/self/cwd` as `cwd`.

package/dist/slicc-ui.js

@@ -10334,8 +10334,8 @@ var ranges = [
   [100, "bg", 8]
 ];
 function simple(code3) {
-  const flag2 = flags[code3];
-  if (flag2) return flag2;
+  const flag = flags[code3];
+  if (flag) return flag;
   const range2 = ranges.find(([start2]) => code3 >= start2 && code3 < start2 + 8);
   return range2 ? { [range2[1]]: code3 - range2[0] + range2[2] } : null;
 }
@@ -40283,12 +40283,12 @@ var SliccMonitor = class extends ModelElement {
     </li>`;
   }
   #section(section) {
-    const flag2 = attention2(section);
+    const flag = attention2(section);
     const surface2 = surfaces[section.id];
     const rows2 = section.rows.length > 0;
-    const open = rows2 && (this.expanded[section.id] ?? flag2 !== null);
+    const open = rows2 && (this.expanded[section.id] ?? flag !== null);
     const list6 = `rows-${section.id}`;
-    const badge = flag2 ? b`<swc-badge size="s" variant=${flag2.variant} subtle>${flag2.text}</swc-badge>` : A;
+    const badge = flag ? b`<swc-badge size="s" variant=${flag.variant} subtle>${flag.text}</swc-badge>` : A;
     return b`<li class="section" data-id=${section.id} data-open=${open ? "" : A}>
       <div class="line">
         <span class="caption">${rows2 ? b`<button class="toggle" aria-expanded=${open ? "true" : "false"} aria-controls=${open ? list6 : A} @click=${() => {
@@ -44099,14 +44099,14 @@ var directions2 = /* @__PURE__ */ new Set(["left", "right", "above", "below", "w
 function scan(parsed, rest, positional) {
   for (let index2 = 0; index2 < rest.length; index2++) {
     const arg = rest[index2];
-    const flag2 = arg.startsWith("--") ? arg.slice(2) : null;
-    if (flag2 === "json") parsed.json = true;
-    else if (flag2 === "section" || flag2 !== null && directions2.has(flag2)) {
+    const flag = arg.startsWith("--") ? arg.slice(2) : null;
+    if (flag === "json") parsed.json = true;
+    else if (flag === "section" || flag !== null && directions2.has(flag)) {
       const value = rest[++index2];
-      if (value === void 0) return `--${flag2} needs a value`;
-      if (flag2 === "section") parsed.section = value;
+      if (value === void 0) return `--${flag} needs a value`;
+      if (flag === "section") parsed.section = value;
       else if (parsed.place) return "give one place";
-      else parsed.place = { direction: flag2, ref: value };
+      else parsed.place = { direction: flag, ref: value };
     } else if (arg.startsWith("-")) return `unknown option ${arg}`;
     else positional.push(arg);
   }
@@ -48570,7 +48570,7 @@ var SliccUpdates = class extends ModelElement {
     const shown4 = developer ? item2 : { ...item2, npm: null };
     const meta = npmMeta(shown4);
     const note = npmNote(shown4);
-    const ahead = shown4.npm?.state === "offered" ? shown4.npm.latest ?? null : null;
+    const ahead2 = shown4.npm?.state === "offered" ? shown4.npm.latest ?? null : null;
     return b`<swc-divider size="s"></swc-divider>
     <article data-id=${item2.id} data-state=${item2.state} data-npm=${item2.npm?.state ?? A} aria-label=${item2.label}>
       <div class="head">
@@ -48591,7 +48591,7 @@ var SliccUpdates = class extends ModelElement {
               <span>${error}</span>
             </div>` : A}
       ${this.#actions(item2)}
-      ${this.#whatsNew(`releases:item:${item2.id}`, item2.label, whatsNew(item2.releases, item2.from, ahead ?? item2.to), 3)}
+      ${this.#whatsNew(`releases:item:${item2.id}`, item2.label, whatsNew(item2.releases, item2.from, ahead2 ?? item2.to), 3)}
       ${item2.log ? b`<details ?open=${this.#logs.has(`item:${item2.id}`)} @toggle=${this.#logs.details(`item:${item2.id}`)}><summary>${chevron}Install log</summary><pre>${item2.log}</pre></details>` : A}
     </article>`;
   }
@@ -49843,26 +49843,6 @@ var readOnly = [
   "xxd",
   "yq"
 ];
-var flag = (short2, long) => (args2) => args2.some((arg) => {
-  if (!arg.startsWith("--")) return /^-[^-]/.test(arg) && [...short2].some((c29) => arg.includes(c29));
-  const [name] = arg.slice(2).split("=");
-  return !!name && long.some((option2) => option2.startsWith(name));
-});
-var operands = (args2) => {
-  const end = args2.includes("--") ? args2.indexOf("--") : args2.length;
-  const named2 = args2.slice(0, end).filter((arg) => arg === "-" || !arg.startsWith("-"));
-  return named2.length + args2.slice(end + 1).length > 1;
-};
-var writes = {
-  base64: flag("o", ["output"]),
-  file: flag("C", ["compile"]),
-  find: (args2) => args2.some((arg) => /^-(?:delete|exec|execdir|ok|okdir|fls|fprint0?|fprintf)$/.test(arg)),
-  sort: flag("oT", ["output", "temporary-directory", "compress-program"]),
-  tree: flag("oR", []),
-  uniq: operands,
-  xxd: operands,
-  yq: flag("is", ["inplace", "in-place", "split-exp", "split-exp-file"])
-};
 function candidates(word2) {
   if (word2 === "--") return [];
   if (word2.startsWith("--"))
@@ -49886,10 +49866,6 @@ function protects(path2, whole) {
   return rulePaths.some((rule) => glob.test(rule)) || top !== path2 && pattern(top).test("/etc/fnox") || whole && ruleParents.some((parent) => glob.test(parent));
 }
 var command2 = (word2) => word2.split("/").pop() ?? "";
-var trusted2 = ([word2, ...args2]) => {
-  const name = word2.replace(/^\/(?:usr\/)?bin\/(?=[^/]+$)/, "");
-  return readOnly.includes(name) && !writes[name]?.(args2);
-};
 function letter(arg, short2, takes) {
   for (const char of arg.slice(1)) {
     if (short2.includes(char)) return true;
@@ -49904,17 +49880,47 @@ var option = (short2, long, takes = "") => (args2) => args2.find((arg) => {
 });
 var outputs = (valued2) => (args2) => {
   const end = args2.includes("--") ? args2.indexOf("--") : args2.length;
-  const named2 = args2.slice(0, end).filter((arg, index2) => (arg === "-" || !arg.startsWith("-")) && !valued2.test(args2[index2 - 1]));
+  const named2 = args2.slice(0, end).filter(
+    (arg, index2) => (arg === "-" || !arg.startsWith("-")) && !valued2(args2[index2 - 1] ?? "")
+  );
   return named2.length + args2.slice(end + 1).length > 1;
 };
+var uniqValue = (arg) => arg.startsWith("--") ? /^--(?:s|sk|ski|skip|skip-|skip-[fc][\w-]*|c|ch[\w-]*)$/.test(arg) : /^-[^-]/.test(arg) && arg.slice(1).search(/[fsw]/) === arg.length - 2;
+var xxdValue = {
+  c: "ols",
+  g: "roup",
+  l: "en",
+  n: "ame",
+  o: "ffset"
+};
+function valuedXxd(letter2, rest) {
+  if (letter2 === "c" && rest.startsWith("apitalize")) return false;
+  if (letter2 === "R") return !rest;
+  if (letter2 === "s") return !rest || rest.startsWith("kip") || rest.startsWith("eek");
+  return Object.hasOwn(xxdValue, letter2) && (!rest || rest.startsWith(xxdValue[letter2]));
+}
+function xxd(args2) {
+  let index2 = 0;
+  for (; index2 < args2.length; index2++) {
+    const arg = args2[index2];
+    if (arg === "--") {
+      index2++;
+      break;
+    }
+    if (!/^-./.test(arg)) break;
+    const pp = arg.startsWith("--") && arg.length > 2 ? arg.slice(1) : arg;
+    if (valuedXxd(pp[1], pp.slice(2))) index2++;
+  }
+  return args2.length - index2 > 1;
+}
 var gates = {
-  base64: option("o", ["output"], "bwi"),
+  base64: option("o", ["output"], "w"),
   file: option("C", ["compile"], "efFmP"),
-  find: writes.find,
+  find: (args2) => args2.some((arg) => /^-(?:delete|exec|execdir|ok|okdir|fls|fprint0?|fprintf)$/.test(arg)),
   sort: option("oT", ["output", "temporary-directory", "compress-program"], "kSt"),
-  tree: option("oR", [], "HILPT"),
-  uniq: outputs(/^(?:-[^-]*[fsw]|--(?:s|sk|ski|skip|skip-|skip-[fc]\w*|c|ch\w*))$/),
-  xxd: outputs(/^-(?:[cglnosR]|cols|groupsize|len|name|offset|seek)$/),
+  tree: option("oR", []),
+  uniq: outputs(uniqValue),
+  xxd,
   yq: option("is", ["inplace", "in-place", "split-exp", "split-exp-file"], "fIop")
 };
 var plainly = (word2) => word2.replace(/^\/(?:usr\/)?bin\/(?=[^/]+$)/, "");
@@ -49971,6 +49977,7 @@ var safe = ([word2, ...args2]) => {
   const name = plainly(word2);
   return readOnly.includes(name) && !gates[name]?.(args2);
 };
+var trusted2 = ([word2, ...args2]) => plainly(word2) === "xargs" ? launched(args2).every((run) => runs(run) && !Object.hasOwn(gates, plainly(run[0] ?? "echo"))) : safe([word2, ...args2]);
 var unseen2 = {
   xargs: (args2) => {
     const run = launched(args2).find((words2) => !runs(words2));
@@ -49992,10 +49999,18 @@ var wrappers = {
   timeout: ["ks", ["kill-after", "signal"], 1]
 };
 var assignment = /^[A-Za-z_]\w*(?:\[[^\]]*\])?\+?=/;
-var shells = ["sh", "bash", "dash", "zsh", "ksh", "fish"];
+var shells = ["sh", "bash", "dash", "zsh", "ksh", "fish", "su", "runuser"];
+var firsts = /* @__PURE__ */ new WeakMap();
 function shell(words2, index2) {
-  const flag2 = words2[index2 - 1] === "--" ? index2 - 2 : index2 - 1;
-  return /^-[A-Za-z]*c[A-Za-z]*$/.test(words2[flag2] ?? "") && words2.slice(0, flag2).some((word2) => shells.includes(command2(word2)));
+  const flag = words2[index2 - 1] === "--" ? index2 - 2 : index2 - 1;
+  if (!/^-[A-Za-z]*c[A-Za-z]*$/.test(words2[flag] ?? "")) return false;
+  if (!firsts.has(words2))
+    firsts.set(
+      words2,
+      words2.findIndex((word2) => shells.includes(command2(word2)))
+    );
+  const first2 = firsts.get(words2);
+  return first2 >= 0 && first2 < flag;
 }
 var escaped = /[\\$\ue124]/;
 function split(arg, next) {
@@ -50006,12 +50021,12 @@ function split(arg, next) {
   return value.length ? value.join("=") : next;
 }
 function options2(at, start2, name) {
-  if (at.seen.has(`${name} ${start2}`)) return;
-  at.seen.add(`${name} ${start2}`);
   const { words: words2 } = at;
   const [takes, long, positional] = wrappers[name];
   let index2 = start2;
   for (; words2[index2]?.startsWith("-") && (words2[index2] !== "-" || name === "env"); index2++) {
+    if (at.seen.has(`${name} ${index2}`)) return;
+    at.seen.add(`${name} ${index2}`);
     const arg = words2[index2];
     if (arg === "--") {
       index2++;
@@ -50206,11 +50221,38 @@ function tokens(segment2) {
 function commas(words2) {
   return words2.flatMap((word2) => word2.includes(",") ? [word2, ...word2.split(",")] : [word2]).filter(Boolean);
 }
+function ahead(words2, test) {
+  const next = Array(words2.length + 1).fill(words2.length);
+  for (let index2 = words2.length - 1; index2 >= 0; index2--)
+    next[index2] = test(words2[index2]) ? next[index2 + 1] : index2;
+  return next;
+}
+function positions2(words2) {
+  const skip = ahead(
+    words2,
+    (word2) => assignment.test(word2) || Object.hasOwn(wrappers, command2(word2)) || /^-|^\d+$/.test(word2)
+  );
+  const dashes = ahead(words2, (word2) => word2.startsWith("-"));
+  const at = [];
+  let [runner, options3] = [-1, -1];
+  for (const index2 of words2.keys()) {
+    const flag = words2[index2 - 1] === "--" ? index2 - 2 : index2 - 1;
+    const start2 = index2 === 0 || words2[index2] !== "--" && (words2[index2 - 1] === "-c" && shell(words2, index2) || flag > runner && runner >= 0 && index2 <= options3 && /^-[A-Za-z]*c[A-Za-z]*$/.test(words2[flag])) || at[index2 - 1] && keyword.test(words2[index2 - 1]) || at[index2 - 2] === true && words2[index2 - 2] === "function";
+    at.push(start2);
+    if (start2) {
+      runner = skip[index2];
+      options3 = dashes[runner + 1] ?? -1;
+      if (!shells.includes(command2(words2[runner] ?? ""))) runner = -1;
+    }
+  }
+  return at;
+}
 function scan2(words2, cwds, whole) {
   let cd = false;
+  const at = positions2(words2);
   for (const [index2, word2] of words2.entries()) {
     let hit = null;
-    if (index2 === 0 || words2[index2 - 1] === "-c") {
+    if (at[index2]) {
       cd = ["cd", "pushd"].includes(command2(word2));
       hit = touched2(cwds, word2, whole);
     } else if (!cd) hit = touched2(cwds, word2, whole);
@@ -64694,9 +64736,9 @@ var TabReorderController = class extends CompositeDisposable {
     else this._animState.currentInsertionIndex = null;
   }
   snapshotTabPositions() {
-    const positions2 = /* @__PURE__ */ new Map();
-    for (const tab of this._tabs) positions2.set(tab.value.panel.id, tab.value.element.getBoundingClientRect());
-    return positions2;
+    const positions3 = /* @__PURE__ */ new Map();
+    for (const tab of this._tabs) positions3.set(tab.value.panel.id, tab.value.element.getBoundingClientRect());
+    return positions3;
   }
   /** Main-axis extent of a rect for this header's orientation. */
   _mainAxisSize(rect) {
@@ -75810,13 +75852,13 @@ function ensureChildIdByNameId(nodes, index2) {
 }
 function ensureChildPositions(index2) {
   if (index2.childPositionById != null) return index2.childPositionById;
-  const positions2 = /* @__PURE__ */ new Map();
+  const positions3 = /* @__PURE__ */ new Map();
   for (let i26 = 0; i26 < index2.childIds.length; i26++) {
     const childId = index2.childIds[i26];
-    if (childId != null) positions2.set(childId, i26);
+    if (childId != null) positions3.set(childId, i26);
   }
-  index2.childPositionById = positions2;
-  return positions2;
+  index2.childPositionById = positions3;
+  return positions3;
 }
 function appendChildReference(index2, childId) {
   if (index2.childPositionById != null) index2.childPositionById.set(childId, index2.childIds.length);
@@ -75955,11 +75997,11 @@ function isDirectoryNode(node2) {
 function getNodeFlags(node2) {
   return node2.depthAndFlags & PATH_STORE_NODE_FLAGS_MASK;
 }
-function hasNodeFlag(node2, flag2) {
-  return (getNodeFlags(node2) & flag2) !== 0;
+function hasNodeFlag(node2, flag) {
+  return (getNodeFlags(node2) & flag) !== 0;
 }
-function addNodeFlag(node2, flag2) {
-  node2.depthAndFlags |= flag2;
+function addNodeFlag(node2, flag) {
+  node2.depthAndFlags |= flag;
 }
 function setNodeDepth(node2, depth) {
   node2.depthAndFlags = createNodeDepthAndFlags(depth, getNodeFlags(node2), getNodeKind(node2));
@@ -77468,10 +77510,10 @@ function insertChildReference(state2, parentId, childId) {
 }
 function removeChildReference(state2, parentId, childId, childNameId) {
   const parentIndex = getDirectoryIndex(state2, parentId);
-  const positions2 = ensureChildPositions(parentIndex);
-  const childIndex = positions2.get(childId) ?? -1;
+  const positions3 = ensureChildPositions(parentIndex);
+  const childIndex = positions3.get(childId) ?? -1;
   ensureChildIdByNameId(state2.snapshot.nodes, parentIndex).delete(childNameId);
-  positions2.delete(childId);
+  positions3.delete(childId);
   const childNode = state2.snapshot.nodes[childId];
   if (childNode != null) applyChildAggregateDelta(parentIndex, childId, -childNode.subtreeNodeCount, -childNode.visibleSubtreeCount);
   if (childIndex >= 0) {