wizards 0.1.9

package/apps/runtime/dist/services/wizards.js

@@ -0,0 +1,342 @@
+import { validateWizard, wizardSchema, } from "@engenty-wizards/shared/definition";
+import { and, desc, eq, sql } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { applyOps, OpError } from "../authoring/ops.js";
+import { listConnectors } from "../connectors/external.js";
+import { db, schema } from "../db/client.js";
+import { env } from "../env.js";
+import { dropLinks, putLink } from "../tenants/control.js";
+import { currentTenant } from "../tenants/tenant.js";
+import { changedSteps, emitDraftChanged } from "./draft-events.js";
+import { notFound, ServiceError } from "./errors.js";
+import { copyFiles, draftFiles, sameFiles, seedFiles } from "./files.js";
+import { forgetWizardLinks } from "./links.js";
+import { asLang, countInstall, marketplaceWizard } from "./marketplace.js";
+import { defaultProject, ownedProject } from "./projects.js";
+const BLANK = {
+    version: 1,
+    title: "Neuer Wizard",
+    description: "",
+    avatar: "round",
+    steps: [
+        {
+            id: "start",
+            type: "page",
+            title: "Los geht's",
+            fields: [{ id: "input", label: "Worum geht es?", kind: "textarea", required: true }],
+        },
+        { id: "done", type: "result", title: "Fertig", deliverables: [] },
+    ],
+};
+export const studioUrl = (wizardId) => `${env.appUrl}/studio/edit/${wizardId}`;
+export const shareUrl = (token) => `${env.appUrl}/w/${token}`;
+const newShareToken = () => nanoid(14);
+export async function ownedWizard(_userId, wizardId) {
+    const w = await db.query.wizard.findFirst({
+        where: and(eq(schema.wizard.id, wizardId), eq(schema.wizard.tenantId, currentTenant())),
+    });
+    if (!w) {
+        throw notFound();
+    }
+    return w;
+}
+export function wizardSummary(w) {
+    return {
+        id: w.id,
+        projectId: w.projectId,
+        title: w.title,
+        description: w.draft.description,
+        avatar: w.draft.avatar,
+        revision: w.revision,
+        published: w.publishedVersion !== null,
+        publishedVersion: w.publishedVersion,
+        shareToken: w.shareToken,
+        shareEnabled: w.shareEnabled,
+        dailyRunLimit: w.dailyRunLimit,
+        stepCount: w.draft.steps.length,
+        updatedAt: w.updatedAt.toISOString(),
+    };
+}
+export async function listWizards(_userId, projectId) {
+    const rows = await db.query.wizard.findMany({
+        where: and(eq(schema.wizard.tenantId, currentTenant()), projectId ? eq(schema.wizard.projectId, projectId) : undefined),
+        orderBy: [desc(schema.wizard.updatedAt)],
+    });
+    return rows.map(wizardSummary);
+}
+async function publishedVersion(w) {
+    if (w.publishedVersion === null) {
+        return null;
+    }
+    const v = await db.query.wizardVersion.findFirst({
+        where: and(eq(schema.wizardVersion.wizardId, w.id), eq(schema.wizardVersion.version, w.publishedVersion)),
+    });
+    return v ?? null;
+}
+/** Connections must name connectors the project has imported, and actions those connectors have. */
+async function connectorIssues(projectId, draft) {
+    const wanted = (draft.connections ?? []).filter((c) => c.connector);
+    if (!wanted.length) {
+        return [];
+    }
+    const issues = [];
+    const connectors = await listConnectors(projectId);
+    for (const connection of wanted) {
+        const connector = connectors.find((c) => c.id === connection.connector);
+        if (!connector) {
+            issues.push({
+                message: `Connection "${connection.id}" uses connector "${connection.connector}", which this project has not imported.`,
+            });
+            continue;
+        }
+        const unknown = (connection.actions ?? []).filter((a) => !connector.actions.some((x) => x.id === a));
+        if (unknown.length && !connector.toolsPending) {
+            issues.push({
+                message: `Connection "${connection.id}": ${connector.name} has no action ${unknown.map((a) => `"${a}"`).join(", ")}.`,
+            });
+        }
+    }
+    return issues;
+}
+/** Everything wrong with a draft: its structure, its workspace files, its project's connectors. */
+async function checkDraft(projectId, draft, files) {
+    return [...validateWizard(draft, files), ...(await connectorIssues(projectId, draft))];
+}
+/** Validator issues of the draft, checked against its workspace and the project's connectors. */
+export async function draftIssues(w) {
+    const files = await draftFiles(w.id);
+    return checkDraft(w.projectId, w.draft, files.map((f) => f.path));
+}
+/** The draft with its validator issues and whether it differs from the published version. */
+export async function wizardState(w) {
+    const published = await publishedVersion(w);
+    const files = await draftFiles(w.id);
+    return {
+        ...wizardSummary(w),
+        draft: w.draft,
+        files,
+        issues: await checkDraft(w.projectId, w.draft, files.map((f) => f.path)),
+        dirty: !published ||
+            JSON.stringify(published.definition) !== JSON.stringify(w.draft) ||
+            !sameFiles(published.files, files),
+        shareUrl: shareUrl(w.shareToken),
+        studioUrl: studioUrl(w.id),
+    };
+}
+export async function wizardMessages(wizardId) {
+    return db.query.wizardMessage.findMany({
+        where: eq(schema.wizardMessage.wizardId, wizardId),
+        orderBy: [schema.wizardMessage.createdAt],
+    });
+}
+export async function addMessage(wizardId, message, writer = { source: "studio" }) {
+    const id = nanoid(12);
+    await db.insert(schema.wizardMessage).values({
+        id,
+        wizardId,
+        role: message.role,
+        content: message.content,
+        changed: message.changed ?? false,
+        source: writer.source,
+        client: writer.source === "mcp" ? writer.client : null,
+    });
+    return id;
+}
+function stepLabel(raw, index) {
+    const steps = raw?.steps;
+    const id = steps?.[index]?.id;
+    return typeof id === "string" ? `steps[${index}] "${id}"` : `steps[${index}]`;
+}
+/** The schema check every write passes. Validator issues are allowed in a draft; a wrong shape is not. */
+export function parseDraft(raw, files) {
+    const parsed = wizardSchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new ServiceError("invalid", "The wizard does not match the schema.", {
+            issues: shapeIssues(parsed.error, raw),
+        });
+    }
+    return { draft: parsed.data, issues: validateWizard(parsed.data, files) };
+}
+export function shapeIssues(error, raw) {
+    return error.issues.map((i) => {
+        const [head, index, ...rest] = i.path;
+        const where = head === "steps" && typeof index === "number"
+            ? [stepLabel(raw, index), ...rest].join(".")
+            : i.path.join(".");
+        return { message: `${where || "wizard"}: ${i.message}` };
+    });
+}
+export async function createWizard(userId, input, writer = { source: "studio" }) {
+    const project = input.projectId
+        ? await ownedProject(userId, input.projectId)
+        : await defaultProject(userId);
+    const starter = input.starterId
+        ? await marketplaceWizard(input.starterId, asLang(input.lang))
+        : undefined;
+    if (input.starterId && !starter) {
+        throw new ServiceError("invalid", `There is no starter "${input.starterId}".`);
+    }
+    const { draft, issues } = input.definition !== undefined
+        ? parseDraft(input.definition)
+        : { draft: starter?.definition ?? structuredClone(BLANK), issues: [] };
+    const fromStarter = input.definition === undefined ? starter : undefined;
+    const id = nanoid(12);
+    const shareToken = newShareToken();
+    await db.insert(schema.wizard).values({
+        id,
+        projectId: project.id,
+        tenantId: currentTenant(),
+        title: draft.title,
+        draft,
+        shareToken,
+        dailyRunLimit: env.limits.defaultDailyRuns,
+        starter: fromStarter?.id ?? null,
+        starterRevision: fromStarter?.revision ?? null,
+    });
+    await putLink(shareToken, "wizard", id);
+    if (fromStarter) {
+        await seedFiles(id, fromStarter.files);
+        // Counted at the marketplace, beside the request.
+        void countInstall(fromStarter.id);
+    }
+    if (input.note) {
+        await addMessage(id, { role: "assistant", content: input.note, changed: true }, writer);
+    }
+    else if (fromStarter) {
+        await addMessage(id, {
+            role: "assistant",
+            content: fromStarter.language === "en"
+                ? `I have set up the template "${fromStarter.title}" for you. Test it at the top right – or tell me what should be different.`
+                : `Ich habe die Vorlage „${fromStarter.title}“ für dich angelegt. Teste sie rechts oben – oder sag mir, was anders sein soll.`,
+        });
+    }
+    return { id, revision: 0, issues, studioUrl: studioUrl(id) };
+}
+/**
+ * Replaces the draft if nobody wrote since `baseRevision`. Every draft write — studio inspector,
+ * architect, MCP — goes through here, so the revision counts all of them.
+ */
+export async function writeDraft(userId, wizardId, input, writer = { source: "studio" }) {
+    const w = await ownedWizard(userId, wizardId);
+    const files = await draftFiles(w.id);
+    const paths = files.map((f) => f.path);
+    const { draft } = parseDraft(input.definition, paths);
+    const issues = await checkDraft(w.projectId, draft, paths);
+    const [row] = await db
+        .update(schema.wizard)
+        .set({
+        draft,
+        title: draft.title,
+        revision: sql `${schema.wizard.revision} + 1`,
+        updatedAt: new Date(),
+    })
+        .where(and(eq(schema.wizard.id, w.id), eq(schema.wizard.revision, input.baseRevision)))
+        .returning({ revision: schema.wizard.revision });
+    if (!row) {
+        const current = await ownedWizard(userId, wizardId);
+        throw new ServiceError("revision_conflict", "Der Wizard wurde inzwischen geändert.", {
+            revision: current.revision,
+        });
+    }
+    if (input.note) {
+        await addMessage(w.id, { role: "assistant", content: input.note, changed: true }, writer);
+    }
+    emitDraftChanged({
+        wizardId: w.id,
+        kind: "draft",
+        revision: row.revision,
+        source: writer.source,
+        client: writer.source === "mcp" ? writer.client : null,
+        note: input.note ?? null,
+        touched: changedSteps(w.draft, draft),
+    });
+    return { revision: row.revision, issues, draft };
+}
+export async function editWizard(userId, wizardId, input, writer) {
+    const w = await ownedWizard(userId, wizardId);
+    if (w.revision !== input.baseRevision) {
+        throw new ServiceError("revision_conflict", "Der Wizard wurde inzwischen geändert.", {
+            revision: w.revision,
+        });
+    }
+    let definition;
+    try {
+        definition = applyOps(w.draft, input.ops);
+    }
+    catch (err) {
+        if (err instanceof OpError) {
+            throw new ServiceError("invalid", err.message);
+        }
+        throw err;
+    }
+    return writeDraft(userId, wizardId, { definition, baseRevision: input.baseRevision, note: input.note }, writer);
+}
+export async function updateWizardSettings(userId, wizardId, patch) {
+    const w = await ownedWizard(userId, wizardId);
+    if (patch.projectId) {
+        await ownedProject(userId, patch.projectId);
+    }
+    await db
+        .update(schema.wizard)
+        .set({ ...patch, updatedAt: new Date() })
+        .where(eq(schema.wizard.id, w.id));
+    return wizardSummary(await ownedWizard(userId, wizardId));
+}
+export async function rotateShareLink(userId, wizardId) {
+    const w = await ownedWizard(userId, wizardId);
+    const token = newShareToken();
+    await db
+        .update(schema.wizard)
+        .set({ shareToken: token, updatedAt: new Date() })
+        .where(eq(schema.wizard.id, w.id));
+    await dropLinks([w.shareToken]);
+    await putLink(token, "wizard", w.id);
+    return { shareToken: token, shareUrl: shareUrl(token) };
+}
+export async function duplicateWizard(userId, wizardId) {
+    const w = await ownedWizard(userId, wizardId);
+    const id = nanoid(12);
+    const draft = { ...w.draft, title: `${w.draft.title} (Kopie)` };
+    const shareToken = newShareToken();
+    await db.insert(schema.wizard).values({
+        id,
+        projectId: w.projectId,
+        tenantId: currentTenant(),
+        title: draft.title,
+        draft,
+        shareToken,
+        dailyRunLimit: w.dailyRunLimit,
+        starter: w.starter,
+    });
+    await putLink(shareToken, "wizard", id);
+    await copyFiles(w.id, id);
+    return { id };
+}
+export async function deleteWizard(_userId, wizardId) {
+    await forgetWizardLinks(wizardId);
+    await db
+        .delete(schema.wizard)
+        .where(and(eq(schema.wizard.id, wizardId), eq(schema.wizard.tenantId, currentTenant())));
+}
+/** A wizard with validator issues is never published — same rule for studio and MCP. */
+export async function requireClean(w) {
+    const files = await draftFiles(w.id);
+    const issues = await checkDraft(w.projectId, w.draft, files.map((f) => f.path));
+    if (issues.length) {
+        throw new ServiceError("has_issues", "Der Wizard hat noch Fehler.", { issues });
+    }
+    return { definition: w.draft, files };
+}
+export async function publishWizard(userId, wizardId) {
+    const w = await ownedWizard(userId, wizardId);
+    const { definition, files } = await requireClean(w);
+    const version = (w.publishedVersion ?? 0) + 1;
+    await db
+        .insert(schema.wizardVersion)
+        .values({ id: nanoid(12), wizardId: w.id, version, definition, files });
+    await db
+        .update(schema.wizard)
+        .set({ publishedVersion: version, updatedAt: new Date() })
+        .where(eq(schema.wizard.id, w.id));
+    return { version, shareUrl: shareUrl(w.shareToken), shareEnabled: w.shareEnabled };
+}

package/apps/runtime/dist/settings.js

@@ -0,0 +1,16 @@
+import { eq } from "drizzle-orm";
+import { control, controlDb } from "./db/client.js";
+/** Settings of a runtime that runs alone, kept in the control database. Never secrets. */
+export async function readSetting(key) {
+    const row = await controlDb.query.setting.findFirst({ where: eq(control.setting.key, key) });
+    return row?.value ?? null;
+}
+export async function writeSetting(key, value) {
+    await controlDb
+        .insert(control.setting)
+        .values({ key, value })
+        .onConflictDoUpdate({ target: control.setting.key, set: { value } });
+}
+export async function deleteSetting(key) {
+    await controlDb.delete(control.setting).where(eq(control.setting.key, key));
+}

package/apps/runtime/dist/store/index.js

@@ -0,0 +1,279 @@
+import { newCells, patchCells, rowKey, STORE_LIMITS, } from "@engenty-wizards/shared/store";
+import { cleanPath, mimeForPath } from "@engenty-wizards/shared/workspace";
+import { and, asc, eq, inArray, like, lt, sql } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { db, schema } from "../db/client.js";
+import { env } from "../env.js";
+import { getBlob, putBlob } from "../files/blobs.js";
+import { seal, unseal } from "../secrets/crypto.js";
+export class StoreError extends Error {
+}
+/** The person a run belongs to: the signed-in admin, else the visitor of the shared link. */
+export function holderOf(run) {
+    if (run.userId) {
+        return `u:${run.userId}`;
+    }
+    return run.visitorId ? `v:${run.visitorId}` : `r:${run.id}`;
+}
+export function scopeOf(run) {
+    return { wizardId: run.wizardId, holder: holderOf(run) };
+}
+/** Marks the store as in use; stores nobody came back to are cleaned up. */
+export async function touchStore(scope) {
+    await db
+        .insert(schema.storeHolder)
+        .values({ ...scope, usedAt: new Date() })
+        .onConflictDoUpdate({
+        target: [schema.storeHolder.wizardId, schema.storeHolder.holder],
+        set: { usedAt: new Date() },
+    });
+}
+// --- lists -------------------------------------------------------------------
+const inList = (scope, list) => and(eq(schema.storeRow.wizardId, scope.wizardId), eq(schema.storeRow.holder, scope.holder), eq(schema.storeRow.list, list));
+function toRow(r) {
+    return { id: r.id, cells: r.cells, updatedAt: r.updatedAt.toISOString() };
+}
+export async function listRows(scope, list) {
+    const rows = await db.query.storeRow.findMany({
+        where: inList(scope, list),
+        orderBy: [asc(schema.storeRow.createdAt), asc(schema.storeRow.id)],
+    });
+    return rows.map(toRow);
+}
+/**
+ * Saves rows into a list. With a key column, a row whose key is already there is updated — only
+ * the columns given change, so a step can add "how to get the invoice" without wiping the rest.
+ * A row with a bad value is refused as a whole (`TableColumnValueError` names the column).
+ */
+export async function saveRows(scope, def, input) {
+    let added = 0;
+    let updated = 0;
+    const existing = await db.query.storeRow.findMany({ where: inList(scope, def.id) });
+    const byKey = new Map(existing.filter((r) => r.key).map((r) => [r.key, r]));
+    let count = existing.length;
+    for (const raw of input) {
+        const key = rowKey(def, raw);
+        const hit = key ? byKey.get(key) : undefined;
+        if (hit) {
+            const cells = patchCells(def, hit.cells, raw);
+            await db
+                .update(schema.storeRow)
+                .set({ cells, updatedAt: new Date() })
+                .where(eq(schema.storeRow.id, hit.id));
+            hit.cells = cells;
+            updated++;
+            continue;
+        }
+        const cells = newCells(def, raw);
+        if (Object.values(cells).every((v) => v === null)) {
+            continue;
+        }
+        if (count >= STORE_LIMITS.rowsPerList) {
+            throw new StoreError(`List "${def.id}" is full (${STORE_LIMITS.rowsPerList} rows).`);
+        }
+        const row = { id: nanoid(14), ...scope, list: def.id, key, cells };
+        await db.insert(schema.storeRow).values(row);
+        if (key) {
+            byKey.set(key, { ...row, createdAt: new Date(), updatedAt: new Date() });
+        }
+        count++;
+        added++;
+    }
+    await touchStore(scope);
+    return { added, updated };
+}
+/** Changes cells of one row (the person edited it). */
+export async function updateRow(scope, def, rowId, patch) {
+    const row = await db.query.storeRow.findFirst({
+        where: and(inList(scope, def.id), eq(schema.storeRow.id, rowId)),
+    });
+    if (!row) {
+        return false;
+    }
+    const cells = patchCells(def, row.cells, patch);
+    const key = rowKey(def, cells);
+    const clash = key && key !== row.key
+        ? await db.query.storeRow.findFirst({
+            where: and(inList(scope, def.id), eq(schema.storeRow.key, key)),
+        })
+        : null;
+    if (clash) {
+        throw new StoreError("Diesen Eintrag gibt es schon.");
+    }
+    await db
+        .update(schema.storeRow)
+        .set({ cells, key, updatedAt: new Date() })
+        .where(eq(schema.storeRow.id, rowId));
+    return true;
+}
+/** Deletes rows by id, or by the value of the key column. */
+export async function deleteRows(scope, def, idsOrKeys) {
+    if (!idsOrKeys.length) {
+        return 0;
+    }
+    const keys = idsOrKeys.map((k) => k.trim().toLowerCase());
+    const byId = await db
+        .delete(schema.storeRow)
+        .where(and(inList(scope, def.id), inArray(schema.storeRow.id, idsOrKeys)))
+        .returning({ id: schema.storeRow.id });
+    const byKey = await db
+        .delete(schema.storeRow)
+        .where(and(inList(scope, def.id), inArray(schema.storeRow.key, keys)))
+        .returning({ id: schema.storeRow.id });
+    return byId.length + byKey.length;
+}
+// --- files -------------------------------------------------------------------
+const ownFiles = (scope) => and(eq(schema.storeFile.wizardId, scope.wizardId), eq(schema.storeFile.holder, scope.holder));
+function toFile(r) {
+    return {
+        path: r.path,
+        mime: r.mime,
+        size: r.size,
+        source: r.source,
+        updatedAt: r.updatedAt.toISOString(),
+    };
+}
+/** Any name a model or a mail server comes up with, as a path the store accepts. */
+export function storePath(raw) {
+    const path = raw
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/ß/g, "ss")
+        .split("/")
+        .map((part) => part
+        .trim()
+        .replace(/[^A-Za-z0-9_.-]+/g, "_")
+        .replace(/^[._]+/, "")
+        .slice(0, 80))
+        .filter(Boolean)
+        .join("/");
+    const clean = cleanPath(path);
+    if (!clean) {
+        throw new StoreError(`"${raw}" is not a usable file name.`);
+    }
+    return clean;
+}
+export async function storeFiles(scope, folder) {
+    const rows = await db.query.storeFile.findMany({
+        where: folder
+            ? and(ownFiles(scope), like(schema.storeFile.path, `${folder.replace(/\/+$/, "")}/%`))
+            : ownFiles(scope),
+        orderBy: [asc(schema.storeFile.path)],
+    });
+    return rows.map(toFile);
+}
+export async function readStoreFile(scope, rawPath) {
+    const path = cleanPath(rawPath);
+    const row = path
+        ? await db.query.storeFile.findFirst({
+            where: and(ownFiles(scope), eq(schema.storeFile.path, path)),
+        })
+        : undefined;
+    return row ? { file: toFile(row), data: await getBlob(row.hash) } : null;
+}
+export async function writeStoreFile(scope, rawPath, content, meta = {}) {
+    const path = storePath(rawPath);
+    const data = typeof content === "string" ? Buffer.from(content, "utf8") : Buffer.from(content);
+    if (data.byteLength > STORE_LIMITS.fileBytes) {
+        throw new StoreError(`${path} is larger than 15 MB.`);
+    }
+    const [usage] = await db
+        .select({
+        files: sql `count(*)`,
+        bytes: sql `coalesce(sum(${schema.storeFile.size}), 0)`,
+    })
+        .from(schema.storeFile)
+        .where(ownFiles(scope));
+    if (usage.files >= STORE_LIMITS.files ||
+        usage.bytes + data.byteLength > STORE_LIMITS.totalBytes) {
+        throw new StoreError("The wizard's storage is full.");
+    }
+    const hash = await putBlob(data);
+    const mime = meta.mime && meta.mime !== "application/octet-stream" ? meta.mime : mimeForPath(path);
+    const updatedAt = new Date();
+    await db
+        .insert(schema.storeFile)
+        .values({ ...scope, path, hash, mime, size: data.byteLength, source: meta.source ?? null })
+        .onConflictDoUpdate({
+        target: [schema.storeFile.wizardId, schema.storeFile.holder, schema.storeFile.path],
+        set: { hash, mime, size: data.byteLength, source: meta.source ?? null, updatedAt },
+    });
+    await touchStore(scope);
+    return {
+        path,
+        mime,
+        size: data.byteLength,
+        source: meta.source ?? null,
+        updatedAt: updatedAt.toISOString(),
+    };
+}
+export async function deleteStoreFile(scope, rawPath) {
+    const path = cleanPath(rawPath);
+    if (!path) {
+        return false;
+    }
+    const gone = await db
+        .delete(schema.storeFile)
+        .where(and(ownFiles(scope), eq(schema.storeFile.path, path)))
+        .returning({ path: schema.storeFile.path });
+    return gone.length > 0;
+}
+// --- secrets -----------------------------------------------------------------
+const ownSecrets = (scope) => and(eq(schema.storeSecret.wizardId, scope.wizardId), eq(schema.storeSecret.holder, scope.holder));
+export async function getSecret(scope, slot) {
+    const row = await db.query.storeSecret.findFirst({
+        where: and(ownSecrets(scope), eq(schema.storeSecret.slot, slot)),
+    });
+    const data = row ? unseal(row.data) : null;
+    return row && data
+        ? { provider: row.provider, label: row.label, data, createdAt: row.createdAt }
+        : null;
+}
+export async function putSecret(scope, slot, provider, label, data) {
+    const sealed = seal(data);
+    await db
+        .insert(schema.storeSecret)
+        .values({ id: nanoid(14), ...scope, slot, provider, label, data: sealed })
+        .onConflictDoUpdate({
+        target: [schema.storeSecret.wizardId, schema.storeSecret.holder, schema.storeSecret.slot],
+        set: { provider, label, data: sealed, updatedAt: new Date() },
+    });
+    await touchStore(scope);
+}
+export async function deleteSecret(scope, slot) {
+    await db
+        .delete(schema.storeSecret)
+        .where(and(ownSecrets(scope), eq(schema.storeSecret.slot, slot)));
+}
+export async function listSecrets(scope) {
+    const rows = await db.query.storeSecret.findMany({ where: ownSecrets(scope) });
+    return rows.map((r) => ({
+        slot: r.slot,
+        provider: r.provider,
+        label: r.label,
+        createdAt: r.createdAt.toISOString(),
+    }));
+}
+// --- everything --------------------------------------------------------------
+/** Deletes everything the wizard keeps for this person. Blobs stay: other files may share them. */
+export async function clearStore(scope) {
+    await db
+        .delete(schema.storeRow)
+        .where(and(eq(schema.storeRow.wizardId, scope.wizardId), eq(schema.storeRow.holder, scope.holder)));
+    await db.delete(schema.storeFile).where(ownFiles(scope));
+    await db.delete(schema.storeSecret).where(ownSecrets(scope));
+    await db
+        .delete(schema.storeHolder)
+        .where(and(eq(schema.storeHolder.wizardId, scope.wizardId), eq(schema.storeHolder.holder, scope.holder)));
+}
+/** Stores nobody used for STORE_TTL_DAYS are deleted — a visitor's cookie is long gone by then. */
+export async function purgeUnusedStores() {
+    const cutoff = new Date(Date.now() - env.limits.storeTtlDays * 24 * 60 * 60 * 1000);
+    const stale = await db.query.storeHolder.findMany({
+        where: lt(schema.storeHolder.usedAt, cutoff),
+    });
+    for (const scope of stale) {
+        await clearStore(scope);
+    }
+    return stale.length;
+}