@afora/core 0.0.4 → 0.0.6

package/README.md

@@ -335,6 +335,8 @@ Where the others win: Zod and Valibot are faster, have far larger ecosystems and
 
 ## Contributing
 
+Issues open from a template: bug report, feature request, or feedback from building on afora. Questions go to [Discussions](https://github.com/afora-framework/core/discussions). Pull requests follow [the PR template](.github/PULL_REQUEST_TEMPLATE.md).
+
 Commits follow [Conventional Commits](https://www.conventionalcommits.org) (`feat(repository): …`, `fix: …`), checked by commitlint in a Husky `commit-msg` hook; the `pre-commit` hook runs Biome and Knip. CI runs lint, Knip, type checks, unit and interop tests, the build and the Node smoke test on every push and pull request. Pushing a `v*` tag that matches `package.json` publishes to npm with provenance.
 
 Scripts:

package/dist/core/application/exceptions.d.ts

@@ -40,6 +40,15 @@ export declare const ApplicationNotStarted: import("../../index.js").DeclaredExc
     /** The application, or none when `useApplication()` found none started. */
     readonly application?: string;
 }>;
+/**
+ * A repository read or wrote through a provider of `providersOf` made by
+ * `providerFrom` outside an application: an application that registers the
+ * storage makes it on start, and its bound repositories use it.
+ */
+export declare const ProviderNotBound: import("../../index.js").DeclaredExceptionClass<{
+    /** The key of the provider in its storage. */
+    readonly provider: string;
+}>;
 /**
  * `app.start()` was called while another application is the started one of
  * the process; `start({ replace: true })` stops it and takes its place.

package/dist/core/application/providers.d.ts

@@ -0,0 +1,46 @@
+import type { IRepositoryProvider } from "../repository/types/repository.interface.js";
+import { Kind } from "../symbols/kind.js";
+import { type ProviderFactory } from "./start.js";
+/**
+ * One provider of a storage made by `providersOf`, e.g. `Providers.audit`:
+ * what a repository (`repositoryOf({ provider: Providers.audit })`) or an
+ * application (`provider: Providers.main`) names. Each application that
+ * registers the storage reads and writes through its own instance of it.
+ */
+export type ProviderSlot<Key extends string = string> = IRepositoryProvider & {
+    readonly [Kind]: "provider-slot";
+    /** Its key in the storage. */
+    readonly key: Key;
+};
+/** The providers of `providersOf`, by key. */
+export type ProviderStorage<Keys extends string = string> = {
+    readonly [Key in Keys]: ProviderSlot<Key>;
+} & {
+    readonly [Kind]: "provider-storage";
+};
+/** What a slot stands for. */
+interface SlotEntry {
+    readonly key: string;
+    readonly storage: object;
+    readonly value: IRepositoryProvider | ProviderFactory;
+}
+/**
+ * Named providers, declared once in a module of their own so that
+ * repositories can name one before any application exists, e.g.
+ * `const Providers = providersOf({ main: providerFrom(Database, ...), audit: auditProvider() })`,
+ * then `repositoryOf({ ..., provider: Providers.audit })` and
+ * `applicationOf({ providers: Providers, provider: Providers.main, ... })`.
+ * Each value is a provider or a factory of `providerFrom`; an application
+ * that registers the storage makes each factory on `start()`, its own
+ * instance (an application that extends it shares them).
+ */
+export declare function providersOf<const Entries extends Readonly<Record<string, IRepositoryProvider | ProviderFactory>>>(entries: Entries): ProviderStorage<keyof Entries & string>;
+/** Whether `value` is a provider of a storage made by `providersOf`. */
+export declare function isProviderSlot(value: unknown): value is ProviderSlot;
+/** Whether `value` is a storage made by `providersOf`. */
+export declare function isProviderStorage(value: unknown): value is ProviderStorage;
+/** The slots of `storage`, in the order of its keys. @internal */
+export declare function slotsOf(storage: ProviderStorage): readonly ProviderSlot[];
+/** What `slot` stands for. @internal */
+export declare function slotEntry(slot: ProviderSlot): SlotEntry;
+export {};

package/dist/core/application/types/application.interface.d.ts

@@ -1,3 +1,4 @@
+import type { AnyBlueprint, BlueprintInput, IBlueprint } from "../../blueprint/types/blueprint.interface.js";
 import type { AnyCommand } from "../../command/types/command.interface.js";
 import type { AnyEnvironment, EnvironmentValue } from "../../environment/environment.js";
 import type { ExceptionLayers } from "../../exception/enums/exception-layers.js";
@@ -8,9 +9,32 @@ import type { ProviderDescription } from "../../repository/types/query.interface
 import type { AnyRepository, IRepositoryProvider } from "../../repository/types/repository.interface.js";
 import type { Kind } from "../../symbols/kind.js";
 import type { UseCaseStepDescription } from "../../use-case/steps/types/steps.interface.js";
-import type { AnyExceptionClass, AnyUseCaseClass } from "../../use-case/use-case.js";
+import type { AnyExceptionClass, AnyUseCaseClass, UseCaseInput, UseCaseResponse } from "../../use-case/use-case.js";
+import type { ProviderSlot, ProviderStorage } from "../providers.js";
 import type { LogFactory, ProviderFactory } from "../start.js";
 type Named<Value> = Readonly<Record<string, Value>>;
+/**
+ * The options of `app.run`: the `context` of the use case, required when it
+ * declares one, and `dependencies`, what its `execute` takes to replace them.
+ */
+export type ApplicationRunOptions<UseCase extends AnyUseCaseClass> = (UseCase["context"] extends IBlueprint<infer Properties> ? {
+    readonly context: BlueprintInput<Properties>;
+} : {
+    readonly context?: undefined;
+}) & {
+    readonly dependencies?: Parameters<InstanceType<UseCase>["execute"]>[0];
+};
+/**
+ * What `app.run` takes after the use case: its input, optional when no key
+ * of it is required, and the options, required when it declares a context.
+ */
+export type ApplicationRunArgs<UseCase extends AnyUseCaseClass> = UseCase["context"] extends AnyBlueprint ? [input: UseCaseInput<UseCase>, options: ApplicationRunOptions<UseCase>] : {} extends UseCaseInput<UseCase> ? [
+    input?: UseCaseInput<UseCase>,
+    options?: ApplicationRunOptions<UseCase>
+] : [
+    input: UseCaseInput<UseCase>,
+    options?: ApplicationRunOptions<UseCase>
+];
 /** The declarations of an application, by name, one collection for each kind. */
 export interface ApplicationCollections {
     readonly properties: Named<unknown>;
@@ -53,9 +77,18 @@ export interface ApplicationSettings<Name extends string, Extended extends reado
      * The provider of the repositories that did not declare one; the
      * repositories of the application read and write through it. With
      * `providerFrom`, it is made by `app.start()` from the variables of its
-     * environments, and calls before that throw `ApplicationNotStarted`.
+     * environments, and calls before that throw `ApplicationNotStarted`. A
+     * provider of `providers` (`Providers.main`) names the instance this
+     * application makes of it.
      */
     readonly provider?: IRepositoryProvider | ProviderFactory;
+    /**
+     * Named providers made by `providersOf`, which repositories name
+     * (`repositoryOf({ provider: Providers.audit })`). The application makes
+     * its own instance of each `providerFrom` on `start()` and binds the
+     * repositories to it; an application that extends it shares them.
+     */
+    readonly providers?: ProviderStorage;
     /**
      * How it logs: the providers its lines go to and the lowest level kept.
      * Use cases, commands and repository calls of the application are logged
@@ -105,25 +138,29 @@ export interface IApplication<Name extends string, Collections extends Applicati
     readonly entities: Collections["entities"];
     readonly environments: Collections["environments"];
     /**
-     * Its repositories, inherited ones included. With a `provider` they are
-     * bound to it: they share the declaration of the original but read and
-     * write through that provider (unless they declared their own).
+     * Its repositories, inherited ones included. With a `provider` (or
+     * `providers`) they are bound to it: they share the declaration of the
+     * original but read and write through that provider (unless they declared
+     * their own).
      */
     readonly repositories: Collections["repositories"];
     /**
-     * Its use cases. With a `provider` they are subclasses whose repositories
-     * are the bound ones, through child use cases too; the same subclass every
-     * time. Without one they are the declared classes.
+     * Its use cases. With a `provider`, `providers` or `log` they are
+     * subclasses whose repositories are the bound ones, through child use
+     * cases too; the same subclass every time. Without any of them they are
+     * the declared classes.
      */
     readonly useCases: Collections["useCases"];
     /**
-     * Its commands. With a `provider` they are rebuilt over the bound use
-     * cases (same settings), memoized; without one, the declared commands.
+     * Its commands. With a `provider`, `providers` or `log` they are rebuilt
+     * over the bound use cases (same settings), memoized; without any of them,
+     * the declared commands.
      */
     readonly commands: Collections["commands"];
     /**
-     * Its outputs. With a `provider` they are rebuilt over the bound commands
-     * (same name, statuses and stages), memoized; without one, the declared outputs.
+     * Its outputs. With a `provider`, `providers` or `log` they are rebuilt
+     * over the bound commands (same name, statuses and stages), memoized;
+     * without any of them, the declared outputs.
      */
     readonly outputs: Collections["outputs"];
     /** Its exceptions. */
@@ -132,6 +169,13 @@ export interface IApplication<Name extends string, Collections extends Applicati
     repository<Repository extends AnyRepository>(repository: Repository): Repository;
     /** The bound version of a use case registered in the application. */
     useCase<UseCase extends AnyUseCaseClass>(useCase: UseCase): UseCase;
+    /**
+     * Runs a use case registered in the application over its bound
+     * repositories: `new (app.useCase(UseCase))(input, { context }).execute(dependencies)`.
+     * It rejects with what the constructor or `execute` throw. The events the
+     * use case collected are not handled; a command is what dispatches them.
+     */
+    run<UseCase extends AnyUseCaseClass>(useCase: UseCase, ...args: ApplicationRunArgs<UseCase>): Promise<UseCaseResponse<UseCase>>;
     /** The bound version of a command registered in the application. */
     command<Command extends AnyCommand>(command: Command): Command;
     /** The bound version of an output registered in the application. */
@@ -163,6 +207,8 @@ export interface IApplication<Name extends string, Collections extends Applicati
     get<UseCase extends AnyUseCaseClass>(useCase: UseCase): UseCase;
     /** The bound version of a repository registered in the application. */
     get<Repository extends AnyRepository>(repository: Repository): Repository;
+    /** The instance this application reads and writes through for a provider of its `providers`. */
+    get(provider: ProviderSlot): IRepositoryProvider;
     /** Whether `start()` completed and `stop()` was not called since. */
     readonly started: boolean;
 }
@@ -345,13 +391,22 @@ export interface LogDescription {
         readonly kind: "opaque";
     })[];
 }
+/** How `describe` names a provider of `providersOf`: by its key. */
+export interface ProviderReference {
+    readonly kind: "ref";
+    readonly key: string;
+}
 /** The graph `describe` gives: every declaration by name, with its origin in `from`. */
 export interface ApplicationDescription {
     readonly name: string;
     /** The names of the applications it extends directly. */
     readonly extends: readonly string[];
     /** The provider of the application (or of the last extended one), present only when configured. */
-    readonly provider?: ProviderDescription;
+    readonly provider?: ProviderDescription | ProviderReference;
+    /** Its providers of `providersOf` (inherited ones included), by key; present only when it has some. */
+    readonly providers?: Readonly<Record<string, ProviderDescription & {
+        readonly from: string;
+    }>>;
     /** Its `log` (or the one of the last extended application), present only when configured. */
     readonly log?: LogDescription | {
         readonly kind: "opaque";
@@ -378,8 +433,8 @@ export interface ApplicationDescription {
         readonly relations: readonly string[];
         /** The names of its `environmentDependencies`. */
         readonly environments: readonly string[];
-        /** Its own provider, present only when it declared one. */
-        readonly provider?: ProviderDescription;
+        /** Its own provider, present only when it declared one; a provider of `providersOf` by its key. */
+        readonly provider?: ProviderDescription | ProviderReference;
     }>>;
     readonly useCases: Readonly<Record<string, UseCaseDescription>>;
     readonly commands: Readonly<Record<string, CommandDescription>>;

package/dist/core/blueprint/types/slice.interface.d.ts

@@ -1,4 +1,4 @@
-import type { RecordUniqueKeys } from "../../record/types/plugin.interface.js";
+import type { RecordSensitiveKeys, RecordUniqueKeys } from "../../record/types/plugin.interface.js";
 import type { RecordConstructor } from "../../record/types/record.interface.js";
 import type { Meta } from "../../symbols/meta.js";
 import type { AnyBlueprint, AnyBlueprintList, AnyOptionalRecord, AnyRecordClass, BlueprintData, BlueprintField, IBlueprint, IBlueprintCollection, IBlueprintList, OptionalRecord } from "./blueprint.interface.js";
@@ -37,13 +37,16 @@ type SlicedRecord<Original extends AnyRecordClass, Mask> = SlicedProperties<Orig
     readonly [Meta]: {
         readonly blueprint: Original["blueprint"];
     };
-}> : never;
+}, KeptSensitive<Original, keyof Properties>> : never;
 type KeptChange<Instance, Keys> = Instance extends {
     readonly change: infer Change;
 } ? Extract<keyof Change, Keys & string> : never;
 type KeptUnique<Original, Keys> = Original extends {
     readonly [RecordUniqueKeys]?: infer Unique;
 } ? Extract<Unique, Keys & string> : never;
+type KeptSensitive<Original, Keys> = Original extends {
+    readonly [RecordSensitiveKeys]?: infer Sensitive;
+} ? Extract<Sensitive, Keys & string> : never;
 /** The properties of `Blueprint`, read lazily so generic uses stay shallow. */
 export type PropertiesOf<Blueprint> = Blueprint extends IBlueprint<infer Properties, boolean> ? Properties : never;
 /** The blueprint of `Properties` that keeps only the keys of `Mask`. */

package/dist/core/entity/abstract-entity.d.ts

@@ -17,7 +17,7 @@ export declare const EntityUniqueKeys: unique symbol;
  * and never changed after, an `updatedAt` set by each change, and a
  * `deletedAt` set by `destroy`, after which it no longer changes.
  */
-export declare abstract class AbstractEntity<Properties extends IBlueprintCollection> extends AbstractRecord<Properties> {
+export declare abstract class AbstractEntity<Properties extends IBlueprintCollection, Sensitive extends string = never> extends AbstractRecord<Properties, Sensitive> {
     constructor(value: BlueprintInput<Properties>);
     /** Queues an event for this entity without running its handler. */
     protected emit(event: EventDefinition): void;

package/dist/core/entity/types/entity.interface.d.ts

@@ -1,6 +1,6 @@
 import type { BlueprintField, BlueprintInput, BlueprintValue, IBlueprint, IBlueprintCollection, JoinedProperties } from "../../blueprint/types/blueprint.interface.js";
 import type { ParseResult } from "../../parse/types/parse.interface.js";
-import type { AnyRecordPlugin, IRecordPluginCatalog, PluginMembers, PluginUniqueKey, WithPluginProperties } from "../../record/types/plugin.interface.js";
+import type { AnyRecordPlugin, IRecordPluginCatalog, PluginMembers, PluginSensitiveKey, PluginUniqueKey, WithPluginProperties } from "../../record/types/plugin.interface.js";
 import type { MarkedUniqueKey, RecordChanges, RecordKey, RecordOptions, RecordSettings } from "../../record/types/record.interface.js";
 import type { StandardSchemaV1 } from "../../standard/standard-schema.js";
 import type { Kind } from "../../symbols/kind.js";
@@ -45,32 +45,38 @@ export type EntityProperties<Identity extends IEntityIdentity, Properties extend
  */
 export type EntityInput<Identity extends IEntityIdentity, Properties extends IBlueprintCollection> = BlueprintInput<Properties> & Partial<BlueprintInput<Identity>>;
 /** What `entityOf` takes, after the blueprint, to describe its keys. */
-export type EntityOptions<Properties extends IBlueprintCollection, Change extends readonly RecordKey<Properties>[] = readonly RecordKey<Properties>[], Unique extends readonly RecordKey<Properties>[] = readonly RecordKey<Properties>[], Plugins extends readonly AnyRecordPlugin[] = readonly AnyRecordPlugin[], Context = unknown> = RecordOptions<Properties, Change, Unique, Plugins, Context> & EntityEvents;
+export type EntityOptions<Properties extends IBlueprintCollection, Change extends readonly RecordKey<Properties>[] = readonly RecordKey<Properties>[], Unique extends readonly RecordKey<Properties>[] = readonly RecordKey<Properties>[], Plugins extends readonly AnyRecordPlugin[] = readonly AnyRecordPlugin[], Context = unknown, Sensitive extends readonly RecordKey<Properties>[] = readonly RecordKey<Properties>[]> = RecordOptions<Properties, Change, Unique, Plugins, Context, Sensitive> & EntityEvents;
 /**
  * The unique keys of an entity: `id`, those listed in `options.unique`, and
  * those holding a property declared `unique`, as `Slug`.
  */
 export type EntityUniqueKey<Identity extends IEntityIdentity, Properties extends IBlueprintCollection, Unique extends readonly string[]> = "id" | Unique[number] | MarkedUniqueKey<EntityProperties<Identity, Properties>>;
 /** The entities of the class `entityOf` returns, with what its plugins add, `Members`. */
-export type DeclaredEntityInstance<Identity extends IEntityIdentity, Properties extends IBlueprintCollection, Change extends readonly string[], Members = unknown> = AbstractEntity<EntityProperties<Identity, Properties>> & Readonly<BlueprintValue<EntityProperties<Identity, Properties>>> & RecordChanges<Properties, Change> & Members;
+export type DeclaredEntityInstance<Identity extends IEntityIdentity, Properties extends IBlueprintCollection, Change extends readonly string[], Members = unknown, Sensitive extends string = never> = AbstractEntity<EntityProperties<Identity, Properties>, Sensitive> & Readonly<BlueprintValue<EntityProperties<Identity, Properties>>> & RecordChanges<Properties, Change> & Members;
 /** What `entityOf` returns: a record class with identity. */
-export type EntityConstructor<Identity extends IEntityIdentity, Properties extends IBlueprintCollection, Change extends readonly string[], Unique extends readonly string[] = [], Members = unknown> = {
+export type EntityConstructor<Identity extends IEntityIdentity, Properties extends IBlueprintCollection, Change extends readonly string[], Unique extends readonly string[] = [], Members = unknown, Sensitive extends string = never> = {
     readonly [EntityClassBrand]: true;
     /** The keys no two entities may share, as `options.unique` lists them. */
     readonly [EntityUniqueKeys]: readonly EntityUniqueKey<Identity, Properties, Unique>[];
-    new (value: EntityInput<Identity, Properties>): DeclaredEntityInstance<Identity, Properties, Change, Members>;
+    new (value: EntityInput<Identity, Properties>): DeclaredEntityInstance<Identity, Properties, Change, Members, Sensitive>;
     /**
      * The Standard Schema of the class: `validate` gives an instance of it, or
      * the issues that reject the value. Typed with the instance of the class
      * `entityOf` returns, not of a subclass.
      */
-    readonly "~standard": StandardSchemaV1.Props<EntityInput<Identity, Properties>, DeclaredEntityInstance<Identity, Properties, Change, Members>>;
+    readonly "~standard": StandardSchemaV1.Props<EntityInput<Identity, Properties>, DeclaredEntityInstance<Identity, Properties, Change, Members, Sensitive>>;
     /**
      * An instance of the class (a subclass included) for `value`, or every
      * issue that rejects it; never throws for an invalid value.
      */
     safeParse<Self extends new (value: never) => object>(this: Self, value: unknown): ParseResult<InstanceType<Self>>;
     readonly [Kind]: "record";
+    /**
+     * The name of the class as declared: the `name` option, which a bundler
+     * does not rename, or the name of the class without one. A subclass may
+     * give its own with `static override readonly recordName = "..."`.
+     */
+    readonly recordName: string;
     readonly blueprint: IBlueprint<EntityProperties<Identity, Properties>>;
     readonly options: RecordSettings<EntityProperties<Identity, Properties>>;
     /** Its plugins, those they require included, each once. */
@@ -80,4 +86,4 @@ export type EntityConstructor<Identity extends IEntityIdentity, Properties exten
  * What `entityBuilderOf` returns: `entityOf`, declaring entities with the
  * identity it was given, whose `options.plugins` picks from `Context`.
  */
-export type EntityBuilder<Identity extends IEntityIdentity, Context = Record<never, never>> = <Properties extends IBlueprintCollection & Partial<Record<EntityIdentityKey, never>>, const Change extends readonly RecordKey<Properties>[] = [], const Unique extends readonly RecordKey<Properties>[] = [], const Plugins extends readonly AnyRecordPlugin[] = []>(blueprint: IBlueprint<Properties, boolean>, options?: EntityOptions<NoInfer<Properties>, Change, Unique, Plugins, Context>) => EntityConstructor<Identity, WithPluginProperties<Properties, Plugins>, Change, readonly (Unique[number] | PluginUniqueKey<Plugins>)[], PluginMembers<Plugins>>;
+export type EntityBuilder<Identity extends IEntityIdentity, Context = Record<never, never>> = <Properties extends IBlueprintCollection & Partial<Record<EntityIdentityKey, never>>, const Change extends readonly RecordKey<Properties>[] = [], const Unique extends readonly RecordKey<Properties>[] = [], const Plugins extends readonly AnyRecordPlugin[] = [], const Sensitive extends readonly RecordKey<Properties>[] = []>(blueprint: IBlueprint<Properties, boolean>, options?: EntityOptions<NoInfer<Properties>, Change, Unique, Plugins, Context, Sensitive>) => EntityConstructor<Identity, WithPluginProperties<Properties, Plugins>, Change, readonly (Unique[number] | PluginUniqueKey<Plugins>)[], PluginMembers<Plugins>, Sensitive[number] | PluginSensitiveKey<Plugins>>;

package/dist/core/exception/exception.d.ts

@@ -31,8 +31,17 @@ export declare class Exception<Details = unknown> extends Error {
     /**
      * Passes the exception to an upper layer: a new exception in `scope`, with
      * this one as its cause, keeping its name and message unless given others.
+     * With the same name and no new `details`, an exception of a class declared
+     * with `exceptionOf` (or of a subclass of one) stays an instance of that
+     * class and keeps its `details`, so `instanceof` holds across layers; the
+     * constructor of the class does not run again.
      */
-    propagate<Next = undefined>({ layer, source, name, message, details, }: ExceptionPropagation<Next>): Exception<Next>;
+    propagate(scope: ExceptionScope & {
+        readonly name?: undefined;
+        readonly message?: string;
+        readonly details?: undefined;
+    }): Exception<Details>;
+    propagate<Next = undefined>(scope: ExceptionPropagation<Next>): Exception<Next>;
     toJSON(): ExceptionFrame<Details> & {
         trace: readonly ExceptionFrame[];
     };

package/dist/core/output/status.d.ts

@@ -2,8 +2,8 @@ import { Exception } from "../exception/exception.js";
 import type { OperationDescriptor, OutputStatuses } from "./types/output.interface.js";
 /**
  * The exception that raised `error` under its name: a use case or a command
- * passes an exception up as a copy with the same name, no details and the
- * original as its cause, so the original is the deepest one with that name.
+ * passes an exception up as a copy with the same name and the original as
+ * its cause, so the original is the deepest one with that name.
  */
 export declare function raisedOf(error: Exception): Exception;
 /**

package/dist/core/property/property.d.ts

@@ -6,20 +6,20 @@ import { AbstractDefineProperty } from "./define-property.js";
 import type { AnyPropertyConstructor } from "./types/property-collection.type.js";
 import type { PropertyValue } from "./types/property-constructor.type.js";
 import type { PropertyOptions } from "./types/property-options.interface.js";
-import type { IPropertyType, UniqueMark } from "./types/property-type.interface.js";
+import type { IPropertyType, SensitiveMark, UniqueMark } from "./types/property-type.interface.js";
 type SchemaValueType<SchemaType extends TSchema, Optional extends boolean = false> = Optional extends true ? TOptional<SchemaType> : SchemaType;
 /**
  * What `propertyOf` takes. `SchemaType` is inferred from `schema` alone: the
  * value is `NoInfer`, since inferring through `Static` makes TypeScript
  * measure `Static` itself, which costs about a second on every check.
  */
-type PropertyOfArgs<SchemaType extends TSchema, Optional extends boolean = false, Unique extends boolean = false, Value = Static<SchemaType>> = {
+type PropertyOfArgs<SchemaType extends TSchema, Optional extends boolean = false, Unique extends boolean = false, Sensitive extends boolean = false, Value = Static<SchemaType>> = {
     name: string;
     schema: SchemaType;
     default?: NoInfer<Value>;
     optional?: Optional;
     /** A record masks its value in `toJSON`, at any depth, as `Password`. */
-    sensitive?: boolean;
+    sensitive?: Sensitive;
     /**
      * A record lists a key holding it in `options.unique`, as `Slug`; records
      * do not check it, repositories (or the database) enforce it.
@@ -53,5 +53,5 @@ export interface PropertyClass<SchemaType extends TSchema, Value = Static<Schema
     with<Self extends AnyPropertyConstructor>(this: Self, options: PropertyOptions<SchemaType, Value>): Self;
     demo<Self extends AbstractProperty<any>>(this: new (value: never) => Self): Self;
 }
-export declare function propertyOf<SchemaType extends TSchema, Optional extends boolean = false, const Unique extends boolean = false>({ name, schema, optional, sensitive, unique, default: _default, preHandle: onPreHandle, afterHandle: onAfterHandle, }: PropertyOfArgs<SchemaType, Optional, Unique>): PropertyClass<SchemaValueType<SchemaType, Optional>, Static<SchemaType>> & UniqueMark<Unique>;
+export declare function propertyOf<SchemaType extends TSchema, Optional extends boolean = false, const Unique extends boolean = false, const Sensitive extends boolean = false>({ name, schema, optional, sensitive, unique, default: _default, preHandle: onPreHandle, afterHandle: onAfterHandle, }: PropertyOfArgs<SchemaType, Optional, Unique, Sensitive>): PropertyClass<SchemaValueType<SchemaType, Optional>, Static<SchemaType>> & UniqueMark<Unique> & SensitiveMark<Sensitive>;
 export {};

package/dist/core/property/types/optional-property.type.d.ts

@@ -5,7 +5,7 @@ import type { AbstractProperty } from "../abstract-property.js";
 import type { AnyPropertyConstructor } from "./property-collection.type.js";
 import type { PropertyValue } from "./property-constructor.type.js";
 import type { CallableKey, StoredField } from "./property-options.interface.js";
-import type { IPropertyType, UniqueTypeOf } from "./property-type.interface.js";
+import type { IPropertyType, SensitiveTypeOf, UniqueTypeOf } from "./property-type.interface.js";
 /**
  * `Property` accepting `undefined`: its schema becomes `TOptional`, while its
  * own methods and statics (e.g. `Password#verify`, `Id.generate`) are kept.
@@ -14,7 +14,7 @@ export type OptionalProperty<Property extends AnyPropertyConstructor> = Property
     readonly type: IPropertyType<infer SchemaType, infer Value>;
 } ? SchemaType extends TOptional<TSchema> ? StoredField<Property> : Omit<Property, "type" | "prototype" | "safeParse" | "~standard" | CallableKey> & {
     new (value: PropertyValue<TOptional<SchemaType>, Value>): AbstractProperty<TOptional<SchemaType>, Value> & Omit<InstanceType<Property>, keyof AbstractProperty<TSchema>>;
-    readonly type: IPropertyType<TOptional<SchemaType>, Value> & UniqueTypeOf<Property>;
+    readonly type: IPropertyType<TOptional<SchemaType>, Value> & UniqueTypeOf<Property> & SensitiveTypeOf<Property>;
     safeParse(value: unknown): ParseResult<PropertyValue<TOptional<SchemaType>, Value>>;
     readonly "~standard": StandardSchemaV1.Props<PropertyValue<TOptional<SchemaType>, Value>, PropertyValue<TOptional<SchemaType>, Value>>;
 } : never;

package/dist/core/property/types/property-type.interface.d.ts

@@ -25,6 +25,23 @@ export type UniqueMark<Unique extends boolean> = Unique extends true ? {
         readonly unique: true;
     };
 } : unknown;
+/**
+ * The type of a property declared `sensitive`, as `Password`, so that the
+ * type of `toJSON` masks the keys holding it.
+ */
+export type SensitiveMark<Sensitive extends boolean> = Sensitive extends true ? {
+    readonly type: {
+        readonly sensitive: true;
+    };
+} : unknown;
+/** `{ sensitive: true }` when `Property` is declared `sensitive`, for its optional version. */
+export type SensitiveTypeOf<Property> = Property extends {
+    readonly type: {
+        readonly sensitive: true;
+    };
+} ? {
+    readonly sensitive: true;
+} : unknown;
 /** `{ unique: true }` when `Property` is declared `unique`, for its optional version. */
 export type UniqueTypeOf<Property> = Property extends {
     readonly type: {

package/dist/core/record/abstract-record.d.ts

@@ -1,8 +1,8 @@
-import type { BlueprintData, BlueprintField, BlueprintInput, BlueprintValue, IBlueprint, IBlueprintCollection } from "../blueprint/types/blueprint.interface.js";
+import type { BlueprintField, BlueprintInput, BlueprintValue, IBlueprint, IBlueprintCollection } from "../blueprint/types/blueprint.interface.js";
 import type { ParseResult } from "../parse/types/parse.interface.js";
 import type { StandardSchemaV1 } from "../standard/standard-schema.js";
 import { Meta } from "../symbols/meta.js";
-import type { IRecord, RecordChange, RecordEffects, RecordSettings } from "./types/record.interface.js";
+import type { IRecord, RecordChange, RecordEffects, RecordJson, RecordSettings } from "./types/record.interface.js";
 /** The statics of a class made by `recordOf`, that its records read. */
 interface RecordDeclaration<Properties extends IBlueprintCollection> {
     readonly blueprint: IBlueprint<Properties>;
@@ -54,7 +54,7 @@ export declare const RecordPluginHooks: unique symbol;
  * having `key`, then those of the record, for a stored change.
  */
 export declare function runRecordEffects<Self extends object>(record: Self, key: PropertyKey, next: unknown, previous: unknown): Self;
-export declare abstract class AbstractRecord<Properties extends IBlueprintCollection> implements IRecord<Properties> {
+export declare abstract class AbstractRecord<Properties extends IBlueprintCollection, Sensitive extends string = never> implements IRecord<Properties, Sensitive> {
     get [Meta](): RecordDeclaration<Properties>;
     constructor(value: BlueprintInput<Properties>);
     /**
@@ -72,7 +72,7 @@ export declare abstract class AbstractRecord<Properties extends IBlueprintCollec
      * The value with the sensitive keys, and every property declared
      * `sensitive` (as `Password`), masked.
      */
-    toJSON(): Readonly<Partial<BlueprintData<Properties>>>;
+    toJSON(): RecordJson<Properties, Sensitive>;
     /**
      * Validates `value`, stores it under `key`, then runs `onSetAll` and the
      * effect of `key` in `onSet`.

package/dist/core/record/exceptions.d.ts

@@ -9,6 +9,8 @@ export declare const InvalidRecordValue: import("../../index.js").DeclaredExcept
     readonly errors: readonly string[];
     readonly issues: readonly Issue[];
 }>;
+/** `recordOf` or `entityOf` got an option it cannot use, as a `name` that is not an identifier. */
+export declare const InvalidRecordDeclaration: import("../../index.js").DeclaredExceptionClass<string>;
 /**
  * A record is given a key its blueprint does not declare, in its value or by
  * `set`; `key` is its path, e.g. `address.extra`, and `source` the record name.

package/dist/core/record/name.d.ts

@@ -0,0 +1,16 @@
+/** Whether `name` can be the `name` option of `recordOf` or `entityOf`. */
+export declare function isRecordName(name: unknown): name is string;
+/**
+ * The name of a record or entity class: the `name` option it, or the class it
+ * extends, was declared with, which bundlers and minifiers do not change;
+ * without one, the name of the class.
+ */
+export declare function recordNameOf(Class: object): string;
+/** Keeps the `name` option `Class` was declared with. */
+export declare function declareRecordName(Class: object, name: string): void;
+/**
+ * The name `Class` declares: the `name` option of it or of a class it
+ * extends, or a `static recordName` of its own; `undefined` when the name of
+ * the record is only the name of its class.
+ */
+export declare function declaredRecordNameOf(Class: object): string | undefined;

package/dist/core/record/record.d.ts

@@ -1,12 +1,12 @@
 import type { AnyBlueprint, IBlueprint, IBlueprintCollection } from "../blueprint/types/blueprint.interface.js";
 import { AbstractRecord } from "./abstract-record.js";
-import type { AnyRecordPlugin, IRecordPluginCatalog, PluginMembers, PluginUniqueKey, RecordPluginContext, WithPluginProperties } from "./types/plugin.interface.js";
+import type { AnyRecordPlugin, IRecordPluginCatalog, PluginMembers, PluginSensitiveKey, PluginUniqueKey, RecordPluginContext, WithPluginProperties } from "./types/plugin.interface.js";
 import type { RecordConstructor, RecordKey, RecordOptions } from "./types/record.interface.js";
 /**
  * What `recordBuilderOf` returns: `recordOf`, whose `options.plugins` can
  * pick plugins from `Context`, the plugins of its catalogs by name.
  */
-export type RecordBuilder<Context> = <Properties extends IBlueprintCollection, const Change extends readonly RecordKey<Properties>[] = [], const Unique extends readonly RecordKey<Properties>[] = [], const Plugins extends readonly AnyRecordPlugin[] = []>(blueprint: IBlueprint<Properties, boolean>, options?: RecordOptions<NoInfer<Properties>, Change, Unique, Plugins, Context>) => RecordConstructor<WithPluginProperties<Properties, Plugins>, Change, Unique[number] | PluginUniqueKey<Plugins>, PluginMembers<Plugins>>;
+export type RecordBuilder<Context> = <Properties extends IBlueprintCollection, const Change extends readonly RecordKey<Properties>[] = [], const Unique extends readonly RecordKey<Properties>[] = [], const Plugins extends readonly AnyRecordPlugin[] = [], const Sensitive extends readonly RecordKey<Properties>[] = []>(blueprint: IBlueprint<Properties, boolean>, options?: RecordOptions<NoInfer<Properties>, Change, Unique, Plugins, Context, Sensitive>) => RecordConstructor<WithPluginProperties<Properties, Plugins>, Change, Unique[number] | PluginUniqueKey<Plugins>, PluginMembers<Plugins>, never, Sensitive[number] | PluginSensitiveKey<Plugins>>;
 /**
  * A `recordOf` whose `options.plugins` can pick plugins from `catalogs`,
  * e.g. `recordBuilderOf(StdRecordPlugins)`, as `(ctx) => [ctx.publishable]`;
@@ -27,6 +27,7 @@ export declare function pluginContextOf(catalogs: readonly IRecordPluginCatalog[
 export declare const recordOf: RecordBuilder<Record<never, never>>;
 /** The options `declareRecord` takes, untyped. */
 interface RecordOptionsInput {
+    readonly name?: string;
     readonly sensitive?: readonly string[];
     readonly unique?: readonly string[];
     readonly change?: readonly string[];
@@ -37,5 +38,5 @@ interface RecordOptionsInput {
  * and named `name`; `reserved` are more names no key can take, the members
  * `Base` adds, and `context` the plugins `options.plugins` can pick from.
  */
-export declare function declareRecord(Base: abstract new (value: never) => AbstractRecord<IBlueprintCollection>, declared: AnyBlueprint, { plugins, ...declaredOptions }: RecordOptionsInput, name: string, reserved?: readonly string[], context?: Readonly<Record<string, AnyRecordPlugin>>): abstract new (value: never) => AbstractRecord<IBlueprintCollection>;
+export declare function declareRecord(Base: abstract new (value: never) => AbstractRecord<IBlueprintCollection>, declared: AnyBlueprint, { plugins, name: declaredName, ...declaredOptions }: RecordOptionsInput, fallback: string, reserved?: readonly string[], context?: Readonly<Record<string, AnyRecordPlugin>>): abstract new (value: never) => AbstractRecord<IBlueprintCollection>;
 export {};

package/dist/core/record/types/plugin.interface.d.ts

@@ -7,6 +7,11 @@ import type { RecordSettings } from "./record.interface.js";
  * class holds a value under it.
  */
 export declare const RecordUniqueKeys: unique symbol;
+/**
+ * Where the type of the keys a record class lists in `options.sensitive` is
+ * kept, for the type of `toJSON` of what its plugin is applied to. Type only.
+ */
+export declare const RecordSensitiveKeys: unique symbol;
 /** What `recordPluginOf` takes, after the record class. */
 export interface RecordPluginOptions {
     /** A semantic version, e.g. `1.2.0`; `1.0.0` when left out. */
@@ -139,4 +144,10 @@ export type PluginUniqueKey<Plugins extends readonly AnyRecordPlugin[]> = Plugin
         readonly [RecordUniqueKeys]?: infer Key;
     };
 } ? Extract<Key, string> : never : never;
+/** The keys the record classes of the plugins list in `options.sensitive`. */
+export type PluginSensitiveKey<Plugins extends readonly AnyRecordPlugin[]> = Plugins[number] extends infer Plugin ? Plugin extends {
+    readonly record: {
+        readonly [RecordSensitiveKeys]?: infer Key;
+    };
+} ? Extract<Key, string> : never : never;
 export {};