@brydio/manifest 0.1.0-alpha.5 → 0.1.0-alpha.50

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.5",
+  "version": "0.1.0-alpha.50",
   "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": "f9e99418eb18cedd529d7a62fe6c037396c50e3f",
+  "gitHead": "796e805c8326bbaee6381c18d59c38e3d35bd683",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",

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

@@ -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/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).
@@ -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];
 } & {};

package/src/field-types.js

@@ -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. */