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

package/README.md

@@ -11,7 +11,7 @@ export const manifest = defineManifest({
   name: 'checklist',
   version: '0.1.0',
   screens: { home: { entry: 'screens/home.js' } },
-  placements: [{ kind: 'project-tab', screen: 'home', label: 'Checklist' }],
+  placements: [{ kind: 'project-widget', screen: 'home', label: 'Checklist', sizes: ['medium', 'large'] }],
 });
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brydio/manifest",
-  "version": "0.1.0-alpha.6",
+  "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": "24bd1c63c437a96b40313077a85181cb4a5f6476",
+  "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/anonymous.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+/**
+ * An anonymous collection (P13): answers nobody can tie back to the person
+ * who gave them. Mirrors Brydio's `apps/api/src/apps/manifest/anonymous.ts`;
+ * the two change together.
+ *
+ * An app only declares it: which structured field groups the answers (a
+ * form, a survey round: a number, a choice, a date), and how many answers a
+ * group must hold before any of them is read. Brydio does the rest in the store, never the app: no writer kept
+ * on the record, times cut to the day, no live change told, no update, a
+ * create naming its own writer refused, and reads only of a whole group of
+ * at least `minimum` answers.
+ */
+export declare const ANONYMOUS_LIMITS: {
+    /** The fewest answers a group, or a narrowed read of one, may be read at. */
+    readonly minimum: 5;
+    /** The most an app may ask for. */
+    readonly maximum: 1000;
+};
+/** What the store writes as `created_by` on every anonymous record. */
+export declare const ANONYMOUS_WRITER = "anonymous";
+export declare const anonymousSchema: z.ZodObject<{
+    group: z.ZodString;
+    minimum: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type AnonymousDeclared = z.infer<typeof anonymousSchema>;
+/** As the host reads it, on `CollectionSpec.anonymous`. */
+export interface AnonymousSpec {
+    group: string;
+    minimum: number;
+}
+export type AnonymousProblemCode = 'data_anonymous_group' | 'data_anonymous_member' | 'data_anonymous_minimum' | 'data_anonymous_coedit';
+export declare function anonymousProblems(collection: string, declared: {
+    schema: Record<string, unknown>;
+    anonymous?: AnonymousDeclared;
+}): {
+    code: AnonymousProblemCode;
+    collection: string;
+    field?: string;
+    message: string;
+}[];
+export declare function anonymousSpec(declared: AnonymousDeclared): AnonymousSpec;

package/src/anonymous.js

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { FIELD_LIMITS, isStructured, parseFieldType, } from "./field-types.js";
+/**
+ * An anonymous collection (P13): answers nobody can tie back to the person
+ * who gave them. Mirrors Brydio's `apps/api/src/apps/manifest/anonymous.ts`;
+ * the two change together.
+ *
+ * An app only declares it: which structured field groups the answers (a
+ * form, a survey round: a number, a choice, a date), and how many answers a
+ * group must hold before any of them is read. Brydio does the rest in the store, never the app: no writer kept
+ * on the record, times cut to the day, no live change told, no update, a
+ * create naming its own writer refused, and reads only of a whole group of
+ * at least `minimum` answers.
+ */
+export const ANONYMOUS_LIMITS = {
+    /** The fewest answers a group, or a narrowed read of one, may be read at. */
+    minimum: 5,
+    /** The most an app may ask for. */
+    maximum: 1000,
+};
+/** What the store writes as `created_by` on every anonymous record. */
+export const ANONYMOUS_WRITER = 'anonymous';
+export const anonymousSchema = z
+    .object({
+    /** A structured field of the same collection, never a member: which group an answer belongs to. */
+    group: z.string().min(1).max(FIELD_LIMITS.nameChars),
+    /** At least 5, the default. */
+    minimum: z.number().int().max(ANONYMOUS_LIMITS.maximum).optional(),
+})
+    .strict();
+export function anonymousProblems(collection, declared) {
+    const anonymous = declared.anonymous;
+    if (!anonymous)
+        return [];
+    const problems = [];
+    const types = new Map();
+    for (const [field, raw] of Object.entries(declared.schema)) {
+        try {
+            types.set(field, parseFieldType(raw));
+        }
+        catch {
+            // Refused as a field type already.
+        }
+    }
+    // Kept in plain, so a read can name its group; words never are.
+    const group = types.get(anonymous.group);
+    if (!group || !isStructured(group) || group.kind === 'member') {
+        problems.push({
+            code: 'data_anonymous_group',
+            collection,
+            field: anonymous.group,
+            message: `${collection}.anonymous.group must name one of its structured fields (a number, choice, date, boolean, token or project); ${anonymous.group} is not.`,
+        });
+    }
+    if (anonymous.minimum !== undefined && anonymous.minimum < ANONYMOUS_LIMITS.minimum) {
+        problems.push({
+            code: 'data_anonymous_minimum',
+            collection,
+            message: `${collection}.anonymous.minimum is at least ${ANONYMOUS_LIMITS.minimum}: fewer answers than that can be told apart.`,
+        });
+    }
+    for (const [field, type] of types) {
+        // A member field names a person on the record, which is what this is for not doing.
+        if (type.kind === 'member') {
+            problems.push({
+                code: 'data_anonymous_member',
+                collection,
+                field,
+                message: `${collection} is anonymous, so it can't name a member: ${field} would.`,
+            });
+        }
+        // Writing together shows who is typing, and changes a record after it is given.
+        if (type.coedit) {
+            problems.push({
+                code: 'data_anonymous_coedit',
+                collection,
+                field,
+                message: `${collection} is anonymous, so its answers can't be written together: ${field} would be.`,
+            });
+        }
+    }
+    return problems;
+}
+export function anonymousSpec(declared) {
+    return { group: declared.group, minimum: declared.minimum ?? ANONYMOUS_LIMITS.minimum };
+}

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

@@ -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.
@@ -23,7 +34,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
@@ -47,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,4 +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).
@@ -12,10 +14,41 @@ import { createHash } from 'node:crypto';
  */
 /** 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.
@@ -29,9 +62,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,16 +110,25 @@ 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);
+    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 && !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,
-            };
+        if (path !== BUNDLE_MANIFEST && !brand.has(path) && !SCRIPT.test(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)) {
@@ -72,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. ` +
@@ -84,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/confirm-email.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+/**
+ * The confirmation email of a public form (FO04). Mirrors Brydio's
+ * `apps/api/src/apps/manifest/confirm-email.ts`; the two change together.
+ *
+ * An app only declares it: which field of a `publicSubmit` collection holds
+ * the visitor's address, and a short plain text to say. Brydio decides the
+ * rest — when it is sent, to whom, how often, from whom — so an anonymous
+ * page can never be used to send anybody anything else.
+ */
+export declare const CONFIRM_LIMITS: {
+    readonly subjectChars: 120;
+    readonly messageChars: 600;
+};
+export declare const confirmEmailSchema: z.ZodObject<{
+    field: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    link: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ConfirmEmailDeclared = z.infer<typeof confirmEmailSchema>;
+/** As the host reads it, on `CollectionSpec.confirmEmail`. */
+export interface ConfirmEmailSpec {
+    field: string;
+    subject: string | null;
+    message: string | null;
+    link: boolean;
+}
+export type ConfirmProblemCode = 'data_confirm_submit' | 'data_confirm_field' | 'data_confirm_text';
+export declare function confirmEmailProblems(collection: string, declared: {
+    schema: Record<string, unknown>;
+    publicSubmit?: boolean;
+    confirmEmail?: ConfirmEmailDeclared;
+}): {
+    code: ConfirmProblemCode;
+    collection: string;
+    field?: string;
+    message: string;
+}[];
+export declare function confirmEmailSpec(declared: ConfirmEmailDeclared): ConfirmEmailSpec;

package/src/confirm-email.js

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { FIELD_LIMITS, parseFieldType } from "./field-types.js";
+/**
+ * The confirmation email of a public form (FO04). Mirrors Brydio's
+ * `apps/api/src/apps/manifest/confirm-email.ts`; the two change together.
+ *
+ * An app only declares it: which field of a `publicSubmit` collection holds
+ * the visitor's address, and a short plain text to say. Brydio decides the
+ * rest — when it is sent, to whom, how often, from whom — so an anonymous
+ * page can never be used to send anybody anything else.
+ */
+export const CONFIRM_LIMITS = {
+    subjectChars: 120,
+    messageChars: 600,
+};
+export const confirmEmailSchema = z
+    .object({
+    /** A `string` field of the same collection: the visitor's address. */
+    field: z.string().min(1).max(FIELD_LIMITS.nameChars),
+    subject: z.string().min(1).max(CONFIRM_LIMITS.subjectChars).optional(),
+    /** Plain text; a blank line starts a new paragraph. */
+    message: z.string().min(1).max(CONFIRM_LIMITS.messageChars).optional(),
+    /** One button back to the public page the visitor answered. */
+    link: z.boolean().optional(),
+})
+    .strict();
+/** A link, an address a client would turn into one, or markup. */
+const NOT_PLAIN = /(?:[a-z][a-z0-9+.-]*:\/\/|www\.|[<>]|\]\(|mailto:)/i;
+export function confirmEmailProblems(collection, declared) {
+    const confirm = declared.confirmEmail;
+    if (!confirm)
+        return [];
+    const problems = [];
+    if (!declared.publicSubmit) {
+        problems.push({
+            code: 'data_confirm_submit',
+            collection,
+            message: `${collection} sends a confirmation email but visitors can't submit to it: mark it publicSubmit.`,
+        });
+    }
+    const raw = declared.schema[confirm.field];
+    let kind = null;
+    try {
+        kind = raw === undefined ? null : parseFieldType(raw).kind;
+    }
+    catch {
+        kind = null;
+    }
+    if (kind !== 'string') {
+        problems.push({
+            code: 'data_confirm_field',
+            collection,
+            field: confirm.field,
+            message: `${collection}.confirmEmail.field must name one of its string fields; ${confirm.field} is not.`,
+        });
+    }
+    for (const [key, text] of [
+        ['subject', confirm.subject],
+        ['message', confirm.message],
+    ]) {
+        if (text !== undefined && NOT_PLAIN.test(text)) {
+            problems.push({
+                code: 'data_confirm_text',
+                collection,
+                message: `${collection}.confirmEmail.${key} is plain text: no links, addresses or markup.`,
+            });
+        }
+    }
+    return problems;
+}
+export function confirmEmailSpec(declared) {
+    return {
+        field: declared.field,
+        subject: declared.subject?.trim() || null,
+        message: declared.message?.trim() || null,
+        link: declared.link === true,
+    };
+}

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' | 'ref';
 export interface FieldType {
     kind: FieldKind;
     /** Written with a trailing `?`: may be left out on create. */
@@ -27,6 +27,25 @@ 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;
+    /**
+     * Kept in the plain `fields` column although its kind is not (P5): an
+     * open-schema table's multi-select and link lists, and the field naming a
+     * row's table. Set by the host only, never parsed from a manifest.
+     */
+    plain?: boolean;
+    /**
+     * The most entries a `string[]` holds, when not `FIELD_LIMITS.listEntries`:
+     * a collection's readers or editors field takes `READERS_LIMIT` (P16,
+     * DW06). Set by the host only, never parsed from a manifest.
+     */
+    maxEntries?: number;
 }
 /**
  * The bounds a schema and a record are held to (A3-F01-S03).
@@ -37,7 +56,7 @@ export interface FieldType {
  */
 export declare const FIELD_LIMITS: {
     /** Collections one app may keep. */
-    readonly collections: 20;
+    readonly collections: 40;
     /** Fields one collection may have. */
     readonly fields: 40;
     /** Values one choice may allow. */
@@ -74,9 +93,13 @@ 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);
 }
+/** The longest record id a `ref` field holds. */
+export declare const REF_CHARS = 128;
+/** What a record id looks like: letters, digits, `_` and `-`; never words. */
+export declare const REF_FORMAT: RegExp;
 /**
  * One field's manifest spelling, as a type.
  *
@@ -87,6 +110,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 +160,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];
 } & {};