wizards 0.2.17 → 0.2.18

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

@@ -1,13 +1,16 @@
 import { TableColumnValueError, tableColumnsSchema, } from "@engenty-wizards/shared/engenty/data-tables";
 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 } from "drizzle-orm";
+import { and, asc, count, desc, eq, inArray, isNotNull, isNull, max } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { db, schema } from "../db/client.js";
 import { currentTenant } from "../tenants/tenant.js";
 import { projectWritable, requireWritableProject } from "./access.js";
 import { notFound, ServiceError } from "./errors.js";
+import { filePaths, freeSlug, knowledgePage, pageTree, tablePaths } from "./knowledge.js";
+import { queueIndex } from "./project-index.js";
 import { ownedProject } from "./projects.js";
+import { itemCategoriesOf, setItemCategories, syncTableRowCategories } from "./space-categories.js";
 /** A wizard of the space, or null for the space's own. */
 async function ownerOf(projectId, wizardId) {
     if (!wizardId) {
@@ -28,18 +31,19 @@ function cellError(err) {
     }
     throw err;
 }
-function checkColumns(columns) {
+export function checkColumns(columns) {
     const parsed = tableColumnsSchema.safeParse(columns);
     if (!parsed.success) {
         throw new ServiceError("invalid", parsed.error.issues[0]?.message ?? "Ungültige Spalten.");
     }
     return parsed.data;
 }
+/** Daten: the tables and pages the space's wizards keep, and the wizards to name whose they are. */
 export async function listSpaceData(userId, projectId) {
     const project = await ownedProject(userId, projectId);
     const [tables, rows, pages, wizards] = await Promise.all([
         db.query.spaceTable.findMany({
-            where: eq(schema.spaceTable.projectId, project.id),
+            where: and(eq(schema.spaceTable.projectId, project.id), isNotNull(schema.spaceTable.wizardId)),
             orderBy: [asc(schema.spaceTable.title)],
             columns: { id: true, wizardId: true, list: true, title: true, updatedAt: true },
         }),
@@ -50,7 +54,7 @@ export async function listSpaceData(userId, projectId) {
             .where(eq(schema.spaceTable.projectId, project.id))
             .groupBy(schema.spaceTableRow.tableId),
         db.query.spacePage.findMany({
-            where: eq(schema.spacePage.projectId, project.id),
+            where: and(eq(schema.spacePage.projectId, project.id), isNotNull(schema.spacePage.wizardId)),
             orderBy: [asc(schema.spacePage.title)],
             columns: { id: true, wizardId: true, title: true, updatedAt: true },
         }),
@@ -85,36 +89,74 @@ async function writableTable(tableId) {
     await requireWritableProject(table.projectId);
     return table;
 }
-async function touchTable(tableId) {
+/** A person changed a table: when a plugin wrote it, the plugin no longer does. */
+async function touchTable(table) {
     await db
         .update(schema.spaceTable)
-        .set({ updatedAt: new Date() })
-        .where(eq(schema.spaceTable.id, tableId));
+        .set({ updatedAt: new Date(), ...(table.origin && !table.kept ? { kept: true } : {}) })
+        .where(eq(schema.spaceTable.id, table.id));
 }
-export async function createTable(userId, projectId, input) {
-    const project = await ownedProject(userId, projectId);
-    await requireWritableProject(project.id);
+async function tableCount(projectId) {
     const [{ n }] = await db
         .select({ n: count() })
         .from(schema.spaceTable)
-        .where(eq(schema.spaceTable.projectId, project.id));
+        .where(eq(schema.spaceTable.projectId, projectId));
     if (n >= SPACE_DATA_LIMITS.tables) {
         throw new ServiceError("refused", `Ein Space hat höchstens ${SPACE_DATA_LIMITS.tables} Tabellen.`);
     }
+}
+export async function createTable(userId, projectId, input) {
+    const project = await ownedProject(userId, projectId);
+    await requireWritableProject(project.id);
+    await tableCount(project.id);
     const columns = input.columns
         ? checkColumns(input.columns)
-        : [{ id: "name", name: "Name", type: "text" }];
+        : input.format === "faq"
+            ? [
+                { id: "frage", name: "Frage", type: "text" },
+                {
+                    id: "antwort",
+                    name: "Antwort",
+                    type: "text",
+                    format: { style: "multiline" },
+                },
+            ]
+            : [{ id: "name", name: "Name", type: "text" }];
     const id = nanoid(12);
+    const wizardId = await ownerOf(project.id, input.wizardId);
+    const title = input.title.trim() || "Tabelle";
     await db.insert(schema.spaceTable).values({
         id,
         tenantId: currentTenant(),
         projectId: project.id,
-        wizardId: await ownerOf(project.id, input.wizardId),
-        title: input.title.trim() || "Tabelle",
+        wizardId,
+        title,
+        slug: wizardId ? null : await freeSlug(project.id, title, "table"),
+        format: input.format ?? null,
         columns,
     });
     return { id };
 }
+async function tableKnowledge(table) {
+    if (table.wizardId) {
+        return null;
+    }
+    const file = table.fileId
+        ? await db.query.projectFile.findFirst({
+            where: eq(schema.projectFile.id, table.fileId),
+            columns: { id: true, name: true, mime: true },
+        })
+        : undefined;
+    return {
+        path: (await tablePaths(table.projectId)).get(table.id) ?? "",
+        categories: (await itemCategoriesOf([{ tableId: table.id }])).get(`t:${table.id}`) ?? [],
+        origin: table.origin,
+        originLabel: table.originLabel,
+        kept: table.kept,
+        review: table.review,
+        file: file ?? null,
+    };
+}
 export async function getTable(userId, tableId) {
     const table = await tableRow(tableId);
     const project = await ownedProject(userId, table.projectId);
@@ -128,35 +170,66 @@ export async function getTable(userId, tableId) {
         wizardId: table.wizardId,
         list: table.list,
         title: table.title,
+        format: table.format,
         columns: table.columns,
         rows: rows.map((r) => ({ id: r.id, cells: r.cells, updatedAt: r.updatedAt.toISOString() })),
         readOnly: !(await projectWritable(project)),
+        knowledge: await tableKnowledge(table),
     };
 }
 /**
  * A new title, owner or columns. Rows keep their cells: a removed column's cells are dropped
- * the next time the row changes, and are not shown before.
+ * the next time the row changes, and are not shown before. `review: null`: a person looked.
  */
 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", "Diese Tabelle gehört zu einer Liste des Wizards: ihre Spalten kommen aus dem Wizard.");
     }
+    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;
+    const changed = title !== table.title || patch.columns !== undefined || patch.format !== undefined;
     await db
         .update(schema.spaceTable)
         .set({
-        ...(patch.title !== undefined ? { title: patch.title.trim() || table.title } : {}),
-        ...(patch.wizardId !== undefined
-            ? { wizardId: await ownerOf(table.projectId, patch.wizardId) }
+        title,
+        wizardId,
+        ...(title !== table.title || wizardId !== table.wizardId
+            ? { slug: wizardId ? null : await freeSlug(table.projectId, title, "table", table.id) }
             : {}),
         ...(patch.columns !== undefined ? { columns: checkColumns(patch.columns) } : {}),
+        ...(patch.format !== undefined ? { format: patch.format } : {}),
+        ...(patch.review === null ? { review: null } : {}),
+        ...(changed && table.origin ? { kept: true } : {}),
         updatedAt: new Date(),
     })
         .where(eq(schema.spaceTable.id, table.id));
+    if (changed || wizardId !== table.wizardId) {
+        queueIndex(`t:${table.id}`);
+    }
+}
+/** The file an item was read from goes with it, when it was uploaded and nothing else uses it. */
+async function dropOriginal(item) {
+    if (!item.fileId || item.originKey) {
+        return;
+    }
+    const used = (await db.query.spacePage.findFirst({
+        where: eq(schema.spacePage.fileId, item.fileId),
+        columns: { id: true },
+    })) ??
+        (await db.query.spaceTable.findFirst({
+            where: eq(schema.spaceTable.fileId, item.fileId),
+            columns: { id: true },
+        }));
+    if (!used) {
+        const { removeProjectFile } = await import("./project-files.js");
+        await removeProjectFile(item.projectId, item.fileId).catch(() => undefined);
+    }
 }
 export async function deleteTable(_userId, tableId) {
     const table = await writableTable(tableId);
     await db.delete(schema.spaceTable).where(eq(schema.spaceTable.id, table.id));
+    await dropOriginal(table);
 }
 /** The key a row of a shared list is matched on; tables made in the studio have none. */
 function keyOf(table, cells) {
@@ -177,6 +250,14 @@ async function refuseClash(tableId, key, rowId) {
         throw new ServiceError("invalid", "Diesen Eintrag gibt es schon.");
     }
 }
+/** After a row of a table of Wissen changed: its Kategorien from its columns, its unit. */
+async function rowChanged(table, rowId) {
+    if (table.wizardId) {
+        return;
+    }
+    await syncTableRowCategories(table.id, [rowId]);
+    queueIndex(`r:${rowId}`);
+}
 /** Adds a row; `cells` may leave columns empty, even required ones, to be filled later. */
 export async function addTableRow(_userId, tableId, cells = {}) {
     const table = await writableTable(tableId);
@@ -198,7 +279,8 @@ export async function addTableRow(_userId, tableId, cells = {}) {
     await refuseClash(table.id, key, null);
     const row = { id: nanoid(14), tableId: table.id, key, cells: value, createdAt: new Date() };
     await db.insert(schema.spaceTableRow).values(row);
-    await touchTable(table.id);
+    await touchTable(table);
+    await rowChanged(table, row.id);
     return { id: row.id, cells: value };
 }
 /** Changes the cells named in `cells`; the others stay. */
@@ -223,7 +305,8 @@ export async function updateTableRow(_userId, tableId, rowId, cells) {
         .update(schema.spaceTableRow)
         .set({ cells: value, key, updatedAt: new Date() })
         .where(eq(schema.spaceTableRow.id, row.id));
-    await touchTable(table.id);
+    await touchTable(table);
+    await rowChanged(table, row.id);
     return { id: row.id, cells: value };
 }
 export async function deleteTableRows(_userId, tableId, rowIds) {
@@ -234,7 +317,7 @@ export async function deleteTableRows(_userId, tableId, rowIds) {
     await db
         .delete(schema.spaceTableRow)
         .where(and(eq(schema.spaceTableRow.tableId, table.id), inArray(schema.spaceTableRow.id, rowIds)));
-    await touchTable(table.id);
+    await touchTable(table);
 }
 // --- pages ---------------------------------------------------------------------
 async function pageRow(pageId) {
@@ -252,25 +335,68 @@ function checkMarkdown(markdown) {
     }
     return markdown;
 }
-export async function createPage(userId, projectId, input) {
-    const project = await ownedProject(userId, projectId);
-    await requireWritableProject(project.id);
+async function pageCount(projectId, more = 1) {
     const [{ n }] = await db
         .select({ n: count() })
         .from(schema.spacePage)
-        .where(eq(schema.spacePage.projectId, project.id));
-    if (n >= SPACE_DATA_LIMITS.pages) {
+        .where(eq(schema.spacePage.projectId, projectId));
+    if (n + more > SPACE_DATA_LIMITS.pages) {
         throw new ServiceError("refused", `Ein Space hat höchstens ${SPACE_DATA_LIMITS.pages} Seiten.`);
     }
+}
+/** A page of the space's own that a sub-page may stand under: never one of its own sub-pages. */
+async function parentOf(projectId, parentId, pageId) {
+    if (!parentId) {
+        return null;
+    }
+    const parent = await db.query.spacePage.findFirst({
+        where: and(eq(schema.spacePage.id, parentId), eq(schema.spacePage.projectId, projectId)),
+        columns: { id: true, wizardId: true, parentId: true },
+    });
+    if (!parent || parent.wizardId) {
+        throw new ServiceError("invalid", "Unter diese Seite kann keine Seite.");
+    }
+    for (let at = parent.id; at && pageId;) {
+        if (at === pageId) {
+            throw new ServiceError("invalid", "Eine Seite kann nicht unter sich selbst stehen.");
+        }
+        const up = await db.query.spacePage.findFirst({
+            where: eq(schema.spacePage.id, at),
+            columns: { parentId: true },
+        });
+        at = up?.parentId ?? null;
+    }
+    return parent.id;
+}
+async function nextPosition(projectId, parentId) {
+    const [{ last }] = await db
+        .select({ last: max(schema.spacePage.position) })
+        .from(schema.spacePage)
+        .where(and(eq(schema.spacePage.projectId, projectId), isNull(schema.spacePage.wizardId), parentId ? eq(schema.spacePage.parentId, parentId) : isNull(schema.spacePage.parentId)));
+    return (last ?? -1) + 1;
+}
+export async function createPage(userId, projectId, input) {
+    const project = await ownedProject(userId, projectId);
+    await requireWritableProject(project.id);
+    await pageCount(project.id);
     const id = nanoid(12);
+    const wizardId = await ownerOf(project.id, input.wizardId);
+    const parentId = wizardId ? null : await parentOf(project.id, input.parentId);
+    const title = input.title.trim() || "Seite";
     await db.insert(schema.spacePage).values({
         id,
         tenantId: currentTenant(),
         projectId: project.id,
-        wizardId: await ownerOf(project.id, input.wizardId),
-        title: input.title.trim() || "Seite",
+        wizardId,
+        parentId,
+        position: wizardId ? 0 : await nextPosition(project.id, parentId),
+        title,
+        slug: wizardId ? null : await freeSlug(project.id, title, { parentId }),
         markdown: checkMarkdown(input.markdown ?? ""),
     });
+    if (!wizardId) {
+        queueIndex(`p:${id}`);
+    }
     return { id };
 }
 export async function getPage(userId, pageId) {
@@ -284,42 +410,80 @@ export async function getPage(userId, pageId) {
         markdown: page.markdown,
         updatedAt: page.updatedAt.toISOString(),
         readOnly: !(await projectWritable(project)),
+        knowledge: page.wizardId ? null : await knowledgePage(page),
     };
 }
+/**
+ * A new title, text, owner or place. A person who changes what a plugin wrote keeps the page:
+ * the plugin no longer writes it. `review: null`: a person looked at it.
+ */
 export async function updatePage(_userId, pageId, patch) {
     const page = await pageRow(pageId);
     await requireWritableProject(page.projectId);
+    const title = patch.title !== undefined ? patch.title.trim() || page.title : page.title;
+    const wizardId = patch.wizardId !== undefined ? await ownerOf(page.projectId, patch.wizardId) : page.wizardId;
+    const parentId = wizardId !== null
+        ? null
+        : patch.parentId !== undefined
+            ? await parentOf(page.projectId, patch.parentId, page.id)
+            : page.parentId;
+    const moved = title !== page.title || wizardId !== page.wizardId || parentId !== page.parentId;
+    const edited = moved || (patch.markdown !== undefined && patch.markdown !== page.markdown);
     await db
         .update(schema.spacePage)
         .set({
-        ...(patch.title !== undefined ? { title: patch.title.trim() || page.title } : {}),
-        ...(patch.wizardId !== undefined
-            ? { wizardId: await ownerOf(page.projectId, patch.wizardId) }
+        title,
+        wizardId,
+        parentId,
+        ...(moved
+            ? {
+                slug: wizardId ? null : await freeSlug(page.projectId, title, { parentId }, page.id),
+                ...(parentId !== page.parentId
+                    ? { position: await nextPosition(page.projectId, parentId) }
+                    : {}),
+            }
             : {}),
         ...(patch.markdown !== undefined ? { markdown: checkMarkdown(patch.markdown) } : {}),
+        ...(patch.review === null ? { review: null } : {}),
+        ...(edited && page.origin ? { kept: true } : {}),
         updatedAt: new Date(),
     })
         .where(eq(schema.spacePage.id, page.id));
+    if (moved) {
+        queueIndex(`P:${page.id}`);
+    }
+    else if (edited) {
+        queueIndex(`p:${page.id}`);
+    }
 }
 export async function deletePage(_userId, pageId) {
     const page = await pageRow(pageId);
     await requireWritableProject(page.projectId);
     await db.delete(schema.spacePage).where(eq(schema.spacePage.id, page.id));
+    await dropOriginal(page);
+}
+/** Puts a page's sub-pages into the order of `ids`. */
+export async function orderSubPages(_userId, pageId, ids) {
+    const page = await pageRow(pageId);
+    await requireWritableProject(page.projectId);
+    for (const [position, id] of ids.entries()) {
+        await db
+            .update(schema.spacePage)
+            .set({ position })
+            .where(and(eq(schema.spacePage.id, id), eq(schema.spacePage.parentId, page.id)));
+    }
 }
 // --- what runs read and write --------------------------------------------------
 // A run writes the pages of its own wizard, on the runtime it runs on: a run on the server writes
 // the server's, also in a space a local install synced, which the studio there only shows. It
-// reads its wizard's pages and the space's own.
-/** The pages a run can read: its wizard's, then the space's own. */
+// reads its wizard's pages; the space's own are Wissen, read by path.
+/** The pages of a run's wizard. */
 export async function runPages(projectId, wizardId) {
-    const pages = await db.query.spacePage.findMany({
-        where: eq(schema.spacePage.projectId, projectId),
+    return db.query.spacePage.findMany({
+        where: and(eq(schema.spacePage.projectId, projectId), eq(schema.spacePage.wizardId, wizardId)),
         columns: { id: true, wizardId: true, title: true, markdown: true, updatedAt: true },
         orderBy: [asc(schema.spacePage.title)],
     });
-    return pages
-        .filter((p) => p.wizardId === wizardId || p.wizardId === null)
-        .sort((a, b) => Number(b.wizardId === wizardId) - Number(a.wizardId === wizardId));
 }
 /** Writes a page of the run's wizard: a new one, or the one with this title, replaced or added to. */
 export async function writeRunPage(projectId, wizardId, input) {
@@ -359,3 +523,267 @@ export async function writeRunPage(projectId, wizardId, input) {
     });
     return { id, title, chars: markdown.length, made: true };
 }
+async function originSpace(space) {
+    const project = await db.query.project.findFirst({
+        where: and(eq(schema.project.id, space), eq(schema.project.tenantId, currentTenant())),
+        columns: { id: true },
+    });
+    if (!project) {
+        throw new ServiceError("not_found", `There is no space "${space}".`);
+    }
+    await requireWritableProject(project.id);
+    return project.id;
+}
+/** Keeps the original of what a plugin wrote: a document of the space under the same key. */
+async function originalFile(origin, projectId, key, label, original, text) {
+    const { putOriginFile } = await import("./project-files.js");
+    return putOriginFile(origin, {
+        space: projectId,
+        key,
+        label,
+        name: original.name,
+        mime: original.mime,
+        data: original.data,
+        text,
+    });
+}
+export async function putOriginPage(origin, input) {
+    const projectId = await originSpace(input.space);
+    const key = input.key.trim().slice(0, 300);
+    const existing = await db.query.spacePage.findFirst({
+        where: and(eq(schema.spacePage.projectId, projectId), eq(schema.spacePage.origin, origin), eq(schema.spacePage.originKey, key)),
+    });
+    if (existing?.kept) {
+        return { id: existing.id, state: "kept" };
+    }
+    const parent = input.parent
+        ? await db.query.spacePage.findFirst({
+            where: and(eq(schema.spacePage.projectId, projectId), eq(schema.spacePage.origin, origin), eq(schema.spacePage.originKey, input.parent)),
+            columns: { id: true },
+        })
+        : null;
+    if (input.parent && !parent) {
+        throw new ServiceError("invalid", `There is no page with the key "${input.parent}" to stand under.`);
+    }
+    const title = input.title.replace(/\s+/g, " ").trim().slice(0, 200) || "Seite";
+    const markdown = checkMarkdown(input.markdown);
+    const label = input.label?.trim().slice(0, 120) || null;
+    const parentId = parent?.id ?? null;
+    const fileId = input.original
+        ? await originalFile(origin, projectId, key, label, input.original, markdown)
+        : (existing?.fileId ?? null);
+    const position = input.position ?? existing?.position ?? (await nextPosition(projectId, parentId));
+    let id = existing?.id;
+    const moved = !existing || existing.title !== title || existing.parentId !== parentId;
+    if (existing) {
+        await db
+            .update(schema.spacePage)
+            .set({
+            title,
+            markdown,
+            parentId,
+            position,
+            originLabel: label,
+            fileId,
+            review: input.review ?? null,
+            ...(moved ? { slug: await freeSlug(projectId, title, { parentId }, existing.id) } : {}),
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.spacePage.id, existing.id));
+    }
+    else {
+        await pageCount(projectId);
+        id = nanoid(12);
+        await db.insert(schema.spacePage).values({
+            id,
+            tenantId: currentTenant(),
+            projectId,
+            parentId,
+            position,
+            title,
+            slug: await freeSlug(projectId, title, { parentId }),
+            markdown,
+            origin,
+            originKey: key,
+            originLabel: label,
+            fileId,
+            review: input.review ?? null,
+        });
+    }
+    const set = input.categories
+        ? await setItemCategories(projectId, { pageId: id }, input.categories, "origin")
+        : { changed: false };
+    queueIndex(`${moved || set.changed ? "P" : "p"}:${id}`);
+    return { id: id, state: "written" };
+}
+export async function putOriginTable(origin, input) {
+    const projectId = await originSpace(input.space);
+    const key = input.key.trim().slice(0, 300);
+    const existing = await db.query.spaceTable.findFirst({
+        where: and(eq(schema.spaceTable.projectId, projectId), eq(schema.spaceTable.origin, origin), eq(schema.spaceTable.originKey, key)),
+    });
+    if (existing?.kept) {
+        return { id: existing.id, state: "kept" };
+    }
+    const columns = checkColumns(input.columns);
+    if (input.rows.length > SPACE_DATA_LIMITS.rowsPerTable) {
+        throw new ServiceError("refused", `A table keeps at most ${SPACE_DATA_LIMITS.rowsPerTable} rows.`);
+    }
+    let cells;
+    try {
+        cells = input.rows.map((row) => editCells(columns, {}, row));
+    }
+    catch (err) {
+        cellError(err);
+    }
+    const title = input.title.replace(/\s+/g, " ").trim().slice(0, 120) || "Tabelle";
+    const label = input.label?.trim().slice(0, 120) || null;
+    const csv = [
+        columns.map((c) => c.name).join(","),
+        ...cells.map((r) => columns.map((c) => String(r[c.id] ?? "")).join(",")),
+    ].join("\n");
+    const fileId = input.original
+        ? await originalFile(origin, projectId, key, label, input.original, csv)
+        : (existing?.fileId ?? null);
+    let id = existing?.id;
+    if (existing) {
+        await db
+            .update(schema.spaceTable)
+            .set({
+            title,
+            columns,
+            format: input.format ?? null,
+            originLabel: label,
+            fileId,
+            review: input.review ?? null,
+            ...(existing.title !== title
+                ? { slug: await freeSlug(projectId, title, "table", existing.id) }
+                : {}),
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.spaceTable.id, existing.id));
+        await db.delete(schema.spaceTableRow).where(eq(schema.spaceTableRow.tableId, existing.id));
+    }
+    else {
+        await tableCount(projectId);
+        id = nanoid(12);
+        await db.insert(schema.spaceTable).values({
+            id,
+            tenantId: currentTenant(),
+            projectId,
+            title,
+            slug: await freeSlug(projectId, title, "table"),
+            format: input.format ?? null,
+            columns,
+            origin,
+            originKey: key,
+            originLabel: label,
+            fileId,
+            review: input.review ?? null,
+        });
+    }
+    const now = Date.now();
+    for (let i = 0; i < cells.length; i += 200) {
+        await db.insert(schema.spaceTableRow).values(cells.slice(i, i + 200).map((c, j) => ({
+            id: nanoid(14),
+            tableId: id,
+            cells: c,
+            // The order they came in: one millisecond apart.
+            createdAt: new Date(now - cells.length + i + j),
+        })));
+    }
+    if (input.categories) {
+        await setItemCategories(projectId, { tableId: id }, input.categories, "origin");
+    }
+    await syncTableRowCategories(id);
+    queueIndex(`t:${id}`);
+    return { id: id, state: "written" };
+}
+/** What a plugin wrote into a space, by its keys. */
+export async function listOrigin(origin, space) {
+    const projectId = await originSpace(space);
+    const [pages, tables, files] = await Promise.all([
+        // What a document of the plugin was read into stands behind the document, not on its own.
+        db.query.spacePage.findMany({
+            where: and(eq(schema.spacePage.projectId, projectId), eq(schema.spacePage.origin, origin), isNotNull(schema.spacePage.originKey)),
+            columns: {
+                id: true,
+                originKey: true,
+                title: true,
+                kept: true,
+                review: true,
+                updatedAt: true,
+            },
+        }),
+        db.query.spaceTable.findMany({
+            where: and(eq(schema.spaceTable.projectId, projectId), eq(schema.spaceTable.origin, origin), isNotNull(schema.spaceTable.originKey)),
+            columns: {
+                id: true,
+                originKey: true,
+                title: true,
+                kept: true,
+                review: true,
+                updatedAt: true,
+            },
+        }),
+        db.query.projectFile.findMany({
+            where: and(eq(schema.projectFile.projectId, projectId), eq(schema.projectFile.origin, origin)),
+            columns: { id: true, originKey: true, name: true, updatedAt: true },
+        }),
+    ]);
+    const [tree, tPaths, fPaths] = await Promise.all([
+        pageTree(projectId),
+        tablePaths(projectId),
+        filePaths(projectId),
+    ]);
+    return [
+        ...pages.map((p) => ({
+            key: p.originKey,
+            kind: "page",
+            id: p.id,
+            title: p.title,
+            path: tree.get(p.id)?.path ?? "",
+            state: (p.kept ? "kept" : "written"),
+            review: p.review,
+            updatedAt: p.updatedAt.toISOString(),
+        })),
+        ...tables.map((t) => ({
+            key: t.originKey,
+            kind: "table",
+            id: t.id,
+            title: t.title,
+            path: tPaths.get(t.id) ?? "",
+            state: (t.kept ? "kept" : "written"),
+            review: t.review,
+            updatedAt: t.updatedAt.toISOString(),
+        })),
+        ...files.map((f) => ({
+            key: f.originKey,
+            kind: "file",
+            id: f.id,
+            title: f.name,
+            path: fPaths.get(f.id) ?? "",
+            state: "written",
+            review: null,
+            updatedAt: f.updatedAt.toISOString(),
+        })),
+    ];
+}
+/**
+ * Takes out what a plugin wrote under a key, or without a key everything it wrote into the
+ * space. What a person changed since stays. Returns how many items went.
+ */
+export async function removeOrigin(origin, space, key) {
+    const projectId = await originSpace(space);
+    const pages = await db
+        .delete(schema.spacePage)
+        .where(and(eq(schema.spacePage.projectId, projectId), eq(schema.spacePage.origin, origin), eq(schema.spacePage.kept, false), key === undefined ? undefined : eq(schema.spacePage.originKey, key)))
+        .returning({ id: schema.spacePage.id });
+    const tables = await db
+        .delete(schema.spaceTable)
+        .where(and(eq(schema.spaceTable.projectId, projectId), eq(schema.spaceTable.origin, origin), eq(schema.spaceTable.kept, false), key === undefined ? undefined : eq(schema.spaceTable.originKey, key)))
+        .returning({ id: schema.spaceTable.id });
+    const { removeOriginFiles } = await import("./project-files.js");
+    const files = await removeOriginFiles(origin, projectId, key);
+    return pages.length + tables.length + files;
+}