@brydio/manifest 0.1.0-alpha.59 → 0.1.0-alpha.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brydio/manifest",
-  "version": "0.1.0-alpha.59",
+  "version": "0.1.0-alpha.61",
   "description": "The shape of a Brydio app's manifest, its collections' schemas, and the checks that say what is wrong with one.",
   "type": "module",
   "license": "MIT",
@@ -10,11 +10,15 @@
     "url": "https://github.com/nakel-ola/brydio-sdk",
     "directory": "packages/manifest"
   },
-  "gitHead": "3645964c21307d88950b196e4fd389ad82e6a286",
+  "gitHead": "3b1b248522223b5b75fd9b5480c6cc7106dc6e87",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",
       "default": "./src/index.js"
+    },
+    "./look": {
+      "types": "./src/look.d.ts",
+      "default": "./src/look.js"
     }
   },
   "files": [

package/src/bundle.d.ts

@@ -11,11 +11,22 @@
  */
 /** 1 MB per version, every file counted, the manifest included. */
 export declare const BUNDLE_MAX_BYTES: number;
+/**
+ * What a bundle with frame screens may carry beside its code (PB27): their
+ * pages, styles, images and media, 4 MB of them, on top of the 1 MB of code.
+ */
+export declare const FRAME_ASSETS_MAX_BYTES: number;
 /** The manifest, at the root of every published bundle. Never stored, never hashed. */
 export declare const BUNDLE_MANIFEST = "app.json";
 export declare const BUNDLE_PATH_MAX_CHARS = 200;
 /** The files of one bundle, by path inside it. */
 export type BundleFiles = ReadonlyMap<string, Uint8Array>;
+/** What a frame screen's page may load from its own bundle (PB27), by extension. No fonts. Brydio's list. */
+export declare const FRAME_ASSET_TYPES: Readonly<Record<string, string>>;
+/** Whether a file is a frame screen's asset rather than code. */
+export declare const isFrameAsset: (path: string) => boolean;
+/** The type a file is served with, or null for one the store never holds. Brydio's answer. */
+export declare function contentTypeOf(path: string): string | null;
 /**
  * Whether a path can name a file inside a bundle: relative, forward slashes,
  * no empty, `.` or `..` segment, no hidden segment, plain printable ASCII.
@@ -54,6 +65,8 @@ export interface BundleProblem {
  * and words: every path first, then the manifest, then the code, then the size.
  */
 export declare function bundleProblem(files: BundleFiles): BundleProblem | null;
-/** Every file's bytes, the manifest included: what the cap is measured on. */
+/** Every file's bytes, the manifest included. */
 export declare const bundleBytes: (files: BundleFiles) => number;
+/** A frame screen's pages, styles, images and media, which have a cap of their own (PB27). */
+export declare const frameAssetBytes: (files: BundleFiles) => number;
 export declare function sizeOf(bytes: number): string;

package/src/bundle.js

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import { brandPathsOf } from "./requirements.js";
+import { framePagesOf } from "./screen-kinds.js";
 /**
  * What a bundle may hold, and the fingerprint its code is served under
  * (contracts §11, A7-F02).
@@ -13,10 +14,41 @@ import { brandPathsOf } from "./requirements.js";
  */
 /** 1 MB per version, every file counted, the manifest included. */
 export const BUNDLE_MAX_BYTES = 1024 * 1024;
+/**
+ * What a bundle with frame screens may carry beside its code (PB27): their
+ * pages, styles, images and media, 4 MB of them, on top of the 1 MB of code.
+ */
+export const FRAME_ASSETS_MAX_BYTES = 4 * 1024 * 1024;
 /** The manifest, at the root of every published bundle. Never stored, never hashed. */
 export const BUNDLE_MANIFEST = 'app.json';
 export const BUNDLE_PATH_MAX_CHARS = 200;
 const SCRIPT = /\.m?js$/;
+/** What a frame screen's page may load from its own bundle (PB27), by extension. No fonts. Brydio's list. */
+export const FRAME_ASSET_TYPES = {
+    html: 'text/plain; charset=utf-8',
+    css: 'text/css; charset=utf-8',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    avif: 'image/avif',
+    svg: 'image/svg+xml',
+    mp4: 'video/mp4',
+    webm: 'video/webm',
+    mp3: 'audio/mpeg',
+    ogg: 'audio/ogg',
+    wav: 'audio/wav',
+};
+const extensionOf = (path) => /\.([a-z0-9]+)$/i.exec(path)?.[1]?.toLowerCase() ?? '';
+/** Whether a file is a frame screen's asset rather than code. */
+export const isFrameAsset = (path) => !SCRIPT.test(path) && Object.prototype.hasOwnProperty.call(FRAME_ASSET_TYPES, extensionOf(path));
+/** The type a file is served with, or null for one the store never holds. Brydio's answer. */
+export function contentTypeOf(path) {
+    if (SCRIPT.test(path))
+        return 'text/javascript; charset=utf-8';
+    return isFrameAsset(path) ? FRAME_ASSET_TYPES[extensionOf(path)] : null;
+}
 /**
  * Whether a path can name a file inside a bundle: relative, forward slashes,
  * no empty, `.` or `..` segment, no hidden segment, plain printable ASCII.
@@ -79,16 +111,24 @@ export function bundleHash(files) {
  */
 export function bundleProblem(files) {
     const brand = brandOf(files);
+    const pages = framePagesOf(manifestIn(files));
+    const framed = pages.size > 0;
     for (const path of files.keys()) {
         if (!isBundlePath(path)) {
             return { code: 'bundle_path_invalid', message: `"${JSON.stringify(path).slice(1, -1)}" is not a path a bundle can hold.`, file: path };
         }
         if (path !== BUNDLE_MANIFEST && !brand.has(path) && !SCRIPT.test(path)) {
-            return {
-                code: 'bundle_file_not_code',
-                message: `"${path}" is not a script. A bundle holds only .js files and ${BUNDLE_MANIFEST}.`,
-                file: path,
-            };
+            // A frame screen's page, styles, images and media (PB27); nothing else.
+            const asset = framed && isFrameAsset(path) && (!path.endsWith('.html') || pages.has(path));
+            if (!asset) {
+                return {
+                    code: 'bundle_file_not_code',
+                    message: framed
+                        ? `"${path}" is not a script, a frame screen's page, a stylesheet, an image or media. A bundle holds only those and ${BUNDLE_MANIFEST}.`
+                        : `"${path}" is not a script. A bundle holds only .js files and ${BUNDLE_MANIFEST}.`,
+                    file: path,
+                };
+            }
         }
     }
     if (!files.has(BUNDLE_MANIFEST)) {
@@ -97,9 +137,21 @@ export function bundleProblem(files) {
     if (codeOf(files).size === 0) {
         return { code: 'bundle_empty', message: 'That bundle has no screens in it, only a manifest.' };
     }
-    const total = bundleBytes(files);
+    const assets = [...files].filter(([path]) => isFrameAsset(path) && !brand.has(path));
+    const assetBytes = assets.reduce((sum, [, bytes]) => sum + bytes.length, 0);
+    if (assetBytes > FRAME_ASSETS_MAX_BYTES) {
+        const [largest] = [...assets].sort(([, a], [, b]) => b.length - a.length);
+        return {
+            code: 'bundle_too_large',
+            message: `The frame screens' pages, styles, images and media are ${sizeOf(assetBytes)}, over the ${sizeOf(FRAME_ASSETS_MAX_BYTES)} cap. ` +
+                `The largest is "${largest[0]}" at ${sizeOf(largest[1].length)}.`,
+            file: largest[0],
+        };
+    }
+    const counted = [...files].filter(([path]) => !(isFrameAsset(path) && !brand.has(path)));
+    const total = counted.reduce((sum, [, bytes]) => sum + bytes.length, 0);
     if (total > BUNDLE_MAX_BYTES) {
-        const [largest] = [...files].sort(([, a], [, b]) => b.length - a.length);
+        const [largest] = [...counted].sort(([, a], [, b]) => b.length - a.length);
         return {
             code: 'bundle_too_large',
             message: `That bundle is ${sizeOf(total)}, over the ${sizeOf(BUNDLE_MAX_BYTES)} cap. ` +
@@ -109,8 +161,13 @@ export function bundleProblem(files) {
     }
     return null;
 }
-/** Every file's bytes, the manifest included: what the cap is measured on. */
+/** Every file's bytes, the manifest included. */
 export const bundleBytes = (files) => [...files.values()].reduce((sum, bytes) => sum + bytes.length, 0);
+/** A frame screen's pages, styles, images and media, which have a cap of their own (PB27). */
+export const frameAssetBytes = (files) => {
+    const brand = brandOf(files);
+    return [...files].filter(([path]) => isFrameAsset(path) && !brand.has(path)).reduce((sum, [, bytes]) => sum + bytes.length, 0);
+};
 export function sizeOf(bytes) {
     if (bytes < 1024)
         return `${bytes} bytes`;

package/src/frame-checks.d.ts

@@ -0,0 +1,13 @@
+import type { BundleFiles } from './bundle.js';
+/**
+ * What a publish warns about in a frame screen's own files (PB27), and never
+ * refuses: a password field, and a font of its own. A copy of Brydio's
+ * `frameWarnings` (`apps/api/src/apps/publishing/frame-checks.ts`), in its
+ * words, so `brydio validate` says what the registry will.
+ */
+export interface FrameWarning {
+    code: 'frame_password_field' | 'frame_font';
+    message: string;
+    at: string;
+}
+export declare function frameWarnings(manifest: Record<string, unknown>, files: BundleFiles): FrameWarning[];

package/src/frame-checks.js

@@ -0,0 +1,35 @@
+import { framePagesOf } from "./screen-kinds.js";
+const text = (bytes) => (bytes ? new TextDecoder().decode(bytes) : '');
+const PASSWORD_IN_PAGE = /<input\b[^>]*\btype\s*=\s*["']?password\b/i;
+const PASSWORD_IN_SCRIPT = /\btype\s*[:=]\s*["']password["']|setAttribute\(\s*["']type["']\s*,\s*["']password["']\)/;
+const FONT_FACE = /@font-face\b/i;
+export function frameWarnings(manifest, files) {
+    const pages = framePagesOf(manifest);
+    const screens = (manifest.screens ?? {});
+    const warnings = [];
+    for (const [screen, declared] of Object.entries(screens)) {
+        const entry = declared?.entry;
+        if (typeof entry !== 'string' || !pages.has(entry))
+            continue;
+        const folder = entry.includes('/') ? entry.slice(0, entry.lastIndexOf('/') + 1) : '';
+        const scripts = [...files.keys()].filter(path => path !== entry && path.startsWith(folder) && !path.slice(folder.length).includes('/') && /\.m?js$/.test(path));
+        const password = PASSWORD_IN_PAGE.test(text(files.get(entry))) ? entry : scripts.find(path => PASSWORD_IN_SCRIPT.test(text(files.get(path))));
+        if (password) {
+            warnings.push({
+                code: 'frame_password_field',
+                at: password,
+                message: `The "${screen}" frame screen has a password field (${password}). An app never asks for a Brydio password or sign-in; a reviewer will ask why it is there.`,
+            });
+        }
+    }
+    for (const path of [...files.keys()].filter(one => one.endsWith('.css') || pages.has(one))) {
+        if (FONT_FACE.test(text(files.get(path)))) {
+            warnings.push({
+                code: 'frame_font',
+                at: path,
+                message: `${path} declares a font of its own. A frame screen loads no fonts; every app uses Brydio's own, so this one is never shown.`,
+            });
+        }
+    }
+    return warnings;
+}

package/src/index.d.ts

@@ -5,7 +5,7 @@
  */
 export { APP_NAME_FORMAT, MANIFEST_LIMITS, SEMVER_FORMAT, baseManifestSchema, brandImagesSchema } from './base.js';
 export { BRAND_FIELDS, BRAND_LIMITS, brandFilePath, brandPathsOf, brandProblems, brandShapeOf, isBrandPath, pngVerdict, svgColours, toolsProblem, type BrandField, type RequirementCode, type RequirementFiles, type RequirementProblem, } from './requirements.js';
-export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, bundleBytes, bundleHash, brandOf, bundleProblem, codeOf, isBundlePath, isScriptPath, sizeOf, type BundleFiles, type BundleProblem, type BundleProblemCode, } from './bundle.js';
+export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, FRAME_ASSETS_MAX_BYTES, FRAME_ASSET_TYPES, bundleBytes, contentTypeOf, frameAssetBytes, isFrameAsset, bundleHash, brandOf, bundleProblem, codeOf, isBundlePath, isScriptPath, sizeOf, type BundleFiles, type BundleProblem, type BundleProblemCode, } from './bundle.js';
 export { COLOUR_TOKENS, coeditedFields, FIELD_LIMITS, RESERVED_FIELDS, describeType, isCoedited, isSearchable, isSortable, isStructured, parseFieldType, structuredFields, valueProblem, valueSchema, FieldTypeInvalid, type DocumentOf, type FieldKind, type FieldType, type FieldValue, type FieldsOf, } from './field-types.js';
 export { appManifestSchema, appToolPrefix, collectionOf, crossAppTool, collectionsOf, dataProblems, effectivePlacementKey, HOME_CARD_SIZES, labelOf, manifestExtensionsSchema, newAppManifestSchema, SIZED_PLACEMENT_KINDS, MAX_APP_SECRETS, MAX_SECRET_CHARS, PLACEMENT_KEY, SECRET_NAME, storedExtensionsSchema, type AppManifestWithData, type CollectionSpec, type DataProblem, type DataProblemCode, type DataProblemOptions, type HomeCardSize, type ManifestExtensions, type SecretSpec, } from './schema.js';
 export { OPEN_LIMITS, OPEN_TYPES, choicesProblem, definitionOf, definitionTypeProblem, describeField, fieldTypeOf, hasChoices, isPlainOpenType, keyFromName, keyProblem, missingRequired, moveValue, openSchemaProblems, openSpec, openValueProblem, type Moved, type OpenField, type OpenFieldChange, type OpenFieldValue, type OpenProblem, type OpenProblemCode, type OpenSchemaFlag, type OpenType, } from './open-schema.js';
@@ -20,3 +20,6 @@ export { compareVersions, sdkRefusal, type SdkSupport } from './sdk.js';
 export { TOOL_WRITES, generatedToolsOf, toolNames, type GeneratedTool, type ToolVerb } from './tools.js';
 export { validateManifest, validateManifestText, type ManifestProblem, type ManifestProblemCode, type ManifestValidation, } from './validate.js';
 export { defineManifest, type ManifestShape, type ScreenNameOf, type WithDeclaredScreens } from './define.js';
+export { themeProblems, themeWarnings, themeOf, styleRefusal, colourRefusal, type AppTheme, type ColourPair, type LookProblem, type LookProblemCode, type LookWarningCode, } from './look.js';
+export { SCREEN_KINDS, framePagesOf, screenKindOf, screensOfKind, type ScreenKind } from './screen-kinds.js';
+export { frameWarnings, type FrameWarning } from './frame-checks.js';

package/src/index.js

@@ -5,7 +5,7 @@
  */
 export { APP_NAME_FORMAT, MANIFEST_LIMITS, SEMVER_FORMAT, baseManifestSchema, brandImagesSchema } from "./base.js";
 export { BRAND_FIELDS, BRAND_LIMITS, brandFilePath, brandPathsOf, brandProblems, brandShapeOf, isBrandPath, pngVerdict, svgColours, toolsProblem, } from "./requirements.js";
-export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, bundleBytes, bundleHash, brandOf, bundleProblem, codeOf, isBundlePath, isScriptPath, sizeOf, } from "./bundle.js";
+export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, FRAME_ASSETS_MAX_BYTES, FRAME_ASSET_TYPES, bundleBytes, contentTypeOf, frameAssetBytes, isFrameAsset, bundleHash, brandOf, bundleProblem, codeOf, isBundlePath, isScriptPath, sizeOf, } from "./bundle.js";
 export { COLOUR_TOKENS, coeditedFields, FIELD_LIMITS, RESERVED_FIELDS, describeType, isCoedited, isSearchable, isSortable, isStructured, parseFieldType, structuredFields, valueProblem, valueSchema, FieldTypeInvalid, } from "./field-types.js";
 export { appManifestSchema, appToolPrefix, collectionOf, crossAppTool, collectionsOf, dataProblems, effectivePlacementKey, HOME_CARD_SIZES, labelOf, manifestExtensionsSchema, newAppManifestSchema, SIZED_PLACEMENT_KINDS, MAX_APP_SECRETS, MAX_SECRET_CHARS, PLACEMENT_KEY, SECRET_NAME, storedExtensionsSchema, } from "./schema.js";
 export { OPEN_LIMITS, OPEN_TYPES, choicesProblem, definitionOf, definitionTypeProblem, describeField, fieldTypeOf, hasChoices, isPlainOpenType, keyFromName, keyProblem, missingRequired, moveValue, openSchemaProblems, openSpec, openValueProblem, } from "./open-schema.js";
@@ -20,3 +20,8 @@ export { compareVersions, sdkRefusal } from "./sdk.js";
 export { TOOL_WRITES, generatedToolsOf, toolNames } from "./tools.js";
 export { validateManifest, validateManifestText, } from "./validate.js";
 export { defineManifest } from "./define.js";
+// PB21, PB22: the look rules, Brydio's one rule set, copied.
+export { themeProblems, themeWarnings, themeOf, styleRefusal, colourRefusal, } from "./look.js";
+// PB27: tree screens and frame screens.
+export { SCREEN_KINDS, framePagesOf, screenKindOf, screensOfKind } from "./screen-kinds.js";
+export { frameWarnings } from "./frame-checks.js";

package/src/look.d.ts

@@ -0,0 +1,196 @@
+/**
+ * How an app may look: its theme (`tasks/app-publishing` PB21) and the
+ * `style` any element takes (PB22).
+ *
+ * A copy of Brydio's rule set, `apps/api/src/apps/manifest/app-look.ts`, which
+ * is the one source: a publish and the registry read it there, the host
+ * checks every node it draws with its own copy, and `brydio validate`, the
+ * catalogue's checks (`@brydio/ui/validate`) and the fake host read this
+ * one. `test/look.test.ts` holds
+ * this copy to Brydio's answers, sentence for sentence, whenever a Brydio
+ * checkout sits beside this repository, and to the recorded answers in
+ * `contracts/brydio.json` otherwise. It imports nothing.
+ */
+/** A name an app gives one of its colours: `ocean`, read as `app.ocean`. */
+export declare const APP_COLOUR_NAME: RegExp;
+/** The most named colours a theme may hold. */
+export declare const MAX_APP_COLOURS = 24;
+/** A plain colour: `#rgb` or `#rrggbb`. */
+export declare const HEX_COLOUR: RegExp;
+/** WCAG AA for body text. */
+export declare const TEXT_CONTRAST = 4.5;
+/**
+ * Brydio's own colours an app may name in a style, each to the token it
+ * reads. They follow light and dark by themselves.
+ */
+export declare const BRYDIO_COLOURS: Readonly<Record<string, string>>;
+/**
+ * What a check reads a Brydio colour as, to judge contrast on a screenshot.
+ * Near enough to the tokens to judge by; never drawn.
+ */
+export declare const BRYDIO_COLOUR_CHECK_VALUES: Readonly<Record<'light' | 'dark', Readonly<Record<string, string>>>>;
+/** Where Brydio draws an app: the ground a screenshot check reads text against. */
+export declare const GROUND: {
+    readonly light: "#ffffff";
+    readonly dark: "#212121";
+};
+/** A colour with a value for each theme. */
+export interface ColourPair {
+    light: string;
+    dark: string;
+}
+export declare const THEME_DENSITIES: readonly ["compact", "normal", "roomy"];
+export declare const THEME_ROUNDINGS: readonly ["none", "small", "normal", "large", "round"];
+export type ThemeDensity = (typeof THEME_DENSITIES)[number];
+export type ThemeRounding = (typeof THEME_ROUNDINGS)[number];
+/** How much each density scales Brydio's spacing and control heights. */
+export declare const DENSITY_SCALE: Readonly<Record<ThemeDensity, number>>;
+/** How much each rounding scales Brydio's corner radii. */
+export declare const ROUNDING_SCALE: Readonly<Record<ThemeRounding, number>>;
+/** An app's theme, as the manifest gives it (PB21). */
+export interface AppTheme {
+    /** What the `brand` tone becomes inside the app. */
+    accent?: ColourPair;
+    /** Named colours, read as `app.<name>`. */
+    colors?: Record<string, ColourPair>;
+    rounding?: ThemeRounding;
+    density?: ThemeDensity;
+}
+export type LookProblemCode = 'theme_invalid' | 'theme_font' | 'theme_colour_pair' | 'theme_colour_format' | 'theme_colour_name' | 'theme_colours_too_many' | 'theme_density' | 'theme_rounding';
+export type LookWarningCode = 'theme_contrast_low';
+/** One thing wrong with a theme, named down to the field. */
+export interface LookProblem {
+    code: LookProblemCode | LookWarningCode;
+    message: string;
+    /** Inside the manifest: `theme.colors.ocean.dark`. */
+    path: string;
+}
+/** Everything a publish refuses about a theme. Empty when it is fine. */
+export declare function themeProblems(theme: unknown): LookProblem[];
+/**
+ * What a publish warns about a theme, and never refuses: a colour whose best
+ * text, white or near-black, falls below WCAG AA on it.
+ */
+export declare function themeWarnings(theme: unknown): LookProblem[];
+/** The theme as code reads it after `themeProblems` found nothing. */
+export declare function themeOf(manifest: unknown): AppTheme | null;
+/** `#abc` → `[170, 187, 204]`, or null. */
+export declare function rgbOf(hex: string): [number, number, number] | null;
+/** WCAG contrast between two plain colours; 1 when either isn't one. */
+export declare function contrastOf(a: string, b: string): number;
+/** The text colour that reads best on a fill: white or near-black. */
+export declare function onColour(fill: string): string;
+/** How long a style may be, so a node can't carry a stylesheet. */
+export declare const STYLE_MAX_KEYS = 48;
+export declare const STYLE_MAX_BYTES: number;
+/** The furthest a length may reach, in pixels. */
+export declare const LENGTH_MAX = 10000;
+/** Brydio's spacing steps an app may name: `space.4`. */
+export declare const SPACE_MAX = 16;
+/** The highest layer inside an app's area. The area starts its own, so this is all an app needs. */
+export declare const Z_INDEX_MAX = 10;
+export declare const BRYDIO_RADII: readonly ["xs", "sm", "md", "lg", "xl", "2xl", "3xl"];
+export declare const BRYDIO_SHADOWS: readonly ["xs", "sm", "md", "lg"];
+export declare const TRANSITIONS: readonly ["none", "fast", "base", "slow"];
+type Rule = {
+    kind: 'size';
+} | {
+    kind: 'space';
+    negative: boolean;
+    sides: boolean;
+} | {
+    kind: 'offset';
+} | {
+    kind: 'colour';
+} | {
+    kind: 'enum';
+    values: readonly string[];
+} | {
+    kind: 'number';
+    min: number;
+    max: number;
+    integer?: boolean;
+} | {
+    kind: 'border-width';
+} | {
+    kind: 'radius';
+} | {
+    kind: 'shadow';
+} | {
+    kind: 'font-size';
+} | {
+    kind: 'font-weight';
+} | {
+    kind: 'line-height';
+} | {
+    kind: 'flex';
+} | {
+    kind: 'tracks';
+} | {
+    kind: 'grid-line';
+} | {
+    kind: 'position';
+} | {
+    kind: 'z-index';
+} | {
+    kind: 'image';
+} | {
+    kind: 'transition';
+};
+/** Every property a style may set (PB22), and what it takes. Nothing else is drawn. */
+export declare const STYLE_PROPERTIES: Readonly<Record<string, Rule>>;
+/** Properties people reach for that are refused on purpose, with the rule that refuses them. */
+export declare const STYLE_REFUSED: Readonly<Record<string, string>>;
+/**
+ * Why a colour can't be drawn, or null. A colour is one of Brydio's
+ * (`brydio.text`), one of the app's (`app.ocean`), `transparent`,
+ * `currentColor`, or a plain pair `{ light, dark }`. `colours`, when given,
+ * are the app's own names, so a name it never declared is refused too.
+ */
+export declare function colourRefusal(value: unknown, colours?: ReadonlySet<string>): string | null;
+/**
+ * Why a node's `style` can't be drawn, or null when it can (PB22). The
+ * sentence names the property and the rule: "style position can’t be fixed
+ * or sticky: …".
+ */
+export declare function styleRefusal(style: unknown, colours?: ReadonlySet<string>): string | null;
+/** The app colour names a theme declares, for `colourRefusal`. */
+export declare function colourNamesOf(theme: AppTheme | null | undefined): Set<string>;
+/** The app colour a tone names (`app.ocean` → `ocean`), or null when it names a Brydio tone. */
+export declare const appColourOfTone: (tone: unknown) => string | null;
+export type Mode = 'light' | 'dark';
+/**
+ * The plain colour a value is in this mode, for a check: an app colour or a
+ * pair to its hex, a Brydio colour to the value checks read it as, otherwise
+ * null.
+ */
+export declare function checkColourOf(value: unknown, mode: Mode, theme: AppTheme | null | undefined): string | null;
+/** The CSS a colour is drawn with in this mode. */
+export declare function cssColourOf(value: unknown, mode: Mode): string | null;
+/**
+ * A checked style as CSS declarations, for this mode. Only what passed
+ * `styleRefusal` is ever given here; anything it can't read is left out.
+ * `backgroundImage` is the host's to draw, since only it can read the file.
+ */
+export declare function styleToCss(style: Record<string, unknown>, mode: Mode): Record<string, string>;
+/**
+ * The CSS variables an app's area carries for its theme in this mode: its
+ * colours as `--app-color-<name>`, the accent as Brydio's brand tokens (so
+ * the `brand` tone is the app's), and the rounding and density as scales of
+ * Brydio's own radii and spacing.
+ */
+export declare function themeVariables(theme: AppTheme | null | undefined, mode: Mode): Record<string, string>;
+/**
+ * Whether a setting may name one of the app's colours as well as its own
+ * values (PB21): a `tone` that offers Brydio's `brand`.
+ */
+export declare const takesAppColour: (name: string, values: readonly string[]) => boolean;
+/** What a tone that names an app colour is told when it isn't one. */
+export declare const appColourSaid = "or one of the app\u2019s colours (app.<name>)";
+/**
+ * Why a `bry-canvas`'s shapes can't be drawn, or null (PB24). Their shape is
+ * the catalogue's to check; this is their colours, which are names only —
+ * Brydio's or the app's — so a canvas follows light and dark.
+ */
+export declare function canvasRefusal(ops: unknown, colours?: ReadonlySet<string>): string | null;
+export {};