wizards 0.2.17 → 0.2.18

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

@@ -64,6 +64,13 @@
       "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);
@@ -196,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 }),
@@ -212,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"),
@@ -226,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
@@ -247,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", {
@@ -269,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(),
@@ -277,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/steps.js

@@ -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";
@@ -31,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];
@@ -173,7 +164,8 @@ export async function runAgentStep(step, ctx) {
             GROUND_RULES,
             `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,

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) });

package/apps/runtime/dist/models.js

@@ -600,6 +600,44 @@ export async function embeddingModel() {
         ? { model: gatewayClient(access, {}).embeddingModel("wizards/embedding"), ref: bound.model }
         : null;
 }
+/**
+ * The way to TypeSafe's Jev, a classifier that answers typed questions with probabilities and
+ * writes no text: the credits on a Manage-App's runtime; alone, an AI Gateway key, a TypeSafe
+ * key, or the linked account's credits. Null when there is none.
+ */
+export async function systemOneAccess() {
+    const cfg = await config();
+    const viaCredits = (access) => ({
+        url: `${access.baseUrl}/v4/ai/systemone`,
+        headers: {
+            authorization: `Bearer ${access.token}`,
+            // Booked under the classifier class; its evaluation model answers.
+            "ai-model-id": "wizards/classifier",
+            ...(access.tenant ? { "x-wizards-tenant": access.tenant } : {}),
+        },
+        model: null,
+    });
+    if (managed) {
+        const access = await creditAccess(cfg, true).catch(() => null);
+        return access ? viaCredits(access) : null;
+    }
+    if (cfg.keys.gateway) {
+        return {
+            url: "https://ai-gateway.vercel.sh/typesafe/v1/systemone",
+            headers: { authorization: `Bearer ${cfg.keys.gateway}` },
+            model: "typesafe-ai/jev",
+        };
+    }
+    if (env.typesafeKey) {
+        return {
+            url: "https://api.typesafe.ai/v1/systemone",
+            headers: { authorization: `Bearer ${env.typesafeKey}` },
+            model: "jev-latest",
+        };
+    }
+    const access = await creditAccess(cfg, false).catch(() => null);
+    return access ? viaCredits(access) : null;
+}
 /** Search tools an AI Gateway runs itself; they travel in the request, so any gateway client names them. */
 export const gatewayTools = createGateway({ apiKey: "unused" }).tools;
 /**

package/apps/runtime/dist/plugins/loader.js

@@ -11,6 +11,7 @@ import { parseDocument } from "../documents/parse.js";
 import { env } from "../env.js";
 import { ModelUnavailableError, textModel } from "../models.js";
 import { putIndexEntry, removeIndexEntries } from "../services/project-index.js";
+import { originData } from "../services/space-origin.js";
 import { safeFetch } from "../tools/net-guard.js";
 import { discoverPlugins } from "./discovery.js";
 import { migrateOpenTenants, migratePlugins } from "./migrations.js";
@@ -112,6 +113,7 @@ function apiFor(record) {
                 put: (entry) => putIndexEntry(source.id, entry),
                 remove: (space, key) => removeIndexEntries(source.id, space, key),
             },
+            spaceData: originData(source.id),
             web: {
                 fetch: (url, init) => safeFetch(url, init),
                 read: (url, options) => readPage(url, options?.signal),

package/apps/runtime/dist/routes/studio.js

@@ -1,6 +1,7 @@
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { MODEL_CLASSES, TEXT_CLASSES } from "@engenty-wizards/shared/definition";
+import { CATEGORY_TYPES, whereSchema } from "@engenty-wizards/shared/knowledge";
 import { PROJECT_FILE_KINDS } from "@engenty-wizards/shared/projects";
 import { isCreditsRef } from "@engenty-wizards/shared/providers";
 import { generateText } from "ai";
@@ -30,15 +31,18 @@ import { HTML_RESPONSE_CSP } from "../render/guard.js";
 import { mayBuild, projectWritable, requireWritable } from "../services/access.js";
 import { architectTurn } from "../services/architect.js";
 import { checkForCloud, cloudLinked, cloudSpaces, cloudState, forgetCloud, publishAndSync, pushSharing, removeFromCloud, replaceCloudSpaces, rotateInCloud, syncToCloud, } from "../services/cloud.js";
-import { ServiceError } from "../services/errors.js";
+import { notFound, ServiceError } from "../services/errors.js";
 import { deleteFile, listFiles, readFile, writeFile } from "../services/files.js";
+import { categoryContents, listKnowledge, resolvePath, valueContents, } from "../services/knowledge.js";
+import { writeSummary } from "../services/knowledge-model.js";
 import { exportWizard, importWizard, PACKAGE_EXTENSION, PACKAGE_MAX_BYTES, PACKAGE_MIME, } from "../services/package.js";
 import { profileSchema, saveProfile, userProfile } from "../services/profile.js";
 import { addProjectFile, fileView, orderProjectFiles, projectFile, projectFileContent, projectFiles, reindexProjectFile, removeProjectFile, updateProjectFile, } from "../services/project-files.js";
-import { documentText, searchProject } from "../services/project-index.js";
+import { documentText, queueIndex, searchKnowledge } from "../services/project-index.js";
 import { createProject, deleteProject, listProjects, maskedServers, ownedProject, projectLimit, projectPatchSchema, updateProject, } from "../services/projects.js";
 import { listResults, listRuns, startTestRun } from "../services/runs.js";
-import { addTableRow, createPage, createTable, deletePage, deleteTable, deleteTableRows, getPage, getTable, listSpaceData, updatePage, updateTable, updateTableRow, } from "../services/space-data.js";
+import { addCategoryValue, categoryRow, categoryValue, deleteCategory, deleteCategoryValue, mergeCategoryValues, orderCategoryValues, putCategory, renameCategoryValue, setItemCategory, updateCategory, } from "../services/space-categories.js";
+import { addTableRow, createPage, createTable, deletePage, deleteTable, deleteTableRows, getPage, getTable, listSpaceData, orderSubPages, updatePage, updateTable, updateTableRow, } from "../services/space-data.js";
 import { draftWidgetPreview } from "../services/widgets.js";
 import { createWizard, deleteWizard, duplicateWizard, listWizards, ownedWizard, rotateShareLink, updateWizardSettings, wizardMessages, wizardState, writableWizard, writeDraft, } from "../services/wizards.js";
 import { readSetting, writeSetting } from "../settings.js";
@@ -344,11 +348,13 @@ export const studio = new Hono()
     const text = await documentText(row);
     return c.json({ text: text.slice(0, limit), chars: text.length });
 })
-    // What the document index finds for a question: the passages an agent step would get.
+    // What a search of Wissen finds for a question: the items an agent step would get.
     .post("/projects/:id/search", async (c) => {
     const project = await ownedProject(c.get("user").id, c.req.param("id"));
-    const { query } = z.object({ query: z.string().min(1).max(400) }).parse(await c.req.json());
-    return c.json({ hits: await searchProject(project.id, query, 6) });
+    const body = z
+        .object({ query: z.string().min(1).max(400), where: whereSchema.optional() })
+        .parse(await c.req.json());
+    return c.json(await searchKnowledge(project.id, body.query, { where: body.where }));
 })
     // The assistant fills the project in: from a description, a website, the files given.
     .post("/projects/:id/assist", async (c) => {
@@ -362,6 +368,7 @@ export const studio = new Hono()
             .array(z.object({ role: z.enum(["user", "assistant"]), content: z.string().max(8000) }))
             .max(24)
             .default([]),
+        part: z.enum(["info", "knowledge"]).default("info"),
     })
         .parse(await c.req.json());
     if (!(await canSpend())) {
@@ -376,6 +383,7 @@ export const studio = new Hono()
                 projectId: project.id,
                 message: body.message,
                 history: body.history,
+                part: body.part,
                 signal: abort.signal,
                 onText: (delta) => {
                     void stream.writeSSE({ event: "text", data: JSON.stringify(delta) });
@@ -466,6 +474,128 @@ export const studio = new Hono()
         mode: query.mode,
         days: query.days,
     }));
+})
+    // --- Wissen: its items and Kategorien ---------------------------------------
+    .get("/projects/:id/knowledge", async (c) => c.json(await listKnowledge(c.get("user").id, c.req.param("id"))))
+    // What a link in a page names (`pages/bgb/p-281`): the studio opens it.
+    .get("/projects/:id/resolve", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    const found = await resolvePath(project.id, z.string().max(600).parse(c.req.query("path")));
+    if (!found) {
+        throw notFound();
+    }
+    return c.json(found);
+})
+    .post("/projects/:id/categories", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    await requireWritable(project);
+    const body = z
+        .object({
+        name: z.string().min(1).max(80),
+        type: z.enum(CATEGORY_TYPES),
+        unit: z.string().max(20).nullish(),
+        multiple: z.boolean().optional(),
+        ordered: z.boolean().optional(),
+        hint: z.string().max(120).nullish(),
+        values: z.array(z.string().max(200)).max(200).optional(),
+        tableId: z.string().nullish(),
+        columnId: z.string().nullish(),
+    })
+        .parse(await c.req.json());
+    const row = await putCategory(project.id, body);
+    return c.json({ id: row.id });
+})
+    .patch("/categories/:id", async (c) => {
+    const row = await categoryRow(c.req.param("id"));
+    await ownedProject(c.get("user").id, row.projectId);
+    const body = z
+        .object({
+        name: z.string().min(1).max(80).optional(),
+        unit: z.string().max(20).nullish(),
+        multiple: z.boolean().optional(),
+        ordered: z.boolean().optional(),
+        hint: z.string().max(120).nullish(),
+        proposed: z.literal(false).optional(),
+        position: z.number().int().min(0).optional(),
+    })
+        .parse(await c.req.json());
+    await updateCategory(row.id, body);
+    return c.json({ ok: true });
+})
+    .delete("/categories/:id", async (c) => {
+    const row = await categoryRow(c.req.param("id"));
+    await ownedProject(c.get("user").id, row.projectId);
+    await deleteCategory(row.id);
+    return c.json({ ok: true });
+})
+    .post("/categories/:id/values", async (c) => {
+    const row = await categoryRow(c.req.param("id"));
+    await ownedProject(c.get("user").id, row.projectId);
+    const { value } = z.object({ value: z.string().min(1).max(200) }).parse(await c.req.json());
+    return c.json(await addCategoryValue(row.id, value));
+})
+    .put("/categories/:id/values/order", async (c) => {
+    const row = await categoryRow(c.req.param("id"));
+    await ownedProject(c.get("user").id, row.projectId);
+    const { ids } = z.object({ ids: z.array(z.string()).max(500) }).parse(await c.req.json());
+    await orderCategoryValues(row.id, ids);
+    return c.json({ ok: true });
+})
+    .get("/values/:id", async (c) => c.json(await valueContents(c.get("user").id, c.req.param("id"))))
+    // Everything that has a Kategorie: the entries its page lists.
+    .get("/categories/:id/items", async (c) => c.json(await categoryContents(c.get("user").id, c.req.param("id"))))
+    .patch("/values/:id", async (c) => {
+    const { category } = await categoryValue(c.req.param("id"));
+    await ownedProject(c.get("user").id, category.projectId);
+    const { value } = z.object({ value: z.string().min(1).max(200) }).parse(await c.req.json());
+    await renameCategoryValue(c.req.param("id"), value);
+    return c.json({ ok: true });
+})
+    .post("/values/:id/merge", async (c) => {
+    const { category } = await categoryValue(c.req.param("id"));
+    await ownedProject(c.get("user").id, category.projectId);
+    const { into } = z.object({ into: z.string() }).parse(await c.req.json());
+    await mergeCategoryValues(c.req.param("id"), into);
+    return c.json({ ok: true });
+})
+    .delete("/values/:id", async (c) => {
+    const { category } = await categoryValue(c.req.param("id"));
+    await ownedProject(c.get("user").id, category.projectId);
+    await deleteCategoryValue(c.req.param("id"));
+    return c.json({ ok: true });
+})
+    // The Übersicht of a value: a model writes it from the value's items.
+    .post("/values/:id/summary", async (c) => {
+    const { category } = await categoryValue(c.req.param("id"));
+    const project = await ownedProject(c.get("user").id, category.projectId);
+    await requireWritable(project);
+    return c.json({ summary: await writeSummary(c.req.param("id")) });
+})
+    // A Kategorie a person sets on an item: `p:<page>`, `t:<table>`, `r:<row>`, `f:<file>`.
+    .put("/projects/:id/items/:key/categories/:categoryId", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    await requireWritable(project);
+    const key = c.req.param("key");
+    const id = key.slice(2);
+    const ref = key[0] === "p"
+        ? { pageId: id }
+        : key[0] === "t"
+            ? { tableId: id }
+            : key[0] === "r"
+                ? { rowId: id }
+                : key[0] === "f"
+                    ? { fileId: id }
+                    : null;
+    if (!ref || key[1] !== ":") {
+        throw new ServiceError("invalid", "Unbekannter Eintrag.");
+    }
+    const { values } = z
+        .object({ values: z.array(z.union([z.string().max(300), z.number(), z.boolean()])).max(50) })
+        .parse(await c.req.json());
+    if (await setItemCategory(project.id, ref, c.req.param("categoryId"), values)) {
+        queueIndex(key[0] === "p" ? `P:${id}` : key);
+    }
+    return c.json({ ok: true });
 })
     // --- the space's tables and pages --------------------------------------------
     .get("/projects/:id/data", async (c) => c.json(await listSpaceData(c.get("user").id, c.req.param("id"))))
@@ -475,6 +605,7 @@ export const studio = new Hono()
         title: z.string().max(120),
         wizardId: z.string().nullish(),
         columns: z.unknown().optional(),
+        format: z.enum(["faq"]).nullish(),
     })
         .parse(await c.req.json());
     return c.json(await createTable(c.get("user").id, c.req.param("id"), body));
@@ -486,6 +617,8 @@ export const studio = new Hono()
         title: z.string().max(120).optional(),
         wizardId: z.string().nullish(),
         columns: z.unknown().optional(),
+        format: z.enum(["faq"]).nullish(),
+        review: z.null().optional(),
     })
         .parse(await c.req.json());
     await updateTable(c.get("user").id, c.req.param("id"), body);
@@ -515,6 +648,7 @@ export const studio = new Hono()
         .object({
         title: z.string().max(200),
         wizardId: z.string().nullish(),
+        parentId: z.string().nullish(),
         markdown: z.string().optional(),
     })
         .parse(await c.req.json());
@@ -526,11 +660,18 @@ export const studio = new Hono()
         .object({
         title: z.string().max(200).optional(),
         wizardId: z.string().nullish(),
+        parentId: z.string().nullish(),
         markdown: z.string().optional(),
+        review: z.null().optional(),
     })
         .parse(await c.req.json());
     await updatePage(c.get("user").id, c.req.param("id"), body);
     return c.json({ ok: true });
+})
+    .put("/pages/:id/order", async (c) => {
+    const { ids } = z.object({ ids: z.array(z.string()).max(5000) }).parse(await c.req.json());
+    await orderSubPages(c.get("user").id, c.req.param("id"), ids);
+    return c.json({ ok: true });
 })
     .delete("/pages/:id", async (c) => {
     await deletePage(c.get("user").id, c.req.param("id"));