@tollwyn/baukasten 0.0.2 → 1.2.2

package/dist/check.js

@@ -0,0 +1,285 @@
+import { z } from 'zod';
+import { KEY_RIGHTS, WEBHOOK_EVENTS, WEBHOOK_PATH } from './server/stripe.js';
+import { APP_TOML, appTomlProblems } from './shopify/toml.js';
+import { SHOPIFY_STUBS, STUBS } from './stubs.js';
+const ANGABE_PATH = 'deploy/auslieferung.json';
+const STUBS_COMMAND = 'npx --no-install baukasten-stubs';
+const ANGABE = z.looseObject({
+    version: z.literal(2, 'must be 2, the version that names the art of the product'),
+    art: z.literal('webapp', 'must be webapp'),
+    stripe: z.looseObject({
+        webhook: z.discriminatedUnion('art', [
+            z.looseObject({ art: z.literal('keiner') }),
+            z.looseObject({
+                art: z.literal('endpunkt'),
+                pfad: z.string(),
+                ereignisse: z.array(z.string())
+            })
+        ], 'must be { art: endpunkt, pfad, ereignisse }'),
+        rechte: z.array(z.looseObject({ ressource: z.string(), zugriff: z.enum(['lesen', 'schreiben']) }))
+    })
+});
+/** The migration command of a Shopify app in its delivery manifest. */
+export const SHOPIFY_MIGRATION = [
+    'node',
+    'node_modules/@tollwyn/baukasten/dist/bin/migrate.js',
+    'shopify'
+];
+const SHOPIFY_ANGABE = z.looseObject({
+    version: z.literal(2, 'must be 2, the version that names the art of the product'),
+    art: z.literal('shopify'),
+    subdomain: z.string('must name the subdomain of the app'),
+    migration: z.array(z.string(), 'must give the migration command of the baukasten')
+});
+/** Words the review of the App Store refuses in an address of an app. */
+const REFUSED_IN_ADDRESS = ['shopify', 'example'];
+const ART = z.looseObject({ art: z.literal('shopify') });
+const PACKAGE = z.looseObject({ overrides: z.record(z.string(), z.unknown()).optional() });
+const PEER = z.looseObject({ version: z.string() });
+/**
+ * What the product builds with, checked like a peer: adapter-node 6 no longer reads ORIGIN, which the
+ * server of the baukasten sets from PUBLIC_ORIGIN. It is no peer, since only the build needs it, and
+ * npm keeps a peer of a dependency in the image.
+ */
+const BUILT_WITH = { '@sveltejs/adapter-node': '^5.0.0' };
+/**
+ * A reference to an account of a web app or a shop of a Shopify app: the one way a migration of the
+ * product names the schema baukasten.
+ */
+const REFERENCE = {
+    webapp: /\bREFERENCES\s+"?baukasten"?\s*\.\s*"?accounts"?(?![\w$])/gi,
+    shopify: /\bREFERENCES\s+"?baukasten"?\s*\.\s*"?shops"?(?![\w$])/gi
+};
+const REFERENCED = {
+    webapp: 'baukasten.accounts',
+    shopify: 'baukasten.shops'
+};
+const SQL_COMMENTS = /--[^\n]*|\/\*[\s\S]*?\*\//g;
+function json(text) {
+    try {
+        return { kind: 'json', value: JSON.parse(text) };
+    }
+    catch {
+        return { kind: 'broken' };
+    }
+}
+/** The art the manifest names: a Shopify app, or else a web app, whose manifest the check reads. */
+function artOf(files) {
+    const text = files.read(ANGABE_PATH);
+    const parsed = text === undefined ? null : json(text);
+    return parsed?.kind === 'json' && ART.safeParse(parsed.value).success ? 'shopify' : 'webapp';
+}
+const STUBS_OF = {
+    webapp: { stubs: STUBS, command: STUBS_COMMAND },
+    shopify: { stubs: SHOPIFY_STUBS, command: `${STUBS_COMMAND} shopify` }
+};
+function stubProblems(files, version, art) {
+    const { stubs, command } = STUBS_OF[art];
+    return Object.entries(stubs).flatMap(([path, content]) => {
+        const there = files.read(path);
+        if (there === undefined)
+            return [`${path} is missing: run ${command}`];
+        if (there !== content) {
+            return [`${path} is not the stub of version ${version}: run ${command}`];
+        }
+        return [];
+    });
+}
+function shopifyProblems(files) {
+    const text = files.read(ANGABE_PATH);
+    const parsed = text === undefined ? null : json(text);
+    if (parsed?.kind !== 'json')
+        throw new Error(`the art was read from ${ANGABE_PATH}, which is gone`);
+    const angabe = SHOPIFY_ANGABE.safeParse(parsed.value);
+    if (!angabe.success) {
+        return angabe.error.issues.map((issue) => `${ANGABE_PATH}: ${issue.path.join('.')} ${issue.message}`);
+    }
+    const { subdomain, migration } = angabe.data;
+    const problems = [];
+    if ('stripe' in angabe.data) {
+        problems.push(`${ANGABE_PATH}: a Shopify app has no stripe; Shopify bills it`);
+    }
+    if (JSON.stringify(migration) !== JSON.stringify(SHOPIFY_MIGRATION)) {
+        problems.push(`${ANGABE_PATH}: migration must be ${JSON.stringify(SHOPIFY_MIGRATION)}`);
+    }
+    for (const word of REFUSED_IN_ADDRESS.filter((w) => subdomain.includes(w))) {
+        problems.push(`${ANGABE_PATH}: the subdomain names ${word}, which the review of the App Store refuses in the address of an app`);
+    }
+    const toml = files.read(APP_TOML);
+    if (toml === undefined) {
+        problems.push(`${APP_TOML} is missing: ${STUBS_OF.shopify.command} writes a starting point`);
+    }
+    else {
+        problems.push(...appTomlProblems(toml, subdomain));
+    }
+    if (files.names('extensions').length > 0) {
+        problems.push('extensions/ holds extensions of Shopify, which this version does not serve');
+    }
+    return problems;
+}
+function angabeProblems(files) {
+    const text = files.read(ANGABE_PATH);
+    if (text === undefined)
+        return [`${ANGABE_PATH} is missing`];
+    const parsed = json(text);
+    if (parsed.kind === 'broken')
+        return [`${ANGABE_PATH} is no JSON`];
+    const angabe = ANGABE.safeParse(parsed.value);
+    if (!angabe.success) {
+        return angabe.error.issues.map((issue) => `${ANGABE_PATH}: ${issue.path.join('.')} ${issue.message}`);
+    }
+    const { webhook, rechte } = angabe.data.stripe;
+    const problems = [];
+    if (webhook.art === 'keiner') {
+        problems.push(`${ANGABE_PATH}: stripe.webhook is keiner; the baukasten needs its webhook at ${WEBHOOK_PATH}`);
+    }
+    else {
+        if (webhook.pfad !== WEBHOOK_PATH) {
+            problems.push(`${ANGABE_PATH}: stripe.webhook.pfad must be ${WEBHOOK_PATH}`);
+        }
+        const events = WEBHOOK_EVENTS;
+        for (const event of WEBHOOK_EVENTS.filter((e) => !webhook.ereignisse.includes(e))) {
+            problems.push(`${ANGABE_PATH}: stripe.webhook.ereignisse lacks ${event}`);
+        }
+        for (const event of webhook.ereignisse.filter((e) => !events.includes(e))) {
+            problems.push(`${ANGABE_PATH}: stripe.webhook.ereignisse names ${event}, which the baukasten does not apply`);
+        }
+    }
+    const rights = KEY_RIGHTS;
+    for (const right of rights) {
+        // Writing includes reading.
+        const granted = rechte.some((r) => r.ressource === right.ressource &&
+            (r.zugriff === 'schreiben' || r.zugriff === right.zugriff));
+        if (!granted) {
+            problems.push(`${ANGABE_PATH}: stripe.rechte lacks ${right.ressource} ${right.zugriff}, a right of the baukasten`);
+        }
+    }
+    return problems;
+}
+const numbers = (match) => [
+    Number(match[1]),
+    Number(match[2]),
+    Number(match[3])
+];
+/** Whether `version` lies in the caret range `range` from 1.0.0 on; a pre-release lies in none. */
+export function fits(version, range) {
+    const wanted = /^\^(\d+)\.(\d+)\.(\d+)$/.exec(range);
+    if (wanted === null || numbers(wanted)[0] === 0) {
+        throw new Error(`the peer range ${range} is no caret range from 1.0.0 on, as the check reads`);
+    }
+    const given = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+    if (given === null)
+        return false;
+    const [major, minor, patch] = numbers(given);
+    const [least, leastMinor, leastPatch] = numbers(wanted);
+    return major === least && (minor > leastMinor || (minor === leastMinor && patch >= leastPatch));
+}
+function versionProblems(files, baukasten) {
+    const wanted = { ...baukasten.peerDependencies, ...BUILT_WITH };
+    return Object.entries(wanted).flatMap(([name, range]) => {
+        const manifest = files.read(`node_modules/${name}/package.json`);
+        if (manifest === undefined)
+            return [`${name} is not installed; the baukasten needs ${range}`];
+        const parsed = json(manifest);
+        const peer = parsed.kind === 'json' ? PEER.safeParse(parsed.value) : null;
+        if (peer === null || !peer.success) {
+            return [`node_modules/${name}/package.json names no version`];
+        }
+        const { version } = peer.data;
+        return fits(version, range)
+            ? []
+            : [`${name} ${version} is installed; the baukasten needs ${range}`];
+    });
+}
+/** The name of a package in a key of `overrides`, like `pg`, `pg@^8` or `@scope/name@1`. */
+function packageName(key) {
+    const at = key.indexOf('@', 1);
+    return at < 0 ? key : key.slice(0, at);
+}
+/** Every package `overrides` names, at any depth; `.` stands for its parent. */
+function overridden(overrides) {
+    if (typeof overrides !== 'object' || overrides === null)
+        return [];
+    return Object.entries(overrides).flatMap(([key, value]) => [
+        ...(key === '.' ? [] : [packageName(key)]),
+        ...overridden(value)
+    ]);
+}
+function packageProblems(files, baukasten) {
+    const text = files.read('package.json');
+    if (text === undefined)
+        return ['package.json is missing'];
+    const parsed = json(text);
+    const manifest = parsed.kind === 'json' ? PACKAGE.safeParse(parsed.value) : null;
+    if (manifest === null || !manifest.success) {
+        return ['package.json is no JSON object, or its overrides are no object'];
+    }
+    const own = new Set([
+        baukasten.name,
+        ...Object.keys(baukasten.dependencies),
+        ...Object.keys(baukasten.peerDependencies)
+    ]);
+    const names = [...new Set(overridden(manifest.data.overrides))].filter((name) => own.has(name));
+    return names.map((name) => `package.json overrides ${name}, which the baukasten brings itself; remove it`);
+}
+function migrationProblems(files, art) {
+    // Like the migration: every entry read, a folder failing loudly, then the .sql files.
+    return files
+        .names('migrations')
+        .map((name) => {
+        const path = `migrations/${name}`;
+        const sql = files.read(path);
+        if (sql === undefined)
+            throw new Error(`${path} was listed, yet is gone`);
+        return { name, path, sql };
+    })
+        .filter(({ name }) => name.endsWith('.sql'))
+        .flatMap(({ path, sql }) => {
+        const rest = sql.replace(SQL_COMMENTS, '').replace(REFERENCE[art], '');
+        return /\bbaukasten\b/i.test(rest)
+            ? [
+                `${path} names the schema baukasten beyond a reference to ${REFERENCED[art]}: the product never changes the tables of the baukasten`
+            ]
+            : [];
+    });
+}
+/** Read from the text of vite.config.ts only; the handle guards the policy at run time. */
+const OPTIONS = {
+    webapp: {
+        name: 'SVELTEKIT_OPTIONS',
+        passes: /\bsveltekit\(\s*\{[\s\S]*?\.\.\.SVELTEKIT_OPTIONS\b/,
+        imports: /import\s*\{[^}]*\bSVELTEKIT_OPTIONS\b[^}]*\}\s*from\s*['"]@tollwyn\/baukasten['"]/
+    },
+    shopify: {
+        name: 'SHOPIFY_SVELTEKIT_OPTIONS',
+        passes: /\bsveltekit\(\s*\{[\s\S]*?\.\.\.SHOPIFY_SVELTEKIT_OPTIONS\b/,
+        imports: /import\s*\{[^}]*\bSHOPIFY_SVELTEKIT_OPTIONS\b[^}]*\}\s*from\s*['"]@tollwyn\/baukasten['"]/
+    }
+};
+function configurationProblems(files, art) {
+    const problems = [];
+    if (files.read('baukasten.config.ts') === undefined) {
+        problems.push(`baukasten.config.ts is missing: the configuration of the product (${STUBS_OF[art].command} writes a starting point)`);
+    }
+    const vite = files.read('vite.config.ts');
+    const options = OPTIONS[art];
+    if (vite === undefined) {
+        problems.push('vite.config.ts is missing');
+    }
+    else if (!options.imports.test(vite) || !options.passes.test(vite)) {
+        problems.push(`vite.config.ts does not pass ${options.name} of @tollwyn/baukasten to sveltekit(): sveltekit({ ...${options.name}, adapter: adapter() })`);
+    }
+    return problems;
+}
+/** What keeps the product from fitting the installed baukasten; empty when it fits. */
+export function productProblems(files, baukasten) {
+    const art = artOf(files);
+    return [
+        ...stubProblems(files, baukasten.version, art),
+        ...(art === 'shopify' ? shopifyProblems(files) : angabeProblems(files)),
+        ...versionProblems(files, baukasten),
+        ...packageProblems(files, baukasten),
+        ...migrationProblems(files, art),
+        ...configurationProblems(files, art)
+    ];
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { z } from 'zod';
+export { defineProduct, LANGUAGES, type Brand, type Catalog, type CatalogProduct, type Language, type NavigationLink, type Product, type ProductEnv, type ProductLegal, type PurchasePrice, type SubscriptionPrice } from './product.js';
+export { defineShopifyApp, type ShopifyApp, type ShopifyPlan, type ShopifyPrivacy } from './shopify/app.js';
+export { SHOPIFY_SVELTEKIT_OPTIONS } from './shopify/sveltekit.js';
+export { SVELTEKIT_OPTIONS } from './sveltekit.js';
+export { TEXTS, type Linked, type Texts } from './texts.js';
+export { BAUKASTEN_VARIABLES, SHOPIFY_STANDARD_VARIABLES, SHOPIFY_VARIABLES, STANDARD_VARIABLES, WEBAPP_VARIABLES, type ShopifyStandardVariable, type StandardVariable } from './variables.js';

package/dist/index.js

@@ -0,0 +1,9 @@
+// The entry a product may import anywhere, in the browser too: nothing here touches the server. The
+// schema of the product's variables takes the Zod of the baukasten from here.
+export { z } from 'zod';
+export { defineProduct, LANGUAGES } from './product.js';
+export { defineShopifyApp } from './shopify/app.js';
+export { SHOPIFY_SVELTEKIT_OPTIONS } from './shopify/sveltekit.js';
+export { SVELTEKIT_OPTIONS } from './sveltekit.js';
+export { TEXTS } from './texts.js';
+export { BAUKASTEN_VARIABLES, SHOPIFY_STANDARD_VARIABLES, SHOPIFY_VARIABLES, STANDARD_VARIABLES, WEBAPP_VARIABLES } from './variables.js';

package/dist/product.d.ts

@@ -0,0 +1,161 @@
+import { z } from 'zod';
+export declare const LANGUAGES: readonly ["en", "de"];
+export type Language = (typeof LANGUAGES)[number];
+/** The schema of each variable of the product, by its name; it gets the trimmed text or undefined. */
+export type ProductEnv = Record<string, z.ZodType>;
+/** A link in the head of every page, to a path of the product. */
+export interface NavigationLink {
+    href: string;
+    label: string;
+}
+/** The grounds on which a product may process personal data, as the privacy policy names them. */
+export declare const LEGAL_BASES: readonly ["contract", "legitimateInterest"];
+export type LegalBasis = (typeof LEGAL_BASES)[number];
+/**
+ * What covers personal data that go to a recipient: a country with adequate protection (only
+ * Switzerland, the EEA and the countries in Annex 1 of the Swiss Data Protection Ordinance, DSV), the
+ * recipient's certification under the Data Privacy Framework, or the EU standard contractual clauses.
+ */
+export declare const TRANSFERS: readonly ["adequate", "dpf", "scc"];
+export type Transfer = (typeof TRANSFERS)[number];
+/** Whether a recipient processes the data for the operator, or as a controller of its own. */
+export declare const ROLES: readonly ["processor", "controller"];
+export type Role = (typeof ROLES)[number];
+/**
+ * What the legal pages say of the product, in its language, and true. The sentences are whole, each
+ * ending with a full stop; the parts of a sentence have none at their end.
+ */
+export interface ProductLegal {
+    /** What the product does for its customers, in whole sentences: the terms, «The service». */
+    service: string;
+    /** What it does not guarantee, besides being always available, in whole sentences. */
+    notGuaranteed: string;
+    /** What customers may do with it and what not, in whole sentences: the terms, «Use». */
+    use: string;
+    /** The personal data it keeps itself, besides the accounts, payments and logs of the baukasten. */
+    data: readonly {
+        /** A short name, like «Notes». */
+        name: string;
+        /** What they are, like «the texts you add, with the time you added them». */
+        what: string;
+        /** Where they come from, when not from the customer, like «the official gazette». */
+        source?: string;
+        /**
+         * Why, like «to keep them for you and show them to you and your API keys». On legitimate
+         * interest it names the interest.
+         */
+        purpose: string;
+        basis: LegalBasis;
+        /** How long, like «until you delete your account; then they are deleted at once». */
+        kept: string;
+    }[];
+    /** Who gets personal data from it besides the providers of the fleet. */
+    recipients: readonly {
+        /** Like «the official gazettes portal of the Swiss Confederation». */
+        name: string;
+        /** The country, like «Switzerland». */
+        place: string;
+        transfer: Transfer;
+        /** A processor is one of the sub-processors the terms have the customer approve. */
+        role: Role;
+        /** What it gets and why, like «gets the UIDs on your list, without who watches them, …». */
+        purpose: string;
+    }[];
+    /**
+     * Whether the operator processes personal data on behalf of the customers, as their processor:
+     * then the terms carry the clauses for it. `data` ends «For personal data …», like «in your
+     * notes»; `subjects` ends «which concern …», like «the people you write about»; `retrieve` ends
+     * «you can read or export them through …», like «the notes page and the API».
+     */
+    processor: {
+        kind: 'no';
+    } | {
+        kind: 'yes';
+        data: string;
+        subjects: string;
+        retrieve: string;
+    };
+}
+/** A price of a subscription: an amount in the smallest unit of the currency, per month or year. */
+export interface SubscriptionPrice {
+    /** The price at Stripe has this lookup key; a new amount becomes a new price under the same key. */
+    lookupKey: string;
+    amount: number;
+    interval: 'month' | 'year';
+}
+/** A price paid once, in the smallest unit of the currency. */
+export interface PurchasePrice {
+    lookupKey: string;
+    amount: number;
+}
+/** A product at Stripe, under its fixed id in every mode: sold as a subscription, or once. */
+export type CatalogProduct = {
+    kind: 'subscription';
+    id: string;
+    name: string;
+    prices: readonly SubscriptionPrice[];
+    /** A subscription of this product counts a quantity from 1 to `max`, like seats. */
+    quantity?: {
+        max: number;
+    };
+} | {
+    kind: 'purchase';
+    id: string;
+    name: string;
+    prices: readonly PurchasePrice[];
+};
+/** What the product sells at Stripe; the migration sets it up there. */
+export interface Catalog {
+    /** The currency of every price, like CHF; the sales numbers count revenue in it alone. */
+    currency: string;
+    products: readonly CatalogProduct[];
+}
+export interface Product<E extends ProductEnv = ProductEnv> {
+    /** Every page, mail, error message and legal text of the baukasten comes in this language. */
+    language: Language;
+    env: E;
+    /** The navigation of the product in the head of every page, in its language. */
+    navigation: readonly NavigationLink[];
+    accounts: {
+        /** Where sign-up, login and a new password lead: a path of the product. */
+        home: string;
+        /** API keys start with it and an underscore, like `mu_…`: 2 to 8 small letters. */
+        keyPrefix: string;
+        /** The heading and the lead of the sign-up page, in the language of the product. */
+        signup: {
+            heading: string;
+            lead: string;
+        };
+    };
+    /**
+     * The day the product's part of its legal texts (`legal`) last changed, as YYYY-MM-DD. The terms
+     * an account accepts are named by the later of this day and that of the baukasten's part.
+     */
+    termsDate: string;
+    legal: ProductLegal;
+    catalog: Catalog;
+    /** The marks of the product; without them the frame shows its name as text. */
+    brand?: Brand;
+}
+/**
+ * The marks of a product, files of its own under `static/`, named by their path on its origin. The
+ * frame shows the logo in the head of every page, with the name of the product as its text, and every
+ * page names the icon and the picture of a shared link.
+ */
+export interface Brand {
+    /** Sign and name as one SVG, with its size in pixels; the head shows it at most 40 pixels high. */
+    logo: {
+        src: string;
+        width: number;
+        height: number;
+    };
+    /** The icon of the tab: an SVG or a PNG. */
+    icon: string;
+    /** The picture of a shared link (`og:image`): a PNG of 1200 × 630 pixels. */
+    image: string;
+    /** The theme on `<html data-theme>`, as Skeleton names its themes; without it, none. */
+    theme?: string;
+}
+export declare function isProduct(value: unknown): value is Product;
+/** Declares the configuration of the product; anything wrong with it stops the product loudly. */
+export declare function defineProduct<const E extends ProductEnv>(product: Product<E>): Product<E>;

package/dist/product.js

@@ -0,0 +1,152 @@
+import { z } from 'zod';
+import { BAUKASTEN_VARIABLES } from './variables.js';
+export const LANGUAGES = ['en', 'de'];
+/** The grounds on which a product may process personal data, as the privacy policy names them. */
+export const LEGAL_BASES = ['contract', 'legitimateInterest'];
+/**
+ * What covers personal data that go to a recipient: a country with adequate protection (only
+ * Switzerland, the EEA and the countries in Annex 1 of the Swiss Data Protection Ordinance, DSV), the
+ * recipient's certification under the Data Privacy Framework, or the EU standard contractual clauses.
+ */
+export const TRANSFERS = ['adequate', 'dpf', 'scc'];
+/** Whether a recipient processes the data for the operator, or as a controller of its own. */
+export const ROLES = ['processor', 'controller'];
+const NAME = /^[A-Z][A-Z0-9_]*$/;
+const OWN = new Set(BAUKASTEN_VARIABLES);
+const ownPath = z
+    .string()
+    .regex(/^\/(?!\/)[^\s\\]*$/, 'must be a path of the product, like /notes');
+const text = z
+    .string('must not be empty')
+    .trim()
+    .min(1, { error: 'must not be empty', abort: true });
+const sentences = text.regex(/[.!?]$/, 'must be whole sentences, ending with a full stop');
+const part = text.regex(/[^.!?;:,]$/, 'must be part of a sentence, without a full stop at the end');
+const LEGAL = z.object({
+    service: sentences,
+    notGuaranteed: sentences,
+    use: sentences,
+    data: z.array(z.object({
+        name: part,
+        what: part,
+        source: part.optional(),
+        purpose: part,
+        basis: z.enum(LEGAL_BASES, 'must be contract or legitimateInterest'),
+        kept: part
+    })),
+    recipients: z.array(z.object({
+        name: part,
+        place: part,
+        transfer: z.enum(TRANSFERS, 'must be adequate, dpf or scc'),
+        role: z.enum(ROLES, 'must be processor or controller'),
+        purpose: part
+    })),
+    processor: z.discriminatedUnion('kind', [
+        z.object({ kind: z.literal('no') }),
+        z.object({ kind: z.literal('yes'), data: part, subjects: part, retrieve: part })
+    ], 'must be { kind: no } or { kind: yes, data, subjects, retrieve }')
+}, 'must be given');
+const staticFile = (...endings) => z
+    .string()
+    .regex(new RegExp(`^/[a-z0-9][a-z0-9._/-]*\\.(${endings.join('|')})$`), `must be the path of a file under static/ ending in .${endings.join(' or .')}, like /name.${endings[0]}`)
+    .refine((path) => !path.includes('..') && !path.includes('//'), 'must not leave static/');
+const pixels = z.int('must be a whole number of pixels').positive('must be more than nothing');
+const BRAND = z.object({
+    logo: z.object({ src: staticFile('svg'), width: pixels, height: pixels }),
+    icon: staticFile('svg', 'png'),
+    image: staticFile('png'),
+    theme: z
+        .string()
+        .regex(/^[a-z][a-z0-9-]*$/, 'must be the name of a theme, like cerberus')
+        .optional()
+});
+/** An id or a lookup key at Stripe, the same in every mode. */
+const stripeKey = z
+    .string()
+    .regex(/^[a-z][a-z0-9_]{2,63}$/, 'must be 3 to 64 small letters, digits and _, first a letter');
+const amount = z
+    .int('must be a whole amount in the smallest unit of the currency')
+    .positive('must be more than nothing');
+const CATALOG = z
+    .object({
+    currency: z.string().regex(/^[A-Z]{3}$/, 'must be a currency code like CHF'),
+    products: z
+        .array(z.discriminatedUnion('kind', [
+        z.object({
+            kind: z.literal('subscription'),
+            id: stripeKey,
+            name: text,
+            prices: z
+                .array(z.object({
+                lookupKey: stripeKey,
+                amount,
+                interval: z.enum(['month', 'year'], 'must be month or year')
+            }))
+                .min(1, 'must name a price'),
+            quantity: z
+                .object({ max: z.int().min(2, 'must be 2 or more').max(10_000, 'is too large') })
+                .optional()
+        }),
+        z.object({
+            kind: z.literal('purchase'),
+            id: stripeKey,
+            name: text,
+            prices: z
+                .array(z.object({ lookupKey: stripeKey, amount }))
+                .min(1, 'must name a price')
+        })
+    ], 'must be a subscription or a purchase'))
+        .min(1, 'must name a product')
+})
+    .superRefine((catalog, ctx) => {
+    const twice = (names) => names.filter((name, i) => names.indexOf(name) !== i);
+    for (const id of twice(catalog.products.map((p) => p.id))) {
+        ctx.addIssue({ code: 'custom', path: ['products'], message: `names the id ${id} twice` });
+    }
+    const keys = catalog.products.flatMap((p) => p.prices.map((price) => price.lookupKey));
+    for (const key of twice(keys)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['products'],
+            message: `names the lookup key ${key} twice`
+        });
+    }
+});
+const SETTINGS = z.object({
+    language: z.enum(LANGUAGES, 'must be en or de'),
+    navigation: z.array(z.object({ href: ownPath, label: text })),
+    accounts: z.object({
+        home: ownPath,
+        keyPrefix: z.string().regex(/^[a-z]{2,8}$/, 'must be 2 to 8 small letters'),
+        signup: z.object({ heading: text, lead: text })
+    }),
+    termsDate: z.iso.date('must be a day like 2026-10-08'),
+    legal: LEGAL,
+    catalog: CATALOG,
+    brand: BRAND.optional()
+});
+/** What defineProduct accepted; the migration command finds the product by it. */
+const DEFINED = new WeakSet();
+export function isProduct(value) {
+    return typeof value === 'object' && value !== null && DEFINED.has(value);
+}
+/** Declares the configuration of the product; anything wrong with it stops the product loudly. */
+export function defineProduct(product) {
+    const names = Object.keys(product.env);
+    const problems = [];
+    const taken = names.filter((name) => OWN.has(name));
+    if (taken.length > 0) {
+        problems.push(`variables ${taken.join(', ')} ${taken.length === 1 ? 'is' : 'are'} read by the baukasten itself`);
+    }
+    const malformed = names.filter((name) => !NAME.test(name));
+    if (malformed.length > 0)
+        problems.push(`variables ${malformed.join(', ')} must look like NAME_IN_CAPITALS`);
+    const settings = SETTINGS.safeParse(product);
+    if (!settings.success) {
+        problems.push(...settings.error.issues.map((issue) => `${issue.path.join('.')} ${issue.message}`));
+    }
+    if (problems.length > 0)
+        throw new Error(`the product: ${problems.join('; ')}`);
+    DEFINED.add(product);
+    return product;
+}