@develemit/web-hooks 0.3.1 → 0.4.0

package/dist/chunk-TE2FRIPF.js

@@ -0,0 +1,616 @@
+"use client";
+
+// src/terminal-output/ansi-sgr.ts
+var FLAG_ON = {
+  1: "bold",
+  2: "dim",
+  3: "italic",
+  4: "underline",
+  7: "inverse"
+};
+var FLAG_OFF = {
+  22: ["bold", "dim"],
+  23: ["italic"],
+  24: ["underline"],
+  27: ["inverse"]
+};
+function byte(n) {
+  return Math.max(0, Math.min(255, n));
+}
+function extendedColor(args) {
+  if (args[0] === 5 && args.length >= 2) return { kind: "ansi", index: byte(args[1] ?? 0) };
+  if (args[0] === 2 && args.length >= 4) {
+    const [r = 0, g = 0, b = 0] = args.slice(-3);
+    return { kind: "rgb", r: byte(r), g: byte(g), b: byte(b) };
+  }
+  return null;
+}
+function setKey(style, key, value) {
+  if (value === void 0 || value === false) delete style[key];
+  else style[key] = value;
+}
+function applySgr(style, params) {
+  const next = { ...style };
+  const tokens = params === "" ? ["0"] : params.split(";");
+  for (let i = 0; i < tokens.length; i++) {
+    const parts = (tokens[i] ?? "").split(":").map((p) => p === "" ? 0 : Number(p));
+    const code = parts[0] ?? 0;
+    if (Number.isNaN(code)) continue;
+    if (code === 38 || code === 48) {
+      const key = code === 38 ? "fg" : "bg";
+      let args = parts.slice(1);
+      if (parts.length === 1) {
+        args = tokens.slice(i + 1, i + 5).map(Number);
+        const used = args[0] === 5 ? 2 : args[0] === 2 ? 4 : 0;
+        i += used;
+        args = args.slice(0, used);
+      }
+      const color = extendedColor(args);
+      if (color) setKey(next, key, color);
+      continue;
+    }
+    if (code === 0) {
+      for (const k of Object.keys(next)) delete next[k];
+    } else if (FLAG_ON[code]) setKey(next, FLAG_ON[code], true);
+    else if (FLAG_OFF[code]) (FLAG_OFF[code] ?? []).forEach((k) => setKey(next, k, void 0));
+    else if (code >= 30 && code <= 37) setKey(next, "fg", { kind: "ansi", index: code - 30 });
+    else if (code === 39) setKey(next, "fg", void 0);
+    else if (code >= 40 && code <= 47) setKey(next, "bg", { kind: "ansi", index: code - 40 });
+    else if (code === 49) setKey(next, "bg", void 0);
+    else if (code >= 90 && code <= 97) setKey(next, "fg", { kind: "ansi", index: code - 90 + 8 });
+    else if (code >= 100 && code <= 107) setKey(next, "bg", { kind: "ansi", index: code - 100 + 8 });
+  }
+  return next;
+}
+function colorEquals(a, b) {
+  if (a === b) return true;
+  if (!a || !b || a.kind !== b.kind) return false;
+  if (a.kind === "ansi") return a.index === b.index;
+  const o = b;
+  return a.r === o.r && a.g === o.g && a.b === o.b;
+}
+function styleEquals(a, b) {
+  return a === b || colorEquals(a.fg, b.fg) && colorEquals(a.bg, b.bg) && !!a.bold === !!b.bold && !!a.dim === !!b.dim && !!a.italic === !!b.italic && !!a.underline === !!b.underline && !!a.inverse === !!b.inverse;
+}
+
+// src/terminal-output/ansi-screen.ts
+var BLANK = {};
+var newRow = () => ({ cells: [], shared: false });
+var Screen = class _Screen {
+  rows = [newRow()];
+  row = 0;
+  col = 0;
+  line() {
+    const row = this.rows[this.row] ??= newRow();
+    if (row.shared) {
+      row.cells = row.cells.slice();
+      row.shared = false;
+    }
+    row.segments = void 0;
+    return row.cells;
+  }
+  write(ch, style, href) {
+    const line = this.line();
+    while (line.length < this.col) line.push({ ch: " ", style: BLANK });
+    line[this.col] = { ch, style, href };
+    this.col++;
+  }
+  newline() {
+    this.moveRow(this.row + 1);
+    this.col = 0;
+  }
+  carriageReturn() {
+    this.col = 0;
+  }
+  backspace() {
+    this.col = Math.max(0, this.col - 1);
+  }
+  moveRow(row) {
+    this.row = Math.max(0, row);
+    while (this.rows.length <= this.row) this.rows.push(newRow());
+  }
+  moveRowBy(delta) {
+    this.moveRow(this.row + delta);
+  }
+  setColumn(col) {
+    this.col = Math.max(0, col);
+  }
+  /** `ESC[nK`: 0 cursor to end, 1 start to cursor, 2 whole line. */
+  eraseLine(mode) {
+    const line = this.line();
+    if (mode === 2) this.rows[this.row] = newRow();
+    else if (mode === 1) {
+      for (let i = 0; i < Math.min(this.col + 1, line.length); i++) line[i] = { ch: " ", style: BLANK };
+    } else if (this.col < line.length) line.length = this.col;
+  }
+  /** `ESC[0J`: erase from the cursor to the end of the screen. */
+  eraseBelow() {
+    this.eraseLine(0);
+    this.rows.length = this.row + 1;
+  }
+  lines() {
+    return this.rows.map((row) => row.segments ??= toSegments(row.cells));
+  }
+  get rowCount() {
+    return this.rows.length;
+  }
+  get cursorRow() {
+    return this.row;
+  }
+  /** Forgets the first `count` rows (never the cursor's row) and returns how many went. */
+  dropTop(count) {
+    const n = Math.max(0, Math.min(count, this.row));
+    this.rows.splice(0, n);
+    this.row -= n;
+    return n;
+  }
+  /** An independent copy, so a partial line can be rendered without committing it. */
+  clone() {
+    const copy = new _Screen();
+    for (const row of this.rows) row.shared = true;
+    copy.rows = this.rows.map((r) => ({ ...r }));
+    copy.row = this.row;
+    copy.col = this.col;
+    return copy;
+  }
+};
+function toSegments(cells) {
+  const out = [];
+  let current = null;
+  let currentStyle = null;
+  for (const cell of cells) {
+    if (current && currentStyle && current.href === cell.href && styleEquals(currentStyle, cell.style)) {
+      current.text += cell.ch;
+      continue;
+    }
+    current = { text: cell.ch, ...cell.style };
+    if (cell.href) current.href = cell.href;
+    currentStyle = cell.style;
+    out.push(current);
+  }
+  return out;
+}
+
+// src/terminal-output/ansi.ts
+var ESCAPE_SOURCE = "\\x1b(?:\\[([0-?]*)([ -/]*)([@-~])|\\]([^\\x07\\x1b]*)(?:\\x07|\\x1b\\\\)|[ -/]+[0-~]|[0-~])";
+var DEFAULT_SCHEMES = ["http", "https", "file"];
+function stripAnsi(text) {
+  return text.replace(new RegExp(ESCAPE_SOURCE, "g"), "");
+}
+function allowedHref(uri, schemes) {
+  const match = /^([a-z][a-z0-9+.-]*):/i.exec(uri);
+  return match && schemes.includes((match[1] ?? "").toLowerCase()) ? uri : void 0;
+}
+function writeText(screen, state, text) {
+  for (const ch of text) {
+    if (ch === "\n") screen.newline();
+    else if (ch === "\r") screen.carriageReturn();
+    else if (ch === "\b") screen.backspace();
+    else if (ch === "	" || ch >= " " && ch !== "\x7F") screen.write(ch, state.style, state.href);
+  }
+}
+function applyCsi(screen, state, params, inter, final) {
+  if (inter !== "") return;
+  if (final === "m") {
+    if (/^[0-9;:]*$/.test(params)) state.style = applySgr(state.style, params);
+    return;
+  }
+  if (!/^[0-9;]*$/.test(params)) return;
+  const n = params === "" ? NaN : Number(params.split(";")[0]);
+  const count = Number.isNaN(n) || n === 0 ? 1 : n;
+  const mode = Number.isNaN(n) ? 0 : n;
+  if (final === "A") screen.moveRowBy(-count);
+  else if (final === "B") screen.moveRowBy(count);
+  else if (final === "G") screen.setColumn(count - 1);
+  else if (final === "K") screen.eraseLine(mode);
+  else if (final === "J" && mode === 0) screen.eraseBelow();
+}
+function applyOsc(state, payload, schemes) {
+  if (!payload.startsWith("8;")) return;
+  const split = payload.indexOf(";", 2);
+  state.href = split === -1 ? void 0 : allowedHref(payload.slice(split + 1), schemes);
+}
+function feedAnsi(screen, state, text, options) {
+  const schemes = options.linkSchemes ?? DEFAULT_SCHEMES;
+  const re = new RegExp(ESCAPE_SOURCE, "g");
+  let last = 0;
+  for (let m = re.exec(text); m; m = re.exec(text)) {
+    writeText(screen, state, text.slice(last, m.index));
+    last = m.index + m[0].length;
+    if (m[3] !== void 0) applyCsi(screen, state, m[1] ?? "", m[2] ?? "", m[3]);
+    else if (m[4] !== void 0) applyOsc(state, m[4], schemes);
+  }
+  writeText(screen, state, text.slice(last));
+}
+function run(text, state, options) {
+  const screen = new Screen();
+  feedAnsi(screen, state, text, options);
+  return screen.lines();
+}
+function parseAnsi(text, options = {}) {
+  return run(text, { style: {} }, options);
+}
+function createAnsiParser(options = {}) {
+  const state = { style: {} };
+  return {
+    parse: (chunk) => run(chunk, state, options),
+    reset: () => {
+      state.style = {};
+      state.href = void 0;
+    }
+  };
+}
+
+// src/terminal-output/line-split.ts
+var INCOMPLETE_ESCAPE = /\x1b(?:\[[0-?]*[ -/]*|\][^\x07\x1b]*\x1b?|[ -/]*)$/;
+function splitIncompleteEscape(text) {
+  const match = INCOMPLETE_ESCAPE.exec(text);
+  if (!match) return { complete: text, held: "" };
+  return { complete: text.slice(0, match.index), held: match[0] };
+}
+function splitLines(text) {
+  const pieces = text.split("\n");
+  const rest = pieces.pop() ?? "";
+  const lines = pieces.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+  return { lines, rest };
+}
+
+// src/terminal-output/line-buffer.ts
+function createLineBuffer({ maxLines }) {
+  let decoder = new TextDecoder("utf-8");
+  let lines = [];
+  let pending = "";
+  let cursor;
+  let dropped = 0;
+  function keep(added) {
+    lines.push(...added);
+    const over = Math.max(0, lines.length - maxLines);
+    if (over > 0) lines.splice(0, over);
+    dropped += over;
+    return over;
+  }
+  function update(added, over) {
+    return { lines: added, partial: splitIncompleteEscape(pending).complete, dropped: over };
+  }
+  return {
+    push(chunk, options) {
+      const text = typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+      if (options?.cursor !== void 0) cursor = options.cursor;
+      const { lines: added, rest } = splitLines(pending + text);
+      pending = rest;
+      return update(added, keep(added));
+    },
+    flush() {
+      const tail = pending + decoder.decode();
+      pending = "";
+      const added = tail === "" ? [] : [tail];
+      return update(added, keep(added));
+    },
+    reset() {
+      decoder = new TextDecoder("utf-8");
+      lines = [];
+      pending = "";
+      cursor = void 0;
+      dropped = 0;
+    },
+    get lines() {
+      return lines;
+    },
+    get partial() {
+      return splitIncompleteEscape(pending).complete;
+    },
+    get cursor() {
+      return cursor;
+    },
+    get dropped() {
+      return dropped;
+    }
+  };
+}
+
+// src/terminal-output/ansi-stream.ts
+var DEFAULT_TAIL = 50;
+var CURSOR_UP = /\x1b\[(\d*)A/g;
+function largestCursorUp(text) {
+  let largest = 0;
+  for (const m of text.matchAll(CURSOR_UP)) largest = Math.max(largest, Number(m[1] || 1));
+  return largest;
+}
+function sameLine(a, b) {
+  return a !== void 0 && (a === b || JSON.stringify(a) === JSON.stringify(b));
+}
+function createAnsiStream(options = {}) {
+  let tail = options.tailLines ?? DEFAULT_TAIL;
+  let screen = new Screen();
+  let state = { style: {} };
+  let frozen = 0;
+  let shown = [];
+  let lastPartial = "";
+  let finished = false;
+  function render(partial) {
+    tail = Math.max(tail, largestCursorUp(partial));
+    screen.lines();
+    const draft = screen.clone();
+    feedAnsi(draft, { ...state }, partial, options);
+    const rows = draft.lines();
+    const first = rows.findIndex((row, i) => !sameLine(shown[i], row));
+    const from = first === -1 ? rows.length < shown.length ? rows.length : -1 : first;
+    shown = rows;
+    const update = from === -1 ? {} : { replaced: { from: frozen + from, lines: rows.slice(from) } };
+    const freeze = screen.cursorRow - tail;
+    if (freeze > 0) {
+      const dropped = screen.dropTop(freeze);
+      shown = shown.slice(dropped);
+      frozen += dropped;
+    }
+    return update;
+  }
+  return {
+    push(lines, partial = "") {
+      if (finished) return {};
+      for (const line of lines) {
+        tail = Math.max(tail, largestCursorUp(line));
+        feedAnsi(screen, state, `${line}
+`, options);
+      }
+      lastPartial = partial;
+      return render(partial);
+    },
+    finish(partial = lastPartial) {
+      if (finished) return {};
+      const update = render(partial);
+      finished = true;
+      return update;
+    },
+    reset() {
+      finished = false;
+      lastPartial = "";
+      screen = new Screen();
+      state = { style: {} };
+      frozen = 0;
+      shown = [];
+      tail = options.tailLines ?? DEFAULT_TAIL;
+    }
+  };
+}
+
+// src/terminal-output/log-helpers.ts
+var escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function queryMatcher(query) {
+  const q = query.trim();
+  return q ? new RegExp(escapeRegExp(q), "giu") : null;
+}
+function filterLines(lines, query) {
+  const matcher = queryMatcher(query);
+  const indexes = [];
+  lines.forEach((line, i) => {
+    if (!matcher) indexes.push(i);
+    else {
+      matcher.lastIndex = 0;
+      if (matcher.test(line)) indexes.push(i);
+    }
+  });
+  return indexes;
+}
+function splitByMatch(line, query) {
+  const matcher = queryMatcher(query);
+  if (!matcher) return [{ text: line, match: false }];
+  const segments = [];
+  let last = 0;
+  for (const m of line.matchAll(matcher)) {
+    const start = m.index ?? 0;
+    if (start > last) segments.push({ text: line.slice(last, start), match: false });
+    segments.push({ text: m[0], match: true });
+    last = start + m[0].length;
+  }
+  if (last < line.length || segments.length === 0) {
+    segments.push({ text: line.slice(last), match: false });
+  }
+  return segments;
+}
+var FAILURE_PATTERNS = [
+  { tool: "tsc", kind: "error", pattern: /\berror TS\d+/ },
+  { tool: "pnpm", kind: "error", pattern: /\bERR_PNPM_[A-Z_]+/ },
+  { tool: "npm", kind: "error", pattern: /\bnpm (?:ERR!|error\b)/ },
+  { tool: "nx", kind: "failed tasks", pattern: /targets failed, including|Failed tasks/ },
+  { tool: "nx", kind: "task failed", pattern: /^\s*✖\s+nx run / },
+  { tool: "nx", kind: "failed", pattern: /^\s*✖\s+\d+\/\d+ failed/ },
+  { tool: "vitest", kind: "fail", pattern: /^\s*FAIL\s/ },
+  { tool: "vitest", kind: "test", pattern: /^\s*[×✗]\s/ },
+  { tool: "docker", kind: "error", pattern: /^\s*(?:Error response from daemon|ERROR: failed to solve|failed to solve|pull access denied)/ },
+  { tool: "docker", kind: "exit", pattern: /^\s*Container \S+\s+(?:Error|exited with code [1-9]\d*)/ },
+  { tool: "generic", kind: "error", pattern: /\b\w*Error\b(?: \[\w+\])?:/ }
+];
+var STACK_FRAME = /^\s*at\s/;
+function findFailures(lines, patterns = FAILURE_PATTERNS) {
+  const failures = [];
+  lines.forEach((line, index) => {
+    if (STACK_FRAME.test(line)) return;
+    const hit = patterns.find((p) => p.pattern.test(line));
+    if (hit) failures.push({ index, tool: hit.tool, kind: hit.kind });
+  });
+  return failures;
+}
+function firstFailureIndex(lines, patterns = FAILURE_PATTERNS) {
+  return findFailures(lines, patterns)[0]?.index ?? -1;
+}
+var NOISE_PATTERNS = [
+  /^\s*[0-9a-f]{12}: (?:Pulling fs layer|Waiting|Downloading|Download complete|Verifying Checksum|Extracting|Pull complete|Already exists)/,
+  /^\s*[0-9a-f]{12} (?:Pulling fs layer|Waiting|Downloading|Download complete|Verifying|Extracting|Pull complete|Already exists)/,
+  /^\s*Image \S+\s+(?:Pulling|Pulled)\s*$/,
+  /^\s*Container \S+\s+(?:Creating|Created|Starting|Started|Running|Waiting|Healthy|Stopping|Stopped|Removing|Removed)\s*$/,
+  /^\s*Nx read the output from the cache/
+];
+function isNoise(line, patterns = NOISE_PATTERNS) {
+  return patterns.some((p) => p.test(line));
+}
+function tailMeaningful(lines, n, patterns = NOISE_PATTERNS) {
+  const out = [];
+  for (let i = lines.length - 1; i >= 0 && out.length < n; i--) {
+    const line = (lines[i] ?? "").trimEnd();
+    if (line.trim() && !isNoise(line, patterns)) out.unshift(line);
+  }
+  return out;
+}
+
+// src/terminal-output/follow-tail.ts
+var DEFAULT_TAIL_THRESHOLD = 24;
+function distanceFromEnd({ scrollTop, scrollHeight, clientHeight }) {
+  return scrollHeight - scrollTop - clientHeight;
+}
+function isNearEnd(metrics, threshold = DEFAULT_TAIL_THRESHOLD) {
+  return distanceFromEnd(metrics) <= threshold;
+}
+function shouldStick(prevAtBottom, metrics, userInitiated, threshold = DEFAULT_TAIL_THRESHOLD) {
+  if (!userInitiated) return prevAtBottom;
+  return isNearEnd(metrics, threshold);
+}
+function isUserScrollUp({ kind, delta = 0, lastTarget, scrollTop }, threshold = DEFAULT_TAIL_THRESHOLD) {
+  if (kind === "wheel") return delta < 0;
+  if (kind === "touch") return delta > 0;
+  if (kind === "gutter") return true;
+  return lastTarget !== null && scrollTop < lastTarget - threshold;
+}
+function unreadDelta(prevCount, nextCount, attached) {
+  if (attached) return 0;
+  return Math.max(0, nextCount - prevCount);
+}
+
+// src/terminal-output/use-follow-tail.ts
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+var useIsomorphicLayoutEffect = typeof window === "undefined" ? useEffect : useLayoutEffect;
+function useFollowTail({
+  scrollRef,
+  itemCount,
+  scrollToEnd,
+  resetKey,
+  threshold = DEFAULT_TAIL_THRESHOLD
+}) {
+  const [atBottom, setAtBottom] = useState(true);
+  const [unread, setUnread] = useState(0);
+  const attached = useRef(true);
+  const programmatic = useRef(false);
+  const lastTarget = useRef(null);
+  const lastTop = useRef(0);
+  const frame = useRef(0);
+  const prevCount = useRef(itemCount);
+  const prevReset = useRef(resetKey);
+  const latest = useRef({ scrollToEnd, threshold });
+  latest.current = { scrollToEnd, threshold };
+  const attach = useCallback((value) => {
+    attached.current = value;
+    setAtBottom(value);
+    if (value) setUnread(0);
+  }, []);
+  const followEnd = useCallback(() => {
+    const el = scrollRef.current;
+    if (!el) return;
+    programmatic.current = true;
+    if (latest.current.scrollToEnd) latest.current.scrollToEnd();
+    else el.scrollTop = el.scrollHeight;
+    lastTarget.current = el.scrollHeight - el.clientHeight;
+    if (typeof requestAnimationFrame === "function") {
+      cancelAnimationFrame(frame.current);
+      frame.current = requestAnimationFrame(() => {
+        programmatic.current = false;
+      });
+    } else {
+      programmatic.current = false;
+    }
+  }, [scrollRef]);
+  useIsomorphicLayoutEffect(() => {
+    const count = prevCount.current;
+    prevCount.current = itemCount;
+    if (prevReset.current !== resetKey) {
+      prevReset.current = resetKey;
+      attach(true);
+      followEnd();
+      return;
+    }
+    if (attached.current) {
+      if (itemCount > 0) followEnd();
+      return;
+    }
+    const added = unreadDelta(count, itemCount, false);
+    if (added > 0) setUnread((n) => n + added);
+  }, [itemCount, resetKey, attach, followEnd]);
+  useEffect(() => {
+    const el = scrollRef.current;
+    if (!el) return;
+    const takeOver = () => {
+      programmatic.current = false;
+      lastTarget.current = null;
+      if (attached.current) attach(false);
+    };
+    const onScroll = () => {
+      const { threshold: limit } = latest.current;
+      const movedUp = el.scrollTop < lastTop.current;
+      lastTop.current = el.scrollTop;
+      const info = { kind: "scroll", lastTarget: movedUp ? lastTarget.current : null, scrollTop: el.scrollTop };
+      const user = isUserScrollUp(info, limit);
+      if (user) takeOver();
+      const next = shouldStick(attached.current, el, user || !programmatic.current, limit);
+      if (next !== attached.current) attach(next);
+    };
+    const canScrollUp = () => el.scrollHeight > el.clientHeight && el.scrollTop > 0;
+    const onWheel = (e) => {
+      if (canScrollUp() && isUserScrollUp({ kind: "wheel", delta: e.deltaY, lastTarget: null, scrollTop: el.scrollTop })) takeOver();
+    };
+    let touchY = 0;
+    const onTouchStart = (e) => {
+      touchY = e.touches[0]?.clientY ?? 0;
+    };
+    const onTouchMove = (e) => {
+      const delta = (e.touches[0]?.clientY ?? touchY) - touchY;
+      if (canScrollUp() && isUserScrollUp({ kind: "touch", delta, lastTarget: null, scrollTop: el.scrollTop })) takeOver();
+    };
+    const onPointerDown = (e) => {
+      const gutter = el.offsetWidth - el.clientWidth;
+      if (e.target !== el || gutter <= 0) return;
+      if (e.clientX >= el.getBoundingClientRect().left + el.clientWidth) {
+        if (isUserScrollUp({ kind: "gutter", lastTarget: null, scrollTop: el.scrollTop })) takeOver();
+      }
+    };
+    el.addEventListener("scroll", onScroll, { passive: true });
+    el.addEventListener("wheel", onWheel, { passive: true });
+    el.addEventListener("touchstart", onTouchStart, { passive: true });
+    el.addEventListener("touchmove", onTouchMove, { passive: true });
+    el.addEventListener("pointerdown", onPointerDown, { passive: true });
+    return () => {
+      el.removeEventListener("scroll", onScroll);
+      el.removeEventListener("wheel", onWheel);
+      el.removeEventListener("touchstart", onTouchStart);
+      el.removeEventListener("touchmove", onTouchMove);
+      el.removeEventListener("pointerdown", onPointerDown);
+      if (typeof cancelAnimationFrame === "function") cancelAnimationFrame(frame.current);
+    };
+  }, [scrollRef, attach]);
+  const jumpToBottom = useCallback(() => {
+    attach(true);
+    followEnd();
+  }, [attach, followEnd]);
+  return { atBottom, unread, jumpToBottom };
+}
+
+export {
+  stripAnsi,
+  parseAnsi,
+  createAnsiParser,
+  createLineBuffer,
+  createAnsiStream,
+  filterLines,
+  splitByMatch,
+  FAILURE_PATTERNS,
+  findFailures,
+  firstFailureIndex,
+  NOISE_PATTERNS,
+  isNoise,
+  tailMeaningful,
+  DEFAULT_TAIL_THRESHOLD,
+  distanceFromEnd,
+  isNearEnd,
+  shouldStick,
+  isUserScrollUp,
+  unreadDelta,
+  useFollowTail
+};