arisa 4.3.4 → 5.0.2

package/test/doctor.test.js

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { formatDoctorReport, runDoctor } from "../src/runtime/doctor.js";
+import { serviceEntryFile } from "../src/runtime/service-manager.js";
+
+const doctorPolicy = {
+  contextInspectionTimeoutMs: 1_000,
+  contextWarningPercent: 70,
+  contextCriticalPercent: 90,
+  contextInefficientMinTokens: 32_000,
+  contextToolResultWarningPercent: 60,
+  contextSingleMessageWarningPercent: 50
+};
+
+const daemonPolicy = {
+  healthTimeoutMs: 1_000,
+  stopTimeoutMs: 1_000
+};
+
+function runtime(overrides = {}) {
+  return {
+    harness: "pi",
+    sessions: 1,
+    closingSessions: 0,
+    managedProcessIds: [],
+    contexts: [],
+    ...overrides
+  };
+}
+
+async function run({ diagnostic = runtime(), processes = [], service = { running: false }, repairs = [] } = {}) {
+  const stopped = [];
+  const report = await runDoctor({
+    agentManager: { getRuntimeDiagnostic: async () => diagnostic },
+    toolProcessSupervisor: { repair: async () => repairs },
+    daemonPolicy,
+    doctorPolicy,
+    listProcesses: async () => processes,
+    serviceStatus: async () => service,
+    stopProcess: async (pid) => { stopped.push(pid); },
+    stopDaemon: async () => {},
+    unregisterDaemon: async () => {}
+  });
+  return { report, stopped };
+}
+
+test("reports Pi context size and retained-content inefficiency", async () => {
+  const { report } = await run({
+    diagnostic: runtime({
+      contexts: [{
+        chatId: "42",
+        messages: 20,
+        estimatedTokens: 40_000,
+        toolResultPercent: 70,
+        largestMessagePercent: 10,
+        tokens: 80_000,
+        contextWindow: 100_000,
+        percent: 80
+      }]
+    })
+  });
+
+  assert.equal(report.contexts[0].level, "warning");
+  assert.match(report.attention.join("\n"), /80,000\/100,000 tokens/);
+  assert.match(report.attention.join("\n"), /tool results occupy 70\.0%/);
+  assert.match(formatDoctorReport(report), /Core: Pi, 1 active session/);
+});
+
+test("stops only a registered duplicate Arisa service with verified identity", async () => {
+  const duplicatePid = 321;
+  const { report, stopped } = await run({
+    processes: [{ pid: duplicatePid, command: `${process.execPath} ${serviceEntryFile} --service-runner` }],
+    service: { running: true, pid: duplicatePid }
+  });
+
+  assert.deepEqual(stopped, [duplicatePid]);
+  assert.match(report.repairs.join("\n"), /Stopped duplicate Arisa service process 321/);
+});
+
+test("requires complete positive doctor context policy", async () => {
+  await assert.rejects(
+    runDoctor({
+      agentManager: { getRuntimeDiagnostic: async () => runtime() },
+      toolProcessSupervisor: { repair: async () => [] },
+      daemonPolicy,
+      doctorPolicy: { ...doctorPolicy, contextInspectionTimeoutMs: 0 }
+    }),
+    /positive contextInspectionTimeoutMs/
+  );
+});

package/test/log-viewer.test.js

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { appendFile, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { promisify } from "node:util";
+import { followLogFile, readRecentLogLines } from "../src/runtime/log-viewer.js";
+
+const execFileAsync = promisify(execFile);
+
+async function waitFor(check, timeoutMs = 1_000) {
+  const startedAt = Date.now();
+  while (!check()) {
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw new Error(`Condition was not met after ${timeoutMs}ms`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+}
+
+test("reads only the requested most recent log lines", async (t) => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "arisa-log-"));
+  const logFile = path.join(directory, "arisa.log");
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  await writeFile(logFile, "one\ntwo\nthree\nfour\n", "utf8");
+
+  const result = await readRecentLogLines(logFile, 2);
+
+  assert.equal(result.text, "three\nfour");
+  assert.equal(result.endsWithNewline, true);
+  assert.equal(result.size, 19);
+});
+
+test("preserves an unterminated final log line", async (t) => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "arisa-log-"));
+  const logFile = path.join(directory, "arisa.log");
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  await writeFile(logFile, "one\ntwo", "utf8");
+
+  const result = await readRecentLogLines(logFile, 1);
+
+  assert.equal(result.text, "two");
+  assert.equal(result.endsWithNewline, false);
+});
+
+test("follows appended logs and resumes from a replaced log file", async (t) => {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "arisa-log-"));
+  const logFile = path.join(directory, "arisa.log");
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  await writeFile(logFile, "existing\n", "utf8");
+  const initial = await readRecentLogLines(logFile, 10);
+  const controller = new AbortController();
+  let output = "";
+  const following = followLogFile({
+    logFile,
+    initialSize: initial.size,
+    initialIno: initial.ino,
+    write: (content) => { output += content; },
+    signal: controller.signal,
+    pollIntervalMs: 10
+  });
+
+  await appendFile(logFile, "new\n", "utf8");
+  await waitFor(() => output === "new\n");
+  await rename(logFile, `${logFile}.old`);
+  await writeFile(logFile, "rotated and longer\n", "utf8");
+  await waitFor(() => output === "new\nrotated and longer\n");
+  controller.abort();
+  await following;
+
+  assert.equal(output, "new\nrotated and longer\n");
+});
+
+test("arisa log prints the active package version and recent logs", async (t) => {
+  const arisaHome = await mkdtemp(path.join(os.tmpdir(), "arisa-home-"));
+  const stateDir = path.join(arisaHome, "state");
+  t.after(() => rm(arisaHome, { recursive: true, force: true }));
+  await mkdir(stateDir, { recursive: true });
+  await writeFile(path.join(stateDir, "arisa.log"), "first\nlatest\n", "utf8");
+
+  const { stdout } = await execFileAsync(process.execPath, ["src/index.js", "log", "--no-follow"], {
+    cwd: path.resolve(import.meta.dirname, ".."),
+    env: { ...process.env, ARISA_HOME: arisaHome }
+  });
+  const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+
+  assert.equal(stdout.split("\n")[0], `Arisa v${packageJson.version} | Recent logs`);
+  assert.match(stdout, /first\nlatest\n$/);
+});

package/test/model-selection.test.js

@@ -4,8 +4,10 @@ import test from "node:test";
 import {
   resolveChatModel,
   resolveChatModelSelection,
+  resolveChatSpeed,
   resolveChatThinkingLevel,
   selectChatModel,
+  selectChatSpeed,
   selectChatThinkingLevel
 } from "../src/core/agent/model-selection.js";
 import { applyConfigDefaults, piConfigDefaults, telegramConfigDefaults } from "../src/core/config/config-defaults.js";
@@ -14,13 +16,18 @@ import {
   listModelThinkingLevels,
   modelSupportsThinking
 } from "../src/core/agent/pi-runtime.js";
+import { clampModelSpeed, createModelSpeedController, modelSupportsSpeed, normalizeModelSpeed, speedToServiceTier } from "../src/core/agent/model-speed.js";
 import { getChatPiSessionsDir } from "../src/runtime/paths.js";
 import {
   buildEffortPicker,
   buildModelPicker,
+  buildSpeedPicker,
   parseEffortPickerAction,
-  parseModelPickerAction
+  parseModelPickerAction,
+  parseSpeedPickerAction,
+  reverseModelOrder
 } from "../src/transport/telegram/model-picker.js";
+import { closeModelPicker } from "../src/transport/telegram/bot.js";
 
 function createConfig() {
   return applyConfigDefaults({
@@ -47,6 +54,7 @@ test("resolves the default model until a chat selects one", () => {
     provider: "openai-codex",
     model: "gpt-selected",
     thinkingLevel: "high",
+    speed: 1,
     sessionRevision: 1
   });
 });
@@ -74,10 +82,22 @@ test("updates effort without bumping the session revision", () => {
     provider: "openai-codex",
     model: "gpt-a",
     thinkingLevel: "high",
+    speed: 1,
     sessionRevision: 1
   });
 });
 
+test("updates Pi speed without bumping the session revision", () => {
+  const config = createConfig();
+
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-5.6-sol" }, { thinkingLevel: "high" });
+  selectChatSpeed(config, 123, 1.5);
+
+  assert.equal(resolveChatSpeed(config, 123), 1.5);
+  assert.equal(config.pi.chatModels["123"].sessionRevision, 1);
+  assert.equal(config.pi.chatModels["123"].thinkingLevel, "high");
+});
+
 test("ignores a chat selection from a different active provider", () => {
   const config = createConfig();
   config.pi.chatModels = {
@@ -120,6 +140,25 @@ test("builds a paged model picker and marks the current model", () => {
   assert.equal(picker.replyMarkup.inline_keyboard[2][1].callback_data, "model-page:1");
 });
 
+test("reverses model order without mutating the provider list", () => {
+  const models = [
+    { provider: "openai-codex", id: "gpt-old" },
+    { provider: "openai-codex", id: "gpt-current" },
+    { provider: "openai-codex", id: "gpt-new" }
+  ];
+
+  assert.deepEqual(reverseModelOrder(models).map((model) => model.id), [
+    "gpt-new",
+    "gpt-current",
+    "gpt-old"
+  ]);
+  assert.deepEqual(models.map((model) => model.id), [
+    "gpt-old",
+    "gpt-current",
+    "gpt-new"
+  ]);
+});
+
 test("builds an effort picker for the current model or pending model choice", () => {
   const current = buildEffortPicker({
     provider: "openai-codex",
@@ -142,6 +181,46 @@ test("builds an effort picker for the current model or pending model choice", ()
   assert.equal(pending.replyMarkup.inline_keyboard[1][0].callback_data, "model-effort:4:high");
 });
 
+test("builds and parses the speed picker", () => {
+  const picker = buildSpeedPicker({
+    provider: "openai-codex",
+    modelId: "gpt-5.6-sol",
+    speeds: [1, 1.5],
+    selectedSpeed: 1.5
+  });
+  assert.equal(picker.replyMarkup.inline_keyboard[0][0].callback_data, "speed:1");
+  assert.match(picker.replyMarkup.inline_keyboard[1][0].text, /^✓ 1\.5x$/);
+  assert.deepEqual(parseSpeedPickerAction("speed:1.5"), { type: "speed", speed: 1.5 });
+  assert.deepEqual(parseSpeedPickerAction("speed:1"), { type: "speed", speed: 1 });
+  assert.equal(parseSpeedPickerAction("speed:2"), null);
+});
+
+test("closes the picker after selecting the already active model and effort", async () => {
+  const calls = [];
+  const ctx = {
+    chat: { id: 123 },
+    callbackQuery: { message: { message_id: 456 } },
+    api: {
+      async editMessageText(...args) {
+        calls.push(["editMessageText", ...args]);
+      }
+    },
+    async answerCallbackQuery(...args) {
+      calls.push(["answerCallbackQuery", ...args]);
+    }
+  };
+
+  await closeModelPicker(ctx, {
+    messageText: "Already using openai-codex/gpt-b (effort: high).",
+    callbackText: "Already using gpt-b at high."
+  });
+
+  assert.deepEqual(calls, [
+    ["editMessageText", 123, 456, "Already using openai-codex/gpt-b (effort: high)."],
+    ["answerCallbackQuery", { text: "Already using gpt-b at high." }]
+  ]);
+});
+
 test("parses only model picker callback data", () => {
   assert.deepEqual(parseModelPickerAction("model:12"), { type: "select", value: 12 });
   assert.deepEqual(parseModelPickerAction("model-page:2"), { type: "page", value: 2 });
@@ -162,14 +241,16 @@ test("parses effort picker callback data", () => {
   assert.equal(parseEffortPickerAction("model:1"), null);
 });
 
-test("centralizes picker defaults in config", () => {
+test("centralizes Telegram and Pi defaults in config", () => {
   const config = applyConfigDefaults({
     telegram: {},
     pi: { provider: "openai-codex", model: "gpt-default" }
   });
 
   assert.equal(config.telegram.modelPickerPageSize, telegramConfigDefaults.modelPickerPageSize);
+  assert.equal(config.telegram.busyMessageMode, "steer");
   assert.equal(config.pi.thinkingLevel, piConfigDefaults.thinkingLevel);
+  assert.equal(config.pi.speed, piConfigDefaults.speed);
 });
 
 test("lists and clamps thinking levels from model capabilities", () => {
@@ -193,3 +274,45 @@ test("lists and clamps thinking levels from model capabilities", () => {
   assert.equal(clampModelThinkingLevel(plain, "high"), "off");
   assert.equal(modelSupportsThinking(plain), false);
 });
+
+test("maps supported model speeds to provider service tiers", () => {
+  const fastModel = {
+    provider: "openai-codex",
+    api: "openai-codex-responses",
+    id: "gpt-5.6-sol"
+  };
+  assert.equal(modelSupportsSpeed(fastModel), true);
+  assert.equal(clampModelSpeed(fastModel, 1.5), 1.5);
+  assert.equal(clampModelSpeed({ ...fastModel, id: "gpt-5.3" }, 1.5), 1);
+  assert.equal(speedToServiceTier(1), "default");
+  assert.equal(speedToServiceTier(1.5), "priority");
+  assert.throws(() => normalizeModelSpeed(2), /Invalid model speed/);
+});
+
+test("applies Pi speed to every provider request and updates it in place", async () => {
+  const calls = [];
+  const controller = createModelSpeedController((model, context, options) => {
+    calls.push({ model, context, options });
+    return "stream";
+  }, 1);
+
+  assert.equal(controller.streamFn("model", "context", {
+    signal: "signal",
+    onPayload: (payload) => ({ ...payload, preserved: true })
+  }), "stream");
+  controller.setSpeed(1.5);
+  controller.streamFn("model", "context", { signal: "signal" });
+
+  assert.equal(calls[0].options.serviceTier, "default");
+  assert.equal(calls[1].options.serviceTier, "priority");
+  assert.equal(calls[1].options.signal, "signal");
+  assert.deepEqual(await calls[0].options.onPayload({ model: "gpt" }, "model"), {
+    model: "gpt",
+    preserved: true,
+    service_tier: "default"
+  });
+  assert.deepEqual(await calls[1].options.onPayload({ model: "gpt" }, "model"), {
+    model: "gpt",
+    service_tier: "priority"
+  });
+});

package/test/paths.test.js

@@ -9,6 +9,7 @@ import {
   chatsDir,
   createIpcSocketPath,
   getChatArtifactsDir,
+  getChatConversationHistoryFile,
   getChatToolConfigPath,
   getChatToolStateDir,
   getToolStateDir,
@@ -23,6 +24,13 @@ test("keeps chat artifact paths scoped below the chat directory", () => {
   assert.equal(artifactsDir, path.join(chatsDir, "chat-1", "artifacts"));
 });
 
+test("keeps portable conversation history scoped below the chat state directory", () => {
+  assert.equal(
+    getChatConversationHistoryFile("chat-1"),
+    path.join(chatsDir, "chat-1", "state", "conversation.jsonl")
+  );
+});
+
 test("keeps chat tool state and config paths scoped below the chat directory for normal names", () => {
   assert.equal(
     getChatToolStateDir("chat-1", "strudel-agent"),

package/test/pi-compaction.test.js

@@ -0,0 +1,43 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createPiSettingsManager } from "../src/core/agent/agent-manager.js";
+import { applyConfigDefaults, piConfigDefaults } from "../src/core/config/config-defaults.js";
+
+test("provides Pi compaction defaults through Arisa config", () => {
+  const config = applyConfigDefaults({ pi: {} });
+
+  assert.deepEqual(config.pi.compaction, {
+    enabled: true,
+    reserveTokens: 16_384,
+    keepRecentTokens: 20_000
+  });
+  assert.deepEqual(config.pi.compaction, piConfigDefaults.compaction);
+});
+
+test("merges partial Pi compaction overrides with defaults", () => {
+  const config = applyConfigDefaults({
+    pi: { compaction: { reserveTokens: 8_192 } }
+  });
+
+  assert.deepEqual(config.pi.compaction, {
+    enabled: true,
+    reserveTokens: 8_192,
+    keepRecentTokens: 20_000
+  });
+});
+
+test("passes Arisa compaction config to Pi settings", () => {
+  const config = applyConfigDefaults({
+    pi: {
+      compaction: {
+        enabled: false,
+        reserveTokens: 12_000,
+        keepRecentTokens: 18_000
+      }
+    }
+  });
+
+  const settingsManager = createPiSettingsManager(config);
+
+  assert.deepEqual(settingsManager.getCompactionSettings(), config.pi.compaction);
+});

package/test/service-manager.test.js

@@ -0,0 +1,234 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createTelegramRestartHandler, telegramCommands } from "../src/transport/telegram/bot.js";
+import { handoffServiceRestart, restartService, serviceEntryFile, waitForServiceStop } from "../src/runtime/service-manager.js";
+
+test("registers /restart as a native Telegram command", () => {
+  assert.equal(
+    telegramCommands.some((command) => command.command === "restart"),
+    true
+  );
+  assert.equal(telegramCommands.some((command) => command.command === "harness"), false);
+  assert.equal(telegramCommands.some((command) => command.command === "login"), false);
+});
+
+test("replies before handing restart to a detached CLI process", async () => {
+  const calls = [];
+  let unreferenced = false;
+  let logClosed = false;
+  const environment = { ARISA_TEST: "restart" };
+
+  const result = await handoffServiceRestart({
+    verbose: false,
+    cliArgs: ["--pi.model", "example/model"]
+  }, {
+    ensureHome: async () => { calls.push("ensure-home"); },
+    getStatus: async () => {
+      calls.push("get-status");
+      return { running: true, pid: 41 };
+    },
+    openLog: async (file, mode) => {
+      calls.push(["open-log", file, mode]);
+      return {
+        fd: 17,
+        close: async () => { logClosed = true; }
+      };
+    },
+    spawnProcess: (command, args, options) => {
+      calls.push(["spawn", command, args, options]);
+      return {
+        pid: 84,
+        unref: () => { unreferenced = true; }
+      };
+    },
+    environment,
+    currentPid: 41
+  });
+
+  assert.equal(calls[0], "ensure-home");
+  assert.equal(calls[1], "get-status");
+  assert.equal(calls[2][0], "open-log");
+  assert.equal(calls[2][2], "a");
+  assert.equal(calls[3][0], "spawn");
+  assert.equal(calls[3][1], process.execPath);
+  assert.deepEqual(calls[3][2], [
+    serviceEntryFile,
+    "restart",
+    "--pi.model",
+    "example/model",
+    "--silent"
+  ]);
+  assert.deepEqual(calls[3][3], {
+    detached: true,
+    stdio: ["ignore", 17, 17],
+    env: environment
+  });
+  assert.equal(unreferenced, true);
+  assert.equal(logClosed, true);
+  assert.equal(result.pid, 84);
+
+  const handlerCalls = [];
+  const handler = createTelegramRestartHandler({
+    authorize: async () => ({ ok: true }),
+    requestRestart: async () => {
+      handlerCalls.push("handoff");
+      return result;
+    }
+  });
+  const ctx = {
+    reply: async (text) => { handlerCalls.push(["reply", text]); }
+  };
+
+  await handler(ctx);
+  await handler(ctx);
+
+  assert.deepEqual(handlerCalls, [
+    ["reply", "Arisa is restarting. I'll be back shortly."],
+    "handoff",
+    ["reply", "An Arisa restart is already in progress."]
+  ]);
+});
+
+test("refuses Telegram restart handoff outside the active background service", async () => {
+  let spawned = false;
+
+  await assert.rejects(
+    handoffServiceRestart({}, {
+      ensureHome: async () => {},
+      getStatus: async () => ({ running: true, pid: 99 }),
+      spawnProcess: () => {
+        spawned = true;
+      },
+      currentPid: 41
+    }),
+    /requires the active background service process/
+  );
+
+  assert.equal(spawned, false);
+});
+
+test("reports a failed Telegram restart handoff and permits retry", async () => {
+  const replies = [];
+  let attempts = 0;
+  const handler = createTelegramRestartHandler({
+    authorize: async () => ({ ok: true }),
+    requestRestart: async () => {
+      attempts += 1;
+      if (attempts === 1) throw new Error("synthetic handoff failure");
+      return { pid: 84 };
+    }
+  });
+  const ctx = { reply: async (text) => { replies.push(text); } };
+
+  await handler(ctx);
+  await handler(ctx);
+
+  assert.equal(attempts, 2);
+  assert.deepEqual(replies, [
+    "Arisa is restarting. I'll be back shortly.",
+    "Arisa could not be restarted: synthetic handoff failure",
+    "Arisa is restarting. I'll be back shortly."
+  ]);
+});
+
+test("waits until the stopped service releases its PID before restarting", async () => {
+  const calls = [];
+  const statuses = [
+    { running: true, pid: 41 },
+    { running: true, pid: 41 },
+    { running: false, pid: null }
+  ];
+
+  const result = await restartService({
+    verbose: false,
+    cliArgs: ["--pi.model", "example/model"],
+    shutdownTimeoutMs: 1_000,
+    shutdownPollIntervalMs: 1
+  }, {
+    stop: async () => {
+      calls.push("stop");
+      return { ok: true, pid: 41 };
+    },
+    getStatus: async () => {
+      calls.push("status");
+      return statuses.shift();
+    },
+    start: async (options) => {
+      calls.push("start");
+      assert.deepEqual(options, {
+        verbose: false,
+        cliArgs: ["--pi.model", "example/model"]
+      });
+      return { ok: true, pid: 84, logFile: "/tmp/arisa.log" };
+    },
+    sleep: async () => {
+      calls.push("sleep");
+    }
+  });
+
+  assert.deepEqual(calls, ["stop", "status", "sleep", "status", "sleep", "status", "start"]);
+  assert.deepEqual(result, {
+    ok: true,
+    pid: 84,
+    previousPid: 41,
+    wasRunning: true,
+    logFile: "/tmp/arisa.log"
+  });
+});
+
+test("restart starts Arisa when it is not running", async () => {
+  let statusChecks = 0;
+  const result = await restartService({
+    shutdownTimeoutMs: 1_000,
+    shutdownPollIntervalMs: 1
+  }, {
+    stop: async () => ({ ok: false, reason: "not-running", pid: null }),
+    getStatus: async () => {
+      statusChecks += 1;
+      return { running: false, pid: null };
+    },
+    start: async () => ({ ok: true, pid: 84, logFile: "/tmp/arisa.log" })
+  });
+
+  assert.equal(statusChecks, 0);
+  assert.deepEqual(result, {
+    ok: true,
+    pid: 84,
+    previousPid: null,
+    wasRunning: false,
+    logFile: "/tmp/arisa.log"
+  });
+});
+
+test("restart does not start a second service when shutdown times out", async () => {
+  let started = false;
+
+  await assert.rejects(
+    restartService({
+      shutdownTimeoutMs: 2,
+      shutdownPollIntervalMs: 1
+    }, {
+      stop: async () => ({ ok: true, pid: 41 }),
+      getStatus: async () => ({ running: true, pid: 41 }),
+      start: async () => {
+        started = true;
+        return { ok: true, pid: 84 };
+      },
+      sleep: async () => {}
+    }),
+    /did not stop within 2ms/
+  );
+
+  assert.equal(started, false);
+});
+
+test("requires explicit positive shutdown timing policy", async () => {
+  await assert.rejects(
+    waitForServiceStop({ timeoutMs: 0, pollIntervalMs: 1 }),
+    /positive shutdownTimeoutMs/
+  );
+  await assert.rejects(
+    waitForServiceStop({ timeoutMs: 1, pollIntervalMs: 0 }),
+    /positive shutdownPollIntervalMs/
+  );
+});