@drhomet/mithaq 0.0.0-stage → 0.1.1

package/dist/base/decimal.d.ts

@@ -0,0 +1,9 @@
+/** Fixed-point text, held to what a Postgres `numeric` holds: 131072 digits before the point and 16383 after. */
+export declare const isDecimal: (value: unknown) => value is string;
+/** How many digits a decimal holds before and after its point, as `numeric(precision, scale)` counts them. */
+export declare const decimalDigits: (value: string) => {
+    whole: number;
+    fraction: number;
+};
+/** -1, 0 or 1 as `left` is below, equal to or above `right`, on two values `isDecimal` accepts. */
+export declare const compareDecimals: (left: string, right: string) => number;

package/dist/base/decimal.js

@@ -0,0 +1,16 @@
+// Read without passing a digit through a JS number, which would round a money
+// value past 15 significant digits. Imports nothing, so a browser can load it.
+/** Fixed-point text, held to what a Postgres `numeric` holds: 131072 digits before the point and 16383 after. */
+export const isDecimal = (value) => typeof value === 'string' && /^[+-]?\d{1,131072}(?:\.\d{1,16383})?$/.test(value);
+/** How many digits a decimal holds before and after its point, as `numeric(precision, scale)` counts them. */
+export const decimalDigits = (value) => {
+    const [whole = '', fraction = ''] = value.replace(/^[+-]/, '').split('.');
+    return { whole: whole.replace(/^0+/, '').length, fraction: fraction.length };
+};
+/** -1, 0 or 1 as `left` is below, equal to or above `right`, on two values `isDecimal` accepts. */
+export const compareDecimals = (left, right) => {
+    const [a, b] = [left, right].map((one) => /^([+-]?\d+)(?:\.(\d+))?$/.exec(one));
+    const scale = Math.max(a[2]?.length ?? 0, b[2]?.length ?? 0);
+    const [first, second] = [a, b].map((one) => BigInt(one[1] + (one[2] ?? '').padEnd(scale, '0')));
+    return first < second ? -1 : first > second ? 1 : 0;
+};

package/dist/base/fields.d.ts

@@ -0,0 +1,123 @@
+/**
+ * The `id` field alone, for a kayan that keeps no timestamps:
+ * `fields: { ...defaultIdField, title }`.
+ */
+export declare const defaultIdField: {
+    /** A uuid Postgres fills when a create leaves it out; a client may send its own, so rows can be made offline. */
+    readonly id: {
+        readonly kind: 'uuid';
+        readonly label: {
+            readonly en: 'ID';
+            readonly ar: 'المعرف';
+        };
+    };
+};
+/** The `updatedAt` and `createdAt` fields the runner writes, spread beside an id. */
+export declare const defaultTimestampFields: {
+    /** Written by the runner on every write that changes a row, and drawn disabled in the form. */
+    readonly updatedAt: {
+        readonly kind: 'datetime';
+        readonly label: {
+            readonly en: 'Updated at';
+            readonly ar: 'تاريخ التعديل';
+        };
+        readonly rules: {
+            readonly required: true;
+            readonly defaultNow: true;
+            readonly nowOnUpdate: true;
+            readonly providedBy: {
+                readonly create: 'application';
+                readonly update: 'application';
+            };
+        };
+    };
+    /** Written by the runner on insert, and indexed because a read that names no sort orders by it. */
+    readonly createdAt: {
+        readonly kind: 'datetime';
+        readonly label: {
+            readonly en: 'Created at';
+            readonly ar: 'تاريخ الإنشاء';
+        };
+        readonly rules: {
+            readonly required: true;
+            readonly defaultNow: true;
+            readonly index: true;
+            readonly providedBy: {
+                readonly create: 'application';
+                readonly update: 'application';
+            };
+        };
+    };
+};
+/**
+ * The `id`, `updatedAt` and `createdAt` fields a kayan spreads into its own
+ * `fields`: `fields: { ...defaultFields, title }`. Spread order is column order.
+ */
+export declare const defaultFields: {
+    /** A uuid Postgres fills when a create leaves it out; a client may send its own, so rows can be made offline. */
+    readonly id: {
+        readonly kind: 'uuid';
+        readonly label: {
+            readonly en: 'ID';
+            readonly ar: 'المعرف';
+        };
+    };
+    /** Written by the runner on every write that changes a row, and drawn disabled in the form. */
+    readonly updatedAt: {
+        readonly kind: 'datetime';
+        readonly label: {
+            readonly en: 'Updated at';
+            readonly ar: 'تاريخ التعديل';
+        };
+        readonly rules: {
+            readonly required: true;
+            readonly defaultNow: true;
+            readonly nowOnUpdate: true;
+            readonly providedBy: {
+                readonly create: 'application';
+                readonly update: 'application';
+            };
+        };
+    };
+    /** Written by the runner on insert, and indexed because a read that names no sort orders by it. */
+    readonly createdAt: {
+        readonly kind: 'datetime';
+        readonly label: {
+            readonly en: 'Created at';
+            readonly ar: 'تاريخ الإنشاء';
+        };
+        readonly rules: {
+            readonly required: true;
+            readonly defaultNow: true;
+            readonly index: true;
+            readonly providedBy: {
+                readonly create: 'application';
+                readonly update: 'application';
+            };
+        };
+    };
+};
+export declare const globalTypeLabel: {
+    readonly en: 'Global type';
+    readonly ar: 'النوع العام';
+};
+/**
+ * The field a global spreads into its own `fields`:
+ * `fields: { ...defaultFields, siteTitle, ...defaultGlobalFields }`.
+ */
+export declare const defaultGlobalFields: {
+    readonly globalType: {
+        readonly kind: 'text';
+        readonly label: {
+            readonly en: 'Global type';
+            readonly ar: 'النوع العام';
+        };
+        readonly rules: {
+            readonly required: true;
+            readonly unique: true;
+        };
+        readonly access: {
+            readonly update: () => false;
+        };
+    };
+};

package/dist/base/fields.js

@@ -0,0 +1,51 @@
+/**
+ * The `id` field alone, for a kayan that keeps no timestamps:
+ * `fields: { ...defaultIdField, title }`.
+ */
+export const defaultIdField = {
+    /** A uuid Postgres fills when a create leaves it out; a client may send its own, so rows can be made offline. */
+    id: { kind: 'uuid', label: { en: 'ID', ar: 'المعرف' } },
+};
+/** The `updatedAt` and `createdAt` fields the runner writes, spread beside an id. */
+export const defaultTimestampFields = {
+    /** Written by the runner on every write that changes a row, and drawn disabled in the form. */
+    updatedAt: {
+        kind: 'datetime',
+        label: { en: 'Updated at', ar: 'تاريخ التعديل' },
+        rules: {
+            required: true,
+            defaultNow: true,
+            nowOnUpdate: true,
+            providedBy: { create: 'application', update: 'application' },
+        },
+    },
+    /** Written by the runner on insert, and indexed because a read that names no sort orders by it. */
+    createdAt: {
+        kind: 'datetime',
+        label: { en: 'Created at', ar: 'تاريخ الإنشاء' },
+        rules: {
+            required: true,
+            defaultNow: true,
+            index: true,
+            providedBy: { create: 'application', update: 'application' },
+        },
+    },
+};
+/**
+ * The `id`, `updatedAt` and `createdAt` fields a kayan spreads into its own
+ * `fields`: `fields: { ...defaultFields, title }`. Spread order is column order.
+ */
+export const defaultFields = { ...defaultIdField, ...defaultTimestampFields };
+export const globalTypeLabel = { en: 'Global type', ar: 'النوع العام' };
+/**
+ * The field a global spreads into its own `fields`:
+ * `fields: { ...defaultFields, siteTitle, ...defaultGlobalFields }`.
+ */
+export const defaultGlobalFields = {
+    globalType: {
+        kind: 'text',
+        label: globalTypeLabel,
+        rules: { required: true, unique: true },
+        access: { update: () => false },
+    },
+};

package/dist/base/index.d.ts

@@ -0,0 +1,46 @@
+/** The rukn every project lays down first: the shipped kinds and rules. */
+export declare const base: {
+    readonly name: "base";
+    readonly kinds: {
+        text: import("./kinds.ts").Kind<string, "defaultValue" | "index" | "localized" | "lowercase" | "maxLength" | "minLength" | "pattern" | "providedBy" | "required" | "trim" | "unique" | "uppercase">;
+        email: import("./kinds.ts").Kind<string, "defaultValue" | "index" | "localized" | "lowercase" | "maxLength" | "minLength" | "pattern" | "providedBy" | "required" | "trim" | "unique" | "uppercase">;
+        number: import("./kinds.ts").Kind<number, "defaultValue" | "index" | "localized" | "max" | "min" | "providedBy" | "required" | "unique">;
+        integer: import("./kinds.ts").Kind<number, "defaultValue" | "index" | "localized" | "max" | "min" | "providedBy" | "required" | "unique">;
+        decimal: import("./kinds.ts").Kind<string, "defaultValue" | "index" | "localized" | "max" | "min" | "precision" | "providedBy" | "required" | "scale" | "unique">;
+        checkbox: import("./kinds.ts").Kind<boolean, "defaultValue" | "index" | "providedBy" | "required">;
+        datetime: import("./kinds.ts").Kind<Date, "defaultNow" | "defaultValue" | "index" | "localized" | "nowOnUpdate" | "providedBy" | "required">;
+        date: import("./kinds.ts").Kind<string, "defaultValue" | "index" | "localized" | "max" | "min" | "providedBy" | "required">;
+        textArray: import("./kinds.ts").Kind<string[], "defaultValue" | "maxRows" | "minRows" | "providedBy" | "required">;
+        uuid: import("./kinds.ts").Kind<string, "defaultValue" | "index" | "providedBy" | "required" | "unique">;
+        relationship: import("./kinds.ts").Kind<string | number, "defaultValue" | "index" | "onDelete" | "providedBy" | "required" | "unique"> & {
+            pointsAtRow: true;
+        };
+        join: import("./kinds.ts").Kind<unknown[], "providedBy" | "required">;
+    };
+    readonly rules: {
+        required: import("./rules.ts").Rule<boolean>;
+        unique: import("./rules.ts").Rule<boolean>;
+        index: import("./rules.ts").Rule<boolean>;
+        defaultValue: import("./rules.ts").Rule<string | number | boolean | Date | readonly unknown[] | import("../index.ts").Ref>;
+        defaultNow: import("./rules.ts").Rule<boolean>;
+        nowOnUpdate: import("./rules.ts").Rule<boolean>;
+        providedBy: import("./rules.ts").Rule<Readonly<{
+            create?: import("./rules.ts").Provider;
+            update?: import("./rules.ts").Provider;
+        }>>;
+        localized: import("./rules.ts").Rule<boolean>;
+        maxLength: import("./rules.ts").Rule<number>;
+        precision: import("./rules.ts").Rule<number>;
+        scale: import("./rules.ts").Rule<number>;
+        minLength: import("./rules.ts").Rule<number>;
+        pattern: import("./rules.ts").Rule<RegExp>;
+        min: import("./rules.ts").Rule<string | number>;
+        max: import("./rules.ts").Rule<string | number>;
+        minRows: import("./rules.ts").Rule<number>;
+        maxRows: import("./rules.ts").Rule<number>;
+        uppercase: import("./rules.ts").Rule<boolean>;
+        lowercase: import("./rules.ts").Rule<boolean>;
+        trim: import("./rules.ts").Rule<boolean>;
+        onDelete: import("./rules.ts").Rule<import("./kinds.ts").OnDelete>;
+    };
+};

package/dist/base/index.js

@@ -0,0 +1,5 @@
+import { defineRukn } from '../mithaq/rukn.js';
+import { defaultKinds } from './kinds.js';
+import { defaultRules } from './rules.js';
+/** The rukn every project lays down first: the shipped kinds and rules. */
+export const base = defineRukn({ name: 'base', kinds: defaultKinds, rules: defaultRules });

package/dist/base/kinds.d.ts

@@ -0,0 +1,54 @@
+import type { Localized } from '../mithaq/types.ts';
+import type { Operator } from '../mithaq/where.ts';
+/** A kind of field value: its label, its runtime check, the rules it accepts and what each target makes of it. */
+export type Kind<Value = unknown, RuleName extends string = string> = {
+    /** The name of the kind, shown wherever a kind is named to a person. */
+    label: Localized;
+    /** What a person reads where a value is not of this kind. */
+    message: Localized;
+    /** Compile-time value carried by fields of this kind; never read at runtime. */
+    value: Value;
+    /** Runtime check for dynamic field/default input where TypeScript is absent. */
+    accepts(value: unknown): value is Value;
+    /** Makes the write's moment, for a field that declares `defaultNow` or `nowOnUpdate`. */
+    now?: () => Value;
+    /** Rules fields of this kind may bind. Target order still decides application order. */
+    rules: readonly RuleName[];
+    /** What this kind is in each target, keyed by the target's `type`: a column, a shape, a control and a cell. */
+    targets?: Readonly<Record<string, unknown>>;
+    /** The `Where` operators a field of this kind takes; any other is refused. */
+    operators?: readonly Operator[];
+    /** `false` where a value of this kind cannot order a page. */
+    sortable?: false;
+    /** `true` where a value of this kind is the id of another row, named by `relationTo`. */
+    pointsAtRow?: true;
+    /** What a field of this kind does when the row it points at is deleted, unless it names its own `onDelete`. */
+    onDelete?: OnDelete;
+};
+/** Defines a project kind from its runtime check. */
+export declare const kind: <Value>(accepts: (value: unknown) => value is Value) => <const RuleName extends string, const Targets extends Readonly<Record<string, unknown>> = {}, const PointsAtRow extends true | undefined = undefined>(definition: Omit<Kind<Value, RuleName>, 'accepts' | 'value' | 'targets' | 'pointsAtRow'> & {
+    targets?: Targets;
+    pointsAtRow?: PointsAtRow;
+}) => Kind<Value, RuleName> & ({} extends Targets ? unknown : {
+    targets: Targets;
+}) & (PointsAtRow extends true ? {
+    pointsAtRow: true;
+} : unknown);
+/** What the database does to this row when the row it points at is deleted. */
+export type OnDelete = 'cascade' | 'restrict' | 'set null';
+export declare const defaultKinds: {
+    text: Kind<string, "defaultValue" | "index" | "localized" | "lowercase" | "maxLength" | "minLength" | "pattern" | "providedBy" | "required" | "trim" | "unique" | "uppercase">;
+    email: Kind<string, "defaultValue" | "index" | "localized" | "lowercase" | "maxLength" | "minLength" | "pattern" | "providedBy" | "required" | "trim" | "unique" | "uppercase">;
+    number: Kind<number, "defaultValue" | "index" | "localized" | "max" | "min" | "providedBy" | "required" | "unique">;
+    integer: Kind<number, "defaultValue" | "index" | "localized" | "max" | "min" | "providedBy" | "required" | "unique">;
+    decimal: Kind<string, "defaultValue" | "index" | "localized" | "max" | "min" | "precision" | "providedBy" | "required" | "scale" | "unique">;
+    checkbox: Kind<boolean, "defaultValue" | "index" | "providedBy" | "required">;
+    datetime: Kind<Date, "defaultNow" | "defaultValue" | "index" | "localized" | "nowOnUpdate" | "providedBy" | "required">;
+    date: Kind<string, "defaultValue" | "index" | "localized" | "max" | "min" | "providedBy" | "required">;
+    textArray: Kind<string[], "defaultValue" | "maxRows" | "minRows" | "providedBy" | "required">;
+    uuid: Kind<string, "defaultValue" | "index" | "providedBy" | "required" | "unique">;
+    relationship: Kind<string | number, "defaultValue" | "index" | "onDelete" | "providedBy" | "required" | "unique"> & {
+        pointsAtRow: true;
+    };
+    join: Kind<unknown[], "providedBy" | "required">;
+};

package/dist/base/kinds.js

@@ -0,0 +1,78 @@
+import { isDecimal } from './decimal.js';
+/** Defines a project kind from its runtime check. */
+export const kind = (accepts) => (definition) => ({ ...definition, value: undefined, accepts });
+export const defaultKinds = {
+    text: kind((value) => typeof value === 'string')({
+        label: { en: 'Text', ar: 'نص' },
+        message: { en: 'This is not text.', ar: 'هذا ليس نصا.' },
+        rules: ['providedBy', 'required', 'unique', 'index', 'defaultValue', 'localized', 'maxLength', 'minLength', 'pattern', 'uppercase', 'lowercase', 'trim'],
+    }),
+    email: kind((value) => typeof value === 'string')({
+        label: { en: 'Email', ar: 'بريد إلكتروني' },
+        message: { en: 'This is not an email address.', ar: 'هذا ليس بريدا إلكترونيا.' },
+        rules: ['providedBy', 'required', 'unique', 'index', 'defaultValue', 'localized', 'maxLength', 'minLength', 'pattern', 'uppercase', 'lowercase', 'trim'],
+    }),
+    number: kind((value) => typeof value === 'number')({
+        label: { en: 'Number', ar: 'رقم' },
+        message: { en: 'This is not a number.', ar: 'هذا ليس رقما.' },
+        rules: ['providedBy', 'required', 'unique', 'index', 'defaultValue', 'localized', 'min', 'max'],
+    }),
+    // Held to int4's range, because the column is a Postgres `integer`.
+    integer: kind((value) => Number.isInteger(value) && value >= -2147483648 && value <= 2147483647)({
+        label: { en: 'Integer', ar: 'عدد صحيح' },
+        message: { en: 'This is not a 32-bit integer.', ar: 'هذا ليس عددا صحيحا من 32 بت.' },
+        rules: ['providedBy', 'required', 'unique', 'index', 'defaultValue', 'localized', 'min', 'max'],
+    }),
+    // Carried as text, because a JS number would round money past 15 significant digits.
+    decimal: kind(isDecimal)({
+        label: { en: 'Decimal', ar: 'عدد عشري' },
+        message: { en: 'This is not a decimal number.', ar: 'هذا ليس عددا عشريا.' },
+        rules: ['providedBy', 'required', 'unique', 'index', 'defaultValue', 'localized', 'min', 'max', 'precision', 'scale'],
+    }),
+    checkbox: kind((value) => typeof value === 'boolean')({
+        label: { en: 'Checkbox', ar: 'خانة اختيار' },
+        message: { en: 'This is answered yes or no.', ar: 'يجاب على هذا بنعم أو لا.' },
+        rules: ['providedBy', 'required', 'index', 'defaultValue'],
+    }),
+    datetime: kind((value) => value instanceof Date)({
+        label: { en: 'Date and time', ar: 'التاريخ والوقت' },
+        message: { en: 'This is not a date and time.', ar: 'هذا ليس تاريخا ووقتا.' },
+        now: () => new Date(),
+        rules: ['providedBy', 'required', 'index', 'defaultValue', 'defaultNow', 'nowOnUpdate', 'localized'],
+    }),
+    // A string, not a `Date`: a day read in another zone as a moment is the day before.
+    // `Date.parse('2026-02-30')` rolls over to March 2, so a day must come back as itself.
+    date: kind((value) => typeof value === 'string' &&
+        /^\d{4}-\d{2}-\d{2}$/.test(value) &&
+        new Date(value).toJSON()?.startsWith(value) === true)({
+        label: { en: 'Date', ar: 'التاريخ' },
+        message: { en: 'This is not a date.', ar: 'هذا ليس تاريخا.' },
+        rules: ['providedBy', 'required', 'index', 'defaultValue', 'localized', 'min', 'max'],
+    }),
+    textArray: kind((value) => Array.isArray(value) && value.every((one) => typeof one === 'string'))({
+        label: { en: 'Text list', ar: 'قائمة نصوص' },
+        message: { en: 'This is not a list of text.', ar: 'هذه ليست قائمة نصوص.' },
+        rules: ['providedBy', 'required', 'defaultValue', 'minRows', 'maxRows'],
+    }),
+    // Named rather than `text` because a foreign key takes the type of the id it
+    // points at, and Postgres refuses a text reference to a uuid key.
+    uuid: kind((value) => typeof value === 'string')({
+        label: { en: 'UUID', ar: 'معرف فريد' },
+        message: { en: 'This is not a unique identifier.', ar: 'هذا ليس معرفا فريدا.' },
+        rules: ['providedBy', 'required', 'unique', 'index', 'defaultValue'],
+    }),
+    relationship: kind((value) => typeof value === 'number' || typeof value === 'string')({
+        label: { en: 'Relationship', ar: 'علاقة' },
+        message: { en: 'Pick one of the listed entries.', ar: 'اختر عنصرًا من القائمة.' },
+        rules: ['providedBy', 'required', 'unique', 'index', 'defaultValue', 'onDelete'],
+        pointsAtRow: true,
+        onDelete: 'set null',
+    }),
+    // The rows of another kayan whose `on` relationship points at this one. It builds
+    // no column: the id lives on the child, and a read populates it through the child's access.
+    join: kind((value) => Array.isArray(value))({
+        label: { en: 'Related rows', ar: 'صفوف مرتبطة' },
+        message: { en: 'This is not a list of related entries.', ar: 'هذه ليست قائمة عناصر مرتبطة.' },
+        rules: ['providedBy', 'required'],
+    }),
+};

package/dist/base/rules.d.ts

@@ -0,0 +1,73 @@
+import { type Ref } from '../mithaq/user.ts';
+import type { Localized } from '../mithaq/types.ts';
+import type { OnDelete } from './kinds.ts';
+export type Rule<Value = unknown> = {
+    /** Compile-time value carried by a binding; never read at runtime. */
+    value: Value;
+    /** Runtime check for dynamic declarations where TypeScript is absent. */
+    accepts(value: unknown): value is Value;
+    /** What a person reads where this rule refuses a value. A rule that never refuses one carries none. */
+    message?: Localized;
+    /** The rules a field may not declare beside this one, by name. */
+    excludes?: readonly string[];
+};
+export type RuleValue<R> = R extends Rule<infer Value> ? Value : never;
+/** Defines a project rule from its runtime check. */
+export declare const rule: <Value>({ accepts, message, excludes, }: {
+    accepts: (value: unknown) => value is Value;
+    message?: Localized;
+    excludes?: readonly string[];
+}) => Rule<Value>;
+declare const providers: readonly ['client', 'application', 'never'];
+export type Provider = (typeof providers)[number];
+export type ProvidedBy = Readonly<{
+    create?: Provider;
+    update?: Provider;
+}>;
+/** Who supplies a field's value on one operation; a field that declares nothing is the client's. */
+export declare const providerOf: (field: {
+    rules?: Record<string, unknown>;
+}, on: 'create' | 'update') => Provider;
+/** The shipped rules, which a project passes to `defineMithaq` and may add its own to. */
+export declare const defaultRules: {
+    required: Rule<boolean>;
+    unique: Rule<boolean>;
+    index: Rule<boolean>;
+    /** A literal, or `user.<key>` for the actor's value. Each row gets its own copy. */
+    defaultValue: Rule<string | number | boolean | Date | readonly unknown[] | Ref>;
+    /** The moment of the write, on create. */
+    defaultNow: Rule<boolean>;
+    /** The moment of the write, on every update, whatever the column is called. */
+    nowOnUpdate: Rule<boolean>;
+    /** Who supplies the value on create and on update. A field declaring nothing is the client's on both. */
+    providedBy: Rule<Readonly<{
+        create?: Provider;
+        update?: Provider;
+    }>>;
+    /** One value per locale the language declares: one column per locale, and an object keyed by locale in every shape. */
+    localized: Rule<boolean>;
+    /** Length is a rule, not a kind: `text` with a maximum is `varchar(n)`. */
+    maxLength: Rule<number>;
+    /** A decimal's size, `numeric(precision, scale)`: declare both or neither. A value with more digits is refused, not rounded. */
+    precision: Rule<number>;
+    scale: Rule<number>;
+    minLength: Rule<number>;
+    pattern: Rule<RegExp>;
+    /** A bound on an ordered value: a number for `number`, an ISO day for `date`. */
+    min: Rule<string | number>;
+    max: Rule<string | number>;
+    /** How few and how many rows a list holds. A list that is not `required` may be left empty whatever its floor. */
+    minRows: Rule<number>;
+    maxRows: Rule<number>;
+    /** Rewrites the value's case before any check judges it; never refuses a value for its case. */
+    uppercase: Rule<boolean>;
+    lowercase: Rule<boolean>;
+    trim: Rule<boolean>;
+    /** What happens to this row when the row it points at is deleted. Left out, a required relationship restricts and an optional one is set null. */
+    onDelete: Rule<OnDelete>;
+};
+/** The rule keys a field may carry, derived from the record the language names. */
+export type Rules = {
+    [Name in keyof typeof defaultRules]?: RuleValue<(typeof defaultRules)[Name]>;
+};
+export {};

package/dist/base/rules.js

@@ -0,0 +1,80 @@
+import { isRef } from '../mithaq/user.js';
+/** Defines a project rule from its runtime check. */
+export const rule = ({ accepts, message, excludes, }) => ({ value: undefined, accepts, message, excludes });
+const isBoolean = (value) => typeof value === 'boolean';
+const isNumber = (value) => typeof value === 'number';
+const boolean = rule({ accepts: isBoolean });
+const writeOperations = ['create', 'update'];
+// `never` is not `application`: not "something else fills it" but "nobody does, for this operation".
+const providers = ['client', 'application', 'never'];
+/** Who supplies a field's value on one operation; a field that declares nothing is the client's. */
+export const providerOf = (field, on) => field.rules?.providedBy?.[on] ?? 'client';
+/** The shipped rules, which a project passes to `defineMithaq` and may add its own to. */
+export const defaultRules = {
+    required: rule({ accepts: isBoolean, message: { en: 'This field is required.', ar: 'هذا الحقل مطلوب.' } }),
+    unique: boolean,
+    index: boolean,
+    /** A literal, or `user.<key>` for the actor's value. Each row gets its own copy. */
+    defaultValue: rule({
+        accepts: (value) => value instanceof Date || isRef(value) || Array.isArray(value) || ['boolean', 'number', 'string'].includes(typeof value),
+        excludes: ['defaultNow'],
+    }),
+    /** The moment of the write, on create. */
+    defaultNow: rule({ accepts: isBoolean, excludes: ['defaultValue', 'localized'] }),
+    /** The moment of the write, on every update, whatever the column is called. */
+    nowOnUpdate: rule({ accepts: isBoolean, excludes: ['localized'] }),
+    /** Who supplies the value on create and on update. A field declaring nothing is the client's on both. */
+    providedBy: rule({
+        accepts: (value) => !!value &&
+            typeof value === 'object' &&
+            !Array.isArray(value) &&
+            Object.entries(value).every(([operation, supplier]) => writeOperations.includes(operation) && providers.includes(supplier)),
+    }),
+    /** One value per locale the language declares: one column per locale, and an object keyed by locale in every shape. */
+    localized: boolean,
+    /** Length is a rule, not a kind: `text` with a maximum is `varchar(n)`. */
+    maxLength: rule({ accepts: isNumber, message: { en: 'The value is too long.', ar: 'القيمة طويلة جدًا.' } }),
+    /** A decimal's size, `numeric(precision, scale)`: declare both or neither. A value with more digits is refused, not rounded. */
+    precision: rule({
+        accepts: (value) => Number.isInteger(value) && value >= 1 && value <= 1000,
+        message: { en: 'The value has too many digits.', ar: 'القيمة فيها أرقام أكثر من المسموح.' },
+    }),
+    scale: rule({
+        accepts: (value) => Number.isInteger(value) && value >= 0 && value <= 1000,
+        message: { en: 'The value has too many decimal places.', ar: 'القيمة فيها منازل عشرية أكثر من المسموح.' },
+    }),
+    minLength: rule({ accepts: isNumber, message: { en: 'The value is too short.', ar: 'القيمة أقصر من المسموح.' } }),
+    pattern: rule({
+        accepts: (value) => value instanceof RegExp,
+        message: {
+            en: 'The value is not in the shape this field takes.',
+            ar: 'القيمة ليست بالشكل الذي يقبله هذا الحقل.',
+        },
+    }),
+    /** A bound on an ordered value: a number for `number`, an ISO day for `date`. */
+    min: rule({
+        accepts: (value) => typeof value === 'number' || typeof value === 'string',
+        message: { en: 'The value is too small.', ar: 'القيمة أصغر من المسموح.' },
+    }),
+    max: rule({
+        accepts: (value) => typeof value === 'number' || typeof value === 'string',
+        message: { en: 'The value is too large.', ar: 'القيمة أكبر من المسموح.' },
+    }),
+    /** How few and how many rows a list holds. A list that is not `required` may be left empty whatever its floor. */
+    minRows: rule({
+        accepts: (value) => Number.isInteger(value) && value >= 0,
+        message: { en: 'This list has too few entries.', ar: 'هذه القائمة فيها عناصر أقل من المسموح.' },
+    }),
+    maxRows: rule({
+        accepts: (value) => Number.isInteger(value) && value >= 0,
+        message: { en: 'This list has too many entries.', ar: 'هذه القائمة فيها عناصر أكثر من المسموح.' },
+    }),
+    /** Rewrites the value's case before any check judges it; never refuses a value for its case. */
+    uppercase: rule({ accepts: isBoolean, excludes: ['lowercase'] }),
+    lowercase: rule({ accepts: isBoolean, excludes: ['uppercase'] }),
+    trim: boolean,
+    /** What happens to this row when the row it points at is deleted. Left out, a required relationship restricts and an optional one is set null. */
+    onDelete: rule({
+        accepts: (value) => typeof value === 'string' && ['cascade', 'restrict', 'set null'].includes(value),
+    }),
+};