dsh-plugin-billing 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,563 @@
+/**
+ * 余额与金额插件 —— Host 侧。
+ *
+ * 只做客户端做不到的事：拿提供方凭证去问账户余额，并把「当前路由的模型」一并告诉
+ * 浏览器。金额计算留在浏览器侧（那边已经有 token 账目），因此这里不碰 token 统计。
+ *
+ * ## 为什么走 HTTP 路由而不是 Remote
+ *
+ * 本部署的 Host↔Client 类型化 Remote（Typert）需要随包发布的生成产物
+ * （`typert.host.js` / `typert.remote-client.js`），不适合一个本地小插件。
+ * 而 `ctx.webServer` 本来就允许插件注册具名路由（`dsh-client-modules` 也是这么
+ * 提供 `/plugins` 的），浏览器同源 `fetch` 即可，无需新增构建链。
+ *
+ * 路由是**精确匹配**：`webServer.match()` 先查 exact 表再查最长前缀，因此
+ * `/plugins/billing/summary` 不会被 `/plugins` 前缀路由抢走。
+ *
+ * ## 配置
+ *
+ * 全部走环境变量（插件不声明 `Config` schema，避免与组合器校验耦合）：
+ *
+ * | 环境变量 | 默认值 | 作用 |
+ * |---|---|---|
+ * | `DSH_BILLING_API_KEY_ENV` | `DEEPSEEK_API_KEY` | 用哪个凭据引用去解析密钥 |
+ * | `DSH_BILLING_BASE_URL` / `DEEPSEEK_BASE_URL` | `https://api.deepseek.com` | 提供方端点 |
+ * | `DSH_BILLING_BALANCE_TTL_MS` | `30000` | 余额缓存时长 |
+ *
+ * 单价表在 `src/pricing-body.js`，改完执行 `node scripts/build-client.mjs`。
+ */
+
+/** 余额摘要路由（客户端 fetch 的同源地址）。 */
+import { createPricingReader } from './pricing.js';
+import { overridePath, readOverride, refreshPrices } from './prices.js';
+
+const ROUTE_PATH = '/plugins/billing/summary';
+
+/** 价格表接口：`GET` 读当前表，`POST .../refresh` 从官方页更新（写本机覆盖文件）。 */
+const PRICES_PREFIX = '/plugins/billing/prices';
+const PRICES_PATH = PRICES_PREFIX;
+const REFRESH_PATH = `${PRICES_PREFIX}/refresh`;
+
+/** 提供方默认端点与余额路径。 */
+const DEFAULT_BASE_URL = 'https://api.deepseek.com';
+const BALANCE_PATH = '/user/balance';
+
+/** 默认凭据引用名：与 `@deepseek-ai/dsh-llm-deepseek` 的 `apiKeyEnv` 默认值一致。 */
+const DEFAULT_API_KEY_ENV = 'DEEPSEEK_API_KEY';
+
+/** 余额缓存默认时长：余额变化慢，没必要每次渲染都打接口。 */
+const DEFAULT_TTL_MS = 30_000;
+
+/** 单次上游请求超时。 */
+const REQUEST_TIMEOUT_MS = 10_000;
+
+/** 会话模型解析结果的缓存时长：命中长、未命中短（会话首轮尚无 `request/context`）。 */
+const MODEL_TTL_HIT_MS = 60_000;
+const MODEL_TTL_MISS_MS = 5_000;
+
+/** 计费币种：优先取接口返回的那个，没有时用这个兜底。 */
+const FALLBACK_CURRENCY = 'CNY';
+
+/**
+ * 读环境变量，空串与纯空白视为未设置。
+ * @param name - 变量名。
+ * @returns 去除首尾空白后的值，或 `undefined`。
+ */
+function envValue(name) {
+  const value = process.env[name];
+  if (value === undefined) return undefined;
+  const trimmed = value.trim();
+  return trimmed === '' ? undefined : trimmed;
+}
+
+/**
+ * 组装运行期选项。每次调用都重读环境变量，便于不重启就调整缓存时长。
+ * @returns `{ apiKeyEnv, baseURL, ttlMs }`。
+ */
+function options() {
+  const ttl = Number(envValue('DSH_BILLING_BALANCE_TTL_MS') ?? DEFAULT_TTL_MS);
+  return {
+    apiKeyEnv: envValue('DSH_BILLING_API_KEY_ENV') ?? DEFAULT_API_KEY_ENV,
+    baseURL: (envValue('DSH_BILLING_BASE_URL') ?? envValue('DEEPSEEK_BASE_URL') ?? DEFAULT_BASE_URL).replace(
+      /\/+$/,
+      '',
+    ),
+    ttlMs: Number.isFinite(ttl) && ttl >= 0 ? ttl : DEFAULT_TTL_MS,
+  };
+}
+
+/**
+ * 按凭据 seam 解析 API 密钥：先问凭据服务（它已叠加进程环境、托管存储与 `.env`），
+ * 再退回直接读进程环境。
+ * @param ctx - Host cordis 上下文。
+ * @param envName - 凭据引用名。
+ * @returns `{ value, source }`，未配置时为 `undefined`。
+ */
+async function resolveApiKey(ctx, envName) {
+  const credentials = ctx.get('credentials');
+  if (credentials !== undefined && typeof credentials.resolve === 'function') {
+    const hit = await credentials.resolve(envName);
+    if (hit !== undefined && typeof hit.value === 'string' && hit.value.trim() !== '') {
+      return { value: hit.value, source: hit.source ?? 'credentials' };
+    }
+  }
+  const ambient = envValue(envName);
+  return ambient === undefined ? undefined : { value: ambient, source: 'env' };
+}
+
+/**
+ * 读部署的**默认路由**模型（`agentDefaultModel.currentSelection()`）。
+ * 这只是兜底：真正在服务某个会话的模型可能与之不同，优先用 {@link modelForSession}。
+ * @param ctx - Host cordis 上下文。
+ * @returns `{ provider, model }` 或 `null`。
+ */
+function defaultModel(ctx) {
+  const service = ctx.get('agentDefaultModel');
+  if (service === undefined || typeof service.currentSelection !== 'function') return null;
+  const selection = service.currentSelection();
+  if (selection === null || typeof selection !== 'object' || typeof selection.model !== 'string') return null;
+  return {
+    provider: typeof selection.provider === 'string' ? selection.provider : null,
+    model: selection.model,
+  };
+}
+
+/**
+ * 读一个会话的事件列表，跨 dsh 版本：
+ * - **0.1.5+**：`sessionPersistence` 改成句柄式 API，`inspect(id)` 已被移除；
+ *   用 `open(id, 'read')` 拿只读句柄（不取得写所有权），`read()` 取事件，随后 `close()`。
+ * - **0.1.1**：仍有按 id 寻址的 `inspect(id)`，返回已验证的逻辑视图。
+ * @param persistence - `ctx.sessionPersistence` 服务。
+ * @param sessionId - 目标会话 id。
+ * @returns 事件数组，或 `undefined`（读不到）。
+ */
+async function readSessionEvents(persistence, sessionId) {
+  if (typeof persistence.open === 'function') {
+    const reader = await persistence.open(sessionId, 'read');
+    try {
+      const slice = await reader.read();
+      return Array.isArray(slice?.events) ? slice.events : undefined;
+    } finally {
+      // 句柄是本地资源，必须释放；close 幂等。
+      await reader.close?.();
+    }
+  }
+  if (typeof persistence.inspect === 'function') {
+    const view = await persistence.inspect(sessionId);
+    return Array.isArray(view?.events) ? view.events : undefined;
+  }
+  return undefined;
+}
+
+/**
+ * 读**某个会话实际使用**的 provider/model：从该会话自己的日志里取最后一条
+ * `request/context`。日志是事件溯源的唯一真源，所以这是精确值，而不是部署默认值——
+ * 两者可以不同（本机上默认路由是 v4-pro，而这个会话跑的是 v4-flash，单价差 3 倍）。
+ *
+ * 用 `sessionPersistence.inspect()`：它返回已验证的逻辑视图且**不提交恢复、不发布
+ * Session**，对正在运行的会话也是安全的只读操作（`load()` 会在轮次开放时拒绝，且带副作用）。
+ * 命中缓存 60 秒，未命中只缓存 5 秒——会话刚起第一轮时还没有 `request/context`，
+ * 短缓存能让它尽快转为精确值，同时避免每次轮询都重扫长日志。
+ * @param ctx - Host cordis 上下文。
+ * @param sessionId - 目标会话 id；缺省时返回 `undefined`。
+ * @param cache - 缓存槽（会在此挂载 `models` Map）。
+ * @returns `{ provider, model }`，无法确定时为 `undefined`。
+ */
+async function modelForSession(ctx, sessionId, cache) {
+  if (typeof sessionId !== 'string' || sessionId === '') return undefined;
+  const persistence = ctx.get('sessionPersistence');
+  const canRead =
+    persistence !== undefined &&
+    (typeof persistence.open === 'function' || typeof persistence.inspect === 'function');
+  if (!canRead) return undefined;
+
+  const now = Date.now();
+  const cached = cache.models?.get(sessionId);
+  if (cached !== undefined && now - cached.at < (cached.value === undefined ? MODEL_TTL_MISS_MS : MODEL_TTL_HIT_MS)) {
+    return cached.value;
+  }
+
+  let value;
+  try {
+    const events = (await readSessionEvents(persistence, sessionId)) ?? [];
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      const event = events[index];
+      if (event?.type !== 'request/context') continue;
+      const model = event.data?.model;
+      if (typeof model !== 'string' || model === '') continue;
+      value = {
+        provider: typeof event.data.provider === 'string' ? event.data.provider : null,
+        model,
+      };
+      break;
+    }
+  } catch {
+    // 会话不存在、日志损坏或后端不支持：一律退回默认路由，不让整条路由失败。
+    value = undefined;
+  }
+
+  if (cache.models === undefined) cache.models = new Map();
+  if (cache.models.size > 64) cache.models.clear();
+  cache.models.set(sessionId, { at: now, value });
+  return value;
+}
+
+/**
+ * 定出用于计价的模型：优先该会话的真实路由，退回部署默认路由。
+ * @param ctx - Host cordis 上下文。
+ * @param sessionId - 目标会话 id。
+ * @param cache - 缓存槽。
+ * @returns `{ provider, model, source }`；`source` 为 `session` / `default` / `unknown`。
+ */
+async function resolveModel(ctx, sessionId, cache) {
+  const session = await modelForSession(ctx, sessionId, cache);
+  if (session !== undefined) return { ...session, source: 'session' };
+  const fallback = defaultModel(ctx);
+  if (fallback !== null) return { ...fallback, source: 'default' };
+  return { provider: null, model: null, source: 'unknown' };
+}
+
+/**
+ * 请求上游余额接口并归一化。
+ * @param baseURL - 提供方端点。
+ * @param apiKey - 已解析的密钥。
+ * @returns 归一化后的余额对象。
+ * @throws 带 `code` 的错误（`http-error` / `bad-response` / `network`）。
+ */
+async function queryBalance(baseURL, apiKey) {
+  let response;
+  try {
+    response = await fetch(`${baseURL}${BALANCE_PATH}`, {
+      headers: { authorization: `Bearer ${apiKey}`, accept: 'application/json' },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw Object.assign(new Error(`请求 ${baseURL}${BALANCE_PATH} 失败：${detail}`), { code: 'network' });
+  }
+
+  if (!response.ok) {
+    // 上游正文可能带诊断信息，但绝不回显密钥；截断后附上。
+    const text = await response.text().catch(() => '');
+    const suffix = text.trim() === '' ? '' : ` — ${text.trim().slice(0, 200)}`;
+    throw Object.assign(new Error(`余额接口返回 HTTP ${response.status}${suffix}`), { code: 'http-error' });
+  }
+
+  let body;
+  try {
+    body = await response.json();
+  } catch (error) {
+    throw Object.assign(new Error('余额接口返回的不是 JSON'), { code: 'bad-response' });
+  }
+
+  const infos = Array.isArray(body?.balance_infos) ? body.balance_infos : [];
+  const info = infos.find((entry) => entry?.currency === FALLBACK_CURRENCY) ?? infos[0];
+  if (info === undefined || info === null || typeof info !== 'object') {
+    throw Object.assign(new Error('余额接口未返回 balance_infos'), { code: 'bad-response' });
+  }
+
+  return {
+    state: 'ok',
+    isAvailable: body?.is_available === true,
+    currency: typeof info.currency === 'string' ? info.currency : FALLBACK_CURRENCY,
+    total: String(info.total_balance ?? '0'),
+    granted: String(info.granted_balance ?? '0'),
+    toppedUp: String(info.topped_up_balance ?? '0'),
+  };
+}
+
+/**
+ * 产出一次余额摘要。成功结果按 TTL 缓存；失败不缓存，因此刚配好密钥的下一步就能生效。
+ * @param ctx - Host cordis 上下文。
+ * @param cache - 缓存槽（`{ at, balance, models }`）。
+ * @param sessionId - 请求方所在的会话 id，用于精确定位计价模型。
+ * @returns 响应体。
+ */
+async function summary(ctx, cache, sessionId, pricing) {
+  const opts = options();
+  const now = Date.now();
+  const model = await resolveModel(ctx, sessionId, cache);
+  // 价格表随每次响应下发：客户端优先用它，因此改价不需要重建 bundle 或刷新页面。
+  const priceInfo = pricing?.read() ?? { prices: {}, source: undefined, currency: undefined };
+  const priceFields = { prices: priceInfo.prices, priceSource: priceInfo.source, currency: priceInfo.currency };
+
+  if (cache.at !== undefined && now - cache.at < opts.ttlMs) {
+    return { ok: true, fetchedAt: now, currency: cache.balance.currency, balance: cache.balance, model, ...priceFields };
+  }
+
+  let apiKey;
+  try {
+    apiKey = await resolveApiKey(ctx, opts.apiKeyEnv);
+  } catch (error) {
+    return {
+      ok: false,
+      fetchedAt: now,
+      currency: FALLBACK_CURRENCY,
+      model,
+      ...priceFields,
+      error: { code: 'credential-error', message: error instanceof Error ? error.message : String(error) },
+    };
+  }
+
+  if (apiKey === undefined) {
+    return {
+      ok: false,
+      fetchedAt: now,
+      currency: FALLBACK_CURRENCY,
+      model,
+      ...priceFields,
+      error: {
+        code: 'missing-credential',
+        message: `未配置凭据 ${opts.apiKeyEnv}（可设 DSH_BILLING_API_KEY_ENV 指向别的引用）`,
+      },
+    };
+  }
+
+  try {
+    const balance = await queryBalance(opts.baseURL, apiKey.value);
+    cache.at = now;
+    cache.balance = balance;
+    return { ok: true, fetchedAt: now, currency: balance.currency, balance, model, ...priceFields };
+  } catch (error) {
+    return {
+      ok: false,
+      fetchedAt: now,
+      currency: FALLBACK_CURRENCY,
+      model,
+      ...priceFields,
+      error: {
+        code: typeof error?.code === 'string' ? error.code : 'unexpected',
+        message: error instanceof Error ? error.message : String(error),
+      },
+    };
+  }
+}
+
+/**
+ * 与部署数据面（`/api`）对齐的请求准入判断。
+ *
+ * 0.1.5 起 dsh web 给数据请求加了两道闸，`connection` 服务把它们打包成
+ * `requestRejection(request)`：
+ * 1. **Host/Origin 信任围栏** —— 不属于受信 authority 的请求直接 403（防 DNS rebinding）；
+ * 2. **浏览器会话认证** —— 带 `?token=` 访问一次首页后，服务器签发绑定 authority 的
+ *    签名 cookie（`dsh-auth-<authority-hash>`，Path=/、HttpOnly、SameSite=Strict），
+ *    之后校验它，失败给 401。
+ *
+ * 本插件的余额路由返回的是**数据**（账户余额），所以用同一入口做准入，语义与 `/api` 一致。
+ * `requestRejection` 返回 `undefined` 表示放行。
+ *
+ * 0.1.1 没有这个方法（它的围栏在别处），此时返回 `undefined` 跳过，保持与旧版部署一致。
+ * @param ctx - Host cordis 上下文。
+ * @param req - 传入的 HTTP 请求。
+ * @returns `undefined` 放行；`401` / `403` 为拒绝状态码。
+ */
+function requestRejection(ctx, req) {
+  const connection = ctx.get('connection');
+  if (connection === undefined || typeof connection.requestRejection !== 'function') return undefined;
+  try {
+    const rejection = connection.requestRejection(req);
+    return rejection === 401 || rejection === 403 ? rejection : undefined;
+  } catch {
+    // 准入服务本身异常时按拒绝处理：这是数据面，宁可 401 也不放开。
+    return 401;
+  }
+}
+
+/**
+ * 路由处理器。返回 Promise，交给 `webServer` 的 `await route.handler(...)` 统一
+ * 收敛错误——同时让处理器在测试里可被 await。
+ * @param req - node:http 请求。
+ * @param res - node:http 响应。
+ * @param ctx - Host cordis 上下文。
+ * @param cache - 余额缓存槽。
+ * @param pricing - 价格读取器（随响应下发价格表）。
+ * @returns 响应写完后的 Promise。
+ */
+async function handleSummary(req, res, ctx, cache, pricing) {
+  const rejection = requestRejection(ctx, req);
+  if (rejection !== undefined) {
+    res.writeHead(rejection, { 'cache-control': 'no-store', 'content-type': 'text/plain; charset=utf-8' });
+    res.end(
+      rejection === 401
+        ? 'dsh web authentication required; reopen the URL printed by dsh web.\n'
+        : 'forbidden: request authority is not trusted by this deployment.\n',
+    );
+    return;
+  }
+
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    res.writeHead(405, { allow: 'GET, HEAD' });
+    res.end();
+    return;
+  }
+
+  // 客户端带上 `?session=<id>` 时按该会话的真实路由计价，否则退回部署默认路由。
+  let sessionId;
+  try {
+    sessionId = new URL(req.url ?? '/', 'http://localhost').searchParams.get('session') ?? undefined;
+  } catch {
+    sessionId = undefined;
+  }
+
+  let body;
+  try {
+    body = await summary(ctx, cache, sessionId, pricing);
+  } catch (error) {
+    // 兜底：任何未预料的异常也要给出可解析的响应，别让前端 fetch 挂住。
+    const fallback = defaultModel(ctx);
+    const priceInfo = pricing?.read() ?? { prices: {}, source: undefined };
+    body = {
+      ok: false,
+      fetchedAt: Date.now(),
+      currency: FALLBACK_CURRENCY,
+      model: { provider: fallback?.provider ?? null, model: fallback?.model ?? null, source: 'default' },
+      prices: priceInfo.prices,
+      priceSource: priceInfo.source,
+      error: { code: 'unexpected', message: error instanceof Error ? error.message : String(error) },
+    };
+  }
+
+  const text = JSON.stringify(body);
+  res.writeHead(200, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+    'content-length': Buffer.byteLength(text),
+  });
+  res.end(req.method === 'HEAD' ? undefined : text);
+}
+
+/**
+ * 价格表接口：读当前表 / 从官方页更新（写入本机覆盖文件）。
+ *
+ * 「一点就更新」按钮打的就是这里。仍然走与数据面同一套准入（`requestRejection`），
+ * 因为这是一个**会写文件**的动作。
+ * @param ctx - Host cordis 上下文。
+ * @param req - 请求。
+ * @param res - 应答。
+ * @param pricing - 价格读取器（写成功后要让它丢缓存，界面无需等 TTL）。
+ */
+async function handlePrices(ctx, req, res, pricing) {
+  const connection = ctx.get('connection');
+  const rejection =
+    typeof connection?.requestRejection === 'function' ? connection.requestRejection(req) : undefined;
+  const send = (status, value) => {
+    const text = `${JSON.stringify(value)}\n`;
+    res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+    res.end(text);
+  };
+  if (rejection !== undefined) {
+    send(rejection, { ok: false, error: rejection === 401 ? 'authentication-required' : 'forbidden' });
+    return;
+  }
+
+  const path = (req.url ?? '/').split('?')[0];
+  /**
+   * 描述当前价格表。
+   * 注意：**每次调用都重新读**——刷新成功后必须用刷新后的状态回答，
+   * 否则界面会显示"没变"（这个坑踩过一次）。
+   */
+  const describe = (state = pricing.read()) => {
+    const override = readOverride();
+    return {
+      ok: true,
+      source: state.source,
+      currency: state.currency,
+      modelCount: Object.keys(state.prices).length,
+      models: Object.keys(state.prices),
+      overrideUsed: state.overrideUsed,
+      overridePath: overridePath(),
+      // 覆盖文件里的抓取日期：界面用它显示"上次更新于"。
+      updatedAt: typeof override?.fetchedAt === 'string' ? override.fetchedAt : null,
+    };
+  };
+
+  if (path === PRICES_PATH && req.method === 'GET') {
+    send(200, describe());
+    return;
+  }
+  if (path === REFRESH_PATH) {
+    if (req.method !== 'POST') {
+      res.writeHead(405, { allow: 'POST', 'cache-control': 'no-store' });
+      res.end();
+      return;
+    }
+    const before = { ...pricing.read().prices };
+    try {
+      const result = await refreshPrices();
+      // 丢掉 TTL 缓存，让界面立刻拿到新价（否则最多要等 5 秒）。
+      pricing.invalidate();
+      const after = pricing.read();
+      const changed = Object.keys(after.prices).filter(
+        (model) => JSON.stringify(before[model]) !== JSON.stringify(after.prices[model]),
+      );
+      send(200, { ...describe(after), changed, models: result.models, path: result.path });
+    } catch (error) {
+      // 解析/网络失败：把原因原样给界面（自校验的报错信息本身就是给用户看的）。
+      send(502, {
+        ok: false,
+        error: 'refresh-failed',
+        message: error instanceof Error ? error.message : String(error),
+        ...describe(),
+      });
+    }
+    return;
+  }
+  send(404, { ok: false, error: 'not-found' });
+}
+
+/**
+ * 注册余额摘要路由。
+ * @param ctx - Host cordis 上下文。
+ */
+export function apply(ctx) {
+  const opts = options();
+  /** 成功结果的缓存槽：TTL 内复用，避免前端每次渲染都打上游。 */
+  const cache = {};
+  /** 价格读取器：每次请求读 pricing.json（+ 本机覆盖），因此改价无需重启。 */
+  const pricing = createPricingReader();
+
+  ctx.inject(['webServer'], (hostCtx) => {
+    hostCtx.effect(
+      () =>
+        hostCtx.webServer.register({
+          kind: 'exact',
+          path: ROUTE_PATH,
+          handler: (req, res) => handleSummary(req, res, ctx, cache, pricing),
+        }),
+      'billing: summary route',
+    );
+    // 价格表：读 + 「一点就更新」。用 prefix 一次挂住两个子路径。
+    hostCtx.effect(
+      () =>
+        hostCtx.webServer.register({
+          kind: 'prefix',
+          path: PRICES_PREFIX,
+          // 必须把 promise 返回出去：调用方（测试、上层）靠它等待异步完成。
+          handler: (req, res) =>
+            handlePrices(ctx, req, res, pricing).catch(() => {
+              if (!res.headersSent) {
+                res.writeHead(500, { 'content-type': 'application/json; charset=utf-8' });
+                res.end('{"ok":false,"error":"internal"}\n');
+              } else {
+                res.end();
+              }
+            }),
+        }),
+      'billing: prices route',
+    );
+  });
+
+  // 启动时把鉴权可用性写进日志：拿不到 connection 服务时会退化成不校验，
+  // 这一点必须可见，而不是悄悄放开。
+  const connection = ctx.get('connection');
+  const authReady = connection !== undefined && typeof connection.requestRejection === 'function';
+  const priceFiles = pricing.files();
+  console.log(
+    `billing: 价格表 ${Object.keys(pricing.read().prices).length} 个模型（${pricing.read().source}）；` +
+      `内置 ${priceFiles.builtin}，覆盖 ${priceFiles.override}`,
+  );
+  ctx.logger?.info?.(
+    `billing: 余额路由 ${ROUTE_PATH} 就绪（端点 ${opts.baseURL}${BALANCE_PATH}，凭据 ${opts.apiKeyEnv}）；` +
+      `数据面鉴权 ${authReady ? '已启用（connection.requestRejection）' : '不可用 —— 按旧版跳过校验'}`,
+  );
+}