@graview/core 0.1.0 → 0.1.2

package/dist/document/schema.d.ts

@@ -0,0 +1,459 @@
+import { z } from "zod";
+export declare const FORMAT = "graview-document";
+export declare const FORMAT_VERSION = 1;
+export declare const MAX_DOCUMENT_BYTES: number;
+/** kebab-case: kinds, acts, rules, edges, roles, modules. */
+export declare const NAME: RegExp;
+/** Field names are identifiers so a rule can say them bare: `quote != null`. */
+export declare const FIELD_NAME: RegExp;
+/**
+ * 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 declare const EDGE_NAME: RegExp;
+export declare const FIELD_TYPES: readonly ["string", "text", "number", "integer", "boolean", "date", "datetime", "enum", "list", "url", "email"];
+export type FieldType = (typeof FIELD_TYPES)[number];
+export declare const FieldSpec: z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        date: "date";
+        enum: "enum";
+        list: "list";
+        email: "email";
+        integer: "integer";
+        datetime: "datetime";
+        url: "url";
+    }>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    of: z.ZodOptional<z.ZodEnum<{
+        string: "string";
+        number: "number";
+        date: "date";
+    }>>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    unit: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<{
+        money: "money";
+        percent: "percent";
+        duration: "duration";
+    }>>;
+    renamedFrom: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FieldSpec = z.infer<typeof FieldSpec>;
+export declare const EdgeSpec: z.ZodObject<{
+    to: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+    cardinality: z.ZodOptional<z.ZodEnum<{
+        one: "one";
+        many: "many";
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    appendOnly: z.ZodOptional<z.ZodBoolean>;
+    renamedFrom: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type EdgeSpec = z.infer<typeof EdgeSpec>;
+export declare const KindSpec: z.ZodObject<{
+    noun: z.ZodOptional<z.ZodString>;
+    plural: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            text: "text";
+            date: "date";
+            enum: "enum";
+            list: "list";
+            email: "email";
+            integer: "integer";
+            datetime: "datetime";
+            url: "url";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        of: z.ZodOptional<z.ZodEnum<{
+            string: "string";
+            number: "number";
+            date: "date";
+        }>>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodEnum<{
+            money: "money";
+            percent: "percent";
+            duration: "duration";
+        }>>;
+        renamedFrom: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    label: z.ZodOptional<z.ZodString>;
+    describe: z.ZodOptional<z.ZodString>;
+    lifecycle: z.ZodOptional<z.ZodObject<{
+        field: z.ZodString;
+        retired: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>>;
+    figure: z.ZodOptional<z.ZodString>;
+    edges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        to: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+        cardinality: z.ZodOptional<z.ZodEnum<{
+            one: "one";
+            many: "many";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+        inverse: z.ZodOptional<z.ZodString>;
+        appendOnly: z.ZodOptional<z.ZodBoolean>;
+        renamedFrom: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    renamedFrom: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type KindSpec = z.infer<typeof KindSpec>;
+/** A value an effect writes: a literal, `$arg`, `$subject`, `$new`, `$now`, `$today`, or `{ expr }`. */
+export declare const ValueSpec: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+    expr: z.ZodString;
+}, z.core.$strict>]>;
+export type ValueSpec = z.infer<typeof ValueSpec>;
+export declare const EffectSpec: z.ZodUnion<readonly [z.ZodObject<{
+    create: z.ZodString;
+    as: z.ZodOptional<z.ZodString>;
+    set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+        expr: z.ZodString;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>, z.ZodObject<{
+    set: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+        expr: z.ZodString;
+    }, z.core.$strict>]>>;
+    target: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    connect: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    sever: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    remove: z.ZodString;
+}, z.core.$strict>]>;
+export type EffectSpec = z.infer<typeof EffectSpec>;
+export declare const ActSpec: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+    on: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    creates: z.ZodOptional<z.ZodString>;
+    sets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+        expr: z.ZodString;
+    }, z.core.$strict>]>>>;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    connects: z.ZodOptional<z.ZodString>;
+    severs: z.ZodOptional<z.ZodString>;
+    removes: z.ZodOptional<z.ZodLiteral<true>>;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            text: "text";
+            date: "date";
+            enum: "enum";
+            list: "list";
+            email: "email";
+            integer: "integer";
+            datetime: "datetime";
+            url: "url";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        of: z.ZodOptional<z.ZodEnum<{
+            string: "string";
+            number: "number";
+            date: "date";
+        }>>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        unit: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodEnum<{
+            money: "money";
+            percent: "percent";
+            duration: "duration";
+        }>>;
+        renamedFrom: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    effects: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        create: z.ZodString;
+        as: z.ZodOptional<z.ZodString>;
+        set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+            expr: z.ZodString;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        set: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+            expr: z.ZodString;
+        }, z.core.$strict>]>>;
+        target: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        connect: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        sever: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        remove: z.ZodString;
+    }, z.core.$strict>]>>>;
+    allowedWhen: z.ZodOptional<z.ZodString>;
+    refusal: z.ZodOptional<z.ZodString>;
+    destructive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ActSpec = z.infer<typeof ActSpec>;
+export declare const RepairSpec: z.ZodObject<{
+    act: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+        expr: z.ZodString;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>;
+export declare const RuleSpec: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    over: z.ZodUnion<readonly [z.ZodLiteral<"graph">, z.ZodString]>;
+    when: z.ZodOptional<z.ZodString>;
+    require: z.ZodString;
+    says: z.ZodOptional<z.ZodString>;
+    repairs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        act: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+            expr: z.ZodString;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type RuleSpec = z.infer<typeof RuleSpec>;
+export declare const GrantSpec: z.ZodObject<{
+    roles: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+    mutations: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+    kinds: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>>;
+    describe: z.ZodOptional<z.ZodString>;
+    self: z.ZodOptional<z.ZodBoolean>;
+}, 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.ZodObject<{
+    roles: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+    kinds: z.ZodArray<z.ZodString>;
+    own: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type SightSpec = z.infer<typeof SightSpec>;
+export declare const PolicySpec: z.ZodObject<{
+    grants: z.ZodArray<z.ZodObject<{
+        roles: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+        mutations: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+        kinds: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>>;
+        describe: z.ZodOptional<z.ZodString>;
+        self: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    sees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        roles: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+        kinds: z.ZodArray<z.ZodString>;
+        own: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type PolicySpec = z.infer<typeof PolicySpec>;
+export declare const BrandSpec: z.ZodObject<{
+    accent: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const DocumentSpec: z.ZodObject<{
+    format: z.ZodLiteral<"graview-document">;
+    formatVersion: z.ZodLiteral<1>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodNumber>;
+    kinds: z.ZodRecord<z.ZodString, z.ZodObject<{
+        noun: z.ZodOptional<z.ZodString>;
+        plural: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                text: "text";
+                date: "date";
+                enum: "enum";
+                list: "list";
+                email: "email";
+                integer: "integer";
+                datetime: "datetime";
+                url: "url";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            of: z.ZodOptional<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                date: "date";
+            }>>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            unit: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodEnum<{
+                money: "money";
+                percent: "percent";
+                duration: "duration";
+            }>>;
+            renamedFrom: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        label: z.ZodOptional<z.ZodString>;
+        describe: z.ZodOptional<z.ZodString>;
+        lifecycle: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            retired: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strict>>;
+        figure: z.ZodOptional<z.ZodString>;
+        edges: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            to: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+            cardinality: z.ZodOptional<z.ZodEnum<{
+                one: "one";
+                many: "many";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+            inverse: z.ZodOptional<z.ZodString>;
+            appendOnly: z.ZodOptional<z.ZodBoolean>;
+            renamedFrom: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        renamedFrom: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    acts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        fromTheOtherEnd: z.ZodOptional<z.ZodString>;
+        on: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        creates: z.ZodOptional<z.ZodString>;
+        sets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+            expr: z.ZodString;
+        }, z.core.$strict>]>>>;
+        writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        connects: z.ZodOptional<z.ZodString>;
+        severs: z.ZodOptional<z.ZodString>;
+        removes: z.ZodOptional<z.ZodLiteral<true>>;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                text: "text";
+                date: "date";
+                enum: "enum";
+                list: "list";
+                email: "email";
+                integer: "integer";
+                datetime: "datetime";
+                url: "url";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            of: z.ZodOptional<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                date: "date";
+            }>>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            unit: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodEnum<{
+                money: "money";
+                percent: "percent";
+                duration: "duration";
+            }>>;
+            renamedFrom: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        effects: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            create: z.ZodString;
+            as: z.ZodOptional<z.ZodString>;
+            set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+                expr: z.ZodString;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            set: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+                expr: z.ZodString;
+            }, z.core.$strict>]>>;
+            target: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            connect: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            sever: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            remove: z.ZodString;
+        }, z.core.$strict>]>>>;
+        allowedWhen: z.ZodOptional<z.ZodString>;
+        refusal: z.ZodOptional<z.ZodString>;
+        destructive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        over: z.ZodUnion<readonly [z.ZodLiteral<"graph">, z.ZodString]>;
+        when: z.ZodOptional<z.ZodString>;
+        require: z.ZodString;
+        says: z.ZodOptional<z.ZodString>;
+        repairs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            act: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodObject<{
+                expr: z.ZodString;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    policy: z.ZodOptional<z.ZodObject<{
+        grants: z.ZodArray<z.ZodObject<{
+            roles: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+            mutations: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+            kinds: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>>;
+            describe: z.ZodOptional<z.ZodString>;
+            self: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        sees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            roles: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"*">]>;
+            kinds: z.ZodArray<z.ZodString>;
+            own: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    modules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    lenses: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    pages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    views: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        card: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        row: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        page: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    brand: z.ZodOptional<z.ZodObject<{
+        accent: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    settings: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    migrations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>;
+export type GraviewDocument = z.infer<typeof DocumentSpec>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/document/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,MAAM,qBAAqB,CAAC;AACzC,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,eAAO,MAAM,kBAAkB,QAAa,CAAC;AAE7C,6DAA6D;AAC7D,eAAO,MAAM,IAAI,QAAoC,CAAC;AACtD,gFAAgF;AAChF,eAAO,MAAM,UAAU,QAAwB,CAAC;AAIhD;;;;GAIG;AACH,eAAO,MAAM,SAAS,QAA0D,CAAC;AAUjF,eAAO,MAAM,WAAW,iHAAkH,CAAC;AAC3I,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoBlB,CAAC;AACL,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD,eAAO,MAAM,QAAQ;;;;;;;;;;kBAUV,CAAC;AACZ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAcV,CAAC;AACZ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,wGAAwG;AACxG,eAAO,MAAM,SAAS;;oBAA0H,CAAC;AACjJ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAIlD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;oBAMrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmBT,CAAC;AACZ,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAC;AAE9C,eAAO,MAAM,UAAU;;;;;;kBAMZ,CAAC;AAEZ,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;kBAUV,CAAC;AACZ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,SAAS;;;;;;kBAQX,CAAC;AAEZ;;;;;GAKG;AACH,eAAO,MAAM,SAAS;;;;kBAOX,CAAC;AACZ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD,eAAO,MAAM,UAAU;;;;;;;;;;;;;kBAKZ,CAAC;AACZ,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD,eAAO,MAAM,SAAS;;;kBAKX,CAAC;AAaZ,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoBd,CAAC;AACZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/document/schema.js

@@ -0,0 +1,197 @@
+import { z } from "zod";
+/*
+ * THE GRAVIEW DECLARATION DOCUMENT, v1 — as data a stranger can hand us.
+ *
+ * docs/declaration-document.md is the prose; this is the shape. Every key is
+ * closed (`strict`): an unknown key is a finding, not something quietly
+ * ignored, because a model that misspells `requires` for `require` should be
+ * told, not given an app whose rule holds nothing.
+ */
+export const FORMAT = "graview-document";
+export const FORMAT_VERSION = 1;
+export const MAX_DOCUMENT_BYTES = 256 * 1024;
+/** kebab-case: kinds, acts, rules, edges, roles, modules. */
+export const NAME = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+/** Field names are identifiers so a rule can say them bare: `quote != null`. */
+export const FIELD_NAME = /^[a-z][A-Za-z0-9]*$/;
+const RESERVED_FIELDS = new Set(["id", "kind"]);
+const name = (what) => z.string().regex(NAME, `${what} names are lower-case words joined by hyphens, like "booked-vendor"`);
+/**
+ * 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().regex(EDGE_NAME, 'relation names are one camelCase word, like "tendedBy"');
+const fieldName = z
+    .string()
+    .regex(FIELD_NAME, 'field names are one word or camelCase, like "dueDate" — rules say them bare')
+    .refine((n) => !RESERVED_FIELDS.has(n), 'a field cannot be called "id" or "kind" — the framework keeps those; try "type" or "category"');
+const sentence = z.string().min(1).max(500);
+const expression = z.string().min(1).max(2000);
+const template = z.string().min(1).max(300);
+export const FIELD_TYPES = ["string", "text", "number", "integer", "boolean", "date", "datetime", "enum", "list", "url", "email"];
+export const FieldSpec = z
+    .object({
+    type: z.enum(FIELD_TYPES),
+    required: z.boolean().optional(),
+    description: sentence.optional(),
+    /** What the field is called on screen, where its name does not say it. */
+    label: z.string().min(1).max(60).optional(),
+    options: z.array(z.string().min(1).max(80)).min(1).max(100).optional(),
+    of: z.enum(["string", "number", "date"]).optional(),
+    default: z.unknown().optional(),
+    unit: z.string().max(12).optional(),
+    format: z.enum(["money", "percent", "duration"]).optional(),
+    /** The name this field had in the previous version: its values move instead of being dropped. */
+    renamedFrom: z.string().regex(FIELD_NAME).optional(),
+})
+    .strict()
+    .superRefine((f, ctx) => {
+    if (f.type === "enum" && !f.options)
+        ctx.addIssue({ code: "custom", message: 'an enum field lists its "options"', path: ["options"] });
+    if (f.type !== "enum" && f.options)
+        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"] });
+});
+export const EdgeSpec = z
+    .object({
+    to: z.union([z.array(name("kind")).min(1), z.literal("*")]),
+    cardinality: z.enum(["one", "many"]).optional(),
+    description: sentence.optional(),
+    inverse: z.string().min(1).max(80).optional(),
+    appendOnly: z.boolean().optional(),
+    /** The name this relation had in the previous version: its links move. */
+    renamedFrom: z.string().optional(),
+})
+    .strict();
+export const KindSpec = z
+    .object({
+    noun: z.string().min(1).max(40).optional(),
+    plural: z.string().min(1).max(40).optional(),
+    description: sentence.optional(),
+    fields: z.record(fieldName, FieldSpec).refine((f) => Object.keys(f).length > 0, "a kind has at least one field"),
+    label: template.optional(),
+    describe: template.optional(),
+    lifecycle: z.object({ field: fieldName, retired: z.array(z.union([z.string(), z.number(), z.boolean()])).min(1) }).strict().optional(),
+    figure: z.string().max(20_000).optional(),
+    edges: z.record(edgeName, EdgeSpec).optional(),
+    /** The name this kind had in the previous version: its records move. */
+    renamedFrom: z.string().regex(NAME).optional(),
+})
+    .strict();
+/** 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.object({ expr: expression }).strict()]);
+const ref = z.string().regex(/^\$[A-Za-z][A-Za-z0-9]*$/, 'a reference is "$" and a name, like "$subject" or "$new"');
+export const EffectSpec = z.union([
+    z.object({ create: name("kind"), as: z.string().regex(FIELD_NAME).optional(), set: z.record(fieldName, ValueSpec).optional() }).strict(),
+    z.object({ set: z.record(fieldName, ValueSpec), target: ref.optional() }).strict(),
+    z.object({ connect: edgeName, from: ref, to: ref }).strict(),
+    z.object({ sever: edgeName, from: ref, to: ref }).strict(),
+    z.object({ remove: ref }).strict(),
+]);
+export const ActSpec = z
+    .object({
+    title: z.string().min(1).max(80).optional(),
+    description: sentence.optional(),
+    /** How the act reads standing on the far end of the relation it makes or breaks. */
+    fromTheOtherEnd: z.string().min(1).max(80).optional(),
+    on: z.union([name("kind"), z.array(name("kind")).min(1)]).optional(),
+    creates: name("kind").optional(),
+    sets: z.record(fieldName, ValueSpec).optional(),
+    writes: z.array(fieldName).min(1).optional(),
+    connects: edgeName.optional(),
+    severs: edgeName.optional(),
+    removes: z.literal(true).optional(),
+    args: z.record(fieldName, FieldSpec).optional(),
+    effects: z.array(EffectSpec).min(1).max(20).optional(),
+    allowedWhen: expression.optional(),
+    refusal: template.optional(),
+    destructive: z.boolean().optional(),
+})
+    .strict();
+export const RepairSpec = z
+    .object({
+    act: name("act"),
+    label: z.string().min(1).max(80).optional(),
+    args: z.record(z.string(), ValueSpec).optional(),
+})
+    .strict();
+export const RuleSpec = z
+    .object({
+    title: z.string().min(1).max(120).optional(),
+    description: sentence.optional(),
+    over: z.union([z.literal("graph"), name("kind")]),
+    when: expression.optional(),
+    require: expression,
+    says: template.optional(),
+    repairs: z.array(RepairSpec).max(10).optional(),
+})
+    .strict();
+export const GrantSpec = z
+    .object({
+    roles: z.union([z.array(name("role")).min(1), z.literal("*")]),
+    mutations: z.union([z.array(name("act")).min(1), z.literal("*")]),
+    kinds: z.union([z.array(name("kind")), z.literal("*")]).optional(),
+    describe: sentence.optional(),
+    self: z.boolean().optional(),
+})
+    .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 const SightSpec = z
+    .object({
+    roles: z.union([z.array(name("role")).min(1), z.literal("*")]),
+    kinds: z.array(name("kind")).min(1),
+    /** Only the principal's own records: the ones they made, their own record, and what an edge joins to it. */
+    own: z.boolean().optional(),
+})
+    .strict();
+export const PolicySpec = z
+    .object({
+    grants: z.array(GrantSpec),
+    sees: z.array(SightSpec).optional(),
+})
+    .strict();
+export const BrandSpec = z
+    .object({
+    accent: z.string().regex(/^#[0-9a-fA-F]{6}$/, 'an accent is a colour like "#c2577a"'),
+    name: z.string().min(1).max(60).optional(),
+})
+    .strict();
+const loose = z.record(z.string(), z.unknown());
+/** A kind's view specs: which slots it fills. The blocks are checked in views.ts, sentence by sentence. */
+const ViewSpecsSpec = z
+    .object({
+    card: z.array(z.unknown()).optional(),
+    row: z.array(z.unknown()).optional(),
+    page: z.array(z.unknown()).optional(),
+})
+    .strict();
+export const DocumentSpec = z
+    .object({
+    format: z.literal(FORMAT),
+    formatVersion: z.literal(FORMAT_VERSION),
+    name: z.string().min(1).max(80),
+    description: sentence.optional(),
+    version: z.number().int().min(1).optional(),
+    kinds: z.record(name("kind"), KindSpec).refine((k) => Object.keys(k).length > 0, "a document declares at least one kind").refine((k) => Object.keys(k).length <= 40, "a document declares at most 40 kinds"),
+    acts: z.record(name("act"), ActSpec).optional(),
+    rules: z.record(name("rule"), RuleSpec).optional(),
+    roles: z.array(name("role")).optional(),
+    policy: PolicySpec.optional(),
+    modules: loose.optional(),
+    lenses: z.array(loose).optional(),
+    pages: loose.optional(),
+    views: z.record(z.string(), ViewSpecsSpec).optional(),
+    brand: BrandSpec.optional(),
+    settings: z.array(loose).optional(),
+    migrations: z.array(loose).optional(),
+})
+    .strict();
+//# sourceMappingURL=schema.js.map