dsh-session-conductor 0.0.0-stage → 1.0.9

package/lib/core/config.js

@@ -0,0 +1,159 @@
+// dsh-session-conductor — 运行期配置与开关（插件全局状态）
+//
+// 【为什么单独成文件】cfg（运行期配置）与 switchGroups（自动重命名/自动续跑开关缓存）
+// 是插件被几乎所有域读写的全局状态；集中在此可让各域 import 同一份，
+// 不必反向依赖插件入口（避免循环引用），也让「配置从哪来、写到哪」只此一份实现。
+
+import path from "node:path";
+import { homedir } from "node:os";
+import { readFile, mkdir } from "node:fs/promises";
+import { writeFileSync, renameSync, statSync } from "node:fs";
+import { log } from "../shared/log.js";
+
+/** 插件默认配置（面板可改；cfg 的初值来源）。 */
+export const DEFAULTS = {
+  enabled: true, // 自动续跑总开关
+  defaultAutoContinue: false, // 单会话默认关闭，面板可逐会话显式开启
+  failRetryDelayMs: 30000, // 本轮运行失败识别后延迟续跑（默认 30s，避免立即重试）
+  maxConcurrent: 2, // 全局同时续跑的会话数上限
+  maxAttached: 12, // 活跃（attached）会话上限，达到后自动续跑暂停
+  listInspectBatch: 2, // 会话列表「冷会话 inspect」并发上限（防一次性并发全量会话把内存打爆）
+  listCacheMs: 5000, // 会话列表结果缓存时长（毫秒）——合并同一瞬间的多次 list 请求
+  cooldownMs: 15 * 60 * 1000, // 同会话两次自动续跑最小间隔
+  maxContinuesPerSession: 3, // 每会话自动续跑总次数上限（防死循环）
+  turnTimeoutMs: 20 * 60 * 1000, // 单回合续跑最长等待，超时取消
+  scanIntervalMs: 5 * 60 * 1000, // 周期扫描间隔
+};
+
+/** 运行期配置（面板/测试可改）。外部只读引用；改整体请用 setConfig。 */
+export let cfg = { ...DEFAULTS };
+
+/** 整体替换运行期配置（测试钩子 / 面板应用配置时用）。 */
+export function setConfig(next) {
+  cfg = { ...DEFAULTS, ...(next ?? {}) };
+}
+
+/**
+ * 开关组缓存：autoRename / autoContinue 两组的「会话 → 开关/记账」。
+ * 落盘在 <DSH_HOME>/session-conductor/config.json，内存是它的缓存。
+ */
+const switchGroups = { autoRename: new Map(), autoContinue: new Map() };
+
+/** 解析 DSH 主目录：DSH_HOME 环境变量 > ~/.dsh */
+export function resolveDshHome(ctx, c) {
+  if (process.env.DSH_HOME) return process.env.DSH_HOME;
+  const home = process.env.HOME || process.env.USERPROFILE || homedir();
+  return home ? path.join(home, '.dsh') : '';
+}
+
+/**
+ * 模板/额外注入系统提示词的「目录浏览」根目录 = DSH 工作区目录（HOME/工作区），
+ * 即工作区（skill 仓库、项目仓库都在其下），而不是 DSH 主目录（~/.dsh，只放落盘文件）。
+ * 存在性探测：HOME/工作区 存在则用它；否则回退 DSH_HOME（老布局）。
+ */
+export function resolveBrowseRoot(ctx, c) {
+  const home = process.env.HOME || process.env.USERPROFILE || homedir();
+  const ws = home ? path.join(home, '工作区') : '';
+  if (ws) {
+    try { if (statSync(ws).isDirectory()) return ws; } catch { /* 不存在则回退 */ }
+  }
+  return resolveDshHome(ctx, c);
+}
+
+/** config.json 路径（<DSH_HOME>/session-conductor/config.json）。 */
+export function pluginConfigPath(ctx) {
+  const home = resolveDshHome(ctx, cfg);
+  return home ? path.join(home, "session-conductor", "config.json") : "";
+}
+
+/** 读某组（autoRename/autoContinue）某会话的开关/记账（内存缓存；无记录返回 null）。 */
+export function readSwitch(group, sessionId) {
+  const map = switchGroups[group];
+  return map?.get(sessionId) ?? null;
+}
+
+/** 改→写：更新缓存并原子落盘 config.json，返回更新后 entry。
+ *  group ∈ "autoRename" | "autoContinue"；defaultEntry 为该组无记录时的基线。 */
+export async function patchSwitch(ctx, group, sessionId, patch, defaultEntry = {}) {
+  const map = switchGroups[group];
+  if (!map) throw new Error(`未知开关组 ${group}`);
+  const cur = map.get(sessionId) ?? defaultEntry;
+  const next = { ...cur, ...patch };
+  map.set(sessionId, next);
+  await savePluginConfig(ctx);
+  return next;
+}
+
+/** 从 config.json 载入两组开关到内存缓存（启动时/测试）。文件缺失或损坏 → 空配置。 */
+export async function loadPluginConfig(ctx) {
+  const file = pluginConfigPath(ctx);
+  const parsed = {};
+  if (file) {
+    try {
+      const j = JSON.parse(await readFile(file, "utf8"));
+      if (j && typeof j === "object") Object.assign(parsed, j);
+    } catch { /* 文件不存在/损坏 → 空配置 */ }
+  }
+  for (const group of Object.keys(switchGroups)) {
+    const src = parsed[group] && typeof parsed[group] === "object" ? parsed[group] : {};
+    switchGroups[group].clear();
+    for (const [sid, e] of Object.entries(src)) if (e && typeof e === "object") switchGroups[group].set(sid, { ...e });
+  }
+}
+
+/** 原子落盘 config.json（临时文件 + rename；保留未知顶层字段）。 */
+export async function savePluginConfig(ctx) {
+  const file = pluginConfigPath(ctx);
+  if (!file) return;
+  let rest = {};
+  try {
+    const j = JSON.parse(await readFile(file, "utf8"));
+    if (j && typeof j === "object") rest = j;
+  } catch { /* 文件不存在/损坏 → 全量写 */ }
+  await mkdir(path.dirname(file), { recursive: true });
+  const tmpPath = file + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify({
+    ...rest,
+    autoRename: Object.fromEntries(switchGroups.autoRename),
+    autoContinue: Object.fromEntries(switchGroups.autoContinue),
+  }, null, 2), "utf8");
+  renameSync(tmpPath, file);
+}
+
+/** 启动复位：自动续跑开关全部置 false（每次 DSH 启动默认关闭；autoRename 不复位）。幂等。 */
+export async function resetAutoContinueOnStart(ctx) {
+  await loadPluginConfig(ctx);
+  let anyOn = false;
+  for (const e of switchGroups.autoContinue.values()) if (e?.enabled === true) { anyOn = true; break; }
+  if (!anyOn) return;
+  for (const [sid, e] of switchGroups.autoContinue) switchGroups.autoContinue.set(sid, { ...e, enabled: false });
+  await savePluginConfig(ctx);
+  log(ctx, "🔒 启动复位：自动续跑开关已全部关闭（面板可逐会话开启）");
+}
+
+/** 会话的自动重命名是否开启（读 config 缓存；兼容旧签名，state 忽略）。 */
+export function autoRenameEnabled(ctx, state, sessionId) {
+  return readSwitch("autoRename", sessionId)?.enabled === true;
+}
+
+/** 自动续跑是否生效：面板显式开关优先（读 config），否则跟随全局默认 defaultAutoContinue。 */
+export function effectiveAutoContinue(cfgObj, state, sessionId) {
+  const entry = readSwitch("autoContinue", sessionId);
+  return entry?.enabled ?? cfgObj.defaultAutoContinue;
+}
+
+/** 测试钩子：清空开关缓存（单测在场景之间调用）。 */
+export function resetSwitchGroupsForTest() {
+  switchGroups.autoRename.clear();
+  switchGroups.autoContinue.clear();
+}
+
+/** 删除某组某会话的开关记录（会话删除时清理），返回是否确实删掉了。 */
+export function deleteSwitch(group, sessionId) {
+  return switchGroups[group]?.delete(sessionId) ?? false;
+}
+
+/** 测试钩子：暴露开关组本身（单测直接断言缓存内容）。 */
+export function getSwitchGroupsForTest() {
+  return switchGroups;
+}

package/lib/core/domain.js

@@ -0,0 +1,157 @@
+// dsh-session-conductor — 插件持久化域（全局状态：开关、模型选择、模板元信息）
+//
+// 【为什么单独成文件】domain schema（90 行）与 open/close 生命周期是插件状态的唯一入口，
+// 被列表、续跑、重命名、成员模型切换等多个域读写；抽出后各域只需 import 本模块，
+// 不必依赖插件入口（避免循环引用），也让「域已打开/已关闭」的状态只此一份。
+
+import { defineDomain } from "@deepseek-ai/dsh-storage-domain";
+import { z } from "zod";
+
+/** 插件自身的持久化域：自动重命名/自动续跑开关 + 记账，存于 <DSH_HOME>/storages/dsh-session-conductor.json。
+ *  版本保持 1：autoContinue 是纯增量字段（带 default），旧域文件可无损加载。 */
+const pluginDomainSpec = defineDomain({
+  name: "dsh_session_conductor",
+  version: 1,
+  global: {
+    schema: z.object({
+      autoRename: z.record(z.string(), z.object({
+        enabled: z.boolean(),
+        lastAnalysisSeq: z.number().int().nonnegative().optional(),
+        lastAnalysisAt: z.number().nonnegative().optional()
+      })).default({}),
+      autoContinue: z.record(z.string(), z.object({
+        enabled: z.boolean().optional(), // 缺省 = 跟随全局默认 defaultAutoContinue
+        lastContinuedSeq: z.number().int().nonnegative().optional(),
+        lastContinuedAt: z.number().nonnegative().optional(),
+        continueCount: z.number().int().nonnegative().optional()
+      })).default({}),
+      // ⚠️ ：自动续跑开关与记账已移至 <DSH_HOME>/session-conductor/config.json
+      //   （用户流程：控制开关 → 写 config.json → 自动续跑读 config.json；启动时 apply 自动全关）。
+      //   上方 autoContinue 字段保留仅为兼容旧域文件（旧数据不再读写，配置以 config.json 为准）。
+      // 压缩模型选择：会话模型旁单独选压缩用模型。
+      // 取值：{provider, model} 或 null=跟随会话模型。写入后由部署层注入 compaction-basic。
+      compactionModel: z.object({
+        provider: z.string(),
+        model: z.string()
+      }).nullable().optional(),
+      // 自动重命名模型选择：设置页「DSH 同款解析选择器」选定的模型。
+      // 取值：{provider, model} 或 null=跟随会话模型（默认）。优先级：
+      //   UI 选择 > patch 配置（autoRenameProvider/Model）> 会话 request/header。
+      autoRenameModel: z.object({
+        provider: z.string(),
+        model: z.string()
+      }).nullable().optional(),
+      // 自动续跑全局闸门（与 guardian 联动）：
+      //   closed → 一切自动续跑跳过（周期扫描/面板 scan 的自动续跑部分均不续）；
+      //   open   → 恢复原有判定。DSH 刚启动 guardian 置 closed（防崩溃恢复后自动续跑
+      //   批量建空壳会话）；用户手动开启（API/面板）或检测到「用户第一次手动对话」
+      //   （turn/start 由 user 发起）后自动置 open。
+      autoContinueGate: z.enum(["open", "closed"]).default("open"),
+      // 额外 md 注入：设置卡上传的 md 清单（内容落盘 <DSH_HOME>/extra-inject-md/）
+      extraMdFiles: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        addedAt: z.number().optional()
+      })).default([]),
+      // 会话模板注入：plan（方案模板）/ closing（收尾模板）两个固定槽位
+      // 元信息存 domain，内容落盘 <DSH_HOME>/template-inject-md/<slot>.md
+      sessionTemplates: z.object({
+        plan: z.object({
+          enabled: z.boolean().default(false),
+          enforce: z.boolean().default(false), //  强制门禁：未出提案+未确认前拒绝改码工具
+          name: z.string().default(""),
+          url: z.string().default(""),
+          bytes: z.number().default(0),
+          updatedAt: z.number().default(0)
+        }).default({ enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 }),
+        closing: z.object({
+          enabled: z.boolean().default(false),
+          enforce: z.boolean().default(false),
+          name: z.string().default(""),
+          url: z.string().default(""),
+          bytes: z.number().default(0),
+          updatedAt: z.number().default(0)
+        }).default({ enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 })
+      }).default({ plan: { enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 }, closing: { enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 } }),
+      // 成员模型切换意图（sessionId → {provider, model}）：
+      // 切模型随时可做（成员 inactive/未挂载时也能切）——意图持久化在这里，
+      // 成员下次 resume/运行时由 resumeSetupFor 应用（优先于会话最近路由）。
+      memberModelOverrides: z.record(z.object({
+        provider: z.string(),
+        model: z.string()
+      })).default({})
+    }),
+    initial: {
+      autoRename: {},
+      autoContinue: {},
+      compactionModel: null,
+      autoRenameModel: null,
+      autoContinueGate: "open",
+      extraMdFiles: [],
+      sessionTemplates: {
+        plan: { enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 },
+        closing: { enabled: false, enforce: false, name: "", url: "", bytes: 0, updatedAt: 0 }
+      },
+      memberModelOverrides: {}
+    },
+  },
+  tables: {}
+});
+
+let domainPromise = null;
+/** 域当前是否「已打开且尚未关闭」。
+ *  用于判断重载时能否复用缓存——只凭 domainPromise 是否为 null 判断不了
+ *  「域是活的还是已被关掉」，这正是「domain already open / domain is closed」两类 500 的根源。 */
+let domainLive = false;
+
+/**
+ * 打开（或复用）插件持久化域。
+ * @param {object} ctx 插件上下文
+ * @returns {Promise<object>} 域对象；storageDomain 服务缺失时 reject
+ */
+export function pluginDomain(ctx) {
+  if (domainPromise === null) {
+    const storage = ctx.get("storageDomain");
+    if (!storage) return Promise.reject(new Error("storageDomain 不可用"));
+    domainPromise = storage.open(pluginDomainSpec).then((domain) => {
+      domainLive = true;
+      // 只在 apply 的活跃 fiber 上挂 close；HTTP handler / 事件回调 fiber 是 inactive，
+      // ctx.effect 会抛 cannot create effect on inactive context，且 rejected Promise 被缓存后 list 一直 500。
+      try {
+        ctx.effect(() => () => {
+          // 关闭的同时把缓存与存活标记一起清掉——下一次 apply 才会重新 open。
+          // 【原代码】只 return domain.close()（缓存不清），靠 apply 开头无条件 domainPromise = null 兜，
+          //   遇到「域还活着就重载」时会在旧的活域上再 open 一次 → storage 报 already open → list 500。
+          domainLive = false;
+          domainPromise = null;
+          return domain.close();
+        }, "session-conductor: domain close");
+      } catch {
+        /* 请求路径打开时不挂 effect；apply() 已预热并挂过 */
+      }
+      return domain;
+    }).catch((err) => {
+      domainPromise = null;
+      domainLive = false;
+      throw err;
+    });
+  }
+  return domainPromise;
+}
+
+/** 读域里的全局状态对象。 */
+export async function pluginState(ctx) {
+  const domain = await pluginDomain(ctx);
+  return domain.global.get();
+}
+
+/** 当前域是否已打开且存活（apply 重载判定用）。 */
+export function isDomainLive() {
+  return domainLive;
+}
+
+/** 测试钩子：清空域缓存（单测在场景之间调用，避免上一条用例的域串到下一条）。 */
+export function resetDomainForTest() {
+  domainPromise = null;
+  domainLive = false;
+}

package/lib/core/lazy.js

@@ -0,0 +1,20 @@
+// dsh-session-conductor — 重量级模块的按需加载器
+//
+// 【为什么单独成文件】修复/分析类模块（repair、zstd-frames、seq-gap、eio、value）
+// 体积大且只在特定功能触发时才用到；按需 import 可让插件启动更快。
+// 拆分成多个域后，各域都需要这些加载器——集中在这里避免重复定义与循环引用。
+
+let _lazyRepair = null;
+let _lazyZstd = null;
+let _lazySeqGap = null;
+let _lazyEio = null;
+let _lazyValue = null;
+let _lazyFs = null;
+
+export const lazyRepair = () => (_lazyRepair ??= import("../repair.js"));
+export const lazyZstd = () => (_lazyZstd ??= import("../zstd-frames.js"));
+export const lazySeqGap = () => (_lazySeqGap ??= import("../seq-gap-repair.js"));
+export const lazyEio = () => (_lazyEio ??= import("../eio-repair.js"));
+export const lazyValue = () => (_lazyValue ??= import("../value.js"));
+/** node:fs 的按需加载：只有删会话备份扫描等少数路径需要 readdirSync/existsSync。 */
+export const lazyFs = () => (_lazyFs ??= import("node:fs"));

package/lib/core/state.js

@@ -0,0 +1,106 @@
+// dsh-session-conductor — 共享运行时状态与串行锁
+//
+// 【为什么单独成文件】这些 Map/计数器被多个域共用：
+//   continueJobs（进行中的续跑）既被续跑域写、也被会话列表域读（面板展示「续跑中」）；
+//   deleteLocks / continueLocks / 并发闸 被续跑、删除、撤回同时用到。
+// 集中在此保证「同一份状态」，避免各域各建一份导致计数/状态不一致。
+
+import { cfg } from "./config.js";
+import { pendingTimers } from "../features/rename/analysis.js";
+
+/** 防抖定时器（会话 → timer）。 */
+export const continueTimers = new Map();
+/** 每会话串行锁（续跑排队）。 */
+export const continueLocks = new Map();
+/** 进行中的续跑（会话 → job；UI 状态用）。 */
+export const continueJobs = new Map();
+/** 每会话删除锁（删除是破坏性操作，同会话删除请求排队串行）。 */
+export const deleteLocks = new Map();
+
+/** 全局并发续跑数（并发闸计数）。 */
+let activeContinues = 0;
+/** 周期扫描定时器句柄。 */
+let scanTimer = null;
+
+/** 每会话删除锁：同一会话的删除请求排队串行执行（并发删除不交错）。 */
+export function withDeleteLock(sessionId, fn) {
+  const prev = deleteLocks.get(sessionId) ?? Promise.resolve();
+  const run = prev.then(fn, () => fn());
+  const guard = run
+    .catch(() => void 0)
+    .finally(() => {
+      if (deleteLocks.get(sessionId) === guard) deleteLocks.delete(sessionId);
+    });
+  deleteLocks.set(sessionId, guard);
+  return run;
+}
+
+/** 每会话串行锁：同一会话的续跑排队执行。 */
+export function withSessionLock(sessionId, fn) {
+  const prev = continueLocks.get(sessionId) ?? Promise.resolve();
+  const run = prev.then(fn, () => fn());
+  const guard = run
+    .catch(() => void 0)
+    .finally(() => {
+      if (continueLocks.get(sessionId) === guard) continueLocks.delete(sessionId);
+    });
+  continueLocks.set(sessionId, guard);
+  return run;
+}
+
+/** 并发闸轮询间隔（毫秒）：等名额释放时的重试节奏，兼顾响应速度与空转开销。 */
+const GATE_POLL_INTERVAL_MS = 250;
+
+/** 全局并发闸：达到 cfg.maxConcurrent 时等待。 */
+export async function withConcurrencyGate(fn) {
+  while (activeContinues >= cfg.maxConcurrent) {
+    await new Promise((resolve) => setTimeout(resolve, GATE_POLL_INTERVAL_MS));
+  }
+  activeContinues += 1;
+  try {
+    return await fn();
+  } finally {
+    activeContinues -= 1;
+  }
+}
+
+/** 取消某会话遗留的防抖定时器与续跑记账（删除时调用，避免删除后定时器再触发）。 */
+export function cancelSessionTimers(sessionId) {
+  const ct = continueTimers.get(sessionId);
+  if (ct !== void 0) {
+    clearTimeout(ct);
+    continueTimers.delete(sessionId);
+  }
+  const pt = pendingTimers.get(sessionId);
+  if (pt !== void 0) {
+    clearTimeout(pt);
+    pendingTimers.delete(sessionId);
+  }
+  if (continueJobs.has(sessionId)) continueJobs.delete(sessionId);
+}
+
+/** 周期扫描定时器读写（插件启停扫描用）。 */
+export function getScanTimer() {
+  return scanTimer;
+}
+export function setScanTimer(timer) {
+  scanTimer = timer;
+  return scanTimer;
+}
+
+/** 当前并发续跑数（面板/测试观察用）。 */
+export function activeContinueCount() {
+  return activeContinues;
+}
+
+/** 测试钩子：清空全部运行时状态（单测在场景之间调用）。 */
+export function resetRuntimeStateForTest() {
+  for (const timer of continueTimers.values()) clearTimeout(timer);
+  continueTimers.clear();
+  continueLocks.clear();
+  continueJobs.clear();
+  deleteLocks.clear();
+  activeContinues = 0;
+  if (scanTimer !== null) clearTimeout(scanTimer);
+  scanTimer = null;
+}

package/lib/core.js

@@ -0,0 +1,82 @@
+// dsh-task-completion 核心纯函数：渲染收尾块 + 校验收尾格式。
+// 不依赖 ctx / DSH 服务，可独立单测（test-core.mjs）。
+// 与 skill `task-completion-report` 的格式约定保持一致。
+
+export const DIVIDER = "══════════════════════════";
+
+const STATUS_MARKERS = {
+  done: "✅ 任务完成",
+  partial: "⚠️ 未完成",
+  failed: "❌ 失败"
+};
+
+/** 合法状态集合（供 API/工具入参校验）。 */
+export const VALID_STATUSES = Object.keys(STATUS_MARKERS);
+
+/**
+ * 渲染标准收尾块。
+ * @param options.delivered - 交付了什么（可多行）
+ * @param options.verified  - 验证状态（可多行）
+ * @param options.remaining - 遗留事项（可多行）
+ * @param options.status    - done | partial | failed
+ * @returns 带分隔线与状态标记的完整收尾块文本。
+ */
+export function renderCompletionBlock(options = {}) {
+  const status = VALID_STATUSES.includes(options.status) ? options.status : "done";
+  const lines = [];
+  lines.push(DIVIDER);
+  lines.push(STATUS_MARKERS[status]);
+  lines.push("");
+  if (hasText(options.delivered)) {
+    lines.push("交付：");
+    lines.push(String(options.delivered));
+    lines.push("");
+  }
+  if (hasText(options.verified)) {
+    lines.push("验证：");
+    lines.push(String(options.verified));
+    lines.push("");
+  }
+  if (hasText(options.remaining)) {
+    lines.push("遗留：");
+    lines.push(String(options.remaining));
+  }
+  lines.push(DIVIDER);
+  // 去掉结尾多余空行，保持结构紧凑
+  while (lines.length > 0 && lines.at(-1) === "") lines.pop();
+  return lines.join("\n");
+}
+
+/**
+ * 校验一段文本是否符合任务完成收尾格式（启发式）。
+ * @param text - 待校验文本
+ * @returns {ok, hasDivider, hasMarker, hasDelivered, hasVerified, hasRemaining, missing}
+ *   missing 为缺失项数组（divider / marker / delivered / verified / remaining）。
+ */
+export function checkCompletionText(text) {
+  const t = typeof text === "string" ? text : "";
+  const hasDivider = /^═{4,}$/m.test(t);
+  const hasMarker = /(✅\s*任务完成|❌\s*失败|⚠️\s*未完成|✅\s*任务失败|✅\s*Done|✅\s*Task completed)/.test(t);
+  const hasDelivered = /交付|delivered|deliver/i.test(t) && /[:：]/.test(t);
+  const hasVerified = /验证|verified|verify/i.test(t);
+  const hasRemaining = /遗留|remaining|left|todo|边界/i.test(t);
+  const missing = [];
+  if (!hasDivider) missing.push("divider");
+  if (!hasMarker) missing.push("marker");
+  if (!hasDelivered) missing.push("delivered");
+  if (!hasVerified) missing.push("verified");
+  if (!hasRemaining) missing.push("remaining");
+  return {
+    ok: missing.length === 0,
+    hasDivider,
+    hasMarker,
+    hasDelivered,
+    hasVerified,
+    hasRemaining,
+    missing
+  };
+}
+
+function hasText(value) {
+  return typeof value === "string" && value.trim() !== "";
+}