chatlab-cli 0.28.0 → 0.28.1

package/dist/chunk-YBS3YQB6.mjs

@@ -0,0 +1,1336 @@
+import { createRequire as __createRequire } from 'module';
+import { dirname as __pathDirname } from 'path';
+import { fileURLToPath as __fileURLToPath } from 'url';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  BGE_BASE_PROFILE,
+  CHUNKER_VERSION,
+  CHUNK_VECTOR_INDEX_INDEXES,
+  CHUNK_VECTOR_INDEX_TABLE,
+  DEFAULT_CHUNKER_CONFIG,
+  DESENSITIZE_RULES_SCHEMA_VERSION,
+  EMBEDDING_INDEX_SCHEMA,
+  EmbeddingIndexStore,
+  LocalEmbeddingProvider,
+  MEANINGFUL_POS_TAGS,
+  OpenAICompatibleEmbeddingProvider,
+  QWEN3_PROFILE,
+  SEARCH_MAX_RESULTS_DEFAULT,
+  SEARCH_MAX_RESULTS_MAX,
+  SEARCH_MAX_RESULTS_MIN,
+  SEMANTIC_INDEX_AUTH_PROFILE,
+  SEMANTIC_INDEX_CONFIG_FILE,
+  SEMANTIC_INDEX_CONFIG_VERSION,
+  SEMANTIC_INDEX_DB_FILE,
+  SEMANTIC_INDEX_SESSION_TABLE,
+  STRATEGY_ID,
+  SemanticIndexConfigStore,
+  SemanticIndexJobQueue,
+  SemanticIndexService,
+  SemanticIndexStateStore,
+  StaticPathProvider,
+  applyQueryInstruction,
+  assembleEvidence,
+  chunkMessages,
+  clampSearchMaxResults,
+  clampTextChars,
+  composeChunkId,
+  computeChunkerConfigHash,
+  computeDbPathHash,
+  createChatDbFtsSearcher,
+  createChatDbMessageRangeReader,
+  createChatDbMessageSource,
+  createEmbedder,
+  createSemanticIndexService,
+  defaultSemanticIndexConfig,
+  deriveParentId,
+  detectConflictsInMessages,
+  estimateTokens,
+  extractFtsKeywords,
+  formatEvidenceMessages,
+  generateMessageKey,
+  getCache,
+  getCollidingPlatformIds,
+  getJieba,
+  getLocalProfileByModelId,
+  getLocalProfilesForLocale,
+  hybridSearch,
+  isKeylessSemanticIndexApiBaseUrl,
+  isSemanticIndexConfigured,
+  isSemanticVoid,
+  isStopword,
+  loadConfig,
+  mergeMembers,
+  migrateFromElectronIfNeeded,
+  normalizePlatformId,
+  parseParentBounds,
+  persistSemanticIndexConfig,
+  reciprocalRankFusion,
+  resolveApiKey,
+  resolveModelId,
+  resolveSemanticIndexApiKeySet,
+  runWarmup,
+  setCache,
+  snapshotPathProvider,
+  vecTableName,
+  vecTableSchema,
+  writeConfigField
+} from "./chunk-ZVDOFWL7.mjs";
+import {
+  __export
+} from "./chunk-GFHSSCCR.mjs";
+
+// ../../packages/node-runtime/src/node-path-provider.ts
+import * as fs2 from "fs";
+import * as os from "os";
+import * as path2 from "path";
+
+// ../../packages/node-runtime/src/data-dir-switch.ts
+import * as fs from "fs";
+import * as path from "path";
+var CHATLAB_MARKER_FILE = ".chatlab";
+var USER_DATA_REQUIRED_DIRS = ["databases"];
+var PENDING_MIGRATION_FILE = "data-dir-migration.json";
+var DANGEROUS_PATHS = [
+  "C:\\Windows",
+  "C:\\Program Files",
+  "C:\\Program Files (x86)",
+  "C:\\ProgramData",
+  "/usr",
+  "/etc",
+  "/bin",
+  "/sbin",
+  "/lib",
+  "/var",
+  "/boot",
+  "/root",
+  "/System",
+  "/Library"
+];
+function normalizePathForCompare(input) {
+  const resolved = path.resolve(input);
+  const normalized = path.normalize(resolved);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isSubPath(parent, child) {
+  const parentPath = normalizePathForCompare(parent);
+  const childPath = normalizePathForCompare(child);
+  if (parentPath === childPath) return false;
+  return childPath.startsWith(`${parentPath}${path.sep}`);
+}
+function isPathSafe(targetPath) {
+  const normalizedTarget = targetPath.toLowerCase().replace(/\//g, "\\");
+  for (const dangerous of DANGEROUS_PATHS) {
+    const normalizedDangerous = dangerous.toLowerCase().replace(/\//g, "\\");
+    if (normalizedTarget.startsWith(normalizedDangerous)) {
+      return false;
+    }
+  }
+  return true;
+}
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function hasChatLabUserDataStructure(entries) {
+  return entries.includes(CHATLAB_MARKER_FILE) && USER_DATA_REQUIRED_DIRS.every((dir) => entries.includes(dir));
+}
+function hasChatLabDatabaseFiles(dirPath, entries) {
+  const dirEntries = entries ?? fs.readdirSync(dirPath);
+  if (!dirEntries.includes("databases")) return false;
+  const dbDir = path.join(dirPath, "databases");
+  try {
+    return fs.existsSync(dbDir) && fs.readdirSync(dbDir).some((file) => file.endsWith(".db"));
+  } catch {
+    return false;
+  }
+}
+function isExistingUserDataDir(dirPath) {
+  if (!fs.existsSync(dirPath)) return false;
+  try {
+    const entries = fs.readdirSync(dirPath);
+    return hasChatLabUserDataStructure(entries) || hasChatLabDatabaseFiles(dirPath, entries);
+  } catch {
+    return false;
+  }
+}
+function isUserDataDirSafeToUse(dirPath) {
+  if (!fs.existsSync(dirPath)) return true;
+  try {
+    const entries = fs.readdirSync(dirPath);
+    if (entries.length === 0) return true;
+    return hasChatLabUserDataStructure(entries) || hasChatLabDatabaseFiles(dirPath, entries);
+  } catch {
+    return false;
+  }
+}
+function isDirectoryEmptyOrMissing(dirPath) {
+  if (!fs.existsSync(dirPath)) return true;
+  try {
+    return fs.readdirSync(dirPath).length === 0;
+  } catch {
+    return false;
+  }
+}
+function copyDirMerge(src, dest, mkdir = ensureDir, stats = { copied: 0, skipped: 0, errors: [] }) {
+  if (!fs.existsSync(src)) return stats;
+  try {
+    mkdir(dest);
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+      try {
+        if (entry.isDirectory()) {
+          copyDirMerge(srcPath, destPath, mkdir, stats);
+        } else if (!fs.existsSync(destPath)) {
+          fs.copyFileSync(srcPath, destPath);
+          stats.copied++;
+        } else {
+          stats.skipped++;
+        }
+      } catch (error) {
+        stats.errors.push(`\u590D\u5236\u5931\u8D25: ${srcPath} -> ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  } catch (error) {
+    stats.errors.push(`\u8BFB\u53D6\u76EE\u5F55\u5931\u8D25: ${src} -> ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return stats;
+}
+function createPendingDataDirMigration(input) {
+  return {
+    from: input.from,
+    to: input.to,
+    migrate: input.migrate,
+    deleteSourceOnSuccess: input.migrate && input.targetWasEmpty,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function runPendingDataDirMigration(pending, deps) {
+  const copy = deps.copyDirMerge ?? copyDirMerge;
+  const mkdir = deps.ensureDir ?? ensureDir;
+  let stats = { copied: 0, skipped: 0, errors: [] };
+  if (pending.migrate && path.resolve(pending.from) !== path.resolve(pending.to)) {
+    if (!fs.existsSync(pending.from)) {
+      return {
+        success: false,
+        from: pending.from,
+        to: pending.to,
+        copied: 0,
+        skipped: 0,
+        errors: [`\u6E90\u6570\u636E\u76EE\u5F55\u4E0D\u5B58\u5728: ${pending.from}`]
+      };
+    }
+    stats = copy(pending.from, pending.to, mkdir);
+    deps.log?.(
+      `\u6570\u636E\u76EE\u5F55\u8FC1\u79FB\u5B8C\u6210: \u4ECE ${pending.from} \u5230 ${pending.to}\uFF0C\u590D\u5236 ${stats.copied} \u9879\uFF0C\u8DF3\u8FC7 ${stats.skipped} \u9879\uFF0C\u9519\u8BEF ${stats.errors.length} \u9879`
+    );
+    if (stats.errors.length > 0) {
+      return {
+        success: false,
+        from: pending.from,
+        to: pending.to,
+        copied: stats.copied,
+        skipped: stats.skipped,
+        errors: stats.errors
+      };
+    }
+  } else {
+    mkdir(pending.to);
+  }
+  deps.writeUserDataDir(pending.to);
+  deps.clearPendingMigration();
+  if (pending.deleteSourceOnSuccess && path.resolve(pending.from) !== path.resolve(pending.to)) {
+    deps.markPendingDeleteDir?.(pending.from);
+  }
+  return {
+    success: true,
+    from: pending.from,
+    to: pending.to,
+    copied: stats.copied,
+    skipped: stats.skipped,
+    errors: []
+  };
+}
+function getPendingMigrationPath(systemDir) {
+  return path.join(systemDir, "settings", PENDING_MIGRATION_FILE);
+}
+function getPendingNodeDataDirMigration(systemDir) {
+  const filePath = getPendingMigrationPath(systemDir);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (!parsed.from || !parsed.to || typeof parsed.migrate !== "boolean") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function clearPendingNodeDataDirMigration(systemDir) {
+  const filePath = getPendingMigrationPath(systemDir);
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+}
+function deleteOldUserDataDirIfSafe(dirPath, currentDir, removeDir) {
+  if (path.resolve(dirPath) === path.resolve(currentDir)) return false;
+  if (!isPathSafe(dirPath)) return false;
+  if (!fs.existsSync(dirPath)) return false;
+  if (!isExistingUserDataDir(dirPath)) return false;
+  const remove = removeDir ?? ((dir) => fs.rmSync(dir, { recursive: true, force: true }));
+  remove(dirPath);
+  return true;
+}
+function writePendingNodeDataDirMigration(systemDir, pending) {
+  const filePath = getPendingMigrationPath(systemDir);
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, JSON.stringify(pending, null, 2), "utf-8");
+}
+function createNodeDataDirSwitch(input) {
+  if (input.envDataDir) {
+    return { success: false, error: "CHATLAB_DATA_DIR is set, data directory cannot be changed from Web UI" };
+  }
+  const newDir = (input.targetDir?.trim() || input.defaultDir || "").trim();
+  if (!newDir) return { success: false, error: "Data directory is required" };
+  if (!path.isAbsolute(newDir)) return { success: false, error: "Data directory must be an absolute path" };
+  if (!isPathSafe(newDir)) return { success: false, error: "System directories cannot be used as data directory" };
+  const migrate = input.migrate !== false;
+  if (migrate && path.resolve(input.currentDir) !== path.resolve(newDir) && isSubPath(input.currentDir, newDir)) {
+    return { success: false, error: "Target directory cannot be inside current data directory" };
+  }
+  if (!isUserDataDirSafeToUse(newDir)) {
+    return { success: false, error: "Target directory is not empty and is not a ChatLab data directory" };
+  }
+  if (path.resolve(input.currentDir) === path.resolve(newDir)) {
+    clearPendingNodeDataDirMigration(input.systemDir);
+    return { success: true, from: input.currentDir, to: newDir, requiresRelaunch: false };
+  }
+  const pending = createPendingDataDirMigration({
+    from: input.currentDir,
+    to: newDir,
+    migrate,
+    targetWasEmpty: isDirectoryEmptyOrMissing(newDir)
+  });
+  writePendingNodeDataDirMigration(input.systemDir, pending);
+  return { success: true, from: input.currentDir, to: newDir, requiresRelaunch: true };
+}
+function applyPendingNodeDataDirMigration(systemDir, deps = {}) {
+  const pending = getPendingNodeDataDirMigration(systemDir);
+  if (!pending) return { success: true, skipped: true };
+  const writeConfig = deps.writeConfigField ?? writeConfigField;
+  const result = runPendingDataDirMigration(pending, {
+    writeUserDataDir(dir) {
+      writeConfig("data", "user_data_dir", dir);
+      writeConfig("data", "electron_migration_done", true);
+    },
+    clearPendingMigration() {
+      clearPendingNodeDataDirMigration(systemDir);
+    },
+    markPendingDeleteDir(dir) {
+      deleteOldUserDataDirIfSafe(dir, pending.to, deps.removeDir);
+    }
+  });
+  if (!result.success) {
+    return { success: false, error: result.errors.join("; ") || "Data directory migration failed" };
+  }
+  return { success: true };
+}
+
+// ../../packages/node-runtime/src/node-path-provider.ts
+var SYSTEM_DIR = path2.join(os.homedir(), ".chatlab");
+var _pendingElectronDataWarning = false;
+function hasPendingElectronDataWarning() {
+  return _pendingElectronDataWarning;
+}
+function applyPendingNodeDataDirMigrationIfNeeded() {
+  if (process.env.CHATLAB_DATA_DIR) return { success: true, skipped: true };
+  return applyPendingNodeDataDirMigration(SYSTEM_DIR);
+}
+var NodePathProvider = class {
+  systemDir;
+  userDataDir;
+  constructor(userDataDir) {
+    this.systemDir = SYSTEM_DIR;
+    this.userDataDir = userDataDir || resolveUserDataDir();
+  }
+  getSystemDir() {
+    return this.systemDir;
+  }
+  getUserDataDir() {
+    return this.userDataDir;
+  }
+  getDatabaseDir() {
+    return path2.join(this.userDataDir, "databases");
+  }
+  getVectorDir() {
+    return path2.join(this.userDataDir, "vector");
+  }
+  getAiDataDir() {
+    return path2.join(this.systemDir, "ai");
+  }
+  getSettingsDir() {
+    return path2.join(this.systemDir, "settings");
+  }
+  getCacheDir() {
+    return path2.join(this.systemDir, "cache");
+  }
+  getTempDir() {
+    return path2.join(this.systemDir, "temp");
+  }
+  getLogsDir() {
+    return path2.join(this.systemDir, "logs");
+  }
+  getDownloadsDir() {
+    return path2.join(os.homedir(), "Downloads");
+  }
+  /**
+   * 确保系统目录和用户数据目录都存在
+   */
+  ensureAllDirs() {
+    const dirs = [
+      this.systemDir,
+      this.userDataDir,
+      this.getDatabaseDir(),
+      this.getVectorDir(),
+      this.getAiDataDir(),
+      this.getSettingsDir(),
+      this.getCacheDir(),
+      this.getTempDir(),
+      this.getLogsDir()
+    ];
+    for (const dir of dirs) {
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
+      }
+    }
+    const markerPath = path2.join(this.userDataDir, ".chatlab");
+    if (!fs2.existsSync(markerPath)) {
+      fs2.writeFileSync(markerPath, "ChatLab Data Directory", "utf-8");
+    }
+  }
+};
+function resolveUserDataDir() {
+  const envDir = process.env.CHATLAB_DATA_DIR;
+  if (envDir) {
+    return expandHome(envDir);
+  }
+  const config = loadConfig();
+  if (config.data.user_data_dir) {
+    return expandHome(config.data.user_data_dir);
+  }
+  const result = migrateFromElectronIfNeeded(SYSTEM_DIR);
+  if (result.migrated && result.userDataDir) {
+    return result.userDataDir;
+  }
+  const defaultDir = getDefaultNodeUserDataDir();
+  if (result.electronDetected) {
+    _pendingElectronDataWarning = true;
+    return defaultDir;
+  }
+  writeConfigField("data", "user_data_dir", defaultDir);
+  return defaultDir;
+}
+function getDefaultNodeUserDataDir() {
+  return path2.join(os.homedir(), ".chatlab", "data");
+}
+function getSystemLogsDir() {
+  return path2.join(SYSTEM_DIR, "logs");
+}
+function expandHome(filePath) {
+  if (filePath.startsWith("~/") || filePath === "~") {
+    return path2.join(os.homedir(), filePath.slice(1));
+  }
+  return filePath;
+}
+
+// ../../packages/node-runtime/src/jieba-nlp-provider.ts
+function createJiebaNlpProvider(dictType = "default") {
+  return {
+    tag(text) {
+      return getJieba(dictType).tag(text);
+    },
+    isStopword,
+    meaningfulPosTags: MEANINGFUL_POS_TAGS
+  };
+}
+
+// ../../packages/node-runtime/src/cache/analytics-cache.ts
+import * as fs3 from "fs";
+function getDbFileVersion(dbPath) {
+  const parts = [];
+  for (const p of [dbPath, `${dbPath}-wal`]) {
+    try {
+      const st = fs3.statSync(p);
+      parts.push(`${Math.floor(st.mtimeMs)}:${st.size}`);
+    } catch {
+      parts.push("-");
+    }
+  }
+  return parts.join("|");
+}
+function getOrComputeAnalysisCache(sessionId, key, queryCacheDir, version, compute) {
+  const cached = getCache(sessionId, key, queryCacheDir);
+  if (cached && cached.v === version) {
+    return cached.data;
+  }
+  const data = compute();
+  setCache(sessionId, key, { v: version, data }, queryCacheDir);
+  return data;
+}
+
+// ../../packages/node-runtime/src/preferences.ts
+import * as fs4 from "fs";
+import * as path3 from "path";
+var DEFAULTS = {
+  pinnedSessionIds: [],
+  aiPreprocessConfig: {
+    dataCleaning: true,
+    mergeConsecutive: true,
+    mergeWindowSeconds: 180,
+    blacklistKeywords: [],
+    denoise: true,
+    desensitize: true,
+    desensitizeRulesSchemaVersion: DESENSITIZE_RULES_SCHEMA_VERSION,
+    desensitizeBuiltinRuleOverrides: {},
+    desensitizeRules: [],
+    anonymizeNames: false
+  },
+  aiGlobalSettings: {
+    maxMessagesPerRequest: 1e3,
+    exportFormat: "markdown",
+    sqlExportFormat: "csv",
+    enableAutoSkill: true,
+    chartAutoMode: "suggest",
+    searchContextBefore: 2,
+    searchContextAfter: 2,
+    contextCompression: {
+      enabled: true,
+      tokenThresholdPercent: 75,
+      bufferSizePercent: 20,
+      maxToolResultPercent: 50
+    }
+  },
+  customKeywordTemplates: [],
+  deletedPresetTemplateIds: [],
+  wordFilter: {
+    schemes: [],
+    defaultSchemeId: null,
+    sessionSchemeOverrides: {}
+  },
+  filterHistory: [],
+  thinkingLevels: {},
+  ownerProfilesByPlatform: {},
+  ownerPromptDismissedSessionIds: []
+};
+var PreferencesManager = class {
+  filePath;
+  cache = null;
+  constructor(systemDir) {
+    this.filePath = path3.join(systemDir, "preferences.json");
+  }
+  load() {
+    if (this.cache) return this.cache;
+    try {
+      if (fs4.existsSync(this.filePath)) {
+        const raw = fs4.readFileSync(this.filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const migrated = this.migrateLegacyDesensitizeRules(parsed, raw);
+        this.cache = this.mergeDefaults(migrated.preferences);
+        if (migrated.changed) {
+          this.writePreferences(this.cache);
+        }
+        return this.cache;
+      }
+    } catch (err) {
+      console.warn("[Preferences] Failed to load preferences.json:", err);
+    }
+    this.cache = { ...DEFAULTS };
+    return this.cache;
+  }
+  save(partial) {
+    try {
+      const current = this.load();
+      const merged = this.deepMerge(
+        current,
+        partial
+      );
+      if (Object.prototype.hasOwnProperty.call(partial.aiPreprocessConfig ?? {}, "desensitizeBuiltinRuleOverrides")) {
+        const mergedAiPreprocessConfig = merged.aiPreprocessConfig;
+        mergedAiPreprocessConfig.desensitizeBuiltinRuleOverrides = partial.aiPreprocessConfig?.desensitizeBuiltinRuleOverrides;
+      }
+      this.cache = this.mergeDefaults(merged);
+      this.writePreferences(this.cache);
+      return { success: true };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error("[Preferences] Failed to save:", msg);
+      return { success: false, error: msg };
+    }
+  }
+  getFilePath() {
+    return this.filePath;
+  }
+  invalidateCache() {
+    this.cache = null;
+  }
+  mergeDefaults(partial) {
+    return {
+      pinnedSessionIds: partial.pinnedSessionIds ?? DEFAULTS.pinnedSessionIds,
+      aiPreprocessConfig: partial.aiPreprocessConfig ? this.normalizeAiPreprocessConfig(partial.aiPreprocessConfig) : { ...DEFAULTS.aiPreprocessConfig },
+      aiGlobalSettings: partial.aiGlobalSettings ? {
+        ...DEFAULTS.aiGlobalSettings,
+        ...partial.aiGlobalSettings,
+        contextCompression: {
+          ...DEFAULTS.aiGlobalSettings.contextCompression,
+          ...partial.aiGlobalSettings.contextCompression ?? {}
+        }
+      } : { ...DEFAULTS.aiGlobalSettings },
+      customKeywordTemplates: partial.customKeywordTemplates ?? DEFAULTS.customKeywordTemplates,
+      deletedPresetTemplateIds: partial.deletedPresetTemplateIds ?? DEFAULTS.deletedPresetTemplateIds,
+      wordFilter: partial.wordFilter ? { ...DEFAULTS.wordFilter, ...partial.wordFilter } : { ...DEFAULTS.wordFilter },
+      filterHistory: partial.filterHistory ?? DEFAULTS.filterHistory,
+      thinkingLevels: partial.thinkingLevels ?? DEFAULTS.thinkingLevels,
+      ownerProfilesByPlatform: partial.ownerProfilesByPlatform ?? DEFAULTS.ownerProfilesByPlatform,
+      ownerPromptDismissedSessionIds: partial.ownerPromptDismissedSessionIds ?? DEFAULTS.ownerPromptDismissedSessionIds
+    };
+  }
+  normalizeAiPreprocessConfig(partial) {
+    const defaults = DEFAULTS.aiPreprocessConfig;
+    const rules = Array.isArray(partial?.desensitizeRules) ? partial.desensitizeRules : [];
+    const customRules = rules.filter((rule) => !rule.builtin);
+    return {
+      dataCleaning: partial?.dataCleaning ?? defaults.dataCleaning,
+      mergeConsecutive: partial?.mergeConsecutive ?? defaults.mergeConsecutive,
+      mergeWindowSeconds: partial?.mergeWindowSeconds ?? defaults.mergeWindowSeconds,
+      blacklistKeywords: partial?.blacklistKeywords ?? defaults.blacklistKeywords,
+      denoise: partial?.denoise ?? defaults.denoise,
+      desensitize: partial?.desensitize ?? defaults.desensitize,
+      desensitizeRulesSchemaVersion: DESENSITIZE_RULES_SCHEMA_VERSION,
+      desensitizeBuiltinRuleOverrides: this.normalizeBooleanMap(partial?.desensitizeBuiltinRuleOverrides),
+      desensitizeRules: customRules,
+      anonymizeNames: partial?.anonymizeNames ?? defaults.anonymizeNames
+    };
+  }
+  normalizeBooleanMap(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+    const result = {};
+    for (const [key, flag] of Object.entries(value)) {
+      if (typeof flag === "boolean") result[key] = flag;
+    }
+    return result;
+  }
+  migrateLegacyDesensitizeRules(partial, rawContent) {
+    const rules = partial.aiPreprocessConfig?.desensitizeRules;
+    if (!Array.isArray(rules) || !rules.some((rule) => rule.builtin)) {
+      return { preferences: partial, changed: false };
+    }
+    this.backupLegacyPreferences(rawContent);
+    const legacyBuiltinRuleOverrides = rules.filter((rule) => rule.builtin && typeof rule.enabled === "boolean").reduce((overrides, rule) => {
+      overrides[rule.id] = rule.enabled;
+      return overrides;
+    }, {});
+    const existingOverrides = this.normalizeBooleanMap(partial.aiPreprocessConfig?.desensitizeBuiltinRuleOverrides);
+    return {
+      preferences: {
+        ...partial,
+        aiPreprocessConfig: {
+          ...partial.aiPreprocessConfig,
+          desensitizeRulesSchemaVersion: DESENSITIZE_RULES_SCHEMA_VERSION,
+          desensitizeBuiltinRuleOverrides: {
+            ...legacyBuiltinRuleOverrides,
+            ...existingOverrides
+          },
+          desensitizeRules: rules.filter((rule) => !rule.builtin)
+        }
+      },
+      changed: true
+    };
+  }
+  backupLegacyPreferences(rawContent) {
+    const backupDir = path3.join(path3.dirname(this.filePath), "backups");
+    if (!fs4.existsSync(backupDir)) {
+      fs4.mkdirSync(backupDir, { recursive: true });
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupPath = path3.join(backupDir, `preferences-pre-desensitize-groups-${timestamp}.json`);
+    fs4.writeFileSync(backupPath, rawContent, "utf-8");
+    console.info(`[Preferences] Backed up legacy desensitize rules to ${backupPath}`);
+  }
+  writePreferences(preferences) {
+    const dir = path3.dirname(this.filePath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
+    }
+    fs4.writeFileSync(this.filePath, JSON.stringify(preferences, null, 2), "utf-8");
+  }
+  /**
+   * Deep merge: arrays are replaced (not concatenated), objects are merged.
+   */
+  deepMerge(base, override) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+      if (value === void 0) continue;
+      if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof base[key] === "object" && base[key] !== null && !Array.isArray(base[key])) {
+        result[key] = this.deepMerge(base[key], value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+};
+
+// ../../packages/node-runtime/src/merger/index.ts
+function checkConflictsFromSources(dataSources) {
+  const allMessages = [];
+  for (const { source, filename } of dataSources) {
+    const meta = source.getMeta();
+    const platform = meta?.platform || "unknown";
+    source.streamMessages(1e4, (messages) => {
+      for (const msg of messages) {
+        allMessages.push({ msg, source: filename, platform });
+      }
+    });
+  }
+  return detectConflictsInMessages(allMessages);
+}
+function buildMergedOutput(dataSources, outputName) {
+  const metas = dataSources.map(({ source, filename }) => ({
+    meta: source.getMeta(),
+    members: source.getMembers(),
+    filename,
+    source
+  }));
+  const collidingIds = getCollidingPlatformIds(
+    metas.map(({ meta, members }) => ({
+      platform: meta?.platform || "unknown",
+      members: members.map((m) => ({ platformId: m.platformId }))
+    }))
+  );
+  const memberMap = mergeMembers(
+    metas.map(({ meta, members }) => ({
+      platform: meta?.platform || "unknown",
+      members
+    })),
+    collidingIds
+  );
+  const seenKeys = /* @__PURE__ */ new Set();
+  const mergedMessages = [];
+  for (const { source, meta } of metas) {
+    const platform2 = meta?.platform || "unknown";
+    source.streamMessages(1e4, (messages) => {
+      for (const msg of messages) {
+        const nid = normalizePlatformId(msg.senderPlatformId, platform2, collidingIds);
+        const key = generateMessageKey(msg.timestamp, nid, msg.content ?? null);
+        if (seenKeys.has(key)) continue;
+        seenKeys.add(key);
+        mergedMessages.push({
+          sender: nid,
+          accountName: msg.senderAccountName,
+          groupNickname: msg.senderGroupNickname,
+          timestamp: msg.timestamp,
+          type: msg.type,
+          content: msg.content
+        });
+      }
+    });
+  }
+  mergedMessages.sort((a, b) => a.timestamp - b.timestamp);
+  const sources = dataSources.map(({ source, filename }) => ({
+    filename,
+    platform: source.getMeta()?.platform || "unknown",
+    messageCount: source.getMessageCount()
+  }));
+  const uniquePlatforms = [...new Set(metas.map(({ meta }) => meta?.platform || "unknown"))];
+  const platform = uniquePlatforms.length === 1 ? uniquePlatforms[0] : "mixed";
+  const groupIds = new Set(metas.map(({ meta }) => meta?.groupId).filter(Boolean));
+  const groupId = groupIds.size === 1 ? metas.find(({ meta }) => meta?.groupId)?.meta?.groupId : void 0;
+  const groupAvatar = groupId ? metas.filter(({ meta }) => meta?.groupId === groupId).pop()?.meta?.groupAvatar : void 0;
+  const chatLabData = {
+    chatlab: {
+      version: "0.0.1",
+      exportedAt: Math.floor(Date.now() / 1e3),
+      generator: "ChatLab Merge Tool",
+      description: `Merged from ${dataSources.length} files`
+    },
+    meta: {
+      name: outputName,
+      platform,
+      type: metas[0]?.meta?.type || "group",
+      sources,
+      groupId,
+      groupAvatar
+    },
+    members: Array.from(memberMap.values()),
+    messages: mergedMessages
+  };
+  return { success: true, chatLabData };
+}
+function* serializeChatLabToJsonl(data) {
+  yield JSON.stringify({
+    _type: "header",
+    chatlab: data.chatlab,
+    meta: data.meta
+  });
+  for (const member of data.members) {
+    yield JSON.stringify({ _type: "member", ...member });
+  }
+  for (const msg of data.messages) {
+    yield JSON.stringify({ _type: "message", ...msg });
+  }
+}
+
+// ../../packages/node-runtime/src/services/analytics.ts
+import * as fs5 from "fs";
+import * as path4 from "path";
+var REGIONS = {
+  US: "https://us.aptabase.com",
+  EU: "https://eu.aptabase.com"
+};
+var DEFAULT_DATA = { lastReportDate: null, firstReportDate: null, enabled: true };
+var AnalyticsService = class {
+  dataPath;
+  endpoint;
+  appKey;
+  appVersion;
+  sessionId;
+  constructor(systemDir, appKey, appVersion) {
+    this.dataPath = path4.join(systemDir, "analytics.json");
+    this.appKey = appKey;
+    this.appVersion = appVersion;
+    this.sessionId = `${Math.floor(Date.now() / 1e3)}${Math.floor(Math.random() * 1e8).toString().padStart(8, "0")}`;
+    const parts = appKey.split("-");
+    const base = parts.length === 3 ? REGIONS[parts[1]] : void 0;
+    this.endpoint = base ? `${base}/api/v0/event` : null;
+  }
+  load() {
+    try {
+      if (fs5.existsSync(this.dataPath)) {
+        return { ...DEFAULT_DATA, ...JSON.parse(fs5.readFileSync(this.dataPath, "utf-8")) };
+      }
+    } catch (_e) {
+    }
+    return { ...DEFAULT_DATA };
+  }
+  save(data) {
+    try {
+      fs5.writeFileSync(this.dataPath, JSON.stringify(data, null, 2), "utf-8");
+    } catch (e) {
+      console.error("[Analytics] Failed to save:", e);
+    }
+  }
+  getEnabled() {
+    return this.load().enabled;
+  }
+  setEnabled(enabled) {
+    const data = this.load();
+    data.enabled = enabled;
+    this.save(data);
+  }
+  async track(eventName, props) {
+    if (!this.endpoint) return false;
+    if (!this.getEnabled()) return false;
+    try {
+      const resp = await fetch(this.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "App-Key": this.appKey },
+        body: JSON.stringify({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          sessionId: this.sessionId,
+          eventName,
+          systemProps: {
+            isDebug: false,
+            locale: "",
+            osName: process.platform,
+            osVersion: "",
+            engineName: "Node.js",
+            engineVersion: process.versions.node,
+            appVersion: this.appVersion,
+            sdkVersion: "chatlab@1"
+          },
+          props
+        })
+      });
+      return resp.ok;
+    } catch (e) {
+      console.error(`[Analytics] Failed to track ${eventName}:`, e);
+      return false;
+    }
+  }
+  async trackDailyActive(props) {
+    if (!this.endpoint) return;
+    const data = this.load();
+    if (!data.enabled) return;
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const isNew = data.firstReportDate === null;
+    if (isNew) data.firstReportDate = today;
+    if (data.lastReportDate === today) {
+      if (isNew) this.save(data);
+      return;
+    }
+    const tracked = await this.track(isNew ? "app_active_new" : "app_active", props);
+    if (!tracked) return;
+    data.lastReportDate = today;
+    this.save(data);
+  }
+};
+
+// ../../packages/node-runtime/src/semantic-index/index.ts
+var semantic_index_exports = {};
+__export(semantic_index_exports, {
+  CHUNKER_VERSION: () => CHUNKER_VERSION,
+  CHUNK_VECTOR_INDEX_INDEXES: () => CHUNK_VECTOR_INDEX_INDEXES,
+  CHUNK_VECTOR_INDEX_TABLE: () => CHUNK_VECTOR_INDEX_TABLE,
+  DEFAULT_CHUNKER_CONFIG: () => DEFAULT_CHUNKER_CONFIG,
+  EMBEDDING_INDEX_SCHEMA: () => EMBEDDING_INDEX_SCHEMA,
+  EmbeddingIndexStore: () => EmbeddingIndexStore,
+  SEARCH_MAX_RESULTS_DEFAULT: () => SEARCH_MAX_RESULTS_DEFAULT,
+  SEARCH_MAX_RESULTS_MAX: () => SEARCH_MAX_RESULTS_MAX,
+  SEARCH_MAX_RESULTS_MIN: () => SEARCH_MAX_RESULTS_MIN,
+  SEMANTIC_INDEX_AUTH_PROFILE: () => SEMANTIC_INDEX_AUTH_PROFILE,
+  SEMANTIC_INDEX_CONFIG_FILE: () => SEMANTIC_INDEX_CONFIG_FILE,
+  SEMANTIC_INDEX_CONFIG_VERSION: () => SEMANTIC_INDEX_CONFIG_VERSION,
+  SEMANTIC_INDEX_DB_FILE: () => SEMANTIC_INDEX_DB_FILE,
+  SEMANTIC_INDEX_SESSION_TABLE: () => SEMANTIC_INDEX_SESSION_TABLE,
+  STRATEGY_ID: () => STRATEGY_ID,
+  SemanticIndexConfigStore: () => SemanticIndexConfigStore,
+  SemanticIndexJobQueue: () => SemanticIndexJobQueue,
+  SemanticIndexService: () => SemanticIndexService,
+  SemanticIndexStateStore: () => SemanticIndexStateStore,
+  SemanticIndexWorkerClient: () => SemanticIndexWorkerClient,
+  StaticPathProvider: () => StaticPathProvider,
+  assembleEvidence: () => assembleEvidence,
+  chunkMessages: () => chunkMessages,
+  clampSearchMaxResults: () => clampSearchMaxResults,
+  composeChunkId: () => composeChunkId,
+  computeChunkerConfigHash: () => computeChunkerConfigHash,
+  computeDbPathHash: () => computeDbPathHash,
+  createChatDbFtsSearcher: () => createChatDbFtsSearcher,
+  createChatDbMessageRangeReader: () => createChatDbMessageRangeReader,
+  createChatDbMessageSource: () => createChatDbMessageSource,
+  createEmbedder: () => createEmbedder,
+  createSemanticIndexService: () => createSemanticIndexService,
+  createSemanticIndexWorkerClient: () => createSemanticIndexWorkerClient,
+  createSemanticIndexWorkerRuntimeClient: () => createSemanticIndexWorkerRuntimeClient,
+  createSemanticIndexWorkerThreadTransport: () => createSemanticIndexWorkerThreadTransport,
+  defaultSemanticIndexConfig: () => defaultSemanticIndexConfig,
+  deriveParentId: () => deriveParentId,
+  embedding: () => embedding_exports,
+  estimateTokens: () => estimateTokens,
+  extractFtsKeywords: () => extractFtsKeywords,
+  formatEvidenceMessages: () => formatEvidenceMessages,
+  hybridSearch: () => hybridSearch,
+  isSemanticIndexConfigured: () => isSemanticIndexConfigured,
+  isSemanticVoid: () => isSemanticVoid,
+  parseParentBounds: () => parseParentBounds,
+  persistSemanticIndexConfig: () => persistSemanticIndexConfig,
+  reciprocalRankFusion: () => reciprocalRankFusion,
+  resolveModelId: () => resolveModelId,
+  resolveSemanticIndexApiKeySet: () => resolveSemanticIndexApiKeySet,
+  runWarmup: () => runWarmup,
+  snapshotPathProvider: () => snapshotPathProvider,
+  vecTableName: () => vecTableName,
+  vecTableSchema: () => vecTableSchema
+});
+
+// ../../packages/node-runtime/src/semantic-index/worker-client.ts
+import path5 from "path";
+
+// ../../packages/node-runtime/src/semantic-index/worker-thread-transport.ts
+import { Worker } from "worker_threads";
+var DEFAULT_CLOSE_TIMEOUT_MS = 3e3;
+function defaultWorkerEntryUrl() {
+  return import.meta.url.endsWith(".ts") ? new URL("./worker-thread-entry.ts", import.meta.url) : new URL("./worker-thread-entry.js", import.meta.url);
+}
+function normalizeWorkerEntryUrl(entryUrl) {
+  if (!entryUrl) return defaultWorkerEntryUrl();
+  return typeof entryUrl === "string" ? new URL(entryUrl) : entryUrl;
+}
+function createDefaultWorker(startup, entryUrlInput) {
+  const entryUrl = normalizeWorkerEntryUrl(entryUrlInput);
+  if (!entryUrl.href.endsWith(".ts")) {
+    return new Worker(entryUrl, { workerData: startup });
+  }
+  const bootstrap = `
+    import { register } from 'tsx/esm/api';
+    register();
+    await import(${JSON.stringify(entryUrl.href)});
+  `;
+  const options = {
+    eval: true,
+    type: "module",
+    workerData: startup,
+    execArgv: []
+  };
+  return new Worker(bootstrap, options);
+}
+var SemanticIndexWorkerThreadTransport = class {
+  worker;
+  pending = /* @__PURE__ */ new Map();
+  requestId = 0;
+  closeTimeoutMs;
+  constructor(options) {
+    this.closeTimeoutMs = options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
+    this.worker = options.workerFactory?.() ?? createDefaultWorker(options.startup, options.workerEntryUrl);
+    this.worker.on("message", (message) => this.handleMessage(message));
+    this.worker.on("error", (error) => this.rejectAll(error));
+    this.worker.on("exit", (code) => {
+      if (code !== 0) this.rejectAll(new Error(`Semantic index worker exited with code ${code}`));
+    });
+  }
+  request(method, args) {
+    const id = `si_${++this.requestId}`;
+    return new Promise((resolve2, reject) => {
+      this.pending.set(id, { resolve: resolve2, reject });
+      this.worker.postMessage({ id, method, args });
+    });
+  }
+  async close() {
+    await this.requestRuntimeClose();
+    await this.worker.terminate();
+    this.rejectAll(new Error("Semantic index worker closed"));
+  }
+  async requestRuntimeClose() {
+    let timeout = null;
+    const timeoutPromise = new Promise((resolve2) => {
+      timeout = setTimeout(resolve2, this.closeTimeoutMs);
+    });
+    try {
+      await Promise.race([this.request("__close", []).then(() => void 0), timeoutPromise]);
+    } catch {
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+  handleMessage(message) {
+    const payload = message;
+    if (!payload.id) return;
+    const pending = this.pending.get(payload.id);
+    if (!pending) return;
+    this.pending.delete(payload.id);
+    if (payload.success) pending.resolve(payload.result);
+    else pending.reject(new Error(payload.error ?? "Semantic index worker request failed"));
+  }
+  rejectAll(error) {
+    for (const [id, pending] of this.pending.entries()) {
+      this.pending.delete(id);
+      pending.reject(error);
+    }
+  }
+};
+function createSemanticIndexWorkerThreadTransport(options) {
+  return new SemanticIndexWorkerThreadTransport(options);
+}
+
+// ../../packages/node-runtime/src/semantic-index/worker-client.ts
+var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
+var defaultTimers = {
+  setTimeout: (callback, ms) => setTimeout(callback, ms),
+  clearTimeout: (timer) => clearTimeout(timer)
+};
+var SemanticIndexWorkerClient = class {
+  transport = null;
+  pendingRequests = 0;
+  idleTimer = null;
+  activeBuildSessionIds = /* @__PURE__ */ new Set();
+  hasUnknownActiveBuild = false;
+  activeModelDownloadProxyUrl;
+  configStore;
+  transportFactory;
+  idleTimeoutMs;
+  timers;
+  getModelDownloadProxyUrl;
+  resolveApiKey;
+  writeAuthProfile;
+  constructor(options) {
+    this.configStore = options.configStore;
+    this.transportFactory = options.transportFactory;
+    this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+    this.timers = options.timers ?? defaultTimers;
+    this.getModelDownloadProxyUrl = options.getModelDownloadProxyUrl ?? (() => void 0);
+    this.resolveApiKey = options.resolveApiKey ?? resolveApiKey;
+    this.writeAuthProfile = options.writeAuthProfile;
+  }
+  getConfig() {
+    return this.configStore.get();
+  }
+  async setConfig(config, options) {
+    const saved = persistSemanticIndexConfig(this.configStore, config, {
+      apiKey: options?.apiKey,
+      writeAuthProfile: this.writeAuthProfile
+    });
+    if (!saved.enabled) this.clearActiveBuildTracking();
+    const needsWorker = saved.enabled && saved.mode === "local" && this.configStore.isConfigured();
+    if (!this.transport && !needsWorker) return saved;
+    if (needsWorker) await this.closeTransportForLocalModelProxyChangeIfNeeded();
+    return await this.call("setConfig", [saved]);
+  }
+  isConfigured() {
+    return this.configStore.isConfigured();
+  }
+  hasApiKey() {
+    return resolveSemanticIndexApiKeySet(this.configStore.get(), this.resolveApiKey);
+  }
+  async getModelStatus() {
+    if (!this.transport) return "idle";
+    return this.call("getModelStatus", []);
+  }
+  enable(sessionId) {
+    return this.call("enable", [sessionId]);
+  }
+  remove(sessionId) {
+    return this.call("remove", [sessionId]);
+  }
+  async build(sessionId) {
+    await this.closeTransportForLocalModelProxyChangeIfNeeded();
+    this.activeBuildSessionIds.add(sessionId);
+    try {
+      await this.call("build", [sessionId]);
+    } catch (error) {
+      this.activeBuildSessionIds.delete(sessionId);
+      throw error;
+    }
+  }
+  pause(sessionId) {
+    return this.call("pause", [sessionId]);
+  }
+  cancel(sessionId) {
+    return this.call("cancel", [sessionId]);
+  }
+  async rebuild(sessionId) {
+    await this.closeTransportForLocalModelProxyChangeIfNeeded();
+    this.activeBuildSessionIds.add(sessionId);
+    try {
+      await this.call("rebuild", [sessionId]);
+    } catch (error) {
+      this.activeBuildSessionIds.delete(sessionId);
+      throw error;
+    }
+  }
+  async buildAllPending() {
+    await this.closeTransportForLocalModelProxyChangeIfNeeded();
+    this.hasUnknownActiveBuild = true;
+    try {
+      await this.call("buildAllPending", []);
+    } catch (error) {
+      this.hasUnknownActiveBuild = false;
+      throw error;
+    }
+  }
+  async listEnabledStatuses() {
+    const statuses = await this.callProbe("listEnabledStatuses", [], [], {
+      scheduleIdle: false
+    });
+    this.updateActiveBuildFromCompleteSnapshot(statuses);
+    this.scheduleIdleCloseIfNeeded();
+    return statuses;
+  }
+  async status(sessionId) {
+    const status = await this.callProbe("status", [sessionId], null, {
+      scheduleIdle: false
+    });
+    this.updateActiveBuildFromPartialSnapshot([sessionId], status ? [status] : []);
+    this.scheduleIdleCloseIfNeeded();
+    return status;
+  }
+  async statusForSessions(sessionIds) {
+    const statuses = await this.callProbe("statusForSessions", [sessionIds], [], {
+      scheduleIdle: false
+    });
+    this.updateActiveBuildFromPartialSnapshot(sessionIds, statuses);
+    this.scheduleIdleCloseIfNeeded();
+    return statuses;
+  }
+  async canSearch(sessionId) {
+    if (!this.canRunFromLocalConfig()) return false;
+    return await this.callProbe("canSearch", [sessionId], false);
+  }
+  async search(sessionId, query, options) {
+    await this.closeTransportForLocalModelProxyChangeIfNeeded();
+    return await this.call("search", [sessionId, query, options]);
+  }
+  async searchForTool(sessionId, query, options) {
+    await this.closeTransportForLocalModelProxyChangeIfNeeded();
+    return await this.call("searchForTool", [sessionId, query, options]);
+  }
+  cleanupUnused() {
+    return this.call("cleanupUnused", []);
+  }
+  recover() {
+    return this.call("recover", []);
+  }
+  async close() {
+    this.clearIdleTimer();
+    await this.closeTransport();
+  }
+  async call(method, args, options) {
+    const transport = await this.ensureTransport();
+    this.pendingRequests++;
+    this.clearIdleTimer();
+    try {
+      return await transport.request(method, args);
+    } finally {
+      this.pendingRequests--;
+      if (options?.scheduleIdle !== false) this.scheduleIdleCloseIfNeeded();
+    }
+  }
+  async callProbe(method, args, fallback, options) {
+    try {
+      return await this.call(method, args, options);
+    } catch {
+      await this.closeFailedProbeTransport();
+      return fallback;
+    }
+  }
+  async ensureTransport() {
+    if (!this.transport) {
+      const proxyUrl = await this.currentModelDownloadProxyUrl();
+      if (!this.transport) {
+        this.activeModelDownloadProxyUrl = proxyUrl;
+        this.transport = this.transportFactory(proxyUrl);
+      }
+    }
+    return this.transport;
+  }
+  async currentModelDownloadProxyUrl() {
+    const proxyUrl = (await this.getModelDownloadProxyUrl())?.trim();
+    return proxyUrl || void 0;
+  }
+  async closeTransportForLocalModelProxyChangeIfNeeded() {
+    if (!this.transport) return;
+    const config = this.configStore.get();
+    if (!this.configStore.canRun() || config.mode !== "local") return;
+    if (this.hasUnknownActiveBuild || this.activeBuildSessionIds.size > 0) return;
+    if (await this.currentModelDownloadProxyUrl() === this.activeModelDownloadProxyUrl) return;
+    await this.closeTransport();
+  }
+  canRunFromLocalConfig() {
+    const config = this.configStore.get();
+    if (!this.configStore.canRun()) return false;
+    if (config.mode !== "api") return true;
+    if (isKeylessSemanticIndexApiBaseUrl(config.api?.baseUrl)) return true;
+    return resolveSemanticIndexApiKeySet(config, this.resolveApiKey);
+  }
+  updateActiveBuildFromCompleteSnapshot(statuses) {
+    this.hasUnknownActiveBuild = false;
+    this.activeBuildSessionIds = new Set(
+      statuses.filter((status) => this.isActiveBuildStatus(status)).map((status) => status.sessionId)
+    );
+  }
+  updateActiveBuildFromPartialSnapshot(requestedSessionIds, statuses) {
+    const bySessionId = new Map(statuses.map((status) => [status.sessionId, status]));
+    for (const sessionId of requestedSessionIds) {
+      const status = bySessionId.get(sessionId);
+      if (status && this.isActiveBuildStatus(status)) this.activeBuildSessionIds.add(sessionId);
+      else this.activeBuildSessionIds.delete(sessionId);
+    }
+  }
+  isActiveBuildStatus(status) {
+    return status.running || status.queued || status.indexStatus === "running";
+  }
+  clearActiveBuildTracking() {
+    this.hasUnknownActiveBuild = false;
+    this.activeBuildSessionIds.clear();
+  }
+  scheduleIdleCloseIfNeeded() {
+    if (!this.transport || this.pendingRequests > 0 || this.hasUnknownActiveBuild || this.activeBuildSessionIds.size > 0)
+      return;
+    this.clearIdleTimer();
+    this.idleTimer = this.timers.setTimeout(() => {
+      void this.closeTransport().catch((err) => {
+        console.warn("[semantic-index] idle worker close failed:", err instanceof Error ? err.message : String(err));
+      });
+    }, this.idleTimeoutMs);
+  }
+  clearIdleTimer() {
+    if (this.idleTimer) {
+      this.timers.clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+  }
+  async closeTransport() {
+    const transport = this.transport;
+    this.transport = null;
+    this.activeModelDownloadProxyUrl = void 0;
+    this.clearActiveBuildTracking();
+    if (transport) await transport.close();
+  }
+  async closeFailedProbeTransport() {
+    this.clearIdleTimer();
+    try {
+      await this.closeTransport();
+    } catch {
+    }
+  }
+};
+function createSemanticIndexWorkerClient(options) {
+  return new SemanticIndexWorkerClient(options);
+}
+function createSemanticIndexWorkerRuntimeClient(options) {
+  const configStore = new SemanticIndexConfigStore(
+    path5.join(options.pathProvider.getAiDataDir(), SEMANTIC_INDEX_CONFIG_FILE)
+  );
+  return createSemanticIndexWorkerClient({
+    configStore,
+    idleTimeoutMs: options.idleTimeoutMs,
+    resolveApiKey: options.resolveApiKey,
+    writeAuthProfile: options.writeAuthProfile,
+    getModelDownloadProxyUrl: options.getModelDownloadProxyUrl,
+    transportFactory: (modelDownloadProxyUrl) => createSemanticIndexWorkerThreadTransport({
+      workerEntryUrl: options.workerEntryUrl,
+      startup: {
+        paths: snapshotPathProvider(options.pathProvider),
+        runtime: options.runtime,
+        nativeBinding: options.nativeBinding,
+        sqliteVecLoadablePath: options.sqliteVecLoadablePath,
+        modelDownloadProxyUrl
+      }
+    })
+  });
+}
+
+// ../../packages/node-runtime/src/semantic-index/embedding/index.ts
+var embedding_exports = {};
+__export(embedding_exports, {
+  BGE_BASE_PROFILE: () => BGE_BASE_PROFILE,
+  LocalEmbeddingProvider: () => LocalEmbeddingProvider,
+  OpenAICompatibleEmbeddingProvider: () => OpenAICompatibleEmbeddingProvider,
+  QWEN3_PROFILE: () => QWEN3_PROFILE,
+  applyQueryInstruction: () => applyQueryInstruction,
+  clampTextChars: () => clampTextChars,
+  getLocalProfileByModelId: () => getLocalProfileByModelId,
+  getLocalProfilesForLocale: () => getLocalProfilesForLocale
+});
+
+export {
+  isExistingUserDataDir,
+  isUserDataDirSafeToUse,
+  isDirectoryEmptyOrMissing,
+  copyDirMerge,
+  createPendingDataDirMigration,
+  runPendingDataDirMigration,
+  getPendingNodeDataDirMigration,
+  clearPendingNodeDataDirMigration,
+  createNodeDataDirSwitch,
+  applyPendingNodeDataDirMigration,
+  hasPendingElectronDataWarning,
+  applyPendingNodeDataDirMigrationIfNeeded,
+  NodePathProvider,
+  getDefaultNodeUserDataDir,
+  getSystemLogsDir,
+  createJiebaNlpProvider,
+  getDbFileVersion,
+  getOrComputeAnalysisCache,
+  PreferencesManager,
+  checkConflictsFromSources,
+  buildMergedOutput,
+  serializeChatLabToJsonl,
+  AnalyticsService,
+  createSemanticIndexWorkerRuntimeClient,
+  semantic_index_exports
+};
+//# sourceMappingURL=chunk-YBS3YQB6.mjs.map