Jauge de contexte, espace disque sur partage agrégé, panneau Fichiers

Trois défauts sans rapport entre eux, tous visibles à l'écran.

Jauge de contexte bloquée à « 0 / N (0 %) » : le comptage exact vient de
usage.prompt_tokens (include_usage), qu'un llama-server récent a cessé de
renvoyer. On note désormais si l'usage est arrivé ; sinon la fin de tour
publie l'estimation qui pilote déjà la compaction — approximative, mais
jamais absente. Et la souscription envoie la valeur courante juste après
le rattrapage : une page rechargée affichait zéro sur une discussion
pourtant pleine, faute d'événement ctx_used dans la fenêtre rejouée.

Espace disque : « il ne reste que 11,9 Go » sur un partage Unraid qui en
a des centaines. /mnt/user est servi par shfs, un FUSE qui agrège
plusieurs disques — statfs y renvoie l'espace d'un seul, et ce chiffre
REFUSAIT l'installation du modèle. Les systèmes de fichiers qui
approximent (FUSE, overlay, NFS, CIFS, Ceph, Gluster) sont reconnus par
leur magie : leur chiffre reste affiché, précédé d'un « ~ », mais ne
bloque plus rien.

Panneau Fichiers : le panneau entier défilait, emportant vers le haut
l'en-tête, le fil d'Ariane et le pied (occupation disque, bouton .zip)
dès qu'il y avait quelques fichiers. Seule la liste défile maintenant ;
le pied reste en bas et l'état vide se centre.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

frontend/node_modules/@babel/traverse/lib/path/inference/inferer-reference.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _t = require("@babel/types");
+var _util = require("./util.js");
+const {
+  BOOLEAN_NUMBER_BINARY_OPERATORS,
+  createTypeAnnotationBasedOnTypeof,
+  numberTypeAnnotation,
+  voidTypeAnnotation
+} = _t;
+function _default(node) {
+  if (!this.isReferenced()) return;
+  const binding = this.scope.getBinding(node.name);
+  if (binding) {
+    if (binding.identifier.typeAnnotation) {
+      return binding.identifier.typeAnnotation;
+    } else {
+      return getTypeAnnotationBindingConstantViolations(binding, this, node.name);
+    }
+  }
+  if (node.name === "undefined") {
+    return voidTypeAnnotation();
+  } else if (node.name === "NaN" || node.name === "Infinity") {
+    return numberTypeAnnotation();
+  } else if (node.name === "arguments") {}
+}
+function getTypeAnnotationBindingConstantViolations(binding, path, name) {
+  const types = [];
+  const functionConstantViolations = [];
+  let constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
+  const testType = getConditionalAnnotation(binding, path, name);
+  if (testType) {
+    const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
+    constantViolations = constantViolations.filter(path => !testConstantViolations.includes(path));
+    types.push(testType.typeAnnotation);
+  }
+  if (constantViolations.length) {
+    constantViolations.push(...functionConstantViolations);
+    for (const violation of constantViolations) {
+      types.push(violation.getTypeAnnotation());
+    }
+  }
+  if (!types.length) {
+    return;
+  }
+  return (0, _util.createUnionType)(types);
+}
+function getConstantViolationsBefore(binding, path, functions) {
+  const violations = binding.constantViolations.slice();
+  violations.unshift(binding.path);
+  return violations.filter(violation => {
+    violation = violation.resolve();
+    const status = violation._guessExecutionStatusRelativeTo(path);
+    if (functions && status === "unknown") functions.push(violation);
+    return status === "before";
+  });
+}
+function inferAnnotationFromBinaryExpression(name, path) {
+  const operator = path.node.operator;
+  const right = path.get("right").resolve();
+  const left = path.get("left").resolve();
+  let target;
+  if (left.isIdentifier({
+    name
+  })) {
+    target = right;
+  } else if (right.isIdentifier({
+    name
+  })) {
+    target = left;
+  }
+  if (target) {
+    if (operator === "===") {
+      return target.getTypeAnnotation();
+    }
+    if (BOOLEAN_NUMBER_BINARY_OPERATORS.includes(operator)) {
+      return numberTypeAnnotation();
+    }
+    return;
+  }
+  if (operator !== "===" && operator !== "==") return;
+  let typeofPath;
+  let typePath;
+  if (left.isUnaryExpression({
+    operator: "typeof"
+  })) {
+    typeofPath = left;
+    typePath = right;
+  } else if (right.isUnaryExpression({
+    operator: "typeof"
+  })) {
+    typeofPath = right;
+    typePath = left;
+  }
+  if (!typeofPath) return;
+  if (!typeofPath.get("argument").isIdentifier({
+    name
+  })) return;
+  typePath = typePath.resolve();
+  if (!typePath.isLiteral()) return;
+  const typeValue = typePath.node.value;
+  if (typeof typeValue !== "string") return;
+  return createTypeAnnotationBasedOnTypeof(typeValue);
+}
+function getParentConditionalPath(binding, path, name) {
+  let parentPath;
+  while (parentPath = path.parentPath) {
+    if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
+      if (path.key === "test") {
+        return;
+      }
+      return parentPath;
+    }
+    if (parentPath.isFunction()) {
+      if (name == null || parentPath.parentPath.scope.getBinding(name) !== binding) return;
+    }
+    path = parentPath;
+  }
+}
+function getConditionalAnnotation(binding, path, name) {
+  const ifStatement = getParentConditionalPath(binding, path, name);
+  if (!ifStatement) return;
+  const test = ifStatement.get("test");
+  const paths = [test];
+  const types = [];
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    if (path.isLogicalExpression()) {
+      if (path.node.operator === "&&") {
+        paths.push(path.get("left"));
+        paths.push(path.get("right"));
+      }
+    } else if (path.isBinaryExpression()) {
+      const type = inferAnnotationFromBinaryExpression(name, path);
+      if (type) types.push(type);
+    }
+  }
+  if (types.length) {
+    return {
+      typeAnnotation: (0, _util.createUnionType)(types),
+      ifStatement
+    };
+  }
+  return getConditionalAnnotation(binding, ifStatement, name);
+}
+
+//# sourceMappingURL=inferer-reference.js.map