@engenty/wizards-runtime 0.0.0-stage → 0.7.6

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

@@ -0,0 +1,456 @@
+import { createHash } from "node:crypto";
+import { note } from "@engenty-wizards/shared/run";
+import { and, asc, eq, inArray, isNotNull, isNull, like } from "drizzle-orm";
+import { accountToken, linkedAccount } from "../auth/account.js";
+import { control, controlDb, db, schema } from "../db/client.js";
+import { env } from "../env.js";
+import { getBlob } from "../files/blobs.js";
+import { managed } from "../manage.js";
+import { deleteSetting, readSetting, writeSetting } from "../settings.js";
+import { currentTenant } from "../tenants/tenant.js";
+import { mainLogoId } from "./brand.js";
+import { ServiceError } from "./errors.js";
+import { projectFileContent, projectFiles } from "./project-files.js";
+import { ownedProject } from "./projects.js";
+import { ownedWizard, publishedVersion, publishWizard } from "./wizards.js";
+const key = (wizardId) => `cloud:${wizardId}`;
+const EMPTY = { copy: null, error: null };
+/** Whether this runtime sends what it publishes: it runs alone and an account is linked. */
+export async function cloudLinked() {
+    return !managed && Boolean(await linkedAccount());
+}
+/** Where a local wizard stands in the cloud. */
+export async function cloudState(wizardId) {
+    return (await readSetting(key(wizardId))) ?? EMPTY;
+}
+async function call(method, path, body, timeoutMs = 30_000) {
+    const token = await accountToken();
+    if (!token) {
+        throw new ServiceError("refused", note("accountSignedOut"), {
+            reason: "signed_out",
+        });
+    }
+    const res = await fetch(`${env.local.cloudUrl}/api/v1${path}`, {
+        method,
+        headers: {
+            authorization: `Bearer ${token}`,
+            ...(body === undefined ? {} : { "content-type": "application/json" }),
+        },
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: AbortSignal.timeout(timeoutMs),
+    }).catch(() => null);
+    if (!res) {
+        throw new ServiceError("refused", note("cloudNotReachedRight"), {
+            reason: "unreachable",
+        });
+    }
+    const parsed = (await res.json().catch(() => ({})));
+    return { ok: res.ok, status: res.status, body: parsed };
+}
+function refusal(answer, fallback) {
+    const { error, reason, ...rest } = answer.body;
+    const message = answer.status === 401
+        ? note("accountSignedOut")
+        : typeof error === "string" && error
+            ? error
+            : fallback;
+    return new ServiceError("refused", message, {
+        reason: answer.status === 401 ? "signed_out" : typeof reason === "string" ? reason : "refused",
+        status: answer.status,
+        ...(Array.isArray(rest.spaces) ? { spaces: rest.spaces } : {}),
+    });
+}
+/** A try is made again by itself when the cloud, not what was sent, was the trouble. */
+function worthAnotherTry(err) {
+    if (!(err instanceof ServiceError)) {
+        return true;
+    }
+    const status = typeof err.data.status === "number" ? err.data.status : 0;
+    return err.data.reason === "unreachable" || status >= 500 || status === 429;
+}
+/** A minute, then twice as long each time, up to an hour. */
+function nextTry(tries, from) {
+    const minutes = Math.min(60, 2 ** (tries - 1));
+    return new Date(from.getTime() + minutes * 60_000).toISOString();
+}
+/** The project as the cloud keeps it: its name, what it says about itself, its logo. */
+async function spaceOf(userId, projectId) {
+    const project = await ownedProject(userId, projectId);
+    const logoId = await mainLogoId(project.id);
+    const logo = logoId ? await projectFileContent(project.id, logoId).catch(() => null) : null;
+    return {
+        name: project.name,
+        brand: {
+            name: project.brand.name,
+            about: project.brand.about,
+            colors: project.brand.colors,
+        },
+        facts: project.facts,
+        logo: logo
+            ? {
+                name: logo.row.name,
+                mime: logo.row.mime,
+                description: logo.row.description,
+                data: Buffer.from(logo.data).toString("base64"),
+            }
+            : null,
+    };
+}
+/** The space's own tables and pages, as they are sent: not what a wizard's runs keep. */
+async function spaceDataOf(projectId) {
+    const own = (table) => and(eq(table.projectId, projectId), isNull(table.wizardId));
+    const tables = await db.query.spaceTable.findMany({
+        where: own(schema.spaceTable),
+        orderBy: [asc(schema.spaceTable.id)],
+    });
+    const rows = tables.length
+        ? await db.query.spaceTableRow.findMany({
+            where: inArray(schema.spaceTableRow.tableId, tables.map((t) => t.id)),
+            orderBy: [asc(schema.spaceTableRow.createdAt), asc(schema.spaceTableRow.id)],
+        })
+        : [];
+    const pages = await db.query.spacePage.findMany({
+        where: own(schema.spacePage),
+        orderBy: [asc(schema.spacePage.id)],
+    });
+    const categories = await db.query.spaceCategory.findMany({
+        where: and(eq(schema.spaceCategory.projectId, projectId), eq(schema.spaceCategory.proposed, false)),
+        orderBy: [asc(schema.spaceCategory.position), asc(schema.spaceCategory.id)],
+    });
+    const values = categories.length
+        ? await db.query.spaceCategoryValue.findMany({
+            where: inArray(schema.spaceCategoryValue.categoryId, categories.map((c) => c.id)),
+            orderBy: [asc(schema.spaceCategoryValue.position), asc(schema.spaceCategoryValue.id)],
+        })
+        : [];
+    const assignments = categories.length
+        ? await db.query.spaceItemCategory.findMany({
+            where: and(eq(schema.spaceItemCategory.projectId, projectId), isNull(schema.spaceItemCategory.fileId)),
+            orderBy: [asc(schema.spaceItemCategory.id)],
+        })
+        : [];
+    const tableIds = new Set(tables.map((t) => t.id));
+    const rowIds = new Set(rows.map((r) => r.id));
+    const pageIds = new Set(pages.map((p) => p.id));
+    return {
+        tables: tables.map((t) => ({
+            id: t.id,
+            title: t.title,
+            format: t.format,
+            originLabel: t.originLabel,
+            columns: t.columns,
+            rows: rows.filter((r) => r.tableId === t.id).map((r) => ({ id: r.id, cells: r.cells })),
+        })),
+        pages: pages.map((p) => ({
+            id: p.id,
+            title: p.title,
+            markdown: p.markdown,
+            parentId: p.parentId,
+            position: p.position,
+            originLabel: p.originLabel,
+        })),
+        categories: categories.map((c) => ({
+            id: c.id,
+            name: c.name,
+            type: c.type,
+            unit: c.unit,
+            multiple: c.multiple,
+            ordered: c.ordered,
+            hint: c.hint,
+            tableId: c.tableId && tableIds.has(c.tableId) ? c.tableId : null,
+            columnId: c.tableId && tableIds.has(c.tableId) ? c.columnId : null,
+            position: c.position,
+            values: values
+                .filter((v) => v.categoryId === c.id)
+                .map((v) => ({ id: v.id, value: v.value, position: v.position, summary: v.summary })),
+        })),
+        // Only what goes along: a page, a table or a row of it.
+        assignments: assignments
+            .filter((a) => (a.pageId && pageIds.has(a.pageId)) ||
+            (a.tableId && tableIds.has(a.tableId)) ||
+            (a.rowId && rowIds.has(a.rowId)))
+            .map((a) => ({
+            categoryId: a.categoryId,
+            item: a.pageId ? `p:${a.pageId}` : a.tableId ? `t:${a.tableId}` : `r:${a.rowId}`,
+            valueId: a.valueId,
+            text: a.text,
+            num: a.num,
+            at: a.at,
+            bool: a.bool,
+            by: a.by,
+        })),
+    };
+}
+/**
+ * Sends the space's own tables and pages along with a wizard, when they changed since they last
+ * arrived. A sending that fails is tried with the next wizard; the wizard is there either way.
+ */
+async function syncSpaceDataToCloud(projectId) {
+    const data = await spaceDataOf(projectId);
+    const hash = createHash("sha256").update(JSON.stringify(data)).digest("hex");
+    const sent = `cloud-data:${projectId}`;
+    if ((await readSetting(sent)) === hash) {
+        return;
+    }
+    try {
+        const answer = await call("PUT", `/spaces/${projectId}/data`, data, 120_000);
+        if (answer.ok) {
+            await writeSetting(sent, hash);
+        }
+        else {
+            console.error("[cloud] the space's data was not taken:", answer.status, answer.body);
+        }
+    }
+    catch (err) {
+        console.error("[cloud] sending the space's data failed:", err);
+    }
+}
+/**
+ * Sends a wizard's published version to the cloud: the same wizard again updates its copy
+ * there, whose link stays. What came back is kept; a try that failed is kept as such beside
+ * the copy from before. The space's own tables and pages follow it.
+ */
+export async function syncToCloud(userId, wizardId) {
+    const w = await ownedWizard(userId, wizardId);
+    const version = await publishedVersion(w);
+    if (!version) {
+        throw new ServiceError("refused", note("publishWizardFirst"));
+    }
+    const before = await cloudState(w.id);
+    try {
+        const files = await Promise.all(version.files.map(async (f) => ({
+            path: f.path,
+            mime: f.mime,
+            data: (await getBlob(f.hash)).toString("base64"),
+        })));
+        const answer = await call("PUT", `/spaces/${w.projectId}/wizards/${w.id}`, {
+            space: await spaceOf(userId, w.projectId),
+            version: version.version,
+            definition: version.definition,
+            files,
+            shareEnabled: w.shareEnabled,
+            dailyRunLimit: w.dailyRunLimit,
+        }, 120_000);
+        if (!answer.ok || !answer.body.shareUrl) {
+            throw refusal(answer, "The cloud did not take the wizard.");
+        }
+        const state = {
+            copy: {
+                shareUrl: answer.body.shareUrl,
+                code: answer.body.code,
+                version: version.version,
+                publishedVersion: answer.body.publishedVersion,
+                runnable: answer.body.runnable,
+                problems: answer.body.problems ?? [],
+                syncedAt: new Date().toISOString(),
+            },
+            error: null,
+        };
+        await writeSetting(key(w.id), state);
+        await syncSpaceDataToCloud(w.projectId);
+        return state;
+    }
+    catch (err) {
+        const now = new Date();
+        const tries = (before.error?.tries ?? 0) + 1;
+        const failed = {
+            copy: before.copy,
+            error: {
+                message: err instanceof ServiceError ? err.message : "Sending did not work.",
+                reason: err instanceof ServiceError ? err.data.reason : undefined,
+                at: now.toISOString(),
+                tries,
+                again: worthAnotherTry(err) ? nextTry(tries, now) : null,
+            },
+        };
+        await writeSetting(key(w.id), failed);
+        if (!(err instanceof ServiceError)) {
+            console.error("[cloud] sync failed:", err);
+        }
+        return failed;
+    }
+}
+/**
+ * Publishes here and, with an account linked, sends the version on. The cloud never holds the
+ * publishing up or back: what it answered comes along as `cloud`.
+ */
+export async function publishAndSync(userId, wizardId) {
+    const published = await publishWizard(userId, wizardId);
+    const cloud = (await cloudLinked()) ? await syncToCloud(userId, wizardId) : null;
+    return { ...published, cloud };
+}
+/** How a wizard is shared changed here: the copy in the cloud follows. */
+export async function pushSharing(userId, wizardId) {
+    if (!(await cloudLinked())) {
+        return;
+    }
+    const state = await cloudState(wizardId);
+    if (!state.copy) {
+        return;
+    }
+    const w = await ownedWizard(userId, wizardId);
+    await call("PATCH", `/spaces/${w.projectId}/wizards/${w.id}`, {
+        shareEnabled: w.shareEnabled,
+        dailyRunLimit: w.dailyRunLimit,
+        translate: w.translate,
+        ...(w.runners ? { runners: w.runners } : {}),
+    }).catch((err) => console.error("[cloud] sharing not sent:", err.message));
+}
+/**
+ * A new link was made here: the copy in the cloud gets a new one too, and its old one stops
+ * answering. Null where no account is linked; the state as it was where the cloud has no copy.
+ */
+export async function rotateInCloud(userId, wizardId) {
+    if (!(await cloudLinked())) {
+        return null;
+    }
+    const state = await cloudState(wizardId);
+    if (!state.copy) {
+        return state;
+    }
+    const w = await ownedWizard(userId, wizardId);
+    const answer = await call("POST", `/spaces/${w.projectId}/wizards/${w.id}/rotate-link`);
+    if (!answer.ok || !answer.body.shareUrl) {
+        throw refusal(answer, "The link in the cloud could not be renewed.");
+    }
+    const next = {
+        ...state,
+        copy: { ...state.copy, shareUrl: answer.body.shareUrl, code: answer.body.code },
+    };
+    await writeSetting(key(w.id), next);
+    return next;
+}
+/** A wizard is about to be deleted here: its copy in the cloud goes too. */
+export async function removeFromCloud(userId, wizardId) {
+    const state = await cloudState(wizardId);
+    if (!state.copy && !state.error) {
+        return;
+    }
+    const w = await ownedWizard(userId, wizardId).catch(() => null);
+    await deleteSetting(key(wizardId));
+    if (!w || !state.copy || !(await cloudLinked())) {
+        return;
+    }
+    await call("DELETE", `/spaces/${w.projectId}/wizards/${w.id}`).catch((err) => console.error("[cloud] copy not removed:", err.message));
+}
+/**
+ * Sends again what did not arrive and is due for another try. Called every minute by the
+ * runtime that runs alone; a wizard that is gone meanwhile is forgotten.
+ */
+export async function retryFailedSends(userId) {
+    if (!(await cloudLinked())) {
+        return;
+    }
+    const now = new Date().toISOString();
+    const rows = await controlDb
+        .select({ key: control.setting.key, value: control.setting.value })
+        .from(control.setting)
+        .where(like(control.setting.key, "cloud:%"));
+    for (const row of rows) {
+        const state = row.value;
+        if (!state.error?.again || state.error.again > now) {
+            continue;
+        }
+        const wizardId = row.key.slice("cloud:".length);
+        const w = await ownedWizard(userId, wizardId).catch(() => null);
+        if (!w?.publishedVersion) {
+            await deleteSetting(row.key);
+            continue;
+        }
+        const sent = await syncToCloud(userId, wizardId);
+        // Something the person has to see to (signed out, no room) holds for every wizard.
+        if (sent.error && !sent.error.again) {
+            break;
+        }
+    }
+}
+/** The account was unlinked: what this runtime kept of its cloud belongs to no account now. */
+export async function forgetCloud() {
+    await controlDb.delete(control.setting).where(like(control.setting.key, "cloud:%"));
+    await forgetSentData();
+}
+/** The space's data counts as not sent: the next wizard takes it along again. */
+async function forgetSentData() {
+    await controlDb.delete(control.setting).where(like(control.setting.key, "cloud-data:%"));
+}
+/** Sends every published wizard: once after an account was linked. */
+export async function syncAllToCloud(userId) {
+    // A cloud that was linked anew, or whose spaces were replaced, has none of it.
+    await forgetSentData();
+    const wizards = await db
+        .select({ id: schema.wizard.id })
+        .from(schema.wizard)
+        .where(and(eq(schema.wizard.tenantId, currentTenant()), isNotNull(schema.wizard.publishedVersion)));
+    let sent = 0;
+    let failed = 0;
+    for (const [i, { id }] of wizards.entries()) {
+        const state = await syncToCloud(userId, id);
+        if (state.error) {
+            failed++;
+            // A refusal that holds for every wizard (no room, signed out) is not asked again; a cloud
+            // out of reach neither, but the rest is then tried again later, with this one.
+            if (state.error.reason && state.error.reason !== "refused") {
+                for (const rest of wizards.slice(i + 1)) {
+                    failed++;
+                    await writeSetting(key(rest.id), {
+                        copy: (await cloudState(rest.id)).copy,
+                        error: state.error,
+                    });
+                }
+                break;
+            }
+        }
+        else {
+            sent++;
+        }
+    }
+    return { sent, failed };
+}
+/** What the cloud would lack for the draft, asked before it is published. */
+export async function checkForCloud(userId, wizardId) {
+    const w = await ownedWizard(userId, wizardId);
+    const files = await db
+        .select({ path: schema.wizardFile.path })
+        .from(schema.wizardFile)
+        .where(eq(schema.wizardFile.wizardId, w.id));
+    const answer = await call("POST", "/spaces/check", {
+        definition: w.draft,
+        files: files.map((f) => f.path),
+    });
+    if (!answer.ok) {
+        throw refusal(answer, "The cloud did not answer.");
+    }
+    const documents = await projectFiles(w.projectId, "document");
+    return {
+        problems: answer.body.problems ?? [],
+        documents: documents.length > 0 && w.draft.steps.some((s) => s.type === "agent"),
+    };
+}
+/** The projects the account's cloud holds of local installs: this one's, or another machine's. */
+export async function cloudSpaces() {
+    const answer = await call("GET", "/spaces");
+    if (!answer.ok) {
+        throw refusal(answer, "The cloud did not answer.");
+    }
+    return answer.body.spaces ?? [];
+}
+/**
+ * Makes room for this install's project: the projects of other installs go from the cloud, with
+ * their links, then everything published here is sent. For the person who moved to a new
+ * machine or installed anew.
+ */
+export async function replaceCloudSpaces(userId) {
+    const mine = new Set((await db
+        .select({ id: schema.project.id })
+        .from(schema.project)
+        .where(eq(schema.project.tenantId, currentTenant()))).map((p) => p.id));
+    for (const space of await cloudSpaces()) {
+        if (!mine.has(space.id)) {
+            const answer = await call("DELETE", `/spaces/${space.id}`);
+            if (!answer.ok) {
+                throw refusal(answer, "The space in the cloud could not be removed.");
+            }
+        }
+    }
+    return syncAllToCloud(userId);
+}

package/apps/runtime/dist/services/draft-events.js

@@ -0,0 +1,27 @@
+import { EventEmitter } from "node:events";
+const bus = new EventEmitter();
+bus.setMaxListeners(0);
+export function emitDraftChanged(change) {
+    bus.emit(change.wizardId, change);
+}
+export function subscribeDraft(wizardId, listener) {
+    bus.on(wizardId, listener);
+    return () => bus.off(wizardId, listener);
+}
+/** Steps that are new or differ in `after`. */
+export function changedSteps(before, after) {
+    const old = new Map(before.steps.map((s) => [s.id, JSON.stringify(s)]));
+    return after.steps.filter((s) => old.get(s.id) !== JSON.stringify(s)).map((s) => s.id);
+}
+/** A workspace file was written or removed. Files carry no revision; the draft's is passed along. */
+export function filesChanged(w, path) {
+    return {
+        wizardId: w.id,
+        kind: "files",
+        revision: w.revision,
+        source: "studio",
+        client: null,
+        note: null,
+        touched: [path],
+    };
+}

package/apps/runtime/dist/services/engenty-shapes.js

@@ -0,0 +1,71 @@
+// Written by apps/web/scripts/engenty-shapes.tsx from apps/web/src/engenty — do not edit by hand.
+export const ENGENTY_KINDS = ["round", "drop", "dome", "flame", "oval", "bean", "pebble", "sprout", "tower", "wedge"];
+/** Each kind's fill in oklch, as the web writes it: the stage of a wizard takes its hue. */
+export const ENGENTY_FILL_OKLCH = {
+    "round": "oklch(60% 0.23 262)",
+    "drop": "oklch(82% 0.17 78)",
+    "dome": "oklch(72% 0.22 145)",
+    "flame": "oklch(64% 0.25 18)",
+    "oval": "oklch(70% 0.21 42)",
+    "bean": "oklch(74% 0.16 192)",
+    "pebble": "oklch(66% 0.13 235)",
+    "sprout": "oklch(89% 0.2 118)",
+    "tower": "oklch(60% 0.25 300)",
+    "wedge": "oklch(65% 0.28 345)"
+};
+/** Still SVG, 120 × 120. */
+export const ENGENTY_SVG = {
+    "round": "<svg viewBox=\"0 0 120 120\"><g><path fill=\"#2873ff\" d=\"M60 22 Q96 26 96 62 Q96 96 60 100 Q24 96 24 62 Q24 26 60 22 Z\"></path><circle cx=\"97\" cy=\"34\" fill=\"#2873ff\" opacity=\"0.5\" r=\"6\"></circle><circle cx=\"106\" cy=\"24\" fill=\"#2873ff\" opacity=\"0.35\" r=\"3.5\"></circle><g><ellipse cx=\"68\" cy=\"58\" fill=\"#fff\" rx=\"8\" ry=\"9.2\"></ellipse><circle cx=\"68\" cy=\"59\" fill=\"#000e34\" r=\"3.84\"></circle><circle cx=\"66\" cy=\"55.6\" fill=\"#fff\" r=\"1.44\"></circle></g></g></svg>",
+    "drop": "<svg viewBox=\"0 0 120 120\"><g><path fill=\"#ffb407\" d=\"M60 16 Q90 34 90 66 Q90 96 60 98 Q30 96 30 66 Q30 34 60 16 Z\"></path><g><ellipse cx=\"60\" cy=\"56\" fill=\"#fff\" rx=\"8\" ry=\"9.2\"></ellipse><circle cx=\"60\" cy=\"57\" fill=\"#501c00\" r=\"3.84\"></circle><circle cx=\"58\" cy=\"53.6\" fill=\"#fff\" r=\"1.44\"></circle></g><path d=\"M48 76 Q54 72 60 76 Q66 80 72 76\" fill=\"none\" stroke=\"#511a00\" stroke-linecap=\"round\" stroke-width=\"2.6\"></path></g></svg>",
+    "dome": "<svg viewBox=\"0 0 120 120\"><g><path fill=\"#19c63c\" d=\"M60 20 Q92 30 92 70 Q92 96 60 96 Q28 96 28 70 Q28 30 60 20 Z\"></path><path d=\"M46 90 L46 80 M60 92 L60 82 M74 90 L74 80\" opacity=\"0.5\" stroke=\"#003610\" stroke-linecap=\"round\" stroke-width=\"2.4\"></path><circle cx=\"60\" cy=\"6\" fill=\"#19c63c\" r=\"3\"></circle><g><ellipse cx=\"60\" cy=\"54\" fill=\"#fff\" rx=\"8.5\" ry=\"9.774999999999999\"></ellipse><circle cx=\"60\" cy=\"55\" fill=\"#001602\" r=\"4.08\"></circle><circle cx=\"57.875\" cy=\"51.45\" fill=\"#fff\" r=\"1.53\"></circle></g></g></svg>",
+    "flame": "<svg viewBox=\"0 0 120 120\"><g><path fill=\"#ff154f\" d=\"M60 14 Q84 44 80 76 Q78 98 60 98 Q42 98 40 76 Q36 44 60 14 Z\"></path><path d=\"M40 20 Q60 6 80 20\" fill=\"none\" opacity=\"0.55\" stroke=\"#ff154f\" stroke-linecap=\"round\" stroke-width=\"3\"></path><g><ellipse cx=\"60\" cy=\"62\" fill=\"#fff\" rx=\"8\" ry=\"9.2\"></ellipse><circle cx=\"60\" cy=\"63\" fill=\"#3d0007\" r=\"3.84\"></circle><circle cx=\"58\" cy=\"59.6\" fill=\"#fff\" r=\"1.44\"></circle></g><circle cx=\"60\" cy=\"82\" fill=\"#3d0007\" r=\"2.6\"></circle></g></svg>",
+    "oval": "<svg viewBox=\"0 0 120 120\"><g><path fill=\"#ff6404\" d=\"M60 34 Q100 38 100 64 Q100 92 60 94 Q20 92 20 64 Q20 38 60 34 Z\"></path><g fill=\"none\" opacity=\"0.45\" stroke=\"#8a0700\" stroke-width=\"2.2\"><path d=\"M28 54 Q60 48 92 54\"></path><path d=\"M26 70 Q60 64 94 70\"></path></g><g><ellipse cx=\"66\" cy=\"58\" fill=\"#fff\" rx=\"8\" ry=\"9.2\"></ellipse><circle cx=\"66\" cy=\"59\" fill=\"#430000\" r=\"3.84\"></circle><circle cx=\"64\" cy=\"55.6\" fill=\"#fff\" r=\"1.44\"></circle></g></g></svg>",
+    "bean": "<svg viewBox=\"0 0 120 120\"><g><path fill=\"#00c9c5\" d=\"M48 96 Q24 92 26 68 Q28 44 52 38 Q78 32 88 50 Q98 66 84 84 Q70 100 48 96 Z\"></path><circle cx=\"32\" cy=\"94\" fill=\"#00c9c5\" opacity=\"0.4\" r=\"4\"></circle><g><ellipse cx=\"70\" cy=\"58\" fill=\"#fff\" rx=\"8\" ry=\"9.2\"></ellipse><circle cx=\"70\" cy=\"59\" fill=\"#001a1f\" r=\"3.84\"></circle><circle cx=\"68\" cy=\"55.6\" fill=\"#fff\" r=\"1.44\"></circle></g></g></svg>",
+    "pebble": "<svg viewBox=\"0 0 120 120\"><g><path fill=\"#259ed6\" d=\"M60 96 Q20 96 18 78 Q16 60 46 56 Q78 52 98 62 Q110 72 104 86 Q98 96 60 96 Z\"></path><g fill=\"#163045\" opacity=\"0.32\"><circle cx=\"42\" cy=\"76\" r=\"3\"></circle><circle cx=\"56\" cy=\"86\" r=\"2.2\"></circle><circle cx=\"86\" cy=\"80\" r=\"2.6\"></circle></g><g><ellipse cx=\"68\" cy=\"72\" fill=\"#fff\" rx=\"7.5\" ry=\"8.625\"></ellipse><circle cx=\"68\" cy=\"73\" fill=\"#00182f\" r=\"3.5999999999999996\"></circle><circle cx=\"66.125\" cy=\"69.75\" fill=\"#fff\" r=\"1.3499999999999999\"></circle></g></g></svg>",
+    "sprout": "<svg viewBox=\"0 0 120 120\"><g><g fill=\"#d0eb24\"><ellipse cx=\"48\" cy=\"34\" rx=\"6\" ry=\"10\"></ellipse><ellipse cx=\"72\" cy=\"32\" rx=\"5.5\" ry=\"9\"></ellipse></g><path fill=\"#d0eb24\" d=\"M60 100 Q28 98 28 72 Q28 46 60 44 Q92 46 92 72 Q92 98 60 100 Z\"></path><g><ellipse cx=\"60\" cy=\"68\" fill=\"#fff\" rx=\"8.5\" ry=\"9.774999999999999\"></ellipse><circle cx=\"60\" cy=\"69\" fill=\"#242100\" r=\"4.08\"></circle><circle cx=\"57.875\" cy=\"65.45\" fill=\"#fff\" r=\"1.53\"></circle></g></g></svg>",
+    "tower": "<svg viewBox=\"0 0 120 120\"><g><path fill=\"#9b48fb\" d=\"M60 102 Q36 100 38 78 Q40 58 42 44 Q44 26 60 24 Q76 26 78 44 Q80 58 82 78 Q84 100 60 102 Z\"></path><g fill=\"none\" opacity=\"0.4\" stroke=\"#37164e\" stroke-linecap=\"round\" stroke-width=\"2.2\"><path d=\"M42 74 Q60 70 78 74\"></path><path d=\"M40 88 Q60 84 80 88\"></path></g><g><ellipse cx=\"60\" cy=\"52\" fill=\"#fff\" rx=\"8\" ry=\"9.2\"></ellipse><circle cx=\"60\" cy=\"53\" fill=\"#210434\" r=\"3.84\"></circle><circle cx=\"58\" cy=\"49.6\" fill=\"#fff\" r=\"1.44\"></circle></g></g></svg>",
+    "wedge": "<svg viewBox=\"0 0 120 120\"><g><path fill=\"#f800b5\" d=\"M60 30 Q74 40 86 70 Q96 92 78 98 Q60 102 42 98 Q24 92 34 70 Q46 40 60 30 Z\"></path><path d=\"M52 22 Q60 14 68 22\" fill=\"none\" opacity=\"0.5\" stroke=\"#f800b5\" stroke-linecap=\"round\" stroke-width=\"3\"></path><g><ellipse cx=\"60\" cy=\"70\" fill=\"#fff\" rx=\"8\" ry=\"9.2\"></ellipse><circle cx=\"60\" cy=\"71\" fill=\"#370025\" r=\"3.84\"></circle><circle cx=\"58\" cy=\"67.6\" fill=\"#fff\" r=\"1.44\"></circle></g></g></svg>"
+};
+/** The line each kind stands on (`cy`) and its shadow's half width, in the same 120 × 120. */
+export const ENGENTY_SHADOW = {
+    "round": {
+        "cy": 108,
+        "rx": 26
+    },
+    "drop": {
+        "cy": 106,
+        "rx": 24
+    },
+    "dome": {
+        "cy": 104,
+        "rx": 27
+    },
+    "flame": {
+        "cy": 106,
+        "rx": 22
+    },
+    "oval": {
+        "cy": 102,
+        "rx": 32
+    },
+    "bean": {
+        "cy": 102,
+        "rx": 26
+    },
+    "pebble": {
+        "cy": 102,
+        "rx": 34
+    },
+    "sprout": {
+        "cy": 106,
+        "rx": 26
+    },
+    "tower": {
+        "cy": 108,
+        "rx": 20
+    },
+    "wedge": {
+        "cy": 106,
+        "rx": 28
+    }
+};

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

@@ -0,0 +1,29 @@
+import { note } from "@engenty-wizards/shared/run";
+import { errorText, NotedError } from "../model-errors.js";
+const STATUS = {
+    not_found: 404,
+    invalid: 400,
+    has_issues: 400,
+    revision_conflict: 409,
+    no_credits: 402,
+    refused: 400,
+    read_only: 403,
+    forbidden: 403,
+};
+export class ServiceError extends NotedError {
+    code;
+    data;
+    constructor(code, said, data = {}) {
+        super(said);
+        this.code = code;
+        this.data = data;
+    }
+    get status() {
+        return STATUS[this.code];
+    }
+    /** The answer, its words in the asker's language; English where none is known. */
+    toJSON(lang = "en") {
+        return { error: errorText(this, lang), code: this.code, ...this.data };
+    }
+}
+export const notFound = () => new ServiceError("not_found", note("notFound"));