@drhomet/mithaq 0.1.1 → 0.2.1

package/dist/mithaq/types.d.ts

@@ -6,7 +6,7 @@ import type { StandardSchemaV1 } from './standard-schema.ts';
 import type { Rules } from '../base/rules.ts';
 import type { Rule, RuleValue } from '../base/rules.ts';
 import type { Kind } from '../base/kinds.ts';
-import type { RichTextRead } from '../rich-text/rich-text.ts';
+import type { RichTextRead } from '../rich-text/value.ts';
 import type { ResolvedStorage } from '../storage/storage.ts';
 import type { RefOf, ScreenField, ScreenKeys } from '../screen/index.ts';
 /** What a field access callback is handed. */
@@ -54,6 +54,16 @@ export type ServiceOf<L> = L extends {
 } ? Extract<Targets[keyof Targets], {
     capability: 'service';
 }> : never;
+/**
+ * Payload's `jsonSchema`: `schema` is what a value is checked against. `uri` and `fileMatch` name it
+ * for an editor; it is never fetched from its `uri`, which would be a request the server makes on a
+ * writer's behalf.
+ */
+export type JsonSchema = {
+    schema: Record<string, unknown> | boolean;
+    uri?: string;
+    fileMatch?: readonly string[];
+};
 type Named<Locale extends string = string> = {
     access?: {
         create?: StoredFieldAccess;
@@ -73,6 +83,10 @@ type Named<Locale extends string = string> = {
         readonly value: string;
         readonly label: Localized<Locale>;
     }[];
+    /** A `json` field only: the JSON Schema its value is checked against, as Payload's field takes it. */
+    jsonSchema?: JsonSchema;
+    /** A `json` field only, and every one names it: the longest JSON text its value is, `defaultJsonMaxBytes` or its own. */
+    maxBytes?: number;
     /** The column name. A relationship without one gets `<snake_case name>_id`. */
     dbName?: string;
     /**
@@ -100,6 +114,7 @@ type FieldKind<KindName extends string> = KindName extends 'join' ? {
     relationTo: string | (() => Kayan);
     /** Whether this field holds a set of rows rather than one, kept in a join table and read back as an array of ids. */
     hasMany?: true;
+    filterOptions?: FilterOptions;
     on?: never;
     defaultLimit?: never;
     defaultSort?: never;
@@ -107,6 +122,7 @@ type FieldKind<KindName extends string> = KindName extends 'join' ? {
     kind: KindName;
     relationTo?: never;
     hasMany?: never;
+    filterOptions?: never;
     on?: never;
     defaultLimit?: never;
     defaultSort?: never;
@@ -121,6 +137,7 @@ export type RuntimeField = Named & {
     rules?: Record<string, unknown>;
     relationTo?: string | (() => Kayan);
     hasMany?: true;
+    filterOptions?: FilterOptions;
     /** A `join` field only: the child's relationship that points back at this kayan. */
     on?: string;
     /** A `join` field only: how many of the child's rows one populated read carries. */
@@ -158,6 +175,7 @@ type BoundField<L extends LanguageShape, K extends keyof L['kinds'] & string> =
 } ? {
     relationTo: string | (() => Kayan);
     hasMany?: true;
+    filterOptions?: FilterOptions;
     on?: never;
     defaultLimit?: never;
     defaultSort?: never;
@@ -168,6 +186,16 @@ type BoundField<L extends LanguageShape, K extends keyof L['kinds'] & string> =
     defaultLimit?: never;
     defaultSort?: never;
 });
+/**
+ * Which rows of its target a relationship's picker offers this actor, as Payload's field of the same
+ * name: a `Where`, `true` for every row the actor reads, `false` for none. A picker's read is ANDed
+ * with it, so it narrows what the target's own read answers and never widens it.
+ */
+export type FilterOptions = (args: {
+    user: unknown;
+    /** The transaction of the write it holds, where there is one, so a read it makes joins it as Payload's `req` carries one. */
+    tx?: unknown;
+}) => Where | boolean | Promise<Where | boolean>;
 /** Field union derived once from a concrete language's kind and rule registries. */
 export type FieldOf<L extends LanguageShape> = {
     [K in keyof L['kinds'] & string]: BoundField<L, K>;

package/dist/rbac/index.d.ts

@@ -17,8 +17,8 @@ export type Assigned = {
 /** The access target: it names the system roles, reads which an actor is assigned, and answers what they hold. */
 export type AccessTarget<Roles extends SystemRoles = SystemRoles, Table extends RowTable = RowTable, Actor = unknown> = {
     readonly capability: 'access';
-    /** `'rbac'` from `rbacTarget`, `'betterAuth'` from `betterAuthTarget`. */
-    readonly type?: 'rbac' | 'betterAuth';
+    /** `'rbac'` from `rbacTarget`, `'betterAuth'` from `betterAuthTarget`, `'memberRole'` from `memberRoleTarget`. */
+    readonly type?: 'rbac' | 'betterAuth' | 'memberRole';
     /** The system roles, which are also the names a row table may be keyed on. */
     readonly roles: Roles;
     /** The slugs this actor is assigned, read from the trusted snapshot, so an actor naming its own roles is a claim. Absent is `user.roles`. */

package/dist/rbac/index.js

@@ -105,7 +105,7 @@ export const rbacTarget = ({ roles, rolesOf, access, kayan, }) => {
                     if (!Object.hasOwn(roles, role))
                         throw new Refusal(`Role "${role}" is not declared on the access target.`);
                     if (role === 'super_admin')
-                        throw new Refusal('Role "super_admin" is the platform role and cannot be assigned in a tenant.');
+                        throw new Refusal('Role "super_admin" is the backoffice role and cannot be assigned in a tenant.');
                     const project = asas;
                     const declarations = resolvedKayans.get(project) ?? {};
                     const assignment = declarations[memberRoles];

package/dist/rich-text/index.d.ts

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import type { StandardSchemaV1 } from '../mithaq/standard-schema.ts';
 import type { ResolvedField } from '../mithaq/types.ts';
 import { type RichTextValue } from './rich-text.ts';
+export * from './rich-text.ts';
 /**
  * The rukn a project lays down for rich text, over its own node list:
  * `arkan: [base, richText({ nodes: richTextNodes })]`.

package/dist/rich-text/index.js

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { kind } from '../base/kinds.js';
 import { defineRukn } from '../mithaq/rukn.js';
 import { isRichText, richTextReader, storedRichText } from './rich-text.js';
+export * from './rich-text.js';
 // An emptied editor still sends a root and one empty paragraph, so a blank text
 // with no decorator is missing for `required`.
 const refusalOf = ({ field, read, value }) => {

package/dist/rich-text/rich-text.d.ts

@@ -1,50 +1,10 @@
 import { DecoratorNode, type ElementFormatType, type Klass, type LexicalNode, type LexicalUpdateJSON, type SerializedLexicalNode } from 'lexical';
-/** One node of Lexical's serialized editor state: a `type`, and `children` where it holds any. */
-export type RichTextNode = {
-    type: string;
-    children?: RichTextNode[];
-    text?: string;
-    [key: string]: unknown;
-};
-/** What a `richText` field holds: Lexical's `editorState.toJSON()`, a root of `type: 'root'`. */
-export type RichTextValue = {
-    root: RichTextNode & {
-        type: 'root';
-        children: RichTextNode[];
-    };
-    [key: string]: unknown;
-};
-/**
- * How deep a rich text value may nest, how large it may be and how many nodes it may hold,
- * all checked before any Lexical code reads it.
- */
-export declare const richTextBounds: {
-    depth: number;
-    bytes: number;
-    nodes: number;
-};
-/** Whether a link may point here: `http`, `https`, `mailto`, `tel`, a fragment or a path. */
-export declare const safeUrl: (url: unknown) => boolean;
-/**
- * Why a value is no Lexical editor state a `richText` column may hold, or nothing. Runs before
- * any Lexical code reads the value; a `style` is refused, since no editor of the project writes one.
- */
-export declare const richTextGuard: (value: unknown) => string | undefined;
-/** Whether a value passes `richTextGuard`, which is all the kind itself asks of one. */
-export declare const isRichText: (value: unknown) => value is RichTextValue;
+import { type RichTextRead, type RichTextValue } from './value.ts';
+export * from './value.ts';
 /** The node classes the registry's editor draws. A project's list spreads it: `[...defaultNodes, CalloutNode]`. */
 export declare const defaultNodes: readonly Klass<LexicalNode>[];
 /** Every node type a list of classes can read, the core ones included. */
 export declare const typesOf: (nodes: readonly Klass<LexicalNode>[]) => ReadonlySet<string>;
-/**
- * The first node type under a value's `root` that `types` does not hold, or nothing, and `''`
- * past the depth bound. Read off the JSON, since a production Lexical minifies its errors.
- */
-export declare const unknownType: ({ node, types, depth }: {
-    node: unknown;
-    types: ReadonlySet<string>;
-    depth?: number;
-}) => string | undefined;
 /** An upload node as Payload's lexical editor writes it, v3. */
 export type SerializedUploadNode = SerializedLexicalNode & {
     type: 'upload';
@@ -113,24 +73,11 @@ export declare class UploadNode extends DecoratorNode<unknown> {
     isInline(): false;
     decorate(): unknown;
 }
-/** What a write's value reads as: its text and whether it holds a decorator, or why it is refused. */
-export type RichTextRead = {
-    text: string;
-    holdsDecorator?: boolean;
-} | {
-    refused: string;
-    type?: string;
-};
 /**
  * A reader of `richText` values over a node list: the guard walk, then a headless parse.
  * `uploads` names the kayan an `UploadNode` may point at.
  */
 export declare const richTextReader: (nodes: readonly Klass<LexicalNode>[], uploads?: readonly string[]) => (value: unknown) => RichTextRead;
-/**
- * How a stored `richText` value is read back: a root with children and nothing more,
- * so a value holding a node the project has since dropped still reads.
- */
-export declare const storedRichText: (value: unknown) => RichTextRead;
 /** What a converter left out of a value: the node's path in what it was handed, its type, and why. */
 export type RichTextDropped = {
     path: string;

package/dist/rich-text/rich-text.js

@@ -4,129 +4,14 @@ import { LinkNode } from '@lexical/link';
 import { ListItemNode, ListNode } from '@lexical/list';
 import { HeadingNode, QuoteNode } from '@lexical/rich-text';
 import { $getDocument, $getRoot, $isDecoratorNode, $isElementNode, $getState, $setState, createEditor, createState, DecoratorNode, LineBreakNode, ParagraphNode, RootNode, TabNode, TextNode, } from 'lexical';
-/**
- * How deep a rich text value may nest, how large it may be and how many nodes it may hold,
- * all checked before any Lexical code reads it.
- */
-export const richTextBounds = { depth: 64, bytes: 512 * 1024, nodes: 10_000 };
-// Depth is checked before `JSON.stringify` walks a hostile value. An object met
-// twice is refused, so one reachable many ways is not walked once per way.
-const within = (value, depth, seen = new WeakSet()) => {
-    if (value === null || typeof value !== 'object')
-        return undefined;
-    if (depth <= 0)
-        return `The value nests deeper than ${richTextBounds.depth} levels.`;
-    if (seen.has(value))
-        return 'The value holds one object in two places.';
-    seen.add(value);
-    for (const one of Object.values(value)) {
-        const refused = within(one, depth - 1, seen);
-        if (refused)
-            return refused;
-    }
-    return undefined;
-};
-/** Whether a link may point here: `http`, `https`, `mailto`, `tel`, a fragment or a path. */
-export const safeUrl = (url) => {
-    if (typeof url !== 'string')
-        return false;
-    // eslint-disable-next-line no-control-regex
-    const cleaned = url.trim().replace(/[\x00-\x1f\x7f]/g, '');
-    if (cleaned.startsWith('#') || cleaned.startsWith('/') || cleaned.startsWith('./') || cleaned.startsWith('../'))
-        return true;
-    const protocol = cleaned.match(/^([a-z][a-z0-9+\-.]*):(?=.)/i)?.[1]?.toLowerCase();
-    // A web address must name a host: refuses `https://`, `http:///path` (read as
-    // a host named `path`), `https://@` and the like.
-    if (protocol === 'http' || protocol === 'https') {
-        try {
-            return /^https?:\/\/[^/?#\\\s]/i.test(cleaned) && /[\p{L}\p{N}]/u.test(new URL(cleaned).hostname);
-        }
-        catch {
-            return false;
-        }
-    }
-    return protocol === 'mailto' || protocol === 'tel';
-};
-const held = (node, key) => node[key];
-/**
- * Why a value is no Lexical editor state a `richText` column may hold, or nothing. Runs before
- * any Lexical code reads the value; a `style` is refused, since no editor of the project writes one.
- */
-export const richTextGuard = (value) => {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return 'The value is no object.';
-    const nested = within(value, richTextBounds.depth);
-    if (nested)
-        return nested;
-    if (new TextEncoder().encode(JSON.stringify(value)).length > richTextBounds.bytes)
-        return `The value is larger than ${richTextBounds.bytes} bytes.`;
-    const root = held(value, 'root');
-    if (!root || typeof root !== 'object' || Array.isArray(root) || held(root, 'type') !== 'root')
-        return 'The value has no root of type "root".';
-    if (!Array.isArray(held(root, 'children')))
-        return 'The root holds no list of children.';
-    let count = 0;
-    const walk = (node) => {
-        if (!node || typeof node !== 'object' || Array.isArray(node) || typeof held(node, 'type') !== 'string')
-            return 'A node is no object with a string type.';
-        if (++count > richTextBounds.nodes)
-            return `The value holds more than ${richTextBounds.nodes} nodes.`;
-        const type = held(node, 'type');
-        if (Object.hasOwn(node, 'text') && typeof held(node, 'text') !== 'string')
-            return `A node of type "${type}" holds text that is no string.`;
-        if (typeof held(node, 'text') === 'string') {
-            for (const key of ['format', 'detail']) {
-                if (Object.hasOwn(node, key) && !Number.isInteger(held(node, key)))
-                    return `A node of type "${type}" holds a ${key} that is no whole number.`;
-            }
-        }
-        for (const key of ['style', 'textStyle']) {
-            if (Object.hasOwn(node, key) && held(node, key) !== '')
-                return `A node of type "${type}" holds a ${key}, and this editor writes none.`;
-        }
-        if ((type === 'link' || type === 'autolink') && !safeUrl(held(node, 'url')))
-            return `A link points at an address that is not http, https, mailto, tel or a path.`;
-        if (!Object.hasOwn(node, 'children'))
-            return undefined;
-        const children = held(node, 'children');
-        if (!Array.isArray(children))
-            return `A node of type "${type}" holds children that are no list.`;
-        for (const child of children) {
-            const refused = walk(child);
-            if (refused)
-                return refused;
-        }
-        return undefined;
-    };
-    return walk(root);
-};
-/** Whether a value passes `richTextGuard`, which is all the kind itself asks of one. */
-export const isRichText = (value) => richTextGuard(value) === undefined;
+import { richTextBounds, richTextGuard, safeUrl, unknownType } from './value.js';
+export * from './value.js';
 /** The node classes the registry's editor draws. A project's list spreads it: `[...defaultNodes, CalloutNode]`. */
 export const defaultNodes = [HeadingNode, QuoteNode, ListNode, ListItemNode, LinkNode, HorizontalRuleNode];
 /** The nodes every Lexical editor registers whatever it is given. */
 const coreNodes = [RootNode, ParagraphNode, TextNode, LineBreakNode, TabNode];
 /** Every node type a list of classes can read, the core ones included. */
 export const typesOf = (nodes) => new Set([...coreNodes, ...nodes].map((node) => node.getType()));
-/**
- * The first node type under a value's `root` that `types` does not hold, or nothing, and `''`
- * past the depth bound. Read off the JSON, since a production Lexical minifies its errors.
- */
-export const unknownType = ({ node, types, depth = richTextBounds.depth }) => {
-    if (!node || typeof node !== 'object')
-        return undefined;
-    if (depth <= 0)
-        return '';
-    const held = node;
-    if (typeof held.type === 'string' && !types.has(held.type))
-        return held.type;
-    for (const child of Array.isArray(held.children) ? held.children : []) {
-        const type = unknownType({ node: child, types, depth: depth - 1 });
-        if (type !== undefined)
-            return type;
-    }
-    return undefined;
-};
 // Set by `richTextReader` around its own synchronous parse alone, so a value is
 // never checked against another build's list.
 let holdingFiles;
@@ -257,14 +142,6 @@ export const richTextReader = (nodes, uploads) => {
         }
     };
 };
-/**
- * How a stored `richText` value is read back: a root with children and nothing more,
- * so a value holding a node the project has since dropped still reads.
- */
-export const storedRichText = (value) => {
-    const root = value && typeof value === 'object' && !Array.isArray(value) ? value.root : undefined;
-    return root && typeof root === 'object' && root.type === 'root' && Array.isArray(root.children) ? { text: '' } : { refused: 'The stored value is no editor state.' };
-};
 // Canonical through Lexical's own `toJSON`, so converting again changes nothing,
 // and read once more, since the canonical value is larger.
 const settle = (convert, nodes) => {

package/dist/rich-text/value.d.ts

@@ -0,0 +1,55 @@
+/** One node of Lexical's serialized editor state: a `type`, and `children` where it holds any. */
+export type RichTextNode = {
+    type: string;
+    children?: RichTextNode[];
+    text?: string;
+    [key: string]: unknown;
+};
+/** What a `richText` field holds: Lexical's `editorState.toJSON()`, a root of `type: 'root'`. */
+export type RichTextValue = {
+    root: RichTextNode & {
+        type: 'root';
+        children: RichTextNode[];
+    };
+    [key: string]: unknown;
+};
+/**
+ * How deep a rich text value may nest, how large it may be and how many nodes it may hold,
+ * all checked before any Lexical code reads it.
+ */
+export declare const richTextBounds: {
+    depth: number;
+    bytes: number;
+    nodes: number;
+};
+/** Whether a link may point here: `http`, `https`, `mailto`, `tel`, a fragment or a path. */
+export declare const safeUrl: (url: unknown) => boolean;
+/**
+ * Why a value is no Lexical editor state a `richText` column may hold, or nothing. Runs before
+ * any Lexical code reads the value; a `style` is refused, since no editor of the project writes one.
+ */
+export declare const richTextGuard: (value: unknown) => string | undefined;
+/** Whether a value passes `richTextGuard`, which is all the kind itself asks of one. */
+export declare const isRichText: (value: unknown) => value is RichTextValue;
+/**
+ * The first node type under a value's `root` that `types` does not hold, or nothing, and `''`
+ * past the depth bound. Read off the JSON, since a production Lexical minifies its errors.
+ */
+export declare const unknownType: ({ node, types, depth }: {
+    node: unknown;
+    types: ReadonlySet<string>;
+    depth?: number;
+}) => string | undefined;
+/** What a write's value reads as: its text and whether it holds a decorator, or why it is refused. */
+export type RichTextRead = {
+    text: string;
+    holdsDecorator?: boolean;
+} | {
+    refused: string;
+    type?: string;
+};
+/**
+ * How a stored `richText` value is read back: a root with children and nothing more,
+ * so a value holding a node the project has since dropped still reads.
+ */
+export declare const storedRichText: (value: unknown) => RichTextRead;

package/dist/rich-text/value.js

@@ -0,0 +1,126 @@
+// No Lexical import: core reads and checks a stored value with this alone, so a project without rich text installs no Lexical.
+/**
+ * How deep a rich text value may nest, how large it may be and how many nodes it may hold,
+ * all checked before any Lexical code reads it.
+ */
+export const richTextBounds = { depth: 64, bytes: 512 * 1024, nodes: 10_000 };
+// Depth is checked before `JSON.stringify` walks a hostile value. An object met
+// twice is refused, so one reachable many ways is not walked once per way.
+const within = (value, depth, seen = new WeakSet()) => {
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    if (depth <= 0)
+        return `The value nests deeper than ${richTextBounds.depth} levels.`;
+    if (seen.has(value))
+        return 'The value holds one object in two places.';
+    seen.add(value);
+    for (const one of Object.values(value)) {
+        const refused = within(one, depth - 1, seen);
+        if (refused)
+            return refused;
+    }
+    return undefined;
+};
+/** Whether a link may point here: `http`, `https`, `mailto`, `tel`, a fragment or a path. */
+export const safeUrl = (url) => {
+    if (typeof url !== 'string')
+        return false;
+    // eslint-disable-next-line no-control-regex
+    const cleaned = url.trim().replace(/[\x00-\x1f\x7f]/g, '');
+    if (cleaned.startsWith('#') || cleaned.startsWith('/') || cleaned.startsWith('./') || cleaned.startsWith('../'))
+        return true;
+    const protocol = cleaned.match(/^([a-z][a-z0-9+\-.]*):(?=.)/i)?.[1]?.toLowerCase();
+    // A web address must name a host: refuses `https://`, `http:///path` (read as
+    // a host named `path`), `https://@` and the like.
+    if (protocol === 'http' || protocol === 'https') {
+        try {
+            return /^https?:\/\/[^/?#\\\s]/i.test(cleaned) && /[\p{L}\p{N}]/u.test(new URL(cleaned).hostname);
+        }
+        catch {
+            return false;
+        }
+    }
+    return protocol === 'mailto' || protocol === 'tel';
+};
+const held = (node, key) => node[key];
+/**
+ * Why a value is no Lexical editor state a `richText` column may hold, or nothing. Runs before
+ * any Lexical code reads the value; a `style` is refused, since no editor of the project writes one.
+ */
+export const richTextGuard = (value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return 'The value is no object.';
+    const nested = within(value, richTextBounds.depth);
+    if (nested)
+        return nested;
+    if (new TextEncoder().encode(JSON.stringify(value)).length > richTextBounds.bytes)
+        return `The value is larger than ${richTextBounds.bytes} bytes.`;
+    const root = held(value, 'root');
+    if (!root || typeof root !== 'object' || Array.isArray(root) || held(root, 'type') !== 'root')
+        return 'The value has no root of type "root".';
+    if (!Array.isArray(held(root, 'children')))
+        return 'The root holds no list of children.';
+    let count = 0;
+    const walk = (node) => {
+        if (!node || typeof node !== 'object' || Array.isArray(node) || typeof held(node, 'type') !== 'string')
+            return 'A node is no object with a string type.';
+        if (++count > richTextBounds.nodes)
+            return `The value holds more than ${richTextBounds.nodes} nodes.`;
+        const type = held(node, 'type');
+        if (Object.hasOwn(node, 'text') && typeof held(node, 'text') !== 'string')
+            return `A node of type "${type}" holds text that is no string.`;
+        if (typeof held(node, 'text') === 'string') {
+            for (const key of ['format', 'detail']) {
+                if (Object.hasOwn(node, key) && !Number.isInteger(held(node, key)))
+                    return `A node of type "${type}" holds a ${key} that is no whole number.`;
+            }
+        }
+        for (const key of ['style', 'textStyle']) {
+            if (Object.hasOwn(node, key) && held(node, key) !== '')
+                return `A node of type "${type}" holds a ${key}, and this editor writes none.`;
+        }
+        if ((type === 'link' || type === 'autolink') && !safeUrl(held(node, 'url')))
+            return `A link points at an address that is not http, https, mailto, tel or a path.`;
+        if (!Object.hasOwn(node, 'children'))
+            return undefined;
+        const children = held(node, 'children');
+        if (!Array.isArray(children))
+            return `A node of type "${type}" holds children that are no list.`;
+        for (const child of children) {
+            const refused = walk(child);
+            if (refused)
+                return refused;
+        }
+        return undefined;
+    };
+    return walk(root);
+};
+/** Whether a value passes `richTextGuard`, which is all the kind itself asks of one. */
+export const isRichText = (value) => richTextGuard(value) === undefined;
+/**
+ * The first node type under a value's `root` that `types` does not hold, or nothing, and `''`
+ * past the depth bound. Read off the JSON, since a production Lexical minifies its errors.
+ */
+export const unknownType = ({ node, types, depth = richTextBounds.depth }) => {
+    if (!node || typeof node !== 'object')
+        return undefined;
+    if (depth <= 0)
+        return '';
+    const held = node;
+    if (typeof held.type === 'string' && !types.has(held.type))
+        return held.type;
+    for (const child of Array.isArray(held.children) ? held.children : []) {
+        const type = unknownType({ node: child, types, depth: depth - 1 });
+        if (type !== undefined)
+            return type;
+    }
+    return undefined;
+};
+/**
+ * How a stored `richText` value is read back: a root with children and nothing more,
+ * so a value holding a node the project has since dropped still reads.
+ */
+export const storedRichText = (value) => {
+    const root = value && typeof value === 'object' && !Array.isArray(value) ? value.root : undefined;
+    return root && typeof root === 'object' && root.type === 'root' && Array.isArray(root.children) ? { text: '' } : { refused: 'The stored value is no editor state.' };
+};

package/dist/screen/client.d.ts

@@ -1,6 +1,8 @@
+export { flattenMessageFile } from '../mithaq/message-file.ts';
 export { afterCommitHeader } from '../asas/runner/errors.ts';
 export { allowedType } from '../storage/allowed-type.ts';
 export { compareDecimals, decimalDigits, isDecimal } from '../base/decimal.ts';
+export { isJson } from '../base/kinds.ts';
 export type { ButtonClient, ClientField, ClientKayan, FrameClient, LeafClient, NavEntry, NodeClient, PageClient, RegionsClient, ScreenClient, ScreenPageClient, } from './index.ts';
 import type { ClientField, NavEntry, PageClient, ScreenClient } from './index.ts';
 export { compareValues, matchesWhere, same } from '../mithaq/where.ts';
@@ -130,6 +132,7 @@ export declare const builtInScreenKinds: {
     readonly date: readonly ["date"];
     readonly textArray: readonly ["textArray"];
     readonly uuid: readonly ["uuid"];
+    readonly json: readonly ["json"];
     readonly relationship: readonly ["relationship", "upload"];
     readonly join: readonly ["join"];
     readonly switch: readonly ["checkbox"];
@@ -147,7 +150,7 @@ export declare const builtInScreenKinds: {
     readonly calendar: readonly ["date"];
 };
 /** Every control and cell the copied registry ships, by the name it looks each up by. */
-export declare const registryControls: readonly [...("buttonGroup" | "calendar" | "checkbox" | "checkboxGroup" | "combobox" | "date" | "datetime" | "decimal" | "email" | "integer" | "nativeSelect" | "number" | "otp" | "radio" | "relationship" | "select" | "slider" | "switch" | "text" | "textArray" | "textarea" | "toggle" | "toggleGroup" | "uuid")[], "richText", "upload"];
-export declare const registryCells: readonly ['text', 'email', 'number', 'integer', 'decimal', 'checkbox', 'datetime', 'date', 'textArray', 'uuid', 'relationship', 'join', 'richText', 'upload'];
+export declare const registryControls: readonly [...("buttonGroup" | "calendar" | "checkbox" | "checkboxGroup" | "combobox" | "date" | "datetime" | "decimal" | "email" | "integer" | "json" | "nativeSelect" | "number" | "otp" | "radio" | "relationship" | "select" | "slider" | "switch" | "text" | "textArray" | "textarea" | "toggle" | "toggleGroup" | "uuid")[], "richText", "upload"];
+export declare const registryCells: readonly ['text', 'email', 'number', 'integer', 'decimal', 'checkbox', 'datetime', 'date', 'textArray', 'uuid', 'json', 'relationship', 'join', 'richText', 'upload'];
 /** The built-in controls that draw a field's `options`; the build refuses one over a field that declares none. */
 export declare const choiceControls: string[];

package/dist/screen/client.js

@@ -1,8 +1,10 @@
 // Every runtime import of this entry imports nothing but types, so a browser
 // receives no server code and no framework.
+export { flattenMessageFile } from '../mithaq/message-file.js';
 export { afterCommitHeader } from '../asas/runner/errors.js';
 export { allowedType } from '../storage/allowed-type.js';
 export { compareDecimals, decimalDigits, isDecimal } from '../base/decimal.js';
+export { isJson } from '../base/kinds.js';
 export { compareValues, matchesWhere, same } from '../mithaq/where.js';
 /** Whether the access report lets its actor hold one catalog key: a screen's, an operation's, or any other key. */
 export const holds = (report, key) => {
@@ -15,7 +17,7 @@ export const holds = (report, key) => {
         return operations[action] === true;
     return report.permissions === '*' || report.permissions?.includes(key) === true;
 };
-// A reference prints the package name into a glob's base, `/node_modules/<name>/`,
+// `mithaq generate screens` looks a reference's package up as `node_modules/<name>/`,
 // so no path up, absolute path or space may cross.
 const npmName = '(?:@[a-z0-9~-][a-z0-9._~-]*/)?[a-z0-9~-][a-z0-9._~-]*';
 export const packageName = new RegExp(`^${npmName}$`, 'i');
@@ -40,6 +42,7 @@ export const builtInScreenKinds = {
     date: ['date'],
     textArray: ['textArray'],
     uuid: ['uuid'],
+    json: ['json'],
     // A file is a row of a storage kayan, so the picker of rows draws it too.
     relationship: ['relationship', 'upload'],
     join: ['join'],
@@ -63,6 +66,6 @@ export const registryControls = [
     'richText',
     'upload',
 ];
-export const registryCells = ['text', 'email', 'number', 'integer', 'decimal', 'checkbox', 'datetime', 'date', 'textArray', 'uuid', 'relationship', 'join', 'richText', 'upload'];
+export const registryCells = ['text', 'email', 'number', 'integer', 'decimal', 'checkbox', 'datetime', 'date', 'textArray', 'uuid', 'json', 'relationship', 'join', 'richText', 'upload'];
 /** The built-in controls that draw a field's `options`; the build refuses one over a field that declares none. */
 export const choiceControls = ['radio', 'toggleGroup', 'select', 'nativeSelect', 'combobox', 'buttonGroup', 'checkboxGroup'];