@brydio/manifest 0.1.0-alpha.34 → 0.1.0-alpha.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brydio/manifest",
-  "version": "0.1.0-alpha.34",
+  "version": "0.1.0-alpha.36",
   "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": "4da27394c9c0243956b58a6dfdc983b691e67ef6",
+  "gitHead": "2d8e769d02c74fe201ce734f6d77def59ea99d53",
   "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/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/index.d.ts

@@ -9,6 +9,8 @@ export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, bundleBytes,
 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 { OPEN_LIMITS, OPEN_TYPES, choicesProblem, definitionOf, definitionTypeProblem, describeField, fieldTypeOf, hasChoices, isPlainOpenType, keyFromName, keyProblem, missingRequired, moveValue, openSchemaProblems, openSpec, openValueProblem, type Moved, type OpenField, type OpenFieldChange, type OpenFieldValue, type OpenProblem, type OpenProblemCode, type OpenSchemaFlag, type OpenType, } from './open-schema.js';
+export { CONFIRM_LIMITS, confirmEmailProblems, confirmEmailSpec, type ConfirmEmailDeclared, type ConfirmEmailSpec, type ConfirmProblemCode, } from './confirm-email.js';
+export { ANONYMOUS_LIMITS, ANONYMOUS_WRITER, anonymousProblems, anonymousSpec, type AnonymousDeclared, type AnonymousProblemCode, type AnonymousSpec, } from './anonymous.js';
 export { 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';

package/src/index.js

@@ -9,6 +9,8 @@ export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, bundleBytes,
 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 { OPEN_LIMITS, OPEN_TYPES, choicesProblem, definitionOf, definitionTypeProblem, describeField, fieldTypeOf, hasChoices, isPlainOpenType, keyFromName, keyProblem, missingRequired, moveValue, openSchemaProblems, openSpec, openValueProblem, } from "./open-schema.js";
+export { CONFIRM_LIMITS, confirmEmailProblems, confirmEmailSpec, } from "./confirm-email.js";
+export { ANONYMOUS_LIMITS, ANONYMOUS_WRITER, anonymousProblems, anonymousSpec, } from "./anonymous.js";
 export { 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";

package/src/migrations.d.ts

@@ -115,7 +115,7 @@ export type SchemaChange = {
  * Hodler's `diffManifests` to show, and none of them moves a record.
  */
 export declare function diffSchemas(from: unknown, to: unknown): SchemaChange[];
-export type MigrationCode = 'migration_step_invalid' | 'migration_step_pointless' | 'migration_default_missing' | 'migration_default_invalid' | 'migration_unexplained' | 'migration_type_changed' | 'migration_value_removed';
+export type MigrationCode = 'migration_step_invalid' | 'migration_step_pointless' | 'migration_default_missing' | 'migration_default_invalid' | 'migration_unexplained' | 'migration_type_changed' | 'migration_value_removed' | 'migration_anonymous_changed';
 export interface MigrationProblem {
     code: MigrationCode;
     collection: string;

package/src/migrations.js

@@ -181,6 +181,35 @@ export function migrationProblems(from, to, steps) {
                 break;
         }
     }
+    problems.push(...anonymityChanges(from, to));
+    return problems;
+}
+/**
+ * A kept collection that becomes anonymous, stops being, or moves its group
+ * (P13): no step can say what its records become. Records kept before kept
+ * their writers and times, and records kept since were read only by group.
+ */
+function anonymityChanges(from, to) {
+    const before = record(record(from).data);
+    const after = record(record(to).data);
+    const problems = [];
+    for (const [name, declared] of Object.entries(after)) {
+        if (!(name in before))
+            continue;
+        const was = record(record(before[name]).anonymous).group;
+        const now = record(record(declared).anonymous).group;
+        if (was === now)
+            continue;
+        problems.push({
+            code: 'migration_anonymous_changed',
+            collection: name,
+            message: was === undefined
+                ? `${name} already keeps records with their writers, so it can't become anonymous; keep anonymous answers in a new collection.`
+                : now === undefined
+                    ? `${name} keeps anonymous answers, so it stays anonymous.`
+                    : `${name}'s anonymous answers stay grouped by ${String(was)}.`,
+        });
+    }
     return problems;
 }
 /** The old schema with the steps applied, and every step that could not apply or changed nothing. */

package/src/schema.d.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { FieldTypeInvalid, type FieldType } from './field-types.js';
 import { type OpenProblemCode } from './open-schema.js';
+import { type ConfirmProblemCode } from './confirm-email.js';
+import { type AnonymousProblemCode, type AnonymousSpec } from './anonymous.js';
 export { COLOUR_TOKENS, FIELD_LIMITS, parseFieldType, RESERVED_FIELDS, structuredFields, type FieldKind, type FieldType, } from './field-types.js';
 /**
  * What an app adds to `.brydio/app.json` to be more than a bundle of servers
@@ -150,6 +152,16 @@ declare const extensionShape: {
         }, z.core.$strict>>;
         publicRead: z.ZodOptional<z.ZodBoolean>;
         publicSubmit: z.ZodOptional<z.ZodBoolean>;
+        confirmEmail: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            subject: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+            link: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        anonymous: z.ZodOptional<z.ZodObject<{
+            group: z.ZodString;
+            minimum: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>>;
     tools: z.ZodOptional<z.ZodObject<{
         generated: z.ZodOptional<z.ZodBoolean>;
@@ -228,7 +240,7 @@ export interface DataProblem {
     field?: string;
     message: string;
 }
-export type DataProblemCode = FieldTypeInvalid['code'] | OpenProblemCode | 'data_too_many_collections' | 'data_too_many_fields' | 'data_collection_name_format' | 'data_field_name_format' | 'data_field_reserved' | 'data_label_format' | 'data_label_taken' | 'data_project_field_twice' | 'data_search_unknown_field' | 'data_search_not_text' | 'grant_collection_missing' | 'grant_tool_missing' | 'custom_name_taken' | 'custom_collection_unknown' | 'custom_input_invalid' | 'placement_key_taken' | 'placement_screen_unknown' | 'placement_home_sizes' | 'placement_sizes_not_home' | 'placement_widget_sizes' | 'placement_tab_retired' | 'placement_public_shape' | 'placement_public_nothing' | 'placement_children_too_deep' | 'placement_create_tool_unknown' | 'placement_create_not_write' | 'secret_name_taken' | 'grant_secrets_missing';
+export type DataProblemCode = FieldTypeInvalid['code'] | OpenProblemCode | ConfirmProblemCode | AnonymousProblemCode | 'data_too_many_collections' | 'data_too_many_fields' | 'data_collection_name_format' | 'data_field_name_format' | 'data_field_reserved' | 'data_label_format' | 'data_label_taken' | 'data_project_field_twice' | 'data_search_unknown_field' | 'data_search_not_text' | 'grant_collection_missing' | 'grant_tool_missing' | 'custom_name_taken' | 'custom_collection_unknown' | 'custom_input_invalid' | 'placement_key_taken' | 'placement_screen_unknown' | 'placement_home_sizes' | 'placement_sizes_not_home' | 'placement_widget_sizes' | 'placement_tab_retired' | 'placement_public_shape' | 'placement_public_nothing' | 'placement_children_too_deep' | 'placement_create_tool_unknown' | 'placement_create_not_write' | 'secret_name_taken' | 'grant_secrets_missing';
 type Additions = z.infer<z.ZodObject<typeof extensionShape>>;
 /**
  * Everything wrong with an app's additions that a type cannot say.
@@ -305,6 +317,16 @@ export declare const manifestExtensionsSchema: z.ZodObject<{
         }, z.core.$strict>>;
         publicRead: z.ZodOptional<z.ZodBoolean>;
         publicSubmit: z.ZodOptional<z.ZodBoolean>;
+        confirmEmail: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            subject: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+            link: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        anonymous: z.ZodOptional<z.ZodObject<{
+            group: z.ZodString;
+            minimum: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>>;
     tools: z.ZodOptional<z.ZodObject<{
         generated: z.ZodOptional<z.ZodBoolean>;
@@ -430,6 +452,16 @@ export declare const storedExtensionsSchema: z.ZodObject<{
         }, z.core.$strict>>;
         publicRead: z.ZodOptional<z.ZodBoolean>;
         publicSubmit: z.ZodOptional<z.ZodBoolean>;
+        confirmEmail: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            subject: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+            link: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        anonymous: z.ZodOptional<z.ZodObject<{
+            group: z.ZodString;
+            minimum: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>>;
     tools: z.ZodOptional<z.ZodObject<{
         generated: z.ZodOptional<z.ZodBoolean>;
@@ -590,6 +622,16 @@ export declare const appManifestSchema: z.ZodObject<{
         }, z.core.$strict>>;
         publicRead: z.ZodOptional<z.ZodBoolean>;
         publicSubmit: z.ZodOptional<z.ZodBoolean>;
+        confirmEmail: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            subject: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+            link: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        anonymous: z.ZodOptional<z.ZodObject<{
+            group: z.ZodString;
+            minimum: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>>;
     tools: z.ZodOptional<z.ZodObject<{
         generated: z.ZodOptional<z.ZodBoolean>;
@@ -754,6 +796,16 @@ export declare const newAppManifestSchema: z.ZodObject<{
         }, z.core.$strict>>;
         publicRead: z.ZodOptional<z.ZodBoolean>;
         publicSubmit: z.ZodOptional<z.ZodBoolean>;
+        confirmEmail: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            subject: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+            link: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        anonymous: z.ZodOptional<z.ZodObject<{
+            group: z.ZodString;
+            minimum: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>>;
     tools: z.ZodOptional<z.ZodObject<{
         generated: z.ZodOptional<z.ZodBoolean>;
@@ -844,6 +896,8 @@ export interface CollectionSpec {
     };
     /** On a companion: the open collection whose fields its records define (P5). */
     definesFieldsOf?: string;
+    /** Answers kept with no writer, read only a whole group of at least `minimum` at a time (P13). */
+    anonymous?: AnonymousSpec;
 }
 /**
  * The singular a collection's tools are named with: the manifest's, else the

package/src/schema.js

@@ -3,6 +3,8 @@ import { MANIFEST_LIMITS, SEMVER_FORMAT, baseManifestSchema as manifestSchema }
 import { COLLECTION_NAME, FIELD_LIMITS, FIELD_NAME, FieldTypeInvalid, isSearchable, isSortable, isStructured, parseFieldType, RESERVED_FIELDS, } from "./field-types.js";
 import { migrationsSchema } from "./migrations.js";
 import { openSchemaProblems } from "./open-schema.js";
+import { confirmEmailProblems, confirmEmailSchema } from "./confirm-email.js";
+import { anonymousProblems, anonymousSchema, anonymousSpec } from "./anonymous.js";
 export { COLOUR_TOKENS, FIELD_LIMITS, parseFieldType, RESERVED_FIELDS, structuredFields, } from "./field-types.js";
 /**
  * What an app adds to `.brydio/app.json` to be more than a bundle of servers
@@ -130,6 +132,22 @@ const collectionSchema = z.object({
      * `publicRead` is set too (P3).
      */
     publicSubmit: z.boolean().optional(),
+    /**
+     * Brydio emails the visitor once after a public submission here (FO04):
+     * `field` names a `string` field holding their address; `subject` and
+     * `message` are short plain text; `link` adds a button back to the page.
+     * Needs `publicSubmit`. Brydio decides when, how often and from whom.
+     */
+    confirmEmail: confirmEmailSchema.optional(),
+    /**
+     * Answers nobody can tie to who gave them (P13): `group` names a
+     * structured field (a number, choice, date, boolean, token or project)
+     * the answers are read by, a whole group at a time and only once it holds
+     * `minimum` answers (at least 5, the default). Brydio keeps no writer,
+     * cuts times to the day, tells no live change, and refuses an update, a
+     * batch, a watch and a create naming its own writer.
+     */
+    anonymous: anonymousSchema.optional(),
 });
 const screenSchema = z.object({
     /**
@@ -359,6 +377,14 @@ export function dataProblems(additions, options = {}) {
         }
         companions.set(declared.openSchema.fields, collection);
     }
+    // A confirmation email names a string field of a collection visitors submit to (FO04).
+    for (const [collection, declared] of collections) {
+        problems.push(...confirmEmailProblems(collection, declared));
+    }
+    // An anonymous collection groups its answers by one of its structured fields, names nobody (P13).
+    for (const [collection, declared] of collections) {
+        problems.push(...anonymousProblems(collection, declared));
+    }
     // What the app keeps must be what it asks to keep (A3-F06-S01): a
     // collection the grants leave out would be data a workspace never agreed to
     // hold, found only when the first write is refused.
@@ -669,6 +695,7 @@ export function collectionsOf(manifest) {
                 ? { openSchema: { fields: declared.openSchema.fields, table: declared.openSchema.table ?? null } }
                 : {}),
             ...(owner ? { definesFieldsOf: owner.name } : {}),
+            ...(declared.anonymous ? { anonymous: anonymousSpec(declared.anonymous) } : {}),
         };
     });
 }