@tollwyn/baukasten 1.2.3 → 1.3.1

package/dist/server/catalog.js

@@ -1,6 +1,6 @@
 import { WEBHOOK_PATH } from './stripe.js';
 export function pricesOf(catalog) {
-    const currency = catalog.currency.toLowerCase();
+    const { currency } = catalog;
     return catalog.products.flatMap((product) => {
         switch (product.kind) {
             case 'subscription':
@@ -41,9 +41,10 @@ export function priceFits(found, wanted) {
 }
 /**
  * The default configuration of the customer portal names the product and links its own pages: an
- * account copied from another one brings that one's along.
+ * account copied from another one brings that one's along. `ids` holds the price at Stripe of each
+ * lookup key that has one; null while a price the portal offers has none yet.
  */
-export function portalConfiguration(catalog, shop, priceId) {
+export function portalConfiguration(catalog, shop, ids) {
     const subscriptions = catalog.products.flatMap((product) => product.kind === 'subscription' ? [product] : []);
     const prices = subscriptions.reduce((count, product) => count + product.prices.length, 0);
     const allowed = [
@@ -52,6 +53,25 @@ export function portalConfiguration(catalog, shop, priceId) {
             ? ['quantity']
             : [])
     ];
+    const products = [];
+    if (allowed.length > 0) {
+        for (const product of subscriptions) {
+            const offered = [];
+            for (const price of product.prices) {
+                const id = ids.get(price.lookupKey);
+                if (id === undefined)
+                    return null;
+                offered.push(id);
+            }
+            products.push({
+                product: product.id,
+                prices: offered,
+                adjustable_quantity: product.quantity === undefined
+                    ? { enabled: false }
+                    : { enabled: true, minimum: 1, maximum: product.quantity.max }
+            });
+        }
+    }
     return {
         business_profile: {
             headline: shop.name,
@@ -70,13 +90,7 @@ export function portalConfiguration(catalog, shop, priceId) {
                     enabled: true,
                     default_allowed_updates: allowed,
                     proration_behavior: 'create_prorations',
-                    products: subscriptions.map((product) => ({
-                        product: product.id,
-                        prices: product.prices.map((price) => priceId(price.lookupKey)),
-                        adjustable_quantity: product.quantity === undefined
-                            ? { enabled: false }
-                            : { enabled: true, minimum: 1, maximum: product.quantity.max }
-                    }))
+                    products
                 }
         }
     };
@@ -105,80 +119,85 @@ export function contains(found, wanted) {
 }
 /** Only the Dashboard creates the default configuration of the customer portal. */
 export const NO_DEFAULT_PORTAL = 'the Stripe account has no default configuration of the customer portal in this mode: save the settings of the customer portal once in the Stripe Dashboard, then migrate again';
-export async function setUpCatalog(stripe, catalog, shop) {
-    const steps = [];
-    for (const product of catalog.products) {
-        const found = await stripe.product(product.id);
-        const wanted = { id: product.id, name: product.name };
-        if (found === null) {
-            await stripe.createProduct(wanted);
-            steps.push({ subject: 'product', id: product.id, action: 'created' });
-        }
-        else if (!found.active || found.name !== product.name) {
-            await stripe.updateProduct(wanted);
-            steps.push({ subject: 'product', id: product.id, action: 'updated' });
-        }
-        else {
-            steps.push({ subject: 'product', id: product.id, action: 'exists' });
-        }
-    }
-    const ids = new Map();
-    for (const wanted of pricesOf(catalog)) {
-        const found = await stripe.activePrice(wanted.lookupKey);
-        if (found !== null && priceFits(found, wanted)) {
-            ids.set(wanted.lookupKey, found.id);
-            steps.push({ subject: 'price', id: wanted.lookupKey, action: 'exists' });
-        }
-        else {
-            ids.set(wanted.lookupKey, await stripe.createPrice(wanted));
-            steps.push({
-                subject: 'price',
-                id: wanted.lookupKey,
-                action: found === null ? 'created' : 'updated'
-            });
-        }
-    }
-    const portal = await stripe.defaultPortal();
-    if (portal === null)
-        throw new Error(NO_DEFAULT_PORTAL);
-    const wanted = portalConfiguration(catalog, shop, (key) => {
-        const id = ids.get(key);
-        if (id === undefined)
-            throw new Error(`the price ${key} was not set up`);
-        return id;
-    });
-    if (contains(portal.configuration, wanted)) {
-        steps.push({ subject: 'portal', id: portal.id, action: 'exists' });
-    }
-    else {
-        await stripe.updatePortal(portal.id, wanted);
-        steps.push({ subject: 'portal', id: portal.id, action: 'updated' });
-    }
-    return steps;
-}
-/** What the migration would change at Stripe, as `product <id>`, `price <key>` or `portal`. */
-export async function catalogDifferences(stripe, catalog, shop) {
+/**
+ * The catalog compared with Stripe: products first, then prices, then the portal, which offers the
+ * prices. A price still to be made changes a portal that offers it: its new id is in no
+ * configuration yet.
+ */
+export async function catalogPlan(stripe, catalog, shop) {
     const [products, prices, portal] = await Promise.all([
         Promise.all(catalog.products.map(async (product) => [product, await stripe.product(product.id)])),
         Promise.all(pricesOf(catalog).map(async (price) => [price, await stripe.activePrice(price.lookupKey)])),
         stripe.defaultPortal()
     ]);
-    const differences = [
-        ...products.flatMap(([product, found]) => found !== null && found.active && found.name === product.name ? [] : [`product ${product.id}`]),
-        ...prices.flatMap(([wanted, found]) => found !== null && priceFits(found, wanted) ? [] : [`price ${wanted.lookupKey}`])
-    ];
-    // With a price missing, the portal would point at a price the migration has yet to create.
-    if (differences.some((difference) => difference.startsWith('price ')))
-        return differences;
-    const ids = new Map(prices.flatMap(([wanted, found]) => found === null ? [] : [[wanted.lookupKey, found.id]]));
-    const fits = portal !== null &&
-        contains(portal.configuration, portalConfiguration(catalog, shop, (key) => {
-            const id = ids.get(key);
-            if (id === undefined)
-                throw new Error(`the price ${key} is not at Stripe`);
-            return id;
-        }));
-    return fits ? differences : [...differences, 'portal'];
+    const productSteps = products.map(([product, found]) => ({
+        subject: 'product',
+        id: product.id,
+        name: product.name,
+        kind: found === null ? 'create' : !found.active || found.name !== product.name ? 'update' : 'exists'
+    }));
+    const priceSteps = prices.map(([price, found]) => {
+        const step = { subject: 'price', id: price.lookupKey, price };
+        if (found === null)
+            return { ...step, kind: 'create' };
+        return priceFits(found, price)
+            ? { ...step, kind: 'exists', stripeId: found.id }
+            : { ...step, kind: 'update' };
+    });
+    const ids = new Map(priceSteps.flatMap((step) => step.kind === 'exists' ? [[step.id, step.stripeId]] : []));
+    const wanted = portalConfiguration(catalog, shop, ids);
+    const portalStep = portal === null
+        ? { subject: 'portal', id: null, kind: 'missing' }
+        : {
+            subject: 'portal',
+            id: portal.id,
+            kind: wanted !== null && contains(portal.configuration, wanted) ? 'exists' : 'update'
+        };
+    return [...productSteps, ...priceSteps, portalStep];
+}
+/** What the migration would change at Stripe, as `product <id>`, `price <key>` or `portal`. */
+export function catalogChanges(plan) {
+    return plan.flatMap((step) => {
+        if (step.kind === 'exists')
+            return [];
+        return [step.subject === 'portal' ? 'portal' : `${step.subject} ${step.id}`];
+    });
+}
+const DONE = { create: 'created', update: 'updated', exists: 'exists' };
+/** Carries the plan out: a second run finds everything as it exists and changes nothing. */
+export async function setUpCatalog(stripe, catalog, shop) {
+    const done = [];
+    const ids = new Map();
+    for (const step of await catalogPlan(stripe, catalog, shop)) {
+        switch (step.subject) {
+            case 'product': {
+                const product = { id: step.id, name: step.name };
+                if (step.kind === 'create')
+                    await stripe.createProduct(product);
+                if (step.kind === 'update')
+                    await stripe.updateProduct(product);
+                done.push({ subject: 'product', id: step.id, action: DONE[step.kind] });
+                break;
+            }
+            case 'price':
+                ids.set(step.id, step.kind === 'exists' ? step.stripeId : await stripe.createPrice(step.price));
+                done.push({ subject: 'price', id: step.id, action: DONE[step.kind] });
+                break;
+            case 'portal': {
+                if (step.kind === 'missing')
+                    throw new Error(NO_DEFAULT_PORTAL);
+                if (step.kind === 'update') {
+                    const wanted = portalConfiguration(catalog, shop, ids);
+                    if (wanted === null)
+                        throw new Error('a price of the portal was not set up');
+                    await stripe.updatePortal(step.id, wanted);
+                }
+                done.push({ subject: 'portal', id: step.id, action: DONE[step.kind] });
+                break;
+            }
+        }
+    }
+    return done;
 }
 /**
  * The enabled webhook endpoints of the Stripe account that are not this product's: an account copied

package/dist/server/config.d.ts

@@ -85,17 +85,60 @@ export declare const SHAPE: {
     OPERATOR_REGISTER: z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodString]>;
     OPERATOR_VAT: z.ZodLiteral<"none">;
     OPERATOR_JURISDICTION: z.ZodString;
-    HOSTING_LOCATION: z.ZodString;
     STRIPE_SECRET_KEY: z.ZodString;
     STRIPE_WEBHOOK_SECRET: z.ZodString;
     VERTRIEB_TOKEN: z.ZodString;
 };
 /** What a value must be; the problem never repeats the value, which may be a secret. */
 export declare const MUST: Record<StandardVariable, string>;
-export declare const DEFAULT_PORT = 3000;
-type Input = Record<string, string | undefined>;
-/** One problem per variable, in the order of `names`: missing, or what its value must be. */
-export declare function problemsOf<N extends string>(issues: readonly z.core.$ZodIssue[], names: readonly N[], input: Input, invalid: (name: N, issue: z.core.$ZodIssue) => string): string[];
+/** What the standard variables of both arts share, as the schema of either mode reads them. */
+interface Shared {
+    PUBLIC_ORIGIN: string;
+    PORT?: number | undefined;
+    DATABASE_URL: string;
+    SMTP_HOST?: string | undefined;
+    SMTP_PORT?: number | undefined;
+    MAIL_FROM?: string | undefined;
+    MAIL_FROM_NAME: string;
+    VERTRIEB_TOKEN: string;
+}
+/** The part of the configuration that both arts read alike. */
+type SharedConfig<N extends string, E extends ProductEnv> = Pick<Config<E>, 'mode' | 'publicOrigin' | 'port' | 'databaseUrl' | 'name' | 'mail' | 'salesToken' | 'product'> & {
+    missing: readonly N[];
+};
+type Read<T> = {
+    kind: 'ok';
+    value: T;
+} | {
+    kind: 'problems';
+    problems: string[];
+};
+/**
+ * Reads the standard variables `names` of an art with the schema of its mode, the variables of the
+ * product and the address of the double of the tests, and names every problem at once. Locally
+ * each of `groups` is set in full or not at all, and what is unset of them runs without.
+ */
+export declare function readVariables<N extends string, L extends z.ZodType<Shared>, E extends ProductEnv>(env: Env, spec: {
+    names: readonly N[];
+    production: z.ZodType<z.output<L>>;
+    local: L;
+    /** What the value of each must be; a problem never repeats the value, which may be a secret. */
+    must: Record<N, string>;
+    groups: readonly {
+        label: string;
+        names: readonly N[];
+    }[];
+    /** The variable of the double, which takes the keys, and what is wrong with it elsewhere. */
+    double: {
+        name: string;
+        problem: string;
+    };
+    product: E;
+}): Read<{
+    config: SharedConfig<N, E>;
+    data: z.output<L>;
+    double: string | null;
+}>;
 /** A variable that is empty or blank counts as missing. */
 export declare function valueOf(env: Env, name: string): string | undefined;
 /** The port of the server by the rule of loadConfig, which has checked it before the server listens. */

package/dist/server/config.js

@@ -43,18 +43,15 @@ export const SHAPE = {
     OPERATOR_REGISTER: z.union([z.literal(NONE), z.string().refine(isUid)]),
     OPERATOR_VAT: z.literal(NONE),
     OPERATOR_JURISDICTION: text,
-    // Required like every standard variable, yet unread: the legal pages name the server of the
-    // fleet (legal/fleet.ts).
-    HOSTING_LOCATION: text,
     STRIPE_SECRET_KEY: z.string().regex(/^(?:sk|rk)_(?:test|live)_[A-Za-z0-9]+$/),
     STRIPE_WEBHOOK_SECRET: z.string().regex(/^whsec_[A-Za-z0-9]+$/),
     VERTRIEB_TOKEN: z.string().min(32)
 };
 /**
- * The Stripe double of the tests, which takes the key and moves no money: only on this machine, so
- * that no setting sends the key anywhere else.
+ * A double of the tests, which takes the keys and moves no money: only on this machine, so that no
+ * setting sends a key anywhere else.
  */
-const STRIPE_API_BASE = z
+const ON_THIS_MACHINE = z
     .url({ protocol: /^http$/, hostname: /^(?:127\.0\.0\.1|localhost|\[::1\])$/ })
     .transform((value) => new URL(value).origin);
 /** What a value must be; the problem never repeats the value, which may be a secret. */
@@ -71,12 +68,11 @@ export const MUST = {
     OPERATOR_REGISTER: 'none or the company identification number of the entry with its check digit, like CHE-123.456.788',
     OPERATOR_VAT: 'none: with a VAT number the product would have to charge VAT through Stripe Tax, which this version of the baukasten does not support',
     OPERATOR_JURISDICTION: 'a place in Switzerland',
-    HOSTING_LOCATION: 'a place',
     STRIPE_SECRET_KEY: 'a secret or restricted key of Stripe (sk_ or rk_, then test_ or live_)',
     STRIPE_WEBHOOK_SECRET: 'a signing secret of Stripe (whsec_)',
     VERTRIEB_TOKEN: 'at least 32 characters'
 };
-export const DEFAULT_PORT = 3000;
+const DEFAULT_PORT = 3000;
 const MAIL = ['SMTP_HOST', 'SMTP_PORT', 'MAIL_FROM'];
 const STRIPE = ['STRIPE_SECRET_KEY', 'STRIPE_WEBHOOK_SECRET'];
 const PRODUCTION = z.object(SHAPE);
@@ -90,7 +86,7 @@ const LOCAL = z.object({
     STRIPE_WEBHOOK_SECRET: SHAPE.STRIPE_WEBHOOK_SECRET.optional()
 });
 /** One problem per variable, in the order of `names`: missing, or what its value must be. */
-export function problemsOf(issues, names, input, invalid) {
+function problemsOf(issues, names, input, invalid) {
     const first = new Map();
     for (const issue of issues) {
         const name = names.find((n) => n === issue.path[0]);
@@ -107,57 +103,6 @@ export function problemsOf(issues, names, input, invalid) {
         return [input[name] === undefined ? `${name} is missing` : invalid(name, issue)];
     });
 }
-function read(schema, input, build) {
-    const result = schema.safeParse(input);
-    if (result.success)
-        return { kind: 'ok', value: build(result.data) };
-    return {
-        kind: 'problems',
-        problems: problemsOf(result.error.issues, STANDARD_VARIABLES, input, (name) => `${name} must be ${MUST[name]}`)
-    };
-}
-function common(data, rest) {
-    return {
-        publicOrigin: data.PUBLIC_ORIGIN,
-        databaseUrl: data.DATABASE_URL,
-        name: data.MAIL_FROM_NAME,
-        operator: {
-            name: data.OPERATOR_NAME,
-            address: data.OPERATOR_ADDRESS,
-            register: data.OPERATOR_REGISTER === NONE
-                ? { kind: 'none' }
-                : { kind: 'entered', uid: data.OPERATOR_REGISTER },
-            vat: data.OPERATOR_VAT,
-            jurisdiction: data.OPERATOR_JURISDICTION
-        },
-        salesToken: data.VERTRIEB_TOKEN,
-        ...rest
-    };
-}
-function production(data) {
-    return common(data, {
-        port: data.PORT,
-        mail: { kind: 'smtp', host: data.SMTP_HOST, port: data.SMTP_PORT, from: data.MAIL_FROM },
-        stripe: {
-            kind: 'stripe',
-            secretKey: data.STRIPE_SECRET_KEY,
-            webhookSecret: data.STRIPE_WEBHOOK_SECRET
-        }
-    });
-}
-function local(data) {
-    const { SMTP_HOST: host, SMTP_PORT: port, MAIL_FROM: from } = data;
-    const { STRIPE_SECRET_KEY: secretKey, STRIPE_WEBHOOK_SECRET: webhookSecret } = data;
-    return common(data, {
-        port: data.PORT ?? DEFAULT_PORT,
-        mail: host !== undefined && port !== undefined && from !== undefined
-            ? { kind: 'smtp', host, port, from }
-            : { kind: 'log' },
-        stripe: secretKey !== undefined && webhookSecret !== undefined
-            ? { kind: 'stripe', secretKey, webhookSecret }
-            : { kind: 'none' }
-    });
-}
 /** "A, B and C" */
 function list(names) {
     return names.length < 2 ? names.join('') : `${names.slice(0, -1).join(', ')} and ${names.at(-1)}`;
@@ -171,6 +116,57 @@ function partly(label, names, input) {
         `${label} is set only in part: ${list(absent)} ${absent.length === 1 ? 'is' : 'are'} missing`
     ];
 }
+/**
+ * Reads the standard variables `names` of an art with the schema of its mode, the variables of the
+ * product and the address of the double of the tests, and names every problem at once. Locally
+ * each of `groups` is set in full or not at all, and what is unset of them runs without.
+ */
+export function readVariables(env, spec) {
+    const inProduction = env.NODE_ENV === 'production';
+    const input = Object.fromEntries(spec.names.map((name) => [name, valueOf(env, name)]));
+    const names = Object.keys(spec.product);
+    const ownInput = Object.fromEntries(names.map((name) => [name, valueOf(env, name)]));
+    const base = (inProduction ? spec.production : spec.local).safeParse(input);
+    const own = z.object(spec.product).safeParse(ownInput);
+    const address = valueOf(env, spec.double.name);
+    const double = address === undefined ? null : ON_THIS_MACHINE.safeParse(address);
+    const problems = [
+        ...(base.success
+            ? []
+            : problemsOf(base.error.issues, spec.names, input, (name) => `${name} must be ${spec.must[name]}`)),
+        ...(double === null || double.success ? [] : [spec.double.problem]),
+        ...(own.success
+            ? []
+            : problemsOf(own.error.issues, names, ownInput, (name, issue) => `${name} is invalid: ${issue.message}`)),
+        ...(inProduction ? [] : spec.groups.flatMap((group) => partly(group.label, group.names, input)))
+    ];
+    if (!base.success || !own.success || problems.length > 0)
+        return { kind: 'problems', problems };
+    const data = base.data;
+    const { SMTP_HOST: host, SMTP_PORT: port, MAIL_FROM: from } = data;
+    return {
+        kind: 'ok',
+        value: {
+            config: {
+                mode: inProduction ? 'production' : 'local',
+                publicOrigin: data.PUBLIC_ORIGIN,
+                port: data.PORT ?? DEFAULT_PORT,
+                databaseUrl: data.DATABASE_URL,
+                name: data.MAIL_FROM_NAME,
+                mail: host !== undefined && port !== undefined && from !== undefined
+                    ? { kind: 'smtp', host, port, from }
+                    : { kind: 'log' },
+                salesToken: data.VERTRIEB_TOKEN,
+                missing: inProduction
+                    ? []
+                    : spec.groups.flatMap((group) => group.names.filter((name) => input[name] === undefined)),
+                product: own.data
+            },
+            data,
+            double: double === null || !double.success ? null : double.data
+        }
+    };
+}
 /** A variable that is empty or blank counts as missing. */
 export function valueOf(env, name) {
     const raw = env[name]?.trim();
@@ -202,43 +198,45 @@ export function stripeModeOf(secretKey) {
 }
 /** Reads the configuration; ConfigError names every problem at once. */
 export function loadConfig(env, product) {
-    const value = (name) => valueOf(env, name);
-    const inProduction = env.NODE_ENV === 'production';
-    const input = Object.fromEntries(STANDARD_VARIABLES.map((name) => [name, value(name)]));
-    const names = Object.keys(product.env);
-    const ownInput = Object.fromEntries(names.map((name) => [name, value(name)]));
-    const base = inProduction ? read(PRODUCTION, input, production) : read(LOCAL, input, local);
-    const own = z.object(product.env).safeParse(ownInput);
-    const apiBase = value('STRIPE_API_BASE');
-    const double = apiBase === undefined ? null : STRIPE_API_BASE.safeParse(apiBase);
-    const problems = [
-        ...(base.kind === 'problems' ? base.problems : []),
-        ...(double === null || double.success
-            ? []
-            : ['STRIPE_API_BASE must be an http origin on this machine, for the Stripe double']),
-        ...(own.success
-            ? []
-            : problemsOf(own.error.issues, names, ownInput, (name, issue) => `${name} is invalid: ${issue.message}`)),
-        ...(inProduction ? [] : [...partly('mail', MAIL, input), ...partly('Stripe', STRIPE, input)])
-    ];
-    if (base.kind === 'problems' || !own.success || problems.length > 0) {
-        throw new ConfigError(problems);
-    }
-    const stripe = base.value.stripe;
+    const read = readVariables(env, {
+        names: STANDARD_VARIABLES,
+        production: PRODUCTION,
+        local: LOCAL,
+        must: MUST,
+        groups: [
+            { label: 'mail', names: MAIL },
+            { label: 'Stripe', names: STRIPE }
+        ],
+        double: {
+            name: 'STRIPE_API_BASE',
+            problem: 'STRIPE_API_BASE must be an http origin on this machine, for the Stripe double'
+        },
+        product: product.env
+    });
+    if (read.kind === 'problems')
+        throw new ConfigError(read.problems);
+    const { config, data, double } = read.value;
+    const { STRIPE_SECRET_KEY: secretKey, STRIPE_WEBHOOK_SECRET: webhookSecret } = data;
     return {
-        mode: inProduction ? 'production' : 'local',
+        ...config,
         language: product.language,
-        ...base.value,
-        stripe: stripe.kind === 'none'
-            ? stripe
-            : {
-                ...stripe,
-                mode: stripeModeOf(stripe.secretKey),
-                api: double === null || !double.success
-                    ? { kind: 'stripe' }
-                    : { kind: 'double', url: double.data }
-            },
-        missing: inProduction ? [] : [...MAIL, ...STRIPE].filter((name) => input[name] === undefined),
-        product: own.data
+        operator: {
+            name: data.OPERATOR_NAME,
+            address: data.OPERATOR_ADDRESS,
+            register: data.OPERATOR_REGISTER === NONE
+                ? { kind: 'none' }
+                : { kind: 'entered', uid: data.OPERATOR_REGISTER },
+            vat: data.OPERATOR_VAT,
+            jurisdiction: data.OPERATOR_JURISDICTION
+        },
+        stripe: secretKey !== undefined && webhookSecret !== undefined
+            ? {
+                kind: 'stripe',
+                secretKey,
+                webhookSecret,
+                mode: stripeModeOf(secretKey),
+                api: double === null ? { kind: 'stripe' } : { kind: 'double', url: double }
+            }
+            : { kind: 'none' }
     };
 }

package/dist/server/core.d.ts

@@ -0,0 +1,88 @@
+import type { Handle, HandleServerError, RequestEvent, ServerInit } from '@sveltejs/kit';
+import type { Language } from '../product.js';
+import { type Art } from './adapter/migrate.js';
+import { type Mail } from './config.js';
+import { type Check, type HealthReport } from './health.js';
+import { type Limits } from './limits.js';
+import type { Log } from './log.js';
+import type { Db, Mailer } from './ports.js';
+/** What the core reads of the configuration of either art. */
+export interface CoreConfig {
+    mode: 'production' | 'local';
+    language: Language;
+    publicOrigin: string;
+    databaseUrl: string;
+    name: string;
+    mail: Mail;
+    /** What runs without locally; empty in production. */
+    missing: readonly string[];
+}
+/** Pool, configuration, log, mail and limits of what runs, for the hooks of the product. */
+export interface CoreContext<C> {
+    config: C;
+    db: Db;
+    log: Log;
+    mail: Mailer;
+    limits: Limits;
+}
+/** The hooks of the product the core calls; the art calls the others. */
+export interface CoreHooks<C> {
+    checks?: Record<string, (context: CoreContext<C>) => Promise<void>>;
+    start?: (context: CoreContext<C>) => Promise<void> | void;
+    stop?: (context: CoreContext<C>) => Promise<void> | void;
+}
+/** What an art runs with once its configuration is read. */
+export interface Opened<S> {
+    services: S;
+    /** Its own check in /health/deep, beside database and mail. */
+    check: Check;
+    /** Its own runs: they start before the start hook of the product and stop before its stop hook. */
+    runs?: {
+        start(): void;
+        stop(): Promise<void>;
+    };
+}
+export interface Running<C, S> {
+    context: CoreContext<C>;
+    services: S;
+    health: () => Promise<HealthReport>;
+}
+type Resolve = Parameters<Handle>[0]['resolve'];
+export interface CoreSpec<C extends CoreConfig, S> {
+    /** What runs, as the log and the errors name it. */
+    noun: 'product' | 'app';
+    art: Art;
+    /** The name of the art's own check in /health/deep. */
+    check: string;
+    hooks: CoreHooks<C>;
+    /** Reads the configuration in the root of the product; ConfigError names every problem. */
+    load(root: string): C;
+    open(context: CoreContext<C>): Opened<S>;
+    /** Answers every request but /health and /health/deep. */
+    respond(running: Running<C, S>, event: RequestEvent, resolve: Resolve): Promise<Response>;
+    /** The security headers of every answer. */
+    headers: Readonly<Record<string, string>>;
+    /** Fields of the request log beyond method, path, status and time. */
+    logged?: (event: RequestEvent) => Record<string, unknown>;
+}
+export interface Core<C, S> {
+    /**
+     * The `init` of the hooks. SvelteKit runs it in `vite build` too, to prerender pages, with
+     * `building` of `$app/environment` set: then it reads nothing and opens nothing, since the image is
+     * built without a single variable.
+     */
+    init: (building: boolean) => ServerInit;
+    handle: Handle;
+    handleError: HandleServerError;
+    /** What runs; only after `init`, and never in the build. */
+    running: () => Running<C, S>;
+}
+export declare function json(body: unknown, status: number): Response;
+/**
+ * A page without its content security policy does not go out: the policy comes from `option` in
+ * sveltekit() of the product's vite.config.ts, and without it every page is a 500 that the delivery
+ * service sees, not a product that runs without the policy unnoticed. The log says it once.
+ */
+export declare function policyGuard(option: string, noun: 'product' | 'app'): (response: Response, path: string) => Response;
+export declare function serverCore<C extends CoreConfig, S>(spec: CoreSpec<C, S>): Core<C, S>;
+export {};