@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/schedules/schema.js

@@ -1,6 +1,11 @@
 import { z } from "zod";
+import { projectStates, stageKinds } from "../../kernel/pipeline.js";
+import { thinkingModes } from "../../kernel/ports/llm.js";
 import { cadenceSchema, validTimeZone } from "./calendar.js";
 const id = z.uuid();
+// What a project on the calendar waits on the person for: a failed or paused run, or a review
+// (a checkpoint holding the run, or an automatic review's failed item).
+export const calendarNeeds = ["failed", "paused", "review"];
 const keywordName = z
     .string()
     .min(1)
@@ -9,14 +14,58 @@ const keywordName = z
 const values = z.record(keywordName, z.string().max(10000)).readonly();
 // A queued topic. Each run takes the first one and removes it once its project starts.
 // `values` is only filled on schedules saved before topics had one keyword.
+export const topicTitleSchema = z.string().trim().min(1).max(200);
 const item = z
     .object({
-    title: z.string().trim().min(1).max(200),
+    title: topicTitleSchema,
     values,
 })
     .strict()
     .readonly();
 const policy = z.enum(["skip", "run-once"]);
+export const topicModes = ["off", "queue", "hold"];
+export const topicMinDefault = 10;
+export const briefMax = 4000;
+// Whether a schedule asks an LLM for topics when its queue runs low, and whether they join the
+// queue at once or wait for approval. `llm` is null for the template's own LLM.
+export const topicGenerationSchema = z
+    .object({
+    mode: z.enum(topicModes),
+    keepAtLeast: z.number().int().min(1).max(100),
+    llm: z
+        .object({
+        provider: z.string().min(1).max(100),
+        model: z.string().min(1).max(200),
+        thinking: z.enum(thinkingModes).optional(),
+    })
+        .strict()
+        .readonly()
+        .nullable(),
+})
+    .strict()
+    .readonly();
+export const topicGenerationOff = {
+    mode: "off",
+    keepAtLeast: topicMinDefault,
+    llm: null,
+};
+const topicState = z
+    .object({
+    held: z.number().int().nonnegative(),
+    generatingSince: z.string().nullable(),
+    generatedAt: z.string().nullable(),
+    failedAt: z.string().nullable(),
+    error: z.string().nullable(),
+})
+    .strict()
+    .readonly();
+export const topicStateIdle = {
+    held: 0,
+    generatingSince: null,
+    generatedAt: null,
+    failedAt: null,
+    error: null,
+};
 // Enough for a year of daily runs, pasted as one list.
 export const queueMax = 500;
 export const scheduleCreateSchema = z
@@ -39,6 +88,10 @@ export const scheduleCreateSchema = z
     topicKeyword: keywordName.nullable().default(null),
     // Keywords every run uses as they are, such as the word counts.
     values: values.default({}),
+    // What the channel covers, its style and what makes a topic worth watching. Only topic
+    // generation reads it.
+    brief: z.string().trim().max(briefMax).nullable().default(null),
+    topicGeneration: topicGenerationSchema.default(topicGenerationOff),
 })
     .strict()
     .readonly();
@@ -69,6 +122,11 @@ export const scheduleSummarySchema = z
     items: z.array(item).readonly(),
     topicKeyword: z.string().nullable().default(null),
     values: values.default({}),
+    brief: z.string().nullable().default(null),
+    topicGeneration: topicGenerationSchema.default(topicGenerationOff),
+    // The generation's own state: how many topics wait for approval, whether an LLM is being
+    // asked now, and the last failure's plain reason (cleared by the next success).
+    topics: topicState.default(topicStateIdle),
     status: z.enum(["active", "paused", "completed", "canceled"]),
     version: z.number().int().positive(),
     nextRunAt: z.string().datetime({ offset: true }).nullable(),
@@ -93,3 +151,123 @@ export const scheduleRunSchema = z
 })
     .strict()
     .readonly();
+// `values` are the keywords the person set on a held topic before approving it; they go with it
+// into the queue. Absent from a reply of a Slopify before they existed: none.
+export const heldTopicSchema = z
+    .object({
+    id,
+    title: z.string(),
+    values: z.record(z.string(), z.string()).readonly().default({}),
+    rank: z.number().int(),
+    createdAt: z.string(),
+})
+    .strict()
+    .readonly();
+// Edit on a held topic: its title, and its keywords when given (replacing the ones it had).
+export const heldTopicEditSchema = z
+    .object({ title: z.string(), values: z.record(keywordName, z.string()).optional() })
+    .strict();
+// Reordering is by position against the version the person saw, so a run taking the first
+// topic meanwhile makes the move refuse instead of moving the wrong one.
+export const topicMoveSchema = z
+    .object({
+    baseVersion: z.number().int().positive(),
+    from: z.number().int().nonnegative(),
+    to: z.number().int().nonnegative(),
+})
+    .strict()
+    .readonly();
+// The whole queue at once: the schedule page adds, renames, removes and reorders topics in
+// place, and Undo puts the queue back as it was.
+export const topicQueueSchema = z
+    .object({
+    baseVersion: z.number().int().positive(),
+    items: z.array(item).max(queueMax).readonly(),
+})
+    .strict()
+    .readonly();
+// The calendar: what will run, what is running or finished, and what waits in the batch queue.
+// `topicSource` says where a run's topic comes from: the queue (`topic` names it), topics held
+// for approval, a generation still to come, or none (the template as saved).
+export const calendarRunSchema = z
+    .object({
+    at: z.string(),
+    scheduleId: id,
+    scheduleName: z.string(),
+    scheduleVersion: z.number().int().positive(),
+    paused: z.boolean(),
+    templateId: id,
+    templateVersion: z.number().int().positive(),
+    templateName: z.string().nullable(),
+    // The topic's position in the schedule's queue, for reordering; null without one.
+    index: z.number().int().nonnegative().nullable(),
+    topic: z.string().nullable(),
+    topicSource: z.enum(["queued", "held", "generated", "template"]),
+    // The project title this run will get, the way the scheduler builds it; null when it can't
+    // be known yet (a topic still to be approved or generated, or a deleted template). Older
+    // servers leave it out.
+    renderedTitle: z.string().nullable().default(null),
+})
+    .strict()
+    .readonly();
+export const calendarProjectSchema = z
+    .object({
+    id: z.string(),
+    title: z.string(),
+    state: z.enum(projectStates),
+    createdAt: z.string(),
+    finishedAt: z.string().nullable(),
+    scheduleId: z.string().nullable(),
+    // What the project waits on the person for; left out when nothing.
+    needs: z.enum(calendarNeeds).optional(),
+    // Finished, makes a video, not marked uploaded and not a bundled sample.
+    readyToUpload: z.literal(true).optional(),
+    // Stages waiting for a CLI plan's limits to reset.
+    limitWaits: z
+        .array(z
+        .object({
+        name: z.string(),
+        stage: z.enum(stageKinds),
+        resetsAt: z.string().nullable(),
+        retryAt: z.string(),
+    })
+        .strict()
+        .readonly())
+        .readonly()
+        .optional(),
+})
+    .strict()
+    .readonly();
+export const calendarQueuedSchema = z
+    .object({
+    projectId: z.string(),
+    title: z.string(),
+    batchId: z.string(),
+    position: z.number().int(),
+    state: z.enum(["queued", "active"]),
+    queuedAt: z.string(),
+})
+    .strict()
+    .readonly();
+export const calendarSchema = z
+    .object({
+    from: z.string(),
+    to: z.string(),
+    runs: z.array(calendarRunSchema).readonly(),
+    projects: z.array(calendarProjectSchema).readonly(),
+    queued: z.array(calendarQueuedSchema).readonly(),
+})
+    .strict()
+    .readonly();
+// A calendar covers at most this many days per request.
+export const calendarMaxDays = 92;
+export const topicTransferSchema = z
+    .object({
+    baseVersion: z.number().int().positive(),
+    index: z.number().int().nonnegative(),
+    targetId: id,
+    // Where it lands in the other schedule's queue; the end when left out.
+    position: z.number().int().nonnegative().optional(),
+})
+    .strict()
+    .readonly();

package/dist/slices/schedules/service.js

@@ -3,7 +3,8 @@ import { transact } from "../../kernel/db/tx.js";
 import { requestHash } from "../play-drafts/repo.js";
 import { nextOccurrence } from "./calendar.js";
 import { insertSchedule, runsForSchedule, scheduleById, scheduleRows, setScheduleStatus, tombstoneScheduleRow, updateScheduleRow, } from "./repo.js";
-import { scheduleControlSchema, scheduleCreateSchema, scheduleDeleteSchema, scheduleUpdateSchema, } from "./schema.js";
+import { scheduleControlSchema, scheduleCreateSchema, scheduleDeleteSchema, scheduleUpdateSchema, topicStateIdle, } from "./schema.js";
+import { templateKeywords, topicRowProblems } from "./topic-list.js";
 export function listSchedules(deps) {
     return scheduleRows(deps.db);
 }
@@ -37,6 +38,9 @@ export function createSchedule(deps, input) {
         const checked = checkTemplate(deps, parsed.data.templateId, parsed.data.templateVersion);
         if (!checked.ok)
             return checked;
+        const topics = checkTopics(deps, parsed.data, []);
+        if (!topics.ok)
+            return topics;
         const now = deps.clock.now();
         const next = nextOccurrence(parsed.data.cadence, parsed.data.timezone, now);
         if (next === null)
@@ -76,13 +80,18 @@ export function updateSchedule(deps, input) {
         const checked = checkTemplate(deps, parsed.data.templateId, parsed.data.templateVersion);
         if (!checked.ok)
             return checked;
+        const topics = checkTopics(deps, parsed.data, previous.items);
+        if (!topics.ok)
+            return topics;
         const now = deps.clock.now();
         const next = previous.status === "active"
             ? nextOccurrence(parsed.data.cadence, parsed.data.timezone, now)
             : previous.nextRunAt === null
                 ? null
                 : nextOccurrence(parsed.data.cadence, parsed.data.timezone, now);
-        const value = summary(parsed.data, next?.toISOString() ?? null, now.toISOString(), previous.status, previous.version + 1);
+        const value = summary(parsed.data, next?.toISOString() ?? null, now.toISOString(), previous.status, previous.version + 1, 
+        // Saving clears a recorded generation failure, so the next tick tries again.
+        { ...previous.topics, failedAt: null, error: null });
         if (!updateScheduleRow(deps.db, value, parsed.data.mutationId, hash, parsed.data.baseVersion))
             return { ok: false, reason: "conflict" };
         return { ok: true, value };
@@ -154,14 +163,41 @@ function checkTemplate(deps, id, version) {
     const mediaSources = ["audio", "images", "thumbnail"];
     const { form } = template.document;
     // A supplied file is attached again on Play, which a scheduled run cannot do; the shorts'
-    // background music is one too.
+    // background music is one too, and so is the ambient bed's own file.
     if (mediaSources.some((kind) => sources[kind] === "provide") ||
         (form.shorts?.enabled === true && form.provided.shortsMusic) ||
+        form.ambientBed?.source === "upload" ||
         (sources.images === "generate" && form.reference?.source === "provide"))
         return { ok: false, reason: "unsupported-media" };
     return { ok: true, value: true };
 }
-function summary(input, nextRunAt, now, status = "active", version = 1) {
+// The queue's keywords must be the template's: a topic (or an every-run value) naming a keyword
+// the template doesn't use would silently do nothing. Topics saved before, unchanged, are left
+// alone, so a queue from before this check still saves.
+function checkTopics(deps, input, kept) {
+    const template = deps.template(input.templateId, input.templateVersion);
+    if (!template)
+        return { ok: false, reason: "missing-template" };
+    const keywords = templateKeywords(template.document.form);
+    const named = keywords.length === 0 ? "none" : keywords.map((one) => `“${one}”`).join(", ");
+    const problems = [];
+    if (input.topicKeyword !== null && !keywords.includes(input.topicKeyword))
+        problems.push(`The topic keyword “${input.topicKeyword}” is not in this template (its keywords are ${named}). Pick another under Each topic fills.`);
+    for (const keyword of Object.keys(input.values))
+        if (!keywords.includes(keyword))
+            problems.push(`“${keyword}” (for every run) is not a keyword of this template (its keywords are ${named}). Remove it, or pick the template that uses it.`);
+    problems.push(...topicRowProblems(input.items, { keywords, topicKeyword: input.topicKeyword, kept }));
+    if (problems.length === 0)
+        return { ok: true, value: true };
+    const shown = problems.slice(0, 5);
+    const more = problems.length - shown.length;
+    return {
+        ok: false,
+        reason: "invalid-topics",
+        message: `The schedule wasn't saved. ${shown.join(" ")}${more > 0 ? ` And ${String(more)} more like these.` : ""}`,
+    };
+}
+function summary(input, nextRunAt, now, status = "active", version = 1, topics = topicStateIdle) {
     return {
         id: input.id,
         name: input.name,
@@ -175,6 +211,9 @@ function summary(input, nextRunAt, now, status = "active", version = 1) {
         items: input.items,
         topicKeyword: input.topicKeyword,
         values: input.values,
+        brief: input.brief === null || input.brief === "" ? null : input.brief,
+        topicGeneration: input.topicGeneration,
+        topics,
         status,
         version,
         nextRunAt,

package/dist/slices/schedules/similar.js

@@ -0,0 +1,128 @@
+// Near-duplicate checks for generated topics. Pure, so the web bundle can import it too.
+//
+// Two topics are the same when, after normalising (accents dropped, lower case, punctuation
+// to spaces, "&" read as "and"):
+// - the texts are equal, or
+// - their word sets overlap by at least `jaccardMin` (shared words / all words), or
+// - one's words all appear in the other's and cover at least `containmentMin` of it
+//   ("Cleopatra" and "Cleopatra's Palace" are one video; "Red Pyramids" and "Bent Pyramids" are two).
+// Words are compared without filler words ("the", "of", …) and without a plural "s".
+// A project title is compared more loosely: every word of the topic appearing in it is enough,
+// because the title wraps the topic in the template's own words ("History: Cleopatra"). A topic
+// of one or two words is too easily found inside an unrelated title ("Pyramids" in "The Great
+// Pyramids of Giza"), so one of the title's clauses must hold exactly its words, leaving aside
+// question and framing words ("Hypatia" in "Who was Hypatia? The Last Scholar Explained").
+export const jaccardMin = 0.6;
+export const containmentMin = 0.5;
+const filler = new Set([
+    "a",
+    "an",
+    "the",
+    "of",
+    "and",
+    "or",
+    "in",
+    "on",
+    "to",
+    "for",
+    "with",
+    "vs",
+    "s",
+]);
+export function normaliseTopic(text) {
+    return text
+        .normalize("NFKD")
+        .replace(/\p{M}/gu, "")
+        .toLowerCase()
+        .replace(/&/g, " and ")
+        .replace(/[^\p{L}\p{N}]+/gu, " ")
+        .trim();
+}
+export function topicWords(text) {
+    const words = normaliseTopic(text)
+        .split(" ")
+        .filter((word) => word !== "" && !filler.has(word))
+        .map((word) => word.length > 3 && word.endsWith("s") && !word.endsWith("ss") ? word.slice(0, -1) : word);
+    return new Set(words);
+}
+function shared(a, b) {
+    let count = 0;
+    for (const word of a)
+        if (b.has(word))
+            count += 1;
+    return count;
+}
+export function similarTopics(a, b) {
+    const left = normaliseTopic(a);
+    const right = normaliseTopic(b);
+    if (left === right)
+        return left !== "";
+    const wa = topicWords(a);
+    const wb = topicWords(b);
+    if (wa.size === 0 || wb.size === 0)
+        return false;
+    const common = shared(wa, wb);
+    if (common / (wa.size + wb.size - common) >= jaccardMin)
+        return true;
+    const small = Math.min(wa.size, wb.size);
+    const large = Math.max(wa.size, wb.size);
+    return common === small && small / large >= containmentMin;
+}
+export const shortTopicWords = 2;
+// A topic already made as a project: all of its words appear in the project's title, or for a
+// short topic, the title or one of its parts is near the same.
+export function topicInTitle(topic, title) {
+    if (similarTopics(topic, title))
+        return true;
+    const words = topicWords(topic);
+    if (words.size === 0)
+        return false;
+    if (words.size <= shortTopicWords) {
+        const wanted = subjectWords(topic);
+        return titleClauses(title).some((clause) => sameWords(subjectWords(clause), wanted));
+    }
+    return shared(words, topicWords(title)) === words.size;
+}
+// Words that frame a subject in a title without being part of it.
+const framing = new Set([
+    "who",
+    "what",
+    "why",
+    "how",
+    "when",
+    "where",
+    "which",
+    "is",
+    "was",
+    "are",
+    "were",
+    "really",
+    "explained",
+]);
+function subjectWords(text) {
+    return new Set([...topicWords(text)].filter((word) => !framing.has(word)));
+}
+function sameWords(a, b) {
+    return a.size > 0 && a.size === b.size && shared(a, b) === a.size;
+}
+// "History: Cleopatra (Part 2) | Who is Hypatia?" → ["History", "Cleopatra", "Part 2", "Who is Hypatia"].
+function titleClauses(title) {
+    return title
+        .split(/\s*[:|()[\]?!.,;\u2013\u2014]\s*|\s+-\s+/u)
+        .map((part) => part.trim())
+        .filter((part) => part !== "");
+}
+// Keeps the candidates that are new, in their order, dropping repeats among themselves too.
+export function newTopics(candidates, known) {
+    const kept = [];
+    for (const candidate of candidates) {
+        if (known.topics.some((topic) => similarTopics(candidate, topic)))
+            continue;
+        if (known.projects.some((title) => topicInTitle(candidate, title)))
+            continue;
+        if (kept.some((topic) => similarTopics(candidate, topic)))
+            continue;
+        kept.push(candidate);
+    }
+    return kept;
+}

package/dist/slices/schedules/topic-list.js

@@ -0,0 +1,163 @@
+import { parse, stringify } from "yaml";
+import { detectSlots, render } from "../admission/substitute.js";
+// The longest value one topic may give a keyword. Word counts, names and short notes fit;
+// anything longer belongs in the template.
+export const topicValueMax = 2000;
+export const topicTitleMax = 200;
+// A template's keywords: those its project title names plus those it stores a value for (Play
+// stores one for every keyword its prompts use).
+export function templateKeywords(form) {
+    return [...new Set([...detectSlots(form.title).names, ...Object.keys(form.values)])];
+}
+// The project title a run gets, exactly as the scheduler builds it: the template's values, the
+// schedule's every-run values, the topic's own values, then the topic in its keyword. Without
+// a topic keyword the topic is the whole title.
+export function scheduledValues(form, schedule, topic) {
+    return {
+        ...form.values,
+        ...schedule.values,
+        ...(topic?.values ?? {}),
+        ...(topic !== undefined && schedule.topicKeyword !== null
+            ? { [schedule.topicKeyword]: topic.title }
+            : {}),
+    };
+}
+export function renderedTitle(form, schedule, topic) {
+    return topic !== undefined && schedule.topicKeyword === null
+        ? topic.title
+        : render(form.title, scheduledValues(form, schedule, topic));
+}
+const quote = (name) => `“${name}”`;
+const listed = (names) => names.length === 0 ? "none" : names.map(quote).join(", ");
+function rowName(index, title) {
+    return title === "" ? `Topic ${String(index + 1)}` : `Topic ${String(index + 1)} (${title})`;
+}
+// What is wrong with a queue, one plain sentence per problem naming the row and the key.
+// `keywords` are the template's; `required` must be set on every row (keywords with no
+// every-run value); an item equal to one in `kept` (the saved queue) is not checked again, so
+// a topic saved before these rules keeps working until it is edited.
+export function topicRowProblems(rows, options) {
+    const problems = [];
+    const kept = new Set((options.kept ?? []).map((row) => key(row)));
+    rows.forEach((row, index) => {
+        if (kept.has(key(row)))
+            return;
+        const name = rowName(index, row.title.trim());
+        if (row.title.trim() === "")
+            problems.push(options.topicKeyword === null
+                ? `${name} has no title. Write one, or remove the row.`
+                : `${name} has no ${quote(options.topicKeyword)}, the keyword each topic fills. Write one, or remove the row.`);
+        else if (row.title.trim().length > topicTitleMax)
+            problems.push(`${name} is ${String(row.title.trim().length)} characters; a topic can be at most ${String(topicTitleMax)}. Shorten it.`);
+        for (const [keyword, value] of Object.entries(row.values)) {
+            if (!options.keywords.includes(keyword))
+                problems.push(`${name}: ${quote(keyword)} is not a keyword of this template (its keywords are ${listed(options.keywords)}). Rename it to one of them or remove it.`);
+            else if (value.length > topicValueMax)
+                problems.push(`${name}: ${quote(keyword)} is ${String(value.length)} characters; a topic's value can be at most ${String(topicValueMax)}. Shorten it, or put the long text in the template.`);
+        }
+        for (const keyword of options.required ?? []) {
+            if (keyword === options.topicKeyword)
+                continue;
+            if ((row.values[keyword] ?? "").trim() === "")
+                problems.push(`${name} has no ${quote(keyword)}, and there is no every-run value to fall back on. Give this topic one, or fill ${quote(keyword)} for every run.`);
+        }
+    });
+    return problems;
+}
+function key(row) {
+    return JSON.stringify([
+        row.title,
+        Object.entries(row.values).sort(([a], [b]) => a.localeCompare(b)),
+    ]);
+}
+// One topic per line. A line whose text matches a row already in the queue keeps that row's
+// values (first unused match), so switching to lines and back loses nothing.
+export function rowsFromLines(text, previous) {
+    const unused = [...previous];
+    return text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line !== "")
+        .map((title) => {
+        const at = unused.findIndex((row) => row.title === title);
+        if (at === -1)
+            return { title, values: {} };
+        const [row] = unused.splice(at, 1);
+        return row ?? { title, values: {} };
+    });
+}
+export function linesFromRows(rows) {
+    return rows.map((row) => row.title).join("\n");
+}
+// The YAML / JSON list: each item is a map of keyword to value, or a plain string (the topic).
+// JSON is YAML, so a JSON array reads the same way. Numbers and yes/no are read as the text
+// they were written as; lists, maps and multi-document files are refused.
+export function parseTopicList(text, options) {
+    if (text.trim() === "")
+        return { ok: true, rows: [] };
+    let data;
+    try {
+        // Every scalar as the string it was written as: "12000", "yes", "0012".
+        data = parse(text, { schema: "failsafe", uniqueKeys: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message.split("\n")[0] : "";
+        return {
+            ok: false,
+            problems: [
+                `The list couldn't be read as YAML or JSON: ${message ?? ""}. Write one item per topic, such as "- Topic: Cleopatra".`,
+            ],
+        };
+    }
+    if (!Array.isArray(data))
+        return {
+            ok: false,
+            problems: [
+                'The list must be a list of topics: start each one with "- " in YAML, or wrap them in [ ] in JSON.',
+            ],
+        };
+    const problems = [];
+    const rows = [];
+    data.forEach((item, index) => {
+        const name = `Topic ${String(index + 1)}`;
+        if (typeof item === "string") {
+            rows.push({ title: item.trim(), values: {} });
+            return;
+        }
+        if (item === null || typeof item !== "object" || Array.isArray(item)) {
+            problems.push(`${name} is not a topic or a set of keywords. Write it as "- Cleopatra" or "- Topic: Cleopatra".`);
+            return;
+        }
+        let title = "";
+        const values = {};
+        for (const [written, value] of Object.entries(item)) {
+            const keyword = written.trim();
+            // "Topic:" with nothing after it reads as no value.
+            const raw = value ?? "";
+            if (typeof raw !== "string") {
+                problems.push(`${name}: ${quote(keyword)} holds a list or a map. Give it one value, such as "${keyword}: 12000".`);
+                continue;
+            }
+            if (options.topicKeyword !== null && keyword === options.topicKeyword)
+                title = raw.trim();
+            else if (!options.keywords.includes(keyword))
+                problems.push(`${name}: ${quote(keyword)} is not a keyword of this template (its keywords are ${listed(options.keywords)}). Rename it to one of them or remove it.`);
+            else
+                values[keyword] = raw.trim();
+        }
+        rows.push({ title, values });
+    });
+    // Unknown keys were left out of the rows above, so these name the other problems once.
+    const all = [...problems, ...topicRowProblems(rows, options)];
+    return all.length > 0 ? { ok: false, problems: all } : { ok: true, rows };
+}
+// The queue as YAML: a plain "- title" when a topic sets nothing else, else a map with the
+// topic keyword first. Reading it back with parseTopicList gives the same rows.
+export function formatTopicList(rows, topicKeyword) {
+    if (rows.length === 0)
+        return "";
+    const items = rows.map((row) => Object.keys(row.values).length === 0 || topicKeyword === null
+        ? row.title
+        : { [topicKeyword]: row.title, ...row.values });
+    return stringify(items, { lineWidth: 0 });
+}