@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/storage/portable.js

@@ -1,26 +1,35 @@
 import { createHash } from "node:crypto";
 import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join, relative, sep } from "node:path";
 import { crc32 } from "node:zlib";
 import { strFromU8, strToU8, Unzip, UnzipInflate, zipSync } from "fflate";
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
+import { liveProject } from "../admission/repo.js";
 import { silenceGapSecondsMax } from "../admission/rules.js";
 import { detectSlots } from "../admission/substitute.js";
 import { fontMaxBytes } from "../fonts/model.js";
 import { readFontMetadata } from "../fonts/sfnt.js";
 import { lintEntry, lintPrompt } from "../library/lint.js";
 import { entryCategories, entryModes, promptKinds } from "../library/model.js";
+import { photorealisticPromptsKey } from "../library/photorealistic.js";
 import { listEntries, listPrompts } from "../library/repo.js";
 import { notificationUrlKey } from "../notifications/settings.js";
+import { patchNotesSeenKey } from "../patch-notes/seen.js";
 import { projectTemplateSchema } from "../project-templates/schema.js";
 import { cliPathMaxLength } from "../settings/cli-paths.js";
+import { providerDefaultsKey, providerDefaultsSchema } from "../settings/first-run.js";
 import { appearances, providerById, providerIds } from "../settings/model.js";
 import { listVoices } from "../settings/repo.js";
-import { voiceIdMax, voiceNameMax } from "../settings/voices.js";
+import { realPersonVoicesKey, voiceIdMax, voiceNameMax } from "../settings/voices.js";
+import { whatsNewSeenKey } from "../settings/whats-new.js";
+import { studioPlaylistMax } from "../studio/model.js";
+import { studioChannelPlaylistPrefix, studioFillQueuePrefix, studioPairingKey, studioPlaylistKey, studioRealFootageKey, } from "../studio/settings.js";
+import { channelLinksKey } from "../youtube/edits-repo.js";
 import { defaultBackupsDir, projectDir, stagingPath } from "./layout.js";
 import { stageKinds } from "./model.js";
 import { insertStagedFile, stagedFiles } from "./repo.js";
+import { projectStorage } from "./trim.js";
 const record = z.record(z.string(), z.string());
 export const portableMaxArchiveBytes = 100 * 1024 * 1024;
 export const portableMaxExpandedBytes = 128 * 1024 * 1024;
@@ -49,7 +58,18 @@ const libraryRow = z
 })
     .strict();
 const voiceRow = z
-    .object({ id: z.string(), provider: z.enum(providerIds), name: z.string(), voice_id: z.string() })
+    .object({
+    id: z.string(),
+    provider: z.enum(providerIds),
+    name: z.string(),
+    voice_id: z.string(),
+    // Absent from backups made before voice languages, and on a voice whose languages are
+    // unknown.
+    languages: z
+        .array(z.string().regex(/^[a-z]{2,3}$/))
+        .max(60)
+        .optional(),
+})
     .strict();
 const stagedMeta = z
     .object({
@@ -86,6 +106,11 @@ const manifestSchema = z
     staged: z.array(stagedMeta).max(portableMaxStagedFiles),
 })
     .strict();
+// The settings-only .zip. Nothing in the app writes it any more: Export everything (the tar in
+// `backup-export.ts`) replaced it in 2.5.0, and this stays so tests can make the .zip files
+// older versions wrote. Channels and their cast are deliberately not in it: they arrived after
+// the last version that could write a .zip, so no such file can hold one, and the full backup
+// already carries them (with cast pictures) through `backup-format.ts`.
 export function exportPortable(deps) {
     const entries = {};
     const stagedPlan = planStagedExport(deps);
@@ -127,9 +152,10 @@ export function exportPortable(deps) {
         provider: voice.provider,
         name: voice.name,
         voice_id: voice.voiceId,
+        ...(voice.languages === undefined ? {} : { languages: voice.languages }),
     }));
     const templates = deps.db
-        .prepare("SELECT t.id,r.version,r.name,t.created_at AS createdAt,r.created_at AS updatedAt,r.document_json AS document FROM project_templates t JOIN project_template_revisions r ON r.template_id=t.id AND r.version=t.head_version ORDER BY t.id")
+        .prepare("SELECT t.id,r.version,r.name,t.created_at AS createdAt,r.created_at AS updatedAt,r.document_json AS document FROM project_templates t JOIN project_template_revisions r ON r.template_id=t.id AND r.version=t.head_version WHERE t.deleted_at IS NULL ORDER BY t.id")
         .all()
         .map((row) => projectTemplateSchema.parse({ ...row, document: JSON.parse(String(row.document)) }));
     const fonts = exportUploadedFonts(deps.paths, entries);
@@ -209,8 +235,8 @@ export function importPortable(deps, bytes) {
             let voices = 0;
             for (const row of manifest.voices) {
                 deps.db
-                    .prepare("INSERT INTO voices(id,provider,name,voice_id) VALUES(?,?,?,?) ON CONFLICT(id) DO UPDATE SET provider=excluded.provider,name=excluded.name,voice_id=excluded.voice_id")
-                    .run(row.id, row.provider, row.name, row.voice_id);
+                    .prepare("INSERT INTO voices(id,provider,name,voice_id,languages_json) VALUES(?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET provider=excluded.provider,name=excluded.name,voice_id=excluded.voice_id,languages_json=excluded.languages_json")
+                    .run(row.id, row.provider, row.name, row.voice_id, row.languages === undefined ? null : JSON.stringify(row.languages));
                 voices += 1;
             }
             let templateCount = 0;
@@ -324,17 +350,56 @@ const slotsColumn = z.array(z.string());
 const storedCliPath = z.string().max(cliPathMaxLength).nullable();
 const storedSilenceGap = z.number().int().min(0).max(silenceGapSecondsMax);
 const storedAppearance = z.enum(appearances);
+// Settings → General's Level the volume for new runs.
+const storedLoudness = z
+    .object({ enabled: z.boolean(), videoLufs: z.number(), audioFilesLufs: z.number() })
+    .strict();
+const storedPlaylist = z.string().max(studioPlaylistMax);
+// Settings → Channel links, and the providers a fresh Play form starts with.
+// The AI use marks: ticked voices, Image prompts and projects, by id.
+const storedIds = z.array(z.string().max(200)).max(100_000);
+// The channel page's "Keep only titles containing…" text, one per channel.
+const importFilterPrefix = "channels.importFilter.";
+const storedImportFilter = z.string().max(200);
+const storedChannelLinks = z
+    .array(z.object({ name: z.string().max(200), url: z.string().max(2000) }).strict())
+    .max(200);
 function portableSettings(settings) {
     const portable = {};
     for (const [key, value] of Object.entries(settings)) {
         // The Notification URL stays on this machine: an ntfy topic in it is as good as a password.
-        if (key === "tutorial.session" || key === notificationUrlKey)
+        // So does the Studio extension's pairing: its token reads every project's upload pack.
+        // Which "What's new" tour and which patch notes this install has closed are about this
+        // install, not the data.
+        if (key === "tutorial.session" ||
+            // Whether this install showed its first-run welcome belongs to this install.
+            key === "first-run.done" ||
+            key === notificationUrlKey ||
+            key === studioPairingKey ||
+            // What waits to be filled in Studio belongs to this install's pairing.
+            key.startsWith(studioFillQueuePrefix) ||
+            key === whatsNewSeenKey ||
+            key === patchNotesSeenKey)
             continue;
         const parsed = storedJson(value);
         if (key === "silenceGapSeconds")
             storedSilenceGap.parse(parsed);
         else if (key === "appearance")
             storedAppearance.parse(parsed);
+        else if (key === "loudness")
+            storedLoudness.parse(parsed);
+        else if (key === studioPlaylistKey || key.startsWith(studioChannelPlaylistPrefix))
+            storedPlaylist.parse(parsed);
+        else if (key === channelLinksKey)
+            storedChannelLinks.parse(parsed);
+        else if (key === realPersonVoicesKey ||
+            key === photorealisticPromptsKey ||
+            key === studioRealFootageKey)
+            storedIds.parse(parsed);
+        else if (key.startsWith(importFilterPrefix))
+            storedImportFilter.parse(parsed);
+        else if (key === providerDefaultsKey)
+            providerDefaultsSchema.parse(parsed);
         else if (key.startsWith("cli.path.")) {
             const provider = providerById(z.enum(providerIds).parse(key.slice("cli.path.".length)));
             if (provider.auth !== "cli")
@@ -863,16 +928,24 @@ function planStagedImport(deps, archive, files) {
         };
     });
 }
+function inside(root, path) {
+    const r = relative(root, path);
+    return r === "" || (r !== ".." && !r.startsWith(`..${sep}`) && !isAbsolute(r));
+}
 export function storageBytes(paths) {
-    // Scheduled backups default to a folder inside the projects root; they are not project files.
-    const projects = directoryBytes(paths.projects) - directoryBytes(defaultBackupsDir(paths));
+    // Scheduled backups default to a folder inside the projects root on installs from before
+    // 3.0; they are not project files. Newer installs keep projects outside the data dir.
+    const backups = defaultBackupsDir(paths);
+    const projects = directoryBytes(paths.projects) -
+        (inside(paths.projects, backups) ? directoryBytes(backups) : 0);
     const staging = directoryBytes(paths.staging);
-    return { data: directoryBytes(paths.dataDir), projects, staging };
+    const data = directoryBytes(paths.dataDir) + (inside(paths.dataDir, paths.projects) ? 0 : projects);
+    return { data, projects, staging };
 }
 export function storageUsage(deps) {
     const totals = storageBytes(deps.paths);
     const byProject = deps.db
-        .prepare("SELECT id,title FROM projects ORDER BY created_at DESC, id DESC")
+        .prepare(`SELECT id,title FROM projects WHERE ${liveProject()} ORDER BY created_at DESC, id DESC`)
         .all()
         .flatMap((row) => {
         if (typeof row.id !== "string" || typeof row.title !== "string")
@@ -882,10 +955,19 @@ export function storageUsage(deps) {
                 id: row.id,
                 title: row.title,
                 bytes: directoryBytes(projectDir(deps.paths, row.id)),
+                ...projectStorage(deps, row.id),
             },
         ];
     });
-    return { ...totals, byProject };
+    const trashed = deps.db
+        .prepare("SELECT project_id FROM project_trash ORDER BY project_id")
+        .all()
+        .flatMap((row) => (typeof row.project_id === "string" ? [row.project_id] : []));
+    const trash = {
+        projects: trashed.length,
+        bytes: trashed.reduce((sum, id) => sum + directoryBytes(projectDir(deps.paths, id)), 0),
+    };
+    return { ...totals, trash, byProject };
 }
 function directoryBytes(root) {
     if (!existsSync(root))

package/dist/slices/storage/reconcile.js

@@ -1,5 +1,5 @@
 import { readdirSync, rmSync, statSync, unlinkSync } from "node:fs";
-import { join, relative, sep } from "node:path";
+import { isAbsolute, join, relative, sep } from "node:path";
 import { backupsFolderName, outputPath, stagingPath } from "./layout.js";
 import { stagedFiles as stagedRows } from "./repo.js";
 import { stagedFileReferenced } from "./staging-refs.js";
@@ -31,12 +31,20 @@ export function reconcileStorage(db, paths) {
         }
     }
     let orphanFiles = 0;
+    // A Projects folder outside the data dir (in Documents, from 3.0) is one the user browses,
+    // and the system drops its own files there (.DS_Store, desktop.ini). Only folders are
+    // Slopify's in it, so a loose file stays; hidden entries stay everywhere.
+    const userVisible = !within(paths.dataDir, paths.projects);
     for (const entry of readdirSync(paths.projects, { withFileTypes: true })) {
         const path = join(paths.projects, entry.name);
         // The scheduled backups' default folder: its archives belong to slices/backups, which
         // prunes them by its own rules.
         if (entry.name === backupsFolderName && entry.isDirectory())
             continue;
+        if (entry.name.startsWith(".") || osFiles.has(entry.name.toLowerCase()))
+            continue;
+        if (!entry.isDirectory() && userVisible)
+            continue;
         if (!entry.isDirectory()) {
             unlinkSync(path);
             orphanFiles += 1;
@@ -119,6 +127,11 @@ function filesUnder(root) {
     }
     return files;
 }
+const osFiles = new Set(["desktop.ini", "thumbs.db"]);
+function within(root, path) {
+    const inside = relative(root, path);
+    return (inside === "" || (inside !== ".." && !inside.startsWith(`..${sep}`) && !isAbsolute(inside)));
+}
 // outputs.path is stored with forward slashes; the filesystem may hand back backslashes.
 function slashed(path) {
     return path.split(sep).join("/");

package/dist/slices/storage/repo.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { liveProject } from "../admission/repo.js";
 import { outputRoles, stagedFileStates, stageKinds } from "./model.js";
 import { metaSchema } from "./schema.js";
 const outputRow = z.object({
@@ -58,7 +59,9 @@ export function deleteStagedFile(db, id) {
     db.prepare("DELETE FROM staged_files WHERE id = ? AND NOT EXISTS (SELECT 1 FROM play_draft_attachments WHERE staged_file_id = ?)").run(id, id);
 }
 export function projectTitle(db, projectId) {
-    const row = db.prepare("SELECT title FROM projects WHERE id = ?").get(projectId);
+    const row = db
+        .prepare(`SELECT title FROM projects WHERE id = ? AND ${liveProject()}`)
+        .get(projectId);
     if (row === undefined) {
         return undefined;
     }

package/dist/slices/storage/schema.js

@@ -10,11 +10,22 @@ export const metaSchema = z.object({
     prompt: z.string().optional(),
     index: z.number().optional(),
     short: z.number().optional(),
+    format: z.enum(["16:9", "9:16"]).optional(),
     sentences: z.tuple([z.number(), z.number()]).optional(),
     warnings: z.array(z.string()).optional(),
     provider: z.string().optional(),
     model: z.string().optional(),
     voice: z.string().optional(),
+    loudness: z
+        .object({
+        pieces: z.number(),
+        skipped: z.number(),
+        spreadBefore: z.number(),
+        spreadAfter: z.number(),
+        target: z.number(),
+    })
+        .optional(),
+    master: z.object({ target: z.number(), integrated: z.number(), truePeak: z.number() }).optional(),
 });
 export const outputSchema = z.object({
     id: z.string(),

package/dist/slices/storage/trim.js

@@ -0,0 +1,146 @@
+import { existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { derive } from "../../kernel/runner/graph.js";
+import { projectExists, projectPaused, stagesOf } from "../admission/repo.js";
+import { backupsFolderName, projectDir } from "./layout.js";
+import { pieceFile } from "./reconcile.js";
+// Keep outputs only: a finished project drops the working files it was made from (images,
+// narration parts, subtitle timing, render settings) and keeps what gets published. Two
+// rules keep it safe. A file the user supplied is never removed, because nothing could make
+// it again. And only files a project record names are removed: anything else in the folder
+// is reconcile's business (`reconcile.ts`), which leaves the Backups folder alone.
+// What a finished project is for: the files that get uploaded or read, from every revision,
+// so an older video in History stays too.
+export const outputRoles = [
+    "video",
+    "short_video",
+    "shorts",
+    "thumbnail",
+    "article_md",
+    "article_txt",
+    "sources",
+    "youtube_description",
+    "youtube_tags",
+    "document_pdf",
+    "audio_export",
+    "subtitles_srt",
+    "subtitles_vtt",
+];
+export function projectStorage(deps, projectId) {
+    const files = filesOf(deps.paths, projectId);
+    const kept = keptPaths(deps.db, projectId);
+    const outputs = outputPaths(deps.db, projectId);
+    const removable = removablePaths(deps.db, projectId, kept);
+    let outputsBytes = 0;
+    let workingBytes = 0;
+    let removableFiles = 0;
+    let removableBytes = 0;
+    for (const [path, bytes] of files) {
+        if (outputs.has(path))
+            outputsBytes += bytes;
+        else
+            workingBytes += bytes;
+        if (removable.has(path)) {
+            removableFiles += 1;
+            removableBytes += bytes;
+        }
+    }
+    return {
+        outputsBytes,
+        workingBytes,
+        removableFiles,
+        removableBytes,
+        finished: finished(deps, projectId),
+    };
+}
+export function keepOutputsOnly(deps, projectId) {
+    if (!projectExists(deps.db, projectId))
+        return { ok: false, reason: "no-project" };
+    if (!finished(deps, projectId))
+        return { ok: false, reason: "not-finished" };
+    const files = filesOf(deps.paths, projectId);
+    const removable = removablePaths(deps.db, projectId, keptPaths(deps.db, projectId));
+    let count = 0;
+    let bytesFreed = 0;
+    for (const path of removable) {
+        const bytes = files.get(path);
+        if (bytes === undefined)
+            continue;
+        unlinkSync(join(projectDir(deps.paths, projectId), path));
+        count += 1;
+        bytesFreed += bytes;
+    }
+    return { ok: true, files: count, bytesFreed };
+}
+function finished(deps, projectId) {
+    if (deps.hasInflight?.(projectId) === true)
+        return false;
+    const state = derive(stagesOf(deps.db, projectId), projectPaused(deps.db, projectId));
+    if (state !== "done" && state !== "partial")
+        return false;
+    // Nothing admitted that could still start: a rebuild waiting to be picked up needs its inputs.
+    return (deps.db
+        .prepare("SELECT 1 FROM revision_work WHERE project_id=? AND (state='running' OR (state='pending' AND dispatch_state='allowed')) LIMIT 1")
+        .get(projectId) === undefined);
+}
+// Every file under the project folder, by project-relative path with forward slashes.
+function filesOf(paths, projectId) {
+    const files = new Map();
+    if (projectId === backupsFolderName)
+        return files;
+    const root = projectDir(paths, projectId);
+    if (!existsSync(root))
+        return files;
+    for (const entry of readdirSync(root, { withFileTypes: true, recursive: true })) {
+        if (!entry.isFile())
+            continue;
+        const full = join(entry.parentPath, entry.name);
+        files.set(relative(root, full).split(sep).join("/"), statSync(full).size);
+    }
+    return files;
+}
+function outputPaths(db, projectId) {
+    const roles = outputRoles.map(() => "?").join(",");
+    return pathsOf(db
+        .prepare(`SELECT a.path FROM revision_outputs o JOIN project_assets a ON a.id=o.asset_id AND a.project_id=o.project_id
+         WHERE o.project_id=? AND json_extract(o.descriptor,'$.role') IN (${roles})
+         UNION SELECT path FROM outputs WHERE project_id=? AND role IN (${roles})`)
+        .all(projectId, ...outputRoles, projectId, ...outputRoles));
+}
+// The outputs, and every file the user supplied: an asset any saved revision or the project's
+// settings name, or a legacy output row that came from an upload.
+function keptPaths(db, projectId) {
+    const kept = new Set(outputPaths(db, projectId));
+    for (const path of pathsOf(db
+        .prepare(`SELECT a.path FROM project_assets a WHERE a.project_id=? AND (
+           EXISTS(SELECT 1 FROM project_revisions r WHERE r.project_id=a.project_id
+             AND (instr(r.content,a.id)>0 OR instr(r.config,a.id)>0))
+           OR EXISTS(SELECT 1 FROM projects p WHERE p.id=a.project_id AND instr(p.config,a.id)>0))
+         UNION SELECT path FROM outputs WHERE project_id=? AND original_filename IS NOT NULL`)
+        .all(projectId, projectId)))
+        kept.add(path);
+    return kept;
+}
+// The files a record names that are not kept: made by a step, so a step can make them again.
+function removablePaths(db, projectId, kept) {
+    const named = new Set([
+        ...pathsOf(db
+            .prepare("SELECT path FROM project_assets WHERE project_id=? UNION SELECT path FROM outputs WHERE project_id=?")
+            .all(projectId, projectId)),
+    ]);
+    for (const row of db
+        .prepare("SELECT p.payload FROM stage_pieces p JOIN stages s ON s.id=p.stage_id WHERE s.project_id=? AND p.payload IS NOT NULL")
+        .all(projectId)) {
+        const file = pieceFile(row.payload);
+        if (file !== undefined)
+            named.add(file.split(sep).join("/"));
+    }
+    return new Set([...named].filter((path) => !kept.has(path)));
+}
+function pathsOf(rows) {
+    const paths = new Set();
+    for (const row of rows)
+        if (typeof row.path === "string")
+            paths.add(row.path.split("\\").join("/"));
+    return paths;
+}

package/dist/slices/studio/disclosure.js

@@ -0,0 +1,74 @@
+// YouTube's "AI use" question (it was "Altered or synthetic content"), answered for every
+// video and short of a project. Browser-safe: the upload pack carries the answer, the channel
+// page names the setting.
+//
+// The question as Studio asks it (read on the live Details page, 2026-09-27), behind Show more:
+//   AI use — "Was AI used to generate or edit your content in any of the following ways?"
+//   1. "Makes a real person appear to say or do something they didn't say or do"
+//   2. "Alters footage of a real event or place"
+//   3. "Generates a realistic-looking scene that didn't actually occur"
+//   Radios "Yes, AI was used" / "No, AI wasn't used"; "Selecting 'yes' adds a label to your
+//   content."
+// YouTube's help page (https://support.google.com/youtube/answer/14328491) says the same:
+// clearly unrealistic content (fantasy, animation), minor edits (colour, filters) and
+// production help (AI for the script, thumbnail, title or captions) need no label.
+//
+// So the automatic answer is Yes only when one of the three cases applies, and No otherwise:
+// 1. a saved voice marked "Imitates a real person" (Settings → Voices) narrates it: an AI
+//    voice cloned from, or made to sound like, a real person, so that person seems to say it;
+// 2. uploaded clips the person marked as real footage (the project's Prepare upload) get the
+//    Look's atmosphere overlay (embers, dust or fog), which adds to a real scene what wasn't
+//    there. A colour grade, vignette or grain alone is one of YouTube's minor edits;
+// 3. an AI image model draws its pictures from an Image prompt marked "Draws photorealistic
+//    pictures" (Library → Prompts). Stylised, painterly or illustrated images are not
+//    realistic-looking, and animating them doesn't make them so.
+// An AI narrator that doesn't pose as a real person, AI-written text and an AI thumbnail are
+// none of the three. Every mark is off until the person sets it. A channel can still set
+// Always Yes or Always No (Channels → the channel → Brand → YouTube AI disclosure).
+export const aiDisclosureSettings = ["auto", "yes", "no"];
+export const aiDisclosureLabels = {
+    auto: "Automatic",
+    yes: "Always Yes",
+    no: "Always No",
+};
+// Studio's three cases, as it words them.
+export const aiUseCases = [
+    "Makes a real person appear to say or do something they didn't say or do",
+    "Alters footage of a real event or place",
+    "Generates a realistic-looking scene that didn't actually occur",
+];
+const where = "Channels → the channel → Brand → YouTube AI disclosure";
+export function aiDisclosureOf(input) {
+    if (input.setting === "yes")
+        return { altered: true, why: `This channel is set to Always Yes (${where}).` };
+    if (input.setting === "no")
+        return { altered: false, why: `This channel is set to Always No (${where}).` };
+    const reasons = [];
+    if (input.realPersonVoices.length > 0)
+        reasons.push(`the narration uses ${quotedList(input.realPersonVoices)}, marked in Settings → Voices as imitating a real person (YouTube's case 1: "${aiUseCases[0]}")`);
+    if (input.realFootage && input.footageOverlay !== undefined)
+        reasons.push(`the Look's ${input.footageOverlay} overlay is laid over uploaded clips marked as real footage (YouTube's case 2: "${aiUseCases[1]}")`);
+    if (input.photorealistic)
+        reasons.push(`an AI image model draws its pictures from an Image prompt marked photorealistic in Library → Prompts (YouTube's case 3: "${aiUseCases[2]}")`);
+    if (reasons.length > 0)
+        return {
+            altered: true,
+            why: `Yes because ${list(reasons)}. Selecting Yes adds YouTube's AI label.`,
+        };
+    const footage = input.realFootage && input.kind === "video"
+        ? " The uploaded real footage only gets colour, vignette or grain, which YouTube counts as minor edits."
+        : "";
+    return {
+        altered: false,
+        why: `No because none of YouTube's three AI use cases applies: no narrating voice is marked as imitating a real person (Settings → Voices), no real footage is altered, and no AI pictures come from an Image prompt marked photorealistic (Library → Prompts). Stylised AI pictures and an AI narrator that doesn't pose as a real person don't need the label.${footage}`,
+    };
+}
+function quotedList(names) {
+    const quoted = names.map((name) => `"${name}"`);
+    return `the voice${names.length === 1 ? "" : "s"} ${list(quoted)}`;
+}
+function list(parts) {
+    if (parts.length <= 1)
+        return parts.join("");
+    return `${parts.slice(0, -1).join(", ")} and ${parts.at(-1) ?? ""}`;
+}

package/dist/slices/studio/model.js

@@ -0,0 +1,30 @@
+// The upload pack: everything YouTube Studio asks for when a finished video (or one of its
+// shorts) is uploaded by hand, in the order Studio asks for it. Slopify never uploads or
+// publishes; the pack is copied into Studio by the person, or filled in by the Slopify Studio
+// extension (`packages/extension`), and the person presses Publish.
+// Browser-safe: the project page and the extension read these names too.
+// YouTube's own limits on the upload dialog's fields.
+export const studioTitleMax = 100;
+export const studioPlaylistMax = 150;
+// The one audience a Slopify video is uploaded with. Slopify's narrated videos are not made
+// for children, and Studio refuses to continue until the question is answered.
+export const studioAudience = "not_made_for_kids";
+// Studio's upload page. It opens the upload dialog on the signed-in channel.
+export const studioUploadUrl = "https://www.youtube.com/upload";
+// The steps in Studio's order, as the Prepare upload view lists them.
+export const studioSteps = [
+    "video",
+    "title",
+    "description",
+    "thumbnails",
+    "playlist",
+    "audience",
+    "altered",
+    "tags",
+];
+// Tags as Studio's field takes them: comma-separated.
+export function tagsLine(tags) {
+    return tags.join(", ");
+}
+// The browsers the extension is built for, as its download names them.
+export const studioExtensionBrowsers = ["chrome", "firefox"];