@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/designs/sections.js

@@ -0,0 +1,44 @@
+import { detectSlots } from "../admission/substitute.js";
+// The design template editor's sections, and which ones a Save changed. Pure and browser-safe:
+// the page shows the cost on Save only when the Picture changed, because that is the only
+// section whose sample is paid (one artwork); text, formats and the schedule redraw for free.
+export const designSections = [
+    { id: "picture", label: "Picture" },
+    { id: "text", label: "Text layout" },
+    { id: "formats", label: "Formats" },
+    { id: "schedule", label: "Schedule" },
+];
+// Every key of the document belongs to one section; a new key must be added here, which the
+// test that walks the schema's keys enforces.
+export const sectionOfKey = {
+    version: null,
+    picture: "picture",
+    text: "text",
+    samples: "text",
+    formats: "formats",
+    brochure: "formats",
+    schedule: "schedule",
+};
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export function designAffectedSections(before, after) {
+    const changed = new Set();
+    for (const key of Object.keys(sectionOfKey)) {
+        const section = sectionOfKey[key];
+        if (section !== null && !same(before[key], after[key]))
+            changed.add(section);
+    }
+    // The artwork's prompt is filled from the sample values, so a changed sample that the
+    // prompt uses changes the picture too.
+    if (!same(before.samples, after.samples) && promptUsesChangedSample(before, after))
+        changed.add("picture");
+    return designSections.map((section) => section.id).filter((id) => changed.has(id));
+}
+function promptUsesChangedSample(before, after) {
+    if (after.picture.source !== "generate")
+        return false;
+    return detectSlots(after.picture.prompt).names.some((name) => before.samples[name] !== after.samples[name]);
+}
+// Whether a Save with these changes makes a paid picture for the sample.
+export function sampleNeedsPicture(affected) {
+    return affected.includes("picture");
+}

package/dist/slices/designs/service.js

@@ -0,0 +1,233 @@
+import { createHash } from "node:crypto";
+import { transact } from "../../kernel/db/tx.js";
+import { errorText } from "../../kernel/errors.js";
+import { liveProject } from "../admission/repo.js";
+import { storeImageBlob } from "../channels/images.js";
+import { defaultChannelId } from "../channels/model.js";
+import { imageBlob } from "../channels/repo.js";
+import { releaseStagedFile } from "../storage/staging-refs.js";
+import { notTemplateSample } from "../template-studio/repo.js";
+import { readPicture, startingPicture } from "./pictures.js";
+import { designById, designByMutation, insertDesign, listDesigns, updateDesign } from "./repo.js";
+import { createDesignSchema, setHeadSchema, updateDesignSchema } from "./requests.js";
+import { insertStep, stepById, stepsOf } from "./steps-repo.js";
+export const changedMessage = "This design changed in another tab or by an agent. Reload it to see the change, then make yours again.";
+export const reusedMessage = "This request id was already used for a different change. Reload the page and try again.";
+const notFound = {
+    ok: false,
+    reason: "not-found",
+    message: "This design no longer exists. Go back to Designs to choose another.",
+};
+export function mutationHash(input) {
+    return createHash("sha256").update(JSON.stringify(input)).digest("hex");
+}
+export function designView(db, id) {
+    const design = designById(db, id);
+    if (design === undefined || design.deletedAt !== null)
+        return undefined;
+    return { ...design, steps: stepsOf(db, id) };
+}
+export function listDesignViews(db, projectId) {
+    return listDesigns(db, { projectId }).map((design) => ({
+        ...design,
+        steps: stepsOf(db, design.id),
+    }));
+}
+export function getDesign(deps, id) {
+    const view = designView(deps.db, id);
+    return view === undefined ? notFound : { ok: true, value: view };
+}
+function emit(deps, designId) {
+    try {
+        deps.emit?.({ type: "design.changed", designId });
+    }
+    catch (error) {
+        deps.log.write("warn", "designs.emit", { detail: errorText(error) });
+    }
+}
+export function createDesign(deps, raw) {
+    const parsed = createDesignSchema.safeParse(raw);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid",
+            message: `The design can't be made: ${parsed.error.issues[0]?.message ?? "a field is missing"}.`,
+        };
+    const input = parsed.data;
+    const { mutationId, ...rest } = input;
+    const hash = mutationHash(rest);
+    const replay = designByMutation(deps.db, mutationId);
+    if (replay !== undefined) {
+        if (replay.hash !== hash)
+            return { ok: false, reason: "mutation-reused", message: reusedMessage };
+        const view = designView(deps.db, replay.design.id);
+        return view === undefined ? notFound : { ok: true, value: view };
+    }
+    if (designById(deps.db, input.id) !== undefined)
+        return { ok: false, reason: "mutation-reused", message: reusedMessage };
+    const channelId = input.channelId ?? defaultChannelId;
+    if (deps.db.prepare("SELECT 1 FROM channels WHERE id=?").get(channelId) === undefined)
+        return {
+            ok: false,
+            reason: "channel-not-found",
+            message: "That channel no longer exists. Choose another channel, then press Make again.",
+        };
+    if (input.projectId !== undefined && !projectExists(deps.db, input.projectId))
+        return {
+            ok: false,
+            reason: "project-not-found",
+            message: "That project no longer exists or is in the trash. Choose another project, or leave it out.",
+        };
+    if (input.kind === "design" && input.document === undefined)
+        return {
+            ok: false,
+            reason: "invalid",
+            message: "A designed piece needs its settings. Choose its picture, text and formats, then press Make.",
+        };
+    const picture = startingPicture(deps, input);
+    if (!picture.ok)
+        return picture;
+    if (input.kind === "edit" && picture.value === undefined)
+        return {
+            ok: false,
+            reason: "invalid",
+            message: "An edit starts from a picture. Upload a PNG or JPEG, then press Edit.",
+        };
+    const at = deps.clock.now().toISOString();
+    transact(deps.db, () => {
+        insertDesign(deps.db, {
+            id: input.id,
+            kind: input.kind,
+            name: input.name,
+            channelId,
+            projectId: input.projectId ?? null,
+            document: input.document ?? null,
+            values: input.values ?? {},
+            mutationId,
+            mutationHash: hash,
+            at,
+        });
+        const start = picture.value;
+        if (start === undefined)
+            return;
+        const sha256 = storeImageBlob(deps.db, start.bytes, start.mime, at);
+        const step = insertStep(deps.db, {
+            id: deps.ids.next(),
+            designId: input.id,
+            parentId: null,
+            kind: "upload",
+            instruction: null,
+            provider: null,
+            model: null,
+            inputs: { castMemberIds: [] },
+            state: "ready",
+            sha256,
+            width: start.width,
+            height: start.height,
+            mutationId: null,
+            mutationHash: null,
+            at,
+        });
+        updateDesign(deps.db, input.id, undefined, { headStepId: step.id }, at);
+    });
+    // The upload's bytes now live in image_blobs; the staging copy is let go once committed.
+    const stagedId = picture.value?.stagedId;
+    if (stagedId !== undefined)
+        releaseStagedFile({
+            db: deps.db,
+            paths: deps.paths,
+            ids: deps.ids,
+            clock: deps.clock,
+            log: deps.log,
+            emit: () => { },
+        }, stagedId);
+    emit(deps, input.id);
+    const view = designView(deps.db, input.id);
+    return view === undefined ? notFound : { ok: true, value: view };
+}
+function projectExists(db, id) {
+    // A template's studio sample is the studio's alone: no design can be linked to it.
+    return (db
+        .prepare(`SELECT 1 FROM projects WHERE id=? AND ${liveProject()} AND ${notTemplateSample()}`)
+        .get(id) !== undefined);
+}
+export function updateDesignRecord(deps, id, raw) {
+    const parsed = updateDesignSchema.safeParse(raw);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid",
+            message: `The change can't be saved: ${parsed.error.issues[0]?.message ?? "a field is missing"}.`,
+        };
+    const input = parsed.data;
+    const current = designView(deps.db, id);
+    if (current === undefined)
+        return notFound;
+    if (input.projectId !== undefined &&
+        input.projectId !== null &&
+        !projectExists(deps.db, input.projectId))
+        return {
+            ok: false,
+            reason: "project-not-found",
+            message: "That project no longer exists or is in the trash. Choose another project.",
+        };
+    const saved = updateDesign(deps.db, id, input.baseUpdatedAt, {
+        name: input.name,
+        projectId: input.projectId,
+        // Turning an edit into a designed piece is giving it a document.
+        ...(input.document === undefined
+            ? {}
+            : { document: input.document, kind: "design" }),
+        values: input.values,
+    }, deps.clock.now().toISOString());
+    if (!saved)
+        return { ok: false, reason: "changed", message: changedMessage, current };
+    emit(deps, id);
+    const view = designView(deps.db, id);
+    return view === undefined ? notFound : { ok: true, value: view };
+}
+// "Continue from this version": free, it only moves which version the next edit starts from.
+export function setDesignHead(deps, id, raw) {
+    const parsed = setHeadSchema.safeParse(raw);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid", message: "Choose a version to continue from." };
+    if (designView(deps.db, id) === undefined)
+        return notFound;
+    const step = stepById(deps.db, parsed.data.stepId);
+    if (step === undefined || step.designId !== id)
+        return {
+            ok: false,
+            reason: "not-found",
+            message: "That version is no longer in this design. Reload the page.",
+        };
+    if (step.state !== "ready")
+        return {
+            ok: false,
+            reason: "not-ready",
+            message: "That version has no picture yet. Wait for it to finish, or press Try again on it.",
+        };
+    updateDesign(deps.db, id, undefined, { headStepId: step.id }, deps.clock.now().toISOString());
+    emit(deps, id);
+    const view = designView(deps.db, id);
+    return view === undefined ? notFound : { ok: true, value: view };
+}
+export function stepPicture(db, designId, stepId) {
+    const step = stepById(db, stepId);
+    if (step === undefined || step.designId !== designId || step.sha256 === null)
+        return undefined;
+    if (designView(db, designId) === undefined)
+        return undefined;
+    return imageBlob(db, step.sha256);
+}
+// A picture sent as bytes (an agent's upload_design_picture): kept in image_blobs, answered with
+// the hash a new design starts from (`fromStepSha`).
+export function storeUploadedPicture(deps, bytes) {
+    const read = readPicture(bytes);
+    if (!read.ok)
+        return read;
+    const sha256 = storeImageBlob(deps.db, read.value.bytes, read.value.mime, deps.clock.now().toISOString());
+    return {
+        ok: true,
+        value: { sha256, mime: read.value.mime, width: read.value.width, height: read.value.height },
+    };
+}

package/dist/slices/designs/steps-repo.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { stepKinds, stepStates } from "./model.js";
+// Rows of `design_steps` (migration 0070): each one version of a design's picture.
+const stepRow = z.object({
+    id: z.string(),
+    design_id: z.string(),
+    n: z.number(),
+    parent_id: z.string().nullable(),
+    kind: z.enum(stepKinds),
+    instruction: z.string().nullable(),
+    provider: z.string().nullable(),
+    model: z.string().nullable(),
+    inputs_json: z.string(),
+    state: z.enum(stepStates),
+    error: z.string().nullable(),
+    sha256: z.string().nullable(),
+    width: z.number().nullable(),
+    height: z.number().nullable(),
+    created_at: z.string(),
+    settled_at: z.string().nullable(),
+});
+const inputsSchema = z
+    .object({
+    castMemberIds: z.array(z.string()).default([]),
+    aspect: z.enum(["16:9", "9:16", "1:1"]).optional(),
+    prompt: z.string().optional(),
+})
+    .catch({ castMemberIds: [] });
+function toStep(raw) {
+    const row = stepRow.parse(raw);
+    const inputs = inputsSchema.parse(JSON.parse(row.inputs_json));
+    return {
+        id: row.id,
+        designId: row.design_id,
+        n: row.n,
+        parentId: row.parent_id,
+        kind: row.kind,
+        instruction: row.instruction,
+        provider: row.provider,
+        model: row.model,
+        inputs,
+        state: row.state,
+        error: row.error,
+        sha256: row.sha256,
+        width: row.width,
+        height: row.height,
+        createdAt: row.created_at,
+        settledAt: row.settled_at,
+    };
+}
+// Numbered after the design's last step, inside the caller's transaction.
+export function insertStep(db, step) {
+    const last = db
+        .prepare("SELECT max(n) AS n FROM design_steps WHERE design_id=?")
+        .get(step.designId);
+    const n = typeof last?.n === "number" ? last.n + 1 : 1;
+    db.prepare(`INSERT INTO design_steps (id,design_id,n,parent_id,kind,instruction,provider,model,inputs_json,state,sha256,width,height,mutation_id,mutation_hash,created_at,settled_at)
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(step.id, step.designId, n, step.parentId, step.kind, step.instruction, step.provider, step.model, JSON.stringify(step.inputs), step.state, step.sha256, step.width, step.height, step.mutationId, step.mutationHash, step.at, step.state === "making" ? null : step.at);
+    const made = stepById(db, step.id);
+    if (made === undefined)
+        throw new Error(`design step ${step.id} was not stored`);
+    return made;
+}
+export function stepById(db, id) {
+    const row = db.prepare("SELECT * FROM design_steps WHERE id=?").get(id);
+    return row === undefined ? undefined : toStep(row);
+}
+export function stepByMutation(db, mutationId) {
+    const row = db.prepare("SELECT * FROM design_steps WHERE mutation_id=?").get(mutationId);
+    return row === undefined
+        ? undefined
+        : { step: toStep(row), hash: row.mutation_hash === null ? null : String(row.mutation_hash) };
+}
+export function stepsOf(db, designId) {
+    return db
+        .prepare("SELECT * FROM design_steps WHERE design_id=? ORDER BY n")
+        .all(designId)
+        .map(toStep);
+}
+export function makingSteps(db) {
+    return db
+        .prepare("SELECT * FROM design_steps WHERE state='making' ORDER BY created_at, n")
+        .all()
+        .map(toStep);
+}
+export function settleStep(db, id, outcome, at) {
+    const result = outcome.state === "ready"
+        ? db
+            .prepare("UPDATE design_steps SET state='ready',sha256=?,width=?,height=?,error=NULL,settled_at=? WHERE id=? AND state='making'")
+            .run(outcome.sha256, outcome.width, outcome.height, at, id)
+        : db
+            .prepare("UPDATE design_steps SET state='failed',error=?,settled_at=? WHERE id=? AND state='making'")
+            .run(outcome.error, at, id);
+    return Number(result.changes) > 0;
+}
+// Try again: the same step asks again, in place.
+export function restartStep(db, id) {
+    const result = db
+        .prepare("UPDATE design_steps SET state='making',error=NULL,settled_at=NULL WHERE id=? AND state='failed'")
+        .run(id);
+    return Number(result.changes) > 0;
+}

package/dist/slices/designs/studio-kind.js

@@ -0,0 +1,39 @@
+import { estimateRequests } from "../estimate/requests.js";
+import { designAffectedSections, designSections, sampleNeedsPicture, } from "./sections.js";
+import { documentChecks } from "./template-checks.js";
+import { quoteDocument } from "./template-make.js";
+export function freeSample(catalogue) {
+    return estimateRequests([{ kind: "local", stage: "Sample" }], catalogue);
+}
+export function designStudioKind(deps) {
+    return {
+        kind: "design",
+        sections: designSections,
+        affectedSections: designAffectedSections,
+        freeChecks: (doc, ctx) => documentChecks(doc, ctx.templateId),
+        quoteSample: (doc, affected) => sampleNeedsPicture(affected)
+            ? quoteDocument(deps.catalogue(), doc)
+            : freeSample(deps.catalogue()),
+        requestSample: (templateId, version, acknowledgedHigh, acknowledgedUnknown) => deps.samples.request(templateId, version, acknowledgedHigh, acknowledgedUnknown),
+        sampleState: (templateId) => {
+            const sample = deps.samples.state(templateId);
+            const doc = deps.document(templateId);
+            const picture = sample === null
+                ? "off"
+                : sample.state === "making" || sample.state === "queued"
+                    ? "making"
+                    : sample.state === "held"
+                        ? "waiting"
+                        : sample.state === "failed"
+                            ? "needs-fix"
+                            : "current";
+            const drawn = sample?.designId == null ? "off" : "current";
+            return {
+                picture,
+                text: drawn,
+                formats: drawn,
+                schedule: doc?.schedule === undefined ? "off" : "current",
+            };
+        },
+    };
+}

package/dist/slices/designs/template-checks.js

@@ -0,0 +1,44 @@
+import { designFields, fieldProblems } from "./fields.js";
+const isoDate = /^(\d{4})-(\d{2})-(\d{2})$/;
+export function validDate(value) {
+    const match = isoDate.exec(value.trim());
+    if (match === null)
+        return false;
+    const [, y, m, d] = match.map(Number);
+    const date = new Date(Date.UTC(y ?? 0, (m ?? 1) - 1, d ?? 1));
+    return date.getUTCFullYear() === y && date.getUTCMonth() + 1 === m && date.getUTCDate() === d;
+}
+export function documentChecks(doc, templateId) {
+    const at = (section) => ({
+        label: "Open",
+        href: `/library/design-templates/${templateId}#${section}`,
+    });
+    const problems = fieldProblems(doc);
+    const missing = designFields(doc).filter((name) => (doc.samples[name] ?? "").trim() === "");
+    const dateField = doc.schedule?.dateField;
+    const sampleDate = dateField === undefined ? undefined : doc.samples[dateField];
+    return [
+        {
+            id: "fields",
+            ok: problems.length === 0,
+            sentence: problems[0]?.sentence ?? "Every keyword is written as {{Name}}.",
+            fix: problems.length === 0 ? null : at("text"),
+        },
+        {
+            id: "samples",
+            ok: missing.length === 0,
+            sentence: missing.length === 0
+                ? "Every keyword has a sample value."
+                : `${missing.map((name) => `{{${name}}}`).join(", ")} ${missing.length === 1 ? "has" : "have"} no sample value. Fill ${missing.length === 1 ? "it" : "them"} in under Text → Sample values.`,
+            fix: missing.length === 0 ? null : at("text"),
+        },
+        {
+            id: "dates",
+            ok: sampleDate === undefined || validDate(sampleDate),
+            sentence: sampleDate === undefined || validDate(sampleDate)
+                ? "Dates read as YYYY-MM-DD."
+                : `The sample {{${dateField ?? ""}}} "${sampleDate}" isn't a date written YYYY-MM-DD (for example 2026-11-14). Write it that way under Text → Sample values.`,
+            fix: sampleDate === undefined || validDate(sampleDate) ? null : at("text"),
+        },
+    ];
+}

package/dist/slices/designs/template-make.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { estimateRequests } from "../estimate/requests.js";
+import { fieldProblems, fillDocument, missingSentence, missingValues } from "./fields.js";
+import { costChanged, costChangedMessage, quoteDesignImage } from "./quote.js";
+import { designValuesSchema } from "./requests.js";
+import { createDesign, designView, mutationHash } from "./service.js";
+import { getTemplate, templateRevision } from "./templates.js";
+// Make one piece from a design template: a design with the template version's settings and
+// these values, its artwork started at once (the only paid step). Schedules and the template
+// editor's sample make theirs the same way, naming what they made it for (`MakeOrigin`).
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z0-9_-]+$/);
+export const makeFromTemplateSchema = z
+    .object({
+    mutationId: z.string().min(8).max(100),
+    values: designValuesSchema,
+    acknowledgedHigh: z.number().min(0).max(1000),
+    acknowledgedUnknown: z.boolean().optional(),
+    version: z.number().int().min(1).optional(),
+    name: z.string().trim().min(1).max(200).optional(),
+    projectId: id.optional(),
+})
+    .strict();
+const notFound = {
+    ok: false,
+    reason: "not-found",
+    message: "This design template no longer exists. Open Templates → Poster templates to choose another.",
+};
+// What one piece made from this document costs: its artwork, or nothing when the template
+// keeps its own picture.
+export function quoteDocument(catalogue, doc) {
+    if (doc.picture.source !== "generate")
+        return estimateRequests([{ kind: "local", stage: "Artwork" }], catalogue);
+    return quoteDesignImage(catalogue, {
+        provider: doc.picture.provider,
+        model: doc.picture.model,
+        purpose: "design-art",
+        sendsPictures: doc.picture.castMemberIds.length > 0,
+    });
+}
+export function quoteTemplate(deps, templateId) {
+    const template = getTemplate(deps.service.db, templateId);
+    return template === undefined
+        ? notFound
+        : { ok: true, value: quoteDocument(deps.catalogue(), template.document) };
+}
+export function makeFromTemplate(deps, templateId, raw, origin = {}) {
+    const parsed = makeFromTemplateSchema.safeParse(raw);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid",
+            message: `The poster can't be made: ${parsed.error.issues[0]?.message ?? "a keyword is missing"}.`,
+        };
+    const input = parsed.data;
+    const template = getTemplate(deps.service.db, templateId);
+    if (template === undefined)
+        return notFound;
+    const revision = templateRevision(deps.service.db, templateId, input.version ?? template.headVersion);
+    if (revision === undefined)
+        return {
+            ok: false,
+            reason: "not-found",
+            message: "That version of the template doesn't exist. Reload the template.",
+        };
+    const doc = revision.document;
+    const problem = fieldProblems(doc)[0];
+    if (problem !== undefined)
+        return { ok: false, reason: "invalid", message: problem.sentence };
+    const missing = missingValues(doc, input.values);
+    if (missing.length > 0)
+        return { ok: false, reason: "missing-values", message: missingSentence(missing) };
+    const quote = quoteDocument(deps.catalogue(), doc);
+    if (costChanged(quote, input.acknowledgedHigh, input.acknowledgedUnknown))
+        return {
+            ok: false,
+            reason: "cost-changed",
+            message: costChangedMessage(quote, "this poster"),
+            current: quote,
+        };
+    const own = doc.picture.source === "picture" ? doc.picture.sha256 : undefined;
+    if (doc.picture.source === "picture" && own === undefined)
+        return {
+            ok: false,
+            reason: "invalid",
+            message: "This template uses its own picture, but none is saved with it. Upload one under Picture, then press Make.",
+        };
+    const headline = fillDocument(doc, input.values).text.blocks.find((block) => block.text.trim() !== "")?.text;
+    const made = createDesign(deps.service, {
+        // From the request id, so a repeated request finds the design it made.
+        id: `d${mutationHash({ templateId, mutationId: input.mutationId }).slice(0, 31)}`,
+        mutationId: input.mutationId,
+        kind: "design",
+        name: (input.name ?? headline ?? revision.name).slice(0, 200),
+        channelId: template.channelId,
+        ...(input.projectId === undefined ? {} : { projectId: input.projectId }),
+        ...(own === undefined ? {} : { fromStepSha: own }),
+        document: doc,
+        values: input.values,
+    });
+    if (!made.ok)
+        return made;
+    deps.service.db
+        .prepare("UPDATE designs SET template_id=?, template_version=?, sample_of=?, schedule_id=?, schedule_run_id=? WHERE id=?")
+        .run(templateId, revision.version, origin.sampleOf ?? null, origin.scheduleId ?? null, origin.scheduleRunId ?? null, made.value.id);
+    if (own !== undefined) {
+        const view = designView(deps.service.db, made.value.id);
+        return view === undefined ? notFound : { ok: true, value: view };
+    }
+    return deps.runner.artwork(made.value.id, {
+        mutationId: `${input.mutationId}:artwork`,
+        acknowledgedHigh: input.acknowledgedHigh,
+        acknowledgedUnknown: input.acknowledgedUnknown,
+    });
+}