@graview/core 0.1.28 → 0.1.30

package/dist/document/schema.d.ts

@@ -12,8 +12,12 @@ export declare const FIELD_NAME: RegExp;
  * `tended-by.name` would read as a subtraction.
  */
 export declare const EDGE_NAME: RegExp;
-/** `image` and `file` hold what the host stored (FR-162): a `FileValue`, its `href` a path on the host. */
-export declare const FIELD_TYPES: readonly ["string", "text", "number", "integer", "boolean", "date", "datetime", "enum", "list", "url", "email", "image", "file"];
+/**
+ * `image` and `file` hold what the host stored (FR-162): a `FileValue`, its
+ * `href` a path on the host. `phone` and `place` are words drawn as a link to
+ * call and to a map; `duration` is a whole number of minutes, said "1 h 30 min".
+ */
+export declare const FIELD_TYPES: readonly ["string", "text", "number", "integer", "boolean", "date", "datetime", "enum", "list", "url", "email", "image", "file", "app-link", "phone", "place", "duration"];
 export type FieldType = (typeof FIELD_TYPES)[number];
 export declare const FieldSpec: z.ZodMiniObject<{
     type: z.ZodMiniEnum<{
@@ -27,9 +31,13 @@ export declare const FieldSpec: z.ZodMiniObject<{
         email: "email";
         url: "url";
         datetime: "datetime";
-        image: "image";
-        text: "text";
+        duration: "duration";
         list: "list";
+        text: "text";
+        image: "image";
+        phone: "phone";
+        place: "place";
+        "app-link": "app-link";
     }>;
     required: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     description: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -48,11 +56,13 @@ export declare const FieldSpec: z.ZodMiniObject<{
         duration: "duration";
         money: "money";
         percent: "percent";
+        markdown: "markdown";
     }>>;
     min: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
     max: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
     step: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
     renamedFrom: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    repeats: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
 }, z.core.$strict>;
 export type FieldSpec = z.infer<typeof FieldSpec>;
 export declare const EdgeSpec: z.ZodMiniObject<{
@@ -65,6 +75,7 @@ export declare const EdgeSpec: z.ZodMiniObject<{
     inverse: z.ZodMiniOptional<z.ZodMiniString<string>>;
     appendOnly: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     renamedFrom: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    tidying: z.ZodMiniOptional<z.ZodMiniLiteral<"never">>;
 }, z.core.$strict>;
 export type EdgeSpec = z.infer<typeof EdgeSpec>;
 /** A computed field: its expression, or the expression with the words it is shown by (FR-83). */
@@ -90,9 +101,13 @@ export declare const KindSpec: z.ZodMiniObject<{
             email: "email";
             url: "url";
             datetime: "datetime";
-            image: "image";
-            text: "text";
+            duration: "duration";
             list: "list";
+            text: "text";
+            image: "image";
+            phone: "phone";
+            place: "place";
+            "app-link": "app-link";
         }>;
         required: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
         description: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -111,11 +126,13 @@ export declare const KindSpec: z.ZodMiniObject<{
             duration: "duration";
             money: "money";
             percent: "percent";
+            markdown: "markdown";
         }>>;
         min: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         max: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         step: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         renamedFrom: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        repeats: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     }, z.core.$strict>>;
     label: z.ZodMiniOptional<z.ZodMiniString<string>>;
     describe: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -142,6 +159,7 @@ export declare const KindSpec: z.ZodMiniObject<{
         inverse: z.ZodMiniOptional<z.ZodMiniString<string>>;
         appendOnly: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
         renamedFrom: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        tidying: z.ZodMiniOptional<z.ZodMiniLiteral<"never">>;
     }, z.core.$strict>>>;
     computed: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
         expr: z.ZodMiniString<string>;
@@ -151,6 +169,11 @@ export declare const KindSpec: z.ZodMiniObject<{
     fieldRoles: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
     renamedFrom: z.ZodMiniOptional<z.ZodMiniString<string>>;
     people: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    archives: z.ZodMiniOptional<z.ZodMiniLiteral<false>>;
+    tidying: z.ZodMiniOptional<z.ZodMiniEnum<{
+        never: "never";
+        "no-links": "no-links";
+    }>>;
 }, z.core.$strict>;
 export type KindSpec = z.infer<typeof KindSpec>;
 /** A value an effect writes: a literal, `$arg`, `$subject`, `$new`, `$now`, `$today`, or `{ expr }`. */
@@ -210,9 +233,13 @@ export declare const ActSpec: z.ZodMiniObject<{
             email: "email";
             url: "url";
             datetime: "datetime";
-            image: "image";
-            text: "text";
+            duration: "duration";
             list: "list";
+            text: "text";
+            image: "image";
+            phone: "phone";
+            place: "place";
+            "app-link": "app-link";
         }>;
         required: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
         description: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -231,11 +258,13 @@ export declare const ActSpec: z.ZodMiniObject<{
             duration: "duration";
             money: "money";
             percent: "percent";
+            markdown: "markdown";
         }>>;
         min: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         max: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         step: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
         renamedFrom: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        repeats: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     }, z.core.$strict>>>;
     effects: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
         create: z.ZodMiniString<string>;
@@ -295,17 +324,13 @@ export declare const GrantSpec: z.ZodMiniObject<{
     self: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     ownEnd: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
 }, z.core.$strict>;
-/**
- * Who sees which kinds — the framework's `Sight`, one meaning (FR-02).
- * Absent: everyone sees everything. Present: a kind no sight names is seen
- * by nobody but the system (a host that gives its owners everything serves
- * them as the system, or names them in a sight).
- */
 export declare const SightSpec: z.ZodMiniObject<{
     roles: z.ZodMiniUnion<readonly [z.ZodMiniArray<z.ZodMiniString<string>>, z.ZodMiniLiteral<"*">]>;
     kinds: z.ZodMiniArray<z.ZodMiniString<string>>;
     own: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     via: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    fields: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    hide: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
 }, z.core.$strict>;
 export type SightSpec = z.infer<typeof SightSpec>;
 export declare const PolicySpec: z.ZodMiniObject<{
@@ -322,13 +347,16 @@ export declare const PolicySpec: z.ZodMiniObject<{
         kinds: z.ZodMiniArray<z.ZodMiniString<string>>;
         own: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
         via: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        fields: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+        hide: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type PolicySpec = z.infer<typeof PolicySpec>;
 /**
  * The installation's look and its money: an accent color the palette is
  * derived from, and the currency and locale a sum is said in wherever a
- * block names none (FR-100). Any of them may stand alone.
+ * block names none (FR-100) — the locale its days, times and numbers are
+ * said in too (FR-178), "en-US" when absent. Any of them may stand alone.
  */
 export declare const BrandSpec: z.ZodMiniObject<{
     accent: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -339,7 +367,9 @@ export declare const BrandSpec: z.ZodMiniObject<{
         src: z.ZodMiniString<string>;
         alt: z.ZodMiniOptional<z.ZodMiniString<string>>;
     }, z.core.$strict>]>>;
-    favicon: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    favicon: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+        emoji: z.ZodMiniString<string>;
+    }, z.core.$strict>]>>;
     typography: z.ZodMiniOptional<z.ZodMiniObject<{
         display: z.ZodMiniOptional<z.ZodMiniString<string>>;
         body: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -370,6 +400,28 @@ export declare const PagesSpec: z.ZodMiniObject<{
     primary: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
     scene: z.ZodMiniOptional<z.ZodMiniString<string>>;
     pages: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    lists: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+        filters: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+        sort: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+            by: z.ZodMiniString<string>;
+            direction: z.ZodMiniOptional<z.ZodMiniEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+            then: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+                by: z.ZodMiniString<string>;
+                direction: z.ZodMiniOptional<z.ZodMiniEnum<{
+                    desc: "desc";
+                    asc: "asc";
+                }>>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>]>>;
+        group: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+            by: z.ZodMiniString<string>;
+            order: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+            closed: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
 }, z.core.$loose>;
 export declare const DocumentSpec: z.ZodMiniObject<{
     $schema: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -394,9 +446,13 @@ export declare const DocumentSpec: z.ZodMiniObject<{
                 email: "email";
                 url: "url";
                 datetime: "datetime";
-                image: "image";
-                text: "text";
+                duration: "duration";
                 list: "list";
+                text: "text";
+                image: "image";
+                phone: "phone";
+                place: "place";
+                "app-link": "app-link";
             }>;
             required: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
             description: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -415,11 +471,13 @@ export declare const DocumentSpec: z.ZodMiniObject<{
                 duration: "duration";
                 money: "money";
                 percent: "percent";
+                markdown: "markdown";
             }>>;
             min: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
             max: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
             step: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
             renamedFrom: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            repeats: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
         }, z.core.$strict>>;
         label: z.ZodMiniOptional<z.ZodMiniString<string>>;
         describe: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -446,6 +504,7 @@ export declare const DocumentSpec: z.ZodMiniObject<{
             inverse: z.ZodMiniOptional<z.ZodMiniString<string>>;
             appendOnly: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
             renamedFrom: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            tidying: z.ZodMiniOptional<z.ZodMiniLiteral<"never">>;
         }, z.core.$strict>>>;
         computed: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
             expr: z.ZodMiniString<string>;
@@ -455,6 +514,11 @@ export declare const DocumentSpec: z.ZodMiniObject<{
         fieldRoles: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
         renamedFrom: z.ZodMiniOptional<z.ZodMiniString<string>>;
         people: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+        archives: z.ZodMiniOptional<z.ZodMiniLiteral<false>>;
+        tidying: z.ZodMiniOptional<z.ZodMiniEnum<{
+            never: "never";
+            "no-links": "no-links";
+        }>>;
     }, z.core.$strict>>;
     computed: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
         expr: z.ZodMiniString<string>;
@@ -490,9 +554,13 @@ export declare const DocumentSpec: z.ZodMiniObject<{
                 email: "email";
                 url: "url";
                 datetime: "datetime";
-                image: "image";
-                text: "text";
+                duration: "duration";
                 list: "list";
+                text: "text";
+                image: "image";
+                phone: "phone";
+                place: "place";
+                "app-link": "app-link";
             }>;
             required: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
             description: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -511,11 +579,13 @@ export declare const DocumentSpec: z.ZodMiniObject<{
                 duration: "duration";
                 money: "money";
                 percent: "percent";
+                markdown: "markdown";
             }>>;
             min: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
             max: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
             step: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
             renamedFrom: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            repeats: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
         }, z.core.$strict>>>;
         effects: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
             create: z.ZodMiniString<string>;
@@ -573,10 +643,36 @@ export declare const DocumentSpec: z.ZodMiniObject<{
             kinds: z.ZodMiniArray<z.ZodMiniString<string>>;
             own: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
             via: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            fields: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+            hide: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
     modules: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
-    lenses: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>>;
+    lenses: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+        create: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+        options: z.ZodMiniOptional<z.ZodMiniObject<{
+            sort: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+                by: z.ZodMiniString<string>;
+                direction: z.ZodMiniOptional<z.ZodMiniEnum<{
+                    desc: "desc";
+                    asc: "asc";
+                }>>;
+            }, z.core.$strict>]>>;
+            columnSort: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+                by: z.ZodMiniString<string>;
+                direction: z.ZodMiniOptional<z.ZodMiniEnum<{
+                    desc: "desc";
+                    asc: "asc";
+                }>>;
+            }, z.core.$strict>]>>;
+            horizon: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniNumber<number>, z.ZodMiniObject<{
+                years: z.ZodMiniNumber<number>;
+                title: z.ZodMiniString<string>;
+                from: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                to: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+            }, z.core.$loose>]>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
     pages: z.ZodMiniOptional<z.ZodMiniObject<{
         order: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
         hide: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
@@ -584,6 +680,28 @@ export declare const DocumentSpec: z.ZodMiniObject<{
         primary: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
         scene: z.ZodMiniOptional<z.ZodMiniString<string>>;
         pages: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        lists: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+            filters: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+            sort: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+                by: z.ZodMiniString<string>;
+                direction: z.ZodMiniOptional<z.ZodMiniEnum<{
+                    desc: "desc";
+                    asc: "asc";
+                }>>;
+                then: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+                    by: z.ZodMiniString<string>;
+                    direction: z.ZodMiniOptional<z.ZodMiniEnum<{
+                        desc: "desc";
+                        asc: "asc";
+                    }>>;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>]>>;
+            group: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+                by: z.ZodMiniString<string>;
+                order: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+                closed: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>>;
     }, z.core.$loose>>;
     views: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
         card: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnknown>>;
@@ -599,7 +717,9 @@ export declare const DocumentSpec: z.ZodMiniObject<{
             src: z.ZodMiniString<string>;
             alt: z.ZodMiniOptional<z.ZodMiniString<string>>;
         }, z.core.$strict>]>>;
-        favicon: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        favicon: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+            emoji: z.ZodMiniString<string>;
+        }, z.core.$strict>]>>;
         typography: z.ZodMiniOptional<z.ZodMiniObject<{
             display: z.ZodMiniOptional<z.ZodMiniString<string>>;
             body: z.ZodMiniOptional<z.ZodMiniString<string>>;

package/dist/document/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/document/schema.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/document/schema.ts"],"names":[],"mappings":"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"}

package/dist/document/schema.js

@@ -1,4 +1,5 @@
 import * as z from "../schema/zod.js";
+import { LINKED_TARGET } from "../schema/linked.js";
 /*
  * THE GRAVIEW DECLARATION DOCUMENT, v1 — as data a stranger can hand us.
  *
@@ -32,22 +33,26 @@ const notInherited = z.refine((n) => !inherited(n), "every object already has th
 const sized = (min, max) => [...(min === undefined ? [] : [z.minLength(min)]), ...(max === undefined ? [] : [z.maxLength(max)])];
 const str = (min, max) => z.string().check(...sized(min, max));
 const some = (of, min, max) => z.array(of).check(...sized(min, max));
-const name = (what) => z.string().check(z.regex(NAME, `${what} names are lower-case words joined by hyphens, like "booked-vendor"`));
+const name = (what) => z.string().check(z.regex(NAME, `${what} names are kebab-case, lower-case words joined by hyphens like "tool-note" (field and relation names are camelCase, like "supersededBy")`));
 /**
  * A RELATION'S NAME may be kebab-case or one camelCase word. camelCase is
  * recommended: a rule can then walk it bare (`tendedBy.name`), where
  * `tended-by.name` would read as a subtraction.
  */
 export const EDGE_NAME = /^(?:[a-z][a-z0-9]*(?:-[a-z0-9]+)*|[a-z][A-Za-z0-9]*)$/;
-const edgeName = z.string().check(z.regex(EDGE_NAME, 'relation names are one camelCase word, like "tendedBy"'), notInherited);
+const edgeName = z.string().check(z.regex(EDGE_NAME, 'relation names are one camelCase word, like "supersededBy" (kind names are kebab-case, like "tool-note")'), notInherited);
 const fieldName = z
     .string()
-    .check(z.regex(FIELD_NAME, 'field names are one word or camelCase, like "dueDate" — rules say them bare'), z.refine((n) => !RESERVED_FIELDS.has(n), 'a field cannot be called "id" or "kind" — the framework keeps those; try "type" or "category"'), notInherited);
+    .check(z.regex(FIELD_NAME, 'field names are one word or camelCase, like "dueDate", so rules say them bare (kind names are kebab-case, like "tool-note")'), z.refine((n) => !RESERVED_FIELDS.has(n), 'a field cannot be called "id" or "kind" — the framework keeps those; try "type" or "category"'), notInherited);
 const sentence = str(1, 500);
 const expression = str(1, 2000);
 const template = str(1, 300);
-/** `image` and `file` hold what the host stored (FR-162): a `FileValue`, its `href` a path on the host. */
-export const FIELD_TYPES = ["string", "text", "number", "integer", "boolean", "date", "datetime", "enum", "list", "url", "email", "image", "file"];
+/**
+ * `image` and `file` hold what the host stored (FR-162): a `FileValue`, its
+ * `href` a path on the host. `phone` and `place` are words drawn as a link to
+ * call and to a map; `duration` is a whole number of minutes, said "1 h 30 min".
+ */
+export const FIELD_TYPES = ["string", "text", "number", "integer", "boolean", "date", "datetime", "enum", "list", "url", "email", "image", "file", "app-link", "phone", "place", "duration"];
 export const FieldSpec = z
     .strictObject({
     type: z.enum(FIELD_TYPES),
@@ -59,13 +64,20 @@ export const FieldSpec = z
     of: z.optional(z.enum(["string", "number", "date", "image", "file"])),
     default: z.optional(z.unknown()),
     unit: z.optional(str(undefined, 12)),
-    format: z.optional(z.enum(["money", "percent", "duration"])),
+    /** How a number is shown (`money`, `percent`, `duration`), or that a `text` field is written in Markdown (FR-180; the checker's `field-format` says which goes where). */
+    format: z.optional(z.enum(["money", "percent", "duration", "markdown"])),
     /** A number's range (FR-114): the least and the most it may be, and the step its values are whole multiples of (JSON Schema's `multipleOf`). */
     min: z.optional(z.number()),
     max: z.optional(z.number()),
     step: z.optional(z.number()),
     /** The name this field had in the previous version: its values move instead of being dropped. */
     renamedFrom: z.optional(z.string().check(z.regex(FIELD_NAME))),
+    /**
+     * A date that repeats (`repeat.ts`): a record may keep, beside the date
+     * (its first occurrence), how it repeats under the date's name and
+     * `Repeat` — `"startsAtRepeat": { "every": "week", "on": ["tue"] }`.
+     */
+    repeats: z.optional(z.boolean()),
 })
     .check(z.superRefine((f, ctx) => {
     if (f.type === "enum" && !f.options)
@@ -74,15 +86,26 @@ export const FieldSpec = z
         ctx.addIssue({ code: "custom", message: '"options" belongs only on an enum field', path: ["options"] });
     if (f.type !== "list" && f.of)
         ctx.addIssue({ code: "custom", message: '"of" belongs only on a list field', path: ["of"] });
+    if (f.repeats && f.type !== "date" && f.type !== "datetime")
+        ctx.addIssue({ code: "custom", message: '"repeats" belongs only on a date or datetime field', path: ["repeats"] });
 }));
+/**
+ * WHERE A RELATION GOES: a kind of this document (`"house"`), or a kind in
+ * ANOTHER APP the viewer can open (FR-171) — `@` + the app's address + `/`
+ * + its kind: `"@nick/house/house"`, `"@app_kf5eydr9z58jzf/house"`. A link
+ * to another app's record picks one there and leaves that app untouched.
+ */
+const edgeTarget = z.string().check(z.regex(new RegExp(`${NAME.source}|${LINKED_TARGET.source}`), 'a relation goes to a kind of this document, like "house", or of another app, like "@nick/house/house"'));
 export const EdgeSpec = z.strictObject({
-    to: z.union([some(name("kind"), 1), z.literal("*")]),
+    to: z.union([some(edgeTarget, 1), z.literal("*")]),
     cardinality: z.optional(z.enum(["one", "many"])),
     description: z.optional(sentence),
     inverse: z.optional(str(1, 80)),
     appendOnly: z.optional(z.boolean()),
     /** The name this relation had in the previous version: its links move. */
     renamedFrom: z.optional(z.string()),
+    /** `"never"`: no automated author makes or breaks this relation on its own (`@graview/core/tidying`). */
+    tidying: z.optional(z.literal("never")),
 });
 /** A computed field: its expression, or the expression with the words it is shown by (FR-83). */
 export const ComputedSpec = z.union([expression, z.strictObject({ expr: expression, label: z.optional(str(1, 60)), description: z.optional(sentence) })]);
@@ -126,6 +149,10 @@ export const KindSpec = z.strictObject({
     renamedFrom: z.optional(z.string().check(z.regex(NAME))),
     /** This kind stands for the people: a record of it whose id is a member's principal id is that member (`$me`, `self`, `own`, `via`, `ownEnd`). */
     people: z.optional(z.boolean()),
+    /** `false`: its records are kept or removed, never archived — the kind is given no `archive-`, `unarchive-` or `merge-<kind>` (FR-173). */
+    archives: z.optional(z.literal(false)),
+    /** What the app's own actor may do to its records on its own: `"never"` nothing, `"no-links"` all but link and unlink them (`@graview/core/tidying`). */
+    tidying: z.optional(z.enum(["never", "no-links"])),
 });
 /** A value an effect writes: a literal, `$arg`, `$subject`, `$new`, `$now`, `$today`, or `{ expr }`. */
 export const ValueSpec = z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.unknown()), z.strictObject({ expr: expression })]);
@@ -196,6 +223,7 @@ export const GrantSpec = z.strictObject({
  * by nobody but the system (a host that gives its owners everything serves
  * them as the system, or names them in a sight).
  */
+const fieldNames = z.optional(some(name("field"), 1));
 export const SightSpec = z.strictObject({
     roles: z.union([some(name("role"), 1), z.literal("*")]),
     kinds: some(name("kind"), 1),
@@ -203,6 +231,10 @@ export const SightSpec = z.strictObject({
     own: z.optional(z.boolean()),
     /** Only the records this relation joins to the principal's own record of the people kind. */
     via: z.optional(edgeName),
+    /** Only these fields of the records it shows (Roadmap f-field-sight); sights add up. */
+    fields: fieldNames,
+    /** Every field but these of the records it shows: kept from the roles, on every surface, and not theirs to write. */
+    hide: fieldNames,
 });
 export const PolicySpec = z.strictObject({
     grants: z.array(GrantSpec),
@@ -211,7 +243,8 @@ export const PolicySpec = z.strictObject({
 /**
  * The installation's look and its money: an accent color the palette is
  * derived from, and the currency and locale a sum is said in wherever a
- * block names none (FR-100). Any of them may stand alone.
+ * block names none (FR-100) — the locale its days, times and numbers are
+ * said in too (FR-178), "en-US" when absent. Any of them may stand alone.
  */
 export const BrandSpec = z.strictObject({
     accent: z.optional(z.string().check(z.regex(/^#[0-9a-fA-F]{6}$/, 'an accent is a color like "#c2577a"'))),
@@ -226,7 +259,8 @@ export const BrandSpec = z.strictObject({
      * in, how round and how roomy, a hue per kind, and the scheme it prefers.
      */
     logo: z.optional(z.union([str(1, MARK_MAX), z.strictObject({ src: str(1, MARK_MAX), alt: z.optional(str(1, 120)) })])),
-    favicon: z.optional(str(1, MARK_MAX)),
+    // A page icon: a mark as the logo is one, or `{ "emoji": "🏡" }` — one standard emoji, the app's mark where it has no logo (`brand-emoji`).
+    favicon: z.optional(z.union([str(1, MARK_MAX), z.strictObject({ emoji: z.string() })])),
     typography: z.optional(z.strictObject({ display: z.optional(str(1, 200)), body: z.optional(str(1, 200)), mono: z.optional(str(1, 200)) })),
     shape: z.optional(z.strictObject({
         radius: z.optional(z.number().check(z.minimum(0), z.maximum(32))),
@@ -236,12 +270,43 @@ export const BrandSpec = z.strictObject({
     scheme: z.optional(z.enum(["light", "dark", "auto"])),
 });
 const loose = z.record(z.string(), z.unknown());
+/** A grid lens's order (`grid-sort.ts`): a field, or { by, direction }. */
+const GridSortSpec = z.union([str(1, 120), z.strictObject({ by: str(1, 120), direction: z.optional(z.enum(["asc", "desc"])) })]);
+const Year = z.number().check(z.int(), z.minimum(1), z.maximum(9999));
+/**
+ * A lens: checked by `graview check` against the lenses the framework ships
+ * (`declaredLenses`), so loose here but for what its page is: `create`,
+ * false where the place's page leaves off the forms that begin its kind —
+ * and the options whose shape is the same on every lens that takes them:
+ * a coverage's `sort` and `columnSort` and a status board's `sort` (the
+ * order of its rows, columns or cards), and a calendar's `horizon` (its
+ * span of years, reaching its records' first and last unless `from` and
+ * `to` pin it).
+ */
+const LensSpec = z.looseObject({
+    create: z.optional(z.boolean()),
+    options: z.optional(z.looseObject({
+        sort: z.optional(GridSortSpec),
+        columnSort: z.optional(GridSortSpec),
+        horizon: z.optional(z.union([z.number().check(z.int(), z.minimum(1), z.maximum(200)), z.looseObject({ years: z.number().check(z.int(), z.minimum(1), z.maximum(200)), title: str(1, 80), from: z.optional(Year), to: z.optional(Year) })])),
+    })),
+});
 /** A kind's view specs: which slots it fills. The blocks are checked in views.ts, sentence by sentence. */
 const ViewSpecsSpec = z.strictObject({
     card: z.optional(z.array(z.unknown())),
     row: z.optional(z.array(z.unknown())),
     page: z.optional(z.array(z.unknown())),
 });
+/** A kind's list's declared order (`pages.lists.<kind>.sort`): a key, or a key with a direction and a tiebreak. */
+const ListSortSpec = () => {
+    const direction = z.optional(z.enum(["asc", "desc"]));
+    return z.union([
+        str(1, 120),
+        z.strictObject({ by: str(1, 120), direction, then: z.optional(z.union([str(1, 120), z.strictObject({ by: str(1, 120), direction })])) }),
+    ]);
+};
+/** A kind's list's declared grouping (`pages.lists.<kind>.group`): a field, or a field with its groups' order and the closed ones. */
+const ListGroupSpec = () => z.union([str(1, 120), z.strictObject({ by: str(1, 120), order: z.optional(some(str(1, 80), undefined, 40)), closed: z.optional(some(str(1, 80), undefined, 40)) })]);
 /**
  * THE ARRANGEMENT (FR-80): the kinds in order, the kinds the home leaves
  * off, the place the app opens on. Loose enough that a document which
@@ -261,6 +326,17 @@ export const PagesSpec = z.looseObject({
      */
     scene: z.optional(str(1, 40)),
     pages: z.optional(str(1, 40)),
+    /*
+     * What each kind's list offers to filter by, by kind (`pages.lists.request.filters`): fields, relations,
+     * `is`, and `<relation>.<field>` for a choice at a relation's far end. Its choice fields stand as chips.
+     */
+    lists: z.optional(z.record(z.string(), z.strictObject({
+        filters: z.optional(some(str(1, 120), undefined, 40)),
+        /* The order it opens in: a field, a computed field or `label`, lowest first — or { by, direction, then }. */
+        sort: z.optional(ListSortSpec()),
+        /* How it opens grouped: a choice or yes-or-no field — or { by, order, closed }, the closed groups last and shut. */
+        group: z.optional(ListGroupSpec()),
+    }))),
 });
 export const DocumentSpec = z.strictObject({
     /* Where an editor finds this shape as JSON Schema (`@graview/core/document.schema.json`); the compiler reads past it. */
@@ -285,7 +361,7 @@ export const DocumentSpec = z.strictObject({
     roles: z.optional(z.array(name("role"))),
     policy: z.optional(PolicySpec),
     modules: z.optional(loose),
-    lenses: z.optional(z.array(loose)),
+    lenses: z.optional(z.array(LensSpec)),
     pages: z.optional(PagesSpec),
     /** Each kind's views by kind, and `home`: the home view, a list of blocks about no one record (FR-81). */
     views: z.optional(z.record(z.string(), z.union([ViewSpecsSpec, z.array(z.unknown())]))),