wizards 0.2.16 → 0.2.18

package/apps/runtime/dist/db/migrations/tenant/meta/_journal.json

@@ -57,6 +57,20 @@
       "when": 1791287441521,
       "tag": "0007_space_data",
       "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "6",
+      "when": 1791307814904,
+      "tag": "0008_run_event_note",
+      "breakpoints": true
+    },
+    {
+      "idx": 9,
+      "version": "6",
+      "when": 1791311715390,
+      "tag": "0009_knowledge",
+      "breakpoints": true
     }
   ]
 }

package/apps/runtime/dist/db/schema.js

@@ -1,5 +1,5 @@
 import { sql } from "drizzle-orm";
-import { blob, index, integer, primaryKey, sqliteTable, text, uniqueIndex, } from "drizzle-orm/sqlite-core";
+import { blob, index, integer, primaryKey, real, sqliteTable, text, uniqueIndex, } from "drizzle-orm/sqlite-core";
 const now = sql `(unixepoch() * 1000)`;
 const createdAt = () => integer("created_at", { mode: "timestamp_ms" }).notNull().default(now);
 const updatedAt = () => integer("updated_at", { mode: "timestamp_ms" }).notNull().default(now);
@@ -129,6 +129,8 @@ export const runEvent = sqliteTable("run_event", {
     stepId: text("step_id"),
     type: text("type", { enum: ["step_started", "step_done", "tool", "info", "error"] }).notNull(),
     message: text("message").notNull(),
+    /** The message as a note of `RUN_NOTES`, for a runner in another language. */
+    note: text("note", { mode: "json" }).$type(),
     /** A picture of the run the event is about; shown while the step works. */
     assetId: text("asset_id"),
     createdAt: createdAt(),
@@ -194,14 +196,23 @@ export const projectFile = sqliteTable("project_file", {
     chars: integer("chars"),
     /** What the index holds of a document; `embeddings` includes the keywords. */
     indexed: text("indexed", { enum: ["embeddings", "keywords"] }),
+    /** A plugin's file (`server.spaceData.putFile`): the plugin, its key and what it calls it. */
+    origin: text("origin"),
+    originKey: text("origin_key"),
+    originLabel: text("origin_label"),
     createdAt: createdAt(),
     updatedAt: updatedAt(),
-}, (t) => [index("project_file_project").on(t.projectId, t.kind, t.position)]);
+}, (t) => [
+    index("project_file_project").on(t.projectId, t.kind, t.position),
+    uniqueIndex("project_file_origin").on(t.projectId, t.origin, t.originKey),
+]);
 /**
- * The document index: passages of a project's documents, and of the texts plugins put in
- * (`server.index`). Keywords live in the FTS5 table `project_chunk_fts`, which triggers keep
- * in step (see the migrations); `embedding` is the passage's vector as float32 bytes, compared
- * with libSQL's `vector_distance_cos`.
+ * The index of Wissen: one unit per section of a page, row of a table, file, summary of a
+ * Kategorie's value, passage of a document read before pages, and passage of a plugin's text
+ * (`server.index`). Each unit's text starts with where it stands and its Kategorien. Keywords
+ * live in two FTS5 tables, words (`project_chunk_fts`) and trigrams (`project_chunk_tri`), which
+ * triggers keep in step (see the migrations); `embedding` is the unit's vector as float32
+ * bytes, compared with libSQL's `vector_distance_cos`.
  */
 export const projectChunk = sqliteTable("project_chunk", {
     id: integer("id").primaryKey({ autoIncrement: true }),
@@ -210,6 +221,23 @@ export const projectChunk = sqliteTable("project_chunk", {
         .references(() => project.id, { onDelete: "cascade" }),
     /** The document the passage is of; null for a plugin's text. */
     fileId: text("file_id").references(() => projectFile.id, { onDelete: "cascade" }),
+    /** What the unit is of: a page, a row (with its table), a table (FAQ format: a row), a value. */
+    pageId: text("page_id").references(() => spacePage.id, {
+        onDelete: "cascade",
+    }),
+    rowId: text("row_id").references(() => spaceTableRow.id, {
+        onDelete: "cascade",
+    }),
+    tableId: text("table_id").references(() => spaceTable.id, {
+        onDelete: "cascade",
+    }),
+    valueId: text("value_id").references(() => spaceCategoryValue.id, {
+        onDelete: "cascade",
+    }),
+    /** A section's headings, outermost first, joined by " › ". */
+    heading: text("heading"),
+    /** The page of the original a section starts on (`<!-- S. 3 -->`). */
+    sheet: integer("sheet"),
     /** A plugin's text: the plugin, its key for the text, its title and where the studio shows it. */
     plugin: text("plugin"),
     ref: text("ref"),
@@ -224,6 +252,10 @@ export const projectChunk = sqliteTable("project_chunk", {
     index("project_chunk_project").on(t.projectId, t.model),
     index("project_chunk_file").on(t.fileId),
     index("project_chunk_ref").on(t.projectId, t.plugin, t.ref),
+    index("project_chunk_page").on(t.pageId),
+    index("project_chunk_row").on(t.rowId),
+    index("project_chunk_table").on(t.tableId),
+    index("project_chunk_value").on(t.valueId),
 ]);
 // --- The space's data -------------------------------------------------------
 // Tables and pages a space keeps, its own or one of its wizards'. Shared by everyone who works
@@ -245,12 +277,30 @@ export const spaceTable = sqliteTable("space_table", {
     /** The column a row is matched on, as the list says. */
     keyColumn: text("key_column"),
     title: text("title").notNull(),
+    /** Its name in a path (`tables/<slug>`), unique among the space's tables. */
+    slug: text("slug"),
+    /** `faq`: a question and its answer per row. */
+    format: text("format", { enum: ["faq"] }),
     columns: text("columns", { mode: "json" }).$type().notNull(),
+    /**
+     * Written by a plugin (`server.spaceData`): the plugin, its key for the item and what it
+     * calls where it came from ("Tagesberichte"). Null: made in the studio or uploaded.
+     */
+    origin: text("origin"),
+    originKey: text("origin_key"),
+    originLabel: text("origin_label"),
+    /** A person changed what its origin wrote: the origin no longer writes it. */
+    kept: integer("kept", { mode: "boolean" }).notNull().default(false),
+    /** Why a person should look at it ("hardly readable"); null when nothing is in doubt. */
+    review: text("review"),
+    /** The file it was read from, kept as the evidence. */
+    fileId: text("file_id").references(() => projectFile.id, { onDelete: "set null" }),
     createdAt: createdAt(),
     updatedAt: updatedAt(),
 }, (t) => [
     index("space_table_project").on(t.projectId, t.wizardId),
     uniqueIndex("space_table_list").on(t.wizardId, t.list),
+    uniqueIndex("space_table_origin").on(t.projectId, t.origin, t.originKey),
 ]);
 /** A row of a table: cells by column id. Rows stand in the order they were added. */
 export const spaceTableRow = sqliteTable("space_table_row", {
@@ -267,7 +317,10 @@ export const spaceTableRow = sqliteTable("space_table_row", {
     index("space_table_row_table").on(t.tableId, t.createdAt),
     index("space_table_row_key").on(t.tableId, t.key),
 ]);
-/** A page: a title and markdown, what the editor shows and an agent reads and writes. */
+/**
+ * A page: a title and markdown, what the editor shows and an agent reads and writes. A page of
+ * the space's own may have sub-pages: a long document split along its own headings.
+ */
 export const spacePage = sqliteTable("space_page", {
     id: text("id").primaryKey(),
     tenantId: text("tenant_id").notNull(),
@@ -275,11 +328,112 @@ export const spacePage = sqliteTable("space_page", {
         .notNull()
         .references(() => project.id, { onDelete: "cascade" }),
     wizardId: text("wizard_id").references(() => wizard.id, { onDelete: "cascade" }),
+    parentId: text("parent_id").references(() => spacePage.id, {
+        onDelete: "cascade",
+    }),
+    /** Its place among its parent's sub-pages. */
+    position: integer("position").notNull().default(0),
     title: text("title").notNull(),
+    /** Its name in a path (`pages/<parent>/<slug>`), unique among its siblings. */
+    slug: text("slug"),
     markdown: text("markdown").notNull().default(""),
+    /**
+     * Written by a plugin (`server.spaceData`): the plugin, its key for the item and what it
+     * calls where it came from ("Tagesberichte"). Null: made in the studio or uploaded.
+     */
+    origin: text("origin"),
+    originKey: text("origin_key"),
+    originLabel: text("origin_label"),
+    /** A person changed what its origin wrote: the origin no longer writes it. */
+    kept: integer("kept", { mode: "boolean" }).notNull().default(false),
+    /** Why a person should look at it ("hardly readable"); null when nothing is in doubt. */
+    review: text("review"),
+    /** The file it was read from, kept as the evidence. */
+    fileId: text("file_id").references(() => projectFile.id, { onDelete: "set null" }),
     createdAt: createdAt(),
     updatedAt: updatedAt(),
-}, (t) => [index("space_page_project").on(t.projectId, t.wizardId)]);
+}, (t) => [
+    index("space_page_project").on(t.projectId, t.wizardId),
+    index("space_page_parent").on(t.parentId, t.position),
+    uniqueIndex("space_page_origin").on(t.projectId, t.origin, t.originKey),
+]);
+// --- Kategorien -----------------------------------------------------------------
+// Typed properties that run across Wissen: set on pages, rows, tables and files, any number of
+// each, so a step filters before it searches.
+/** A Kategorie of the space: a name, a type and, for a choice, the values it has met. */
+export const spaceCategory = sqliteTable("space_category", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id")
+        .notNull()
+        .references(() => project.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    type: text("type", { enum: ["choice", "date", "number", "text", "boolean"] }).notNull(),
+    /** A number's unit: `h`, `€`, `kg`. */
+    unit: text("unit"),
+    /** A choice: several values per item. */
+    multiple: integer("multiple", { mode: "boolean" }).notNull().default(false),
+    /** A choice whose values are ranked (niedrig, mittel, hoch): their position is the rank. */
+    ordered: integer("ordered", { mode: "boolean" }).notNull().default(false),
+    /** Where its values come from, said in a few words ("Kopfzeile", "Spalte WLL"). */
+    hint: text("hint"),
+    /** The plugin that brought it; null: made in the studio. */
+    origin: text("origin"),
+    /** Proposed, not yet taken: shown to be confirmed, never filled. */
+    proposed: integer("proposed", { mode: "boolean" }).notNull().default(false),
+    /** A column of a table whose cells are its values for the table's rows. */
+    tableId: text("table_id").references(() => spaceTable.id, { onDelete: "set null" }),
+    columnId: text("column_id"),
+    position: integer("position").notNull().default(0),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (t) => [uniqueIndex("space_category_name").on(t.projectId, t.name)]);
+/** A value of a choice: grows as items arrive; its summary is the Übersicht of its items. */
+export const spaceCategoryValue = sqliteTable("space_category_value", {
+    id: text("id").primaryKey(),
+    categoryId: text("category_id")
+        .notNull()
+        .references(() => spaceCategory.id, { onDelete: "cascade" }),
+    value: text("value").notNull(),
+    position: integer("position").notNull().default(0),
+    /** The Übersicht: Markdown a model wrote of the value's items, when it last did. */
+    summary: text("summary"),
+    summaryAt: integer("summary_at", { mode: "timestamp_ms" }),
+    createdAt: createdAt(),
+}, (t) => [uniqueIndex("space_category_value_value").on(t.categoryId, t.value)]);
+/**
+ * A Kategorie set on an item: exactly one of page, row, table and file. A choice points to its
+ * value; the other types keep theirs typed: a date as milliseconds, a number, a short text, yes
+ * or no. A choice with several values has a row per value.
+ */
+export const spaceItemCategory = sqliteTable("space_item_category", {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    projectId: text("project_id")
+        .notNull()
+        .references(() => project.id, { onDelete: "cascade" }),
+    categoryId: text("category_id")
+        .notNull()
+        .references(() => spaceCategory.id, { onDelete: "cascade" }),
+    pageId: text("page_id").references(() => spacePage.id, { onDelete: "cascade" }),
+    rowId: text("row_id").references(() => spaceTableRow.id, { onDelete: "cascade" }),
+    tableId: text("table_id").references(() => spaceTable.id, { onDelete: "cascade" }),
+    fileId: text("file_id").references(() => projectFile.id, { onDelete: "cascade" }),
+    valueId: text("value_id").references(() => spaceCategoryValue.id, { onDelete: "cascade" }),
+    text: text("text"),
+    num: real("num"),
+    at: integer("at"),
+    bool: integer("bool", { mode: "boolean" }),
+    /** Who set it: a person, the item's origin (a source's structure), or a model reading it. */
+    by: text("by", { enum: ["person", "origin", "model"] })
+        .notNull()
+        .default("person"),
+}, (t) => [
+    index("space_item_category_category").on(t.categoryId, t.valueId),
+    index("space_item_category_page").on(t.pageId),
+    index("space_item_category_row").on(t.rowId),
+    index("space_item_category_table").on(t.tableId),
+    index("space_item_category_file").on(t.fileId),
+]);
 // --- The wizard's store ------------------------------------------------------
 // What a wizard keeps between runs for one person. `holder` is that person: "u:<userId>" for a
 // signed-in admin, "v:<visitorId>" for an end user on a shared link.

package/apps/runtime/dist/engine/events.js

@@ -1,13 +1,23 @@
 import { AsyncResource } from "node:async_hooks";
 import { EventEmitter } from "node:events";
+import { noteText } from "@engenty-wizards/shared/run";
 import { and, desc, eq, gt } from "drizzle-orm";
 import { db, schema } from "../db/client.js";
 const bus = new EventEmitter();
 bus.setMaxListeners(0);
-export async function emitEvent(runId, stepId, type, message, asset) {
+export async function emitEvent(runId, stepId, type, said, asset) {
+    const note = typeof said === "string" ? null : said;
+    const message = note ? noteText(note, "de") : said;
     const [row] = await db
         .insert(schema.runEvent)
-        .values({ runId, stepId, type, message: message.slice(0, 2000), assetId: asset ?? null })
+        .values({
+        runId,
+        stepId,
+        type,
+        message: message.slice(0, 2000),
+        note,
+        assetId: asset ?? null,
+    })
         .returning();
     const event = {
         id: row.id,
@@ -15,6 +25,7 @@ export async function emitEvent(runId, stepId, type, message, asset) {
         stepId: row.stepId,
         type: row.type,
         message: row.message,
+        note: row.note ?? null,
         asset: row.assetId,
     };
     bus.emit(runId, { runId, event });
@@ -41,6 +52,7 @@ export async function recentEvents(runId, afterId = 0, limit = 40) {
         stepId: r.stepId,
         type: r.type,
         message: r.message,
+        note: r.note ?? null,
         asset: r.assetId,
     }));
 }

package/apps/runtime/dist/engine/prepare.js

@@ -28,7 +28,7 @@ export async function prepareInputs(ctx) {
             delete values[field.id];
             continue;
         }
-        await ctx.emit("info", `Hört „${field.label}“ an …`);
+        await ctx.emit("info", { code: "listen", params: { label: field.label } });
         try {
             const transcript = await transcribeAudio({
                 bytes: new Uint8Array(found.data),
@@ -45,7 +45,10 @@ export async function prepareInputs(ctx) {
             }
             // The step goes on without the words; the next one tries again.
             console.error(`[run ${ctx.runId}] transcribe ${field.id}`, err);
-            await ctx.emit("info", `„${field.label}“ konnte nicht verschriftlicht werden.`);
+            await ctx.emit("info", {
+                code: "listenFailed",
+                params: { label: field.label },
+            });
         }
     }
 }

package/apps/runtime/dist/engine/requirements.js

@@ -100,6 +100,114 @@ export function unavoidableFrom(def, from, known) {
     };
     return new Set(def.steps.filter((_, i) => !reachesEnd(i)).map((s) => s.id));
 }
+/** Whether a rule matches given what is known: true, false, or null = it may go either way. */
+function ruleHolds(rule, facts) {
+    const k = facts[rule.when.field];
+    const value = rule.when.value;
+    switch (rule.when.op) {
+        case "empty":
+            return k?.filled === undefined ? (k?.is !== undefined ? false : null) : !k.filled;
+        case "notEmpty":
+            return k?.filled === undefined ? (k?.is !== undefined ? true : null) : k.filled;
+        case "equals":
+            return k?.is !== undefined
+                ? k.is === String(value)
+                : k?.not.includes(String(value))
+                    ? false
+                    : null;
+        case "notEquals":
+            return k?.is !== undefined
+                ? k.is !== String(value)
+                : k?.not.includes(String(value))
+                    ? true
+                    : null;
+        case "in": {
+            const list = Array.isArray(value) ? value.map(String) : [];
+            if (k?.is !== undefined) {
+                return list.includes(k.is);
+            }
+            return list.every((v) => k?.not.includes(v)) ? false : null;
+        }
+    }
+}
+/** What is known once a rule did (`held`) or did not match. */
+function learn(rule, held, facts) {
+    const field = rule.when.field;
+    const k = { ...(facts[field] ?? { not: [] }) };
+    k.not = [...k.not];
+    const value = String(rule.when.value);
+    const op = rule.when.op;
+    if ((op === "equals" && held) || (op === "notEquals" && !held)) {
+        k.is = value;
+        k.filled = true;
+    }
+    else if ((op === "equals" && !held) || (op === "notEquals" && held)) {
+        k.not.push(value);
+    }
+    else if (op === "in" && !held && Array.isArray(rule.when.value)) {
+        k.not.push(...rule.when.value.map(String));
+    }
+    else if (op === "empty" || op === "notEmpty") {
+        k.filled = (op === "notEmpty") === held;
+    }
+    return { ...facts, [field]: k };
+}
+/**
+ * The most a run can add up to along one way through the wizard. A branch remembers what it
+ * implies of the answers, so ways that contradict themselves (the 720p clips and the 480p
+ * ones) are not added up. Steps in `closed` are not passed (no model for them here); where that
+ * leaves no way to the end, they count again. A branch back to an earlier step is not followed
+ * twice.
+ */
+export function mostAlongOnePath(def, cost, closed = new Set()) {
+    const index = new Map(def.steps.map((s, i) => [s.id, i]));
+    const end = def.steps.length;
+    const walk = (avoid) => {
+        const best = (i, facts, seen) => {
+            if (i >= end) {
+                return 0;
+            }
+            const step = def.steps[i];
+            if (i < 0 || avoid.has(step.id) || seen.has(i)) {
+                return null;
+            }
+            const passed = new Set(seen).add(i);
+            let most = null;
+            const consider = (j, known) => {
+                const rest = best(j, known, passed);
+                if (rest !== null && (most === null || rest > most)) {
+                    most = rest;
+                }
+            };
+            // The rules are tried in order; the first that matches decides.
+            let known = facts;
+            let decided = false;
+            for (const rule of step.next ?? []) {
+                const holds = ruleHolds(rule, known);
+                if (holds === false) {
+                    continue;
+                }
+                consider(rule.goto === "end" ? end : (index.get(rule.goto) ?? -1), learn(rule, true, known));
+                if (holds === true) {
+                    decided = true;
+                    break;
+                }
+                known = learn(rule, false, known);
+            }
+            if (!decided) {
+                consider(i + 1, known);
+            }
+            return most === null ? null : most + cost(step);
+        };
+        return best(0, {}, new Set());
+    };
+    return walk(closed) ?? walk(new Set()) ?? def.steps.reduce((sum, s) => sum + cost(s), 0);
+}
+/** The steps that call a class this runtime cannot serve. */
+export async function stepsWithoutModel(def) {
+    const missing = await missingClasses();
+    return new Set(def.steps.filter((s) => stepClasses(s).some((cls) => missing.has(cls))).map((s) => s.id));
+}
 /** The classes this wizard needs that this runtime cannot serve; empty = every step can run. */
 export async function missingModels(def) {
     const unavoidable = unavoidableSteps(def);

package/apps/runtime/dist/engine/runner.js

@@ -20,7 +20,7 @@ import { askPerson, clearStaleAsk, unattended } from "./asks.js";
 import { emitEvent, recentEvents, signalChanged } from "./events.js";
 import { readPageInput } from "./input.js";
 import { pushRun } from "./push.js";
-import { blockingMessage, closedChoices, missingModels, openValue } from "./requirements.js";
+import { blockingMessage, closedChoices, missingModels, openValue, stepsWithoutModel, } from "./requirements.js";
 import { releaseResources, resourcesFor } from "./resources.js";
 import { runAutomaticStep } from "./steps.js";
 import { resolveRef } from "./template.js";
@@ -161,7 +161,7 @@ export async function createRun(input) {
         throw new ModelUnavailableError(blocked);
     }
     // The run's expected cost is held before it starts; what it really costs is booked per call.
-    const estimate = await estimateRun(input.wizardId, input.version, input.definition);
+    const estimate = await estimateRun(input.wizardId, input.version, input.definition, await stepsWithoutModel(input.definition));
     if (!(await reserveForRun(id, estimate.reserve))) {
         throw new NoCreditsError();
     }

package/apps/runtime/dist/engine/steps.js

@@ -1,4 +1,4 @@
-import { allFields, dataRef, isDecisionStep, templateRefs, } from "@engenty-wizards/shared/definition";
+import { allFields, dataRef, isDecisionStep, LOCALES, templateRefs, wizardLang, } from "@engenty-wizards/shared/definition";
 import { Agent } from "@mastra/core/agent";
 import { generateText, Output } from "ai";
 import { z } from "zod";
@@ -6,6 +6,7 @@ import { extFor, loadAsset, loadAssetText } from "../files/storage.js";
 import { generateImageMedia, generateSpeechMedia, generateVideoMedia, } from "../media/generate.js";
 import { markMedia } from "../media/marking.js";
 import { attachTools, costOf, isHarnessVendor, textModel } from "../models.js";
+import { knowledgeBlock } from "../services/knowledge.js";
 import { buildStepTools } from "../tools/index.js";
 import { spaceContextOf } from "../tools/plugin.js";
 import { personUploads } from "../tools/store.js";
@@ -13,8 +14,13 @@ import { runWidgetStep } from "../widgets/step.js";
 import { prepareInputs } from "./prepare.js";
 import { answersAsText, colorLine, factLines, renderTemplate, resolveRef, } from "./template.js";
 import { StepError } from "./types.js";
-function today() {
-    return new Date().toLocaleDateString("de-DE", { year: "numeric", month: "long", day: "numeric" });
+/** Today's date as the wizard's people write it. */
+function today(ctx) {
+    return new Date().toLocaleDateString(LOCALES[wizardLang(ctx.def)], {
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+    });
 }
 function brandBlock(ctx) {
     const b = ctx.scope.brand;
@@ -26,16 +32,6 @@ function brandBlock(ctx) {
     ].filter(Boolean);
     return parts.length ? `# WHO THIS WIZARD BELONGS TO\n${parts.join("\n")}` : "";
 }
-/** The project's documents, for a step that has the tools to search and read them. */
-function documentsBlock(ctx) {
-    const docs = ctx.projectFiles.filter((f) => f.kind === "document").slice(0, 40);
-    if (!docs.length) {
-        return "";
-    }
-    return `# THE PROJECT'S DOCUMENTS\nKnowledge the wizard's owner gave for all wizards. Find passages with project_search, read a whole document with project_document. Use them when the task touches what they cover.\n${docs
-        .map((d) => `- ${d.name}${d.description ? ` — ${d.description}` : ""}`)
-        .join("\n")}`;
-}
 /** Previous output of a step, for a revision. */
 async function previousResult(ctx, stepId) {
     const out = ctx.state.outputs[stepId];
@@ -166,9 +162,10 @@ export async function runAgentStep(step, ctx) {
                 : "Finish with everything the result needs in your final answer; it is turned into structured data afterwards.";
         const system = [
             GROUND_RULES,
-            `Today is ${today()}.`,
+            `Today is ${today(ctx)}.`,
             brandBlock(ctx),
-            documentsBlock(ctx),
+            // Wissen: what the space holds for its wizards, and how to find and read it.
+            await knowledgeBlock(ctx.project.id),
             // What the space's plugins hold for its wizards: a wiki, questions and answers.
             ...(await spaceContextOf(ctx)).blocks,
             formatHint,
@@ -221,7 +218,7 @@ export async function runAgentStep(step, ctx) {
         // Working through a mailbox or a row of portals takes many small tool calls.
         const maxSteps = step.tools.includes("browser") || step.connections?.length ? 60 : 20;
         for (const [i, photo] of photos.entries()) {
-            await ctx.emit("info", `Sieht sich Foto ${i + 1} von ${photos.length} an`, photo.id);
+            await ctx.emit("info", { code: "photo", params: { n: i + 1, total: photos.length } }, photo.id);
         }
         const message = photos.length
             ? [
@@ -381,7 +378,7 @@ async function writeHtml(step, ctx, kind) {
         ].join("\n");
     const system = [
         GROUND_RULES,
-        `Today is ${today()}.`,
+        `Today is ${today(ctx)}.`,
         brandBlock(ctx),
         guide,
         images.length
@@ -474,8 +471,8 @@ async function runMediaStep(step, ctx, asset) {
     const todo = entries.filter((e) => !keep(e));
     if (asset === "video") {
         await ctx.emit("info", todo.length > 1
-            ? `${todo.length} Clips werden gerendert – das dauert einige Minuten.`
-            : "Das Video wird gerendert – das dauert meist 1–3 Minuten.");
+            ? { code: "clipsRendering", params: { count: todo.length } }
+            : { code: "videoRendering" });
     }
     let finished = 0;
     const note = ctx.state.notes[step.id];
@@ -496,7 +493,10 @@ async function runMediaStep(step, ctx, asset) {
                 .join("\n")
             : await visualPrompt(step, ctx, entry);
         if (entry.reference && todo.length > 1) {
-            await ctx.emit("info", `${asset === "image" ? "Bearbeitet" : "Dreht"} ${entry.index + 1} von ${entries.length}`, entry.reference);
+            await ctx.emit("info", {
+                code: asset === "image" ? "editing" : "filming",
+                params: { n: entry.index + 1, total: entries.length },
+            }, entry.reference);
         }
         const reference = await loadReference(entry.reference, ctx);
         const media = asset === "image"
@@ -529,7 +529,7 @@ async function runMediaStep(step, ctx, asset) {
         });
         finished++;
         if (todo.length > 1) {
-            await ctx.emit("info", `${finished} von ${todo.length} fertig`, asset === "image" ? ref.id : undefined);
+            await ctx.emit("info", { code: "batchDone", params: { done: finished, total: todo.length } }, asset === "image" ? ref.id : undefined);
         }
         return { index: entry.index, prompt, ref };
     });

package/apps/runtime/dist/engine/template.js

@@ -1,16 +1,17 @@
-import { allFields, isAudioValue, isLocationValue, itemsTotals, locationText, } from "@engenty-wizards/shared/definition";
+import { allFields, isAudioValue, isLocationValue, itemsTotals, LOCALES, locationText, wizardLang, } from "@engenty-wizards/shared/definition";
 import { listAsMarkdown } from "@engenty-wizards/shared/store";
 const TEMPLATE_RE = /\{\{\s*([^}]+?)\s*\}\}/g;
-function money(n, currency) {
+function money(n, currency, locale) {
     try {
-        return new Intl.NumberFormat("de-DE", { style: "currency", currency }).format(n);
+        return new Intl.NumberFormat(locale, { style: "currency", currency }).format(n);
     }
     catch {
         return `${n.toFixed(2)} ${currency}`;
     }
 }
 /** Line items as a Markdown table with their totals — what a model needs to write a document. */
-export function itemsAsMarkdown(field, value, values) {
+export function itemsAsMarkdown(field, value, values, lang = "de") {
+    const locale = LOCALES[lang];
     const totals = itemsTotals(field, value, values);
     const cols = field.columns ?? [];
     if (!totals.rows.length) {
@@ -18,12 +19,14 @@ export function itemsAsMarkdown(field, value, values) {
     }
     const head = `| ${cols.map((c) => c.label).join(" | ")} | Amount |\n|${cols.map(() => " --- ").join("|")}| ---: |`;
     const body = totals.rows.map((r) => `| ${cols
-        .map((c) => c.kind === "money" ? money(Number(r[c.id]) || 0, totals.currency) : String(r[c.id] ?? ""))
-        .join(" | ")} | ${money(r.amount, totals.currency)} |`);
+        .map((c) => c.kind === "money"
+        ? money(Number(r[c.id]) || 0, totals.currency, locale)
+        : String(r[c.id] ?? ""))
+        .join(" | ")} | ${money(r.amount, totals.currency, locale)} |`);
     const sums = [
-        `Net: ${money(totals.net, totals.currency)}`,
-        totals.vatRate ? `VAT ${totals.vatRate}%: ${money(totals.vat, totals.currency)}` : null,
-        `Total: ${money(totals.gross, totals.currency)}`,
+        `Net: ${money(totals.net, totals.currency, locale)}`,
+        totals.vatRate ? `VAT ${totals.vatRate}%: ${money(totals.vat, totals.currency, locale)}` : null,
+        `Total: ${money(totals.gross, totals.currency, locale)}`,
     ].filter(Boolean);
     return [head, ...body, "", ...sums].join("\n");
 }
@@ -118,7 +121,7 @@ export function resolveRef(ref, scope) {
     const value = state.values[head];
     if (field?.kind === "items") {
         if (!rest.length) {
-            return itemsAsMarkdown(field, value, state.values);
+            return itemsAsMarkdown(field, value, state.values, wizardLang(def));
         }
         const totals = itemsTotals(field, value, state.values);
         return totals[rest[0]];

package/apps/runtime/dist/env.js

@@ -158,6 +158,8 @@ export const env = {
     falKey: str("FAL_KEY"),
     elevenlabsKey: str("ELEVENLABS_API_KEY"),
     replicateKey: str("REPLICATE_API_TOKEN"),
+    /** TypeSafe's own API, for the classifier that checks what a search found (Jev). */
+    typesafeKey: str("TYPESAFE_API_KEY"),
     ollamaUrl: str("OLLAMA_URL", "http://127.0.0.1:11434/v1"),
     /** What each model class runs on when this runtime resolves classes itself (own keys, Ollama). */
     models: {

package/apps/runtime/dist/files/storage.js

@@ -77,6 +77,21 @@ export async function inlineAssetRefs(html) {
     }
     return out;
 }
+/** Gives an asset new content under the id it has: what points to it keeps pointing to it. */
+export async function replaceAsset(id, input) {
+    const row = await db.query.asset.findFirst({ where: eq(schema.asset.id, id) });
+    if (!row) {
+        return;
+    }
+    const bytes = Buffer.from(input.data);
+    const file = `${id}-${nanoid(6)}.${extFor(input.mime)}`;
+    await objects.put(assetKey(file), bytes);
+    await db
+        .update(schema.asset)
+        .set({ mime: input.mime, name: input.name, path: file, size: bytes.byteLength })
+        .where(eq(schema.asset.id, id));
+    await objects.remove(assetKey(row.path));
+}
 /** Deletes one asset: its file and its row. */
 export async function removeAsset(id) {
     const row = await db.query.asset.findFirst({ where: eq(schema.asset.id, id) });