@brydio/manifest 0.1.0-alpha.3 → 0.1.0-alpha.31

package/README.md

@@ -0,0 +1,24 @@
+# @brydio/manifest
+
+The schema and validation rules for `.brydio/app.json`. It covers app identity,
+placements, screens, collections, generated and custom tools, grants, and
+migrations.
+
+```ts
+import { defineManifest } from '@brydio/manifest';
+
+export const manifest = defineManifest({
+  name: 'checklist',
+  version: '0.1.0',
+  screens: { home: { entry: 'screens/home.js' } },
+  placements: [{ kind: 'project-widget', screen: 'home', label: 'Checklist', sizes: ['medium', 'large'] }],
+});
+```
+
+Read the [manifest reference](https://github.com/nakel-ola/brydio-sdk/blob/main/docs/manifest.md)
+for every field, schema type, grant, migration operation, and limit. The
+[publish checklist](https://github.com/nakel-ola/brydio-sdk/blob/main/docs/publish-checklist.md)
+lists every validation code and its refusal message.
+
+This package is MIT licensed. While the SDK is `0.x`, a minor version may
+contain a breaking change. Read the repository changelog before upgrading.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brydio/manifest",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.31",
   "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,7 +10,7 @@
     "url": "https://github.com/nakel-ola/brydio-sdk",
     "directory": "packages/manifest"
   },
-  "gitHead": "19f96a9cd43b4e2b8841e44e2e69795de8c4c997",
+  "gitHead": "5b6cf4e4fdacc5c60684fbf25b6b3cc3c78bb4f8",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",

package/src/base.d.ts

@@ -32,6 +32,15 @@ export declare const linksSchema: z.ZodObject<{
     terms: z.ZodOptional<z.ZodString>;
     support: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * One of an app's two images, in its two variants (ADR-A20): `color` for a
+ * tile and the app's own page, `mono` for the sidebar, where the theme tints
+ * it. Both are `./`-prefixed paths inside the app.
+ */
+export declare const brandImagesSchema: z.ZodObject<{
+    color: z.ZodString;
+    mono: z.ZodString;
+}, z.core.$strip>;
 export declare const requiresSchema: z.ZodObject<{
     servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
     integrations: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -57,7 +66,14 @@ export declare const baseManifestSchema: z.ZodObject<{
         terms: z.ZodOptional<z.ZodString>;
         support: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
-    icon: z.ZodOptional<z.ZodString>;
+    logo: z.ZodOptional<z.ZodObject<{
+        color: z.ZodString;
+        mono: z.ZodString;
+    }, z.core.$strip>>;
+    icon: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        color: z.ZodString;
+        mono: z.ZodString;
+    }, z.core.$strip>]>>;
     brandColor: z.ZodOptional<z.ZodString>;
     brandColorDark: z.ZodOptional<z.ZodString>;
     defaultPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/src/base.js

@@ -32,6 +32,15 @@ export const linksSchema = z.object({
     terms: z.string().optional(),
     support: z.string().optional(),
 });
+/**
+ * One of an app's two images, in its two variants (ADR-A20): `color` for a
+ * tile and the app's own page, `mono` for the sidebar, where the theme tints
+ * it. Both are `./`-prefixed paths inside the app.
+ */
+export const brandImagesSchema = z.object({
+    color: z.string(),
+    mono: z.string(),
+});
 export const requiresSchema = z.object({
     servers: z.array(z.string()).default([]),
     integrations: z.array(z.string()).default([]),
@@ -49,7 +58,10 @@ export const baseManifestSchema = z.object({
     license: z.string().max(MANIFEST_LIMITS.licenseChars).optional(),
     keywords: z.array(z.string()).max(MANIFEST_LIMITS.keywords).optional(),
     links: linksSchema.optional(),
-    icon: z.string().optional(),
+    /** Required to publish (ADR-A20); optional here so every stored manifest still reads. */
+    logo: brandImagesSchema.optional(),
+    /** The two-variant icon (ADR-A20), or the one path every app had before it, still read. */
+    icon: z.union([z.string(), brandImagesSchema]).optional(),
     brandColor: z.string().optional(),
     brandColorDark: z.string().optional(),
     defaultPrompts: z.array(z.string()).max(MANIFEST_LIMITS.defaultPrompts).optional(),

package/src/bundle.d.ts

@@ -23,7 +23,14 @@ export type BundleFiles = ReadonlyMap<string, Uint8Array>;
 export declare function isBundlePath(path: string): boolean;
 /** Whether a path is a script a bundle can hold. */
 export declare const isScriptPath: (path: string) => boolean;
-/** The files the store keeps and the fingerprint covers: every one but the root manifest. */
+/**
+ * The logo and icon files the bundle's manifest names (ADR-A20), by path: the
+ * one kind of file beside code a bundle may hold, and only at those paths.
+ * Brydio keeps them with the version, never as code, so they are not in the
+ * fingerprint.
+ */
+export declare function brandOf(files: BundleFiles): BundleFiles;
+/** The files the store keeps and the fingerprint covers: every one but the root manifest and its brand images. */
 export declare function codeOf(files: BundleFiles): BundleFiles;
 /**
  * The fingerprint: sha256, lowercase hex, over the sorted list of the code

package/src/bundle.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { brandPathsOf } from "./requirements.js";
 /**
  * What a bundle may hold, and the fingerprint its code is served under
  * (contracts §11, A7-F02).
@@ -29,9 +30,32 @@ export function isBundlePath(path) {
 }
 /** Whether a path is a script a bundle can hold. */
 export const isScriptPath = (path) => isBundlePath(path) && SCRIPT.test(path);
-/** The files the store keeps and the fingerprint covers: every one but the root manifest. */
+/**
+ * The logo and icon files the bundle's manifest names (ADR-A20), by path: the
+ * one kind of file beside code a bundle may hold, and only at those paths.
+ * Brydio keeps them with the version, never as code, so they are not in the
+ * fingerprint.
+ */
+export function brandOf(files) {
+    const named = new Set(brandPathsOf(manifestIn(files)).values());
+    return new Map([...files].filter(([path]) => named.has(path)));
+}
+/** The bundle's manifest, read leniently: anything unreadable names no files. */
+function manifestIn(files) {
+    const bytes = files.get(BUNDLE_MANIFEST);
+    if (!bytes)
+        return null;
+    try {
+        return JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        return null;
+    }
+}
+/** The files the store keeps and the fingerprint covers: every one but the root manifest and its brand images. */
 export function codeOf(files) {
-    return new Map([...files].filter(([path]) => path !== BUNDLE_MANIFEST));
+    const brand = brandOf(files);
+    return new Map([...files].filter(([path]) => path !== BUNDLE_MANIFEST && !brand.has(path)));
 }
 const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
 /**
@@ -54,11 +78,12 @@ export function bundleHash(files) {
  * and words: every path first, then the manifest, then the code, then the size.
  */
 export function bundleProblem(files) {
+    const brand = brandOf(files);
     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 && !SCRIPT.test(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}.`,

package/src/define.d.ts

@@ -11,7 +11,7 @@
  *   name: 'issues',
  *   version: '0.1.0',
  *   screens: { board: { entry: 'screens/board.js' } },
- *   placements: [{ kind: 'project-tab', screen: 'bord' }],   // error: "bord" is not a screen
+ *   placements: [{ kind: 'project-widget', screen: 'bord', sizes: ['large'] }],   // error: "bord" is not a screen
  * });
  * ```
  */

package/src/define.js

@@ -11,7 +11,7 @@
  *   name: 'issues',
  *   version: '0.1.0',
  *   screens: { board: { entry: 'screens/board.js' } },
- *   placements: [{ kind: 'project-tab', screen: 'bord' }],   // error: "bord" is not a screen
+ *   placements: [{ kind: 'project-widget', screen: 'bord', sizes: ['large'] }],   // error: "bord" is not a screen
  * });
  * ```
  */

package/src/field-types.d.ts

@@ -12,7 +12,7 @@ import { type ZodType } from 'zod';
  * and everything downstream — the store, the generated tools, the screen's
  * form — reads that shape, never the manifest's spelling.
  */
-export type FieldKind = 'string' | 'text' | 'enum' | 'member' | 'project' | 'date' | 'number' | 'boolean' | 'string[]' | 'token';
+export type FieldKind = 'string' | 'text' | 'enum' | 'member' | 'project' | 'date' | 'number' | 'boolean' | 'string[]' | 'token' | 'canvas';
 export interface FieldType {
     kind: FieldKind;
     /** Written with a trailing `?`: may be left out on create. */
@@ -27,6 +27,13 @@ export interface FieldType {
      * changes, and a value with no label reads as itself.
      */
     labels?: Readonly<Record<string, string>>;
+    /**
+     * Written by several people at once (`tasks/docs-wiki` DW01): a `text`
+     * field drawn with `bry-rich-text bind` is one fragment of a shared Yjs
+     * document the host keeps. Such a field leaves the record's `version`
+     * check, and a tool's change to it merges into the live text.
+     */
+    coedit?: boolean;
 }
 /**
  * The bounds a schema and a record are held to (A3-F01-S03).
@@ -74,8 +81,8 @@ export declare const FIELD_NAME: RegExp;
 export declare const COLLECTION_NAME: RegExp;
 /** A field type the manifest wrote that Brydio does not have, or a bad list. */
 export declare class FieldTypeInvalid extends Error {
-    readonly code: 'data_field_type_unknown' | 'data_enum_empty' | 'data_enum_too_many' | 'data_enum_value_invalid' | 'data_enum_duplicate' | 'data_default_not_allowed' | 'data_default_on_required' | 'data_default_invalid' | 'data_labels_not_allowed' | 'data_label_invalid' | 'data_label_unknown_value' | 'data_field_key_unknown';
-    constructor(code: 'data_field_type_unknown' | 'data_enum_empty' | 'data_enum_too_many' | 'data_enum_value_invalid' | 'data_enum_duplicate' | 'data_default_not_allowed' | 'data_default_on_required' | 'data_default_invalid' | 'data_labels_not_allowed' | 'data_label_invalid' | 'data_label_unknown_value' | 'data_field_key_unknown', message: string);
+    readonly code: 'data_field_type_unknown' | 'data_enum_empty' | 'data_enum_too_many' | 'data_enum_value_invalid' | 'data_enum_duplicate' | 'data_default_not_allowed' | 'data_default_on_required' | 'data_default_invalid' | 'data_labels_not_allowed' | 'data_label_invalid' | 'data_label_unknown_value' | 'data_field_key_unknown' | 'data_coedit_not_text';
+    constructor(code: 'data_field_type_unknown' | 'data_enum_empty' | 'data_enum_too_many' | 'data_enum_value_invalid' | 'data_enum_duplicate' | 'data_default_not_allowed' | 'data_default_on_required' | 'data_default_invalid' | 'data_labels_not_allowed' | 'data_label_invalid' | 'data_label_unknown_value' | 'data_field_key_unknown' | 'data_coedit_not_text', message: string);
 }
 /**
  * One field's manifest spelling, as a type.
@@ -87,6 +94,16 @@ export declare class FieldTypeInvalid extends Error {
 export declare function parseFieldType(raw: unknown): FieldType;
 /** How long a choice value's label may be. */
 export declare const LABEL_CHARS = 60;
+/** True for a field several people write at once, through the co-editing layer. */
+export declare const isCoedited: (type: FieldType) => boolean;
+/**
+ * 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 declare const CANVAS_SUMMARY_CHARS = 10000;
+/** A collection's co-edited fields, by name. */
+export declare const coeditedFields: (fields: Readonly<Record<string, FieldType>>) => string[];
 /** How a choice's value reads to a person: its label, or the value itself. */
 export declare const labelOfValue: (type: FieldType, value: string) => string;
 /** True for a type whose value lands in the plain `fields` column. */
@@ -127,7 +144,10 @@ type Optional<T> = T extends `${string}?` ? true : T extends {
 /** The TypeScript type of one field's value, from its manifest spelling. */
 export type FieldValue<T> = T extends {
     type: infer U;
-} ? FieldValue<U> : T extends readonly (infer V)[] ? V : T extends 'number' | 'number?' ? number : T extends 'boolean' | 'boolean?' ? boolean : T extends 'string[]' | 'string[]?' ? string[] : T extends 'token' | 'token?' ? (typeof COLOUR_TOKENS)[number] : T extends string ? string : never;
+} ? FieldValue<U> : T extends readonly (infer V)[] ? V : T extends 'number' | 'number?' ? number : T extends 'boolean' | 'boolean?' ? boolean : T extends 'string[]' | 'string[]?' ? string[] : T extends 'token' | 'token?' ? (typeof COLOUR_TOKENS)[number] : T extends 'canvas' | 'canvas?' ? {
+    elements: number;
+    text: string;
+} : T extends string ? string : never;
 type Simplify<T> = {
     [K in keyof T]: T[K];
 } & {};

package/src/field-types.js

@@ -68,7 +68,7 @@ const STRUCTURED = new Set([
 ]);
 /** 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']);
 /** A field type the manifest wrote that Brydio does not have, or a bad list. */
 export class FieldTypeInvalid extends Error {
     code;
@@ -99,18 +99,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 +125,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 +168,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) {
@@ -228,6 +260,8 @@ export function valueSchema(type) {
             return z.boolean();
         case 'string[]':
             return z.array(z.string().max(FIELD_LIMITS.stringChars)).max(FIELD_LIMITS.listEntries);
+        case 'canvas':
+            return z.object({ elements: z.number().int().min(0), text: z.string().max(CANVAS_SUMMARY_CHARS) }).strict();
     }
 }
 /**
@@ -263,6 +297,8 @@ export function valueProblem(field, type, value) {
             return Array.isArray(value) && value.length > FIELD_LIMITS.listEntries
                 ? `${field} may hold at most ${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.`;
     }
 }
 /** A type in a few words, for a tool's description: every allowed value named. */
@@ -288,6 +324,8 @@ 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';
     }
 }
 /** ", read as \"todo\" is To do, \"done\" is Done", for a choice with labels. */

package/src/grants.d.ts

@@ -7,7 +7,7 @@
  * `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"];
+export declare const HOST_CAPABILITIES: readonly ["navigate", "message", "members", "projects", "files", "chats", "model", "secrets", "notify"];
 /** 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

@@ -8,7 +8,7 @@
  */
 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'];
+export const HOST_CAPABILITIES = ['navigate', 'message', 'members', 'projects', 'files', 'chats', 'model', 'secrets', 'notify'];
 /** 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,14 +3,15 @@
  * 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, bundleBytes, 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, collectionOf, 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 { 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';

package/src/index.js

@@ -3,14 +3,15 @@
  * 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, bundleBytes, 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, collectionOf, 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 { 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";

package/src/requirements.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Two things every app must have before it is published (owner decisions of
+ * 22 September 2026), checked the same way by `brydio validate` and by
+ * `POST /apps/publish`.
+ *
+ * - **A logo and an icon, each in colour and in one colour** (ADR-A20). The
+ *   manifest names four image files, and a package missing any of them is
+ *   refused.
+ * - **Something for the assistant to call** (ADR-A19): generated tools from a
+ *   collection, a custom tool, an MCP server or an integration.
+ *
+ * A copy of Brydio's `apps/api/src/apps/manifest/requirements.ts`, the
+ * checks `POST /apps/publish` runs. Nothing here imports anything, so the
+ * copy is the file: not even `node:zlib`, which a PNG is inflated with, since
+ * a screen may bundle `@brydio/manifest` and a worker has none.
+ * `test/requirements.test.ts` asks Brydio the same questions whenever a
+ * checkout is beside this one.
+ *
+ * ## What "one colour" means
+ *
+ * The mono variant is drawn tinted by the theme, so it must be a shape and
+ * nothing else: one colour on transparency.
+ *
+ * - An **SVG** is read for every colour it paints with: `fill`, `stroke`,
+ *   `stop-color`, `flood-color` and `color`, as attributes and inside `style`.
+ *   `none`, `transparent`, `inherit` and `currentColor` are not colours.
+ *   A shape with no fill of its own paints in the default black, unless the
+ *   root `<svg>` or a `<g>` sets one. More than one distinct colour is
+ *   refused, and so is an embedded `<image>`, which could be anything.
+ * - A **PNG** is decoded, and every pixel at least 1/16 opaque must be within
+ *   32 of one colour on each channel, so anti-aliased edges of a black glyph
+ *   (black at partial alpha) pass and a two-colour picture does not. A PNG
+ *   with no transparent pixel at all is a solid block and is refused too.
+ * - A **JPEG** has no transparency, and a **WebP** is not decoded here, so
+ *   neither can be the one-colour variant. Both are fine in colour.
+ *
+ * ## Sizes
+ *
+ * - An **icon** is square: from 48 to 1,024 pixels across as a raster, and a
+ *   square view box as an SVG.
+ * - A **logo** may be wider than it is tall, never taller: from 48 to 1,024
+ *   pixels tall, at most 2,048 wide, and at most four times as wide as it is
+ *   tall. An SVG's view box is held to the same proportions.
+ * - Every file is at most 512 KB.
+ */
+export declare const BRAND_LIMITS: {
+    readonly bytes: number;
+    readonly iconMinSide: 48;
+    readonly iconMaxSide: 1024;
+    readonly logoMinHeight: 48;
+    readonly logoMaxHeight: 1024;
+    readonly logoMaxWidth: 2048;
+    /** Width over height, at most. */
+    readonly logoMaxRatio: 4;
+};
+/** The two images, and the two variants each one comes in. */
+export declare const BRAND_FIELDS: readonly ["logo.color", "logo.mono", "icon.color", "icon.mono"];
+export type BrandField = (typeof BRAND_FIELDS)[number];
+export type RequirementCode = 'brand_logo_missing' | 'brand_icon_missing' | 'brand_path_invalid' | 'brand_file_missing' | 'brand_file_too_large' | 'brand_file_unreadable' | 'brand_icon_shape' | 'brand_logo_shape' | 'brand_mono_type' | 'brand_mono_colours' | 'app_has_no_tools';
+export interface RequirementProblem {
+    code: RequirementCode;
+    message: string;
+    /** The manifest field, like `icon.mono`. */
+    path: string;
+}
+/** The files a check can see, by their path inside the package with no `./`. */
+export type RequirementFiles = ReadonlyMap<string, Uint8Array>;
+export type BrandImageType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/svg+xml';
+/** A path the manifest wrote, as a bundle names the file: no `./`, forward slashes. */
+export declare const brandFilePath: (declared: string) => string;
+/**
+ * Whether a declared brand path is one Brydio will follow: `./`-prefixed,
+ * relative, inside the package, and a name a bundle can hold.
+ */
+export declare function isBrandPath(declared: unknown): declared is string;
+/**
+ * The brand files a manifest names, by field, as bundle paths. Only fields
+ * written in the two-variant shape; a legacy `icon: "./icon.png"` names none.
+ */
+export declare function brandPathsOf(manifest: unknown): Map<BrandField, string>;
+/**
+ * Everything wrong with an app's logo and icon.
+ *
+ * `required` is off only where a package is read that is not being published
+ * (an import of somebody's plugin with no screens): the images it does name
+ * are still checked, and the ones it leaves out are not asked for.
+ */
+export declare function brandProblems(manifest: Record<string, unknown>, files: RequirementFiles, options?: {
+    required?: boolean;
+}): RequirementProblem[];
+/**
+ * Whether the assistant has anything to call in this app (ADR-A19).
+ *
+ * `parts` counts what the package bundles beside the manifest: the servers in
+ * its `servers.json` and the files in its `integrations/`. Where they can't
+ * be seen (a published bundle holds only code), `requires` still counts.
+ */
+export declare function toolsProblem(manifest: Record<string, unknown>, parts?: {
+    servers?: number;
+    integrations?: number;
+}): RequirementProblem | null;
+export interface BrandShape {
+    type: BrandImageType;
+    width: number;
+    height: number;
+}
+/** What an image is and how big, from its bytes, or null for anything else. */
+export declare function brandShapeOf(bytes: Uint8Array): BrandShape | null;
+/** No script, no event handler, no `javascript:` and no reference that leaves the file. */
+export declare function svgIsInert(svg: string): boolean;
+/**
+ * Every distinct colour an SVG paints with, normalised, or null when it
+ * embeds a raster whose colours can't be read from the markup.
+ */
+export declare function svgColours(svg: string): string[] | null;
+/**
+ * What a PNG's pixels say about being one colour.
+ *
+ * Decodes the image (non-interlaced, every colour type and bit depth) and
+ * compares every pixel at least 1/16 opaque with the most opaque one.
+ */
+export declare function pngVerdict(bytes: Uint8Array): 'one' | 'colours' | 'opaque' | 'unreadable';