wizards 0.3.6 → 0.3.8

package/apps/runtime/dist/film/project.js

@@ -3,8 +3,9 @@ import { existsSync } from "node:fs";
 import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join, normalize } from "node:path";
 import { dataRef, FILM_SIZES } from "@engenty-wizards/shared/definition";
+import { gradientCss, ruleLines, textStyleLine } from "@engenty-wizards/shared/projects";
 import { unzipSync } from "fflate";
-import { renderTemplate, resolveRef } from "../engine/template.js";
+import { logoSectionLine, renderTemplate, resolveRef } from "../engine/template.js";
 import { env } from "../env.js";
 import { getBlob } from "../files/blobs.js";
 import { extFor, loadAsset } from "../files/storage.js";
@@ -128,23 +129,72 @@ export async function prepareFilmFolder(step, ctx) {
     // The space's brand.
     const b = ctx.scope.brand;
     const logos = [];
+    const patterns = [];
+    for (const p of b.patterns ?? []) {
+        const f = ctx.projectFiles.find((x) => x.id === p.file);
+        try {
+            if (f) {
+                const { data } = await projectFileContent(f.projectId, f.id);
+                const name = `patterns/${safeName(f.name.replace(/\.[^.]+$/, ""))}.${extFor(f.mime) === "bin" ? (f.name.split(".").pop() ?? "bin") : extFor(f.mime)}`;
+                await put(join(root, "brand"), name, data);
+                patterns.push({ file: name, name: p.name, tile: Boolean(p.tile) });
+            }
+        }
+        catch {
+            // a pattern less
+        }
+    }
     for (const f of ctx.projectFiles.filter((p) => p.kind === "logo")) {
         try {
             const { data } = await projectFileContent(f.projectId, f.id);
             const name = `logos/${safeName(f.name.replace(/\.[^.]+$/, ""))}.${extFor(f.mime) === "bin" ? (f.name.split(".").pop() ?? "bin") : extFor(f.mime)}`;
             await put(join(root, "brand"), name, data);
-            logos.push(name);
+            const section = logoSectionLine(b.logoSections, f.id);
+            logos.push({
+                file: name,
+                ...(section ? { section } : {}),
+                ...(f.description ? { description: f.description } : {}),
+            });
         }
         catch {
             // a logo less
         }
     }
     await put(join(root, "brand"), "brand.json", JSON.stringify({
-        note: "The space's brand. Colours are named by what they are for; the first is the accent.",
+        note: "The space's brand. Colours are named by what they are for; the first is the accent. A logo's or a colour's section says when to use it; colorRules, logoRules and typeRules, where there are any, say how colours, logos and type may be used; text is set in the fonts.",
         name: b.name ?? "",
         about: b.about ?? "",
-        colors: (b.colors ?? []).map((c) => ({ name: c.name, value: c.value })),
+        colors: (b.colors ?? []).map((c) => {
+            const s = b.colorSections?.find((x) => x.id === c.section);
+            return { name: c.name, value: c.value, ...(s ? { section: s.title } : {}) };
+        }),
+        ...(b.gradients?.length
+            ? {
+                gradients: b.gradients.map((g) => ({
+                    name: g.name,
+                    section: b.colorSections?.find((x) => x.id === g.section)?.title,
+                    css: gradientCss(g),
+                })),
+            }
+            : {}),
+        ...(patterns.length ? { patterns } : {}),
         logos,
+        ...(b.colorRules?.length ? { colorRules: ruleLines(b.colorRules).split("\n") } : {}),
+        ...(b.fonts?.length
+            ? {
+                fonts: b.fonts.map(({ family, role, weights }) => ({ family, role, weights })),
+            }
+            : {}),
+        ...(b.textStyles?.length
+            ? {
+                textStyles: b.textStyles.map((s) => ({
+                    name: s.name,
+                    style: textStyleLine(s, b.fonts ?? []),
+                })),
+            }
+            : {}),
+        ...(b.typeRules?.length ? { typeRules: ruleLines(b.typeRules).split("\n") } : {}),
+        ...(b.logoRules?.length ? { logoRules: ruleLines(b.logoRules).split("\n") } : {}),
         facts: (b.facts ?? []).map((f) => `${f.label}: ${f.value}`),
     }, null, 1));
     // What the run made before.

package/apps/runtime/dist/manage.js

@@ -110,15 +110,15 @@ export function tenantMembers(id) {
     return call("GET", `/v1/tenants/${encodeURIComponent(id)}/members`);
 }
 const users = new Map();
-/** A person's own feature switches, as an admin set them at the Manage-App; cached a minute. */
-export async function userFeatures(userId) {
+/** What the Manage-App says of a person beyond their token; cached a minute. */
+export async function userInfo(userId) {
     const hit = users.get(userId);
     if (hit && Date.now() - hit.at < 60_000) {
         return hit.value;
     }
     const value = await call("GET", `/v1/users/${encodeURIComponent(userId)}`)
-        .then((u) => u.features ?? {})
-        .catch(() => hit?.value ?? {});
+        .then((u) => ({ features: u.features ?? {}, admin: u.admin === true }))
+        .catch(() => hit?.value ?? { features: {}, admin: false });
     users.set(userId, { at: Date.now(), value });
     return value;
 }

package/apps/runtime/dist/models.js

@@ -1013,6 +1013,12 @@ function priceOf(ref) {
     return (catalog.get(provider === null || provider === "gateway" ? id : `${provider}/${id}`)?.pricing ??
         {});
 }
+/** A model's context window in tokens, as the AI Gateway's catalog gives it; null where unknown. */
+export function contextWindowOf(ref) {
+    const { provider, id } = parse(ref);
+    const entry = catalog.get(provider === null || provider === "gateway" ? id : `${provider}/${id}`);
+    return typeof entry?.context_window === "number" ? entry.context_window : null;
+}
 const n = (v, fallback) => {
     const x = Number(v);
     return Number.isFinite(x) ? x : fallback;

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

@@ -1,6 +1,6 @@
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { ASSISTANT_LAYOUTS, ASSISTANT_PAGE_BYTES, assistantTurnSchema, } from "@engenty-wizards/shared/assistant";
+import { ASSISTANT_LAYOUTS, ASSISTANT_PAGE_BYTES, assistantSignalSchema, assistantTurnSchema, } from "@engenty-wizards/shared/assistant";
 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";
@@ -11,9 +11,11 @@ import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { nanoid } from "nanoid";
 import { z } from "zod";
-import { runStudioAssistant } from "../agents/studio-assistant.js";
+import { runStudioAssistant, signalText } from "../agents/studio-assistant.js";
 import { chatEngine, setChatEngine, subscriptionClients } from "../agents/subscription.js";
+import { scanColors, scanFonts, scanImages, scanLogos } from "../agents/website.js";
 import { answerBrowser, awaitBrowser } from "../assistant/browser.js";
+import { endRun, signalRun, startRun, takeSignals } from "../assistant/runs.js";
 import { accountOverview, linkedAccount, startLink, unlink } from "../auth/account.js";
 import { createLocalKey, deleteLocalKey, listLocalKeys } from "../auth/keys.js";
 import { appStates, connectApps } from "../cli/connect.js";
@@ -28,7 +30,7 @@ import { appleStatus } from "../harness/apple.js";
 import { freshAuth, loginEnv } from "../harness/env.js";
 import { detectHarness, detectHarnesses, HARNESS_IDS, harness, installSpec, } from "../harness/index.js";
 import { closeTerminal, openTerminal, resizeTerminal, subscribeTerminal, writeTerminal, } from "../harness/terminal.js";
-import { managed, tenantInfo, tenantMembers, userFeatures } from "../manage.js";
+import { managed, tenantInfo, tenantMembers, userInfo } from "../manage.js";
 import { seenApps } from "../mcp/seen.js";
 import { generateImageMedia, generateSpeechMedia, generateVideoMedia } from "../media/generate.js";
 import { transcribeAudio } from "../media/transcribe.js";
@@ -45,7 +47,7 @@ import { categoryContents, listKnowledge, resolvePath, valueContents, } from "..
 import { writeSummary } from "../services/knowledge-model.js";
 import { exportWizard, importWizard } 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 { addProjectFile, addProjectFileFromUrl, fileView, orderProjectFiles, projectFile, projectFileContent, projectFiles, reindexProjectFile, removeProjectFile, updateProjectFile, } from "../services/project-files.js";
 import { documentText, queueIndex, searchKnowledge } from "../services/project-index.js";
 import { createProject, deleteProject, listProjects, maskedServers, ownedProject, projectLimitOrNull, projectPatchSchema, updateProject, } from "../services/projects.js";
 import { runnersOf, wizardRunners } from "../services/runners.js";
@@ -189,6 +191,10 @@ async function testClass(cls, lang) {
     }
 }
 /** The size of an inline terminal, as the page lays it out. */
+/** Whether the studio assistant's developer mode is offered to this person. */
+async function assistantDevFor(user) {
+    return managed ? (await userInfo(user.id)).admin : env.assistantDev;
+}
 const terminalSize = z.object({
     cols: z.number().int().min(10).max(500).optional(),
     rows: z.number().int().min(4).max(200).optional(),
@@ -202,7 +208,7 @@ export const studio = new Hono()
     const profile = await userProfile(user);
     // What the Manage-App says of the tenant: its plan and feature switches; and of the person.
     const info = managed ? await tenantInfo(user.tenantId).catch(() => null) : null;
-    const own = managed ? await userFeatures(user.id) : null;
+    const person = managed ? await userInfo(user.id) : null;
     return c.json({
         user: { id: user.id, name: profile.name, email: profile.email, image: user.image ?? null },
         /** What the person says about themselves; name and e-mail are the account's when managed. */
@@ -214,7 +220,9 @@ export const studio = new Hono()
             plan: info?.plan ?? null,
         },
         /** The feature switches: the code's defaults, what the Manage-App says of the team and the person, this install's file. */
-        features: features(managed ? { ...info?.features, ...own } : overview?.tenant.features),
+        features: features(managed ? { ...info?.features, ...person?.features } : overview?.tenant.features),
+        /** The studio assistant's developer mode may be switched on: ASSISTANT_DEV here, the platform's admins when managed. */
+        assistantDev: await assistantDevFor(user),
         mode: managed ? "managed" : "local",
         /** The tenant's balance; null where the runtime resolves models itself. */
         credits: managed ? await balanceCredits() : null,
@@ -316,6 +324,12 @@ export const studio = new Hono()
     }
     const voice = await generateSpeechMedia({ text, abortSignal: c.req.raw.signal });
     return c.body(new Uint8Array(voice.bytes), 200, { "content-type": voice.mime });
+})
+    // A message written while a turn runs: the turn takes it before its next step or after its answer.
+    .post("/assistant/run/:runId/signal", async (c) => {
+    const body = assistantSignalSchema.parse(await c.req.json());
+    const taken = signalRun(c.get("user").id, c.req.param("runId"), body);
+    return c.json({ ok: taken }, taken ? 200 : 404);
 })
     // A browser tool's result: the turn that waits for it goes on.
     .post("/assistant/tool/:callId", async (c) => {
@@ -338,53 +352,100 @@ export const studio = new Hono()
         ? { route: body.page.route, title: body.page.title, view: body.page.view }
         : (body.page ?? null);
     const chat = await openChat(user);
-    const history = await turnHistory(user, chat);
+    const debug = Boolean(body.debug) && (await assistantDevFor(user));
+    let history = await turnHistory(user, chat);
     const runId = nanoid(10);
     const userMessageId = await addMessage(chat.id, {
         role: "user",
         content: body.message,
         page: page ? { route: page.route, title: page.title } : null,
     });
+    startRun(runId, user.id);
     return streamSSE(c, async (stream) => {
         const abort = new AbortController();
         stream.onAbort(() => abort.abort());
         const send = (event, data) => stream.writeSSE({ event, data: JSON.stringify(data) });
-        const messageId = nanoid(14);
+        let messageId = nanoid(14);
         await send("run_started", { threadId: chat.id, runId, messageId: userMessageId });
+        // The answer's text since the last message written meanwhile.
         let reply = "";
+        let changed = false;
+        let steps = 0;
+        /** What the answer said and did up to messages written meanwhile; null when nothing. */
+        const storePart = async (before) => {
+            changed ||= before.changed;
+            return before.reply || before.toolCalls.length || before.cards.length
+                ? await addMessage(chat.id, { role: "assistant", content: before.reply, ...before })
+                : null;
+        };
+        /** The messages written meanwhile, after the part of the answer before them. */
+        const storeSignals = async (taken, answerId) => {
+            for (const [i, s] of taken.entries()) {
+                const stored = await addMessage(chat.id, { role: "user", content: s.message });
+                await send("signal", {
+                    ref: s.ref,
+                    messageId: stored,
+                    content: s.message,
+                    answerId: i === 0 ? answerId : null,
+                });
+            }
+            reply = "";
+            messageId = nanoid(14);
+        };
         try {
-            const result = await runStudioAssistant({
-                user,
-                chat,
-                history,
-                project,
-                writable,
-                message: body.message,
-                page,
-                browserTools: body.tools,
-                lang: body.lang,
-                signal: abort.signal,
-                onText: (delta) => {
-                    reply += delta;
-                    void send("text", { messageId, delta });
-                },
-                onActivity: (label) => void send("activity", { label }),
-                onChanged: () => void send("changed", {}),
-                onCard: (card) => void send("card", card),
-                onToolCall: (call) => void send("tool_call", call),
-                onToolResult: (result) => void send("tool_result", result),
-                callBrowser: (call) => awaitBrowser(user.id, call.toolCallId, abort.signal),
-            });
-            reply =
-                result.reply || (result.changed ? (body.lang === "de" ? "Erledigt." : "Done.") : "");
-            const stored = await addMessage(chat.id, {
-                role: "assistant",
-                content: reply,
-                cards: result.cards,
-                toolCalls: result.toolCalls,
-                changed: result.changed,
-            });
-            await send("done", { messageId: stored, reply, changed: result.changed });
+            let message = body.message;
+            for (;;) {
+                const result = await runStudioAssistant({
+                    user,
+                    chat,
+                    history,
+                    project,
+                    writable,
+                    message,
+                    page,
+                    browserTools: body.tools,
+                    lang: body.lang,
+                    signal: abort.signal,
+                    onText: (delta) => {
+                        reply += delta;
+                        void send("text", { messageId, delta });
+                    },
+                    onActivity: (label) => void send("activity", { label }),
+                    onChanged: () => void send("changed", {}),
+                    onCard: (card) => void send("card", card),
+                    onToolCall: (call) => void send("tool_call", call),
+                    onToolResult: (result) => void send("tool_result", result),
+                    callBrowser: (call) => awaitBrowser(user.id, call.toolCallId, abort.signal),
+                    takeSignals: () => takeSignals(runId),
+                    onSignal: async (taken, before) => storeSignals(taken, await storePart(before)),
+                    ...(debug
+                        ? {
+                            onPrompt: (prompt) => void send("prompt", prompt),
+                            onStep: (step) => void send("step", { ...step, step: ++steps }),
+                        }
+                        : {}),
+                });
+                // Written after the answer's last step: the turn goes on with it.
+                const left = takeSignals(runId);
+                if (!left.length || abort.signal.aborted) {
+                    changed ||= result.changed;
+                    reply = result.reply || (changed ? (body.lang === "de" ? "Erledigt." : "Done.") : "");
+                    const stored = await addMessage(chat.id, {
+                        role: "assistant",
+                        content: reply,
+                        cards: result.cards,
+                        toolCalls: result.toolCalls,
+                        changed: result.changed,
+                    });
+                    await send("done", { messageId: stored, reply, changed });
+                    break;
+                }
+                // The next answer knows this one: it is stored before the history is read again.
+                const answerId = await storePart(result);
+                history = await turnHistory(user, chat);
+                await storeSignals(left, answerId);
+                message = signalText(left);
+            }
         }
         catch (err) {
             console.error("[studio-assistant]", err);
@@ -399,6 +460,7 @@ export const studio = new Hono()
                         : "Something went wrong. Please try again.",
             });
         }
+        endRun(runId);
         // Older messages fold into the chat's running summary once enough have piled up.
         void foldChat(chat.id).catch((err) => console.error("[studio-assistant] fold:", err));
     });
@@ -452,6 +514,41 @@ export const studio = new Hono()
         data: new Uint8Array(await file.arrayBuffer()),
     });
     return c.json(fileView(row));
+})
+    .post("/projects/:id/files/url", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    const input = z
+        .object({ url: z.string().min(1).max(500_000), kind: z.enum(PROJECT_FILE_KINDS) })
+        .parse(await c.req.json());
+    const url = /^(https?:\/\/|data:)/i.test(input.url) ? input.url : `https://${input.url}`;
+    try {
+        return c.json({ file: fileView(await addProjectFileFromUrl(project.id, { ...input, url })) });
+    }
+    catch (err) {
+        // A web page where a logo or an asset was asked for: its logos or pictures, to pick from.
+        if (err instanceof ServiceError && err.data.reason === "page") {
+            const page = String(err.data.url ?? url);
+            const scan = input.kind === "logo" ? scanLogos : scanImages;
+            return c.json({ candidates: await scan(page) });
+        }
+        throw err;
+    }
+})
+    .post("/projects/:id/colors/scan", async (c) => {
+    await ownedProject(c.get("user").id, c.req.param("id"));
+    const { url } = z.object({ url: z.string().min(1).max(2000) }).parse(await c.req.json());
+    const colors = await scanColors(url).catch(() => {
+        throw new ServiceError("invalid", "Die Seite ist nicht erreichbar.");
+    });
+    return c.json({ colors });
+})
+    .post("/projects/:id/fonts/scan", async (c) => {
+    await ownedProject(c.get("user").id, c.req.param("id"));
+    const { url } = z.object({ url: z.string().min(1).max(2000) }).parse(await c.req.json());
+    const fonts = await scanFonts(url).catch(() => {
+        throw new ServiceError("invalid", "Die Seite ist nicht erreichbar.");
+    });
+    return c.json({ fonts });
 })
     .put("/projects/:id/files/order", async (c) => {
     const project = await ownedProject(c.get("user").id, c.req.param("id"));

package/apps/runtime/dist/services/assistant-chats.js

@@ -9,8 +9,8 @@ import { ServiceError } from "./errors.js";
 import { trigramQuery } from "./project-index.js";
 /**
  * The studio assistant's chats: one open chat per person and tenant, the same on every page and
- * space. "New chat" closes it with a dense summary; every turn of the next one carries the
- * summaries of the last chats, and older ones are found with `searchChats`.
+ * space. "New chat" closes it at once and writes its dense summary meanwhile; every turn of the
+ * next one carries the summaries of the last chats, and older ones are found with `searchChats`.
  */
 /** Messages of the open chat a turn sends as they are; older ones live in its running summary. */
 export const TURN_MESSAGES = 12;
@@ -74,6 +74,7 @@ export async function addMessage(chatId, message) {
 }
 /** What a turn of the open chat carries besides the new message. */
 export async function turnHistory(user, chat) {
+    await closedSummaries(user);
     const all = await messagesOf(chat.id);
     const earlier = await db.query.assistantChat.findMany({
         where: and(mine(user), isNotNull(schema.assistantChat.closedAt)),
@@ -81,8 +82,11 @@ export async function turnHistory(user, chat) {
         limit: EARLIER_IN_TURN,
     });
     return {
+        // A part of an answer that only called tools (before a message written meanwhile) has no
+        // text: models refuse empty messages.
         messages: all
             .slice(chat.folded)
+            .filter((m) => m.content.trim())
             .slice(-TURN_MESSAGES)
             .map(({ role, content }) => ({ role, content })),
         running: chat.summary,
@@ -170,9 +174,45 @@ export async function foldChat(chatId) {
         .set({ summary, folded: upTo })
         .where(and(eq(schema.assistantChat.id, chat.id), eq(schema.assistantChat.folded, chat.folded)));
 }
+/** Summaries of chats "New chat" closed, still being written: by chat id, with whose chat it is. */
+const summarising = new Map();
+const whose = (user) => `${user.tenantId}:${user.id}`;
+/** Writes the summary and the title of a closed chat. */
+function summariseClosed(user, chat) {
+    const running = summarising.get(chat.id);
+    if (running) {
+        return running.done;
+    }
+    const done = (async () => {
+        const all = await messagesOf(chat.id);
+        const { title, summary } = await summarise(all.slice(chat.folded), chat.summary);
+        await db
+            .update(schema.assistantChat)
+            .set({ ...(title ? { title } : {}), summary })
+            .where(eq(schema.assistantChat.id, chat.id));
+    })()
+        .catch((err) => console.error("[assistant] summary of a closed chat:", err.message))
+        .finally(() => summarising.delete(chat.id));
+    summarising.set(chat.id, { user: whose(user), done });
+    return done;
+}
+/**
+ * Waits for the summaries of the person's closed chats: those being written, and any a stopped
+ * runtime left unwritten.
+ */
+export async function closedSummaries(user) {
+    const unwritten = await db.query.assistantChat.findMany({
+        where: and(mine(user), isNotNull(schema.assistantChat.closedAt), isNull(schema.assistantChat.summary)),
+    });
+    await Promise.all([
+        ...unwritten.map((chat) => summariseClosed(user, chat)),
+        ...[...summarising.values()].filter((s) => s.user === whose(user)).map((s) => s.done),
+    ]);
+}
 /**
- * "New chat": the open chat is summarised and closed (kept to read under "Earlier chats"), and
- * an empty one opens. An open chat without messages stays as it is.
+ * "New chat": the open chat is closed at once (kept to read under "Earlier chats", titled by its
+ * first question until its summary is written) and an empty one opens. An open chat without
+ * messages stays as it is.
  */
 export async function newChat(user) {
     const chat = await openChat(user);
@@ -180,11 +220,12 @@ export async function newChat(user) {
     if (!all.length) {
         return { id: chat.id, messages: [] };
     }
-    const { title, summary } = await summarise(all.slice(chat.folded), chat.summary);
+    const firstAsk = all.find((m) => m.role === "user")?.content ?? "";
     await db
         .update(schema.assistantChat)
-        .set({ title, summary, closedAt: new Date() })
+        .set({ title: firstAsk.replace(/\s+/g, " ").trim().slice(0, 60), closedAt: new Date() })
         .where(eq(schema.assistantChat.id, chat.id));
+    void summariseClosed(user, chat);
     const next = await openChat(user);
     return { id: next.id, messages: [] };
 }
@@ -199,6 +240,8 @@ export async function earlierChats(user, limit = 50) {
         id: c.id,
         title: c.title ?? "",
         summary: c.summary ?? "",
+        /** Its summary is still being written. */
+        summarising: summarising.has(c.id),
         startedAt: c.createdAt.toISOString(),
         closedAt: c.closedAt.toISOString(),
     }));

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

@@ -1,12 +1,15 @@
+import { mainLogo } from "@engenty-wizards/shared/projects";
 import { and, asc, eq } from "drizzle-orm";
 import { db, schema } from "../db/client.js";
-/** The project's first logo: the one end users, documents and widgets get. */
+/** The project's main logo, the first standard one: what end users, documents and widgets get. */
 export async function mainLogoId(projectId) {
-    const logo = await db.query.projectFile.findFirst({
+    const p = await db.query.project.findFirst({ where: eq(schema.project.id, projectId) });
+    const logos = await db.query.projectFile.findMany({
+        columns: { id: true },
         where: and(eq(schema.projectFile.projectId, projectId), eq(schema.projectFile.kind, "logo")),
         orderBy: [asc(schema.projectFile.position), asc(schema.projectFile.createdAt)],
     });
-    return logo?.id ?? null;
+    return mainLogo(logos, p?.brand.logoSections)?.id ?? null;
 }
 /** What end users see of the project: its title, accent and logo — never the project name. */
 export async function brandView(projectId) {

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

@@ -7,6 +7,7 @@ import { loadAsset, removeAsset, replaceAsset, saveAsset } from "../files/storag
 import { embeddingModel, textModel } from "../models.js";
 import { spaceFileChanged } from "../plugins/events.js";
 import { dropLinks, putLink } from "../tenants/control.js";
+import { safeFetch } from "../tools/net-guard.js";
 import { requireWritableProject } from "./access.js";
 import { notFound, ServiceError } from "./errors.js";
 import { convertDocument, fillCategories } from "./knowledge-model.js";
@@ -58,12 +59,17 @@ export async function projectFileContent(projectId, fileId) {
     }
     return { row, data: found.data };
 }
+/**
+ * Assets are what wizards put into what they make: pictures, clips, recordings, and files to
+ * hand on as they are — PDFs, fonts, Lottie animations (JSON), 3D models.
+ */
+const ASSET_TYPES = /^((image|video|audio|font)\/|application\/(pdf|json)$|model\/gltf)/;
 function accepts(kind, mime) {
-    if (kind === "logo") {
+    if (kind === "logo" || kind === "pattern") {
         return mime.startsWith("image/");
     }
     if (kind === "asset") {
-        return /^(image|video|audio)\//.test(mime);
+        return ASSET_TYPES.test(mime);
     }
     return true;
 }
@@ -73,7 +79,9 @@ export async function addProjectFile(projectId, input) {
     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.");
+            : input.kind === "pattern"
+                ? "Ein Muster ist ein Bild (SVG, PNG, JPEG, WebP)."
+                : "Hierher gehören Bilder, Videos, Audio, PDFs, Schriften, Lottie und 3D-Modelle. Texte zum Nachschlagen bitte zu den Dokumenten.");
     }
     const limit = projectFileLimit(input.kind, mime);
     if (!input.data.byteLength || input.data.byteLength > limit) {
@@ -120,6 +128,54 @@ export async function addProjectFile(projectId, input) {
     }
     return row;
 }
+/**
+ * Fetches a file from a public web address into the project, as an upload of it would add it.
+ * A drawing a page holds inline comes as a `data:image/svg+xml` address. A web page where a
+ * picture was asked for is refused with the reason `page`.
+ */
+export async function addProjectFileFromUrl(projectId, input) {
+    const { url, kind, signal } = input;
+    const inline = url.match(/^data:image\/svg\+xml;base64,([A-Za-z0-9+/=]+)$/);
+    if (inline) {
+        return addProjectFile(projectId, {
+            kind,
+            name: `${kind}.svg`,
+            mime: "image/svg+xml",
+            data: new Uint8Array(Buffer.from(inline[1], "base64")),
+            description: input.description,
+        });
+    }
+    const res = await safeFetch(url, {
+        headers: { "user-agent": "Mozilla/5.0 (compatible; engenty-wizards/0.1)" },
+        signal: AbortSignal.any([AbortSignal.timeout(60_000), ...(signal ? [signal] : [])]),
+    }).catch(() => {
+        throw new ServiceError("invalid", "Die Adresse ist nicht erreichbar.");
+    });
+    if (!res.ok) {
+        throw new ServiceError("invalid", `Die Adresse antwortete ${res.status}.`);
+    }
+    const mime = (res.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
+    if (mime === "text/html" && kind !== "document") {
+        await res.body?.cancel();
+        throw new ServiceError("invalid", "Unter der Adresse steht eine Webseite, kein Bild.", {
+            reason: "page",
+            url: res.url,
+        });
+    }
+    if (Number(res.headers.get("content-length") ?? 0) > projectFileLimit(kind, mime)) {
+        throw new ServiceError("invalid", "Die Datei ist zu groß.");
+    }
+    const data = new Uint8Array(await res.arrayBuffer());
+    const name = decodeURIComponent(new URL(res.url).pathname.split("/").pop() || kind);
+    return addProjectFile(projectId, {
+        kind,
+        name,
+        mime,
+        data,
+        description: input.description,
+        source: res.url,
+    });
+}
 // --- reading, describing, indexing -------------------------------------------------
 /** Files are worked through two at a time: each costs model calls. */
 let running = 0;