omnius 1.0.333 → 1.0.335

package/dist/index.js

@@ -279541,19 +279541,26 @@ import { execFileSync as execFileSync6 } from "node:child_process";
 import { existsSync as existsSync42, readFileSync as readFileSync31, writeFileSync as writeFileSync21, mkdirSync as mkdirSync23, statfsSync as statfsSync3 } from "node:fs";
 import { join as join51 } from "node:path";
 import { cpus, totalmem as totalmem2 } from "node:os";
+function gpuComputeUsable(computeCap) {
+  if (!computeCap)
+    return true;
+  const v = parseFloat(computeCap);
+  return Number.isFinite(v) ? v >= MIN_COMPUTE_CAP : true;
+}
 function bytesToGiB(bytes) {
   return Math.round(bytes / 1024 ** 3 * 10) / 10;
 }
 function probeGpus() {
   try {
-    const out = execFileSync6("nvidia-smi", ["--query-gpu=index,name,memory.total,memory.free", "--format=csv,noheader,nounits"], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] });
+    const out = execFileSync6("nvidia-smi", ["--query-gpu=index,name,memory.total,memory.free,compute_cap", "--format=csv,noheader,nounits"], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] });
     return out.trim().split("\n").map((line) => {
-      const [index, name10, total, free] = line.split(",").map((s2) => s2.trim());
+      const [index, name10, total, free, cap] = line.split(",").map((s2) => s2.trim());
       return {
         index: parseInt(index || "0", 10),
         name: name10 || "GPU",
         memTotalMiB: parseInt(total || "0", 10),
-        memFreeMiB: parseInt(free || "0", 10)
+        memFreeMiB: parseInt(free || "0", 10),
+        computeCap: cap || ""
       };
     }).filter((g) => Number.isFinite(g.memTotalMiB) && g.memTotalMiB > 0);
   } catch {
@@ -279577,9 +279584,10 @@ function diskFreeGiB(path12) {
   }
 }
 function selectStack(facts) {
-  const usable = facts.gpus.filter((g) => g.memTotalMiB >= USABLE_GPU_MIN_MIB);
+  const usable = facts.gpus.filter((g) => g.memTotalMiB >= USABLE_GPU_MIN_MIB && gpuComputeUsable(g.computeCap));
   const maxVramGiB = usable.length > 0 ? Math.round(Math.max(...usable.map((g) => g.memTotalMiB)) / 1024) : 0;
   const gpuCount = usable.length;
+  const cudaVisibleDevices = usable.map((g) => g.index).join(",");
   if (gpuCount === 0) {
     return {
       stack: "edge",
@@ -279587,7 +279595,8 @@ function selectStack(facts) {
       precision: "fp32",
       vramGiB: 0,
       gpuCount: 0,
-      reason: `No usable GPU (>=8 GiB) detected; CPU edge stack on ${facts.cpuCores} cores / ${facts.ramGiB} GiB RAM.`
+      cudaVisibleDevices: "",
+      reason: `No usable GPU (>=8 GiB, compute>=7.0) detected; CPU edge stack on ${facts.cpuCores} cores / ${facts.ramGiB} GiB RAM.`
     };
   }
   const precision = maxVramGiB >= 24 ? "bf16" : "fp16";
@@ -279598,7 +279607,8 @@ function selectStack(facts) {
       precision,
       vramGiB: maxVramGiB,
       gpuCount,
-      reason: `Forensic stack: ${gpuCount} usable GPU(s), max ${maxVramGiB} GiB VRAM — multi-pass + thinking-variant LALM + high-res reinspection.`
+      cudaVisibleDevices,
+      reason: `Forensic stack: ${gpuCount} usable GPU(s) [${cudaVisibleDevices}], max ${maxVramGiB} GiB VRAM — multi-pass + thinking-variant LALM + high-res reinspection.`
     };
   }
   if (maxVramGiB >= 16) {
@@ -279608,7 +279618,8 @@ function selectStack(facts) {
       precision,
       vramGiB: maxVramGiB,
       gpuCount,
-      reason: `Baseline stack: one ${maxVramGiB} GiB GPU — V-JEPA2-L/VideoPrism + YOLOE+SAM2 + event-triggered 7B VLM/LALM.`
+      cudaVisibleDevices,
+      reason: `Baseline stack: one ${maxVramGiB} GiB GPU [${cudaVisibleDevices}] — V-JEPA2-L/VideoPrism + YOLOE+SAM2 + event-triggered 7B VLM/LALM.`
     };
   }
   return {
@@ -279617,7 +279628,8 @@ function selectStack(facts) {
     precision,
     vramGiB: maxVramGiB,
     gpuCount,
-    reason: `Edge stack on GPU: only ${maxVramGiB} GiB VRAM — keyframe detectors + lite encoders, small models on event windows.`
+    cudaVisibleDevices,
+    reason: `Edge stack on GPU [${cudaVisibleDevices}]: only ${maxVramGiB} GiB VRAM — keyframe detectors + lite encoders, small models on event windows.`
   };
 }
 function adapterPlacement(cap, role) {
@@ -279664,11 +279676,12 @@ function getMediaCapability(opts = {}) {
   }
   return cap;
 }
-var USABLE_GPU_MIN_MIB, CACHE_FILE2, CACHE_TTL_MS2;
+var MIN_COMPUTE_CAP, USABLE_GPU_MIN_MIB, CACHE_FILE2, CACHE_TTL_MS2;
 var init_media_capability = __esm({
   "packages/execution/dist/av/media-capability.js"() {
     "use strict";
     init_model_store();
+    MIN_COMPUTE_CAP = 7;
     USABLE_GPU_MIN_MIB = 8 * 1024;
     CACHE_FILE2 = "av-capability.json";
     CACHE_TTL_MS2 = 60 * 60 * 1e3;
@@ -553530,6 +553543,7 @@ __export(dist_exports2, {
   gigabytesToBytes: () => gigabytesToBytes,
   globalMediaDir: () => globalMediaDir,
   globalMediaRootDir: () => globalMediaRootDir,
+  gpuComputeUsable: () => gpuComputeUsable,
   hasMaterialAmbiguity: () => hasMaterialAmbiguity,
   hashGeneratedArtifactContent: () => hashGeneratedArtifactContent,
   hashProcessCommand: () => hashProcessCommand,
@@ -599722,8 +599736,8 @@ function codePreviewLines(output, maxLines) {
     return [{ text: "(empty file)", mode: "wrap", kind: "dim" }];
   let hlLines = null;
   if (isAvailable()) {
-    const codeBlock = shown.join("\n");
-    const hl = highlightBlock(codeBlock);
+    const codeBlock2 = shown.join("\n");
+    const hl = highlightBlock(codeBlock2);
     if (hl.length === shown.length) hlLines = hl;
   }
   const body = shown.map((line, i2) => ({
@@ -610144,6 +610158,34 @@ var init_status_bar = __esm({
       unregisterDynamicBlock(id) {
         this._dynamicBlocks.delete(id);
       }
+      /**
+       * Expand every dynamic-block sentinel in `lines` into its registered render
+       * output. Used at SESSION-SAVE time so the persisted transcript carries the
+       * REAL tool / shell / task-complete content instead of `\x01DYNBLOCK:<id>\x01`
+       * sentinels whose content otherwise lives only in this in-memory store and is
+       * lost on reload. Stale/unknown sentinels are dropped (not left as dead
+       * markers). ANSI is stripped by the persistence layer afterwards.
+       */
+      expandDynamicBlockSentinels(lines, width = 100) {
+        const out = [];
+        for (const line of lines) {
+          if (typeof line === "string" && line.startsWith(this.DYNAMIC_BLOCK_MARK_PREFIX) && line.endsWith(this.DYNAMIC_BLOCK_MARK_SUFFIX) && line.length > this.DYNAMIC_BLOCK_MARK_PREFIX.length + this.DYNAMIC_BLOCK_MARK_SUFFIX.length) {
+            const id = line.slice(
+              this.DYNAMIC_BLOCK_MARK_PREFIX.length,
+              line.length - this.DYNAMIC_BLOCK_MARK_SUFFIX.length
+            );
+            const renderer = this._dynamicBlocks.get(id);
+            if (!renderer) continue;
+            try {
+              for (const seg of renderer(width)) out.push(seg);
+            } catch {
+            }
+          } else {
+            out.push(line);
+          }
+        }
+        return out;
+      }
       /**
        * Append a previously-registered dynamic block's sentinel to scrollback
        * and trigger a repaint. The block's renderer fires immediately at the
@@ -654909,6 +654951,140 @@ var init_emotion_engine = __esm({
   }
 });
 
+// packages/cli/src/tui/telegram-format.ts
+function escapeHtml2(text2) {
+  return String(text2 ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function toolCallBlock(name10, args) {
+  const header = `<b>Tool call</b> <code>${escapeHtml2(name10 || "tool")}</code>`;
+  if (args == null || typeof args === "object" && Object.keys(args).length === 0) {
+    return header;
+  }
+  const compact3 = typeof args === "string" ? args : safeJson(args, false);
+  if (compact3.length <= 120 && !compact3.includes("\n")) {
+    return `${header} <code>${escapeHtml2(compact3)}</code>`;
+  }
+  const pretty = typeof args === "string" ? args : safeJson(args, true);
+  return `${header}
+${codeBlock(pretty, "json")}`;
+}
+function toolResultBlock(name10, ok3, output) {
+  const header = `<b>Tool result</b> <code>${escapeHtml2(name10 || "tool")}</code>`;
+  const body = String(output ?? "").trim();
+  if (!body) return `${header}
+<i>${ok3 ? "completed" : "failed"}</i>`;
+  if (body.length <= 160 && !body.includes("\n")) {
+    return `${header}
+<blockquote>${escapeHtml2(body)}</blockquote>`;
+  }
+  return `${header}
+<blockquote expandable>${escapeHtml2(body)}</blockquote>`;
+}
+function codeBlock(code8, language = "") {
+  const inner = escapeHtml2(String(code8 ?? "").replace(/\s+$/, ""));
+  return language ? `<pre><code class="language-${escapeHtml2(language)}">${inner}</code></pre>` : `<pre>${inner}</pre>`;
+}
+function safeJson(v, pretty) {
+  try {
+    return pretty ? JSON.stringify(v, null, 2) : JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+function tokenizeTelegramHtml(html) {
+  const tokens = [];
+  const re = /<(\/?)([a-zA-Z][\w-]*)((?:\s[^>]*)?)>/g;
+  let last2 = 0;
+  let m2;
+  while ((m2 = re.exec(html)) !== null) {
+    if (m2.index > last2) tokens.push({ type: "text", raw: html.slice(last2, m2.index) });
+    const closing = m2[1] === "/";
+    const tag = (m2[2] || "").toLowerCase();
+    if (SPAN_TAGS.has(tag)) {
+      tokens.push(closing ? { type: "close", tag, raw: m2[0] } : { type: "open", tag, raw: m2[0] });
+    } else {
+      tokens.push({ type: "text", raw: m2[0] });
+    }
+    last2 = re.lastIndex;
+  }
+  if (last2 < html.length) tokens.push({ type: "text", raw: html.slice(last2) });
+  return tokens;
+}
+function segmentTelegramHtml(html, maxLength = SAFE_LIMIT) {
+  const text2 = String(html ?? "");
+  if (text2.length <= maxLength) return text2.trim() ? [text2] : [];
+  const tokens = tokenizeTelegramHtml(text2);
+  const out = [];
+  let cur = "";
+  const stack = [];
+  const closeAll = () => stack.slice().reverse().map((t2) => `</${t2.tag}>`).join("");
+  const reopen = () => stack.map((t2) => t2.raw).join("");
+  const closeLen = () => stack.reduce((n2, t2) => n2 + t2.tag.length + 3, 0);
+  const flush3 = () => {
+    const finished = cur + closeAll();
+    if (finished.trim()) out.push(finished);
+    cur = reopen();
+  };
+  for (const tok of tokens) {
+    if (tok.type === "open") {
+      if (cur.length + tok.raw.length + closeLen() > maxLength) flush3();
+      cur += tok.raw;
+      stack.push({ tag: tok.tag, raw: tok.raw });
+    } else if (tok.type === "close") {
+      cur += tok.raw;
+      for (let i2 = stack.length - 1; i2 >= 0; i2--) {
+        if (stack[i2].tag === tok.tag) {
+          stack.splice(i2, 1);
+          break;
+        }
+      }
+    } else {
+      let body = tok.raw;
+      while (cur.length + body.length + closeLen() > maxLength) {
+        const room = maxLength - cur.length - closeLen();
+        if (room <= 1) {
+          flush3();
+          continue;
+        }
+        let bp = body.lastIndexOf("\n", room);
+        if (bp < room * 0.5) bp = body.lastIndexOf(" ", room);
+        if (bp < room * 0.5) bp = room;
+        cur += body.slice(0, bp);
+        flush3();
+        body = body.slice(bp).replace(/^\s+/, "");
+      }
+      cur += body;
+    }
+  }
+  const tail = cur + closeAll();
+  if (tail.trim()) out.push(tail);
+  return out;
+}
+var SAFE_LIMIT, SPAN_TAGS;
+var init_telegram_format = __esm({
+  "packages/cli/src/tui/telegram-format.ts"() {
+    "use strict";
+    SAFE_LIMIT = 3900;
+    SPAN_TAGS = /* @__PURE__ */ new Set([
+      "b",
+      "strong",
+      "i",
+      "em",
+      "u",
+      "ins",
+      "s",
+      "strike",
+      "del",
+      "code",
+      "pre",
+      "blockquote",
+      "tg-spoiler",
+      "a",
+      "span"
+    ]);
+  }
+});
+
 // packages/cli/src/tui/tool-policy.ts
 function getDefaultPolicy(context2) {
   switch (context2) {
@@ -660540,8 +660716,8 @@ function convertMarkdownToTelegramHTML(md) {
   let html = normalizeTelegramOutboundLinks(md);
   html = html.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
   html = html.replace(
-    /```[\w]*\n([\s\S]*?)```/g,
-    (_m, code8) => `<pre>${code8.trimEnd()}</pre>`
+    /```([\w+-]*)\n?([\s\S]*?)```/g,
+    (_m, lang, code8) => lang ? `<pre><code class="language-${lang}">${code8.trimEnd()}</code></pre>` : `<pre>${code8.trimEnd()}</pre>`
   );
   html = html.replace(/`([^`]+)`/g, "<code>$1</code>");
   html = html.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
@@ -660590,6 +660766,9 @@ function truncateTelegramUrlSafe(text2, maxLength, suffix = "...") {
 function splitTelegramMessageText(text2, maxLength = 3900) {
   const trimmed = text2.trim();
   if (!trimmed) return [];
+  if (/<\/?[a-zA-Z][\w-]*(?:\s[^>]*)?>/.test(trimmed)) {
+    return segmentTelegramHtml(trimmed, maxLength);
+  }
   const chunks = [];
   let remaining = trimmed;
   while (remaining.length > maxLength) {
@@ -661038,20 +661217,12 @@ function formatTelegramProgressEvent(event) {
   if (event.type === "tool_result" && event.toolName === "task_complete")
     return null;
   if (event.type === "tool_call") {
-    return `<b>Tool call</b> <code>${escapeTelegramHTML(event.toolName || "tool")}</code>`;
+    return toolCallBlock(event.toolName || "tool");
   }
   if (event.type === "tool_result") {
-    const preview = sanitizeTelegramProgressText(event.content || "", 180);
+    const preview = sanitizeTelegramProgressText(event.content || "", 1500);
     if (isTelegramInternalStatusText(preview)) return null;
-    const toolName = escapeTelegramHTML(event.toolName || "tool");
-    if (preview) {
-      return [
-        `<b>Tool result</b> <code>${toolName}</code>`,
-        `<blockquote>${escapeTelegramHTML(preview)}</blockquote>`
-      ].join("\n");
-    }
-    return `<b>Tool result</b> <code>${toolName}</code>
-<i>${event.success ? "completed" : "failed"}</i>`;
+    return toolResultBlock(event.toolName || "tool", Boolean(event.success), preview);
   }
   if (event.type === "status") {
     if (isCodebaseMemoryStatus(event.content || "")) {
@@ -662165,6 +662336,7 @@ var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTAT
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
+    init_telegram_format();
     init_dist8();
     init_dist5();
     init_project_context();
@@ -693946,6 +694118,64 @@ window.refreshTodos = refreshTodos;
 //   own process group)
 // - Frontend re-attaches via this restore path and shows the partial
 //   output via partial_output_tail in the in_flight payload
+// Parse a raw rendered-TUI transcript into clean GUI chat bubbles. Strips the
+// 
DYNBLOCK:<id>
 sentinels (no content in the persisted log) and TUI
+// chrome, then emits user (▹/>) and assistant (│) messages.
+function renderRecoveredTranscript(raw, conv, title) {
+  const SOH = String.fromCharCode(1);
+  const NL = String.fromCharCode(10);
+  const sentRe = new RegExp(SOH + 'DYNBLOCK:[^' + SOH + ']*' + SOH, 'g');
+  const lines = String(raw).replace(new RegExp(String.fromCharCode(13), 'g'), '').split(NL);
+  let mode = null;        // 'user' | 'assistant'
+  let buf = [];
+  let toolCount = 0;
+  const out = [];         // [{role, text}] or {tools:n}
+  const flush = () => {
+    const text = buf.join(NL).trim();
+    if (text && mode) out.push({ role: mode, text: text });
+    buf = [];
+  };
+  for (let line of lines) {
+    // Count + drop dynamic-block sentinels (tool/shell/etc. — their content is
+    // not in the log; surface them as a compact "tool activity" marker).
+    const sentinels = (line.match(sentRe) || []).length;
+    if (sentinels) toolCount += sentinels;
+    line = line.replace(sentRe, '');
+    const t = line.trim();
+    if (!t) continue;
+    // Skip pure box-border lines from expanded tool/task boxes (╭─╮ ╰─╯ etc.).
+    if (/^[─-╿s]+$/.test(t)) continue;
+    if (/^[▹>]s?/.test(t)) {                         // user prompt
+      flush(); if (toolCount) { out.push({ tools: toolCount }); toolCount = 0; }
+      out.push({ role: 'user', text: t.replace(/^[▹>]s?/, '') }); mode = null; continue;
+    }
+    if (/^│/.test(t)) {                               // assistant / box content
+      if (mode !== 'assistant') { flush(); mode = 'assistant'; }
+      buf.push(t.replace(/^│s?/, '').replace(/s?│$/, '')); continue;  // strip both borders
+    }
+    if (/^[∙!]/.test(t)) continue;                    // status / internal noise — drop
+    if (mode === 'assistant') buf.push(t);            // continuation
+  }
+  flush(); if (toolCount) out.push({ tools: toolCount });
+
+  if (out.length === 0) return; // nothing meaningful — show nothing rather than garbage
+  const note = document.createElement('div');
+  note.style.cssText = 'font-size:0.6rem;color:var(--color-fg-faint);margin:4px 0 8px;text-align:center';
+  note.textContent = 'recovered session' + (title ? ' — ' + title : '');
+  conv.appendChild(note);
+  for (const item of out) {
+    if (item.tools) {
+      const td = document.createElement('div');
+      td.style.cssText = 'font-size:0.6rem;color:var(--color-fg-faint);margin:2px 0 6px;padding-left:8px';
+      td.textContent = '⚙ ' + item.tools + ' tool action' + (item.tools === 1 ? '' : 's');
+      conv.appendChild(td);
+    } else {
+      addMessage(item.role, item.text);
+    }
+  }
+}
+window.renderRecoveredTranscript = renderRecoveredTranscript;
+
 async function restoreChatSession() {
   // chatSessionId is the window-property shim → $chatSessionId.get().
   // Project-scoped storage already hydrated this on $currentProject.set,
@@ -693982,18 +694212,15 @@ async function restoreChatSession() {
       // decisions, sub-agent activity — everything that scrolled past in the
       // TUI) as a visible, scrollable block at the top so opening the session
       // actually shows what happened, instead of just a "loaded" notice.
-      if (data.transcript && String(data.transcript).trim() && data.transcript !== '(empty transcript)') {
-        const wrap = document.createElement('div');
-        wrap.style.cssText = 'margin:6px 0 14px';
-        const head = document.createElement('div');
-        head.style.cssText = 'font-size:0.66rem;color:var(--color-fg-muted);margin-bottom:4px;display:flex;justify-content:space-between;align-items:center';
-        head.innerHTML = '<span>Recovered session transcript' + (data.title ? ' — ' + escapeHtml(data.title) : '') + '</span>';
-        const pre = document.createElement('pre');
-        pre.style.cssText = 'max-height:380px;overflow:auto;background:var(--color-bg-elevated);border:1px solid var(--color-border);border-radius:var(--radius-sm);padding:10px 12px;font-size:0.7rem;line-height:1.35;white-space:pre-wrap;word-break:break-word;color:var(--color-fg-muted);margin:0';
-        pre.textContent = String(data.transcript);
-        wrap.appendChild(head);
-        wrap.appendChild(pre);
-        conv.appendChild(wrap);
+      if (data.transcript && String(data.transcript).trim() && data.transcript !== '(empty transcript)'
+          && (!allMessages || allMessages.length === 0)) {
+        // TUI/raw transcript: PARSE the rendered-TUI scrollback into real chat
+        // bubbles instead of dumping the raw log. The persisted log carries
+        // 
DYNBLOCK:<id>
 sentinels (dynamic blocks expanded only at TUI
+        // paint time — no content here) plus chrome (▹ user, │ assistant,
+        // ∙ status, ! internal). We strip the dead sentinels + noise and emit
+        // user/assistant messages so it reads like a GUI chat.
+        renderRecoveredTranscript(String(data.transcript), conv, data.title || '');
       }
       // WO-CHAT-RESUME-TOOLS — replay the FULL intermediate flow on
       // restore: user/assistant text bubbles AND tool_call/tool_result
@@ -711978,7 +712205,8 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
         }
         try {
           const historySessionId = process.env["OMNIUS_SESSION_ID"] || `session-${Date.now().toString(36)}`;
-          const contentLines = statusBar?._contentLines ?? [];
+          const rawContentLines = statusBar?._contentLines ?? [];
+          const contentLines = typeof statusBar?.expandDynamicBlockSentinels === "function" ? statusBar.expandDynamicBlockSentinels(rawContentLines, 100) : rawContentLines;
           if (contentLines.length > 0) {
             const description = cleanPromptForDiary(task).slice(0, 240);
             const historyTitle = description.slice(0, 80) || void 0;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.333",
+  "version": "1.0.335",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.333",
+      "version": "1.0.335",
       "bundleDependencies": [
         "image-to-ascii"
       ],
@@ -3986,9 +3986,9 @@
       }
     },
     "node_modules/hono": {
-      "version": "4.12.26",
-      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.26.tgz",
-      "integrity": "sha512-uyZtpnYxM9CmQ7QsQknM4zN8EftNqhON1qYeIKM0Se67CCEe2c44xyGURwB0axX2fBDu1dqHrHAc1hmNT8ITkw==",
+      "version": "4.12.27",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.27.tgz",
+      "integrity": "sha512-1yrb/+w6HWQJrUCLkJ2IF5jNIPvvFkblV5RNOYl6bV+OA6p9GLcMpHFFGTosSvHvcAUibuUukRqhlYI4z32C7Q==",
       "license": "MIT",
       "engines": {
         "node": ">=16.9.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.333",
+  "version": "1.0.335",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",