wizards 0.1.9

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

@@ -0,0 +1,202 @@
+import { cleanPath, WORKSPACE_LIMITS } from "@engenty-wizards/shared/workspace";
+import { strFromU8, strToU8, unzipSync, zipSync } from "fflate";
+import { z } from "zod";
+import { listConnectors } from "../connectors/external.js";
+import { getBlob } from "../files/blobs.js";
+import { ServiceError } from "./errors.js";
+import { draftFiles, writeFile } from "./files.js";
+import { ownedProject } from "./projects.js";
+import { createWizard, deleteWizard, draftIssues, ownedWizard, parseDraft } from "./wizards.js";
+/**
+ * A wizard as a file, `<title>.wizard`: a zip with `wizard.json` — the definition and what it
+ * needs from its project — and the workspace under `files/`. What belongs to people (runs, lists, connected
+ * accounts) and to the project (brand, credentials) stays where it is.
+ */
+const FORMAT = "engenty-wizard";
+const MANIFEST = "wizard.json";
+const FILES = "files/";
+export const PACKAGE_EXTENSION = ".wizard";
+/** A type of its own: under `application/zip` a browser may save the file as `.zip`. */
+export const PACKAGE_MIME = "application/vnd.engenty.wizard+zip";
+/** The workspace's 25 MB, with room for the manifest and the zip's own overhead. */
+export const PACKAGE_MAX_BYTES = 30_000_000;
+const manifestSchema = z.object({
+    format: z.literal(FORMAT),
+    version: z.literal(1),
+    exportedAt: z.string().optional(),
+    definition: z.unknown(),
+    /** Imported connectors the wizard's connections name. No address: one pasted by hand can hold a secret. */
+    connectors: z
+        .array(z.object({
+        id: z.string().max(60),
+        name: z.string().max(120),
+        domain: z.string().max(253).optional(),
+        sourceKind: z.enum(["openapi", "mcp"]).optional(),
+    }))
+        .max(50)
+        .default([]),
+    /** Project MCP servers the wizard's steps name — by name only, their address and headers are credentials. */
+    mcpServers: z
+        .array(z.object({ id: z.string().max(31), name: z.string().max(60) }))
+        .max(10)
+        .default([]),
+});
+function fileName(title) {
+    const slug = title
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 60);
+    return `${slug || "wizard"}${PACKAGE_EXTENSION}`;
+}
+export async function exportWizard(userId, wizardId) {
+    const w = await ownedWizard(userId, wizardId);
+    const project = await ownedProject(userId, w.projectId);
+    const named = new Set((w.draft.connections ?? []).map((c) => c.connector));
+    const servers = new Set(w.draft.steps.flatMap((s) => (s.type === "agent" ? (s.mcp ?? []) : [])));
+    const manifest = {
+        format: FORMAT,
+        version: 1,
+        exportedAt: new Date().toISOString(),
+        definition: w.draft,
+        connectors: (await listConnectors(project.id))
+            .filter((c) => c.sourceKind !== "builtin" && named.has(c.id))
+            .map((c) => ({
+            id: c.id,
+            name: c.name,
+            domain: c.domain,
+            sourceKind: c.sourceKind,
+        })),
+        mcpServers: project.mcpServers
+            .filter((s) => servers.has(s.id))
+            .map((s) => ({ id: s.id, name: s.name })),
+    };
+    const entries = {
+        [MANIFEST]: strToU8(JSON.stringify(manifest, null, 2)),
+    };
+    for (const f of await draftFiles(w.id)) {
+        entries[FILES + f.path] = new Uint8Array(await getBlob(f.hash));
+    }
+    return { name: fileName(w.draft.title), zip: zipSync(entries, { level: 6 }) };
+}
+const invalid = (message) => new ServiceError("invalid", message);
+function json(data) {
+    try {
+        return JSON.parse(strFromU8(data));
+    }
+    catch {
+        throw invalid("Das ist kein Wizard-Paket: wizard.json ist kein gültiges JSON.");
+    }
+}
+/** A manifest, or a bare definition: a wizard without workspace is fully told by its JSON. */
+function readManifest(raw) {
+    if (raw?.format !== FORMAT) {
+        return { format: FORMAT, version: 1, definition: raw, connectors: [], mcpServers: [] };
+    }
+    const parsed = manifestSchema.safeParse(raw);
+    if (!parsed.success) {
+        throw invalid("Dieses Wizard-Paket stammt aus einer neueren Version oder ist beschädigt.");
+    }
+    return parsed.data;
+}
+/** The package's content, checked against the workspace limits before anything is unpacked. */
+function readPackage(data) {
+    const zipped = data[0] === 0x50 && data[1] === 0x4b;
+    if (!zipped) {
+        return { manifest: readManifest(json(data)), files: [] };
+    }
+    let total = 0;
+    let count = 0;
+    let entries;
+    try {
+        entries = unzipSync(data, {
+            filter: (file) => {
+                // Folders, and what the Finder adds when a package is zipped by hand.
+                if (file.name.endsWith("/") || /(^|\/)(__MACOSX\/|\.DS_Store$)/.test(file.name)) {
+                    return false;
+                }
+                total += file.originalSize;
+                count += 1;
+                if (file.originalSize > WORKSPACE_LIMITS.fileBytes) {
+                    throw invalid(`${file.name} ist größer als 5 MB.`);
+                }
+                if (count > WORKSPACE_LIMITS.files + 1 || total > PACKAGE_MAX_BYTES) {
+                    throw invalid("Das Paket ist größer als ein Workspace sein darf (200 Dateien, 25 MB).");
+                }
+                return true;
+            },
+        });
+    }
+    catch (err) {
+        throw err instanceof ServiceError ? err : invalid("Das Paket lässt sich nicht entpacken.");
+    }
+    // A package unpacked and zipped again often sits in a folder of its own.
+    const manifestPath = Object.keys(entries)
+        .filter((name) => name === MANIFEST || name.endsWith(`/${MANIFEST}`))
+        .sort((a, b) => a.length - b.length)[0];
+    if (manifestPath === undefined) {
+        throw invalid("Das ist kein Wizard-Paket: wizard.json fehlt.");
+    }
+    const root = manifestPath.slice(0, -MANIFEST.length);
+    const files = Object.entries(entries)
+        .filter(([name]) => name.startsWith(root + FILES))
+        .map(([name, content]) => {
+        const path = cleanPath(name.slice(root.length + FILES.length));
+        if (!path) {
+            throw invalid(`"${name}" ist kein gültiger Dateipfad.`);
+        }
+        return { path, data: content };
+    });
+    if (files.reduce((n, f) => n + f.data.byteLength, 0) > WORKSPACE_LIMITS.totalBytes) {
+        throw invalid("Der Workspace im Paket ist größer als 25 MB.");
+    }
+    return { manifest: readManifest(json(entries[manifestPath])), files };
+}
+/** What the wizard names that the project does not have, in words for the chat. */
+async function missing(userId, projectId, draft, manifest) {
+    const project = await ownedProject(userId, projectId);
+    const connectors = await listConnectors(project.id);
+    const wanted = [...new Set((draft.connections ?? []).flatMap((c) => c.connector ?? []))];
+    const servers = [
+        ...new Set(draft.steps.flatMap((s) => (s.type === "agent" ? (s.mcp ?? []) : []))),
+    ];
+    return [
+        ...wanted
+            .filter((id) => !connectors.some((c) => c.id === id))
+            .map((id) => {
+            const told = manifest.connectors.find((c) => c.id === id);
+            return `Connector „${told?.name ?? id}“${told?.domain ? ` (${told.domain})` : ""}`;
+        }),
+        ...servers
+            .filter((id) => !project.mcpServers.some((s) => s.id === id))
+            .map((id) => `MCP-Server „${manifest.mcpServers.find((s) => s.id === id)?.name ?? id}“`),
+    ];
+}
+/** Makes a new wizard of a package in the project: the draft and its workspace, not published. */
+export async function importWizard(userId, projectId, data, name) {
+    const { manifest, files } = readPackage(data);
+    // The shape is checked before anything is written; a wrong one leaves no wizard behind.
+    const { draft } = parseDraft(manifest.definition, files.map((f) => f.path));
+    const lacks = await missing(userId, projectId, draft, manifest);
+    const note = [
+        `Importiert${name ? ` aus „${name}“` : ""}: ${draft.steps.length} Schritte, ${files.length} ${files.length === 1 ? "Datei" : "Dateien"}.`,
+        lacks.length
+            ? `Diesem Projekt fehlt noch: ${lacks.join(", ")} – in den Einstellungen unter „Connectors“ hinzufügen.`
+            : "",
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+    const { id } = await createWizard(userId, { projectId, definition: draft, note });
+    try {
+        for (const file of files) {
+            await writeFile(userId, id, file.path, file.data);
+        }
+    }
+    catch (err) {
+        await deleteWizard(userId, id);
+        throw err;
+    }
+    return { id, issues: await draftIssues(await ownedWizard(userId, id)) };
+}

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { managed } from "../manage.js";
+import { readSetting, writeSetting } from "../settings.js";
+export const profileSchema = z.object({
+    name: z.string().trim().max(80),
+    about: z.string().trim().max(2000),
+    email: z.string().trim().max(200),
+    phone: z.string().trim().max(40),
+});
+const key = (user) => `profile:${user.tenantId}:${user.id}`;
+export async function userProfile(user) {
+    const stored = (await readSetting(key(user))) ?? {};
+    return {
+        name: (managed ? "" : stored.name) || user.name,
+        about: stored.about ?? "",
+        email: (managed ? "" : stored.email) || user.email,
+        phone: stored.phone ?? "",
+    };
+}
+export async function saveProfile(user, profile) {
+    await writeSetting(key(user), profile);
+    return userProfile(user);
+}

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

@@ -0,0 +1,266 @@
+import { PROJECT_LIMITS, projectFileLimit, } from "@engenty-wizards/shared/projects";
+import { generateText } from "ai";
+import { and, asc, count, eq, max } from "drizzle-orm";
+import { db, schema } from "../db/client.js";
+import { documentMime, UnreadableDocument } from "../documents/parse.js";
+import { loadAsset, removeAsset, saveAsset } from "../files/storage.js";
+import { textModel } from "../models.js";
+import { dropLinks, putLink } from "../tenants/control.js";
+import { notFound, ServiceError } from "./errors.js";
+import { dropIndex, indexDocument } from "./project-index.js";
+/** Reading a file takes seconds to a few minutes; a row still `pending` after this was cut off. */
+const STALE_MS = 15 * 60_000;
+const SEEN_BY_MODEL = ["image/png", "image/jpeg", "image/webp", "image/gif"];
+export function fileView(row) {
+    const stale = row.status === "pending" && Date.now() - row.updatedAt.getTime() > STALE_MS;
+    return {
+        id: row.id,
+        kind: row.kind,
+        name: row.name,
+        mime: row.mime,
+        size: row.size,
+        description: row.description,
+        source: row.source,
+        status: stale ? "failed" : row.status,
+        error: stale ? "Unterbrochen. Bitte neu einlesen." : row.error,
+        indexed: row.indexed,
+        pages: row.pages,
+        chars: row.chars,
+        createdAt: row.createdAt.toISOString(),
+    };
+}
+export function projectFiles(projectId, kind) {
+    return db.query.projectFile.findMany({
+        where: kind
+            ? and(eq(schema.projectFile.projectId, projectId), eq(schema.projectFile.kind, kind))
+            : eq(schema.projectFile.projectId, projectId),
+        orderBy: [asc(schema.projectFile.position), asc(schema.projectFile.createdAt)],
+    });
+}
+export async function projectFile(projectId, fileId) {
+    const row = await db.query.projectFile.findFirst({
+        where: and(eq(schema.projectFile.id, fileId), eq(schema.projectFile.projectId, projectId)),
+    });
+    if (!row) {
+        throw notFound();
+    }
+    return row;
+}
+export async function projectFileContent(projectId, fileId) {
+    const row = await projectFile(projectId, fileId);
+    const found = await loadAsset(row.id);
+    if (!found) {
+        throw notFound();
+    }
+    return { row, data: found.data };
+}
+function accepts(kind, mime) {
+    if (kind === "logo") {
+        return mime.startsWith("image/");
+    }
+    if (kind === "asset") {
+        return /^(image|video|audio)\//.test(mime);
+    }
+    return true;
+}
+export async function addProjectFile(projectId, input) {
+    const mime = documentMime(input.name, input.mime) || "application/octet-stream";
+    if (!accepts(input.kind, mime)) {
+        throw new ServiceError("invalid", input.kind === "logo"
+            ? "Ein Logo ist ein Bild (PNG, SVG, JPEG, WebP)."
+            : "Hierher gehören Bilder, Grafiken, Videos und Audio. Anderes bitte zu den Dokumenten.");
+    }
+    const limit = projectFileLimit(input.kind, mime);
+    if (!input.data.byteLength || input.data.byteLength > limit) {
+        throw new ServiceError("invalid", `Bitte eine Datei bis ${Math.round(limit / 1_000_000)} MB wählen.`);
+    }
+    const scope = and(eq(schema.projectFile.projectId, projectId), eq(schema.projectFile.kind, input.kind));
+    const [{ n, last }] = await db
+        .select({ n: count(), last: max(schema.projectFile.position) })
+        .from(schema.projectFile)
+        .where(scope);
+    if (n >= PROJECT_LIMITS.files[input.kind]) {
+        throw new ServiceError("refused", `Höchstens ${PROJECT_LIMITS.files[input.kind]} Dateien.`);
+    }
+    const name = input.name.slice(0, 120) || "datei";
+    const ref = await saveAsset({
+        kind: input.kind === "logo" ? "logo" : "project",
+        mime,
+        name,
+        data: input.data,
+    });
+    const description = input.description?.trim().slice(0, 600) ?? "";
+    const work = input.kind === "document" || (!description && SEEN_BY_MODEL.includes(mime));
+    const [row] = await db
+        .insert(schema.projectFile)
+        .values({
+        id: ref.id,
+        projectId,
+        kind: input.kind,
+        name,
+        mime,
+        size: input.data.byteLength,
+        description,
+        source: input.source ?? null,
+        position: (last ?? -1) + 1,
+        status: work ? "pending" : "ready",
+    })
+        .returning();
+    if (input.kind === "logo") {
+        // Logos are shown on public pages, where only the control database knows the tenant.
+        await putLink(ref.id, "logo", ref.id);
+    }
+    if (work) {
+        void prepare(row);
+    }
+    return row;
+}
+// --- reading, describing, indexing -------------------------------------------------
+/** Files are worked through two at a time: each costs model calls. */
+let running = 0;
+const waiting = [];
+async function slot(run) {
+    if (running >= 2) {
+        await new Promise((resolve) => waiting.push(resolve));
+    }
+    running++;
+    try {
+        return await run();
+    }
+    finally {
+        running--;
+        waiting.shift()?.();
+    }
+}
+async function projectLine(projectId) {
+    const p = await db.query.project.findFirst({ where: eq(schema.project.id, projectId) });
+    return [p?.brand.name || p?.name, p?.brand.about?.slice(0, 300)].filter(Boolean).join(" — ");
+}
+/** One sentence about a picture, for whoever picks among the project's files later. */
+async function describeImage(row, data) {
+    const seer = await textModel("standard");
+    const result = await generateText({
+        model: seer.model,
+        maxOutputTokens: 300,
+        system: [
+            "You catalogue the files of a project. Describe the picture in ONE sentence of at most 25 words: what it shows, its style and colours, and what it suits (a logo on dark ground, a header image, a team photo, a product shot).",
+            "Write in the language of the project's description; if unclear, German. No preamble, no quotes.",
+        ].join("\n"),
+        messages: [
+            {
+                role: "user",
+                content: [
+                    { type: "file", data, mediaType: row.mime, filename: row.name },
+                    {
+                        type: "text",
+                        text: `Project: ${await projectLine(row.projectId)}\nFile: ${row.name} (${row.kind})`,
+                    },
+                ],
+            },
+        ],
+    });
+    return result.text.trim().slice(0, 600);
+}
+async function describeDocument(row, text) {
+    const reader = await textModel("classifier");
+    const result = await generateText({
+        model: reader.model,
+        maxOutputTokens: 300,
+        system: [
+            "You catalogue the documents of a project. Say in ONE sentence of at most 30 words what this document is and what can be looked up in it.",
+            "Write in the document's language. No preamble, no quotes.",
+        ].join("\n"),
+        prompt: `File: ${row.name}\n\n${text.slice(0, 6000)}`,
+    });
+    return result.text.trim().slice(0, 600);
+}
+/** Reads a new file: a document goes into the index, and a file nobody described is described. */
+async function prepare(row) {
+    await slot(async () => {
+        const set = (values) => db
+            .update(schema.projectFile)
+            .set({ ...values, updatedAt: new Date() })
+            .where(eq(schema.projectFile.id, row.id));
+        try {
+            const found = await loadAsset(row.id);
+            if (!found) {
+                return;
+            }
+            const data = new Uint8Array(found.data);
+            if (row.kind !== "document") {
+                const description = await describeImage(row, data).catch(() => "");
+                await set({ status: "ready", ...(description ? { description } : {}) });
+                return;
+            }
+            const { text, ...indexed } = await indexDocument(row, data);
+            const description = row.description || (text ? await describeDocument(row, text).catch(() => "") : "");
+            await set({ ...indexed, status: "ready", error: null, description });
+        }
+        catch (err) {
+            console.error("[project-file]", row.name, err);
+            await set({
+                status: "failed",
+                error: err instanceof UnreadableDocument
+                    ? err.message
+                    : "Das Lesen hat nicht geklappt. Bitte noch einmal versuchen.",
+            });
+        }
+    });
+}
+export async function reindexProjectFile(projectId, fileId) {
+    const row = await projectFile(projectId, fileId);
+    if (row.kind !== "document") {
+        throw new ServiceError("invalid", "Nur Dokumente stehen im Index.");
+    }
+    const [pending] = await db
+        .update(schema.projectFile)
+        .set({ status: "pending", error: null, updatedAt: new Date() })
+        .where(eq(schema.projectFile.id, row.id))
+        .returning();
+    void prepare(pending);
+    return pending;
+}
+export async function updateProjectFile(projectId, fileId, patch) {
+    const row = await projectFile(projectId, fileId);
+    const [updated] = await db
+        .update(schema.projectFile)
+        .set({
+        ...(patch.name?.trim() ? { name: patch.name.trim().slice(0, 120) } : {}),
+        ...(patch.description !== undefined
+            ? { description: patch.description.trim().slice(0, 600) }
+            : {}),
+    })
+        .where(eq(schema.projectFile.id, row.id))
+        .returning();
+    return updated;
+}
+/** Puts the files of one kind into the order of `ids`; the first logo is the one end users see. */
+export async function orderProjectFiles(projectId, kind, ids) {
+    const rows = await projectFiles(projectId, kind);
+    const order = [...ids.filter((id) => rows.some((r) => r.id === id))];
+    for (const r of rows) {
+        if (!order.includes(r.id)) {
+            order.push(r.id);
+        }
+    }
+    for (const [position, id] of order.entries()) {
+        await db.update(schema.projectFile).set({ position }).where(eq(schema.projectFile.id, id));
+    }
+}
+async function removeRow(row) {
+    await dropIndex(row.id);
+    await db.delete(schema.projectFile).where(eq(schema.projectFile.id, row.id));
+    await removeAsset(row.id);
+    if (row.kind === "logo") {
+        await dropLinks([row.id]);
+    }
+}
+export async function removeProjectFile(projectId, fileId) {
+    await removeRow(await projectFile(projectId, fileId));
+}
+/** Before a project goes: its files leave the object store and the public links. */
+export async function removeProjectFiles(projectId) {
+    for (const row of await projectFiles(projectId)) {
+        await removeRow(row);
+    }
+}

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

@@ -0,0 +1,109 @@
+import { embedMany } from "ai";
+import { eq, inArray, sql } from "drizzle-orm";
+import { db, schema } from "../db/client.js";
+import { parseDocument } from "../documents/parse.js";
+import { createSearchChunks } from "../engenty/search-index/chunks.js";
+import { getBlob, putBlob } from "../files/blobs.js";
+import { embeddingModel } from "../models.js";
+const CHUNK = { mode: "paragraph", max_chunk_length: 1200, overlap: 120 };
+/** Passages of one document; a longer one keeps its start. */
+const MAX_CHUNKS = 2000;
+const vectorBytes = (v) => Buffer.from(new Float32Array(v).buffer);
+/** The page marks of the document converter, as a line a reader understands. */
+function withPageLines(markdown) {
+    return markdown.replace(/<page-break number="(\d+)"[^>]*><\/page-break>/g, (_m, n) => `\n\n[Seite ${n}]\n\n`);
+}
+async function embed(texts) {
+    const resolved = await embeddingModel();
+    if (!resolved || !texts.length) {
+        return null;
+    }
+    const result = await embedMany({ model: resolved.model, values: texts, maxParallelCalls: 4 });
+    return { vectors: result.embeddings.map((e) => Array.from(e)), model: resolved.ref };
+}
+export async function dropIndex(fileId) {
+    await db.delete(schema.projectChunk).where(eq(schema.projectChunk.fileId, fileId));
+}
+/** Reads a document and puts it into the index; what it found goes back onto the file's row. */
+export async function indexDocument(file, data) {
+    const parsed = await parseDocument({ data, name: file.name, mime: file.mime });
+    const text = withPageLines(parsed.markdown).trim();
+    const chunks = createSearchChunks({ doc_id: file.id, text, ...CHUNK }).slice(0, MAX_CHUNKS);
+    // Without an embedding model, or when it fails, the keywords still find the passage.
+    const embedded = await embed(chunks.map((c) => c.text)).catch((err) => {
+        console.error("[project-index] embedding failed", err);
+        return null;
+    });
+    await dropIndex(file.id);
+    for (let i = 0; i < chunks.length; i += 100) {
+        await db.insert(schema.projectChunk).values(chunks.slice(i, i + 100).map((c, j) => ({
+            projectId: file.projectId,
+            fileId: file.id,
+            idx: c.chunk_index,
+            text: c.text,
+            embedding: embedded ? vectorBytes(embedded.vectors[i + j]) : null,
+            model: embedded?.model ?? null,
+        })));
+    }
+    return {
+        textHash: await putBlob(Buffer.from(text, "utf8")),
+        pages: parsed.pages,
+        chars: text.length,
+        indexed: chunks.length ? (embedded ? "embeddings" : "keywords") : null,
+        text,
+    };
+}
+export async function documentText(file) {
+    return file.textHash ? (await getBlob(file.textHash)).toString("utf8") : "";
+}
+const STOP = new Set("der die das den dem des ein eine einen einem einer und oder aber ist sind war wie was wer wo für von mit auf aus bei zu zum zur im in an am es ich du wir ihr sie nicht auch the a an of to and or is are was for with on at by it this that".split(" "));
+/** The question's words as an FTS5 query: any of them, also as the start of a longer word. */
+function keywordQuery(query) {
+    const words = [...new Set(query.toLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? [])]
+        .filter((w) => !STOP.has(w))
+        .slice(0, 16);
+    return words.length ? words.map((w) => `"${w}"*`).join(" OR ") : null;
+}
+/** The passages of the project's documents that fit a question best. */
+export async function searchProject(projectId, query, limit = 6) {
+    const lists = [];
+    const keywords = keywordQuery(query);
+    if (keywords) {
+        lists.push(await db.all(sql `
+        SELECT c.id, c.file_id, c.idx, c.text
+        FROM project_chunk_fts f JOIN project_chunk c ON c.id = f.rowid
+        WHERE project_chunk_fts MATCH ${keywords} AND c.project_id = ${projectId}
+        ORDER BY bm25(project_chunk_fts) LIMIT 24`));
+    }
+    const embedded = await embed([query]).catch(() => null);
+    if (embedded) {
+        lists.push(await db.all(sql `
+        SELECT id, file_id, idx, text
+        FROM project_chunk
+        WHERE project_id = ${projectId} AND model = ${embedded.model}
+        ORDER BY vector_distance_cos(embedding, ${vectorBytes(embedded.vectors[0])}) LIMIT 24`));
+    }
+    // Reciprocal rank fusion: a passage both lists rank high comes first.
+    const scored = new Map();
+    for (const list of lists) {
+        list.forEach((hit, rank) => {
+            const entry = scored.get(hit.id) ?? { hit, score: 0 };
+            entry.score += 1 / (60 + rank);
+            scored.set(hit.id, entry);
+        });
+    }
+    const top = [...scored.values()].sort((a, b) => b.score - a.score).slice(0, limit);
+    if (!top.length) {
+        return [];
+    }
+    const files = await db.query.projectFile.findMany({
+        where: inArray(schema.projectFile.id, [...new Set(top.map((t) => t.hit.file_id))]),
+    });
+    return top.map(({ hit, score }) => ({
+        fileId: hit.file_id,
+        name: files.find((f) => f.id === hit.file_id)?.name ?? "",
+        index: hit.idx,
+        text: hit.text,
+        score: Math.round(score * 10_000) / 10_000,
+    }));
+}