@remnic/core 1.1.11 → 1.1.13

package/src/verified-recall.ts

@@ -0,0 +1,138 @@
+import { BoxBuilder, type BoxFrontmatter } from "./boxes.js";
+import { getCachedEpisodeMap, setCachedEpisodeMap } from "./memory-cache.js";
+import { StorageManager } from "./storage.js";
+import type { MemoryFile } from "./types.js";
+import { countRecallTokenOverlap, normalizeRecallTokens } from "./recall-tokenization.js";
+
+export interface VerifiedEpisodeResult {
+  box: BoxFrontmatter;
+  score: number;
+  verifiedEpisodeCount: number;
+  verifiedMemoryIds: string[];
+  matchedFields: string[];
+}
+
+interface VerifiedEpisodeCandidate {
+  box: BoxFrontmatter;
+  score: number;
+  matchedFields: Set<string>;
+  verifiedMemories: MemoryFile[];
+}
+
+function createReadOnlyBoxBuilder(memoryDir: string): BoxBuilder {
+  return new BoxBuilder(memoryDir, {
+    memoryBoxesEnabled: true,
+    traceWeaverEnabled: false,
+    boxTopicShiftThreshold: 0.35,
+    boxTimeGapMs: 30 * 60 * 1000,
+    boxMaxMemories: 50,
+    traceWeaverLookbackDays: 7,
+    traceWeaverOverlapThreshold: 0.4,
+  });
+}
+
+function scoreVerifiedEpisodeCandidate(box: BoxFrontmatter, verifiedMemories: MemoryFile[], queryTokens: Set<string>) {
+  const matchedFields = new Set<string>();
+  let score = 0;
+
+  const topicMatches = countRecallTokenOverlap(queryTokens, box.topics.join(" "));
+  if (topicMatches > 0) {
+    score += topicMatches * 3;
+    matchedFields.add("topics");
+  }
+
+  const goalMatches = countRecallTokenOverlap(queryTokens, box.goal);
+  if (goalMatches > 0) {
+    score += goalMatches * 4;
+    matchedFields.add("goal");
+  }
+
+  const toolMatches = countRecallTokenOverlap(queryTokens, box.toolsUsed?.join(" "));
+  if (toolMatches > 0) {
+    score += toolMatches * 2;
+    matchedFields.add("toolsUsed");
+  }
+
+  let episodeContentMatches = 0;
+  for (const memory of verifiedMemories) {
+    episodeContentMatches += countRecallTokenOverlap(queryTokens, memory.content);
+  }
+  if (episodeContentMatches > 0) {
+    score += episodeContentMatches * 4;
+    matchedFields.add("episodeContent");
+  }
+
+  return { score, matchedFields };
+}
+
+function resolveVerifiedEpisodeMemoriesFromMap(
+  memoryById: ReadonlyMap<string, MemoryFile>,
+  memoryIds: string[],
+): MemoryFile[] {
+  const verified: MemoryFile[] = [];
+  for (const memoryId of memoryIds) {
+    try {
+      const memory = memoryById.get(memoryId);
+      if (!memory) continue;
+      if (memory.frontmatter.status === "archived" || memory.frontmatter.status === "forgotten") continue;
+      if (memory.frontmatter.memoryKind !== "episode") continue;
+      verified.push(memory);
+    } catch {
+      // fail-open: malformed or unreadable memories should not abort recall
+    }
+  }
+  return verified;
+}
+
+export async function searchVerifiedEpisodes(options: {
+  memoryDir: string;
+  query: string;
+  maxResults: number;
+  boxRecallDays?: number;
+}): Promise<VerifiedEpisodeResult[]> {
+  const queryTokens = new Set(normalizeRecallTokens(options.query, ["what", "which"]));
+  if (queryTokens.size === 0 || options.maxResults <= 0) return [];
+
+  const storage = new StorageManager(options.memoryDir);
+  const version = storage.getMemoryStatusVersion();
+
+  // Use derived episode cache to avoid O(146K) filter+map on every call.
+  let verifiedMemoryById = getCachedEpisodeMap(storage.dir, version);
+  if (!verifiedMemoryById) {
+    const allMemories = await storage.readAllMemories();
+    verifiedMemoryById = setCachedEpisodeMap(storage.dir, allMemories, version);
+  }
+  const boxes = await createReadOnlyBoxBuilder(options.memoryDir)
+    .readRecentBoxes(Math.max(1, Math.floor(options.boxRecallDays ?? 3)))
+    .catch(() => [] as BoxFrontmatter[]);
+
+  const candidates: VerifiedEpisodeCandidate[] = [];
+  for (const box of boxes) {
+    const verifiedMemories = resolveVerifiedEpisodeMemoriesFromMap(verifiedMemoryById, box.memoryIds);
+    if (verifiedMemories.length === 0) continue;
+    const { score, matchedFields } = scoreVerifiedEpisodeCandidate(box, verifiedMemories, queryTokens);
+    if (score <= 0) continue;
+    candidates.push({
+      box,
+      score,
+      matchedFields,
+      verifiedMemories,
+    });
+  }
+
+  return candidates
+    .map((candidate) => ({
+      box: candidate.box,
+      score: candidate.score,
+      verifiedEpisodeCount: candidate.verifiedMemories.length,
+      verifiedMemoryIds: candidate.verifiedMemories.map((memory) => memory.frontmatter.id),
+      matchedFields: [...candidate.matchedFields].sort(),
+    }))
+    .sort(
+      (left, right) =>
+        right.score - left.score
+        || right.verifiedEpisodeCount - left.verifiedEpisodeCount
+        || right.box.sealedAt.localeCompare(left.box.sealedAt),
+    )
+    .slice(0, options.maxResults);
+}

package/src/version-utils.test.ts

@@ -0,0 +1,10 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { compareVersions } from "./version-utils.js";
+
+test("compareVersions sorts version triples consistently", () => {
+  assert.equal(compareVersions([2026, 1, 28], [2026, 1, 29]), -1);
+  assert.equal(compareVersions([2026, 1, 29], [2026, 1, 29]), 0);
+  assert.equal(compareVersions([2026, 3, 8], [2026, 1, 29]), 1);
+});

package/src/version-utils.ts

@@ -0,0 +1,9 @@
+export type VersionTriple = readonly [number, number, number];
+
+export function compareVersions(a: VersionTriple, b: VersionTriple): number {
+  for (let i = 0; i < 3; i += 1) {
+    if (a[i] > b[i]) return 1;
+    if (a[i] < b[i]) return -1;
+  }
+  return 0;
+}

package/src/whitespace.ts

@@ -0,0 +1,10 @@
+export function collapseWhitespace(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+export function truncateCodePointSafe(value: string, maxChars: number): string {
+  const glyphs = Array.from(value);
+  if (maxChars <= 0) return "";
+  if (glyphs.length <= maxChars) return value;
+  return glyphs.slice(0, Math.max(1, maxChars)).join("").trimEnd();
+}

package/src/work/board.ts

@@ -0,0 +1,359 @@
+import type { WorkProject, WorkTask, WorkTaskPriority, WorkTaskStatus } from "./types.js";
+import { WORK_ID_PATTERN, WorkStorage } from "./storage.js";
+
+const BOARD_STATUS_ORDER: WorkTaskStatus[] = [
+  "todo",
+  "in_progress",
+  "blocked",
+  "done",
+  "cancelled",
+];
+
+const BOARD_STATUS_LABEL: Record<WorkTaskStatus, string> = {
+  todo: "Todo",
+  in_progress: "In Progress",
+  blocked: "Blocked",
+  done: "Done",
+  cancelled: "Cancelled",
+};
+
+const PRIORITY_WEIGHT: Record<WorkTaskPriority, number> = {
+  high: 0,
+  medium: 1,
+  low: 2,
+};
+
+export interface WorkBoardItem {
+  id: string;
+  title: string;
+  description: string;
+  status: WorkTaskStatus;
+  priority: WorkTaskPriority;
+  owner: string | null;
+  assignee: string | null;
+  projectId: string | null;
+  tags: string[];
+  dueAt: string | null;
+}
+
+export interface WorkBoardSnapshot {
+  version: 1;
+  generatedAt: string;
+  projectId: string | null;
+  projectName: string | null;
+  items: WorkBoardItem[];
+}
+
+export interface ImportWorkBoardResult {
+  created: number;
+  updated: number;
+}
+
+function stableSortTasks(tasks: WorkTask[]): WorkTask[] {
+  return [...tasks].sort((a, b) => {
+    const priorityCmp = PRIORITY_WEIGHT[a.priority] - PRIORITY_WEIGHT[b.priority];
+    if (priorityCmp !== 0) return priorityCmp;
+    const createdCmp = a.createdAt.localeCompare(b.createdAt);
+    if (createdCmp !== 0) return createdCmp;
+    return a.id.localeCompare(b.id);
+  });
+}
+
+function projectMatches(task: WorkTask, projectId?: string): boolean {
+  if (!projectId) return true;
+  return task.projectId === projectId;
+}
+
+function assertValidImportEnums(item: WorkBoardItem): void {
+  if (!["todo", "in_progress", "blocked", "done", "cancelled"].includes(item.status)) {
+    throw new Error(`invalid task status in snapshot for ${item.id}: ${item.status}`);
+  }
+  if (!["low", "medium", "high"].includes(item.priority)) {
+    throw new Error(`invalid task priority in snapshot for ${item.id}: ${item.priority}`);
+  }
+}
+
+function normalizeImportedProjectId(
+  rawValue: unknown,
+  taskId: string,
+  fallbackForUndefined: string | null,
+): string | null {
+  if (rawValue === undefined) return fallbackForUndefined;
+  if (rawValue === null) return null;
+  if (typeof rawValue === "string") {
+    const trimmed = rawValue.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  throw new Error(`invalid task projectId in snapshot for ${taskId}`);
+}
+
+function normalizeImportedTags(rawValue: unknown, taskId: string): string[] {
+  if (rawValue === undefined || rawValue === null) return [];
+  if (!Array.isArray(rawValue)) {
+    throw new Error(`invalid task tags in snapshot for ${taskId}`);
+  }
+  if (!rawValue.every((entry) => typeof entry === "string")) {
+    throw new Error(`invalid task tags in snapshot for ${taskId}`);
+  }
+  return [...rawValue];
+}
+
+function assertValidImportedTaskId(rawValue: unknown): string {
+  if (typeof rawValue !== "string") {
+    throw new Error("invalid task id in snapshot");
+  }
+  const trimmed = rawValue.trim();
+  if (!WORK_ID_PATTERN.test(trimmed)) {
+    throw new Error(`invalid task id in snapshot: ${trimmed}`);
+  }
+  return trimmed;
+}
+
+function normalizeImportedNullableField(
+  rawValue: unknown,
+  taskId: string,
+  fieldName: "owner" | "assignee" | "dueAt",
+  fallbackForUndefined: string | null,
+): string | null {
+  if (rawValue === undefined) return fallbackForUndefined;
+  if (rawValue === null) return null;
+  if (typeof rawValue === "string") return rawValue;
+  throw new Error(`invalid task ${fieldName} in snapshot for ${taskId}`);
+}
+
+function normalizeImportedTitle(rawValue: unknown, taskId: string): string {
+  if (typeof rawValue !== "string") {
+    throw new Error(`invalid task title in snapshot for ${taskId}`);
+  }
+  const trimmed = rawValue.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`invalid task title in snapshot for ${taskId}`);
+  }
+  return trimmed;
+}
+
+function normalizeImportedDescription(rawValue: unknown, taskId: string): string {
+  if (typeof rawValue !== "string") {
+    throw new Error(`invalid task description in snapshot for ${taskId}`);
+  }
+  return rawValue;
+}
+
+function asBoardItem(task: WorkTask): WorkBoardItem {
+  return {
+    id: task.id,
+    title: task.title,
+    description: task.description,
+    status: task.status,
+    priority: task.priority,
+    owner: task.owner,
+    assignee: task.assignee,
+    projectId: task.projectId,
+    tags: [...task.tags],
+    dueAt: task.dueAt,
+  };
+}
+
+function formatTaskLine(task: WorkBoardItem): string {
+  const bits: string[] = [`id:${task.id}`, `priority:${task.priority}`];
+  if (task.assignee) bits.push(`assignee:${task.assignee}`);
+  if (task.owner) bits.push(`owner:${task.owner}`);
+  if (task.dueAt) bits.push(`due:${task.dueAt}`);
+  if (task.tags.length > 0) bits.push(`tags:${task.tags.join(",")}`);
+  const checked = task.status === "done";
+  return `- [${checked ? "x" : " "}] ${task.title} \`[${bits.join(" ")}]\``;
+}
+
+export async function exportWorkBoardSnapshot(options: {
+  memoryDir: string;
+  projectId?: string;
+  now?: Date;
+}): Promise<WorkBoardSnapshot> {
+  const storage = new WorkStorage(options.memoryDir);
+  await storage.ensureDirectories();
+
+  const projectId = options.projectId?.trim() || undefined;
+  let project: WorkProject | null = null;
+  if (projectId) {
+    project = await storage.getProject(projectId);
+    if (!project) throw new Error(`project not found: ${projectId}`);
+  }
+
+  const allTasks = await storage.listTasks();
+  const filtered = stableSortTasks(allTasks.filter((task) => projectMatches(task, projectId)));
+  return {
+    version: 1,
+    generatedAt: (options.now ?? new Date()).toISOString(),
+    projectId: projectId ?? null,
+    projectName: project?.name ?? null,
+    items: filtered.map(asBoardItem),
+  };
+}
+
+function renderWorkBoardMarkdown(snapshot: WorkBoardSnapshot): string {
+  const lines: string[] = [];
+  lines.push("# Work Board");
+  lines.push("");
+  lines.push(`Generated: ${snapshot.generatedAt}`);
+  lines.push(`Project: ${snapshot.projectName ?? "all"} (${snapshot.projectId ?? "all"})`);
+  lines.push("");
+
+  for (const status of BOARD_STATUS_ORDER) {
+    const bucket = snapshot.items.filter((item) => item.status === status);
+    lines.push(`## ${BOARD_STATUS_LABEL[status]} (${bucket.length})`);
+    if (bucket.length === 0) {
+      lines.push("_none_");
+    } else {
+      for (const item of bucket) {
+        lines.push(formatTaskLine(item));
+      }
+    }
+    lines.push("");
+  }
+
+  return `${lines.join("\n").trim()}\n`;
+}
+
+export async function exportWorkBoardMarkdown(options: {
+  memoryDir: string;
+  projectId?: string;
+  now?: Date;
+}): Promise<string> {
+  const snapshot = await exportWorkBoardSnapshot(options);
+  return renderWorkBoardMarkdown(snapshot);
+}
+
+export async function importWorkBoardSnapshot(options: {
+  memoryDir: string;
+  snapshot: WorkBoardSnapshot;
+  projectId?: string | null;
+  now?: Date;
+}): Promise<ImportWorkBoardResult> {
+  if (options.snapshot.version !== 1) {
+    throw new Error(`unsupported work board snapshot version: ${options.snapshot.version}`);
+  }
+
+  const storage = new WorkStorage(options.memoryDir);
+  await storage.ensureDirectories();
+
+  const forcedProjectId = options.projectId === undefined
+    ? undefined
+    : (options.projectId?.trim() || null);
+  const snapshotProjectId = normalizeImportedProjectId(
+    (options.snapshot as unknown as { projectId?: unknown }).projectId,
+    "snapshot",
+    null,
+  );
+
+  type PreparedImportRow = {
+    item: WorkBoardItem;
+    existing: WorkTask | null;
+    id: string;
+    title: string;
+    description: string;
+    projectId: string | null;
+    tags: string[];
+    owner: string | null;
+    assignee: string | null;
+    dueAt: string | null;
+  };
+
+  const preparedRows: PreparedImportRow[] = [];
+  const seenItemIds = new Set<string>();
+  for (const item of options.snapshot.items) {
+    const id = assertValidImportedTaskId((item as unknown as { id?: unknown }).id);
+    if (seenItemIds.has(id)) {
+      throw new Error(`duplicate task id in snapshot: ${id}`);
+    }
+    seenItemIds.add(id);
+    assertValidImportEnums(item);
+    const existing = await storage.getTask(id);
+    const title = normalizeImportedTitle((item as unknown as { title?: unknown }).title, id);
+    const description = normalizeImportedDescription((item as unknown as { description?: unknown }).description, id);
+    const fallbackProjectId = existing ? existing.projectId : snapshotProjectId;
+    const projectId = forcedProjectId === undefined
+      ? normalizeImportedProjectId(
+        (item as unknown as { projectId?: unknown }).projectId,
+        item.id,
+        fallbackProjectId,
+      )
+      : forcedProjectId;
+
+    const hasTagsField = Object.prototype.hasOwnProperty.call(
+      item as unknown as Record<string, unknown>,
+      "tags",
+    );
+    const tags = hasTagsField
+      ? normalizeImportedTags((item as unknown as { tags?: unknown }).tags, item.id)
+      : (existing ? [...existing.tags] : []);
+
+    const owner = normalizeImportedNullableField(
+      (item as unknown as { owner?: unknown }).owner,
+      id,
+      "owner",
+      existing?.owner ?? null,
+    );
+    const assignee = normalizeImportedNullableField(
+      (item as unknown as { assignee?: unknown }).assignee,
+      id,
+      "assignee",
+      existing?.assignee ?? null,
+    );
+    const dueAt = normalizeImportedNullableField(
+      (item as unknown as { dueAt?: unknown }).dueAt,
+      id,
+      "dueAt",
+      existing?.dueAt ?? null,
+    );
+
+    preparedRows.push({ item, existing, id, title, description, projectId, tags, owner, assignee, dueAt });
+  }
+
+  const projectIdsToValidate = new Set(
+    preparedRows
+      .map((row) => row.projectId)
+      .filter((projectId): projectId is string => typeof projectId === "string"),
+  );
+  for (const projectId of projectIdsToValidate) {
+    const project = await storage.getProject(projectId);
+    if (!project) throw new Error(`project not found: ${projectId}`);
+  }
+
+  let created = 0;
+  let updated = 0;
+  for (const row of preparedRows) {
+    const { item, existing, id, title, description, projectId, tags, owner, assignee, dueAt } = row;
+
+    if (existing) {
+      await storage.updateTask(id, {
+        title,
+        description,
+        status: item.status,
+        priority: item.priority,
+        owner,
+        assignee,
+        projectId,
+        tags,
+        dueAt,
+      }, options.now, { skipStatusTransitionValidation: true });
+      updated += 1;
+      continue;
+    }
+
+    await storage.createTask({
+      id,
+      title,
+      description,
+      status: item.status,
+      priority: item.priority,
+      owner,
+      assignee,
+      projectId,
+      tags,
+      dueAt,
+    }, options.now);
+    created += 1;
+  }
+
+  return { created, updated };
+}

package/src/work/boundary.ts

@@ -0,0 +1,107 @@
+export const WORK_LAYER_CONTEXT_OPEN = "[WORK_LAYER_CONTEXT";
+export const WORK_LAYER_CONTEXT_CLOSE = "[/WORK_LAYER_CONTEXT]";
+const WORK_LAYER_CONTEXT_ESCAPED_OPEN = "[WORK_LAYER_ESCAPED_CONTEXT";
+const WORK_LAYER_CONTEXT_ESCAPED_CLOSE = "[/WORK_LAYER_CONTEXT_ESC]";
+
+export function wrapWorkLayerContext(content: string, options?: { linkToMemory?: boolean }): string {
+  const linkToMemory = options?.linkToMemory === true;
+  const header = `${WORK_LAYER_CONTEXT_OPEN} link_to_memory=${linkToMemory ? "true" : "false"}]`;
+  const payload = content
+    .trim()
+    .replaceAll(WORK_LAYER_CONTEXT_OPEN, WORK_LAYER_CONTEXT_ESCAPED_OPEN)
+    .replaceAll(WORK_LAYER_CONTEXT_CLOSE, WORK_LAYER_CONTEXT_ESCAPED_CLOSE);
+  return `${header}\n${payload}\n${WORK_LAYER_CONTEXT_CLOSE}`;
+}
+
+export function applyWorkExtractionBoundary(conversation: string): string {
+  if (conversation.trim().length === 0) return "";
+
+  // Replace work-layer blocks using indexOf to avoid backtracking regex.
+  let bounded = conversation;
+  const OPEN_TAG = "[WORK_LAYER_CONTEXT";
+  const CLOSE_TAG = "[/WORK_LAYER_CONTEXT]";
+  let searchFrom = 0;
+  while (true) {
+    const openIdx = bounded.indexOf(OPEN_TAG, searchFrom);
+    if (openIdx < 0) break;
+    // Require line-start anchor
+    if (openIdx > 0 && bounded[openIdx - 1] !== "\n") {
+      searchFrom = openIdx + OPEN_TAG.length;
+      continue;
+    }
+    const closeBracket = bounded.indexOf("]", openIdx + OPEN_TAG.length);
+    if (closeBracket < 0) break;
+    const header = bounded.substring(openIdx + OPEN_TAG.length, closeBracket);
+    const closeIdx = bounded.indexOf(CLOSE_TAG, closeBracket + 1);
+    if (closeIdx < 0) break;
+    // Parse attributes from header
+    const flagMatch = header.match(/\blink_to_memory=(true|false)/);
+    const encMatch = header.match(/\bencoding=(base64)/);
+    const flag = flagMatch?.[1];
+    const encoding = encMatch?.[1];
+    // Extract body (between ] and closer)
+    let bodyStart = closeBracket + 1;
+    if (bounded[bodyStart] === "\n") bodyStart++;
+    let bodyEnd = closeIdx;
+    if (bodyEnd > bodyStart && bounded[bodyEnd - 1] === "\n") bodyEnd--;
+    const body = bounded.substring(bodyStart, bodyEnd);
+    const shouldLink = flag === "true";
+    const prefix = openIdx > 0 ? bounded.substring(0, openIdx) : "";
+    const suffix = bounded.substring(closeIdx + CLOSE_TAG.length);
+    if (!shouldLink) {
+      bounded = prefix + suffix;
+      searchFrom = prefix.length;
+    } else if (encoding === "base64") {
+      try {
+        const decoded = Buffer.from(body.trim(), "base64").toString("utf8").trim();
+        bounded = prefix + decoded + suffix;
+        searchFrom = prefix.length + decoded.length;
+      } catch {
+        bounded = prefix + suffix;
+        searchFrom = prefix.length;
+      }
+    } else {
+      bounded = prefix + body.trim() + suffix;
+      searchFrom = prefix.length + body.trim().length;
+    }
+  }
+
+  // Defensive hardening: if a *real wrapper opener* survives without a closer (e.g., turn-level truncation),
+  // strip everything from the opener onward to avoid leaking excluded work-layer payloads.
+  // Keep literal "[WORK_LAYER_CONTEXT" text unless it contains wrapper metadata attributes.
+  // Strip unterminated work-layer openers using indexOf for safety (avoids backtracking).
+  // Only match openers at the start of a line (like the original ^|\n anchor).
+  let strippedUnterminated = bounded;
+  const opener = "[WORK_LAYER_CONTEXT";
+  const closer = "[/WORK_LAYER_CONTEXT]";
+  const lastOpenerIdx = bounded.lastIndexOf(opener);
+  if (lastOpenerIdx >= 0) {
+    // Require line-start: either position 0 or preceded by \n
+    const isLineStart = lastOpenerIdx === 0 || bounded[lastOpenerIdx - 1] === "\n";
+    if (isLineStart) {
+      const afterOpener = bounded.indexOf("]", lastOpenerIdx);
+      if (afterOpener >= 0) {
+        const closerAfter = bounded.indexOf(closer, afterOpener);
+        if (closerAfter < 0) {
+          // Unterminated — only strip if it has real metadata attributes
+          const bracketContent = bounded.substring(lastOpenerIdx, afterOpener + 1);
+          if (bracketContent.includes("link_to_memory=") || bracketContent.includes("encoding=")) {
+            strippedUnterminated = lastOpenerIdx > 0
+              ? bounded.substring(0, lastOpenerIdx - 1)  // exclude the preceding \n
+              : "";
+          }
+        }
+      }
+    }
+  }
+
+  const restoredEscapes = strippedUnterminated
+    .replaceAll(WORK_LAYER_CONTEXT_ESCAPED_OPEN, WORK_LAYER_CONTEXT_OPEN)
+    .replaceAll(WORK_LAYER_CONTEXT_ESCAPED_CLOSE, WORK_LAYER_CONTEXT_CLOSE);
+
+  const cleanedLines = restoredEscapes
+    .split("\n")
+    .map((line) => line.trimEnd());
+
+  return cleanedLines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}