wizards 0.5.6 → 0.5.8

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;

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

@@ -1,5 +1,5 @@
 import { TableColumnValueError, tableColumnsSchema, } from "@engenty-wizards/shared/engenty/data-tables";
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { editCells, SPACE_DATA_LIMITS, } from "@engenty-wizards/shared/space-data";
 import { rowKey } from "@engenty-wizards/shared/store";
 import { and, asc, count, desc, eq, inArray, isNotNull, isNull, max } from "drizzle-orm";
@@ -7,6 +7,7 @@ import { nanoid } from "nanoid";
 import { db, schema } from "../db/client.js";
 import { saidOf } from "../model-errors.js";
 import { currentTenant } from "../tenants/tenant.js";
+import { serverText } from "../texts.js";
 import { projectWritable, requireWritableProject } from "./access.js";
 import { notFound, ServiceError } from "./errors.js";
 import { filePaths, freeSlug, knowledgePage, pageTree, tablePaths } from "./knowledge.js";
@@ -23,7 +24,7 @@ async function ownerOf(projectId, wizardId) {
         columns: { id: true },
     });
     if (!w) {
-        throw new ServiceError("invalid", bilingual("Diesen Wizard gibt es im Space nicht.", "This wizard isn’t in the space."));
+        throw new ServiceError("invalid", note("wizardNotSpace"));
     }
     return w.id;
 }
@@ -36,7 +37,7 @@ function cellError(err) {
 export function checkColumns(columns) {
     const parsed = tableColumnsSchema.safeParse(columns);
     if (!parsed.success) {
-        throw new ServiceError("invalid", parsed.error.issues[0]?.message ?? bilingual("Ungültige Spalten.", "Invalid columns."));
+        throw new ServiceError("invalid", parsed.error.issues[0]?.message ?? note("invalidColumns"));
     }
     return parsed.data;
 }
@@ -104,11 +105,10 @@ async function tableCount(projectId) {
         .from(schema.spaceTable)
         .where(eq(schema.spaceTable.projectId, projectId));
     if (n >= SPACE_DATA_LIMITS.tables) {
-        throw new ServiceError("refused", bilingual(`Ein Space hat höchstens ${SPACE_DATA_LIMITS.tables} Tabellen.`, `A space can have at most ${SPACE_DATA_LIMITS.tables} tables.`));
+        throw new ServiceError("refused", note("spaceMostTables", { count: SPACE_DATA_LIMITS.tables }));
     }
 }
 export async function createTable(userId, projectId, input, lang = "en") {
-    const de = lang === "de";
     const project = await ownedProject(userId, projectId);
     await requireWritableProject(project.id);
     await tableCount(project.id);
@@ -116,10 +116,10 @@ export async function createTable(userId, projectId, input, lang = "en") {
         ? checkColumns(input.columns)
         : input.format === "faq"
             ? [
-                { id: "question", name: de ? "Frage" : "Question", type: "text" },
+                { id: "question", name: serverText(lang, "faqQuestion"), type: "text" },
                 {
                     id: "answer",
-                    name: de ? "Antwort" : "Answer",
+                    name: serverText(lang, "faqAnswer"),
                     type: "text",
                     format: { style: "multiline" },
                 },
@@ -127,7 +127,7 @@ export async function createTable(userId, projectId, input, lang = "en") {
             : [{ id: "name", name: "Name", type: "text" }];
     const id = nanoid(12);
     const wizardId = await ownerOf(project.id, input.wizardId);
-    const title = input.title.trim() || (de ? "Tabelle" : "Table");
+    const title = input.title.trim() || serverText(lang, "tableTitle");
     await db.insert(schema.spaceTable).values({
         id,
         tenantId: currentTenant(),
@@ -187,7 +187,7 @@ export async function getTable(userId, tableId) {
 export async function updateTable(_userId, tableId, patch) {
     const table = await writableTable(tableId);
     if (table.list && (patch.columns !== undefined || patch.wizardId !== undefined)) {
-        throw new ServiceError("refused", bilingual("Diese Tabelle gehört zu einer Liste des Wizards. Ihre Spalten kommen aus dem Wizard.", "This table belongs to one of the wizard’s lists. Its columns come from the wizard."));
+        throw new ServiceError("refused", note("tableBelongsOneWizard"));
     }
     const title = patch.title !== undefined ? patch.title.trim() || table.title : table.title;
     const wizardId = patch.wizardId !== undefined ? await ownerOf(table.projectId, patch.wizardId) : table.wizardId;
@@ -250,7 +250,7 @@ async function refuseClash(tableId, key, rowId) {
         columns: { id: true },
     });
     if (other && other.id !== rowId) {
-        throw new ServiceError("invalid", bilingual("Diesen Eintrag gibt es schon.", "This entry already exists."));
+        throw new ServiceError("invalid", note("entryAlreadyExists"));
     }
 }
 /** After a row of a table of Knowledge changed: its categories from its columns, its unit. */
@@ -269,7 +269,7 @@ export async function addTableRow(_userId, tableId, cells = {}) {
         .from(schema.spaceTableRow)
         .where(eq(schema.spaceTableRow.tableId, table.id));
     if (n >= SPACE_DATA_LIMITS.rowsPerTable) {
-        throw new ServiceError("refused", bilingual(`Eine Tabelle hat höchstens ${SPACE_DATA_LIMITS.rowsPerTable} Zeilen.`, `A table can have at most ${SPACE_DATA_LIMITS.rowsPerTable} rows.`));
+        throw new ServiceError("refused", note("tableMostRows", { count: SPACE_DATA_LIMITS.rowsPerTable }));
     }
     let value;
     try {
@@ -334,7 +334,7 @@ async function pageRow(pageId) {
 }
 function checkMarkdown(markdown) {
     if (markdown.length > SPACE_DATA_LIMITS.pageChars) {
-        throw new ServiceError("refused", bilingual(`Eine Seite hat höchstens ${SPACE_DATA_LIMITS.pageChars.toLocaleString("de")} Zeichen.`, `A page can have at most ${SPACE_DATA_LIMITS.pageChars.toLocaleString("en")} characters.`));
+        throw new ServiceError("refused", note("pageMostChars", { count: SPACE_DATA_LIMITS.pageChars }));
     }
     return markdown;
 }
@@ -344,7 +344,7 @@ async function pageCount(projectId, more = 1) {
         .from(schema.spacePage)
         .where(eq(schema.spacePage.projectId, projectId));
     if (n + more > SPACE_DATA_LIMITS.pages) {
-        throw new ServiceError("refused", bilingual(`Ein Space hat höchstens ${SPACE_DATA_LIMITS.pages} Seiten.`, `A space can have at most ${SPACE_DATA_LIMITS.pages} pages.`));
+        throw new ServiceError("refused", note("spaceMostPages", { count: SPACE_DATA_LIMITS.pages }));
     }
 }
 /** A page of the space's own that a sub-page may stand under: never one of its own sub-pages. */
@@ -357,11 +357,11 @@ async function parentOf(projectId, parentId, pageId) {
         columns: { id: true, wizardId: true, parentId: true },
     });
     if (!parent || parent.wizardId) {
-        throw new ServiceError("invalid", bilingual("Diese Seite kann keine Unterseiten haben.", "This page can’t have subpages."));
+        throw new ServiceError("invalid", note("pageNotSubpages"));
     }
     for (let at = parent.id; at && pageId;) {
         if (at === pageId) {
-            throw new ServiceError("invalid", bilingual("Eine Seite kann nicht ihre eigene Unterseite sein.", "A page can’t be its own subpage."));
+            throw new ServiceError("invalid", note("pageNotOwnSubpage"));
         }
         const up = await db.query.spacePage.findFirst({
             where: eq(schema.spacePage.id, at),
@@ -492,7 +492,7 @@ export async function runPages(projectId, wizardId) {
 export async function writeRunPage(projectId, wizardId, input) {
     const title = input.title.trim();
     if (!title) {
-        throw new ServiceError("invalid", bilingual("Eine Seite braucht einen Titel.", "A page needs a title."));
+        throw new ServiceError("invalid", note("pageNeedsTitle"));
     }
     const existing = (await db.query.spacePage.findMany({
         where: and(eq(schema.spacePage.projectId, projectId), eq(schema.spacePage.wizardId, wizardId)),
@@ -513,7 +513,7 @@ export async function writeRunPage(projectId, wizardId, input) {
         .from(schema.spacePage)
         .where(eq(schema.spacePage.projectId, projectId));
     if (n >= SPACE_DATA_LIMITS.pages) {
-        throw new ServiceError("refused", bilingual(`Ein Space hat höchstens ${SPACE_DATA_LIMITS.pages} Seiten.`, `A space can have at most ${SPACE_DATA_LIMITS.pages} pages.`));
+        throw new ServiceError("refused", note("spaceMostPages", { count: SPACE_DATA_LIMITS.pages }));
     }
     const id = nanoid(12);
     await db.insert(schema.spacePage).values({
@@ -532,7 +532,7 @@ async function originSpace(space) {
         columns: { id: true },
     });
     if (!project) {
-        throw new ServiceError("not_found", bilingual(`Den Space „${space}“ gibt es nicht.`, `There’s no space “${space}”.`));
+        throw new ServiceError("not_found", note("unknownSpace", { space }));
     }
     await requireWritableProject(project.id);
     return project.id;
@@ -566,7 +566,7 @@ export async function putOriginPage(origin, input) {
         })
         : null;
     if (input.parent && !parent) {
-        throw new ServiceError("invalid", bilingual(`Es gibt keine Seite mit dem Schlüssel „${input.parent}“, unter die diese Seite könnte.`, `There’s no page with the key “${input.parent}” to put this page under.`));
+        throw new ServiceError("invalid", note("noParentPage", { parent: input.parent }));
     }
     const title = input.title.replace(/\s+/g, " ").trim().slice(0, 200) || "Seite";
     const markdown = checkMarkdown(input.markdown);
@@ -630,7 +630,7 @@ export async function putOriginTable(origin, input) {
     }
     const columns = checkColumns(input.columns);
     if (input.rows.length > SPACE_DATA_LIMITS.rowsPerTable) {
-        throw new ServiceError("refused", bilingual(`Eine Tabelle hat höchstens ${SPACE_DATA_LIMITS.rowsPerTable} Zeilen.`, `A table can have at most ${SPACE_DATA_LIMITS.rowsPerTable} rows.`));
+        throw new ServiceError("refused", note("tableMostRows", { count: SPACE_DATA_LIMITS.rowsPerTable }));
     }
     let cells;
     try {

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

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { tableColumnsSchema } from "@engenty-wizards/shared/engenty/data-tables";
 import { CATEGORY_TYPES } from "@engenty-wizards/shared/knowledge";
 import { PROJECT_LIMITS } from "@engenty-wizards/shared/projects";
-import { bilingual } from "@engenty-wizards/shared/run";
+import { note } from "@engenty-wizards/shared/run";
 import { SPACE_DATA_LIMITS } from "@engenty-wizards/shared/space-data";
 import { WORKSPACE_LIMITS } from "@engenty-wizards/shared/workspace";
 import { and, count, eq, inArray, isNull, notInArray, sql } from "drizzle-orm";
@@ -150,9 +150,7 @@ async function requireRoom(spaceId) {
         .where(and(counted, sql `${schema.project.id} <> ${spaceId}`));
     const limit = await projectLimit();
     if (others.length >= limit) {
-        throw new ServiceError("refused", limit === 1
-            ? bilingual("Dieses Konto hat hier schon einen Space.", "This account already has a space here.")
-            : bilingual(`Dieses Konto hat hier schon ${limit} Spaces.`, `This account already has ${limit} spaces here.`), {
+        throw new ServiceError("refused", limit === 1 ? note("accountAlreadySpace") : note("accountAlreadySpaces", { count: limit }), {
             reason: "space_limit",
             limit,
             spaces: others.filter((p) => p.origin === "local").map((p) => ({ id: p.id, name: p.name })),
@@ -166,7 +164,7 @@ async function requireWizardRoom(spaceId) {
         .from(schema.wizard)
         .where(eq(schema.wizard.projectId, spaceId));
     if ((row?.n ?? 0) >= env.limits.syncedWizards) {
-        throw new ServiceError("refused", bilingual(`Hier haben höchstens ${env.limits.syncedWizards} veröffentlichte Wizards Platz.`, `There’s room for at most ${env.limits.syncedWizards} published wizards here.`), { reason: "wizard_limit", limit: env.limits.syncedWizards });
+        throw new ServiceError("refused", note("roomMostPublishedWizards", { count: env.limits.syncedWizards }), { reason: "wizard_limit", limit: env.limits.syncedWizards });
     }
 }
 const hashOf = (data) => createHash("sha256").update(data).digest("hex");
@@ -200,7 +198,7 @@ async function syncLogo(projectId, logo) {
 async function syncSpace(spaceId, space) {
     const existing = await syncedProject(spaceId);
     if (existing && existing.origin !== "local") {
-        throw new ServiceError("refused", bilingual("Einen Space mit dieser Kennung gibt es hier schon, und er kommt nicht von deinem Computer.", "A space with this ID already exists here and didn’t come from your computer."), {
+        throw new ServiceError("refused", note("spaceIdAlreadyExists"), {
             reason: "id_taken",
         });
     }
@@ -251,7 +249,7 @@ export async function syncWizard(rawSpaceId, rawWizardId, input) {
                 where: and(eq(schema.wizard.id, wizardId), eq(schema.wizard.tenantId, currentTenant())),
             });
             if (existing && existing.projectId !== spaceId) {
-                throw new ServiceError("refused", bilingual("Ein Wizard mit dieser Kennung gehört hier schon zu einem anderen Space.", "A wizard with this ID already belongs to another space here."), {
+                throw new ServiceError("refused", note("wizardIdAlreadyBelongs"), {
                     reason: "id_taken",
                 });
             }
@@ -507,7 +505,7 @@ export async function syncSpaceData(rawSpaceId, input) {
             : [],
     ]);
     if ([...tablesHere, ...pagesHere].some((x) => x.projectId !== spaceId || x.wizardId !== null)) {
-        throw new ServiceError("refused", bilingual("Diese Kennung ist hier schon vergeben.", "This ID is already in use here."), {
+        throw new ServiceError("refused", note("idAlreadyUse"), {
             reason: "id_taken",
         });
     }
@@ -585,7 +583,7 @@ async function syncCategories(spaceId, categories, assignments) {
         })
         : [];
     if (taken.some((c) => c.projectId !== spaceId)) {
-        throw new ServiceError("refused", bilingual("Diese Kennung ist hier schon vergeben.", "This ID is already in use here."), {
+        throw new ServiceError("refused", note("idAlreadyUse"), {
             reason: "id_taken",
         });
     }