mixdog 0.9.0 → 0.9.2

package/src/vendor/statusline/src/gateway/claude-current.mjs

@@ -119,7 +119,7 @@ export function resolveClaudeModelAlias(model) {
   if (!raw) return null;
   const stripped = stripClaudeContextSuffix(raw);
   if (/^claude-/i.test(stripped)) return stripped;
-  const family = stripped.match(/^(opus|sonnet|haiku)(?:[-_].*)?$/i)?.[1]?.toLowerCase();
+  const family = stripped.match(/^(opus|sonnet|haiku|fable)(?:[-_].*)?$/i)?.[1]?.toLowerCase();
   if (family) return familyDefaultModel(family);
   return null;
 }
@@ -128,11 +128,11 @@ export function displayClaudeModel(model, raw = '', display = '') {
   const explicit = cleanString(display);
   if (explicit) return explicit;
   const id = cleanString(model) || resolveClaudeModelAlias(raw) || cleanString(raw);
-  const m = id.match(/^claude-(opus|sonnet|haiku)-(\d+)-(\d+)(?:-\d{8})?$/i);
+  const m = id.match(/^claude-(opus|sonnet|haiku|fable)-(\d+)(?:-(\d+))?(?:-\d{8})?$/i);
   if (m) {
     const family = `${m[1][0].toUpperCase()}${m[1].slice(1).toLowerCase()}`;
     const suffix = /\[1m\]/i.test(raw) || contextWindowFromRawModel(raw, id) === 1000000 ? ' (1M context)' : '';
-    return `${family} ${m[2]}.${m[3]}${suffix}`;
+    return `${family} ${m[2]}${m[3] ? `.${m[3]}` : ''}${suffix}`;
   }
   return id || raw || '';
 }

package/src/vendor/statusline/src/gateway/route-meta.mjs

@@ -254,8 +254,8 @@ function displayForModel(provider, model, info) {
   const display = cleanString(info?.display) || cleanString(info?.displayName) || cleanString(info?.name);
   if (display) return display;
   if (provider === 'anthropic-oauth') {
-    const m = String(model || '').match(/^claude-(opus|sonnet|haiku)-(\d+)-(\d+)/i);
-    if (m) return `${m[1][0].toUpperCase()}${m[1].slice(1).toLowerCase()} ${m[2]}.${m[3]}`;
+    const m = String(model || '').match(/^claude-(opus|sonnet|haiku|fable)-(\d+)(?:-(\d+))?/i);
+    if (m) return `${m[1][0].toUpperCase()}${m[1].slice(1).toLowerCase()} ${m[2]}${m[3] ? `.${m[3]}` : ''}`;
   }
   return model || '';
 }
@@ -343,25 +343,44 @@ export function readGatewayRouteInfo(seed = {}, providerObj = null) {
   };
 }
 
-function compactBoundaryForRoute(routeInfo = {}, compact = null) {
-  const compactLimit = num(routeInfo?.autoCompactTokenLimit ?? compact?.compactLimitTokens, 0);
+// Boundary denominator for status %, overflow checks, and gateway env window.
+// Order: explicit boundary (routeInfo or compact) → contextWindow → budgetWindow
+// → rawContextWindow. autoCompactTokenLimit / compactLimitTokens are triggers
+// only and are never read here.
+export function compactBoundaryDenominator(routeInfo = {}, compact = null) {
+  const fromRoute = num(
+    routeInfo?.compactBoundaryTokens
+      ?? routeInfo?.compact_boundary_tokens
+      ?? routeInfo?.boundaryTokens,
+    0,
+  );
+  const fromCompact = num(
+    compact?.boundaryTokens
+      ?? compact?.compactBoundaryTokens
+      ?? compact?.compact_boundary_tokens,
+    0,
+  );
+  const boundaryTokens = fromRoute > 0 ? fromRoute : fromCompact;
   const contextWindow = num(routeInfo?.contextWindow ?? compact?.contextWindow, 0);
   const budgetWindow = num(compact?.budgetWindow, 0);
   const rawContextWindow = num(routeInfo?.rawContextWindow ?? compact?.rawContextWindow, 0);
-  if (compactLimit > 0 && contextWindow > 0) return Math.min(compactLimit, contextWindow);
-  if (compactLimit > 0) return compactLimit;
-  if (budgetWindow > 0 && contextWindow > 0) return Math.min(budgetWindow, contextWindow);
-  if (budgetWindow > 0) return budgetWindow;
+  if (boundaryTokens > 0) return boundaryTokens;
   if (contextWindow > 0) return contextWindow;
+  if (budgetWindow > 0) return budgetWindow;
   return rawContextWindow > 0 ? rawContextWindow : 0;
 }
 
+function compactBoundaryForRoute(routeInfo = {}, compact = null) {
+  return compactBoundaryDenominator(routeInfo, compact);
+}
+
 // Single source of truth for the value synced to host env
 // CLAUDE_CODE_AUTO_COMPACT_WINDOW. BOTH the --enable-time write
 // (scripts/gateway-model.mjs) and the runtime sync (src/gateway/server.mjs)
 // must derive the window the SAME way, or they disagree on the value written to
-// settings.json. Prefer the explicit compact limit, bounded by the effective
-// context window, then fall back to context/raw metadata. Returns a positive
+// settings.json. Denominator order: compactBoundaryTokens / boundaryTokens (route
+// or compact) → contextWindow → budgetWindow → rawContextWindow. Never
+// autoCompactTokenLimit or compactLimitTokens (trigger-only). Returns a positive
 // integer, or null when unknown.
 export function autoCompactWindowForRoute(routeInfo) {
   const n = compactBoundaryForRoute(routeInfo);
@@ -428,12 +447,7 @@ function usageCostUsd(routeInfo, usage) {
 }
 
 function contextUsageBoundary(routeInfo, compact = null) {
-  const contextWindow = num(routeInfo?.contextWindow ?? compact?.contextWindow, 0);
-  const budgetWindow = num(compact?.budgetWindow, 0);
-  const rawContextWindow = num(routeInfo?.rawContextWindow ?? compact?.rawContextWindow, 0);
-  if (contextWindow > 0) return contextWindow;
-  if (budgetWindow > 0) return budgetWindow;
-  return rawContextWindow > 0 ? rawContextWindow : compactBoundaryForRoute(routeInfo, compact);
+  return compactBoundaryDenominator(routeInfo, compact);
 }
 
 export function summarizeGatewayUsage(routeInfo, providerOut, compact = null, durationMs = null) {

package/src/workflows/default/WORKFLOW.md

@@ -1,14 +1,41 @@
+---
+id: default
+name: Default
+description: "Default agent workflow — fan-out parallel delegation across independent scopes."
+agents: worker, heavy-worker, reviewer, debugger, maintainer
+---
+
 # Default Workflow
 
-1. Plan — Lead discusses the request with the user, forms a plan, and waits for
-   approval.
-2. Delegate — split the work into the maximum number of independent scopes.
-   Spawn every scope in the same turn. Never merge separable scopes into one
-   agent. Shared functions or cross-cutting concerns do not justify merging;
-   split per path and verify the shared parts yourself.
-3. Review — fan out one review scope per implementation scope, in the same turn.
-   Fact-check implementation and review results yourself. Send fixes back to the
-   original scope and repeat until clean. Skip delegated review only for simple,
-   low-risk tasks.
-4. Report — integrate the results, report the final state, and ask the user
-   whether to ship/deploy when relevant.
+Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
+- Lead handles directly: simple 1–2 step work, plus coordination, pre-planning,
+  config changes, and final git deployment.
+- Worker: implementation that takes several steps.
+- Heavy Worker: high-complexity, multi-step implementation.
+- Reviewer: verify implementation scopes (diff, regressions, missing checks).
+- Debugger: deploy for very high complexity, or when root-causing has already
+  failed at least once.
+
+1. Plan — discuss the request with the user, form a plan, and wait for approval.
+2. Delegate — split into the maximum number of independent scopes.
+   - PARALLEL across independent scopes by default (implementation, analysis,
+     review, debugging split alike). Spawn every scope in the SAME turn. Shared
+     or cross-cutting code does NOT justify merging: split per path and verify
+     the shared parts yourself. The only single scope is a genuinely
+     inseparable dependency — then state it.
+   - SEQUENTIAL within a single complex scope — split it into ordered steps
+     rather than handing it off in one shot, with a build/test-green gate
+     between steps.
+   - Reuse the existing agent (same tag) for follow-up on the same scope; spawn
+     new only for a separate scope. Write briefs per the lead-tool brief
+     contract (token-optimized labeled fragments).
+   - After spawning async agent(s), END THE TURN — do not poll, guess, or start
+     dependent work until the completion notification resumes you (status/read
+     are manual recovery only). Then wait and continue automatically.
+3. Review — pair one reviewer 1:1 with each implementation scope, spawned in the
+   same turn. Cross-check implementation and review results yourself before
+   acting on them. Send fixes back to the original scope and repeat until clean.
+   Skip review only for simple, low-risk tasks.
+4. Report — deliver the final report: synthesize results (outcome + key
+   evidence; never forward raw agent output), state the final state, and ask the
+   user whether to ship/deploy when relevant.

package/src/workflows/sequential/WORKFLOW.md

@@ -0,0 +1,46 @@
+---
+id: sequential
+name: Sequential
+description: "Sequential workflow — delegates 1:1 with no fan-out; one agent at a time."
+agents: worker, heavy-worker, reviewer, debugger, maintainer
+---
+
+# Sequential Workflow
+
+Unlike Default, which fans out independent scopes in parallel, this mode runs
+with no fan-out: it delegates one scope at a time, 1:1, and only moves to the
+next after the current one completes.
+
+Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
+- Lead handles directly: simple 1–2 step work, plus coordination, pre-planning,
+  config changes, and final git deployment.
+- Worker: implementation that takes several steps.
+- Heavy Worker: high-complexity, multi-step implementation.
+- Reviewer: verify implementation scopes (diff, regressions, missing checks).
+- Debugger: deploy for very high complexity, or when root-causing has already
+  failed at least once.
+
+1. Plan — discuss the request with the user, form a plan, and wait for approval.
+2. Delegate — split into ordered scopes and hand them off ONE AT A TIME.
+   - NO PARALLEL, NO FAN-OUT. Even when scopes are independent, spawn exactly
+     one agent per turn; never spawn multiple agents in the same turn. Wait for
+     the current scope's completion notification before spawning the next scope
+     (1:1 sequential).
+   - SEQUENTIAL within a single complex scope — split it into ordered steps
+     rather than handing it off in one shot, with a build/test-green gate
+     between steps.
+   - Reuse the existing agent (same tag) for follow-up on the same scope; spawn
+     new only for a separate scope. Write briefs per the lead-tool brief
+     contract (token-optimized labeled fragments).
+   - After spawning an async agent, END THE TURN — do not poll, guess, or start
+     dependent or subsequent work until the completion notification resumes you
+     (status/read are manual recovery only). Then wait and continue
+     automatically.
+3. Review — after each implementation scope completes, pair one reviewer 1:1
+   with that scope (spawned on its own turn, not batched). Cross-check
+   implementation and review results yourself before acting on them. Send fixes
+   back to the original scope and repeat until clean. Skip review only for
+   simple, low-risk tasks.
+4. Report — deliver the final report: synthesize results (outcome + key
+   evidence; never forward raw agent output), state the final state, and ask the
+   user whether to ship/deploy when relevant.

package/src/workflows/solo/WORKFLOW.md

@@ -1,3 +1,10 @@
+---
+id: solo
+name: Solo
+description: "Solo workflow — Lead handles everything directly; delegation forbidden."
+agents:
+---
+
 # Solo Workflow
 
 1. Plan — Lead discusses the request with the user, forms a plan, and waits for

package/vendor/ink/build/display-width.js

@@ -0,0 +1,62 @@
+/**
+ * display-width.js — [mixdog fork] vendored copy of the shared display-width
+ * policy from src/tui/display-width.mjs.
+ *
+ * MUST STAY IN SYNC with src/tui/display-width.mjs. ink is aliased as an
+ * external bundle (see scripts/build-tui.mjs), so it cannot cleanly import from
+ * src; the small policy is replicated here verbatim instead. If the problem
+ * ranges or the WT_SESSION/MIXDOG_TUI_AMBIGUOUS_WIDE gate change there, change
+ * them here too — ink's MEASUREMENT must agree with OUR wrap/row math or the
+ * overlap gets worse, not better.
+ *
+ * Policy: widen ONLY U+2460–U+24FF (enclosed alphanumerics / circled digits)
+ * and U+2190–U+21FF (arrows) to 2 cells when ON. NEVER widen box-drawing
+ * (U+2500–U+257F), block elements, or other ambiguous glyphs. ON by default
+ * only under Windows Terminal (WT_SESSION); MIXDOG_TUI_AMBIGUOUS_WIDE='1'/'0'
+ * overrides and wins. OFF ⇒ identical to plain string-width.
+ */
+import stringWidth from 'string-width';
+
+function isProblemCodePoint(cp) {
+    return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2190 && cp <= 0x21ff);
+}
+
+function resolveAmbiguousWidePolicy(env = process.env) {
+    const override = env?.MIXDOG_TUI_AMBIGUOUS_WIDE;
+    if (override === '1')
+        return true;
+    if (override === '0')
+        return false;
+    return Boolean(env?.WT_SESSION);
+}
+
+// Resolved once at module load (matches src/tui/display-width.mjs).
+export const AMBIGUOUS_WIDE = resolveAmbiguousWidePolicy();
+
+export function displayWidthWith(str, wide) {
+    const s = String(str ?? '');
+    const base = stringWidth(s);
+    if (!wide)
+        return base;
+    let extra = 0;
+    for (const ch of s) {
+        const cp = ch.codePointAt(0);
+        if (isProblemCodePoint(cp) && stringWidth(ch) === 1)
+            extra += 1;
+    }
+    return base + extra;
+}
+
+/** Visible display width under the resolved policy (ink-side stringWidth). */
+export function displayStringWidth(str) {
+    return displayWidthWith(str, AMBIGUOUS_WIDE);
+}
+
+/** widest-line equivalent under the policy. */
+export function displayWidestLine(text) {
+    let lineWidth = 0;
+    for (const line of String(text ?? '').split('\n')) {
+        lineWidth = Math.max(lineWidth, displayStringWidth(line));
+    }
+    return lineWidth;
+}

package/vendor/ink/build/ink.js

@@ -85,7 +85,7 @@ const stripKittyQueryResponsesAndTrailingPartial = (buffer) => {
 // desynchronizes the incremental erase used for frames that exactly fill the
 // viewport, leaving stale copies of previous frames behind (#969). Keep the
 // pre-7.0 behavior of fully clearing between fullscreen frames there.
-const isWindowsConsole = process.platform === 'win32';
+const isWindowsConsole = process.platform === 'win32' || Boolean(process.env.WT_SESSION);
 const shouldClearTerminalForFrame = ({ isTty, viewportRows, previousOutputHeight, nextOutputHeight, isUnmounting, }) => {
     if (!isTty) {
         return false;
@@ -181,6 +181,11 @@ export default class Ink {
     // cells ({ x1, y1, x2, y2 } inclusive, normalized) or null. The App sets it
     // via setSelection(); onRender forwards it to the renderer for highlighting.
     selectionRect = null;
+    // [mixdog fork] Coalesce drag-selection repaints when a frame is pending.
+    isRendering = false;
+    selectionRepaintQueued = false;
+    selectionRepaintFlushPending = false;
+    selectionRepaintEpoch = 0;
     // [mixdog fork] text under the current selection rect, refreshed every render
     // from the output grid. Read back via getSelectionText() on drag-release.
     selectedText = null;
@@ -318,9 +323,9 @@ export default class Ink {
         this.log.setCursorPosition(position);
     };
     // [mixdog fork] Update the mouse drag-selection rectangle and repaint so the
-    // inverse highlight tracks the drag live. Called by the App's mouse handler.
+    // inverse highlight tracks the drag. Called by the App's mouse handler.
     // A no-op-equal update is skipped to avoid redundant frames during motion.
-    setSelection = (rect) => {
+    setSelection = (rect, options = {}) => {
         const a = this.selectionRect;
         const same = a === rect ||
             (a && rect &&
@@ -331,22 +336,68 @@ export default class Ink {
                 a.y2 === rect.y2 &&
                 a.clipY1 === rect.clipY1 &&
                 a.clipY2 === rect.clipY2 &&
-                a.captureText === rect.captureText);
+                a.captureText === rect.captureText &&
+                a.selectionForeground === rect.selectionForeground &&
+                a.selectionBackground === rect.selectionBackground);
         if (same) {
-            return;
+            if (!options.immediate) {
+                return;
+            }
+        }
+        else {
+            this.selectionRect = rect ?? null;
         }
-        this.selectionRect = rect ?? null;
         if (!this.isUnmounted) {
-            // Drag selection is a direct manipulation gesture. Route it through
-            // the unthrottled renderer so the highlight tracks the pointer
-            // instead of trailing behind at maxFps.
-            this.rootNode.onImmediateRender();
+            if (options.immediate) {
+                this.selectionRepaintEpoch++;
+                this.selectionRepaintFlushPending = false;
+                this.rootNode.onImmediateRender();
+                return;
+            }
+            this.scheduleSelectionRepaint();
+        }
+    };
+    scheduleSelectionRepaint = () => {
+        if (this.hasPendingThrottledRender) {
+            return;
         }
+        if (this.isRendering) {
+            this.selectionRepaintQueued = true;
+            return;
+        }
+        if (this.selectionRepaintFlushPending) {
+            return;
+        }
+        this.selectionRepaintFlushPending = true;
+        const epoch = ++this.selectionRepaintEpoch;
+        queueMicrotask(() => {
+            this.selectionRepaintFlushPending = false;
+            if (epoch !== this.selectionRepaintEpoch || this.isUnmounted) {
+                return;
+            }
+            if (this.hasPendingThrottledRender) {
+                return;
+            }
+            this.rootNode.onImmediateRender();
+        });
     };
     // [mixdog fork] Given a 0-based cell (x, y), return the inclusive rect of the
-    // word (maximal run of non-whitespace cells) on that single row, or null if
-    // the cell is whitespace/empty or out of range. Reuses the cached cell-value
-    // rows from the last render so it works without retaining the Output instance.
+    // word at that cell on that single row, or null if the cell is whitespace/empty
+    // or out of range. Reuses the cached cell-value rows from the last render so it
+    // works without retaining the Output instance.
+    //
+    // Ported from claude-code's selection.ts charClass/wordBoundsAt (3-class word
+    // model) onto mixdog's rect(linear) infra. Instead of a naive "non-space run",
+    // expansion stops at a CHARACTER-CLASS change:
+    //   class 1 = WORD_CHAR — letters (any script), digits, and the punctuation
+    //             iTerm2 treats as word-part by default (/-+~_.\), so a path like
+    //             `/usr/bin/bash` or `~/.claude/config.json` selects whole.
+    //   class 2 = other punctuation — so `->` selects just `->`, not the words
+    //             on either side.
+    //   class 0 = space/empty. claude-code treats a space run as selectable
+    //             (class 0), but mixdog intentionally returns null on empty/space
+    //             so a double-click on blank does nothing (safer for our transcript
+    //             where most alt-screen cells are padding).
     getWordRectAt = (x, y) => {
         const rows = this.lastPlainRows;
         if (!rows)
@@ -354,16 +405,89 @@ export default class Ink {
         const cells = rows[y];
         if (!Array.isArray(cells))
             return null;
-        const isWordChar = (v) => !!v && !/^\s$/u.test(v);
-        if (!isWordChar(cells[x]))
+        // Unicode-aware word-char set (matches selection.ts WORD_CHAR).
+        const WORD_CHAR = /[\p{L}\p{N}_/.\-+~\\]/u;
+        const charClass = (v) => {
+            if (!v || v === ' ')
+                return 0;
+            return WORD_CHAR.test(v) ? 1 : 2;
+        };
+        // [mixdog fork] Wide/CJK glyphs occupy 2+ grid cells: the HEAD cell
+        // holds the glyph and each TRAILING cell is stored as '' (spacer tail)
+        // carrying the glyph's styles — see output.js ~L237-243 for how wide
+        // chars are laid into the grid. A '' cell is a wide-char TAIL only when
+        // it directly follows a non-empty non-space glyph (class !== 0); a ''
+        // after '' or after a space is genuine blank padding. This mirrors
+        // selection.ts wordBoundsAt's SpacerTail step-back (L172-178) and
+        // expansion step-over (L206-221) on mixdog's string-cell grid.
+        const isWideTail = (i) => i > 0 && cells[i] === '' && charClass(cells[i - 1]) !== 0;
+        // On entry: if the click landed on a spacer tail, step back to the head
+        // so charClass sees the actual glyph. Genuine blank padding is left
+        // alone, preserving the null-on-blank behavior below.
+        let sx = x;
+        if (isWideTail(sx))
+            sx = sx - 1;
+        const cls = charClass(cells[sx]);
+        // Preserve mixdog's null-on-space/empty behavior (class 0).
+        if (cls === 0)
             return null;
-        let x1 = x, x2 = x;
-        while (x1 - 1 >= 0 && isWordChar(cells[x1 - 1]))
-            x1--;
-        while (x2 + 1 < cells.length && isWordChar(cells[x2 + 1]))
-            x2++;
+        let x1 = sx, x2 = sx;
+        // Expand left: step OVER a spacer tail to the wide-char head and include
+        // both columns when the head matches the class; otherwise stop at a
+        // class change.
+        while (x1 - 1 >= 0) {
+            const p = x1 - 1;
+            if (isWideTail(p)) {
+                if (p - 1 >= 0 && charClass(cells[p - 1]) === cls) {
+                    x1 = p - 1;
+                    continue;
+                }
+                break;
+            }
+            if (charClass(cells[p]) === cls) {
+                x1 = p;
+                continue;
+            }
+            break;
+        }
+        // Expand right: INCLUDE a spacer tail that follows an in-run glyph so x2
+        // covers the wide glyph's full width; otherwise stop at a class change.
+        while (x2 + 1 < cells.length) {
+            const n = x2 + 1;
+            if (isWideTail(n)) {
+                x2 = n;
+                continue;
+            }
+            if (charClass(cells[n]) === cls) {
+                x2 = n;
+                continue;
+            }
+            break;
+        }
         return { x1, y1: y, x2, y2: y };
     };
+    // [mixdog fork] Given a 0-based row y, return the inclusive rect of the whole
+    // logical line at that row (mirrors claude-code's selectLineAt intent on
+    // mixdog's rect infra). x1 is always 0; x2 is the last non-space content cell
+    // so trailing padding isn't selected. Returns null for an empty/blank row.
+    // Exposed symmetrically to getWordRectAt (index.jsx wires it into the store).
+    getLineRectAt = (y) => {
+        const rows = this.lastPlainRows;
+        if (!rows)
+            return null;
+        const cells = rows[y];
+        if (!Array.isArray(cells))
+            return null;
+        let x2 = -1;
+        for (let x = 0; x < cells.length; x++) {
+            const v = cells[x];
+            if (v && !/^\s$/u.test(v))
+                x2 = x;
+        }
+        if (x2 < 0)
+            return null;
+        return { x1: 0, y1: y, x2, y2: y };
+    };
     restoreLastOutput = () => {
         if (!this.interactive) {
             return;
@@ -401,6 +525,8 @@ export default class Ink {
             this.nextRenderCommit.resolve();
             this.nextRenderCommit = undefined;
         }
+        this.isRendering = true;
+        try {
         const startTime = performance.now();
         const { output, outputHeight, staticOutput, cursor, selectedText, plainRows } = render(this.rootNode, this.isScreenReaderEnabled, this.selectionRect);
         // [mixdog fork] Cache the text under the current selection rect so the App
@@ -488,6 +614,14 @@ export default class Ink {
             this.fullStaticOutput += staticOutput;
         }
         this.renderInteractiveFrame(output, outputHeight, hasStaticOutput ? staticOutput : '');
+        }
+        finally {
+            this.isRendering = false;
+            if (this.selectionRepaintQueued) {
+                this.selectionRepaintQueued = false;
+                this.scheduleSelectionRepaint();
+            }
+        }
     };
     render(node) {
         const tree = (React.createElement(AccessibilityContext.Provider, { value: { isScreenReaderEnabled: this.isScreenReaderEnabled } },

package/vendor/ink/build/measure-text.js

@@ -1,4 +1,7 @@
-import widestLine from 'widest-line';
+// [mixdog fork] use the shared display-width policy so ink's text measurement
+// matches OUR wrap/row math for circled digits / arrows. Kept in sync with
+// src/tui/display-width.mjs.
+import { displayWidestLine as widestLine } from './display-width.js';
 const cache = new Map();
 const measureText = (text) => {
     if (text.length === 0) {