@fougere/schema 0.12.1-alpha.0 → 0.12.2-alpha.0

package/src/projection/Visibility.ts

@@ -15,21 +15,23 @@ export class Visibility {
     const result: Fields = {};
     for (const [name, field] of Object.entries(this.fields)) {
       const role = Role.of(field);
-      if (role.isPrimary) continue;
-      if (Lifecycle.of(field).stampedAtCreate) continue;
-      if (role.isCollection) continue;
-      if (Boundary.of(field).readOnly) continue;
+      if (role.isPrimary()) continue;
+      if (Lifecycle.of(field).stampedAtCreate()) continue;
+      if (role.isCollection()) continue;
+      if (Boundary.of(field).readOnly()) continue;
       result[name] = field;
     }
+
     return result;
   }
 
   get output(): Fields {
     const result: Fields = {};
     for (const [name, field] of Object.entries(this.fields)) {
-      if (Boundary.of(field).writeOnly) continue;
+      if (Boundary.of(field).writeOnly()) continue;
       result[name] = field;
     }
+
     return result;
   }
 
@@ -60,7 +62,7 @@ export class Visibility {
     for (const [key, field] of Object.entries(this.fields)) {
       if (!(key in record)) continue;
       const boundary = Boundary.of(field);
-      if (boundary.writeOnly) {
+      if (boundary.writeOnly()) {
         delete out[key];
         continue;
       }
@@ -68,6 +70,7 @@ export class Visibility {
       if (value === null || value === undefined) continue;
       out[key] = boundary.encode(value);
     }
+
     return out;
   }
 }

package/src/projection/card/Bundle.ts

@@ -56,6 +56,7 @@ export class Bundle {
       byName[name.toLowerCase()] = schema as unknown as EntityConstructor;
       schemas[name] = schema;
     }
+
     return schemas;
   }
 
@@ -72,6 +73,7 @@ export class Bundle {
       );
       if (diff.changes.length > 0 || diff.ambiguous.length > 0) entities[name] = diff;
     }
+
     return {
       entitiesAdded: Object.keys(after).filter((name) => !(name in before)),
       entitiesRemoved: Object.keys(before).filter((name) => !(name in after)),

package/src/projection/card/Card.ts

@@ -39,10 +39,11 @@ export class Card<T = Values<Fields>> {
     const required: string[] = [];
     for (const [key, field] of Object.entries(fields)) {
       properties[key] = describeField(field, key);
-      if (validator.onAbsent(field) === null) required.push(key);
+      if (validator.requires(field)) required.push(key);
     }
-    for (const group of schema.getUnique() ?? [])
-      for (const member of group) carryGroup(properties[member], group);
+    for (const kind of ['unique', 'index'] as const)
+      for (const group of (kind === 'unique' ? schema.getUnique() : schema.getIndex()) ?? [])
+        for (const member of group) carryGroup(properties[member], kind, group);
 
     const descriptor: SchemaDescriptor = {
       type: 'object',
@@ -56,6 +57,7 @@ export class Card<T = Values<Fields>> {
 
     const origin = originOf(schema);
     if (origin) descriptor['x-fougere-derived'] = origin;
+
     return new Card<Values<TFields>>(descriptor);
   }
 
@@ -95,7 +97,7 @@ export class Card<T = Values<Fields>> {
     }
 
     const fields: Fields = {};
-    const groups: string[][] = [];
+    const groups: { unique: string[][]; index: string[][] } = { unique: [], index: [] };
     for (const [key, property] of Object.entries(descriptor.properties)) {
       if (!isObject(property)) {
         refuse(
@@ -104,13 +106,15 @@ export class Card<T = Values<Fields>> {
         );
       }
       fields[key] = reconstructField(property, key, resolve);
-      for (const group of property['x-fougere']?.role?.unique ?? [])
-        if (group.length > 1) groups.push([...group]);
+      for (const kind of ['unique', 'index'] as const)
+        for (const group of property['x-fougere']?.role?.[kind] ?? [])
+          if (group.length > 1) groups[kind].push([...group]);
     }
     const schema = Schema.of({ fields, constraints: SchemaConstraints.of(groups) });
     const title = name ?? descriptor.title;
     if (title)
       Object.defineProperty(schema, 'name', { value: title, configurable: true });
+
     return schema as unknown as SchemaConstructor<FieldsOf<T>>;
   }
 
@@ -127,14 +131,13 @@ export class Card<T = Values<Fields>> {
  */
 function describeExtension(field: Field, key: string): FieldExtension | undefined {
   const extension: Record<string, unknown> = {};
-  for (const slot of Axes.names) {
-    const declared = (field as unknown as Record<string, unknown>)[slot];
-    if (declared === undefined) continue;
-    const form = CardForms.find(slot);
+  for (const [name, declared] of Object.entries(field.axes)) {
+    const form = CardForms.find(name);
     const wire = form ? form.describe(declared, key) : declared;
-    if (wire !== undefined) extension[slot] = wire;
+    if (wire !== undefined) extension[name] = wire;
   }
   clean(extension);
+
   return Object.keys(extension).length ? (extension as FieldExtension) : undefined;
 }
 
@@ -142,9 +145,9 @@ function describeField(field: Field, key: string): FieldDescriptor {
   // The shape IS JSON Schema, so it lands whole rather than key by key — which is what let
   // it be copied under a computed key into a type that names its own.
   const descriptor: FieldDescriptor = clean({ ...field.shape }) as FieldDescriptor;
-  if (field.meta?.description) descriptor.description = field.meta.description;
   const extension = describeExtension(field, key);
   if (extension) descriptor['x-fougere'] = extension;
+
   return descriptor;
 }
 
@@ -159,6 +162,7 @@ function originOf(schema: SchemaView): DerivedFrom | undefined {
   const nameOf = Object.fromEntries(
     Object.entries(derivation.nameOf).map(([key, value]) => [key, value ?? null]),
   );
+
   return { from: derivation.sourceName, nameOf };
 }
 
@@ -177,7 +181,7 @@ function reconstructShape(property: FieldDescriptor): Field['shape'] | undefined
 
   // `describeField` writes the shape whole, so it is read whole: a list of keywords here
   // would be a second inventory, and the one that forgets a keyword loses it in silence.
-  const { 'x-fougere': _extension, description: _description, ...shape } = property;
+  const { 'x-fougere': _extension, ...shape } = property;
   if (shape.items) shape.items = reconstructShape(shape.items) as FieldDescriptor;
 
   return clean(shape) as Field['shape'];
@@ -203,19 +207,13 @@ function reconstructField(
   admitPatterns(shape, `Field '${key}'`);
   const extension = property['x-fougere'];
   const axes: Record<string, unknown> = {};
-  for (const slot of Axes.names) {
-    const wire = (extension as Record<string, unknown> | undefined)?.[slot];
-    const form = CardForms.find(slot);
-    if (wire !== undefined) axes[slot] = form ? form.reconstruct(wire, resolve) : wire;
+  for (const name of Axes.names) {
+    const wire = (extension as Record<string, unknown> | undefined)?.[name];
+    const form = CardForms.find(name);
+    if (wire !== undefined) axes[name] = form ? form.reconstruct(wire, resolve) : wire;
   }
-  return new Field({
-    shape,
-    ...axes,
-    meta:
-      property.description !== undefined
-        ? { description: property.description }
-        : undefined,
-  } as never, key);
+
+  return new Field({ shape, ...axes } as never, key);
 }
 
 /**
@@ -225,10 +223,11 @@ function reconstructField(
  */
 function carryGroup(
   property: FieldDescriptor | undefined,
+  kind: 'unique' | 'index',
   group: readonly string[],
 ): void {
   if (!property) return;
-  const extension = (property['x-fougere'] ??= {}) as { role?: { unique?: string[][] } };
+  const extension = (property['x-fougere'] ??= {}) as { role?: Record<string, string[][]> };
   const role = (extension.role ??= {});
-  (role.unique ??= []).push([...group]);
+  (role[kind] ??= []).push([...group]);
 }

package/src/projection/card/CardForms.ts

@@ -8,6 +8,6 @@ import { roleOnCard } from './RoleDescriptor.js';
  * FR : les axes qu'une carte écrit autrement que déclarés ; les autres voyagent tels quels.
  * `CardForms.register('tenancy', tenancyOnCard)`
  */
-export const CardForms = new Registry<CardForm>('card form', 'call CardForms.register(slot, form)', [
+export const CardForms = new Registry<CardForm>('card form', 'call CardForms.register(name, form)', [
   ['role', roleOnCard as CardForm],
 ]);

package/src/projection/card/Diff.ts

@@ -107,6 +107,7 @@ function restated(
 
 function shapeOf(descriptor: FieldDescriptor): Record<string, unknown> {
   const { 'x-fougere': _extension, description: _description, ...shape } = descriptor;
+
   return shape as Record<string, unknown>;
 }
 
@@ -118,6 +119,7 @@ function shapeOf(descriptor: FieldDescriptor): Record<string, unknown> {
 function typesOf(descriptor: FieldDescriptor): TypeSet {
   const type = descriptor.type;
   if (type === undefined) return [];
+
   return (Array.isArray(type) ? [...type] : [type]).sort();
 }
 
@@ -128,6 +130,7 @@ function typesOf(descriptor: FieldDescriptor): TypeSet {
  */
 function boundsOf(descriptor: FieldDescriptor): Record<string, unknown> {
   const { type: _type, ...rest } = shapeOf(descriptor);
+
   return rest;
 }
 
@@ -153,5 +156,6 @@ function candidates(
   const now = Object.keys(after);
   const apart = ({ removed: gone, added: appeared }: RenameCandidate): number =>
     Math.abs(now.indexOf(appeared) - was.indexOf(gone));
+
   return found.sort((a, b) => apart(a) - apart(b));
 }

package/src/projection/card/FieldExtension.ts

@@ -7,6 +7,6 @@ export interface FieldExtension {
   lifecycle?: LifecycleRules;
   boundary?: BoundaryRef;
 
-  /** An axis registered from outside writes its own slot here, under its own name. */
-  [slot: string]: unknown;
+  /** An axis registered from outside writes here, under its own name. */
+  [axis: string]: unknown;
 }

package/src/projection/card/RoleDescriptor.ts

@@ -5,9 +5,14 @@ import type { Resolver } from '../../axis/Resolver.js';
 import { lowerFirst } from '../../lib/utils.js';
 import type { CardForm } from './CardForm.js';
 
-/** What a role becomes on a card: a target is a NAME there, and a unique is a group. */
-export type RoleDescriptor = Pick<RoleRules, 'primary' | 'index'> & {
+/**
+ * What a role becomes on a card: a target is a NAME there, and `unique` and `index` are both
+ * GROUPS — the field says `true`, the card says which names go together, since a group of
+ * several belongs to no single field.
+ */
+export type RoleDescriptor = Pick<RoleRules, 'primary'> & {
   unique?: string[][];
+  index?: string[][];
   relation?: RelationDescriptor;
 };
 
@@ -21,7 +26,7 @@ export const roleOnCard: CardForm<RoleRules, RoleDescriptor> = {
     const descriptor: Mutable<RoleDescriptor> = {};
     if (role.primary) descriptor.primary = true;
     if (role.unique) descriptor.unique = [[key]];
-    if (role.index) descriptor.index = true;
+    if (role.index) descriptor.index = [[key]];
     if (role.relation) {
       const target = role.relation.to() as { name?: string };
       descriptor.relation = {
@@ -38,7 +43,7 @@ export const roleOnCard: CardForm<RoleRules, RoleDescriptor> = {
     const rules: Mutable<RoleRules> = {};
     if (wire.primary) rules.primary = true;
     if (wire.unique?.some((group) => group.length === 1)) rules.unique = true;
-    if (wire.index) rules.index = true;
+    if (wire.index?.some((group) => group.length === 1)) rules.index = true;
     if (wire.relation) {
       const name = wire.relation.to;
       rules.relation = {

package/src/projection/card/ShapeKeywords.ts

@@ -1,7 +1,7 @@
 import type { Shape } from '../../axis/shape/Shape.js';
+import type { UnionToIntersection } from '../../lib/UnionToIntersection.js';
 
 type KeywordsOf<S> = S extends unknown ? Partial<Omit<S, 'type' | 'items' | 'properties'>> : never;
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 
 /** Every keyword any shape may carry, flattened — what a descriptor records of one. */
 export type ShapeKeywords = UnionToIntersection<KeywordsOf<Shape>>;

package/src/validator/FieldDeclarationValidator.ts

@@ -1,7 +1,7 @@
 import { Axes } from '../axis/Axes.js';
-import { Shapes } from '../axis/shape/Shape.js';
 import type { Field } from '../field/Field.js';
-import { isObject, shown } from '../lib/utils.js';
+import { isObject } from '../lib/utils.js';
+import { SchemaError } from '../SchemaError.js';
 import type { ValidationError } from '../lib/ValidationError.js';
 import type { ValidationResult } from '../lib/ValidationResult.js';
 import { JsonSchemaValidator } from './JsonSchemaValidator.js';
@@ -22,7 +22,7 @@ export class FieldDeclarationValidator {
         errors: [
           {
             path: [],
-            message: `Expected an object — got ${shown(declaration)}`,
+            message: `Expected an object — got ${SchemaError.inspect(declaration)}`,
           },
         ],
       };
@@ -30,17 +30,14 @@ export class FieldDeclarationValidator {
 
     const errors: ValidationError[] = [];
 
-    if (!Shapes.is(declaration.shape)) {
-      errors.push({
-        path: ['shape'],
-        message: `Every field states a shape — got ${shown(declaration.shape)}`,
-      });
+    if (declaration.shape === undefined) {
+      errors.push({ path: ['shape'], message: 'Every field states a shape' });
     }
 
     errors.push(...JsonSchemaValidator.of(Axes.fieldFormat).refusalsOf(declaration, []));
 
-    for (const [slot, axis] of Axes.entries) {
-      errors.push(...(axis.refusals?.(declaration[slot]) ?? []));
+    for (const [name, axis] of Axes.entries) {
+      errors.push(...(axis.refusals?.(declaration[name], declaration) ?? []));
     }
 
     return errors.length

package/src/validator/FieldValueValidator.ts

@@ -30,7 +30,6 @@ export class FieldValueValidator {
     const type = Shapes.typeOf(shape);
     const base = Shapes.of(shape).base;
     if (value !== null) {
-      if (base?.type === 'object' && !base.properties) return { value };
       if (type === 'date' && value instanceof Date) {
         return Number.isNaN(value.getTime()) ? { message: 'Invalid date' } : { value };
       }
@@ -46,6 +45,7 @@ export class FieldValueValidator {
     if (plan.custom && typeof value === 'string' && !plan.custom(value)) {
       return { message: `String does not match format "${plan.formatName}".` };
     }
+
     return { value };
   }
 
@@ -72,6 +72,7 @@ export class FieldValueValidator {
       };
       this.plans.set(shape, plan);
     }
+
     return plan;
   }
 
@@ -83,6 +84,7 @@ export class FieldValueValidator {
           `the engine validates ${Object.keys(engineFormats).length} formats natively and this is not one of them.`,
       );
     }
+
     return custom;
   }
 }

package/src/validator/InputValidator.ts

@@ -1,3 +1,4 @@
+import { Axes } from '../axis/Axes.js';
 import { Boundary } from '../axis/boundary/Boundary.js';
 import { Lifecycle } from '../axis/lifecycle/Lifecycle.js';
 import { Role } from '../axis/role/Role.js';
@@ -20,11 +21,14 @@ export class InputValidator {
     return new InputValidator(fields, options);
   }
 
-  onAbsent(field: Field): 'skip' | 'empty-list' | null {
-    if (Boundary.of(field).readOnly) return 'skip';
-    if (!Lifecycle.of(field).requiredAtCreate) return 'skip';
-    if (Role.of(field).isCollection) return 'empty-list';
-    return null;
+  /**
+   * The three REGISTERED axes decide, and the shape is not one of them — it could not answer
+   * anyway: `nullable(text())` and `optional(text())` both shape `['string', 'null']`, and only
+   * the second dispenses. JSON Schema draws the same line, where `required` is a list on the
+   * OBJECT and never a keyword on the property.
+   */
+  requires(field: Field): boolean {
+    return !Axes.all.some((axis) => axis.admitsAbsence?.(field));
   }
 
   /** Hands on the value it PARSED, so a handler never re-checks a row. */
@@ -43,7 +47,8 @@ export class InputValidator {
     for (const [key, field] of Object.entries(this.fields)) {
       const verdict = this.admit(field, data[key]);
       if (verdict === undefined) continue;
-      if ('message' in verdict) errors.push({ path: [key, ...(verdict.path ?? [])], message: verdict.message });
+      if ('message' in verdict)
+        errors.push({ path: [key, ...(verdict.path ?? [])], message: verdict.message });
       else row[key] = verdict.value;
     }
 
@@ -61,8 +66,11 @@ export class InputValidator {
   private admit(field: Field, value: unknown): Verdict | undefined {
     if (value === undefined) return this.whenAbsent(field);
 
-    if (Boundary.of(field).readOnly) return { message: InputRefusal.readOnly };
-    if (this.options.patch && Lifecycle.of(field).immutable) return { message: InputRefusal.immutable };
+    if (Boundary.of(field).readOnly()) return { message: InputRefusal.readOnly };
+    // The other side of the relation carries the key: there is nothing to write here.
+    if (Role.of(field).isCollection()) return { message: InputRefusal.readOnly };
+    if (this.options.patch && Lifecycle.of(field).immutable())
+      return { message: InputRefusal.immutable };
 
     return FieldValueValidator.of(field).parse(value);
   }
@@ -70,9 +78,6 @@ export class InputValidator {
   private whenAbsent(field: Field): Verdict | undefined {
     if (this.options.patch) return undefined;
 
-    const absence = this.onAbsent(field);
-    if (absence === null) return { message: InputRefusal.required };
-
-    return absence === 'empty-list' ? { value: [] } : undefined;
+    return this.requires(field) ? { message: InputRefusal.required } : undefined;
   }
 }

package/src/vocabulary/preset/created.ts

@@ -1,8 +1,8 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Described } from '../../field/Field.js';
 import { date } from '../primitive/date.js';
 
-export function created(): Field<Date> {
-  return date().with({
+export function created(opts?: Described): Field<Date> {
+  return date(opts).with({
     lifecycle: { create: 'now', update: 'forbidden' },
   });
 }

package/src/vocabulary/preset/updated.ts

@@ -1,7 +1,8 @@
+import { Field, type Described } from '../../field/Field.js';
 import { created } from './created.js';
-import { Field } from '../../field/Field.js';
 
-export function updated(): Field<Date> {
-  const base = created();
+export function updated(opts?: Described): Field<Date> {
+  const base = created(opts);
+
   return base.with({ lifecycle: { ...base.lifecycle, update: 'now' } });
 }

package/src/vocabulary/primitive/bool.ts

@@ -1,10 +1,5 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Shared } from '../../field/Field.js';
 
-export function bool(opts?: { default?: boolean; description?: string }): Field<boolean> {
-  return new Field<boolean>({
-    shape: { type: 'boolean' },
-    lifecycle:
-      opts?.default !== undefined ? { create: { value: opts.default } } : undefined,
-    meta: opts?.description !== undefined ? { description: opts.description } : undefined,
-  });
+export function bool(opts?: Shared<boolean>): Field<boolean> {
+  return new Field<boolean>({ shape: { type: 'boolean' } }).setShared(opts);
 }

package/src/vocabulary/primitive/date.ts

@@ -1,10 +1,11 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Shared } from '../../field/Field.js';
 
 /**
  * A `Date` in a handler, an ISO string on the wire — the `isoDate` boundary converts.
- * FR : un `Date` dans un handler, une chaîne ISO sur le fil — `isoDate` convertit.
  * `date()` → `{ type: 'string', format: 'date-time' }`
  */
-export function date(): Field<Date> {
-  return new Field<Date>({ shape: { type: 'string', format: 'date-time' } });
+export function date(opts?: Shared<Date>): Field<Date> {
+  return new Field<Date>({ shape: { type: 'string', format: 'date-time' } }).setShared(
+    opts,
+  );
 }

package/src/vocabulary/primitive/json.ts

@@ -1,29 +1,44 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Shared } from '../../field/Field.js';
 import type { SchemaView } from '../../SchemaView.js';
 import { InputValidator } from '../../validator/InputValidator.js';
+import { SchemaError } from '../../SchemaError.js';
 
-export function json<T = unknown>(): Field<T>;
+type Entity = SchemaView & (new (...args: never[]) => unknown);
+
+export function json<T = unknown>(opts?: Shared<T>): Field<T>;
 export function json<E extends SchemaView & (new (...args: any[]) => any)>(
   of: E,
+  opts?: Shared<InstanceType<E>>,
 ): Field<InstanceType<E>>;
+
 /**
- * `json(Address)` where the object has a shape; `json()` alone admits any shape forever.
- * FR : `json(Address)` quand l'objet a une forme ; `json()` seul admet tout, à jamais.
  * `json(Address)` → the entity's properties, and its required keys
  */
-export function json(of?: SchemaView): Field<unknown> {
-  if (!of) return new Field({ shape: { type: 'object' } });
-  const fields = of.getFields();
+export function json(
+  of?: Entity | Shared<unknown>,
+  opts?: Shared<unknown>,
+): Field<unknown> {
+  const [schema, shared] = typeof of === 'function' ? [of, opts] : [undefined, of];
+
+  if (schema && typeof schema.getFields !== 'function')
+    throw new SchemaError(
+      'json() takes an entity, such as json(Address) — got a function that is not one',
+    );
+
+  if (!schema) return new Field({ shape: { type: 'object' } }).setShared(shared);
+
+  const fields = schema.getFields();
   const validator = InputValidator.of(fields);
   const properties: Record<string, unknown> = {};
   const required: string[] = [];
+
   for (const [key, field] of Object.entries(fields)) {
-    properties[key] = field.meta?.description
-      ? { ...field.shape, description: field.meta.description }
-      : field.shape;
-    if (validator.onAbsent(field) === null) required.push(key);
+    properties[key] = field.shape;
+
+    if (validator.requires(field)) required.push(key);
   }
+
   return new Field({
     shape: { type: 'object', properties, ...(required.length ? { required } : {}) },
-  });
+  }).setShared(shared);
 }

package/src/vocabulary/primitive/list.ts

@@ -1,22 +1,29 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Shared } from '../../field/Field.js';
 import { SchemaError } from '../../SchemaError.js';
 
-export interface ListOptions {
+export interface ListOptions<T = unknown> extends Shared<T[]> {
   min?: number;
   max?: number;
 }
 
 /**
- * A list of VALUES. The other side of a relation is `many()`, and passing one here throws.
- * FR : une liste de VALEURS. L'autre côté d'une relation est `many()`, et en passer une ici lève.
+ * A list of values. It keeps the shape of the item and nothing else: `nullable()` and a
+ * `description` write in the shape, so they work. A rule writes beside it, and an item of a
+ * list has no key, no column and no name to keep it on.
  * `list(text(), { max: 5 })` → `{ type: 'array', items: { type: 'string' }, maxItems: 5 }`
  */
-export function list<T>(item: Field<T>, opts?: ListOptions): Field<T[]> {
-  if (item.role?.relation)
+export function list<T>(field: Field<T>, opts?: ListOptions<T>): Field<T[]> {
+  if (field.hasAxes())
     throw new SchemaError(
-      'list() takes a value field (text(), number()…) — a relation has no value shape',
+      'list() takes a value, not a rule. Put the rule on the list: unique(list(text())).',
     );
+
   return new Field<T[]>({
-    shape: { type: 'array', items: item.shape, minItems: opts?.min, maxItems: opts?.max },
-  });
+    shape: {
+      type: 'array',
+      items: field.shape,
+      minItems: opts?.min,
+      maxItems: opts?.max,
+    },
+  }).setShared(opts);
 }

package/src/vocabulary/primitive/many.ts

@@ -1,17 +1,16 @@
 import { type EntityConstructor } from '../../axis/role/EntityConstructor.js';
 import { Relation } from '../../axis/role/Relation.js';
-import { Field } from '../../field/Field.js';
+import { Field, type Described } from '../../field/Field.js';
 
 /**
- * The far side of a `ref()`: no column of its own, and absent from what a client sends.
- * FR : l'autre côté d'un `ref()` : aucune colonne à lui, et absent de ce qu'un client envoie.
  * `many(() => Post)` → `{ type: 'array' }` with `role.relation.kind` `'many'`
  */
 export function many<E extends EntityConstructor>(
   target: E | (() => E),
+  opts?: Described,
 ): Field<InstanceType<E>[]> {
   return new Field<InstanceType<E>[]>({
     shape: { type: 'array' },
     role: { relation: Relation.many(target) },
-  });
+  }).setShared(opts);
 }

package/src/vocabulary/primitive/number.ts

@@ -1,11 +1,9 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Shared } from '../../field/Field.js';
 
-export interface NumberOptions {
+export interface NumberOptions extends Shared<number> {
   min?: number;
   max?: number;
   integer?: boolean;
-  default?: number;
-  description?: string;
 }
 
 export function number(opts?: NumberOptions): Field<number> {
@@ -15,8 +13,5 @@ export function number(opts?: NumberOptions): Field<number> {
       minimum: opts?.min,
       maximum: opts?.max,
     },
-    lifecycle:
-      opts?.default !== undefined ? { create: { value: opts.default } } : undefined,
-    meta: opts?.description !== undefined ? { description: opts.description } : undefined,
-  });
+  }).setShared(opts);
 }