wizards 0.1.9

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

@@ -0,0 +1,183 @@
+import { allFields, isAudioValue, isLocationValue, itemsTotals, locationText, } from "@engenty-wizards/shared/definition";
+import { listAsMarkdown } from "@engenty-wizards/shared/store";
+const TEMPLATE_RE = /\{\{\s*([^}]+?)\s*\}\}/g;
+function money(n, currency) {
+    try {
+        return new Intl.NumberFormat("de-DE", { style: "currency", currency }).format(n);
+    }
+    catch {
+        return `${n.toFixed(2)} ${currency}`;
+    }
+}
+/** Line items as a Markdown table with their totals — what a model needs to write a document. */
+export function itemsAsMarkdown(field, value, values) {
+    const totals = itemsTotals(field, value, values);
+    const cols = field.columns ?? [];
+    if (!totals.rows.length) {
+        return "(no line items)";
+    }
+    const head = `| ${cols.map((c) => c.label).join(" | ")} | Amount |\n|${cols.map(() => " --- ").join("|")}| ---: |`;
+    const body = totals.rows.map((r) => `| ${cols
+        .map((c) => c.kind === "money" ? money(Number(r[c.id]) || 0, totals.currency) : String(r[c.id] ?? ""))
+        .join(" | ")} | ${money(r.amount, totals.currency)} |`);
+    const sums = [
+        `Net: ${money(totals.net, totals.currency)}`,
+        totals.vatRate ? `VAT ${totals.vatRate}%: ${money(totals.vat, totals.currency)}` : null,
+        `Total: ${money(totals.gross, totals.currency)}`,
+    ].filter(Boolean);
+    return [head, ...body, "", ...sums].join("\n");
+}
+/** Facts as lines a model reads: "Label: value". */
+export function factLines(facts) {
+    return facts.map((f) => `${f.label}: ${f.value}`).join("\n");
+}
+export function colorLine(colors) {
+    return colors.map((c) => (c.name ? `${c.name} ${c.value}` : c.value)).join(", ");
+}
+function brandRef(brand, key) {
+    switch (key) {
+        case "name":
+            return brand.name ?? "";
+        case "about":
+            return brand.about ?? "";
+        // What the free "details" text once held is now the description and the facts.
+        case "details":
+            return [brand.about, factLines(brand.facts ?? [])].filter(Boolean).join("\n");
+        case "accent":
+            return brand.colors?.[0]?.value ?? "";
+        case "colors":
+            return colorLine(brand.colors ?? []);
+        default:
+            return "";
+    }
+}
+function stringify(v) {
+    if (v === undefined || v === null) {
+        return "";
+    }
+    if (typeof v === "string") {
+        return v;
+    }
+    if (typeof v === "number" || typeof v === "boolean") {
+        return String(v);
+    }
+    if (Array.isArray(v) && v.every((x) => typeof x !== "object")) {
+        return v.join(", ");
+    }
+    return JSON.stringify(v, null, 2);
+}
+export function resolveRef(ref, scope) {
+    const { def, state, brand } = scope;
+    const [head, ...rest] = ref.split(".");
+    if (head === "lists") {
+        const list = scope.lists?.[rest[0] ?? ""];
+        return list ? listAsMarkdown(list.def, list.rows) : "";
+    }
+    if (head === "today") {
+        return new Date().toISOString().slice(0, 10);
+    }
+    if (head === "item" || head === "index" || head === "count") {
+        const entry = scope.entry;
+        if (!entry) {
+            return "";
+        }
+        if (head === "index") {
+            return entry.index + 1;
+        }
+        if (head === "count") {
+            return entry.count;
+        }
+        let cur = entry.item;
+        for (const key of rest) {
+            cur = cur && typeof cur === "object" ? cur[key] : undefined;
+        }
+        return cur;
+    }
+    if (head === "brand") {
+        return brandRef(brand, rest[0] ?? "name");
+    }
+    if (head === "facts") {
+        const facts = brand.facts ?? [];
+        return rest[0] ? (facts.find((f) => f.key === rest[0])?.value ?? "") : factLines(facts);
+    }
+    if (head === "steps") {
+        const out = state.outputs[rest[0] ?? ""];
+        if (!out) {
+            return "";
+        }
+        if (rest.length === 1) {
+            return out.json !== undefined ? out.json : (out.text ?? "");
+        }
+        let cur = out.json;
+        for (const key of rest.slice(1)) {
+            cur = cur && typeof cur === "object" ? cur[key] : undefined;
+        }
+        return cur;
+    }
+    const field = allFields(def).find((f) => f.id === head);
+    const value = state.values[head];
+    if (field?.kind === "items") {
+        if (!rest.length) {
+            return itemsAsMarkdown(field, value, state.values);
+        }
+        const totals = itemsTotals(field, value, state.values);
+        return totals[rest[0]];
+    }
+    if (field?.kind === "image" || field?.kind === "file") {
+        // The files themselves are read with read_document / scan_documents by these names.
+        const ids = (Array.isArray(value) ? value : [value]).filter((v) => typeof v === "string" && v.length > 0);
+        return ids.map((id) => `upload:${id}`).join(", ");
+    }
+    if (field?.kind === "location") {
+        if (!isLocationValue(value)) {
+            return "";
+        }
+        switch (rest[0]) {
+            case undefined:
+                return locationText(value);
+            case "map":
+                return value.lat === undefined
+                    ? ""
+                    : `https://www.openstreetmap.org/?mlat=${value.lat}&mlon=${value.lng}#map=17/${value.lat}/${value.lng}`;
+            default:
+                return value[rest[0]];
+        }
+    }
+    if (field?.kind === "audio") {
+        if (!isAudioValue(value)) {
+            return "";
+        }
+        if (rest[0] === "seconds") {
+            return value.seconds;
+        }
+        // A recording reads as what is said in it.
+        return value.transcript?.trim() || "(voice note without intelligible speech)";
+    }
+    if (field?.kind === "signature") {
+        // Documents place it as an image: <img src="asset://ID">.
+        return typeof value === "string" && value ? `asset://${value}` : "";
+    }
+    if (field?.kind === "list") {
+        const list = scope.lists?.[field.list ?? ""];
+        return list ? listAsMarkdown(list.def, list.rows) : "";
+    }
+    if (field?.kind === "toggle") {
+        return value ? "yes" : "no";
+    }
+    return value;
+}
+export function renderTemplate(template, scope) {
+    return template.replace(TEMPLATE_RE, (_m, ref) => stringify(resolveRef(ref.trim(), scope)));
+}
+/** Everything the person entered so far, readable — handed to agents as data. */
+export function answersAsText(scope) {
+    const lines = [];
+    for (const field of allFields(scope.def)) {
+        const value = scope.state.values[field.id];
+        if (value === undefined || value === "" || (Array.isArray(value) && !value.length)) {
+            continue;
+        }
+        lines.push(`### ${field.label}\n${stringify(resolveRef(field.id, scope))}`);
+    }
+    return lines.join("\n\n");
+}

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

@@ -0,0 +1,3 @@
+/** A step failure the person can read. */
+export class StepError extends Error {
+}

package/apps/runtime/dist/env.js

@@ -0,0 +1,224 @@
+import { execFileSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+/** Load `.env.local` then `.env` without overriding the real environment. */
+function loadEnvFiles() {
+    for (const name of [".env.local", ".env"]) {
+        const path = resolve(process.cwd(), name);
+        if (!existsSync(path)) {
+            continue;
+        }
+        for (const line of readFileSync(path, "utf8").split("\n")) {
+            const match = line.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*)\s*$/);
+            if (!match || process.env[match[1]] !== undefined) {
+                continue;
+            }
+            process.env[match[1]] = match[2].replace(/^(['"])(.*)\1$/, "$2");
+        }
+    }
+}
+loadEnvFiles();
+const str = (key, fallback = "") => process.env[key]?.trim() || fallback;
+/**
+ * Without `SANDBOX`: Docker when the sandbox image is on this machine, else agentOS when its
+ * packages are installed (a checkout has them, the image and the desktop app do not), else none.
+ * The image is not published, so a fresh install would otherwise offer a tool that cannot start.
+ */
+function sandboxEngine(image) {
+    const engine = str("SANDBOX");
+    if (str("SANDBOX_ENABLED", "1") !== "1" || engine === "off") {
+        return "off";
+    }
+    if (engine) {
+        return engine === "agentos" ? "agentos" : "docker";
+    }
+    if (dockerHasImage(image)) {
+        return "docker";
+    }
+    return agentOsInstalled() ? "agentos" : "off";
+}
+function dockerHasImage(image) {
+    try {
+        execFileSync("docker", ["image", "inspect", image], { stdio: "ignore", timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** agentOS ships its sidecar for macOS and Linux on arm64 and x64 only. */
+function agentOsInstalled() {
+    if (!["darwin", "linux"].includes(process.platform) || !["arm64", "x64"].includes(process.arch)) {
+        return false;
+    }
+    try {
+        import.meta.resolve("@rivet-dev/agentos-core");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const num = (key, fallback) => {
+    const v = Number(process.env[key]);
+    return Number.isFinite(v) && v > 0 ? v : fallback;
+};
+const dataDir = resolve(str("DATA_DIR", "data"));
+/**
+ * Signs cookies and links and derives the store's encryption key. A runtime that runs alone
+ * makes its own once and keeps it in the data folder.
+ */
+function appSecret() {
+    const given = str("APP_SECRET");
+    if (given) {
+        return given;
+    }
+    mkdirSync(dataDir, { recursive: true });
+    const file = join(dataDir, "secret");
+    if (!existsSync(file)) {
+        writeFileSync(file, randomBytes(32).toString("hex"), { mode: 0o600 });
+    }
+    return readFileSync(file, "utf8").trim();
+}
+const manageUrl = str("MANAGE_URL").replace(/\/$/, "");
+const port = num("API_PORT", 24368);
+/** From source the Vite dev server on :5181 serves the pages; built, this server does. */
+const fromSource = import.meta.url.endsWith(".ts");
+const sandboxImage = str("SANDBOX_IMAGE", "engenty-sandbox:latest");
+export const env = {
+    production: process.env.NODE_ENV === "production",
+    port,
+    /** Listen address; a runtime that runs alone stays on the loopback interface. */
+    host: str("API_HOST", manageUrl ? "0.0.0.0" : "127.0.0.1"),
+    /** The origin people open, e.g. https://wizards.localhost — auth callbacks and links use it. */
+    appUrl: str("APP_URL", fromSource ? "http://localhost:5181" : `http://localhost:${port}`).replace(/\/$/, ""),
+    /**
+     * Where a signed-out visitor of the start page is sent instead of the sign-in, e.g. a landing
+     * page while sign-up is closed. The sign-in stays at /sign-in. Empty: the start page signs in.
+     */
+    signedOutUrl: str("SIGNED_OUT_URL"),
+    /** More host names this server answers under, besides APP_URL's and the loopback names. */
+    allowedHosts: str("ALLOWED_HOSTS")
+        .split(",")
+        .map((h) => h.trim())
+        .filter(Boolean),
+    dataDir,
+    /** The control database; empty = a libSQL file in the data folder. */
+    databaseUrl: str("DATABASE_URL", ""),
+    databaseAuthToken: str("DATABASE_AUTH_TOKEN"),
+    /** Tenant databases on a libSQL server: `{tenant}` is replaced by the tenant id. Empty = files. */
+    tenantDbUrlTemplate: str("TENANT_DB_URL_TEMPLATE"),
+    tenantDbAuthToken: str("TENANT_DB_AUTH_TOKEN", str("DATABASE_AUTH_TOKEN")),
+    authSecret: appSecret(),
+    /** Where OAuth providers send people back after connecting an account; default <APP_URL>/api/connect/callback. */
+    connectRedirectUrl: str("CONNECT_REDIRECT_URL"),
+    /** Encrypts connected accounts and kept browser sessions; falls back to the app secret. */
+    storeKey: str("STORE_ENC_KEY"),
+    devLogin: process.env.NODE_ENV !== "production" && str("DEV_LOGIN") === "1",
+    /**
+     * The Manage-App this runtime belongs to. Set = people sign in there, tenants come from its
+     * tokens and model calls go through its gateway. Empty = the runtime runs alone with one tenant.
+     */
+    manage: {
+        url: manageUrl,
+        gatewayUrl: str("GATEWAY_URL").replace(/\/$/, ""),
+        clientId: str("MANAGE_CLIENT_ID"),
+        clientSecret: str("MANAGE_CLIENT_SECRET"),
+        /** Authenticates this runtime at the Manage-App and the gateway, and the Manage-App here. */
+        serviceKey: str("MANAGE_SERVICE_KEY"),
+    },
+    /**
+     * A runtime that runs alone answers the studio only with a cookie, set by opening
+     * `/api/local/enter?k=<key>` once. The desktop app passes the key; else one is printed at start.
+     */
+    local: {
+        accessKey: str("LOCAL_ACCESS_KEY"),
+        /** The Manage-App a local runtime links an account to (credits, publishing). */
+        accountUrl: str("ACCOUNT_URL", "https://account.engenty.ai").replace(/\/$/, ""),
+        gatewayUrl: str("ACCOUNT_GATEWAY_URL", "https://gateway.engenty.ai").replace(/\/$/, ""),
+        /** The cloud runtime "publish to the cloud" sends wizards to. */
+        cloudUrl: str("CLOUD_URL", "https://engenty.ai").replace(/\/$/, ""),
+    },
+    /**
+     * The marketplace (docs/marketplace-contract.md): searched live, its starters and what people
+     * starred kept for offline use. `off` = none.
+     */
+    marketplace: {
+        url: str("MARKETPLACE_URL", "https://engenty.ai/wizards")
+            .replace(/^off$/, "")
+            .replace(/\/+$/, ""),
+    },
+    aiGatewayKey: str("AI_GATEWAY_API_KEY"),
+    openaiKey: str("OPENAI_API_KEY"),
+    anthropicKey: str("ANTHROPIC_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: {
+        classifier: str("MODEL_CLASSIFIER", "anthropic/claude-haiku-4.5"),
+        standard: str("MODEL_STANDARD", "anthropic/claude-haiku-4.5"),
+        high: str("MODEL_HIGH", "anthropic/claude-sonnet-5.5"),
+        highest: str("MODEL_HIGHEST", "anthropic/claude-sonnet-5.5"),
+        image: str("MODEL_IMAGE", "google/gemini-3.1-flash-image"),
+        video: str("MODEL_VIDEO", "google/veo-3.1-fast-generate-001"),
+        audio: str("MODEL_AUDIO", "google/gemini-3.5-flash-lite"),
+        speech: str("MODEL_SPEECH", "google/gemini-3.8-flash-tts"),
+        /** Vectors for a project's document index; not a class a step names. */
+        embedding: str("MODEL_EMBEDDING", "openai/text-embedding-3-small"),
+    },
+    /**
+     * Reverse geocoder for location fields (Nominatim's `/reverse`); unset = coordinates only,
+     * nothing about where a person stands leaves this server.
+     */
+    geocoderUrl: str("GEOCODER_URL"),
+    /** CDP endpoint of a Chromium (the engenty-browser image); else a local Chrome is launched. */
+    browserCdpUrl: str("BROWSER_CDP_URL"),
+    chromePath: str("CHROME_PATH", process.platform === "darwin"
+        ? "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+        : "/usr/bin/chromium"),
+    /** Encodes widget animations to MP4; without it widgets offer no video. */
+    ffmpegPath: str("FFMPEG_PATH", "ffmpeg"),
+    /** What runs an agent's shell and code: a Docker container, an agentOS VM, or nothing. */
+    sandbox: sandboxEngine(sandboxImage),
+    sandboxImage,
+    /** Assets and workspace files in an S3-compatible bucket (R2); empty = the data folder. */
+    s3: {
+        endpoint: str("S3_ENDPOINT").replace(/\/$/, ""),
+        bucket: str("S3_BUCKET"),
+        region: str("S3_REGION", "auto"),
+        accessKeyId: str("S3_ACCESS_KEY_ID"),
+        secretAccessKey: str("S3_SECRET_ACCESS_KEY"),
+    },
+    turnstile: { siteKey: str("TURNSTILE_SITE_KEY"), secret: str("TURNSTILE_SECRET_KEY") },
+    limits: {
+        visitorRunsPerHour: num("LIMIT_VISITOR_RUNS_PER_HOUR", 6),
+        defaultDailyRuns: num("LIMIT_DEFAULT_DAILY_RUNS", 50),
+        /** Runs of one tenant that work at the same time; the Manage-App can set another number per tenant. */
+        concurrentRuns: num("LIMIT_CONCURRENT_RUNS", 4),
+        /**
+         * Projects a tenant works with. One: the studio shows no project switcher. The Manage-App
+         * can set another number per tenant; the database holds any number either way.
+         */
+        projects: num("LIMIT_PROJECTS", 1),
+        /** End-user runs (no account) and their shared links are deleted after this many days. */
+        resultTtlDays: num("RESULT_TTL_DAYS", 7),
+        /** What a wizard keeps for a person (lists, files, accounts) goes when unused this long. */
+        storeTtlDays: num("STORE_TTL_DAYS", 400),
+    },
+};
+/**
+ * The path APP_URL ends in: `/wizards` for https://example.com/wizards, empty for an origin alone. The proxy
+ * may strip it or not, so the server takes both; what it writes into a cookie or a redirect
+ * carries it.
+ */
+export const basePath = new URL(env.appUrl).pathname.replace(/\/+$/, "");
+if (env.production) {
+    const required = [
+        "APP_URL",
+        ...(manageUrl ? ["APP_SECRET", "MANAGE_SERVICE_KEY", "MANAGE_CLIENT_ID"] : []),
+    ];
+    const missing = required.filter((k) => !process.env[k]?.trim());
+    if (missing.length) {
+        throw new Error(`Missing required environment in production: ${missing.join(", ")}`);
+    }
+}

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

@@ -0,0 +1,22 @@
+import { createHash } from "node:crypto";
+import { objects } from "./objects.js";
+/** Content-addressed file store for workspaces: a blob never changes, so snapshots are just lists of hashes. */
+const blobKey = (hash) => `blobs/${hash.slice(0, 2)}/${hash}`;
+export async function putBlob(data) {
+    const hash = createHash("sha256").update(data).digest("hex");
+    const key = blobKey(hash);
+    if (!(await objects.has(key))) {
+        await objects.put(key, data);
+    }
+    return hash;
+}
+export async function getBlob(hash) {
+    if (!/^[a-f0-9]{64}$/.test(hash)) {
+        throw new Error("bad blob hash");
+    }
+    const data = await objects.get(blobKey(hash));
+    if (!data) {
+        throw new Error("blob missing");
+    }
+    return data;
+}

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

@@ -0,0 +1,86 @@
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { AwsClient } from "aws4fetch";
+import { env } from "../env.js";
+import { currentTenant } from "../tenants/tenant.js";
+function fileStore(root) {
+    const at = (key) => join(root, key);
+    return {
+        async put(key, data) {
+            const path = at(key);
+            await mkdir(dirname(path), { recursive: true });
+            // Two writers of the same key (the same blob, at the same moment) each need their own.
+            const tmp = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+            await writeFile(tmp, data);
+            await rename(tmp, path);
+        },
+        get: (key) => readFile(at(key)).catch(() => null),
+        has: async (key) => existsSync(at(key)),
+        remove: (key) => rm(at(key), { force: true }),
+        removePrefix: (prefix) => rm(at(prefix), { recursive: true, force: true }),
+    };
+}
+function s3Store() {
+    const aws = new AwsClient({
+        accessKeyId: env.s3.accessKeyId,
+        secretAccessKey: env.s3.secretAccessKey,
+        region: env.s3.region,
+        service: "s3",
+    });
+    const base = `${env.s3.endpoint}/${env.s3.bucket}`;
+    const url = (key) => `${base}/${key.split("/").map(encodeURIComponent).join("/")}`;
+    const check = (res, what) => {
+        if (!res.ok) {
+            throw new Error(`Object store ${what} failed: ${res.status}`);
+        }
+    };
+    return {
+        async put(key, data) {
+            check(await aws.fetch(url(key), { method: "PUT", body: data }), "put");
+        },
+        async get(key) {
+            const res = await aws.fetch(url(key));
+            if (res.status === 404) {
+                return null;
+            }
+            check(res, "get");
+            return Buffer.from(await res.arrayBuffer());
+        },
+        async has(key) {
+            return (await aws.fetch(url(key), { method: "HEAD" })).ok;
+        },
+        async remove(key) {
+            check(await aws.fetch(url(key), { method: "DELETE" }), "delete");
+        },
+        async removePrefix(prefix) {
+            for (let token = ""; token !== null;) {
+                const list = new URL(base);
+                list.searchParams.set("list-type", "2");
+                list.searchParams.set("prefix", prefix);
+                if (token) {
+                    list.searchParams.set("continuation-token", token);
+                }
+                const res = await aws.fetch(list.toString());
+                check(res, "list");
+                const xml = await res.text();
+                const keys = [...xml.matchAll(/<Key>([^<]+)<\/Key>/g)].map((m) => m[1]);
+                await Promise.all(keys.map((key) => aws.fetch(url(key), { method: "DELETE" })));
+                token = xml.match(/<NextContinuationToken>([^<]+)</)?.[1] ?? null;
+            }
+        },
+    };
+}
+const store = env.s3.endpoint && env.s3.bucket ? s3Store() : fileStore(join(env.dataDir, "objects"));
+const tenantKey = (key) => `t/${currentTenant()}/${key}`;
+export const objects = {
+    put: (key, data) => store.put(tenantKey(key), data),
+    get: (key) => store.get(tenantKey(key)),
+    has: (key) => store.has(tenantKey(key)),
+    remove: (key) => store.remove(tenantKey(key)),
+};
+/** Deletes every file of a tenant. */
+export function removeTenantObjects(tenantId) {
+    return store.removePrefix(`t/${tenantId}/`);
+}

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

@@ -0,0 +1,95 @@
+import { eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { db, schema } from "../db/client.js";
+import { currentTenant } from "../tenants/tenant.js";
+import { objects } from "./objects.js";
+const assetKey = (file) => `assets/${file}`;
+const EXT = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/webp": "webp",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "video/quicktime": "mov",
+    "audio/webm": "weba",
+    "audio/mp4": "m4a",
+    "audio/mpeg": "mp3",
+    "audio/ogg": "ogg",
+    "audio/wav": "wav",
+    "text/html": "html",
+    "text/markdown": "md",
+    "text/plain": "txt",
+    "application/json": "json",
+    "application/pdf": "pdf",
+};
+export function extFor(mime) {
+    return EXT[mime] ?? "bin";
+}
+export async function saveAsset(input) {
+    const id = nanoid(16);
+    const bytes = typeof input.data === "string" ? Buffer.from(input.data, "utf8") : Buffer.from(input.data);
+    const file = `${id}.${extFor(input.mime)}`;
+    await objects.put(assetKey(file), bytes);
+    await db.insert(schema.asset).values({
+        id,
+        tenantId: currentTenant(),
+        runId: input.runId ?? null,
+        stepId: input.stepId ?? null,
+        kind: input.kind,
+        mime: input.mime,
+        name: input.name,
+        path: file,
+        size: bytes.byteLength,
+    });
+    return {
+        id,
+        kind: input.kind,
+        mime: input.mime,
+        name: input.name,
+        ...(input.ai ? { ai: input.ai } : {}),
+    };
+}
+export async function loadAsset(id) {
+    const row = await db.query.asset.findFirst({ where: eq(schema.asset.id, id) });
+    if (!row) {
+        return null;
+    }
+    const data = await objects.get(assetKey(row.path));
+    return data ? { row, data } : null;
+}
+export async function loadAssetText(id) {
+    const found = await loadAsset(id);
+    return found ? found.data.toString("utf8") : "";
+}
+/**
+ * Generated HTML points at images as `asset://ID`; previews and downloads get them
+ * inlined as data URIs, so every file stands on its own. Only the tenant's assets resolve.
+ */
+export async function inlineAssetRefs(html) {
+    const ids = [...new Set([...html.matchAll(/asset:\/\/([A-Za-z0-9_-]{6,40})/g)].map((m) => m[1]))];
+    let out = html;
+    for (const id of ids) {
+        const found = await loadAsset(id);
+        const uri = found?.row.mime.startsWith("image/")
+            ? `data:${found.row.mime};base64,${found.data.toString("base64")}`
+            : "";
+        out = out.split(`asset://${id}`).join(uri);
+    }
+    return out;
+}
+/** 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) });
+    if (row) {
+        await objects.remove(assetKey(row.path));
+        await db.delete(schema.asset).where(eq(schema.asset.id, id));
+    }
+}
+/** Deletes every file a run made (uploads, results, renders) and their rows. */
+export async function removeAssetFiles(runId) {
+    const rows = await db.query.asset.findMany({ where: eq(schema.asset.runId, runId) });
+    for (const row of rows) {
+        await objects.remove(assetKey(row.path));
+    }
+    await db.delete(schema.asset).where(eq(schema.asset.runId, runId));
+}

package/apps/runtime/dist/geocode.js

@@ -0,0 +1,58 @@
+import { env } from "./env.js";
+const cache = new Map();
+let queue = Promise.resolve();
+let lastCall = 0;
+/** "Herrengasse 16, 8010 Graz" from a reverse-geocoding answer; null when it names nothing. */
+export function placeLabel(result) {
+    const a = result.address;
+    if (!a) {
+        return result.display_name?.split(",").slice(0, 3).join(",").trim() || null;
+    }
+    const street = [a.road ?? a.pedestrian ?? a.footway ?? a.path, a.house_number]
+        .filter(Boolean)
+        .join(" ");
+    const town = a.city ?? a.town ?? a.village ?? a.municipality ?? a.hamlet ?? a.county;
+    const place = [a.postcode, town].filter(Boolean).join(" ");
+    return [street, place].filter(Boolean).join(", ") || null;
+}
+/**
+ * The address of a position, when the server has a geocoder (`GEOCODER_URL`). Calls go out one
+ * at a time and at most one a second — what a public Nominatim asks of its users.
+ */
+export function reverseGeocode(lat, lng, language = "de") {
+    if (!env.geocoderUrl) {
+        return Promise.resolve(null);
+    }
+    // ~10 m: the same spot asked twice is one call.
+    const key = `${lat.toFixed(4)},${lng.toFixed(4)},${language}`;
+    if (cache.has(key)) {
+        return Promise.resolve(cache.get(key) ?? null);
+    }
+    const call = queue.then(async () => {
+        await new Promise((r) => setTimeout(r, Math.max(0, lastCall + 1000 - Date.now())));
+        lastCall = Date.now();
+        try {
+            const url = new URL(env.geocoderUrl);
+            url.searchParams.set("format", "jsonv2");
+            url.searchParams.set("lat", String(lat));
+            url.searchParams.set("lon", String(lng));
+            url.searchParams.set("zoom", "18");
+            url.searchParams.set("addressdetails", "1");
+            const res = await fetch(url, {
+                headers: { "accept-language": language, "user-agent": `engenty-wizards (${env.appUrl})` },
+                signal: AbortSignal.timeout(4000),
+            });
+            const label = res.ok ? placeLabel((await res.json())) : null;
+            if (cache.size > 500) {
+                cache.clear();
+            }
+            cache.set(key, label);
+            return label;
+        }
+        catch {
+            return null;
+        }
+    });
+    queue = call;
+    return call;
+}