@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/slices/narration/pronunciation.js

@@ -4,6 +4,10 @@ import remarkGfm from "remark-gfm";
 // https://docs.inworld.ai/tts/capabilities/custom-pronunciation
 const ipaAtom = "[ˈˌ]?[abdefghijklmnoprstuvwxzæðŋθɑɒɔəɚɛɜɝɡɪɹʃʊʌʒʔɫɾ][\\u0303\\u031a\\u0325\\u0329\\u032a\\u032c\\u032f\\u035c\\u0361ʰʲʷ]*[ːˑ]?";
 const ipaSymbols = new RegExp(`^(?:${ipaAtom})+(?:\\.(?:${ipaAtom})+)*$`, "u");
+// Another language's glossary needs that language's sounds: the full IPA consonant and vowel
+// charts (ç, ʁ, ø, y, ɲ, ʎ, x, β, …) and its diacritics, still never ARPAbet or tags.
+const worldAtom = "[ˈˌ]?[a-zæçðøħŋœɐɑɒɓɔɕɖɗɘəɚɛɜɝɞɟɠɡɢɣɤɥɦɧɨɪɫɬɭɮɯɰɱɲɳɴɵɶɸɹɺɻɽɾʀʁʂʃʄʈʉʊʋʌʍʎʏʐʑʒʔʕʙʛʜʝʟʡʢβθχ][\\u0300-\\u036fʰʱʲʷʼˠˤ˞]*[ːˑ]?";
+const worldSymbols = new RegExp(`^(?:${worldAtom})+(?:\\.(?:${worldAtom})+)*$`, "u");
 function textOf(node) {
     if (node.type === "break")
         return "\n";
@@ -18,7 +22,12 @@ function rowsOf(node) {
         const rows = node.children ?? [];
         return rows.slice(1).map((row) => {
             const cells = row.children ?? [];
-            return cells.length >= 2 ? cells.slice(0, 2).map(textOf).join(": ") : textOf(row);
+            if (cells.length < 2)
+                return textOf(row);
+            const [term, ipa] = cells.slice(0, 2).map((cell) => textOf(cell).trim());
+            // A table's IPA column is often written without the slashes ("| Tiamat | ˈtiːəmɑːt |");
+            // the column already says what the cell is, so a bare cell reads as one /…/ pronunciation.
+            return `${term}: ${ipa !== undefined && ipa !== "" && !ipa.includes("/") ? `/${ipa}/` : ipa}`;
         });
     }
     if (node.type === "paragraph")
@@ -27,16 +36,6 @@ function rowsOf(node) {
         return (node.children ?? []).flatMap(rowsOf);
     return ["(unsupported glossary block)"];
 }
-function refused(row, reason) {
-    return {
-        ok: false,
-        reason: "Pronunciation Glossary entry " +
-            row +
-            ": " +
-            reason +
-            ". Edit the glossary or turn off Use Pronunciation Glossary.",
-    };
-}
 function termIdentity(term) {
     return Array.from(term, (character) => {
         const lower = character.toLowerCase();
@@ -48,10 +47,19 @@ function termIdentity(term) {
         return match.test(folded) ? folded : match.test(lower) ? lower : character;
     }).join("");
 }
-export function parsePronunciationGlossary(markdown) {
+// `language` is the project's (`kernel/ports/languages.ts`): absent or English accepts the
+// standard-English IPA Inworld asks for, as it always did; any other accepts full IPA.
+export function parsePronunciationGlossary(markdown, language) {
+    const english = language === undefined || language === "en";
+    const symbols = english ? ipaSymbols : worldSymbols;
+    const kind = english ? "standard-English IPA" : "IPA";
     const rows = rowsOf(remark().use(remarkGfm).parse(markdown));
     const entries = new Map();
+    const skipped = [];
     for (const [index, row] of rows.entries()) {
+        const skip = (reason) => {
+            skipped.push({ row: index + 1, reason });
+        };
         const trimmed = row.trim();
         if (trimmed === "" || /^pronunciation glossary:?\s*$/iu.test(trimmed))
             continue;
@@ -61,24 +69,63 @@ export function parsePronunciationGlossary(markdown) {
         if (term === undefined ||
             pronunciation === undefined ||
             !/[\p{L}\p{N}]/u.test(term) ||
-            /[/[\]<>\p{Cc}]/u.test(term))
-            return refused(index + 1, "use Term: /IPA/ or a Term | IPA table");
+            /[/[\]<>\p{Cc}]/u.test(term)) {
+            skip("use Term: /IPA/ or a Term | IPA table");
+            continue;
+        }
         const notation = /^(\/[^/]+\/(?:\s+\/[^/]+\/)*)(?:\s+[^/]+)?$/u.exec(pronunciation);
-        if (notation?.[1] === undefined)
-            return refused(index + 1, "use slash-delimited standard-English IPA");
+        if (notation?.[1] === undefined) {
+            skip(`use slash-delimited ${kind}`);
+            continue;
+        }
         const ipa = Array.from(notation[1].matchAll(/\/([^/]+)\//gu)).flatMap((match) => (match[1] ?? "").trim().split(/\s+/u));
-        if (ipa.length === 0 || ipa.some((word) => !ipaSymbols.test(word)))
-            return refused(index + 1, "use standard-English IPA, not ARPAbet or delivery tags");
-        if (term.split(" ").length !== ipa.length)
-            return refused(index + 1, "supply one IPA word for each written word");
+        if (ipa.length === 0 || ipa.some((word) => !symbols.test(word))) {
+            skip(english
+                ? "use standard-English IPA only, not ARPAbet, delivery tags or non-English sounds; give a foreign name an English approximation"
+                : "use IPA, not ARPAbet or delivery tags");
+            continue;
+        }
+        if (term.split(" ").length !== ipa.length) {
+            skip("supply one IPA word for each written word");
+            continue;
+        }
         const key = termIdentity(term);
         const previous = entries.get(key);
-        if (previous !== undefined && previous.ipa.join(" ") !== ipa.join(" "))
-            return refused(index + 1, "conflicting pronunciations were supplied for the same term");
+        if (previous !== undefined && previous.ipa.join(" ") !== ipa.join(" ")) {
+            skip("an earlier entry already gives this term a different pronunciation");
+            continue;
+        }
         if (previous === undefined)
             entries.set(key, { term, ipa });
     }
-    return { ok: true, entries: [...entries.values()] };
+    return skipped.length === 0
+        ? { ok: true, entries: [...entries.values()] }
+        : { ok: true, entries: [...entries.values()], skipped };
+}
+// What a person reads about the skipped rows: where they are and why, never their text.
+export function skippedGlossaryNotice(skipped) {
+    if (skipped.length === 0)
+        return null;
+    const rows = skipped.map((one) => `entry ${one.row}: ${one.reason}`).join("; ");
+    return (`Pronunciation Glossary: ${skipped.length === 1 ? "1 entry is" : `${skipped.length} entries are`} ` +
+        `skipped and read as ordinary text (${rows}). The rest of the glossary is used. ` +
+        "To use them, fix those entries in the Pronunciation Glossary at the end of the article in Edit project → Article.");
+}
+export function skippedSpeakerPronunciations(speakers, language) {
+    return speakers.flatMap((speaker) => {
+        if (!speaker.pronunciations?.trim())
+            return [];
+        const parsed = parsePronunciationGlossary(speaker.pronunciations, language);
+        const skipped = parsed.ok ? (parsed.skipped ?? []) : [];
+        return skipped.length === 0 ? [] : [{ speaker: speaker.name.trim() || "A speaker", skipped }];
+    });
+}
+export function skippedSpeakerPronunciationsNotice(rows) {
+    if (rows.length === 0)
+        return null;
+    const parts = rows.map((row) => `${row.speaker}: ${row.skipped.map((one) => `entry ${one.row}: ${one.reason}`).join("; ")}`);
+    return (`Speaker pronunciations: some entries are skipped and read as ordinary text (${parts.join(". ")}). ` +
+        "The rest are used. To use them, fix those entries under Speakers → Pronunciations for that speaker (Play → Audio, or Edit project → Providers).");
 }
 export function pronunciationMatches(source, entries) {
     if (entries.length === 0)
@@ -105,7 +152,7 @@ export function pronunciationMatches(source, entries) {
             continue;
         const entry = ordered.find((_, index) => match[index + 1] !== undefined);
         if (entry === undefined)
-            throw new Error("Slopify hit an internal error (a pronunciation glossary term has no pronunciation). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (a pronunciation glossary term has no pronunciation). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         matches.push({ start: match.index, end, entry });
     }
     return matches;
@@ -117,7 +164,7 @@ export function pronunciationSpans(source, entries) {
         for (const [index, word] of Array.from(words).entries()) {
             const ipa = match.entry.ipa[index];
             if (ipa === undefined)
-                throw new Error("Slopify hit an internal error (a pronunciation glossary term is missing a word). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error("Slopify hit an internal error (a pronunciation glossary term is missing a word). Try again; if it happens again, use Download diagnostics in Settings and report it.");
             const start = match.start + word.index;
             spans.push({ start, end: start + word[0].length, text: `/${ipa}/` });
         }

package/dist/slices/narration/run.js

@@ -14,7 +14,7 @@ import { planLegacyNarration } from "./legacy-plan.js";
 import { observeNarration } from "./live.js";
 // An empty narration source fails the stage immediately with no retries. Thrown from the
 // slice rather than from a provider call, so the attempt wrapper never sees it.
-export const nothingToNarrate = "There is nothing to narrate because the article is empty. Add article text in Edit project → Article, then Retry stage.";
+export const nothingToNarrate = "There is nothing to narrate because the article is empty. Add article text in Edit project → Article, then Try again.";
 // What a chunk piece carries between runs: the text that was sent, and the file it came
 // back as once the provider answered. That is the whole of the resume.
 const chunkPayload = z.object({ text: z.string(), file: z.string().optional() });
@@ -41,7 +41,7 @@ export async function runNarration(deps, context, providers) {
     if (choice === undefined) {
         // Admission refuses a run whose audio is Generate without a provider and a voice, so
         // reaching here is a bug in admission rather than something the user did.
-        throw new Error("No voice is set for the narration. Choose a voice in Edit project → Providers, then Retry stage.");
+        throw new Error("No voice is set for the narration. Choose a voice in Edit project → Providers, then Try again.");
     }
     // Read once, before anything is written: the segment steps below ask it what a previous
     // run already stored, and the body step is the only thing that adds to it.
@@ -168,7 +168,7 @@ async function speakSegments(deps, context, providers, choice, outputs) {
         if (text === "") {
             // The same rule, applied to a segment: there is nothing to say, and silently
             // dropping an intro the user picked would lose it without telling anyone.
-            throw new Error(`The ${segment.category} is empty, so there is nothing to narrate for it. Write the ${segment.category} or remove it in Edit project, then Retry stage.`);
+            throw new Error(`The ${segment.category} is empty, so there is nothing to narrate for it. Write the ${segment.category} or remove it in Edit project, then Try again.`);
         }
         const spoken = await providers.forPiece(piece.id).tts({
             provider: choice.provider,
@@ -200,7 +200,7 @@ function segmentPieces(deps, projectId) {
     if (article === undefined) {
         // Admission writes all six stage rows with the project, so a project without an article
         // stage is a bug rather than a run the user configured.
-        throw new Error("Slopify hit an internal error (the project has no article stage). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the project has no article stage). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return piecesOf(deps.db, article.id, "segment");
 }
@@ -257,13 +257,13 @@ function store(deps, projectId, role, path, durationMs, choice) {
 }
 function chunkOf(piece) {
     if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved narration chunk is empty). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (a saved narration chunk is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return chunkPayload.parse(JSON.parse(piece.payload));
 }
 function segmentOf(piece) {
     if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved intro or outro is empty). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (a saved intro or outro is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     }
     return segmentPayload.parse(JSON.parse(piece.payload));
 }

package/dist/slices/narration/shared-glossary.js

@@ -22,7 +22,7 @@ export function collectSharedGlossary(deps, exceptProjectId) {
             continue;
         }
         const parsed = parsePronunciationGlossary(text);
-        // A glossary that doesn't parse can't be trusted in someone else's narration either.
+        // Rows it had to skip are left out; a glossary that does not parse at all shares nothing.
         if (!parsed.ok)
             continue;
         for (const entry of parsed.entries) {

package/dist/slices/narration/steering.js

@@ -9,21 +9,32 @@ function atoms(source, from, to, spans) {
         const span = spans.get(at);
         if (span !== undefined) {
             if (span.end > to || span.end <= at)
-                throw new Error("Slopify hit an internal error (a pronunciation fix spans more than one word). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error("Slopify hit an internal error (a pronunciation fix spans more than one word). Try again; if it happens again, use Download diagnostics in Settings and report it.");
             result.push({ text: span.text, spokenText: source.slice(at, span.end) });
             at = span.end;
         }
         else {
             const point = source.codePointAt(at);
             if (point === undefined)
-                throw new Error("Slopify hit an internal error (a narration position is outside the article text). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error("Slopify hit an internal error (a narration position is outside the article text). Try again; if it happens again, use Download diagnostics in Settings and report it.");
             const text = String.fromCodePoint(point);
-            result.push({ text, spokenText: text });
+            // An empty span is a later word of a multi-word alias (its spoken form sits on the first
+            // word), so the whitespace in front of it would leave two spaces where one word was.
+            // It stays in the spoken (transcript) text, which the captions are aligned against.
+            result.push({ text: silencedBefore(source, at, spans) ? "" : text, spokenText: text });
             at += text.length;
         }
     }
     return result;
 }
+function silencedBefore(source, at, spans) {
+    if (!/\s/u.test(source[at] ?? ""))
+        return false;
+    let next = at;
+    while (next < source.length && /\s/u.test(source[next] ?? ""))
+        next += 1;
+    return spans.get(next)?.text === "";
+}
 function checkedSpans(source, pronunciation) {
     const spans = new Map();
     let end = 0;
@@ -34,7 +45,7 @@ function checkedSpans(source, pronunciation) {
             span.end <= span.start ||
             span.end > source.length ||
             !/^[^\s\uD800-\uDFFF]+$/u.test(source.slice(span.start, span.end)))
-            throw new Error("Slopify hit an internal error (pronunciation fixes overlap or split a word). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (pronunciation fixes overlap or split a word). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         spans.set(span.start, span);
         end = span.end;
     }

package/dist/slices/notifications/notifier.js

@@ -0,0 +1,94 @@
+import { redact } from "../../kernel/log.js";
+import { noticeOf, noticeText, topicsNoticeText, webhookBody } from "./rules.js";
+import { sendFailureText } from "./send.js";
+export function createRunNotifier(deps) {
+    // ceiling: one entry per project seen since boot, a few dozen bytes each.
+    const states = new Map();
+    const reasons = new Map();
+    const inflight = new Set();
+    let closed = false;
+    const notify = (projectId, kind) => {
+        const url = deps.url();
+        if (url === null)
+            return;
+        const subject = deps.subject(projectId);
+        if (subject === undefined)
+            return;
+        const text = noticeText(kind, { ...subject, reason: reasons.get(projectId) });
+        post(url, text, kind, { projectId });
+    };
+    const post = (url, text, kind, about) => {
+        const body = redact(webhookBody(text));
+        const sending = deps
+            .send(url, body)
+            .then((result) => {
+            if (!result.ok)
+                deps.log.write("warn", "notification.failed", {
+                    ...about,
+                    detail: `${kind} notification not delivered: ${sendFailureText(result)}`,
+                });
+        })
+            .catch((error) => {
+            deps.log.write("warn", "notification.failed", {
+                ...about,
+                detail: `${kind} notification not delivered: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        })
+            .finally(() => {
+            inflight.delete(sending);
+        });
+        inflight.add(sending);
+    };
+    return {
+        observe: (event) => {
+            if (closed)
+                return;
+            try {
+                if (event.type === "stage.state") {
+                    if (event.state === "failed" && event.failureReason !== undefined)
+                        reasons.set(event.projectId, event.failureReason);
+                    else if (event.state === "running")
+                        reasons.delete(event.projectId);
+                    return;
+                }
+                if (event.type !== "project.state")
+                    return;
+                const previous = states.get(event.projectId);
+                if (previous === event.state)
+                    return;
+                states.set(event.projectId, event.state);
+                const kind = noticeOf(previous, event.state);
+                if (kind !== undefined)
+                    notify(event.projectId, kind);
+            }
+            catch (error) {
+                deps.log.write("warn", "notification.failed", {
+                    projectId: event.projectId,
+                    detail: `notification skipped: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        },
+        observeTopics: (event) => {
+            if (closed || event.added === 0)
+                return;
+            try {
+                const url = deps.url();
+                if (url === null)
+                    return;
+                post(url, topicsNoticeText(event), "topics", {});
+            }
+            catch (error) {
+                deps.log.write("warn", "notification.failed", {
+                    detail: `topics notification skipped: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+        },
+        close: () => {
+            closed = true;
+        },
+        settled: async () => {
+            while (inflight.size > 0)
+                await Promise.all([...inflight]);
+        },
+    };
+}

package/dist/slices/notifications/rules.js

@@ -0,0 +1,102 @@
+// Only a run seen running can finish, fail or stop to wait: a project first seen already done
+// was done before anyone was watching. Paused and canceled are what the user just pressed, so
+// they say nothing. `pending` after `running` is the runner finding nothing it may start: a
+// review checkpoint holding the next step, or held work waiting for Resume.
+export function noticeOf(previous, next) {
+    if (previous !== "running")
+        return undefined;
+    switch (next) {
+        case "done":
+            return "ready";
+        case "partial":
+            return "partial";
+        case "failed":
+            return "failed";
+        case "pending":
+            return "waiting";
+        default:
+            return undefined;
+    }
+}
+const reasonMax = 140;
+// A provider's failure can run to paragraphs; a notification has a line.
+export function shortReason(reason) {
+    const line = reason
+        ?.split(/\r?\n/)
+        .map((part) => part.trim())
+        .find((part) => part !== "");
+    if (line === undefined)
+        return undefined;
+    return line.length <= reasonMax ? line : `${line.slice(0, reasonMax - 1).trimEnd()}…`;
+}
+export function noticeText(kind, subject) {
+    const title = subject.title.trim() === "" ? "Untitled project" : subject.title.trim();
+    switch (kind) {
+        case "ready":
+            return subject.makesVideo
+                ? { headline: `Video ready: ${title}`, detail: "Open the project to watch it." }
+                : { headline: `Run finished: ${title}`, detail: "Open the project to see its files." };
+        case "partial": {
+            const reason = shortReason(subject.reason);
+            const made = subject.makesVideo
+                ? `Video ready with problems: ${title}`
+                : `Run finished with problems: ${title}`;
+            return {
+                headline: reason === undefined ? made : `${made} — ${reason}`,
+                detail: "Open the project to see which step failed and the button that fixes it.",
+            };
+        }
+        case "failed": {
+            const reason = shortReason(subject.reason);
+            return {
+                headline: reason === undefined ? `Run failed: ${title}` : `Run failed: ${title} — ${reason}`,
+                detail: "Open the project to see what stopped it and press Retry.",
+            };
+        }
+        case "waiting":
+            return {
+                headline: `Waiting for you: ${title}`,
+                detail: "Open the project to review the held step or press Continue the run.",
+            };
+    }
+}
+export function topicsNoticeText(subject) {
+    const name = subject.scheduleName.trim() === "" ? "Untitled schedule" : subject.scheduleName.trim();
+    const count = subject.added;
+    const total = subject.waiting > count ? ` ${String(subject.waiting)} are waiting in all.` : "";
+    return {
+        headline: `${String(count)} new ${count === 1 ? "topic is" : "topics are"} waiting for you`,
+        detail: `Open Calendar → Suggested topics → ${name} to queue or reject ${count === 1 ? "it" : "them"}.${total}`,
+    };
+}
+export const testNotice = {
+    headline: "Slopify test notification",
+    detail: "Notifications work. You'll get one when a run finishes, fails or waits for you.",
+};
+// The body a Notification URL receives: plain text, which ntfy shows as the message. Nothing
+// but the project's title, what happened and the provider's own short reason goes in it.
+export function webhookBody(text) {
+    return `${text.headline}\n${text.detail}\n`;
+}
+export const notificationUrlMax = 2048;
+// Empty clears the setting. Otherwise one absolute http(s) URL with no user name or password:
+// fetch refuses those, and a password in a URL would sit in the database in plain sight.
+export function notificationUrlProblem(value) {
+    const trimmed = value.trim();
+    if (trimmed === "")
+        return undefined;
+    if (trimmed.length > notificationUrlMax)
+        return `Keep the Notification URL to ${String(notificationUrlMax)} characters or fewer.`;
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return "Enter a full address starting with https:// or http://, for example https://ntfy.sh/your-topic.";
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:")
+        return "The Notification URL must start with https:// or http://.";
+    if (parsed.username !== "" || parsed.password !== "")
+        return "Remove the user name and password from the Notification URL; Slopify can't send them.";
+    return undefined;
+}

package/dist/slices/notifications/send.js

@@ -0,0 +1,40 @@
+// One POST to the user's Notification URL. Short, single-shot and never retried: a
+// notification that did not arrive is logged, and a run never waits on one.
+export const notificationTimeoutMs = 5_000;
+export function createNotificationSender(fetchImpl, timeoutMs = notificationTimeoutMs) {
+    return async (url, body) => {
+        try {
+            const response = await fetchImpl(url, {
+                method: "POST",
+                headers: { "content-type": "text/plain; charset=utf-8" },
+                body,
+                redirect: "manual",
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+            // The answer's body is never read; cancelling it frees the socket.
+            await response.body?.cancel().catch(() => { });
+            return response.ok ? { ok: true } : { ok: false, reason: "refused", status: response.status };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                reason: error instanceof DOMException &&
+                    (error.name === "TimeoutError" || error.name === "AbortError")
+                    ? "timeout"
+                    : "unreachable",
+            };
+        }
+    };
+}
+// What went wrong, in words fit for both the log and the Settings screen. The URL itself is
+// never repeated: an ntfy topic in it is as good as a password.
+export function sendFailureText(result) {
+    switch (result.reason) {
+        case "timeout":
+            return `the Notification URL didn't answer within ${String(notificationTimeoutMs / 1000)} seconds`;
+        case "unreachable":
+            return "the Notification URL couldn't be reached (wrong address, no network, or the server is down)";
+        case "refused":
+            return `the Notification URL answered HTTP ${String(result.status)}`;
+    }
+}

package/dist/slices/notifications/settings.js

@@ -0,0 +1,34 @@
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { notificationUrlProblem } from "./rules.js";
+// Its own row in the key/value `settings` table. Backups leave it out
+// (`slices/storage/portable.ts`): an ntfy topic in the URL is as good as a password.
+export const notificationUrlKey = "notificationUrl";
+export function readNotificationUrl(db) {
+    const stored = readSetting(db, notificationUrlKey);
+    if (stored === undefined)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(stored);
+    }
+    catch {
+        return null;
+    }
+    // A hand-edited row that no longer passes the rules is treated as not set rather than
+    // POSTed to.
+    return typeof value === "string" && value !== "" && notificationUrlProblem(value) === undefined
+        ? value
+        : null;
+}
+export function saveNotificationUrl(db, raw) {
+    const problem = notificationUrlProblem(raw);
+    if (problem !== undefined)
+        return { ok: false, message: problem };
+    const url = raw.trim();
+    if (url === "") {
+        db.prepare("DELETE FROM settings WHERE key = ?").run(notificationUrlKey);
+        return { ok: true, url: null };
+    }
+    writeSetting(db, notificationUrlKey, JSON.stringify(url));
+    return { ok: true, url };
+}