@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/slices/revisions/restore.js

@@ -0,0 +1,60 @@
+import { transact } from "../../kernel/db/tx.js";
+import { carryCheckpointGates } from "../checkpoints/recovery.js";
+import { planRevision } from "../rebuild/recipe-save.js";
+import { transitionRevisionWork } from "../rebuild/repo.js";
+import { projectStandings } from "../rebuild/runtime-store.js";
+import { checkMutation, insertReceipt, refusal, requestHash, requiredView, } from "./mutation-request.js";
+import { advanceHead, logicalKeys } from "./mutations.js";
+import { cloneManifest, ensureRevisionStages, projectSelected } from "./projection.js";
+import { insertRevision } from "./repo.js";
+import { getRevisionView } from "./view.js";
+export async function restoreRevision(deps, input) {
+    const identity = {
+        ...input,
+        operation: "restore",
+        hash: requestHash("restore", input.baseRevisionId, {
+            targetRevisionId: input.targetRevisionId,
+        }),
+    };
+    return transact(deps.db, () => {
+        const checked = checkMutation(deps, identity);
+        if (checked !== undefined)
+            return checked;
+        const target = getRevisionView(deps, input.projectId, input.targetRevisionId);
+        if (target === undefined)
+            return refusal(deps, input.projectId, "no-revision");
+        const base = requiredView(deps, input.projectId, input.baseRevisionId);
+        const comparison = planRevision(base, {
+            config: target.revision.config,
+            content: target.revision.content,
+        });
+        const revision = {
+            ...target.revision,
+            id: deps.ids.next(),
+            parentId: base.revision.id,
+            restoredFromId: target.revision.id,
+            createdAt: deps.clock.now().toISOString(),
+        };
+        insertRevision(deps.db, revision);
+        ensureRevisionStages(deps, revision);
+        cloneManifest(deps, revision, {
+            outputs: target.outputs.filter((row) => row.selected),
+            pieces: target.pieces.filter((row) => row.selected),
+        });
+        if (!advanceHead(deps.db, input.projectId, input.baseRevisionId, revision))
+            throw new Error("Project head changed during the restore transaction.");
+        transitionRevisionWork(deps, {
+            projectId: input.projectId,
+            baseRevisionId: input.baseRevisionId,
+            revisionId: revision.id,
+            fingerprints: revision.fingerprints,
+            ...(comparison.ok ? { baseFingerprints: comparison.baseFingerprints } : {}),
+            logicalKeys: logicalKeys(deps, input.projectId, input.baseRevisionId, revision.fingerprints),
+        });
+        carryCheckpointGates(deps, input.baseRevisionId, revision);
+        projectSelected(deps.db, revision);
+        projectStandings(deps, revision.projectId);
+        insertReceipt(deps, identity, revision.id);
+        return { ok: true, view: requiredView(deps, input.projectId, revision.id), duplicate: false };
+    });
+}

package/dist/slices/revisions/rules.js

@@ -0,0 +1,99 @@
+import { isDeepStrictEqual } from "node:util";
+import { buildRecipes } from "../rebuild/recipe-build.js";
+import { normalizeArticleIntent, validateRevisionEdit } from "../rebuild/recipe-save.js";
+export function validateCues(cues, duration) {
+    const fields = [];
+    const seen = new Set();
+    let end = 0;
+    for (const [index, cue] of cues.entries()) {
+        const field = `content.subtitleCues.cues.${index}`;
+        if (seen.has(cue.id))
+            fields.push({ field: `${field}.id`, message: "Caption IDs must be unique." });
+        seen.add(cue.id);
+        if (cue.text.trim() === "")
+            fields.push({ field: `${field}.text`, message: "Caption text is required." });
+        if (!Number.isFinite(cue.start) || cue.start < end)
+            fields.push({ field: `${field}.start`, message: "Start must follow the previous caption." });
+        if (!Number.isFinite(cue.end) || cue.end <= cue.start || cue.end > duration)
+            fields.push({
+                field: `${field}.end`,
+                message: "End must follow start and fit the narration.",
+            });
+        end = cue.end;
+    }
+    return fields;
+}
+export function validateTemplateIntent(base, edit) {
+    const fields = [];
+    if (!isDeepStrictEqual(base.revision.config.values, edit.config.values)) {
+        for (const [key, raw] of Object.entries(base.revision.content.promptTemplates)) {
+            if (raw === null &&
+                edit.content.promptTemplates[key] == null &&
+                base.revision.config.rendered[key] === edit.config.rendered[key])
+                fields.push({
+                    field: `content.promptTemplates.${key}`,
+                    message: "Choose the raw template or explicitly keep the current prompt before changing keywords.",
+                });
+        }
+        for (const [key, image] of Object.entries(base.revision.content.imageDefinitions)) {
+            const next = edit.content.imageDefinitions[key];
+            if (image.source === "generate" &&
+                image.templateKey == null &&
+                next?.source === "generate" &&
+                next.templateKey == null &&
+                next.prompt === image.prompt)
+                fields.push({
+                    field: `content.imageDefinitions.${key}.templateKey`,
+                    message: "Choose the raw template or explicitly keep the current image prompt before changing keywords.",
+                });
+        }
+    }
+    for (const [key, image] of Object.entries(edit.content.imageDefinitions))
+        if (image.source === "generate" &&
+            image.templateKey != null &&
+            edit.content.promptTemplates[image.templateKey] == null &&
+            !(base.revision.content.promptTemplates[image.templateKey] == null &&
+                isDeepStrictEqual(base.revision.content.imageDefinitions[key], image)))
+            fields.push({
+                field: `content.imageDefinitions.${key}.templateKey`,
+                message: "The linked raw image template is missing.",
+            });
+    return fields;
+}
+export function validateNarrationIntent(base, edit) {
+    const content = normalizeArticleIntent(base, edit);
+    const invalid = validateRevisionEdit(edit.config, content);
+    if (invalid.length > 0)
+        return invalid;
+    const recipes = buildRecipes({
+        config: edit.config,
+        content,
+        manifest: {
+            outputs: base.outputs.filter((row) => row.selected),
+            pieces: base.pieces.filter((row) => row.selected),
+        },
+        resolved: {
+            articleMarkdown: base.articleMarkdown,
+            researchNotes: edit.config.provided.research ?? null,
+        },
+    });
+    const keys = new Set(recipes.flatMap((row) => row.input.kind === "tts"
+        ? [row.input.logicalKey]
+        : row.stage === "audio" && row.key.endsWith(":1")
+            ? [row.key.slice(0, -2)]
+            : []));
+    const fields = [];
+    for (const [key, value] of Object.entries(edit.content.narrationOverrides))
+        if (!isDeepStrictEqual(value, base.revision.content.narrationOverrides[key]) && !keys.has(key))
+            fields.push({
+                field: `content.narrationOverrides.${key}`,
+                message: "Choose an active narration group or entry.",
+            });
+    for (const [index, upload] of (edit.uploads ?? []).entries())
+        if (upload.destination.kind === "narration" && !keys.has(upload.destination.key))
+            fields.push({
+                field: `uploads.${index}.destination.key`,
+                message: "Choose an active narration group or entry.",
+            });
+    return fields;
+}

package/dist/slices/revisions/schema.js

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { pieceKinds, pieceStates } from "../../kernel/runner/piece-repo.js";
+import { runConfigSchema } from "../admission/schema.js";
+import { outputSchema } from "../storage/schema.js";
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+const workKey = z.string().min(1).max(256);
+const tokens = z.record(workKey, id);
+const cue = z
+    .object({
+    id,
+    text: z.string().trim().min(1).max(10000),
+    start: z.number().finite().nonnegative(),
+    end: z.number().finite().positive(),
+})
+    .strict()
+    .refine((value) => value.end > value.start, {
+    path: ["end"],
+    message: "End must be after start.",
+});
+export const revisionContentSchema = z
+    .object({
+    articleMarkdown: z.string().max(500000).optional(),
+    articleEdited: z.boolean().default(false),
+    provided: z
+        .object({
+        research: id.optional(),
+        article: id.optional(),
+        audio: id.optional(),
+        thumbnail: id.optional(),
+    })
+        .strict(),
+    imageOrder: z.array(id).max(60),
+    imageDefinitions: z.record(id, z
+        .object({
+        source: z.enum(["generate", "provide"]),
+        assetId: id.nullable(),
+        prompt: z.string().max(500000).nullable(),
+        templateKey: z.string().min(1).max(256).nullable().optional(),
+    })
+        .strict()),
+    narrationOverrides: z.record(workKey, z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("asset"), assetId: id }).strict(),
+        z.object({ kind: z.literal("text"), text: z.string().trim().min(1).max(500000) }).strict(),
+    ])),
+    subtitleCues: z
+        .object({
+        audioFingerprint: z.string().min(1),
+        cues: z.array(cue),
+    })
+        .strict()
+        .optional(),
+    regenerationTokens: tokens,
+    promptTemplates: z.record(z.string().min(1), z.string().max(500000).nullable()),
+})
+    .strict();
+export const revisionEditSchema = z
+    .object({
+    config: runConfigSchema.strict(),
+    content: revisionContentSchema,
+    regenerate: z.array(workKey).optional(),
+    uploads: z
+        .array(z
+        .object({
+        stagedFileId: id,
+        destination: z.discriminatedUnion("kind", [
+            z
+                .object({ kind: z.literal("provided"), stage: z.enum(["audio", "thumbnail"]) })
+                .strict(),
+            z.object({ kind: z.literal("image"), imageKey: id }).strict(),
+            z.object({ kind: z.literal("narration"), key: workKey }).strict(),
+        ]),
+    })
+        .strict())
+        .max(10000)
+        .optional(),
+})
+    .strict();
+export const saveRevisionSchema = z
+    .object({
+    baseRevisionId: id,
+    idempotencyKey: id,
+    edit: revisionEditSchema,
+})
+    .strict();
+export const restoreRevisionSchema = z
+    .object({
+    baseRevisionId: id,
+    idempotencyKey: id,
+    targetRevisionId: id,
+})
+    .strict();
+export const projectRevisionSchema = z.object({
+    id,
+    projectId: id,
+    parentId: id.nullable(),
+    restoredFromId: id.nullable(),
+    config: runConfigSchema,
+    content: revisionContentSchema,
+    fingerprints: z.record(workKey, z.string()),
+    createdAt: z.string(),
+});
+export const stagePieceSchema = z.object({
+    id,
+    stageId: id,
+    kind: z.enum(pieceKinds),
+    idx: z.number().int(),
+    state: z.enum(pieceStates),
+    payload: z.string().nullable(),
+});
+const manifestOutputSchema = z.object({
+    slot: z.string(),
+    workKey,
+    assetId: id,
+    output: outputSchema,
+    fingerprint: z.string(),
+    state: z.enum(["ready", "outdated", "review"]),
+});
+const manifestPieceSchema = z.object({
+    key: workKey,
+    stageKind: z.enum(stageKinds),
+    piece: stagePieceSchema,
+    assetId: id.nullable(),
+    fingerprint: z.string(),
+});
+const viewFields = {
+    recordId: id,
+    publicationId: id.nullable(),
+    selected: z.boolean(),
+    available: z.boolean(),
+};
+export const revisionViewSchema = z.object({
+    articleMarkdown: z.string().nullable(),
+    revision: projectRevisionSchema,
+    outputs: z.array(manifestOutputSchema.extend(viewFields)),
+    pieces: z.array(manifestPieceSchema.extend(viewFields)),
+    current: z.boolean(),
+});
+export const revisionSummarySchema = z.object({
+    id,
+    parentId: id.nullable(),
+    restoredFromId: id.nullable(),
+    title: z.string(),
+    createdAt: z.string(),
+    current: z.boolean(),
+});
+export const revisionMutationSuccessSchema = z.object({
+    ok: z.literal(true),
+    view: revisionViewSchema,
+    duplicate: z.boolean(),
+});
+export const baselineSuccessSchema = z.object({
+    ok: z.literal(true),
+    view: revisionViewSchema,
+    created: z.boolean(),
+});

package/dist/slices/revisions/view.js

@@ -0,0 +1,44 @@
+import { readFileSync, statSync } from "node:fs";
+import { z } from "zod";
+import { outputPath } from "../storage/layout.js";
+import { currentRevisionId, outputsForRevision, piecesForRevision, revisionById } from "./repo.js";
+export function getRevisionView(deps, projectId, revisionId) {
+    const revision = revisionById(deps.db, projectId, revisionId);
+    if (revision === undefined)
+        return undefined;
+    const available = (assetId) => {
+        const row = deps.db
+            .prepare("SELECT path FROM project_assets WHERE project_id=? AND id=?")
+            .get(projectId, assetId);
+        if (row === undefined)
+            throw new Error(`Revision asset ${assetId} is not registered.`);
+        const path = z.object({ path: z.string() }).parse(row).path;
+        return (statSync(outputPath(deps.paths, projectId, path), { throwIfNoEntry: false })?.isFile() ===
+            true);
+    };
+    const outputs = outputsForRevision(deps.db, projectId, revisionId).map((row) => ({
+        ...row,
+        available: available(row.assetId),
+    }));
+    const pieces = piecesForRevision(deps.db, projectId, revisionId).map((row) => ({
+        ...row,
+        available: row.assetId === null || available(row.assetId),
+    }));
+    return {
+        revision,
+        outputs,
+        pieces,
+        current: currentRevisionId(deps.db, projectId) === revisionId,
+        articleMarkdown: resolvedArticleMarkdown(deps, revision, outputs),
+    };
+}
+export function resolvedArticleMarkdown(deps, revision, outputs) {
+    if (revision.content.articleEdited === true && revision.content.articleMarkdown !== undefined)
+        return revision.content.articleMarkdown;
+    const article = outputs.find((one) => one.selected && one.available && one.output.role === "article_md");
+    if (article !== undefined)
+        return readFileSync(outputPath(deps.paths, revision.projectId, article.output.path), "utf8");
+    return revision.config.sources.article === "provide"
+        ? (revision.config.provided.article ?? null)
+        : null;
+}

package/dist/slices/schedules/calendar.js

@@ -0,0 +1,47 @@
+/// <reference lib="esnext.temporal" />
+import { z } from "zod";
+export const cadenceSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("once"), at: z.string().datetime({ offset: true }) }).strict(),
+    z
+        .object({ kind: z.literal("daily"), time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/) })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("weekly"),
+        time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/),
+        days: z.array(z.number().int().min(0).max(6)).min(1).max(7).readonly(),
+    })
+        .strict(),
+]);
+export function validTimeZone(timeZone) {
+    try {
+        new Intl.DateTimeFormat("en", { timeZone }).format();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function nextOccurrence(cadence, timeZone, now) {
+    if (!validTimeZone(timeZone))
+        return null;
+    if (cadence.kind === "once") {
+        const at = new Date(cadence.at);
+        return Number.isNaN(at.valueOf()) || at <= now ? null : at;
+    }
+    const current = Temporal.Instant.fromEpochMilliseconds(now.valueOf())
+        .toZonedDateTimeISO(timeZone)
+        .toPlainDate();
+    const wanted = Temporal.PlainTime.from(cadence.time);
+    for (let offset = 0; offset <= 8; offset++) {
+        const day = current.add({ days: offset });
+        if (cadence.kind === "weekly" && !cadence.days.includes(day.dayOfWeek % 7))
+            continue;
+        const candidate = day.toPlainDateTime(wanted).toZonedDateTime(timeZone, {
+            disambiguation: "compatible",
+        });
+        if (candidate.epochMilliseconds > now.valueOf())
+            return new Date(candidate.epochMilliseconds);
+    }
+    return null;
+}

package/dist/slices/schedules/model.js

@@ -0,0 +1 @@
+export {};