aiden-runtime 4.1.3 → 4.1.4

package/dist/cli/v4/replyRenderer.js

@@ -27,10 +27,16 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getReplyRenderer = getReplyRenderer;
+exports.normalizeBlankLines = normalizeBlankLines;
 exports._resetForTests = _resetForTests;
 const marked_1 = require("marked");
 const skinEngine_1 = require("./skinEngine");
 const syntaxHighlight_1 = require("./syntaxHighlight");
+// v4.1.4 reply-quality polish: single source of truth for frame math.
+// Replaces 3 inline `Math.min(process.stdout.columns ?? 80, 100) - 4`
+// callsites in this file with `getBodyWidth()` and adds soft-wrap for
+// code-block lines that previously overflowed the viewport.
+const frame_1 = require("./display/frame");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const TerminalRenderer = require('marked-terminal').default ?? require('marked-terminal');
 function paint(kind) {
@@ -120,7 +126,11 @@ const CODE_BG_ON = '\x1b[48;2;50;50;60m';
 const CODE_BG_OFF = '\x1b[49m';
 function renderCodeBlock(code, lang) {
     const sk = (0, skinEngine_1.getSkinEngine)();
-    const width = Math.min(process.stdout.columns ?? 80, 100) - 4;
+    // v4.1.4 reply-quality polish: width sourced from frame.ts. Same
+    // visual budget as the v4.1.3 formula (cols capped at 100, minus
+    // gutter+2) — but expressed via the shared helper so it tracks any
+    // future width-policy change in one place.
+    const width = (0, frame_1.getBodyWidth)();
     const langLabel = (lang ?? '').trim();
     // v4.1.3-essentials reply-polish: language tag on the top rule
     // already shipped; keep it. Bottom rule unlabeled (closing fence).
@@ -131,26 +141,43 @@ function renderCodeBlock(code, lang) {
     const body = (0, syntaxHighlight_1.isSupportedLang)(langLabel)
         ? (0, syntaxHighlight_1.highlightCode)(code, langLabel)
         : code;
-    // v4.1.3-essentials reply-polish: each body line gets:
-    //   - 2-space outer indent (existing reply container indent)
+    // v4.1.4 reply-quality polish: per-line soft wrap. The rail + bg
+    // chrome adds 4 visible columns (` │ `, padding spaces around the
+    // line). Subtract those so wrap math targets the actual content
+    // budget. `hard: true` ensures even pathological long tokens
+    // (minified JS, hashes) break instead of escaping the frame.
+    //
+    // Width inside the body of a code line:
+    //   gutter (3) + `│ ` (2) + leading-space (1) + CONTENT + trailing-space (1)
+    // → content budget = width - gutter - 4. We further cap at width to
+    //   keep the fence rule aligned with the body's right margin.
+    const contentBudget = Math.max(8, width - frame_1.GUTTER - 4);
+    // v4.1.3-essentials reply-polish (preserved): each body line gets:
+    //   - frame gutter (was 2-space outer indent; now uses shared GUTTER)
     //   - left rail `│ ` painted muted (mirrors blockquote's `┃ ` rail
     //     with a different glyph so they're visually distinct)
     //   - 24-bit dark background wrapping the rail + content (subtle
     //     "this is code" affordance without going full TUI box-frame)
-    //
-    // Strip the optional ANSI-only NO_COLOR gate by emitting bg codes
-    // unconditionally — the skin engine already short-circuits inner
-    // paint calls when NO_COLOR is set, and bare bg codes degrade
-    // gracefully on terminals that don't render them.
     const rail = sk.applyColors('│', 'muted');
-    const indented = body
-        .split('\n')
-        .map((ln) => `  ${rail} ${CODE_BG_ON} ${ln} ${CODE_BG_OFF}`)
-        .join('\n');
+    const gutter = (0, frame_1.getIndent)(0);
+    // Wrap each source line independently — code-block semantics demand
+    // that a "logical line" remains visible as one continued unit even
+    // when soft-wrapped. The CODE_BG painting closes per VISUAL line so
+    // a wrap break doesn't bleed bg across the rail of the next row.
+    const wrappedLines = [];
+    for (const srcLine of body.split('\n')) {
+        const wrapped = (0, frame_1.wrap)(srcLine, contentBudget, { trim: false, hard: true });
+        for (const visualLine of wrapped.split('\n')) {
+            wrappedLines.push(`${gutter}${rail} ${CODE_BG_ON} ${visualLine} ${CODE_BG_OFF}`);
+        }
+    }
+    const indented = wrappedLines.join('\n');
+    // Top + bottom fence rules sit at the gutter too — visually anchors
+    // the block as a unit inside the assistant frame.
     return [
-        sk.applyColors(top, 'muted'),
+        `${gutter}${sk.applyColors(top, 'muted')}`,
         indented,
-        sk.applyColors(bot, 'muted'),
+        `${gutter}${sk.applyColors(bot, 'muted')}`,
         '',
     ].join('\n') + '\n';
 }
@@ -222,6 +249,97 @@ function renderHeading(text, depth) {
 function renderListItem(text) {
     return text;
 }
+/**
+ * v4.1.4 reply-quality polish — Fix C helper.
+ *
+ * Render a single list item's tokens correctly, expanding inline
+ * emphasis (strong, em, codespan) that the prior `parser.parse` path
+ * silently stranded as raw text.
+ *
+ * Marked v15 token shapes for list items:
+ *
+ *   Tight list (default — no blank lines between items):
+ *     list_item.tokens = [
+ *       { type: 'text', text: '**bold**',
+ *         tokens: [ { type: 'strong', ... } ]   ← inline children
+ *       }
+ *     ]
+ *
+ *   Loose list (blank line between items, OR an item with multiple
+ *   paragraphs):
+ *     list_item.tokens = [
+ *       { type: 'paragraph', tokens: [ inline children… ] },
+ *       { type: 'paragraph', tokens: [ … ] },
+ *     ]
+ *
+ *   Nested list (a list-token inside an item):
+ *     list_item.tokens = [
+ *       { type: 'text', tokens: [...] },   ← the item's own text first
+ *       { type: 'list', items: [...] },    ← then the nested list
+ *     ]
+ *
+ *   Item with fenced code block:
+ *     list_item.tokens = [
+ *       { type: 'text', ... },
+ *       { type: 'code', text: '…', lang: '…' },
+ *     ]
+ *
+ * Dispatch rules:
+ *   - `text` with nested `.tokens`     → parseInline(tokens)
+ *   - `text` with only `.text`          → fall through to raw text
+ *   - `paragraph`                       → parseInline(paragraph.tokens) + '\n'
+ *   - `list` / `code` / other block     → parser.parse([token]) (block path)
+ *
+ * Returns the joined rendered string. Pure-ish: depends on marked's
+ * parser instance (closure-captured) but never mutates it.
+ */
+function renderListItemTokens(it, parser) {
+    const toks = Array.isArray(it.tokens) ? it.tokens : [];
+    if (toks.length === 0)
+        return it.text ?? '';
+    const out = [];
+    for (const raw of toks) {
+        if (typeof raw !== 'object' || raw === null)
+            continue;
+        const tk = raw;
+        const type = tk.type;
+        // Inline-only wrapper (tight-list common case). The `text` outer
+        // token holds inline children we want to expand into ANSI.
+        if (type === 'text') {
+            if (Array.isArray(tk.tokens) && tk.tokens.length > 0 && parser.parseInline) {
+                out.push(parser.parseInline(tk.tokens));
+            }
+            else {
+                out.push(tk.text ?? '');
+            }
+            continue;
+        }
+        // Paragraph block (loose-list case). Marked wraps each paragraph's
+        // inline content in `.tokens`; render those inline + append a
+        // newline so multi-paragraph items stack visually.
+        if (type === 'paragraph') {
+            if (Array.isArray(tk.tokens) && tk.tokens.length > 0 && parser.parseInline) {
+                out.push(parser.parseInline(tk.tokens));
+                out.push('\n');
+            }
+            else {
+                out.push(tk.text ?? '');
+            }
+            continue;
+        }
+        // Nested list, fenced code, or any other block-level token. The
+        // block parser handles these via the normal dispatch (which calls
+        // back into our own `renderer.list` override for nested lists —
+        // depth counter is already incremented before we got here).
+        if (parser.parse) {
+            out.push(parser.parse([tk]));
+            continue;
+        }
+        // Last-resort fallback: drop the token's text in raw.
+        out.push(tk.text ?? '');
+    }
+    return out.join('');
+}
 /**
  * Singleton — caching is fine since options bind to the active skin
  * via paint callbacks (which read getSkinEngine() each call).
@@ -246,7 +364,7 @@ function getReplyRenderer() {
         // need for the 4-tier hierarchy. The prototype-level `renderer.heading`
         // override below owns the depth extraction + tier selection end-to-end.
         // marked-terminal's stripped-args call path never reaches our callback.
-        hr: () => paint('muted')('─'.repeat(Math.min(process.stdout.columns ?? 80, 100) - 4)) + '\n',
+        hr: () => paint('muted')('─'.repeat((0, frame_1.getBodyWidth)())) + '\n',
         listitem: renderListItem,
         paragraph: (text) => `${text}\n\n`,
         // v4.1.3-essentials: bold renders as ANSI bold + underline
@@ -274,7 +392,12 @@ function getReplyRenderer() {
         link: (assembled) => paint('accent')(assembled),
         href: paint('accent'),
         text: (text) => text,
-        width: Math.min(process.stdout.columns ?? 80, 100),
+        // v4.1.4 reply-quality polish: marked-terminal's `width` is the
+        // *outer* canvas it formats into. Frame-aware body width keeps the
+        // tables / hr / hard-wrap targets inside our gutter envelope.
+        // `reflowText: false` (below) stays off — we own prose wrap via
+        // frame.wrap() in the display layer, not here.
+        width: (0, frame_1.getBodyWidth)(),
         showSectionPrefix: false,
         reflowText: false,
         tab: 2,
@@ -417,17 +540,32 @@ function getReplyRenderer() {
             const tok = body;
             isOrdered = tok.ordered === true;
             startNum = typeof tok.start === 'number' ? tok.start : 1;
-            // marked v15: renderer instance has a `parser` field pointing
-            // back to the Parser; `Parser.parse(tokens)` walks the token
-            // tree dispatching back to renderer methods (including this
-            // very `list` override for nested lists, which is what makes
-            // the depth counter increment properly).
+            // v4.1.4 reply-quality polish — Fix C (token-type dispatch).
+            //
+            // Prior implementation called `parser.parse(it.tokens)` and let
+            // marked's block-parser dispatch each token. For tight-list items
+            // marked v15 wraps the item's content in a `text`-type outer
+            // token whose `.tokens` array holds the actual inline tokens
+            // (strong, em, codespan…). `parser.parse` dispatched the outer
+            // wrapper to `renderer.text` (our `opts.text` = identity), which
+            // returned the RAW raw `**bold**` source string — never recursing
+            // into the inline children. Result: literal asterisks in every
+            // bullet that contained inline emphasis.
+            //
+            // Fix: walk each top-level token by type. Tight-list items have
+            // a `text` wrapper → use `parseInline` on its nested tokens to
+            // expand strong/em/codespan. Loose-list items have block-level
+            // `paragraph`/`list`/`code` tokens → those need block-level
+            // recursion (delegates back to our list override for nested
+            // lists, preserving the depth counter).
+            //
+            // Confirmed against marked v15 token shapes from `marked.lexer`
+            // (see scripts/smoke-issue-c-tokens.ts).
             const parser = this.parser;
             items = (tok.items ?? []).map((it) => {
-                if (it.tokens && parser?.parse) {
-                    return parser.parse(it.tokens);
-                }
-                return it.text ?? '';
+                if (!parser)
+                    return it.text ?? '';
+                return renderListItemTokens(it, parser);
             });
         }
         else {
@@ -485,7 +623,21 @@ function getReplyRenderer() {
                 // if other code transiently swaps the renderer.
                 marked_1.marked.setOptions({ renderer: renderer });
                 const out = marked_1.marked.parse(text);
-                return typeof out === 'string' ? out : String(out);
+                const raw = typeof out === 'string' ? out : String(out);
+                // v4.1.4 Part 1.6 Issue I — collapse excess vertical spacing.
+                //
+                // Our `opts.paragraph` callback emits `text\n\n`, our
+                // `renderCodeBlock` ends with `\n\n`, and marked-terminal's
+                // outer block dispatch ALSO emits `\n\n` between adjacent
+                // blocks. Result: 4 newlines (3 visible blank lines) between
+                // paragraphs, after code blocks, between paragraphs and lists.
+                // Root-cause fix would require auditing marked-terminal's
+                // between-block separator across every override (risk-prone).
+                // Band-aid: collapse any run of 3+ newlines down to exactly 2
+                // (= one blank line). Mechanically safe — can only REMOVE
+                // excess whitespace, never add bad spacing. Existing single-
+                // blank-line gaps pass through unchanged.
+                return normalizeBlankLines(raw);
             }
             catch {
                 return text;
@@ -494,6 +646,24 @@ function getReplyRenderer() {
     };
     return cachedRenderer;
 }
+/**
+ * v4.1.4 Part 1.6 Issue I — collapse runs of 3+ consecutive newlines
+ * down to exactly 2 (a single blank line). Exported for unit-test
+ * access; pure with no side effects.
+ *
+ * Confirmed via `scripts/smoke-issue-i-spacing.ts`:
+ *   - "A\n\n\n\nB"    → "A\n\nB"     (2 paras → 1 blank line)
+ *   - "A\n\n\n\n\nB"  → "A\n\nB"     (3+ blanks all collapse)
+ *   - "A\n\nB"        → "A\n\nB"     (already correct, unchanged)
+ *   - "A\nB"          → "A\nB"       (single newline preserved)
+ *   - "A\n"           → "A\n"        (trailing pass-through)
+ *
+ * Does NOT touch the list-under-padding case (lists ending with a
+ * single `\n` before a paragraph) — that's a v4.1.5 follow-up.
+ */
+function normalizeBlankLines(text) {
+    return text.replace(/\n{3,}/g, '\n\n');
+}
 /** Test reset — drops the cached renderer so a skin change picks up. */
 function _resetForTests() {
     cachedRenderer = null;

package/dist/cli/v4/skinEngine.js

@@ -49,9 +49,15 @@ const DEFAULT_SKIN = {
         error: [0xf4, 0x47, 0x47],
         warn: [0xff, 0xc1, 0x07],
         success: [0x4c, 0xaf, 0x50],
-        // v4.1.3-repl-polish: muted is now true grey (#888) so it reads as
-        // genuinely secondary. The soft-cyan that was here moved to 'session'.
-        muted: [0x88, 0x88, 0x88],
+        // v4.1.4 reply-quality polish: muted shifts from neutral grey
+        // (#888888) to warm Aiden-tinted dim (#b8a89a). Mid-grey at +56
+        // brightness on red/green channels with a slight cool-down on
+        // blue, putting muted in the same warm family as brand orange
+        // (#FF6B35) without competing with it. Reads as "intentional
+        // dim" rather than washed-out terminal grey. Used by tool-trail
+        // gutter, status footer, code-block rail, blockquote rail, and
+        // display.dim() — surfaces the user reads constantly.
+        muted: [0xb8, 0xa8, 0x9a],
         heading: BRAND_ORANGE,
         // v4.1.3-repl-polish: session = soft cyan (ex-muted); used for IDs
         // and the session-end card header labels.
@@ -84,7 +90,12 @@ const LIGHT_SKIN = {
         error: [0xb0, 0x10, 0x10],
         warn: [0x80, 0x60, 0x00],
         success: [0x1b, 0x5e, 0x20],
-        muted: [0x60, 0x60, 0x60],
+        // v4.1.4 reply-quality polish: proportional warm-shift for the
+        // light skin too. Was neutral #606060; new value #7a6e5e keeps the
+        // dark-on-light contrast budget but adds the same warm tint as the
+        // default skin's muted so themed surfaces feel coherent across
+        // skin switches.
+        muted: [0x7a, 0x6e, 0x5e],
         heading: [0xc4, 0x42, 0x10],
         session: [0x00, 0x55, 0x88],
         degraded: [0x80, 0x60, 0x00],

package/dist/cli/v4/toolPreview.js

@@ -29,9 +29,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TOOL_PRIMARY_ARG = void 0;
 exports.buildToolPreview = buildToolPreview;
 /**
- * Map of tool-name → name of the property in `args` that should render
- * as the at-a-glance preview. Stable contract; tests assert specific
- * entries.
+ * Map of tool-name → preview extractor (string key OR function).
+ * Stable contract; tests assert specific entries.
  */
 exports.TOOL_PRIMARY_ARG = {
     // ── terminal / execution ─────────────────────────────────────────────
@@ -100,6 +99,37 @@ exports.TOOL_PRIMARY_ARG = {
     media_transport: 'target',
     media_key: 'action',
     app_input: 'app',
+    // ── v4.1.4 Phase 3b' (Issue H) ───────────────────────────────────────
+    // app_launch needs custom logic: when `app === 'explorer.exe'` the
+    // binary is just the URI dispatcher and the meaningful target is in
+    // `args[0]` (e.g. 'spotify:track/...'). Surface the protocol scheme
+    // ('spotify') rather than the dispatch binary. Falls through to the
+    // app name for normal exe launches.
+    app_launch: (args) => {
+        if (!args || typeof args !== 'object')
+            return '';
+        const a = args;
+        const appRaw = typeof a.app === 'string' ? a.app.trim() : '';
+        // URI-protocol case: explorer.exe + 'scheme:...' in args[0].
+        if (appRaw.toLowerCase() === 'explorer.exe' && Array.isArray(a.args)) {
+            const first = a.args[0];
+            if (typeof first === 'string' && first.length > 0) {
+                // Scheme requires ≥2 chars so Windows drive letters
+                // (`C:/path`) don't mis-detect as the scheme `C`. Real URI
+                // schemes (spotify, vscode, http, file, etc.) are all
+                // multi-char by RFC.
+                const m = first.match(/^([A-Za-z][A-Za-z0-9+.-]+):/);
+                if (m)
+                    return m[1]; // 'spotify:track/...' → 'spotify'
+                return first; // No protocol — surface the raw arg
+            }
+        }
+        return appRaw;
+    },
+    // Clipboard write — the actual text being copied is the meaningful
+    // target. Reads have no args worth showing (empty schema).
+    clipboard_write: 'text',
+    clipboard_read: '',
 };
 /**
  * Maximum visible characters for the preview value. Long commands /
@@ -121,28 +151,47 @@ function buildToolPreview(toolName, args) {
     if (!Object.prototype.hasOwnProperty.call(exports.TOOL_PRIMARY_ARG, toolName)) {
         return null;
     }
-    const argKey = exports.TOOL_PRIMARY_ARG[toolName];
-    if (argKey === '')
-        return '';
-    if (!args || typeof args !== 'object')
-        return '';
-    const raw = args[argKey];
-    if (raw === undefined || raw === null)
-        return '';
+    const extractor = exports.TOOL_PRIMARY_ARG[toolName];
+    // v4.1.4 Phase 3b' (Issue H1): function extractor path. Used by
+    // tools whose preview can't be expressed as a single key lookup
+    // (e.g. app_launch with URI-protocol routing through explorer.exe).
     let str;
-    if (typeof raw === 'string') {
-        str = raw;
-    }
-    else if (typeof raw === 'number' || typeof raw === 'boolean') {
-        str = String(raw);
-    }
-    else {
+    if (typeof extractor === 'function') {
         try {
-            str = JSON.stringify(raw);
+            const out = extractor(args);
+            str = typeof out === 'string' ? out : '';
         }
         catch {
+            // Extractor threw — degrade to empty preview rather than crash
+            // the tool-row render. The tool name + state cluster still
+            // carries enough info.
+            str = '';
+        }
+    }
+    else {
+        // String-key path (legacy, unchanged behaviour).
+        const argKey = extractor;
+        if (argKey === '')
+            return '';
+        if (!args || typeof args !== 'object')
+            return '';
+        const raw = args[argKey];
+        if (raw === undefined || raw === null)
+            return '';
+        if (typeof raw === 'string') {
+            str = raw;
+        }
+        else if (typeof raw === 'number' || typeof raw === 'boolean') {
             str = String(raw);
         }
+        else {
+            try {
+                str = JSON.stringify(raw);
+            }
+            catch {
+                str = String(raw);
+            }
+        }
     }
     // Collapse whitespace so multi-line commands stay on one preview row.
     str = str.replace(/\s+/g, ' ').trim();

package/dist/core/v4/aidenAgent.js

@@ -650,6 +650,15 @@ class AidenAgent {
             else if (evt.type === 'tool_call') {
                 runOptions.onToolCallStart?.(evt.toolCall);
             }
+            else if (evt.type === 'progress') {
+                // v4.1.4 Part 1.6 — drive the per-turn token progress bar.
+                // Defensive try/catch — a misbehaving display sink must not
+                // tear down the stream consumer.
+                try {
+                    runOptions.onProgress?.(evt.outputTokens, evt.maxTokens);
+                }
+                catch { /* progress sink errors don't block streaming */ }
+            }
             else if (evt.type === 'done') {
                 finalOutput = evt.output;
             }

package/dist/core/v4/promptBuilder.js

@@ -128,7 +128,8 @@ const EXECUTION_DISCIPLINE_PROSE = [
     'file"), you MUST immediately make the corresponding tool call in the same response.',
     'Never end your turn with a promise of future action — execute it now. Every',
     'response should either contain tool calls that make progress, or deliver a final',
-    'result. Responses that only describe intentions without acting are not acceptable.',
+    'result. When the user requests an action, take it. When the user requests',
+    'discussion, discuss.',
 ].join('\n');
 /**
  * Llama-3.3-specific tool-call format guard. Adapter-side recovery picks

package/dist/core/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // AUTO-GENERATED by scripts/inject-version.js — do not edit by hand
-exports.VERSION = '4.1.3';
+exports.VERSION = '4.1.4';

package/dist/providers/v4/anthropicAdapter.js

@@ -114,7 +114,7 @@ class AnthropicAdapter {
             };
             return;
         }
-        yield* decodeStream(reply.body);
+        yield* decodeStream(reply.body, input.maxTokens ?? DEFAULT_MAX_TOKENS);
     }
     // ── Request body assembly ────────────────────────────────────────────────
     buildBody(input, streaming) {
@@ -404,13 +404,20 @@ function decodeUsage(u) {
     }
     return out;
 }
-async function* decodeStream(body) {
+async function* decodeStream(body, maxTokens) {
     const blocks = new Map();
     const toolCalls = [];
     let stopReason;
     let usage = undefined;
     // Stable text emission order: walk content blocks by index at end-of-stream.
     const textOrder = [];
+    // v4.1.4 Part 1.6: track the last-emitted output-token count so we
+    // only yield a `progress` event when the counter actually advances.
+    // Anthropic emits `message_delta.usage.output_tokens` as a running
+    // total — multiple deltas may carry the same value if no new tokens
+    // were produced between them. Deduping keeps the event stream
+    // proportional to real progress.
+    let lastProgressEmitted = -1;
     for await (const payload of (0, chatCompletionsAdapter_1.parseSseStream)(body)) {
         if (!payload || payload === '[DONE]')
             continue;
@@ -490,6 +497,22 @@ async function* decodeStream(body) {
                     stopReason = evt.delta.stop_reason;
                 if (evt.usage) {
                     usage = { ...(usage ?? {}), ...evt.usage };
+                    // v4.1.4 Part 1.6 — emit a `progress` event when the running
+                    // output-token counter advances. The display layer uses these
+                    // for the ▰▱ progress bar. Deduped via `lastProgressEmitted`
+                    // so a stream of message_delta events with no real progress
+                    // doesn't flood the consumer.
+                    const outputTokens = typeof evt.usage.output_tokens === 'number'
+                        ? evt.usage.output_tokens
+                        : -1;
+                    if (outputTokens > lastProgressEmitted) {
+                        lastProgressEmitted = outputTokens;
+                        yield {
+                            type: 'progress',
+                            outputTokens,
+                            maxTokens,
+                        };
+                    }
                 }
                 break;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-runtime",
-  "version": "4.1.3",
+  "version": "4.1.4",
   "publishConfig": {
     "access": "public"
   },
@@ -277,6 +277,7 @@
     "twilio": "^5.13.1",
     "uuid": "^9.0.0",
     "whatsapp-web.js": "^1.26.0",
+    "wrap-ansi": "^9.0.2",
     "ws": "^8.20.0"
   },
   "optionalDependencies": {