@tollwyn/baukasten 0.0.2 → 1.2.3

package/dist/server/hook.js

@@ -0,0 +1,293 @@
+import { createAccounts } from './accounts.js';
+import { createDb } from './adapter/db.js';
+import { exitAfterLog, log } from './adapter/log.js';
+import { createMailer } from './adapter/mailer.js';
+import { migrationSources, migrationStatus } from './adapter/migrate.js';
+import { secrets } from './adapter/secrets.js';
+import { createStripe } from './adapter/stripe.js';
+import { asApiError, readBody, respond } from './api.js';
+import { createBilling, noBilling } from './billing.js';
+import { ConfigError, loadConfig } from './config.js';
+import { apiAccount, serveApi } from './endpoints.js';
+import { CHECK_TIMEOUT_MS, databaseCheck, deepHealth, mailCheck, stripeCheck } from './health.js';
+import { SECURITY_HEADERS } from './headers.js';
+import { legalPages } from './legal/index.js';
+import { createLimits } from './limits.js';
+import { serveMachine } from './machine.js';
+import { MESSAGES } from './messages.js';
+import { mergeOpenApi, openApiPart } from './openapi.js';
+import { createPages } from './pages.js';
+import { BAUKASTEN_TERMS_DATE, termsVersion } from './terms.js';
+import { clearSessionCookie, clientAddress, isCrossSite, isMachinePath, SESSION_COOKIE } from './web.js';
+const HEALTH = '/health';
+const DEEP = '/health/deep';
+/**
+ * The product's src/app.html writes `<html lang="%baukasten.lang%" %baukasten.theme%>`; the handle
+ * fills in its language and, with a theme in its marks, `data-theme="…"`, else nothing.
+ */
+const LANG = '%baukasten.lang%';
+const THEME = '%baukasten.theme%';
+/** The attribute of the theme on `<html>`: before the first paint, so no page flashes another. */
+function themeAttribute(theme) {
+    return theme === undefined ? '' : `data-theme="${theme}"`;
+}
+/** The queries of the database check end before the check does, and give their connection back. */
+const PROBE_TIMEOUT_MS = CHECK_TIMEOUT_MS - 1_000;
+function json(body, status) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { 'content-type': 'application/json', 'cache-control': 'no-store' }
+    });
+}
+export function baukasten(product, hooks = {}) {
+    const own = hooks.checks ?? {};
+    if ('database' in own || 'mail' in own || 'stripe' in own) {
+        throw new Error('the checks database, mail and stripe belong to the baukasten');
+    }
+    let state = { kind: 'waiting' };
+    function running() {
+        switch (state.kind) {
+            case 'running':
+                return state;
+            case 'building':
+                throw new Error('the baukasten is used in the build: its pages read the configuration of the running product and cannot be prerendered');
+            case 'waiting':
+                throw new Error('the baukasten is used before init ran');
+        }
+    }
+    async function stop(context) {
+        try {
+            await hooks.stop?.(context);
+        }
+        catch (error) {
+            process.exitCode = 1;
+            log.error('the stop hook of the product failed', { error });
+        }
+        await context.db.close();
+        log.info('stopped');
+    }
+    async function start() {
+        let config;
+        try {
+            config = loadConfig(process.env, product);
+        }
+        catch (error) {
+            if (!(error instanceof ConfigError))
+                throw error;
+            log.error('configuration incomplete, not starting', { problems: error.problems });
+            return exitAfterLog(1);
+        }
+        if (config.missing.length > 0) {
+            log.warn('running without what production needs', { missing: config.missing });
+        }
+        const db = createDb(config.databaseUrl, log);
+        const mail = createMailer(config.mail, config.name, log);
+        const limits = createLimits({ now: () => Date.now() });
+        const context = { config, db, log, mail, limits };
+        const version = termsVersion(BAUKASTEN_TERMS_DATE, product.termsDate);
+        const messages = MESSAGES[config.language];
+        const shop = { name: config.name, origin: config.publicOrigin };
+        const paid = config.stripe.kind === 'stripe'
+            ? { stripe: createStripe(config.stripe), mode: config.stripe.mode }
+            : null;
+        const billing = paid === null
+            ? noBilling(db)
+            : createBilling({
+                db,
+                stripe: paid.stripe,
+                catalog: product.catalog,
+                shop,
+                mode: paid.mode,
+                hooks: {
+                    // A product without plans or purchases of its own has nothing to derive.
+                    subscriptionChanged: hooks.subscriptionChanged ?? (() => Promise.resolve()),
+                    purchasePaid: hooks.purchasePaid ?? (() => Promise.resolve())
+                },
+                log,
+                now: () => new Date(),
+                termsMessage: (url) => messages.stripe.terms(config.name, url)
+            });
+        const services = {
+            config,
+            product,
+            db,
+            log,
+            mail,
+            limits,
+            accounts: createAccounts(db, secrets),
+            billing,
+            messages,
+            termsVersion: version,
+            legal: legalPages({
+                language: config.language,
+                name: config.name,
+                origin: config.publicOrigin,
+                operator: config.operator,
+                legal: product.legal,
+                version
+            }),
+            // A product that keeps nothing of its own per account has nothing to delete.
+            deleteHook: hooks.deleteAccount ?? (() => Promise.resolve()),
+            // A product without numbers of its own gives the two of the baukasten.
+            salesNumbers: hooks.salesNumbers ?? (() => Promise.resolve({})),
+            address: (event) => clientAddress(event.request.headers, config.mode, () => event.getClientAddress()),
+            now: () => new Date()
+        };
+        const sources = migrationSources(process.cwd(), 'webapp');
+        const probe = db.withTimeout(PROBE_TIMEOUT_MS);
+        const checks = Object.fromEntries(Object.entries(own).map(([name, check]) => [name, () => check(context)]));
+        // Without Stripe, locally, there is nothing to check.
+        const stripeHealth = paid === null
+            ? () => Promise.resolve()
+            : stripeCheck(paid.stripe, product.catalog, shop, log);
+        const health = deepHealth({
+            checks: {
+                database: databaseCheck(probe, () => migrationStatus(probe, sources), log),
+                mail: mailCheck(mail, log),
+                stripe: stripeHealth,
+                ...checks
+            },
+            now: () => Date.now(),
+            log
+        });
+        state = { kind: 'running', context, services, health };
+        log.info('starting', {
+            mode: config.mode,
+            origin: config.publicOrigin,
+            language: config.language
+        });
+        await hooks.start?.(context);
+        process.once('sveltekit:shutdown', () => void stop(context));
+    }
+    const init = (building) => () => {
+        if (!building)
+            return start();
+        state = { kind: 'building' };
+    };
+    async function health(event) {
+        if (event.request.method !== 'GET' && event.request.method !== 'HEAD') {
+            return new Response(null, { status: 405, headers: { allow: 'GET, HEAD' } });
+        }
+        // Plain health answers without the database: Neon may sleep, the process still lives.
+        if (event.url.pathname === HEALTH)
+            return json({ status: 'ok' }, 200);
+        const report = await running().health();
+        return json(report, report.status === 'ok' ? 200 : 503);
+    }
+    async function respondTo(event, resolve) {
+        const path = event.url.pathname;
+        if (path === HEALTH || path === DEEP)
+            return health(event);
+        const s = running().services;
+        event.locals.account = null;
+        if (isCrossSite(event.request, s.config.publicOrigin)) {
+            log.warn('request refused: from another origin', { path });
+            return path.startsWith('/api/')
+                ? Response.json({ error: { code: 'forbidden', message: s.messages.api.forbidden } }, { status: 403 })
+                : new Response(s.messages.crossSite, {
+                    status: 403,
+                    headers: { 'content-type': 'text/plain; charset=utf-8' }
+                });
+        }
+        if (!isMachinePath(path)) {
+            const token = event.cookies.get(SESSION_COOKIE);
+            if (token !== undefined) {
+                event.locals.account = await s.accounts.forSession(token);
+                if (event.locals.account === null)
+                    clearSessionCookie(event.cookies);
+            }
+        }
+        const machine = serveMachine(s, event);
+        if (machine !== null)
+            return machine;
+        const api = serveApi(s, event);
+        if (api !== null)
+            return api;
+        const response = await resolve(event, {
+            transformPageChunk: ({ html }) => html.replace(LANG, s.config.language).replace(THEME, themeAttribute(s.product.brand?.theme))
+        });
+        return path.startsWith('/api/') ? asApiError(response, s.messages) : withPolicy(response, path);
+    }
+    /** Whether a page went out without its content security policy; said once in the log. */
+    let policyMissing = false;
+    /**
+     * A page without its content security policy does not go out: the policy comes from
+     * SVELTEKIT_OPTIONS in the configuration of the product, and without it every page is a 500 that
+     * the delivery service sees, not a product that runs without the policy unnoticed.
+     */
+    function withPolicy(response, path) {
+        const page = response.headers.get('content-type')?.startsWith('text/html') === true;
+        if (!page || response.status >= 500 || response.headers.has('content-security-policy')) {
+            return response;
+        }
+        if (!policyMissing) {
+            policyMissing = true;
+            log.error('a page without its content security policy: SVELTEKIT_OPTIONS of the baukasten is missing in sveltekit() of vite.config.ts, or an endpoint of the product answers HTML of its own; every such answer is a 500', { path });
+        }
+        return new Response('Internal Error', {
+            status: 500,
+            headers: { 'content-type': 'text/plain; charset=utf-8' }
+        });
+    }
+    const handle = async ({ event, resolve }) => {
+        // Prerendering in the build is no request of anyone.
+        if (state.kind === 'building')
+            return resolve(event);
+        const started = performance.now();
+        let status = 500;
+        try {
+            const response = await respondTo(event, resolve);
+            for (const [name, value] of Object.entries(SECURITY_HEADERS)) {
+                response.headers.set(name, value);
+            }
+            status = response.status;
+            return response;
+        }
+        finally {
+            // The container polls /health; it is logged only at debug. The path goes without its query,
+            // which may carry a token.
+            (event.url.pathname === HEALTH ? log.debug : log.info)('request', {
+                method: event.request.method,
+                path: event.url.pathname,
+                status,
+                ms: Math.round(performance.now() - started)
+            });
+        }
+    };
+    const handleError = ({ error, event, status, message }) => {
+        // An unknown path is already in the request log.
+        if (status === 404)
+            return { message };
+        (status >= 500 ? log.error : log.warn)('request failed', {
+            method: event.request.method,
+            path: event.url.pathname,
+            status,
+            error
+        });
+        return { message: status >= 500 ? 'Internal Error' : message };
+    };
+    return {
+        init,
+        handle,
+        handleError,
+        context: () => running().context,
+        pages: createPages(() => running().services),
+        clientAddress: (event) => running().services.address(event),
+        api: {
+            respond: (handler) => {
+                const s = running().services;
+                return respond(s.log, s.messages, handler);
+            },
+            body: (request, schema) => readBody(request, schema, running().services.messages),
+            account: async (event) => (await apiAccount(running().services, event)).account
+        },
+        openApi: (document) => {
+            const s = running().services;
+            return mergeOpenApi(document, openApiPart(s.config.publicOrigin, s.messages));
+        },
+        billing: {
+            checkout: (account, order) => running().services.billing.checkout(account, order),
+            portal: (account, back) => running().services.billing.portal(account, back)
+        }
+    };
+}

package/dist/server/index.d.ts

@@ -0,0 +1,18 @@
+export type { Account, ApiKey } from './accounts.js';
+export { log } from './adapter/log.js';
+export { ApiError } from './api.js';
+export { StripeFailed, type CheckoutPage, type Order, type Purchase, type Subscription, type SubscriptionChange } from './billing.js';
+export type { Config, Mail as MailConfig, Operator, Register, Stripe } from './config.js';
+export { CheckFailed } from './health.js';
+export { baukasten, type Context, type Hooks, type Kit } from './hook.js';
+export { LIMITS, type Limits, type Rule } from './limits.js';
+export type { Log } from './log.js';
+export { MailFailed } from './mail.js';
+export type { OpenApiDocument } from './openapi.js';
+export type { Pages } from './pages.js';
+export type { Db, Mail, Mailer, Queryable, SubscriptionStatus } from './ports.js';
+export { periodic, type Run, type RunOptions } from './runs.js';
+export type { ProductNumbers } from './sales.js';
+export { start, type NodeHandler } from './start.js';
+export { KEY_RIGHTS, WEBHOOK_EVENTS, WEBHOOK_PATH } from './stripe.js';
+export { requireAccount, tooMany } from './web.js';

package/dist/server/index.js

@@ -0,0 +1,11 @@
+export { log } from './adapter/log.js';
+export { ApiError } from './api.js';
+export { StripeFailed } from './billing.js';
+export { CheckFailed } from './health.js';
+export { baukasten } from './hook.js';
+export { LIMITS } from './limits.js';
+export { MailFailed } from './mail.js';
+export { periodic } from './runs.js';
+export { start } from './start.js';
+export { KEY_RIGHTS, WEBHOOK_EVENTS, WEBHOOK_PATH } from './stripe.js';
+export { requireAccount, tooMany } from './web.js';

package/dist/server/legal/de.d.ts

@@ -0,0 +1,2 @@
+import { type LegalTexts } from './document.js';
+export declare const de: LegalTexts;

package/dist/server/legal/de.js

@@ -0,0 +1,251 @@
+import { SESSION_DAYS } from '../accounts.js';
+import { code, heading, lettered, link, list, longDate, mail, note, numbered, paragraph, strong } from './document.js';
+import { FLEET, FLEET_PROCESSORS } from './fleet.js';
+const { cloudflare, hoster, neon, stripe, webServer } = FLEET;
+const BASIS = {
+    contract: 'Erfüllung des Vertrags, Art. 6 Abs. 1 lit. b DSGVO',
+    legitimateInterest: 'berechtigtes Interesse, Art. 6 Abs. 1 lit. f DSGVO'
+};
+const TRANSFER = {
+    adequate: 'Land mit angemessenem Schutz',
+    dpf: 'unter dem Data Privacy Framework zertifiziert',
+    scc: 'mit den Standardvertragsklauseln der EU, vom EDÖB anerkannt'
+};
+function register(entry) {
+    switch (entry.kind) {
+        case 'none':
+            return 'Einzelunternehmen, nicht im Handelsregister eingetragen.';
+        case 'entered':
+            return `Handelsregister: ${entry.uid}.`;
+    }
+}
+const VAT = {
+    none: {
+        imprint: 'Nicht im MWST-Register eingetragen; es gibt keine MWST-Nummer.',
+        terms: 'Wir sind nicht im MWST-Register eingetragen und verrechnen keine MWST; Steuern, die in Ihrem Land anfallen, rechnen Sie selbst ab.'
+    }
+};
+const BROWSER = {
+    networkErrorLogging: `${cloudflare.name} lässt Ihren Browser ausserdem eine Anweisung speichern, gescheiterte Verbindungen zu melden (Network Error Logging). Löschen Sie Cookies und Websitedaten im Browser, fällt auch diese Anweisung weg.`
+};
+const EDGE = {
+    worldwideUnderScc: 'im Rechenzentrum, das Ihnen am nächsten liegt und ausserhalb der Schweiz und der EU stehen kann; dort gelten die Standardvertragsklauseln seines Auftragsbearbeitungsvertrags'
+};
+const ACCESS_LOG = {
+    none: 'Unser Webserver führt kein Zugriffsprotokoll'
+};
+const ERROR_LOG = {
+    requestWithoutAddress: 'nur eine Anfrage, die er nicht an die Anwendung weitergeben kann, schreibt er in sein Fehlerprotokoll, ohne Ihre IP-Adresse und ohne Parameter und Kopfzeilen'
+};
+const NEW_VERSION = {
+    removed: 'es fällt ausserdem bei jedem Start einer neuen Version weg',
+    stays: 'beim Start einer neuen Version bleibt es'
+};
+const STRIPE_ROLE = {
+    controller: 'Stripe bearbeitet Daten auch als eigener Verantwortlicher, etwa um Betrug zu verhindern und seine gesetzlichen Pflichten zu erfüllen; siehe '
+};
+/** The section of the terms on processing on behalf, which the privacy policy points to. */
+const ON_BEHALF = 'Daten, die wir in Ihrem Auftrag bearbeiten';
+const who = (f) => `${f.operator.name}, ${f.operator.address}`;
+const version = (f) => note(`Stand: ${longDate(f.version, 'de')}.`);
+const from = (data) => data.source === undefined ? '' : `, aus ${data.source}`;
+export const de = {
+    imprint: (f) => ({
+        title: 'Impressum',
+        blocks: [
+            paragraph(`${f.name} wird betrieben von`),
+            paragraph(strong(f.operator.name)),
+            paragraph(f.operator.address),
+            paragraph(`${register(f.operator.register)} ${VAT[f.operator.vat].imprint}`),
+            paragraph('E-Mail: ', mail(FLEET.mailbox), '. E-Mail ist der einzige Supportkanal; eine Telefon-Hotline gibt es nicht.'),
+            paragraph('Für den Inhalt dieser Website ist der oben genannte Betreiber verantwortlich.')
+        ]
+    }),
+    privacy: (f) => {
+        const own = f.legal.data;
+        const processor = f.legal.processor;
+        return {
+            title: 'Datenschutzerklärung',
+            blocks: [
+                version(f),
+                paragraph(`Diese Erklärung beschreibt, welche Personendaten ${f.name} bearbeitet, wozu, wo und wie lange. Verantwortlich ist ${who(f)}, erreichbar unter `, mail(FLEET.mailbox), '. Sie folgt dem Bundesgesetz über den Datenschutz (DSG) und, wo sie anwendbar ist, der Datenschutz-Grundverordnung der EU (DSGVO).'),
+                heading('Was wir bearbeiten, wozu und gestützt worauf'),
+                list([
+                    strong('Konto'),
+                    `: Ihre E-Mail-Adresse, ein gesalzener Hash Ihres Passworts, wann Sie sich registriert und welche Fassung der Bedingungen Sie angenommen haben, wann Sie Ihre Adresse bestätigt haben, die Links, die wir Ihnen per E-Mail schicken (mit einer neuen Adresse, die Sie verlangen), Ihre Anmeldesitzungen und Hashes Ihrer API-Schlüssel – um Sie anzumelden, die Anfragen Ihrer API-Schlüssel zu beantworten, Ihnen E-Mails zum Konto wie die Bestätigung Ihrer Adresse und das Zurücksetzen des Passworts zu schicken und zu wissen, welche Bedingungen gelten (${BASIS.contract}). Ohne E-Mail-Adresse können Sie ${f.name} nicht nutzen.`
+                ], ...own.map((data) => [
+                    strong(data.name),
+                    `: ${data.what}${from(data)} – ${data.purpose} (${BASIS[data.basis]}).`
+                ]), [
+                    strong('Zahlung'),
+                    `: Stripe bearbeitet Ihre E-Mail-Adresse, Zahlungsangaben und Rechnungsadresse sowie eine Steuernummer, wenn Sie eine angeben; wir behalten Ihre Kunden- und Abonummer bei Stripe, den Stand Ihres Abos sowie Beträge und Zeitpunkte Ihrer Zahlungen (${BASIS.contract}; für die Aufbewahrung danach unser berechtigtes Interesse, das Schweizer Buchführungsrecht einzuhalten, Art. 6 Abs. 1 lit. f DSGVO).`
+                ], [
+                    strong('Partnerlinks'),
+                    ': Kommen Sie über einen Link mit ',
+                    code('?via=…'),
+                    ` zu ${f.name}, tragen die Links der Seite diesen Partnernamen weiter, und bei der Registrierung speichern wir ihn mit Ihrem Konto; Software, die sich über die API registriert, kann einen im Feld `,
+                    code('via'),
+                    ` mitschicken. Gespeichert wird nur der Partnername, und wir nutzen ihn, um zu wissen, welche Partner Kunden bringen (${BASIS.legitimateInterest}). Dafür setzen wir kein Cookie und speichern nichts in Ihrem Browser.`
+                ], [
+                    strong('Sicherheit und Betrieb'),
+                    `: Unsere Anwendung protokolliert jede Anfrage (Methode, Pfad ohne Parameter, Status, Dauer) und Ereignisse des Dienstes mit internen Nummern wie der Ihres Kontos, ohne IP-Adressen, E-Mail-Adressen, Passwörter oder Schlüssel. ${ACCESS_LOG[webServer.accessLog]}; ${ERROR_LOG[webServer.errorLog.content]}. Unser Mail-Relay protokolliert für jede E-Mail, die wir senden, die Empfängeradresse und den Zustellstatus und bewahrt beides höchstens ${FLEET.relayLogDays} Tage auf. Um Registrierungen, Anmeldungen und andere Versuche zu begrenzen, zählen wir sie im Arbeitsspeicher der Anwendung, nie auf der Festplatte: je IP-Adresse, je Konto, je API-Schlüssel und je E-Mail-Adresse, diese nur als Hash; ein Zähler gilt höchstens eine Stunde und ist spätestens beim Neustart der Anwendung vergessen (berechtigtes Interesse an einem sicheren und funktionierenden Dienst, Art. 6 Abs. 1 lit. f DSGVO).`
+                ], [
+                    strong('E-Mails an uns'),
+                    ': Schreiben Sie uns, bewahren wir Ihre Nachricht und Adresse auf, um Ihnen zu antworten und den Austausch zu belegen (berechtigtes Interesse; bei Kunden Erfüllung des Vertrags).'
+                ]),
+                ...(processor.kind === 'yes'
+                    ? [
+                        paragraph(`Für Personendaten ${processor.data}, die ${processor.subjects} betreffen, sind Sie verantwortlich, und wir bearbeiten sie in Ihrem Auftrag (siehe «${ON_BEHALF}» in den `, link('Bedingungen', '/terms'), ').')
+                    ]
+                    : []),
+                paragraph(strong('Cookies'), ': Wir setzen ein einziges Cookie, nur für diese Website und mit HttpOnly, Secure und SameSite=Lax: ', code('__Host-session'), ` hält Sie angemeldet, für ${SESSION_DAYS} Tage oder bis Sie sich abmelden, und ist für die Web-App nötig. Sie können Cookies in Ihrem Browser ablehnen; anmelden können Sie sich in der Web-App dann nicht, die API funktioniert weiter mit Schlüsseln. ${BROWSER[cloudflare.browser]} Wir verwenden keine Werbe- oder Analyse-Tracker, verkaufen keine Daten und entscheiden nicht automatisiert über Sie.`),
+                heading('Wer Daten erhält und wo'),
+                list([
+                    `${cloudflare.name} (${cloudflare.country.de}; ${TRANSFER[cloudflare.transfer]}) steht vor ${f.name}: Es entschlüsselt die Verbindung (TLS), leitet Anfragen weiter und filtert Angriffe. Es sieht darum jede Anfrage samt Ihrer IP-Adresse, ${EDGE[cloudflare.edge]}. Ausserdem speichert es die verschlüsselten Sicherungen unserer Datenbank (Cloudflare R2, ${cloudflare.backups.where.de}), die es nicht lesen kann.`
+                ], [
+                    `Anwendungsserver: ${hoster.name} (${hoster.country.de}), in deren Rechenzentren in ${hoster.dataCentres.de}; der Server ist gemietet und wird vom Betreiber verwaltet.`
+                ], [
+                    `Datenbank: ${neon.name} (ein Unternehmen von ${neon.owner}, ${neon.country.de}; ${TRANSFER[neon.transfer]}), gespeichert in der Region ${neon.region} von ${neon.cloud} in ${neon.place.de}; ein Zugriff aus dem Land des Anbieters ist möglich.`
+                ], [
+                    `Zahlungen: ${stripe.name} (${stripe.country.de}), mit Übermittlung an ${stripe.parent.name} (${stripe.parent.country.de}; ${TRANSFER[stripe.parent.transfer]}). ${STRIPE_ROLE[stripe.role]}`,
+                    link(stripe.privacy, `https://${stripe.privacy}`),
+                    '.'
+                ], [
+                    `E-Mail: ${FLEET.mail.name} (${FLEET.mail.country.de}) versendet unsere E-Mails und führt unser Postfach.`
+                ], ...f.legal.recipients.map((recipient) => [
+                    `${recipient.name} (${recipient.place}; ${TRANSFER[recipient.transfer]}): ${recipient.purpose}.`
+                ])),
+                paragraph(`Daten können also in den oben genannten Ländern bearbeitet werden und, bei ${cloudflare.name}, im Land des Rechenzentrums, das Ihnen antwortet. Jeder Empfänger ausserhalb der Schweiz und der EU steht oben mit der Garantie, die ihn deckt.`),
+                heading('Wie lange'),
+                list([
+                    'Ihr Konto mit seinen Sitzungen, Links und Schlüsseln bleibt, bis Sie es unter «Konto» löschen; dann wird es sofort gelöscht.'
+                ], ...own.map((data) => [strong(data.name), `: ${data.kept}.`]), [
+                    `Unser Datenbankanbieter führt höchstens ${neon.historyDays} Tage lang eine Historie, um die Datenbank auf einen früheren Zeitpunkt zurückzusetzen, und unsere verschlüsselten Sicherungen davon werden nach rund ${cloudflare.backups.days} Tagen gelöscht; gelöschte Daten verschwinden innert dieser Zeit aus beiden.`
+                ], [
+                    'Nach der Löschung bleibt nur ein pseudonymer Datensatz des Kontos, ohne Ihre E-Mail-Adresse: der Partnername, die Zeitpunkte des Kontos (etwa der Registrierung) und die angenommene Fassung der Bedingungen, Kunden- und Abonummer bei Stripe mit dem letzten Stand des Abos sowie Beträge und Zeitpunkte Ihrer Zahlungen. Wir bewahren ihn zehn Jahre auf, wie es das Schweizer Buchführungsrecht verlangt (Art. 958f OR). Stripe führt eigene Aufzeichnungen, auch Ihre Rechnungen.'
+                ], [
+                    `Das Anwendungsprotokoll rotiert nach Grösse, in ${FLEET.appLog.files} Dateien zu ${FLEET.appLog.megabytes} MB, und wird überschrieben, sobald neue Einträge kommen; ${NEW_VERSION[FLEET.appLog.newVersion]}. Das Fehlerprotokoll des Webservers rotiert ebenfalls nach Grösse, in ${webServer.errorLog.files} Dateien zu ${webServer.errorLog.megabytes} MB, und wird überschrieben, sobald neue Einträge kommen; ${NEW_VERSION[webServer.errorLog.newVersion]}. Das Protokoll des Mail-Relays bleibt höchstens ${FLEET.relayLogDays} Tage.`
+                ], [
+                    `Die Sitzung dauert ${SESSION_DAYS} Tage oder bis Sie sich abmelden. Die Zähler je IP-Adresse, Konto, API-Schlüssel und E-Mail-Adresse gelten höchstens eine Stunde, liegen nur im Arbeitsspeicher und sind spätestens beim Neustart der Anwendung vergessen.`
+                ], [
+                    'E-Mails an uns: so lange, wie der Austausch es braucht, und bei Kunden so lange, wie Vertrag und Buchführungsrecht es verlangen.'
+                ]),
+                heading('Ihre Rechte'),
+                paragraph('Sie können Auskunft verlangen, was wir über Sie bearbeiten, und diese Daten in einem gängigen elektronischen Format erhalten, sie berichtigen oder löschen lassen und ihre Bearbeitung einschränken lassen. Einer Bearbeitung, die auf unserem berechtigten Interesse beruht, können Sie jederzeit widersprechen. Ihre E-Mail-Adresse ändern und Ihr Konto löschen können Sie selbst unter «Konto»; für alles andere schreiben Sie an ', mail(FLEET.mailbox), '. Wir antworten innert 30 Tagen. Sie können sich beim Eidgenössischen Datenschutz- und Öffentlichkeitsbeauftragten (EDÖB) beschweren oder, in der EU, bei der Datenschutzbehörde Ihres Landes.'),
+                heading('Änderungen'),
+                paragraph('Es gilt die hier veröffentlichte Fassung. Über wichtige Änderungen informieren wir Kunden per E-Mail.')
+            ]
+        };
+    },
+    terms: (f) => {
+        const processor = f.legal.processor;
+        const processors = [
+            ...FLEET_PROCESSORS,
+            ...f.legal.recipients
+                .filter((recipient) => recipient.role === 'processor')
+                .map((recipient) => recipient.name)
+        ];
+        const sections = [
+            {
+                title: 'Nur für Unternehmen',
+                blocks: [
+                    paragraph(`${f.name} richtet sich nur an Unternehmen, öffentliche Stellen und Selbständige für ihre berufliche Tätigkeit, nicht an Konsumenten.`)
+                ]
+            },
+            {
+                title: 'Die Leistung',
+                blocks: [
+                    paragraph(`${f.legal.service} Wir dürfen ${f.name} weiterentwickeln, entfernen aber während einer bezahlten Periode keine seiner Hauptfunktionen.`)
+                ]
+            },
+            {
+                title: 'Was wir nicht gewährleisten',
+                blocks: [
+                    paragraph(`${f.legal.notGuaranteed} Wir gewährleisten nicht, dass ${f.name} jederzeit verfügbar ist: Wartung und Ausfälle unserer Hosting- und Netzanbieter oder von Stripe können den Dienst verzögern oder unterbrechen.`)
+                ]
+            },
+            {
+                title: 'Konto und Testphase',
+                blocks: [
+                    paragraph(`Sie brauchen ein Konto mit einer gültigen E-Mail-Adresse. Bietet ${f.name} eine kostenlose Testphase an, gelten deren Dauer und Grenzen, wie die Preisseite sie nennt; sie endet von selbst und kostet nichts, solange Sie nicht bezahlen. Halten Sie Ihr Passwort und Ihre API-Schlüssel geheim; Sie sind verantwortlich für das, was damit geschieht.`)
+                ]
+            },
+            {
+                title: 'Preise und Zahlung',
+                blocks: [
+                    paragraph(`Es gelten die Preise der Preisseite, in der dort genannten Währung, im Voraus bezahlt über Stripe. ${VAT[f.operator.vat].terms} Ein Abo verlängert sich um seine Periode, bis Sie es im Kundenportal kündigen; es endet dann mit der bezahlten Periode. Wechseln Sie im Kundenportal den Plan, wird die Differenz anteilig belastet oder gutgeschrieben, wie Stripe es dort zeigt; sonst werden bezahlte Perioden und Käufe nicht erstattet, auch nicht, wenn Sie Ihr Konto löschen, was ein Abo sofort beendet. Nicht verbrauchtes Guthaben verfällt ohne Erstattung, wenn Sie Ihr Konto löschen. Scheitert eine Zahlung, dürfen wir die bezahlten Leistungen sperren, bis sie erfolgt ist. Preise dürfen wir mit 30 Tagen Vorlauf per E-Mail ändern; Sie können kündigen, bevor die Änderung gilt.`)
+                ]
+            },
+            {
+                title: 'Nutzung',
+                blocks: [
+                    paragraph(`${f.legal.use} Sie dürfen ${f.name} nicht rechtswidrig nutzen und nicht, um unseren Dienst zu überlasten oder zu stören.`)
+                ]
+            },
+            {
+                title: 'Ihre Daten',
+                blocks: [
+                    paragraph(`Was Sie in ${f.name} eingeben, bleibt Ihres. Löschen Sie Ihr Konto, wird es gelöscht, wie es die Datenschutzerklärung beschreibt.`)
+                ]
+            },
+            ...(processor.kind === 'yes'
+                ? [
+                    {
+                        title: ON_BEHALF,
+                        blocks: [
+                            paragraph(`Für Personendaten ${processor.data}, die ${processor.subjects} betreffen, sind Sie verantwortlich und wir Ihr Auftragsbearbeiter (Art. 9 DSG, Art. 28 DSGVO). Wir bearbeiten diese Daten, solange Ihr Konto besteht, und nur, um Ihnen ${f.name} zu erbringen. Wir:`),
+                            lettered([
+                                'bearbeiten sie nur nach Ihren dokumentierten Weisungen, das sind diese Bedingungen und Ihre Einstellungen, und sagen es Ihnen, wenn wir eine Weisung für datenschutzwidrig halten;'
+                            ], ['verpflichten alle, die Zugang zu ihnen haben, zur Vertraulichkeit;'], [
+                                'schützen sie mit angemessenen technischen und organisatorischen Massnahmen, darunter verschlüsselte Verbindungen, gehashte Passwörter und Schlüssel und einen Zugang, der auf den Betreiber beschränkt ist;'
+                            ], [
+                                `setzen als Unterauftragsbearbeiter nur die in der Datenschutzerklärung genannten ein (${processors.join('; ')}), denen Sie zustimmen, und verpflichten sie auf gleichwertige Datenschutzpflichten; einen neuen kündigen wir 30 Tage im Voraus per E-Mail an, und Sie können widersprechen, indem Sie vor seinem Einsatz kündigen;`
+                            ], [
+                                'helfen Ihnen, soweit wir können, Anfragen betroffener Personen zu beantworten und Ihre Pflichten zu Datensicherheit, Meldung von Verletzungen und Folgenabschätzungen zu erfüllen;'
+                            ], [
+                                'melden Ihnen ohne unangemessene Verzögerung eine Verletzung der Datensicherheit, die diese Daten betrifft;'
+                            ], [
+                                `löschen sie, wenn Sie Ihr Konto löschen, ausser das Gesetz verlangt, sie aufzubewahren; vorher können Sie sie über ${processor.retrieve} lesen oder exportieren; Kopien in der Historie der Datenbank und in unseren Sicherungen enden, wie es die Datenschutzerklärung beschreibt;`
+                            ], [
+                                'geben Ihnen die Informationen, die Sie brauchen, um die Einhaltung dieser Pflichten nachzuweisen, und lassen Prüfungen durch Sie oder eine zur Vertraulichkeit verpflichtete prüfende Person zu, mit angemessener Vorankündigung und auf Ihre Kosten.'
+                            ]),
+                            paragraph('Übermittlungen in die Länder, die die Datenschutzerklärung nennt, erfolgen mit den dort genannten Garantien.')
+                        ]
+                    }
+                ]
+                : []),
+            {
+                title: 'Haftung',
+                blocks: [
+                    paragraph('Wir haften unbeschränkt für Vorsatz und grobe Fahrlässigkeit. Für leichte Fahrlässigkeit ist unsere Haftung, soweit gesetzlich zulässig, auf die Gebühren beschränkt, die Sie in den zwölf Monaten vor dem Schaden bezahlt haben, und wir haften nicht für indirekte Schäden oder Folgeschäden, entgangenen Gewinn oder Datenverlust. Während einer kostenlosen Testphase haften wir nur für Vorsatz und grobe Fahrlässigkeit. Diese Beschränkungen gelten auch für die Haftung für unsere Hilfspersonen und Unterauftragnehmer.')
+                ]
+            },
+            {
+                title: 'Beendigung',
+                blocks: [
+                    paragraph('Sie können Ihr Konto jederzeit unter «Konto» löschen. Wir können Ihr Konto mit 30 Tagen Frist per E-Mail kündigen und erstatten dann Gebühren für die Zeit nach dem Ende sowie nicht verbrauchtes Guthaben. Wir können es fristlos kündigen, wenn Sie diese Bedingungen schwer verletzen.')
+                ]
+            },
+            {
+                title: 'Änderungen dieser Bedingungen',
+                blocks: [
+                    paragraph('Wir können diese Bedingungen mit 30 Tagen Vorlauf per E-Mail ändern. Kündigen Sie nicht, bevor die Änderung gilt, gilt von da an die neue Fassung.')
+                ]
+            },
+            {
+                title: 'Recht und Gerichtsstand',
+                blocks: [
+                    paragraph(`Es gilt Schweizer Recht unter Ausschluss des Übereinkommens der Vereinten Nationen über Verträge über den internationalen Warenkauf (Wiener Kaufrecht). Ausschliesslicher Gerichtsstand ist ${f.operator.jurisdiction}, Schweiz; wir dürfen Sie auch an Ihrem Sitz belangen.`)
+                ]
+            }
+        ];
+        return {
+            title: 'Allgemeine Geschäftsbedingungen',
+            blocks: [
+                version(f),
+                paragraph(`Diese Bedingungen gelten zwischen ${who(f)} («wir») und dem Unternehmen, das ${f.name} unter ${f.origin} nutzt, in der Web-App oder über die API («Sie»). Sie nehmen sie an, wenn Sie sich registrieren, auf der Website oder über die API, und nochmals, wenn Sie in Stripe Checkout bezahlen. Wer sich registriert, bestätigt, für ein Unternehmen zu handeln und es verpflichten zu dürfen.`),
+                ...numbered(sections)
+            ]
+        };
+    }
+};

package/dist/server/legal/document.d.ts

@@ -0,0 +1,37 @@
+import type { Language, ProductLegal } from '../../product.js';
+import type { LegalBlock, LegalData, LegalInline } from '../../ui/data.js';
+import type { Operator } from '../config.js';
+export interface LegalFacts {
+    language: Language;
+    name: string;
+    origin: string;
+    operator: Operator;
+    legal: ProductLegal;
+    /** The name of the terms, a day YYYY-MM-DD: the later of the days of baukasten and product. */
+    version: string;
+}
+export interface LegalPages {
+    imprint: LegalData;
+    privacy: LegalData;
+    terms: LegalData;
+}
+export type LegalTexts = {
+    [Page in keyof LegalPages]: (facts: LegalFacts) => LegalData;
+};
+export declare const strong: (text: string) => LegalInline;
+export declare const code: (text: string) => LegalInline;
+export declare const mail: (address: string) => LegalInline;
+export declare const link: (text: string, href: string) => LegalInline;
+export declare const heading: (text: string) => LegalBlock;
+export declare const paragraph: (...parts: LegalInline[]) => LegalBlock;
+export declare const note: (...parts: LegalInline[]) => LegalBlock;
+export declare const list: (...items: LegalInline[][]) => LegalBlock;
+export declare const lettered: (...items: LegalInline[][]) => LegalBlock;
+export interface Section {
+    title: string;
+    blocks: LegalBlock[];
+}
+/** The sections of the terms, numbered as they come: a section left out leaves no gap. */
+export declare function numbered(sections: readonly Section[]): LegalBlock[];
+/** A day YYYY-MM-DD as people of the language write it: 8 October 2026, 8. Oktober 2026. */
+export declare function longDate(day: string, language: Language): string;

package/dist/server/legal/document.js

@@ -0,0 +1,30 @@
+export const strong = (text) => ({ kind: 'strong', text });
+export const code = (text) => ({ kind: 'code', text });
+export const mail = (address) => ({
+    kind: 'link',
+    text: address,
+    href: `mailto:${address}`
+});
+export const link = (text, href) => ({ kind: 'link', text, href });
+export const heading = (text) => ({ kind: 'heading', text });
+export const paragraph = (...parts) => ({ kind: 'paragraph', parts });
+export const note = (...parts) => ({ kind: 'note', parts });
+export const list = (...items) => ({ kind: 'list', items });
+export const lettered = (...items) => ({ kind: 'lettered', items });
+/** The sections of the terms, numbered as they come: a section left out leaves no gap. */
+export function numbered(sections) {
+    return sections.flatMap((section, index) => [
+        heading(`${index + 1}. ${section.title}`),
+        ...section.blocks
+    ]);
+}
+/** A day YYYY-MM-DD as people of the language write it: 8 October 2026, 8. Oktober 2026. */
+export function longDate(day, language) {
+    const locale = { en: 'en-GB', de: 'de-CH' }[language];
+    return new Intl.DateTimeFormat(locale, {
+        day: 'numeric',
+        month: 'long',
+        year: 'numeric',
+        timeZone: 'UTC'
+    }).format(new Date(`${day}T00:00:00Z`));
+}

package/dist/server/legal/en.d.ts

@@ -0,0 +1,2 @@
+import { type LegalTexts } from './document.js';
+export declare const en: LegalTexts;