wizards 0.5.7 → 0.5.9

package/apps/runtime/dist/services/knowledge-model.js

@@ -1,5 +1,5 @@
 import { dayOf, slugOf } from "@engenty-wizards/shared/knowledge";
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { columnIdOf } from "@engenty-wizards/shared/space-data";
 import { generateText, Output } from "ai";
 import { and, eq, inArray, isNull } from "drizzle-orm";
@@ -504,12 +504,12 @@ export async function writeSummary(valueId) {
         where: eq(schema.spaceCategoryValue.id, valueId),
     });
     if (!value) {
-        throw new ServiceError("not_found", bilingual("Diesen Wert gibt es nicht.", "This value doesn’t exist."));
+        throw new ServiceError("not_found", note("valueNotExist"));
     }
     const category = await categoryRow(value.categoryId);
     const { items, total } = await itemsOfValue(value.id);
     if (!items.length) {
-        throw new ServiceError("invalid", bilingual("Unter diesem Wert steht noch nichts.", "Nothing is filed under this value yet."));
+        throw new ServiceError("invalid", note("nothingFiledUnderValue"));
     }
     const model = await textModel("standard");
     const result = await generateText({

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

@@ -4,7 +4,7 @@ import { DEFINITION_VERSION, readable, wizardSchema, } from "@engenty-wizards/sh
 import { capabilitiesOf, costTierOf, effortOf, formatsOf, MARKETPLACE_LANGS, pluginsOf, } from "@engenty-wizards/shared/marketplace";
 import { wizardOutline } from "@engenty-wizards/shared/marketplace-entry";
 import { searchEntries } from "@engenty-wizards/shared/marketplace-search";
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { and, eq, inArray, notInArray } from "drizzle-orm";
 import { formulaEstimate } from "../credits/estimate.js";
 import { control, controlDb, db, schema, withTenant } from "../db/client.js";
@@ -414,13 +414,13 @@ export async function marketplaceWizard(id, lang) {
         return null;
     }
     if (!readable(found.definition)) {
-        throw new ServiceError("refused", bilingual("Diese Vorlage braucht eine neuere Version von engenty wizards. Aktualisiere zuerst engenty wizards.", "This template needs a newer version of engenty wizards. Update engenty wizards first."));
+        throw new ServiceError("refused", note("templateNeedsNewerVersion"));
     }
     // A wizard whose plugins are not here would stop at its first step that uses them.
     const have = await pluginIdsOf(currentTenant());
     const needs = pluginsOf(wizardSchema.parse(found.definition)).filter((p) => !have.has(p));
     if (needs.length) {
-        throw new ServiceError("refused", bilingual(`Diese Vorlage braucht ${needs.length === 1 ? "das Plugin" : "die Plugins"} ${needs.join(", ")}: bei Pro auf engenty.ai dabei.`, `This template needs the ${needs.length === 1 ? "plugin" : "plugins"} ${needs.join(", ")}: included with Pro on engenty.ai.`));
+        throw new ServiceError("refused", note("templateNeedsPlugins", { count: needs.length, plugins: needs }));
     }
     return {
         id: found.id,

package/apps/runtime/dist/services/package-file.js

@@ -1,4 +1,4 @@
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { manifestSchema, PACKAGE_FILES, PACKAGE_FORMAT, PACKAGE_MANIFEST, PACKAGE_MAX_BYTES, } from "@engenty-wizards/shared/wizard-package";
 import { cleanPath, WORKSPACE_LIMITS } from "@engenty-wizards/shared/workspace";
 import { strFromU8, unzipSync } from "fflate";
@@ -13,7 +13,7 @@ export function json(data) {
         return JSON.parse(strFromU8(data));
     }
     catch {
-        throw invalid(bilingual("Das ist keine Wizard-Datei: Die wizard.json darin lässt sich nicht lesen.", "This isn’t a wizard file: its wizard.json can’t be read."));
+        throw invalid(note("wizardJsonUnreadable"));
     }
 }
 /** A manifest, or a bare definition: a wizard without workspace is fully told by its JSON. */
@@ -23,7 +23,7 @@ export function readManifest(raw) {
     }
     const parsed = manifestSchema.safeParse(raw);
     if (!parsed.success) {
-        throw invalid(bilingual("Diese Wizard-Datei stammt aus einer neueren Version oder ist beschädigt. Aktualisiere engenty wizards oder exportiere den Wizard neu.", "This wizard file comes from a newer version, or it’s damaged. Update engenty wizards or export the wizard again."));
+        throw invalid(note("wizardFileComesNewer"));
     }
     return parsed.data;
 }
@@ -46,26 +46,24 @@ export function readPackage(data) {
                 total += file.originalSize;
                 count += 1;
                 if (file.originalSize > WORKSPACE_LIMITS.fileBytes) {
-                    throw invalid(bilingual(`${file.name} ist größer als 5 MB.`, `${file.name} is larger than 5 MB.`));
+                    throw invalid(note("fileOver5Mb", { name: file.name }));
                 }
                 if (count > WORKSPACE_LIMITS.files + 1 || total > PACKAGE_MAX_BYTES) {
-                    throw invalid(bilingual("Die Wizard-Datei ist zu groß: Ein Arbeitsbereich fasst höchstens 200 Dateien und 25 MB.", "The wizard file is too large: a workspace holds at most 200 files and 25 MB."));
+                    throw invalid(note("wizardFileTooLarge"));
                 }
                 return true;
             },
         });
     }
     catch (err) {
-        throw err instanceof ServiceError
-            ? err
-            : invalid(bilingual("Die Wizard-Datei lässt sich nicht öffnen. Exportiere den Wizard neu und versuche es noch einmal.", "The wizard file can’t be opened. Export the wizard again and try once more."));
+        throw err instanceof ServiceError ? err : invalid(note("wizardFileNotOpened"));
     }
     // A package unpacked and zipped again often sits in a folder of its own.
     const manifestPath = Object.keys(entries)
         .filter((name) => name === PACKAGE_MANIFEST || name.endsWith(`/${PACKAGE_MANIFEST}`))
         .sort((a, b) => a.length - b.length)[0];
     if (manifestPath === undefined) {
-        throw invalid(bilingual("Das ist keine Wizard-Datei: Die wizard.json fehlt.", "This isn’t a wizard file: wizard.json is missing."));
+        throw invalid(note("wizardJsonMissing"));
     }
     const root = manifestPath.slice(0, -PACKAGE_MANIFEST.length);
     const files = Object.entries(entries)
@@ -73,12 +71,12 @@ export function readPackage(data) {
         .map(([name, content]) => {
         const path = cleanPath(name.slice(root.length + PACKAGE_FILES.length));
         if (!path) {
-            throw invalid(bilingual(`„${name}“ ist kein gültiger Dateipfad.`, `“${name}” isn’t a valid file path.`));
+            throw invalid(note("notValidFilePath", { name }));
         }
         return { path, data: content };
     });
     if (files.reduce((n, f) => n + f.data.byteLength, 0) > WORKSPACE_LIMITS.totalBytes) {
-        throw invalid(bilingual("Der Arbeitsbereich in der Wizard-Datei ist größer als 25 MB.", "The workspace in the wizard file is larger than 25 MB."));
+        throw invalid(note("workspaceWizardFileLarger"));
     }
     return { manifest: readManifest(json(entries[manifestPath])), files };
 }

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

@@ -4,6 +4,7 @@ import { strToU8, zipSync } from "fflate";
 import { listConnectors } from "../connectors/external.js";
 import { db, schema } from "../db/client.js";
 import { getBlob } from "../files/blobs.js";
+import { serverText } from "../texts.js";
 import { requireAdmin } from "./access.js";
 import { draftFiles, writeFile } from "./files.js";
 import { pageTree } from "./knowledge.js";
@@ -144,16 +145,14 @@ lang = "en") {
     // The shape is checked before anything is written; a wrong one leaves no wizard behind.
     const { draft } = parseDraft(manifest.definition, files.map((f) => f.path));
     const lacks = await missing(userId, projectId, draft, manifest);
-    const de = lang === "de";
+    const counts = {
+        name,
+        steps: serverText(lang, "stepCount", { count: draft.steps.length }),
+        files: serverText(lang, "fileCount", { count: files.length }),
+    };
     const note = [
-        de
-            ? `Importiert${name ? ` aus „${name}“` : ""}: ${draft.steps.length} Schritte, ${files.length} ${files.length === 1 ? "Datei" : "Dateien"}.`
-            : `Imported${name ? ` from “${name}”` : ""}: ${draft.steps.length} steps, ${files.length} ${files.length === 1 ? "file" : "files"}.`,
-        lacks.length
-            ? de
-                ? `Diesem Space fehlt noch: ${lacks.join(", ")}. Füge es unter Einstellungen → Connectors hinzu.`
-                : `This space still needs: ${lacks.join(", ")}. Add it under Settings → Connectors.`
-            : "",
+        serverText(lang, name ? "importedFrom" : "imported", counts),
+        lacks.length ? serverText(lang, "spaceStillNeeds", { needs: lacks }) : "",
     ]
         .filter(Boolean)
         .join("\n\n");

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

@@ -1,3 +1,4 @@
+import { isLang } from "@engenty-wizards/shared/definition";
 import { z } from "zod";
 import { linkedAccount } from "../auth/account.js";
 import { managed } from "../manage.js";
@@ -34,7 +35,7 @@ const langKey = (user) => `lang:${user.tenantId}:${user.id}`;
  */
 export async function userLang(user) {
     const lang = await readSetting(langKey(user));
-    return lang === "de" || lang === "en" ? lang : null;
+    return isLang(lang) ? lang : null;
 }
 export async function saveUserLang(user, lang) {
     await writeSetting(langKey(user), lang);

package/apps/runtime/dist/services/project-files.js

@@ -1,5 +1,5 @@
 import { PROJECT_LIMITS, projectFileLimit, } from "@engenty-wizards/shared/projects";
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { generateText } from "ai";
 import { and, asc, count, eq, max } from "drizzle-orm";
 import { db, schema } from "../db/client.js";
@@ -79,14 +79,14 @@ export async function addProjectFile(projectId, input) {
     const mime = documentMime(input.name, input.mime) || "application/octet-stream";
     if (!accepts(input.kind, mime)) {
         throw new ServiceError("invalid", input.kind === "logo"
-            ? bilingual("Ein Logo ist ein Bild (PNG, SVG, JPEG, WebP).", "A logo is an image (PNG, SVG, JPEG, WebP).")
+            ? note("logoImagePngSvg")
             : input.kind === "pattern"
-                ? bilingual("Ein Muster ist ein Bild (SVG, PNG, JPEG, WebP).", "A pattern is an image (SVG, PNG, JPEG, WebP).")
-                : bilingual("Hierher gehören Bilder, Videos, Audio, PDFs, Schriften, Lottie und 3D-Modelle. Texte zum Nachschlagen gehören ins Wissen.", "Images, videos, audio, PDFs, fonts, Lottie and 3D models go here. Texts to look things up in go under knowledge."));
+                ? note("patternImageSvgPng")
+                : note("filesGoHere"));
     }
     const limit = projectFileLimit(input.kind, mime);
     if (!input.data.byteLength || input.data.byteLength > limit) {
-        throw new ServiceError("invalid", bilingual(`Wähl eine Datei bis ${Math.round(limit / 1_000_000)} MB.`, `Choose a file of ${Math.round(limit / 1_000_000)} MB or less.`));
+        throw new ServiceError("invalid", note("chooseFileUpTo", { mb: Math.round(limit / 1_000_000) }));
     }
     const scope = and(eq(schema.projectFile.projectId, projectId), eq(schema.projectFile.kind, input.kind));
     const [{ n, last }] = await db
@@ -94,7 +94,7 @@ export async function addProjectFile(projectId, input) {
         .from(schema.projectFile)
         .where(scope);
     if (n >= PROJECT_LIMITS.files[input.kind]) {
-        throw new ServiceError("refused", bilingual(`Hier haben höchstens ${PROJECT_LIMITS.files[input.kind]} Dateien Platz.`, `There’s room for at most ${PROJECT_LIMITS.files[input.kind]} files here.`));
+        throw new ServiceError("refused", note("roomMostFiles", { count: PROJECT_LIMITS.files[input.kind] }));
     }
     const name = input.name.slice(0, 120) || "datei";
     const ref = await saveAsset({
@@ -150,21 +150,21 @@ export async function addProjectFileFromUrl(projectId, input) {
         headers: { "user-agent": "Mozilla/5.0 (compatible; engenty-wizards/0.1)" },
         signal: AbortSignal.any([AbortSignal.timeout(60_000), ...(signal ? [signal] : [])]),
     }).catch(() => {
-        throw new ServiceError("invalid", bilingual("Die Adresse ist nicht erreichbar.", "The address can’t be reached."));
+        throw new ServiceError("invalid", note("addressNotReached"));
     });
     if (!res.ok) {
-        throw new ServiceError("invalid", bilingual(`Die Adresse antwortete mit ${res.status}.`, `The address responded with ${res.status}.`));
+        throw new ServiceError("invalid", note("addressResponded", { status: res.status }));
     }
     const mime = (res.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
     if (mime === "text/html" && kind !== "document") {
         await res.body?.cancel();
-        throw new ServiceError("invalid", bilingual("Unter der Adresse steht eine Webseite, kein Bild.", "The address leads to a web page, not an image."), {
+        throw new ServiceError("invalid", note("addressLeadsWebPage"), {
             reason: "page",
             url: res.url,
         });
     }
     if (Number(res.headers.get("content-length") ?? 0) > projectFileLimit(kind, mime)) {
-        throw new ServiceError("invalid", bilingual("Die Datei ist zu groß.", "The file is too large."));
+        throw new ServiceError("invalid", note("addressFileTooLarge"));
     }
     const data = new Uint8Array(await res.arrayBuffer());
     const name = decodeURIComponent(new URL(res.url).pathname.split("/").pop() || kind);
@@ -305,7 +305,7 @@ export async function reindexProjectFile(projectId, fileId) {
     await requireWritableProject(projectId);
     const row = await projectFile(projectId, fileId);
     if (row.kind !== "document") {
-        throw new ServiceError("invalid", bilingual("Nur Dokumente stehen im Index.", "Only documents are in the index."));
+        throw new ServiceError("invalid", note("onlyDocumentsIndex"));
     }
     const [pending] = await db
         .update(schema.projectFile)
@@ -380,7 +380,7 @@ export async function putOriginFile(origin, input) {
     });
     const mime = documentMime(input.name, input.mime) || "application/octet-stream";
     if (!input.data.byteLength || input.data.byteLength > projectFileLimit("document", mime)) {
-        throw new ServiceError("invalid", bilingual(`„${input.name}“ ist leer oder zu groß für ein Dokument.`, `“${input.name}” is empty or too large for a document.`));
+        throw new ServiceError("invalid", note("emptyTooLargeDocument", { name: input.name }));
     }
     const name = input.name.slice(0, 120) || "datei";
     const values = {
@@ -407,7 +407,7 @@ export async function putOriginFile(origin, input) {
             .from(schema.projectFile)
             .where(and(eq(schema.projectFile.projectId, input.space), eq(schema.projectFile.kind, "document")));
         if (n >= PROJECT_LIMITS.files.document) {
-            throw new ServiceError("refused", bilingual(`Ein Space hat höchstens ${PROJECT_LIMITS.files.document} Dokumente.`, `A space can have at most ${PROJECT_LIMITS.files.document} documents.`));
+            throw new ServiceError("refused", note("spaceMostDocuments", { count: PROJECT_LIMITS.files.document }));
         }
         const ref = await saveAsset({ kind: "project", mime, name, data: input.data });
         id = ref.id;

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

@@ -1,5 +1,5 @@
 import { COLOR_SECTION_KINDS, cleanAssetSections, cleanLogoSections, FACT_TYPES, FONT_USES, FONT_WEIGHTS, GRADIENT_TYPES, orderColors, PROJECT_LIMITS, RULE_MARKS, } from "@engenty-wizards/shared/projects";
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { and, count, eq, isNull } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { z } from "zod";
@@ -8,6 +8,7 @@ import { env } from "../env.js";
 import { managed, tenantInfo } from "../manage.js";
 import { spaceChanged } from "../plugins/events.js";
 import { currentTenant } from "../tenants/tenant.js";
+import { serverText } from "../texts.js";
 import { mayBuild, requireAdmin, requireBuild, requireWritable } from "./access.js";
 import { notFound, ServiceError } from "./errors.js";
 import { forgetWizardLinks } from "./links.js";
@@ -148,10 +149,7 @@ const madeHere = () => and(eq(schema.project.tenantId, currentTenant()), isNull(
 /** The tenant's projects a local install synced. */
 const synced = () => and(eq(schema.project.tenantId, currentTenant()), eq(schema.project.origin, "local"));
 /** What the first space is called, in the language of whoever first opens the studio. */
-const FIRST_SPACE = {
-    cloud: { de: "Meine Wizards", en: "My wizards" },
-    local: { de: "Mein Computer", en: "My computer" },
-};
+const FIRST_SPACE = { cloud: "firstSpaceCloud", local: "firstSpaceLocal" };
 /**
  * A tenant that builds here always has a project of its own: the first one is made when its
  * studio is first opened, named in that request's language.
@@ -163,7 +161,7 @@ async function ensureProject(lang = "en") {
         await db.insert(schema.project).values({
             id,
             tenantId: currentTenant(),
-            name: FIRST_SPACE[env.manage.url ? "cloud" : "local"][lang],
+            name: serverText(lang, FIRST_SPACE[env.manage.url ? "cloud" : "local"]),
         });
         spaceChanged("space.created", id);
     }
@@ -230,9 +228,7 @@ export async function createProject(_userId, name) {
         .where(eq(schema.project.tenantId, currentTenant()));
     const limit = await projectLimit();
     if (n >= limit) {
-        throw new ServiceError("refused", limit === 1
-            ? bilingual("Hier ist nur ein Space möglich.", "Only one space is allowed here.")
-            : bilingual(`Hier sind höchstens ${limit} Spaces möglich.`, `You can have at most ${limit} spaces here.`));
+        throw new ServiceError("refused", limit === 1 ? note("onlyOneSpaceAllowed") : note("mostSpaces", { count: limit }));
     }
     const id = nanoid(12);
     await db
@@ -256,7 +252,7 @@ export async function updateProject(userId, projectId, patch) {
         return { ...s, headers };
     });
     if (patch.facts && new Set(patch.facts.map((f) => f.key)).size !== patch.facts.length) {
-        throw new ServiceError("invalid", bilingual("Zwei Einträge haben denselben Schlüssel.", "Two entries have the same key."));
+        throw new ServiceError("invalid", note("twoEntriesSameKey"));
     }
     await db
         .update(schema.project)
@@ -370,7 +366,7 @@ export async function deleteProject(userId, projectId) {
     await requireAdmin();
     const all = await db.query.project.findMany({ where: madeHere() });
     if (all.length <= 1) {
-        throw new ServiceError("refused", bilingual("Der letzte Space lässt sich nicht löschen.", "You can’t delete the last space."));
+        throw new ServiceError("refused", note("notDeleteLastSpace"));
     }
     await removeProject(projectId);
 }

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

@@ -1,5 +1,5 @@
 import { wizardLang } from "@engenty-wizards/shared/definition";
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { BUILT_IN_RUNNERS, CONVERSATION_RUNNERS, DEFAULT_RUNNER, DEFAULT_RUNNER_SETTINGS, runnerFit, } from "@engenty-wizards/shared/runners";
 import { env } from "../env.js";
 import { conversationAccess, conversationAvailable } from "../models.js";
@@ -72,14 +72,14 @@ export async function checkRunnerSettings(settings) {
     const ids = new Set(available.map((r) => r.id));
     const unknown = settings.enabled.find((id) => !ids.has(id));
     if (unknown) {
-        throw new ServiceError("invalid", bilingual(`Einen Runner „${unknown}“ gibt es hier nicht.`, `There’s no runner “${unknown}” here.`));
+        throw new ServiceError("invalid", note("unknownRunner", { unknown }));
     }
     const enabled = [...new Set(settings.enabled)];
     if (!enabled.length) {
-        throw new ServiceError("invalid", bilingual("Mindestens ein Runner muss eingeschaltet bleiben.", "At least one runner has to stay on."));
+        throw new ServiceError("invalid", note("leastOneRunnerStay"));
     }
     if (!enabled.includes(settings.default)) {
-        throw new ServiceError("invalid", bilingual("Der Link muss einen eingeschalteten Runner öffnen.", "The link has to open a runner that’s turned on."));
+        throw new ServiceError("invalid", note("linkOpenRunnerTurned"));
     }
     return { default: settings.default, enabled };
 }

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

@@ -1,5 +1,5 @@
 import { FIELD_WAYS, formatsFor, isDecidedField, shownFields, slotText, wizardLang, } from "@engenty-wizards/shared/definition";
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { and, count, desc, eq, gte, inArray, max, or, sql } from "drizzle-orm";
 import { canSpend, MICROS_PER_CREDIT } from "../credits/credits.js";
 import { db, schema } from "../db/client.js";
@@ -18,7 +18,7 @@ export async function startTestRun(userId, wizardId, autopilot) {
     const w = await ownedWizard(userId, wizardId);
     const { definition, files } = await requireClean(w);
     if (!(await canSpend())) {
-        throw new ServiceError("no_credits", bilingual("Dein Guthaben ist aufgebraucht.", "Your credits are used up."));
+        throw new ServiceError("no_credits", note("creditsUsedUp"));
     }
     const runId = await createRun({
         wizardId: w.id,
@@ -80,13 +80,10 @@ function fly(runId, answers, acceptReviews) {
             } while (again);
         }
         catch (err) {
-            const answers = (lang) => err instanceof RunInputError
-                ? fieldErrorsIn(err.errors, lang)
-                    .map((e) => `${e.field} – ${e.message}`)
-                    .join("; ")
-                : "";
             const message = err instanceof RunInputError
-                ? bilingual(`Antworten fehlen oder passen nicht: ${answers("de")}`, `Answers are missing or don’t fit: ${answers("en")}`)
+                ? note("answersMissing", {
+                    answers: err.errors.map((e) => note("fieldError", { field: e.field, message: e.message })),
+                })
                 : saidOf(err);
             await emitEvent(runId, null, "error", message).catch(() => undefined);
             land();
@@ -377,7 +374,7 @@ export async function startRun(userId, wizardId, answers = {}) {
         throw notFound();
     }
     if (!(await canSpend())) {
-        throw new ServiceError("no_credits", bilingual("Dein Guthaben ist aufgebraucht.", "Your credits are used up."));
+        throw new ServiceError("no_credits", note("creditsUsedUp"));
     }
     const runId = await createRun({
         wizardId: w.id,
@@ -391,7 +388,7 @@ export async function startRun(userId, wizardId, answers = {}) {
             throw new ServiceError("refused", saidOf(err));
         }
         if (err instanceof NoCreditsError) {
-            throw new ServiceError("no_credits", bilingual("Dein Guthaben ist aufgebraucht.", "Your credits are used up."));
+            throw new ServiceError("no_credits", note("creditsUsedUp"));
         }
         throw err;
     });

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

@@ -1,4 +1,4 @@
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { and, eq, isNotNull, lt } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { db, schema } from "../db/client.js";
@@ -13,7 +13,7 @@ export const shareUrlFor = (token) => `${env.publicUrl}/s/${token}`;
 /** Shares a finished run. Idempotent: the same run keeps the same link. */
 export async function shareRun(run) {
     if (run.status !== "done") {
-        throw new ServiceError("refused", bilingual("Nur fertige Ergebnisse lassen sich teilen.", "Only finished results can be shared."));
+        throw new ServiceError("refused", note("onlyFinishedResultsShared"));
     }
     let token = run.shareToken;
     if (!token) {

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

@@ -1,11 +1,12 @@
 import { factKey, PROJECT_LIMITS } from "@engenty-wizards/shared/projects";
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { runStudioAssistant } from "../agents/studio-assistant.js";
 import { canSpend } from "../credits/credits.js";
 import { errorText } from "../model-errors.js";
 import { currentTenant } from "../tenants/tenant.js";
+import { serverText } from "../texts.js";
 import { projectWritable, requireWritable } from "./access.js";
 import { apiSpace, apiSpaceDetails } from "./api.js";
 import { openChat, turnHistory } from "./assistant-chats.js";
@@ -167,15 +168,13 @@ function assistMessage(input) {
 }
 async function work(job, projectId, input) {
     try {
-        const de = siteLang(input) === "de";
-        job.activity = de
-            ? "Übernimmt die Angaben der Website …"
-            : "Taking over what the website says …";
+        const lang = siteLang(input);
+        job.activity = serverText(lang, "siteTakingOver");
         await fillFromSite(job.userId, projectId, input);
-        job.activity = de ? "Schreibt die Seiten in Wissen …" : "Writing the pages into Knowledge …";
+        job.activity = serverText(lang, "siteWritingPages");
         job.pages = await writePages(projectId, input);
         if (input.assist && (await canSpend())) {
-            job.activity = de ? "Liest die Angaben …" : "Reading the details …";
+            job.activity = serverText(lang, "siteReading");
             const project = await ownedProject(job.userId, projectId);
             // The person's open assistant chat gives the context; the turn is not stored in it.
             const chat = await openChat(job.user);
@@ -210,9 +209,7 @@ async function work(job, projectId, input) {
         job.error =
             err instanceof ServiceError
                 ? errorText(err, siteLang(input))
-                : siteLang(input) === "de"
-                    ? "Die Website ließ sich nicht übernehmen."
-                    : "The website could not be taken over.";
+                : serverText(siteLang(input), "siteFailed");
         console.error("[site]", err);
     }
 }
@@ -267,7 +264,7 @@ function siteJobView(job) {
 export function siteJob(jobId) {
     const job = jobs.get(jobId);
     if (!job || job.tenantId !== currentTenant()) {
-        throw new ServiceError("not_found", bilingual("Diesen Vorgang gibt es nicht, oder er ist schon beendet.", "This job doesn’t exist or has already finished."));
+        throw new ServiceError("not_found", note("jobNotExistAlready"));
     }
     return siteJobView(job);
 }

package/apps/runtime/dist/services/space-categories.js

@@ -1,5 +1,5 @@
 import { CATEGORY_TYPES, dayOf, } from "@engenty-wizards/shared/knowledge";
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { and, asc, eq, inArray, isNotNull, or, sql } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { db, schema } from "../db/client.js";
@@ -273,10 +273,10 @@ const MAX_CATEGORIES = 60;
 function checkDraft(draft) {
     const name = draft.name.replace(/\s+/g, " ").trim().slice(0, 80);
     if (!name) {
-        throw new ServiceError("invalid", bilingual("Eine Kategorie braucht einen Namen.", "A category needs a name."));
+        throw new ServiceError("invalid", note("categoryNeedsName"));
     }
     if (!CATEGORY_TYPES.includes(draft.type)) {
-        throw new ServiceError("invalid", bilingual(`Unbekannter Typ „${draft.type}“.`, `Unknown type “${draft.type}”.`));
+        throw new ServiceError("invalid", note("unknownCategoryType", { type: draft.type }));
     }
     return name;
 }
@@ -330,7 +330,7 @@ export async function putCategory(projectId, draft, opts = {}) {
         return known;
     }
     if (rows.length >= MAX_CATEGORIES) {
-        throw new ServiceError("refused", bilingual(`Ein Space hat höchstens ${MAX_CATEGORIES} Kategorien.`, `A space can have at most ${MAX_CATEGORIES} categories.`));
+        throw new ServiceError("refused", note("spaceMostCategories", { count: MAX_CATEGORIES }));
     }
     const id = nanoid(12);
     const [row] = await db
@@ -409,7 +409,7 @@ export async function updateCategory(categoryId, patch) {
     if (name !== row.name) {
         const clash = byName(await categoryRows(row.projectId), name);
         if (clash && clash.id !== row.id) {
-            throw new ServiceError("invalid", bilingual(`Die Kategorie „${name}“ gibt es schon.`, `The category “${name}” already exists.`));
+            throw new ServiceError("invalid", note("categoryAlreadyExists", { name }));
         }
     }
     await db
@@ -459,7 +459,7 @@ export async function addCategoryValue(categoryId, value) {
     const category = await categoryRow(categoryId);
     await requireWritableProject(category.projectId);
     if (category.type !== "choice") {
-        throw new ServiceError("invalid", bilingual("Werte gibt es nur bei Kategorien vom Typ Auswahl.", "Only choice categories have values."));
+        throw new ServiceError("invalid", note("onlyChoiceCategoriesValues"));
     }
     const ids = await addValues(category.id, [value]);
     return { id: [...ids.values()].at(-1) };
@@ -489,7 +489,7 @@ export async function mergeCategoryValues(fromId, intoId) {
     const from = await valueRow(fromId);
     const into = await valueRow(intoId);
     if (from.category.id !== into.category.id || fromId === intoId) {
-        throw new ServiceError("invalid", bilingual("Nur Werte einer Kategorie lassen sich zusammenführen.", "Only values of one category can be merged."));
+        throw new ServiceError("invalid", note("onlyValuesOneCategory"));
     }
     await requireWritableProject(from.category.projectId);
     const t = schema.spaceItemCategory;