march-cli 0.1.39 → 0.1.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",

package/src/cli/args.mjs

@@ -69,6 +69,7 @@ Usage:
   march [options]            (starts REPL)
   march login [provider]     Login to an OAuth provider
   march provider --config    Configure provider credentials
+  march provider remove      Remove a configured provider interactively
   march provider share [id]  Share a provider profile
   march provider accept <token>
   march web [path]       Start the local Web UI session manager

package/src/cli/input/keybindings.mjs

@@ -9,6 +9,7 @@ export const DEFAULT_KEYBINDINGS = Object.freeze({
   thinkingSelector: "Ctrl+T",
   modelSelector: "Ctrl+L",
   externalEditor: "Ctrl+G",
+  clearInput: "Ctrl+U",
   toggleToolOutput: "Ctrl+O",
   toggleShellDrawer: "Alt+S",
   nextShell: "Alt+N",
@@ -27,6 +28,7 @@ export const KEYBINDING_ACTIONS = Object.freeze({
   thinkingSelector: "Open thinking selector",
   modelSelector: "Open model selector",
   externalEditor: "Open external editor ($VISUAL or $EDITOR)",
+  clearInput: "Clear current input draft",
   toggleToolOutput: "Toggle tool output collapsed/expanded",
   toggleShellDrawer: "Toggle right-side shell pane",
   nextShell: "Select next shell in pane",

package/src/cli/repl-loop.mjs

@@ -104,6 +104,10 @@ export async function runInteractiveRepl({
       trimmed = templateResult.prompt;
     }
 
+    if (turnActive.viewOnly) {
+      ui.writeln("This session is view-only. Use /session and Take over control before sending prompts.");
+      continue;
+    }
     if (turnActive.turnTask) {
       ui.writeln("This session is still running. Use /session to start or inspect another session.");
       continue;

package/src/cli/startup/app-runtime.mjs

@@ -94,7 +94,7 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot }
     ui,
     activeProjectId: currentProjectInfo.projectId,
     activeSessionId: sessionState.sessionId,
-    onRenderTimelineChange: persistRenderTimeline,
+    onPersistRenderTimeline: persistRenderTimeline,
   });
   const runtimeUi = outputRouter.createProjectUi(currentProjectInfo.projectId, () => sessionState.sessionId);
   let turnRunning = false;
@@ -176,7 +176,10 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot }
         onNotificationActivation,
       });
     },
-    onActivate: ({ projectId, sessionId }) => outputRouter.setActiveSession(projectId, sessionId, { renderTimeline: loadStoredRenderTimeline(projectMarchDirs.get(projectId), sessionId) }),
+    onActivate: ({ projectId, sessionId, runtime }) => {
+      if (runtime?.projectMarchDir) projectMarchDirs.set(projectId, runtime.projectMarchDir);
+      outputRouter.setActiveSession(projectId, sessionId, { renderTimeline: loadStoredRenderTimeline(projectMarchDirs.get(projectId), sessionId) });
+    },
   });
   runner = workspaceSupervisor.runner;
 
@@ -213,8 +216,8 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot }
   outputRouter.setActiveSession(currentProjectInfo.projectId, sessionState.sessionId, { renderTimeline: loadStoredRenderTimeline(projectMarchDir, sessionState.sessionId) });
   refreshStatusBar();
 
-  function persistRenderTimeline({ projectId, sessionId, events, event }) {
-    if (!sessionId || !shouldPersistRenderEvent(event?.method)) return;
+  function persistRenderTimeline({ projectId, sessionId, events }) {
+    if (!sessionId) return;
     const routeProjectMarchDir = projectMarchDirs.get(projectId);
     if (!routeProjectMarchDir) return;
     try {
@@ -259,10 +262,6 @@ function loadStoredRenderTimeline(projectMarchDir, sessionId) {
   }
 }
 
-function shouldPersistRenderEvent(method) {
-  return method === "turnEnd" || method === "assistantReplyEnd" || method === "toolEnd" || method === "writeln" || method === "clearOutput";
-}
-
 async function handleNotificationActivation({ activation, stateRoot, workspaceSupervisor, ui }) {
   if (activation?.type !== "workspace-session" || !activation.projectId) return;
   if (!workspaceSupervisor) throw new Error("workspace supervisor is not ready");

package/src/cli/tui/output/timeline-block-restore.mjs

@@ -0,0 +1,45 @@
+import { createToolCardBlock, writeToolEnd } from "../tool-rendering.mjs";
+import { formatRecallLines } from "../recall-rendering.mjs";
+
+export function restoreTimelineBlocksToOutputBuffer(output, blocks) {
+  output.clear();
+  for (const block of Array.isArray(blocks) ? blocks : []) appendTimelineBlock(output, block);
+  output.invalidate?.();
+}
+
+function appendTimelineBlock(output, block) {
+  if (!block || typeof block !== "object") return;
+  switch (block.type) {
+    case "assistant":
+      if (block.content) output.addBlock({ type: "markdown", text: String(block.content), sealed: Boolean(block.closed), cache: new Map() });
+      break;
+    case "thinking":
+      output.addBlock({ type: "thinking", tokens: block.tokens ?? 0, content: splitLines(block.content) });
+      break;
+    case "tool": {
+      const card = createToolCardBlock({ name: block.name, args: block.args });
+      output.addBlock(card);
+      if (block.closed) writeToolEnd({ output, name: block.name, isError: block.isError, result: block.result, toolBlock: card });
+      break;
+    }
+    case "output":
+      if (block.newline) output.writeln(String(block.content ?? ""));
+      else output.write(String(block.content ?? ""));
+      break;
+    case "status":
+      output.addBlock({ type: "status", lines: [String(block.content ?? "")] });
+      break;
+    case "recall":
+      output.addBlock({ type: "plain", lines: formatRecallLines(block.hints ?? []) });
+      break;
+    case "editDiff":
+      output.addBlock({ type: "diff", path: block.path, diffLines: block.diffLines ?? [] });
+      break;
+    default:
+      break;
+  }
+}
+
+function splitLines(value) {
+  return String(value ?? "").split("\n");
+}

package/src/cli/tui/output-buffer.mjs

@@ -2,6 +2,7 @@ import { brightBlack, dim } from "./ui-theme.mjs";
 import { renderToolCardBlock } from "./output/tool-card-renderer.mjs";
 import { renderMarkdown, renderStreamingMarkdown } from "./markdown-renderer.mjs";
 import { renderEditDiffBlock } from "./tui-diff-rendering.mjs";
+import { restoreTimelineBlocksToOutputBuffer } from "./output/timeline-block-restore.mjs";
 import { OutputScrollState } from "./output/scroll-state.mjs";
 import { appendTextLines, wrapLine } from "./output/text-line-renderer.mjs";
 import { appendSelectableEntries, copySourceTextForRange, sliceEntriesWithTail } from "./output/selectable-copy.mjs";
@@ -89,6 +90,10 @@ export class OutputBuffer {
     this._baseEntriesCache = new Map();
   }
 
+  restoreTimelineBlocks(blocks) {
+    restoreTimelineBlocksToOutputBuffer(this, blocks);
+  }
+
   write(text) { this._writeText(text, false); }
   writeMarkdown(text) { this._writeText(text, true); }
 

package/src/cli/tui/tui-input-controller.mjs

@@ -40,6 +40,14 @@ export function createTuiInputController({ editor, requestRender, historyStore =
       requestRender();
     },
 
+    clearInput() {
+      attachmentTokens.clear();
+      editor.lastAction = null;
+      editor.historyIndex = -1;
+      setEditorText("");
+      requestRender();
+    },
+
     insertAttachmentAtCursor({ marker, label }) {
       const token = uniqueAttachmentToken(label || "[image]", attachmentTokens);
       attachmentTokens.set(token, marker);
@@ -59,4 +67,12 @@ export function createTuiInputController({ editor, requestRender, historyStore =
       historyStore?.save?.(editor.history);
     } catch {}
   }
+
+  function setEditorText(text) {
+    if (typeof editor.setTextInternal === "function") {
+      editor.setTextInternal(text);
+      return;
+    }
+    editor.setText?.(text);
+  }
 }

package/src/cli/ui.mjs

@@ -87,6 +87,7 @@ export function createTuiUI({
       thinkingSelector: () => onCtrlTHandler?.(),
       modelSelector: () => onCtrlLHandler?.(),
       externalEditor: () => openExternalEditor(),
+      clearInput: () => inputController.clearInput(),
       toggleToolOutput: () => toggleToolOutput(),
       toggleShellDrawer: () => shellDrawerControls.toggle(),
       nextShell: () => shellDrawerControls.selectNext(),
@@ -216,10 +217,13 @@ export function createTuiUI({
     },
 
     clearOutput: () => {
-      ensureStarted(); flushStreamDeltas(); spinnerStatus.stop(); retryStatus.stop(); output.clear(); requestRender();
+      ensureStarted(); flushStreamDeltas(); spinnerStatus.stop(); retryStatus.stop(); activeToolBlocks.length = 0; output.clear(); requestRender();
+    },
+    restoreTimelineBlocks: (blocks) => {
+      ensureStarted(); flushStreamDeltas(); spinnerStatus.stop(); retryStatus.stop(); activeToolBlocks.length = 0; output.restoreTimelineBlocks(blocks); requestRender();
     },
     restoreTranscript: (turns) => {
-      ensureStarted(); flushStreamDeltas(); spinnerStatus.stop(); retryStatus.stop(); output.clear(); writeTranscriptToOutput(output, turns); requestRender();
+      ensureStarted(); flushStreamDeltas(); spinnerStatus.stop(); retryStatus.stop(); activeToolBlocks.length = 0; output.clear(); writeTranscriptToOutput(output, turns); requestRender();
     },
 
     setStatusBar: (text) => {

package/src/cli/workspace/command.mjs

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import { brightBlack } from "../tui/ui-theme.mjs";
 import { registerProject, listRegisteredProjects } from "../../workspace/project-registry.mjs";
 import { buildWorkspaceSessionSelectItems, listWorkspaceSessions, workspaceSessionSearchText } from "../../workspace/session-index.mjs";
+import { SessionControllerLeaseConflictError } from "../../session/control/controller-lease.mjs";
 
 export const WORKSPACE_SLASH_COMMANDS = [
   {
@@ -93,6 +94,9 @@ export async function handleSessionCommand({ stateRoot, currentProjectId, runner
       ctxRenderActiveSession({ workspaceOutputRouter, projectId: item.project.projectId, sessionId: item.session.id });
       return { handled: true, refreshContextTokens: true, activeChanged: true };
     } catch (err) {
+      if (err instanceof SessionControllerLeaseConflictError) {
+        return await handleSessionControllerConflict({ err, item, workspaceSupervisor, workspaceOutputRouter, ui });
+      }
       ui.writeln(`Error: ${err.message}`);
       return { handled: true };
     }
@@ -101,6 +105,46 @@ export async function handleSessionCommand({ stateRoot, currentProjectId, runner
   return { handled: true };
 }
 
+async function handleSessionControllerConflict({ err, item, workspaceSupervisor, workspaceOutputRouter, ui }) {
+  ui.writeln(err.message);
+  if (!ui.selectList) return { handled: true };
+  const choice = await ui.selectList({
+    items: [
+      { value: "view-only", label: "View only", description: "inspect this session without taking control" },
+      { value: "take-over", label: "Take over control", description: "steal the controller lease for this session" },
+      { value: "cancel", label: "Cancel", description: "leave current controller unchanged" },
+    ],
+    selectedIndex: 0,
+    width: 70,
+    suppressInitialConfirm: true,
+  });
+  if (choice?.value === "view-only") {
+    try {
+      await workspaceSupervisor.viewWorkspaceSession({ project: item.project, session: item.session });
+      ctxRenderActiveSession({ workspaceOutputRouter, projectId: item.project.projectId, sessionId: item.session.id });
+      ui.writeln(`Viewing session: ${item.project.displayName} / ${item.session.name || item.session.id}`);
+      ui.writeln("View-only mode: prompts are disabled until you take over control.");
+      return { handled: true, refreshContextTokens: true, activeChanged: true };
+    } catch (viewErr) {
+      ui.writeln(`Error: ${viewErr.message}`);
+      return { handled: true };
+    }
+  }
+  if (choice?.value !== "take-over") {
+    ui.writeln("Session unchanged.");
+    return { handled: true };
+  }
+  try {
+    await workspaceSupervisor.activateWorkspaceSession({ project: item.project, session: item.session, force: true });
+    ctxRenderActiveSession({ workspaceOutputRouter, projectId: item.project.projectId, sessionId: item.session.id });
+    ui.writeln(`Took over session: ${item.project.displayName} / ${item.session.name || item.session.id}`);
+    return { handled: true, refreshContextTokens: true, activeChanged: true };
+  } catch (takeoverErr) {
+    ui.writeln(`Error: ${takeoverErr.message}`);
+    return { handled: true };
+  }
+}
+
 function annotateWorkspaceItems(items, runtimeSummaries) {
   if (!runtimeSummaries.length) return items;
   const running = new Set(runtimeSummaries.filter((runtime) => runtime.running).map((runtime) => `${runtime.projectId}:${runtime.sessionId}`));

package/src/cli/workspace/output-router.mjs

@@ -1,3 +1,7 @@
+import { createTuiTimelineRegistry } from "./tui-timeline.mjs";
+
+const PERSIST_FLUSH_METHODS = new Set(["turnEnd", "assistantReplyEnd", "toolEnd"]);
+
 const RENDER_METHODS = new Set([
   "turnStart",
   "turnEnd",
@@ -19,11 +23,18 @@ const RENDER_METHODS = new Set([
   "clearOutput",
 ]);
 
-const MAX_RENDER_EVENTS_PER_ROUTE = 4000;
-
-export function createWorkspaceOutputRouter({ ui, activeProjectId, activeSessionId = null, onRenderTimelineChange = null }) {
+export function createWorkspaceOutputRouter({
+  ui,
+  activeProjectId,
+  activeSessionId = null,
+  onPersistRenderTimeline = null,
+  persistDebounceMs,
+} = {}) {
   let active = routeKey(activeProjectId, activeSessionId);
-  const timelines = new Map();
+  const timelineRegistry = createTuiTimelineRegistry({
+    persistDebounceMs,
+    onPersistTimeline: (change) => onPersistRenderTimeline?.({ ...parseRouteKey(change.key), ...change }),
+  });
 
   return {
     setActiveProject(projectId) {
@@ -31,8 +42,9 @@ export function createWorkspaceOutputRouter({ ui, activeProjectId, activeSession
     },
     setActiveSession(projectId, sessionId, { renderTimeline = null } = {}) {
       const next = routeKey(projectId, sessionId);
-      if (Array.isArray(renderTimeline)) setRenderEvents(next, renderTimeline);
+      timelineRegistry.ensure(next, { events: renderTimeline });
       if (next === active) return renderRoute(next);
+      timelineRegistry.flush(active, "session-switch");
       active = next;
       return renderRoute(next);
     },
@@ -72,43 +84,43 @@ export function createWorkspaceOutputRouter({ ui, activeProjectId, activeSession
       return renderRoute(active);
     },
     getRenderEvents(projectId, sessionId = null) {
-      return [...(timelines.get(routeKey(projectId, sessionId)) ?? [])];
+      return timelineRegistry.getEvents(routeKey(projectId, sessionId));
+    },
+    getRenderBlocks(projectId, sessionId = null) {
+      return timelineRegistry.getBlocks(routeKey(projectId, sessionId));
     },
     setRenderEvents(projectId, sessionId = null, events = []) {
-      setRenderEvents(routeKey(projectId, sessionId), events);
+      const key = routeKey(projectId, sessionId);
+      timelineRegistry.replaceEvents(key, events);
     },
     getRenderEventCount(projectId, sessionId = null) {
-      return timelines.get(routeKey(projectId, sessionId))?.length ?? 0;
+      return timelineRegistry.getEventCount(routeKey(projectId, sessionId));
+    },
+    getRenderTimelineMetadata(projectId, sessionId = null) {
+      return timelineRegistry.getMetadata(routeKey(projectId, sessionId));
+    },
+    flushRenderTimeline(projectId, sessionId = null, reason = "manual") {
+      return timelineRegistry.flush(routeKey(projectId, sessionId), reason);
+    },
+    flushAllRenderTimelines(reason = "manual") {
+      return timelineRegistry.flushAll(reason);
     },
   };
 
   function renderRoute(key) {
-    ui.clearOutput?.();
-    const events = timelines.get(key) ?? [];
-    for (const event of events) applyRenderEvent(event);
-    return events.length;
-  }
-
-  function applyRenderEvent({ method, args }) {
-    const value = ui[method];
-    if (typeof value === "function") value.apply(ui, args);
+    const timeline = timelineRegistry.ensure(key);
+    if (typeof ui.restoreTimelineBlocks !== "function") ui.clearOutput?.();
+    return timeline.replayTo(ui);
   }
 
   function recordRenderEvent(key, method, args) {
     if (method === "clearOutput") {
-      timelines.delete(key);
-      onRenderTimelineChange?.({ ...parseRouteKey(key), events: [], event: { method, args } });
+      timelineRegistry.clear(key);
       return;
     }
-    const events = timelines.get(key) ?? [];
-    events.push({ method, args, at: Date.now() });
-    if (events.length > MAX_RENDER_EVENTS_PER_ROUTE) events.splice(0, events.length - MAX_RENDER_EVENTS_PER_ROUTE);
-    timelines.set(key, events);
-    onRenderTimelineChange?.({ ...parseRouteKey(key), events: [...events], event: { method, args } });
-  }
-
-  function setRenderEvents(key, events) {
-    timelines.set(key, normalizeRenderEvents(events));
+    const timeline = timelineRegistry.ensure(key);
+    timeline.apply(method, args);
+    if (PERSIST_FLUSH_METHODS.has(method)) timeline.flushPersist(method);
   }
 }
 
@@ -120,8 +132,3 @@ function parseRouteKey(key) {
   const [projectId, sessionId = ""] = String(key ?? "").split(":", 2);
   return { projectId: projectId || null, sessionId: sessionId || null };
 }
-
-function normalizeRenderEvents(events) {
-  if (!Array.isArray(events)) return [];
-  return events.filter((event) => typeof event?.method === "string" && Array.isArray(event.args));
-}

package/src/cli/workspace/tui-timeline-projection.mjs

@@ -0,0 +1,179 @@
+export function createTuiTimelineProjection() {
+  let blocks = [];
+  let openAssistantBlock = null;
+  let openThinkingBlock = null;
+  let openToolBlocks = [];
+  let nextBlockIndex = 1;
+
+  return {
+    apply(event) {
+      applyProjectionEvent(event);
+    },
+    rebuild(events) {
+      resetProjection();
+      for (const event of events) applyProjectionEvent(event);
+    },
+    clear() {
+      resetProjection();
+    },
+    getBlocks() {
+      return blocks.map((block) => structuredCloneSafe(block));
+    },
+    getMetadata() {
+      return {
+        blockCount: blocks.length,
+        openAssistant: Boolean(openAssistantBlock),
+        openThinking: Boolean(openThinkingBlock),
+        openToolCount: openToolBlocks.length,
+      };
+    },
+  };
+
+  function applyProjectionEvent(event) {
+    const [first, second, third] = event.args ?? [];
+    switch (event.method) {
+      case "turnStart":
+        closeAssistantBlock();
+        blocks.push(createBlock("turn", event.at, { phase: "start" }));
+        break;
+      case "turnEnd":
+        closeAssistantBlock(event.at);
+        closeThinkingBlock(event.at);
+        blocks.push(createBlock("turn", event.at, { phase: "end" }));
+        break;
+      case "textDelta":
+        ensureAssistantBlock(event.at).content += String(first ?? "");
+        touchBlock(openAssistantBlock, event.at);
+        break;
+      case "assistantReplyEnd":
+        closeAssistantBlock(event.at);
+        break;
+      case "thinkingStart":
+        closeThinkingBlock(event.at);
+        openThinkingBlock = createBlock("thinking", event.at, { content: "", closed: false });
+        blocks.push(openThinkingBlock);
+        break;
+      case "thinkingDelta":
+        ensureThinkingBlock(event.at).content += String(first ?? "");
+        touchBlock(openThinkingBlock, event.at);
+        break;
+      case "thinkingEnd":
+        ensureThinkingBlock(event.at).tokens = first ?? null;
+        closeThinkingBlock(event.at);
+        break;
+      case "thinkingBlock":
+        closeThinkingBlock(event.at);
+        blocks.push(createBlock("thinking", event.at, { tokens: first ?? null, content: String(second ?? ""), closed: true }));
+        break;
+      case "toolStart": {
+        closeAssistantBlock(event.at);
+        const block = createBlock("tool", event.at, { name: first ?? null, args: second ?? null, result: null, isError: false, closed: false });
+        blocks.push(block);
+        openToolBlocks.push(block);
+        break;
+      }
+      case "toolEnd": {
+        const block = popOpenToolBlock(first);
+        if (block) {
+          block.name ??= first ?? null;
+          block.isError = Boolean(second);
+          block.result = third ?? null;
+          block.closed = true;
+          touchBlock(block, event.at);
+        } else {
+          blocks.push(createBlock("tool", event.at, { name: first ?? null, isError: Boolean(second), result: third ?? null, closed: true }));
+        }
+        break;
+      }
+      case "write":
+      case "writeln":
+        closeAssistantBlock(event.at);
+        blocks.push(createBlock("output", event.at, { content: String(first ?? ""), newline: event.method === "writeln" }));
+        break;
+      case "status":
+        blocks.push(createBlock("status", event.at, { content: String(first ?? "") }));
+        break;
+      case "recall":
+        blocks.push(createBlock("recall", event.at, { hints: first?.hints ?? [] }));
+        break;
+      case "editDiff":
+        closeAssistantBlock(event.at);
+        blocks.push(createBlock("editDiff", event.at, { path: first ?? null, diffLines: second ?? [] }));
+        break;
+      case "retryStart":
+      case "retryEnd":
+        blocks.push(createBlock("retry", event.at, { method: event.method, payload: first ?? null }));
+        break;
+      default:
+        blocks.push(createBlock("event", event.at, { method: event.method, args: event.args ?? [] }));
+        break;
+    }
+  }
+
+  function ensureAssistantBlock(at) {
+    if (!openAssistantBlock) {
+      openAssistantBlock = createBlock("assistant", at, { content: "", closed: false });
+      blocks.push(openAssistantBlock);
+    }
+    return openAssistantBlock;
+  }
+
+  function closeAssistantBlock(at = null) {
+    if (!openAssistantBlock) return;
+    openAssistantBlock.closed = true;
+    touchBlock(openAssistantBlock, at);
+    openAssistantBlock = null;
+  }
+
+  function ensureThinkingBlock(at) {
+    if (!openThinkingBlock) {
+      openThinkingBlock = createBlock("thinking", at, { content: "", closed: false });
+      blocks.push(openThinkingBlock);
+    }
+    return openThinkingBlock;
+  }
+
+  function closeThinkingBlock(at = null) {
+    if (!openThinkingBlock) return;
+    openThinkingBlock.closed = true;
+    touchBlock(openThinkingBlock, at);
+    openThinkingBlock = null;
+  }
+
+  function popOpenToolBlock(name) {
+    if (openToolBlocks.length === 0) return null;
+    if (name == null) return openToolBlocks.pop();
+    const index = findLastIndex(openToolBlocks, (block) => block.name === name);
+    if (index < 0) return openToolBlocks.pop();
+    return openToolBlocks.splice(index, 1)[0];
+  }
+  function resetProjection() {
+    blocks = [];
+    openAssistantBlock = null;
+    openThinkingBlock = null;
+    openToolBlocks = [];
+    nextBlockIndex = 1;
+  }
+
+  function createBlock(type, at, fields = {}) {
+    const id = `${type}-${nextBlockIndex++}`;
+    return { id, type, createdAt: at ?? null, updatedAt: at ?? null, ...fields };
+  }
+}
+
+function touchBlock(block, at = null) {
+  if (!block || at == null) return;
+  block.updatedAt = at;
+}
+
+function findLastIndex(items, predicate) {
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    if (predicate(items[index], index)) return index;
+  }
+  return -1;
+}
+
+function structuredCloneSafe(value) {
+  if (typeof structuredClone === "function") return structuredClone(value);
+  return JSON.parse(JSON.stringify(value));
+}