@musnows/scriverse 0.7.2 → 0.7.4

package/dist/public/background-task-center.js

@@ -1,5 +1,5 @@
 const activeTaskStatuses = new Set(["pending", "running"]);
-const terminalTaskStatuses = new Set(["review", "completed", "partial", "expired", "cancelled"]);
+const terminalTaskStatuses = new Set(["review", "completed", "partial", "failed", "expired", "cancelled"]);
 
 export function backgroundTaskActivityCount(taskPage, relationshipIndex) {
   const pendingCount = Number(taskPage?.stats?.pendingCount ?? 0);

package/dist/public/chapter-editor-virtualization.js

@@ -0,0 +1,52 @@
+const lineMarker = "\u200b";
+
+export function buildChapterLineMirror(value) {
+  const lines = String(value ?? "").replace(/\r\n?/gu, "\n").split("\n");
+  const offsets = [];
+  const parts = [];
+  let offset = 0;
+  lines.forEach((line, index) => {
+    offsets.push(offset);
+    parts.push(lineMarker, line);
+    offset += lineMarker.length + line.length;
+    if (index < lines.length - 1) {
+      parts.push("\n");
+      offset += 1;
+    }
+  });
+  return { lines, offsets, text: parts.join("") };
+}
+
+export function findChapterLineWindow(lineCount, getBounds, viewportStart, viewportEnd) {
+  const count = Math.max(0, Math.floor(Number(lineCount) || 0));
+  if (count === 0) return { start: 0, end: 0 };
+  const startTarget = Number.isFinite(Number(viewportStart)) ? Number(viewportStart) : 0;
+  const endTarget = Math.max(startTarget, Number.isFinite(Number(viewportEnd)) ? Number(viewportEnd) : startTarget);
+
+  let low = 0;
+  let high = count - 1;
+  let start = count - 1;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    if (getBounds(middle).bottom >= startTarget) {
+      start = middle;
+      high = middle - 1;
+    } else {
+      low = middle + 1;
+    }
+  }
+
+  low = start;
+  high = count - 1;
+  let end = start;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    if (getBounds(middle).top <= endTarget) {
+      end = middle;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return { start, end: end + 1 };
+}

package/dist/public/chapter-version-diff.d.ts

@@ -0,0 +1,20 @@
+export type ChapterDiffRow =
+  | { type: "equal"; before: string; after: string; beforeLine: number; afterLine: number }
+  | { type: "added"; after: string; afterLine: number }
+  | { type: "deleted"; before: string; beforeLine: number }
+  | { type: "modified"; before: string; after: string; beforeLine: number; afterLine: number };
+
+export type ChapterDiffSummary = {
+  added: number;
+  deleted: number;
+  modified: number;
+  unchanged: number;
+};
+
+export function diffChapterLines(
+  beforeContent: unknown,
+  afterContent: unknown,
+  matrixCellLimit?: number
+): ChapterDiffRow[];
+
+export function chapterDiffSummary(rows: ChapterDiffRow[]): ChapterDiffSummary;

package/dist/public/chapter-version-diff.js

@@ -0,0 +1,116 @@
+const DEFAULT_MATRIX_CELL_LIMIT = 2_000_000;
+
+function chapterLines(content) {
+  return String(content ?? "").replace(/\r\n?/gu, "\n").split("\n");
+}
+
+function positionalDiff(beforeLines, afterLines) {
+  const rows = [];
+  const length = Math.max(beforeLines.length, afterLines.length);
+  for (let index = 0; index < length; index += 1) {
+    const before = beforeLines[index];
+    const after = afterLines[index];
+    if (before === undefined) rows.push({ type: "added", after, afterLine: index + 1 });
+    else if (after === undefined) rows.push({ type: "deleted", before, beforeLine: index + 1 });
+    else if (before === after) rows.push({ type: "equal", before, after, beforeLine: index + 1, afterLine: index + 1 });
+    else rows.push({ type: "modified", before, after, beforeLine: index + 1, afterLine: index + 1 });
+  }
+  return rows;
+}
+
+function rawLineDiff(beforeLines, afterLines, matrixCellLimit) {
+  const rows = beforeLines.length + 1;
+  const columns = afterLines.length + 1;
+  if (rows * columns > matrixCellLimit) return null;
+  const matrix = Array.from({ length: rows }, () => new Uint32Array(columns));
+  for (let beforeIndex = beforeLines.length - 1; beforeIndex >= 0; beforeIndex -= 1) {
+    for (let afterIndex = afterLines.length - 1; afterIndex >= 0; afterIndex -= 1) {
+      matrix[beforeIndex][afterIndex] = beforeLines[beforeIndex] === afterLines[afterIndex]
+        ? matrix[beforeIndex + 1][afterIndex + 1] + 1
+        : Math.max(matrix[beforeIndex + 1][afterIndex], matrix[beforeIndex][afterIndex + 1]);
+    }
+  }
+
+  const diff = [];
+  let beforeIndex = 0;
+  let afterIndex = 0;
+  while (beforeIndex < beforeLines.length || afterIndex < afterLines.length) {
+    if (beforeIndex < beforeLines.length && afterIndex < afterLines.length
+      && beforeLines[beforeIndex] === afterLines[afterIndex]) {
+      diff.push({ type: "equal", text: beforeLines[beforeIndex], beforeLine: beforeIndex + 1, afterLine: afterIndex + 1 });
+      beforeIndex += 1;
+      afterIndex += 1;
+    } else if (afterIndex < afterLines.length
+      && (beforeIndex >= beforeLines.length || matrix[beforeIndex][afterIndex + 1] >= matrix[beforeIndex + 1][afterIndex])) {
+      diff.push({ type: "added", text: afterLines[afterIndex], afterLine: afterIndex + 1 });
+      afterIndex += 1;
+    } else {
+      diff.push({ type: "deleted", text: beforeLines[beforeIndex], beforeLine: beforeIndex + 1 });
+      beforeIndex += 1;
+    }
+  }
+  return diff;
+}
+
+function pairChangedLines(changes) {
+  const deleted = changes.filter((row) => row.type === "deleted");
+  const added = changes.filter((row) => row.type === "added");
+  const paired = [];
+  const pairCount = Math.min(deleted.length, added.length);
+  for (let index = 0; index < pairCount; index += 1) {
+    paired.push({
+      type: "modified",
+      before: deleted[index].text,
+      after: added[index].text,
+      beforeLine: deleted[index].beforeLine,
+      afterLine: added[index].afterLine
+    });
+  }
+  for (let index = pairCount; index < deleted.length; index += 1) {
+    paired.push({ type: "deleted", before: deleted[index].text, beforeLine: deleted[index].beforeLine });
+  }
+  for (let index = pairCount; index < added.length; index += 1) {
+    paired.push({ type: "added", after: added[index].text, afterLine: added[index].afterLine });
+  }
+  return paired;
+}
+
+export function diffChapterLines(beforeContent, afterContent, matrixCellLimit = DEFAULT_MATRIX_CELL_LIMIT) {
+  const beforeLines = chapterLines(beforeContent);
+  const afterLines = chapterLines(afterContent);
+  const raw = rawLineDiff(beforeLines, afterLines, matrixCellLimit);
+  if (!raw) return positionalDiff(beforeLines, afterLines);
+
+  const result = [];
+  let index = 0;
+  while (index < raw.length) {
+    if (raw[index].type === "equal") {
+      result.push({
+        type: "equal",
+        before: raw[index].text,
+        after: raw[index].text,
+        beforeLine: raw[index].beforeLine,
+        afterLine: raw[index].afterLine
+      });
+      index += 1;
+      continue;
+    }
+    const changes = [];
+    while (index < raw.length && raw[index].type !== "equal") {
+      changes.push(raw[index]);
+      index += 1;
+    }
+    result.push(...pairChangedLines(changes));
+  }
+  return result;
+}
+
+export function chapterDiffSummary(rows) {
+  return rows.reduce((summary, row) => {
+    if (row.type === "added") summary.added += 1;
+    if (row.type === "deleted") summary.deleted += 1;
+    if (row.type === "modified") summary.modified += 1;
+    if (row.type === "equal") summary.unchanged += 1;
+    return summary;
+  }, { added: 0, deleted: 0, modified: 0, unchanged: 0 });
+}

package/dist/public/foreshadow-reminder.d.ts

@@ -0,0 +1,32 @@
+export type ForeshadowReminder = {
+  foreshadowId: string;
+  occurrenceId: string;
+  title: string;
+  description: string;
+  status: "planned" | "planted";
+  importance: "low" | "medium" | "high";
+  role: "reminder" | "payoff";
+  note: string;
+  versionNo: number;
+  updatedAt: string;
+};
+
+export const FORESHADOW_REMINDER_SNOOZE_STORAGE_KEY: string;
+export function normalizeForeshadowReminders(value: unknown): ForeshadowReminder[];
+export function foreshadowReminderSnoozeKey(
+  workId: unknown,
+  chapterId: unknown,
+  reminder: Partial<ForeshadowReminder> | null | undefined
+): string | null;
+export function parseForeshadowReminderSnoozes(serialized: unknown): Set<string>;
+export function serializeForeshadowReminderSnoozes(snoozes: ReadonlySet<string>, limit?: number): string;
+export function visibleForeshadowReminders(
+  reminders: unknown,
+  workId: unknown,
+  chapterId: unknown,
+  snoozes: ReadonlySet<string>
+): ForeshadowReminder[];
+export function foreshadowReminderRequestTargetsState(
+  request: { workId: unknown; chapterId: unknown } | null | undefined,
+  current: { workId?: unknown; chapterId?: unknown } | null | undefined
+): boolean;

package/dist/public/foreshadow-reminder.js

@@ -0,0 +1,73 @@
+export const FORESHADOW_REMINDER_SNOOZE_STORAGE_KEY = "scriverse.foreshadow-reminder-snoozes.v1";
+
+function normalizedId(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || null;
+}
+
+export function normalizeForeshadowReminders(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+    const foreshadowId = normalizedId(item.foreshadowId);
+    const occurrenceId = normalizedId(item.occurrenceId);
+    const title = String(item.title ?? "").trim();
+    const role = item.role === "payoff" ? "payoff" : item.role === "reminder" ? "reminder" : null;
+    const versionNo = Number(item.versionNo);
+    if (!foreshadowId || !occurrenceId || !title || !role || !Number.isInteger(versionNo) || versionNo < 1) return [];
+    return [{
+      foreshadowId,
+      occurrenceId,
+      title,
+      description: String(item.description ?? ""),
+      status: item.status === "planned" ? "planned" : "planted",
+      importance: ["low", "medium", "high"].includes(item.importance) ? item.importance : "medium",
+      role,
+      note: String(item.note ?? ""),
+      versionNo,
+      updatedAt: String(item.updatedAt ?? "")
+    }];
+  });
+}
+
+export function foreshadowReminderSnoozeKey(workId, chapterId, reminder) {
+  const parts = [
+    normalizedId(workId),
+    normalizedId(chapterId),
+    normalizedId(reminder?.foreshadowId),
+    normalizedId(reminder?.occurrenceId)
+  ];
+  const versionNo = Number(reminder?.versionNo);
+  if (parts.some((part) => !part) || !Number.isInteger(versionNo) || versionNo < 1) return null;
+  return [...parts, `v${versionNo}`].map((part) => encodeURIComponent(part)).join("|");
+}
+
+export function parseForeshadowReminderSnoozes(serialized) {
+  try {
+    const value = JSON.parse(String(serialized ?? "[]"));
+    return new Set(Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.length <= 1000) : []);
+  } catch {
+    return new Set();
+  }
+}
+
+export function serializeForeshadowReminderSnoozes(snoozes, limit = 500) {
+  const safeLimit = Number.isInteger(limit) && limit > 0 ? limit : 500;
+  const values = [...snoozes].filter((item) => typeof item === "string" && item.length <= 1000);
+  return JSON.stringify(values.slice(-safeLimit));
+}
+
+export function visibleForeshadowReminders(reminders, workId, chapterId, snoozes) {
+  return normalizeForeshadowReminders(reminders).filter((reminder) => {
+    const key = foreshadowReminderSnoozeKey(workId, chapterId, reminder);
+    return key && !snoozes.has(key);
+  });
+}
+
+export function foreshadowReminderRequestTargetsState(request, current) {
+  return Boolean(
+    request
+    && normalizedId(request.workId) === normalizedId(current?.workId)
+    && normalizedId(request.chapterId) === normalizedId(current?.chapterId)
+  );
+}

package/dist/public/global-replace-refresh.js

@@ -0,0 +1,60 @@
+function normalizeId(value) {
+  const id = String(value ?? "").trim();
+  return id || null;
+}
+
+function collapsedIds(value) {
+  if (value instanceof Set) return value;
+  return new Set(Array.isArray(value) ? value.map(normalizeId).filter(Boolean) : []);
+}
+
+function normalizedChapterCount(value) {
+  if (value === null || value === undefined || value === "") return null;
+  const count = Number(value);
+  return Number.isSafeInteger(count) && count >= 0 ? count : null;
+}
+
+export function resolveGlobalReplaceChapterCount(volume, previousVolume) {
+  const responseCount = normalizedChapterCount(volume?.chapterCount);
+  if (responseCount !== null) return responseCount;
+  if (Array.isArray(volume?.chapters)) return volume.chapters.length;
+  const previousCount = normalizedChapterCount(previousVolume?.chapterCount);
+  if (previousCount !== null) return previousCount;
+  return Array.isArray(previousVolume?.chapters) ? previousVolume.chapters.length : 0;
+}
+
+export function buildGlobalReplaceRefreshPlan({
+  volumes = [],
+  collapsedVolumeIds = [],
+  selectedChapterId = null,
+  selectedChapterVolumeId = null,
+  routeChapterId = null,
+  scope = "",
+  chapterCount = 0,
+  settingCount = 0
+} = {}) {
+  const volumeList = Array.isArray(volumes) ? volumes : [];
+  const collapsed = collapsedIds(collapsedVolumeIds);
+  const chapterId = normalizeId(selectedChapterId) ?? normalizeId(routeChapterId);
+  const chapterVolumeId = normalizeId(selectedChapterVolumeId)
+    ?? normalizeId(volumeList.find((volume) => Array.isArray(volume?.chapters)
+      && volume.chapters.some((chapter) => normalizeId(chapter?.id) === chapterId))?.id);
+  const proseChanged = (scope === "prose" || scope === "prose-and-settings") && Number(chapterCount) > 0;
+  const settingsChanged = (scope === "settings" || scope === "prose-and-settings") && Number(settingCount) > 0;
+  const expandedVolumeIds = volumeList
+    .filter((volume) => !collapsed.has(volume?.id))
+    .map((volume) => normalizeId(volume?.id))
+    .filter(Boolean);
+  const reloadVolumeIds = proseChanged
+    ? [...new Set([...expandedVolumeIds, chapterVolumeId].filter(Boolean))]
+    : [];
+
+  return {
+    proseChanged,
+    settingsChanged,
+    selectedChapterId: chapterId,
+    selectedChapterVolumeId: chapterVolumeId,
+    expandedVolumeIds,
+    reloadVolumeIds
+  };
+}