@gentbajko/slopify 3.8.7 → 3.9.0

package/dist/edge/http/studio.js

@@ -23,7 +23,8 @@ import { leadHoursMax, seriesOf } from "../../slices/studio/plan-model.js";
 import { enqueueFill, fillOnly, readFillQueue, removeFill, } from "../../slices/studio/queue.js";
 import { allReleases, freeSlots, planReleases, readLeadHours, releasesOf, setRelease, swapReleases, writeLeadHours, } from "../../slices/studio/releases.js";
 import { parseStudioExport, readReport, saveReport } from "../../slices/studio/report.js";
-import { autoCommentKey, bearerToken, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, readStudioPlaylists, resetStudioPairing, saveProjectPlaylists, saveRealFootage, saveStudioPlaylists, studioPairing, studioPlaylistsMax, studioPlaylistsProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
+import { statsFromReport } from "../../slices/studio/report-stats.js";
+import { autoCommentKey, bearerToken, exportViewProblem, exportViews, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, readExportView, readStudioPlaylists, resetStudioPairing, saveExportView, saveProjectPlaylists, saveRealFootage, saveStudioPlaylists, studioPairing, studioPlaylistsMax, studioPlaylistsProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
 import { abResults, abVariantSchema, projectStats, saveAbResult, saveStats, } from "../../slices/studio/stats.js";
 import { confirmUpload, doneVideos, forgetVideo, projectVideos, recordVideo, setChecks, setTaskState, videoIdOf, videoIdPattern, videoOf, waitingTasks, } from "../../slices/studio/videos.js";
 import { setAsideProjects, uploadedProjects } from "../../slices/uploads/repo.js";
@@ -195,6 +196,7 @@ export function studioRoutes(deps) {
             { projectId: project.id, short: video.short, projectTitle: project.title },
         ])));
         return {
+            exportView: readExportView(deps.db, channelId),
             report,
             projects: report === null
                 ? {}
@@ -484,7 +486,61 @@ export function studioRoutes(deps) {
         if (!parsed.ok)
             return problem(c, { status: 400, title: titleOf(400), detail: parsed.message });
         saveReport(deps.db, channelId, parsed.report);
+        statsFromReport(deps.db, parsed.report, parsed.report.importedAt);
         return c.json(reportBody(channelId));
+    })
+        // The Analytics view the extension exports every day for this channel; null forgets it.
+        .put("/channels/:channelId/export-view", zValidator("param", z.object({ channelId: id }), onInvalid), zValidator("json", z.object({ url: z.string().max(4000).nullable() }), onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { channelId } = c.req.valid("param");
+        const { url } = c.req.valid("json");
+        const wrong = url === null || url.trim() === "" ? undefined : exportViewProblem(url);
+        if (wrong !== undefined)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: wrong,
+                extensions: { fields: [{ field: "url", message: wrong }] },
+            });
+        saveExportView(deps.db, channelId, url);
+        return c.json(reportBody(channelId));
+    })
+        // The extension: each channel's Analytics view to export.
+        .get("/ext/export-views", (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        return c.json({ views: exportViews(deps.db) });
+    })
+        // The extension exported a channel's view: the zip Studio's Export makes, as Studio sends
+        // it (base64). Saved as an import would be, and each known video's numbers with it.
+        .post("/ext/report", bodyLimit({
+        maxSize: 40 * 1024 * 1024,
+        onError: (c) => problem(c, {
+            status: 413,
+            title: titleOf(413),
+            detail: "Studio's export was larger than Slopify takes (40 MB).",
+        }),
+    }), zValidator("json", z.object({
+        channelId: id,
+        zippedData: z
+            .string()
+            .min(1)
+            .max(40 * 1024 * 1024),
+    }), onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const { channelId, zippedData } = c.req.valid("json");
+        const now = deps.clock.now().toISOString();
+        const parsed = parseStudioExport(new Uint8Array(Buffer.from(zippedData, "base64url")), now);
+        if (!parsed.ok)
+            return problem(c, { status: 400, title: titleOf(400), detail: parsed.message });
+        saveReport(deps.db, channelId, parsed.report);
+        const videos = statsFromReport(deps.db, parsed.report, now);
+        return c.json({ rows: parsed.report.rows.length, videos });
     })
         // Channels → YouTube: the channel's videos on YouTube with Studio's numbers and totals.
         .get("/channels/:channelId/performance", zValidator("param", z.object({ channelId: id }), onInvalid), (c) => c.json(channelPerformance(deps, c.req.valid("param").channelId)))
@@ -742,7 +798,10 @@ export function studioRoutes(deps) {
         if (!extAllowed(c))
             return refused(c);
         return c.json({
-            videos: doneVideos(deps.db).map((video) => ({
+            // The export brings every video's numbers; only an A/B test's result needs a visit.
+            videos: doneVideos(deps.db)
+                .filter((video) => video.short === null && video.abState === "started")
+                .map((video) => ({
                 projectId: video.projectId,
                 short: video.short,
                 videoId: video.videoId,
@@ -755,17 +814,26 @@ export function studioRoutes(deps) {
             return refused(c);
         const body = c.req.valid("json");
         const readAt = deps.clock.now().toISOString();
-        saveStats(deps.db, {
-            projectId: body.projectId,
-            short: body.short ?? null,
-            videoId: body.videoId,
-            readAt,
-            impressions: body.impressions ?? null,
-            ctr: body.ctr ?? null,
-            views: body.views ?? null,
-            averageViewSeconds: body.averageViewSeconds ?? null,
-            watchHours: body.watchHours ?? null,
-        });
+        // A visit for the A/B result alone brings no numbers: the export's are kept.
+        const numbers = [
+            body.impressions,
+            body.ctr,
+            body.views,
+            body.averageViewSeconds,
+            body.watchHours,
+        ].some((one) => one !== undefined);
+        if (numbers)
+            saveStats(deps.db, {
+                projectId: body.projectId,
+                short: body.short ?? null,
+                videoId: body.videoId,
+                readAt,
+                impressions: body.impressions ?? null,
+                ctr: body.ctr ?? null,
+                views: body.views ?? null,
+                averageViewSeconds: body.averageViewSeconds ?? null,
+                watchHours: body.watchHours ?? null,
+            });
         if (body.abVariants !== undefined && body.abVariants.length > 1)
             saveAbResult(deps.db, {
                 projectId: body.projectId,

package/dist/patch-notes/3.9.0.md

@@ -0,0 +1,17 @@
+# Slopify 3.9.0
+
+Released 4 October 2026.
+
+## Studio's numbers, every day, by themselves
+
+- **The extension exports your Analytics view daily.** Paste the address of your YouTube Studio Analytics → Advanced mode view (with the columns you chose) into Channels → YouTube → From Studio's export, and press Save view. Once a day the extension opens it in the background with the end date moved to today (the start stays as you set it), presses Export → Comma-separated values, and brings Studio's zip straight into Slopify: no file lands in your Downloads, and no import by hand.
+- **Every video's numbers come from that one export.** Each video you uploaded with Slopify gets its views, impressions, click-through rate, average view and watch hours from it, on its project page and in Channels → YouTube. The extension no longer opens each video's Analytics; it only opens a long video whose A/B test is running, to read its result.
+- **The channel's total.** The export's third file (Totals.csv) is read too: tick Channel total above the chart to draw the whole view's daily figure.
+
+## Channels → YouTube
+
+- **One video's chart opens under its row.** Press the arrow beside a video in the From Studio's export table to see its own chart; the grid of every video's chart is gone.
+
+## YouTube Studio extension (1.2.0)
+
+Download the extension again from Settings → YouTube Studio and reload it.

package/dist/patch-notes/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "id": "3.9.0",
+    "title": "Slopify 3.9.0",
+    "version": "3.9.0",
+    "date": "2026-10-04"
+  },
   {
     "id": "3.8.7",
     "title": "Slopify 3.8.7",

package/dist/slices/studio/report-stats.js

@@ -0,0 +1,39 @@
+import { saveStats } from "./stats.js";
+import { doneVideos } from "./videos.js";
+// Studio's export holds every video's numbers: each one Slopify uploaded gets them as its
+// project's numbers (the project page and Channels → YouTube), so the extension needn't open
+// each video's Analytics. A column the export doesn't have is left empty.
+const find = (report, test, not) => report.columns.findIndex((column) => test.test(column.label) && !not?.test(column.label));
+export function statsFromReport(db, report, readAt) {
+    const at = {
+        impressions: find(report, /impressions/i, /rate|ctr/i),
+        ctr: find(report, /click-through rate|ctr/i),
+        views: find(report, /^views$/i),
+        averageViewSeconds: find(report, /^average view duration$/i),
+        watchHours: find(report, /^watch time \(hours\)$/i),
+    };
+    const value = (row, index) => {
+        const one = index < 0 ? null : row.values[index];
+        return typeof one === "number" ? one : null;
+    };
+    const rows = new Map(report.rows.map((row) => [row.videoId, row]));
+    let saved = 0;
+    for (const video of doneVideos(db)) {
+        const row = rows.get(video.videoId);
+        if (row === undefined)
+            continue;
+        saveStats(db, {
+            projectId: video.projectId,
+            short: video.short,
+            videoId: video.videoId,
+            readAt,
+            impressions: value(row, at.impressions),
+            ctr: value(row, at.ctr),
+            views: value(row, at.views),
+            averageViewSeconds: value(row, at.averageViewSeconds),
+            watchHours: value(row, at.watchHours),
+        });
+        saved += 1;
+    }
+    return saved;
+}

package/dist/slices/studio/report.js

@@ -119,10 +119,20 @@ export function parseStudioExport(bytes, importedAt) {
         series[at] = Number(row.at(-1)) || 0;
         daily.set(id, series);
     }
+    // Totals.csv: Date, then the metric; the whole view's figure per day.
+    const totalsBytes = named("totals");
+    const totals = totalsBytes === undefined ? [] : parseCsv(strFromU8(totalsBytes)).slice(1);
+    const dailyTotals = Array.from({ length: days.length }, () => 0);
+    for (const row of totals) {
+        const at = dayIndex.get(row[0] ?? "");
+        if (at !== undefined)
+            dailyTotals[at] = Number(row.at(-1)) || 0;
+    }
     return {
         ok: true,
         report: {
             importedAt,
+            ...(totals.length > 0 && days.length > 0 ? { dailyTotals } : {}),
             chartMetric: chart.length > 1 ? chartMetric : null,
             from: days[0] ?? null,
             to: days.at(-1) ?? null,

package/dist/slices/studio/settings.js

@@ -242,3 +242,38 @@ export function studioRequestAllowed(db, token, origin) {
         return true;
     return pairing.origin !== null && origin === pairing.origin;
 }
+// Each channel's Studio Analytics view (Advanced mode's Explore link with its chosen columns),
+// which the extension opens every day to export into Channels → YouTube. The start stays as
+// saved; the extension moves the end to today.
+export const studioExportViewPrefix = "studio.exportView.";
+export function exportViewProblem(url) {
+    let parsed;
+    try {
+        parsed = new URL(url.trim());
+    }
+    catch {
+        return "That isn't a link. In YouTube Studio, open Analytics → Advanced mode, set it up, and copy the address from the browser's address bar.";
+    }
+    if (parsed.origin !== "https://studio.youtube.com" ||
+        !/^\/channel\/UC[A-Za-z0-9_-]+\/analytics\/.+\/explore$/.test(parsed.pathname))
+        return "That isn't a Studio Analytics Advanced mode link. In YouTube Studio, open Analytics → Advanced mode, set it up, and copy the address from the browser's address bar.";
+    if (!parsed.searchParams.has("time_period"))
+        return "That link has no date range. In Advanced mode, pick the dates (the start stays as you set it; the end follows today), then copy the address again.";
+    return undefined;
+}
+export function readExportView(db, channelId) {
+    return readSetting(db, `${studioExportViewPrefix}${channelId}`) ?? null;
+}
+export function saveExportView(db, channelId, url) {
+    const key = `${studioExportViewPrefix}${channelId}`;
+    if (url === null || url.trim() === "")
+        db.prepare("DELETE FROM settings WHERE key = ?").run(key);
+    else
+        writeSetting(db, key, url.trim());
+}
+export function exportViews(db) {
+    const prefix = studioExportViewPrefix;
+    return db
+        .prepare("SELECT key, value FROM settings WHERE substr(key, 1, ?) = ? ORDER BY key")
+        .all(prefix.length, prefix).map((row) => ({ channelId: row.key.slice(prefix.length), url: row.value }));
+}