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

package/src/field-types.js

@@ -8,7 +8,7 @@ import { z } from 'zod';
  */
 export const FIELD_LIMITS = {
     /** Collections one app may keep. */
-    collections: 20,
+    collections: 40,
     /** Fields one collection may have. */
     fields: 40,
     /** Values one choice may allow. */
@@ -65,10 +65,12 @@ const STRUCTURED = new Set([
     'number',
     'boolean',
     'token',
+    // Another of the app's records, by id (DW06): an id, never words, so a list can name it.
+    'ref',
 ]);
 /** Only the words in these may one day be searched (A3-F01-S02). */
 const SEARCHABLE = new Set(['string', 'text', 'string[]']);
-const SCALARS = new Set(['string', 'text', 'member', 'project', 'date', 'number', 'boolean', 'token']);
+const SCALARS = new Set(['string', 'text', 'member', 'project', 'date', 'number', 'boolean', 'token', 'canvas', 'ref']);
 /** A field type the manifest wrote that Brydio does not have, or a bad list. */
 export class FieldTypeInvalid extends Error {
     code;
@@ -78,6 +80,10 @@ export class FieldTypeInvalid extends Error {
         this.name = 'FieldTypeInvalid';
     }
 }
+/** The longest record id a `ref` field holds. */
+export const REF_CHARS = 128;
+/** What a record id looks like: letters, digits, `_` and `-`; never words. */
+export const REF_FORMAT = /^[A-Za-z0-9_-]+$/;
 /**
  * One field's manifest spelling, as a type.
  *
@@ -99,18 +105,24 @@ export function parseFieldType(raw) {
         return { kind: 'string[]', optional };
     if (name === 'token')
         return { kind: 'token', optional, values: COLOUR_TOKENS };
+    // A drawing is always co-edited and never required: it starts empty (WB01).
+    if (name === 'canvas')
+        return { kind: 'canvas', optional: true, coedit: true };
     if (SCALARS.has(name))
         return { kind: name, optional };
     throw new FieldTypeInvalid('data_field_type_unknown', `"${raw}" is not a field type.`);
 }
-const FIELD_KEYS = new Set(['type', 'optional', 'default', 'labels']);
+const FIELD_KEYS = new Set(['type', 'optional', 'default', 'labels', 'coedit']);
 /** How long a choice value's label may be. */
 export const LABEL_CHARS = 60;
 /** The object form: the short form under `type`, and what it may add. */
 function parseFieldObject(raw) {
     const unknown = Object.keys(raw).find(key => !FIELD_KEYS.has(key));
     if (unknown) {
-        throw new FieldTypeInvalid('data_field_key_unknown', `"${unknown}" is not something a field may say; use type, optional, default and labels.`);
+        throw new FieldTypeInvalid('data_field_key_unknown', `"${unknown}" is not something a field may say; use type, optional, default, labels and coedit.`);
+    }
+    if (raw.coedit !== undefined && typeof raw.coedit !== 'boolean') {
+        throw new FieldTypeInvalid('data_field_key_unknown', '"coedit" is true or false.');
     }
     if (typeof raw.type !== 'string' && !Array.isArray(raw.type)) {
         throw new FieldTypeInvalid('data_field_type_unknown', 'A field written as an object names its type under "type".');
@@ -119,7 +131,12 @@ function parseFieldObject(raw) {
         throw new FieldTypeInvalid('data_field_key_unknown', '"optional" is true or false.');
     }
     const inner = parseFieldType(raw.type);
-    const type = { ...inner, optional: inner.optional || raw.optional === true, ...labelsOf(inner, raw) };
+    const type = {
+        ...inner,
+        optional: inner.optional || raw.optional === true,
+        ...labelsOf(inner, raw),
+        ...coeditOf(inner, raw),
+    };
     if (!('default' in raw))
         return type;
     const value = raw.default;
@@ -157,6 +174,27 @@ function labelsOf(type, raw) {
     }
     return { labels: { ...labels } };
 }
+/** `coedit`, on long text only: nothing else is typed into by several people at once. */
+function coeditOf(type, raw) {
+    if (raw.coedit !== true)
+        return {};
+    if (type.kind !== 'text' && type.kind !== 'canvas') {
+        throw new FieldTypeInvalid('data_coedit_not_text', `Only a text or canvas field may be co-edited, not a ${type.kind}.`);
+    }
+    return { coedit: true };
+}
+/** True for a field several people write at once, through the co-editing layer. */
+export const isCoedited = (type) => type.kind === 'canvas' || (type.kind === 'text' && type.coedit === true);
+/**
+ * What a drawing's field holds in the record (WB01): a summary the host writes
+ * from the live board, so a list, search and the assistant can say what is on
+ * it. The drawing itself lives only in the co-edited document.
+ */
+export const CANVAS_SUMMARY_CHARS = 10_000;
+/** A collection's co-edited fields, by name. */
+export const coeditedFields = (fields) => Object.entries(fields)
+    .filter(([, type]) => isCoedited(type))
+    .map(([field]) => field);
 /** How a choice's value reads to a person: its label, or the value itself. */
 export const labelOfValue = (type, value) => type.labels?.[value] ?? value;
 function parseEnumeration(values) {
@@ -177,9 +215,9 @@ function parseEnumeration(values) {
     return { kind: 'enum', optional: false, values: values };
 }
 /** True for a type whose value lands in the plain `fields` column. */
-export const isStructured = (type) => STRUCTURED.has(type.kind);
+export const isStructured = (type) => STRUCTURED.has(type.kind) || type.plain === true;
 /** True for a type a list can be ordered by: structured, and one value. */
-export const isSortable = (type) => STRUCTURED.has(type.kind);
+export const isSortable = (type) => STRUCTURED.has(type.kind) || (type.plain === true && type.kind !== 'string[]');
 export const isSearchable = (type) => SEARCHABLE.has(type.kind);
 /**
  * The names of a schema's structured fields: the ones kept in plain beside the
@@ -227,7 +265,11 @@ export function valueSchema(type) {
         case 'boolean':
             return z.boolean();
         case 'string[]':
-            return z.array(z.string().max(FIELD_LIMITS.stringChars)).max(FIELD_LIMITS.listEntries);
+            return z.array(z.string().max(FIELD_LIMITS.stringChars)).max(type.maxEntries ?? FIELD_LIMITS.listEntries);
+        case 'canvas':
+            return z.object({ elements: z.number().int().min(0), text: z.string().max(CANVAS_SUMMARY_CHARS) }).strict();
+        case 'ref':
+            return z.string().min(1).max(REF_CHARS).regex(REF_FORMAT);
     }
 }
 /**
@@ -260,9 +302,13 @@ export function valueProblem(field, type, value) {
         case 'boolean':
             return `${field} must be true or false.`;
         case 'string[]':
-            return Array.isArray(value) && value.length > FIELD_LIMITS.listEntries
-                ? `${field} may hold at most ${FIELD_LIMITS.listEntries} entries.`
+            return Array.isArray(value) && value.length > (type.maxEntries ?? FIELD_LIMITS.listEntries)
+                ? `${field} may hold at most ${type.maxEntries ?? FIELD_LIMITS.listEntries} entries.`
                 : `${field} must be a list of short texts, each at most ${FIELD_LIMITS.stringChars.toLocaleString('en-GB')} characters.`;
+        case 'canvas':
+            return `${field} is a drawing: it is changed on its board, never written.`;
+        case 'ref':
+            return `${field} must be the id of one of this app's records.`;
     }
 }
 /** A type in a few words, for a tool's description: every allowed value named. */
@@ -288,6 +334,10 @@ export function describeType(type) {
             return 'true or false';
         case 'string[]':
             return 'a list of short texts';
+        case 'canvas':
+            return 'a drawing, read only: how many shapes it has and the words on it';
+        case 'ref':
+            return "the id of another of this app's records";
     }
 }
 /** ", read as \"todo\" is To do, \"done\" is Done", for a choice with labels. */

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/grants.d.ts

@@ -6,8 +6,20 @@
  * `apps/api/src/apps/manifest/grants.ts`, and the `grant_unknown` sentence in
  * `apps/api/src/apps/publishing/app-publish.service.ts`.
  */
-/** The host grants with a name of their own. A connection's is `connection:<name>`. */
-export declare const HOST_CAPABILITIES: readonly ["navigate", "message", "members", "projects", "model"];
+/**
+ * The host grants with a name of their own. A connection's is `connection:<name>`.
+ *
+ * `chats` and `chat` differ: `chats` is the typed Brydio API's reach into the
+ * person's assistant conversations; `chat` is a handler's `chat.post`, the
+ * app posting one of its cards into a workspace room (FO03). `directory` is
+ * a handler's `directory.*` and a screen's `useProfile` (FO02); `webhooks`
+ * is a handler's `webhooks.send` (FO07); `timers` is a handler's
+ * `timers.*`, running one of the app's own tools later (PJ01); `calendar`
+ * is a handler's `calendar.*`, the caller's events on the event layer (CA02).
+ * `people` is a handler's native HR operations as the current caller; it does
+ * not broaden `directory` access or authorize private records by itself.
+ */
+export declare const HOST_CAPABILITIES: readonly ["navigate", "message", "members", "projects", "files", "chats", "model", "secrets", "notify", "approvals", "chat", "directory", "webhooks", "timers", "calendar", "metrics", "sign", "finance", "people"];
 /** The older name for `HOST_CAPABILITIES`, kept for what already imports it. */
 export declare const KNOWN_HOST_GRANTS: readonly string[];
 /** True for a host grant Brydio knows how to honour: a named capability, or one connection. */

package/src/grants.js

@@ -7,8 +7,40 @@
  * `apps/api/src/apps/publishing/app-publish.service.ts`.
  */
 import { BUNDLE_MANIFEST } from "./bundle.js";
-/** The host grants with a name of their own. A connection's is `connection:<name>`. */
-export const HOST_CAPABILITIES = ['navigate', 'message', 'members', 'projects', 'model'];
+/**
+ * The host grants with a name of their own. A connection's is `connection:<name>`.
+ *
+ * `chats` and `chat` differ: `chats` is the typed Brydio API's reach into the
+ * person's assistant conversations; `chat` is a handler's `chat.post`, the
+ * app posting one of its cards into a workspace room (FO03). `directory` is
+ * a handler's `directory.*` and a screen's `useProfile` (FO02); `webhooks`
+ * is a handler's `webhooks.send` (FO07); `timers` is a handler's
+ * `timers.*`, running one of the app's own tools later (PJ01); `calendar`
+ * is a handler's `calendar.*`, the caller's events on the event layer (CA02).
+ * `people` is a handler's native HR operations as the current caller; it does
+ * not broaden `directory` access or authorize private records by itself.
+ */
+export const HOST_CAPABILITIES = [
+    'navigate',
+    'message',
+    'members',
+    'projects',
+    'files',
+    'chats',
+    'model',
+    'secrets',
+    'notify',
+    'approvals',
+    'chat',
+    'directory',
+    'webhooks',
+    'timers',
+    'calendar',
+    'metrics',
+    'sign',
+    'finance',
+    'people',
+];
 /** The older name for `HOST_CAPABILITIES`, kept for what already imports it. */
 export const KNOWN_HOST_GRANTS = HOST_CAPABILITIES;
 const CONNECTION = /^connection:[a-z0-9][a-z0-9_-]{0,59}$/;

package/src/index.d.ts

@@ -3,15 +3,23 @@
  * types, the tools Brydio generates from them, and the bundle rules. Each is
  * a copy of the server's own, so an app that passes here passes there.
  */
-export { APP_NAME_FORMAT, MANIFEST_LIMITS, SEMVER_FORMAT, baseManifestSchema } from './base.js';
-export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, bundleBytes, bundleHash, bundleProblem, codeOf, isBundlePath, isScriptPath, sizeOf, type BundleFiles, type BundleProblem, type BundleProblemCode, } from './bundle.js';
-export { COLOUR_TOKENS, FIELD_LIMITS, RESERVED_FIELDS, describeType, isSearchable, isSortable, isStructured, parseFieldType, structuredFields, valueProblem, valueSchema, FieldTypeInvalid, type DocumentOf, type FieldKind, type FieldType, type FieldValue, type FieldsOf, } from './field-types.js';
-export { appManifestSchema, collectionOf, collectionsOf, dataProblems, labelOf, manifestExtensionsSchema, storedExtensionsSchema, type AppManifestWithData, type CollectionSpec, type DataProblem, type DataProblemCode, type ManifestExtensions, } from './schema.js';
+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, 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';
+export { CONFIRM_LIMITS, confirmEmailProblems, confirmEmailSpec, type ConfirmEmailDeclared, type ConfirmEmailSpec, type ConfirmProblemCode, } from './confirm-email.js';
+export { ANONYMOUS_LIMITS, ANONYMOUS_WRITER, anonymousProblems, anonymousSpec, type AnonymousDeclared, type AnonymousProblemCode, type AnonymousSpec, } from './anonymous.js';
+export { editorsOf, editorsProblems, READERS_LIMIT, readersOf, readersProblems, type EditorsProblemCode, type ReadersProblemCode } from './readers.js';
 export { DOCUMENT_LIMITS } from './document-limits.js';
 export { HOST_CAPABILITIES, KNOWN_HOST_GRANTS, isHostCapability, unknownHostGrant } from './grants.js';
 export { diffSchemas, migrationProblems, migrationSchema, migrationStepSchema, migrationsSchema, publishedMigrationProblems, schemaOf, type Migration, type MigrationCode, type MigrationProblem, type MigrationStep, type SchemaChange, } from './migrations.js';
-export { SECRET_MESSAGE, findSecrets, secretsInJson, type SecretFound } from './secrets.js';
+export { DEVELOPER_KEY_MESSAGE, SECRET_MESSAGE, developerKeyIn, findSecrets, holdsDeveloperKey, secretsInJson, type SecretFound, } from './secrets.js';
 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

@@ -3,15 +3,25 @@
  * types, the tools Brydio generates from them, and the bundle rules. Each is
  * a copy of the server's own, so an app that passes here passes there.
  */
-export { APP_NAME_FORMAT, MANIFEST_LIMITS, SEMVER_FORMAT, baseManifestSchema } from "./base.js";
-export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, bundleBytes, bundleHash, bundleProblem, codeOf, isBundlePath, isScriptPath, sizeOf, } from "./bundle.js";
-export { COLOUR_TOKENS, FIELD_LIMITS, RESERVED_FIELDS, describeType, isSearchable, isSortable, isStructured, parseFieldType, structuredFields, valueProblem, valueSchema, FieldTypeInvalid, } from "./field-types.js";
-export { appManifestSchema, collectionOf, collectionsOf, dataProblems, labelOf, manifestExtensionsSchema, storedExtensionsSchema, } from "./schema.js";
+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, 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";
+export { CONFIRM_LIMITS, confirmEmailProblems, confirmEmailSpec, } from "./confirm-email.js";
+export { ANONYMOUS_LIMITS, ANONYMOUS_WRITER, anonymousProblems, anonymousSpec, } from "./anonymous.js";
+export { editorsOf, editorsProblems, READERS_LIMIT, readersOf, readersProblems } from "./readers.js";
 export { DOCUMENT_LIMITS } from "./document-limits.js";
 export { HOST_CAPABILITIES, KNOWN_HOST_GRANTS, isHostCapability, unknownHostGrant } from "./grants.js";
 export { diffSchemas, migrationProblems, migrationSchema, migrationStepSchema, migrationsSchema, publishedMigrationProblems, schemaOf, } from "./migrations.js";
-export { SECRET_MESSAGE, findSecrets, secretsInJson } from "./secrets.js";
+export { DEVELOPER_KEY_MESSAGE, SECRET_MESSAGE, developerKeyIn, findSecrets, holdsDeveloperKey, secretsInJson, } from "./secrets.js";
 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 {};