@afora/core 0.0.2 → 0.0.3

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

@@ -16,13 +16,17 @@ export declare function isApplication(value: unknown): value is AnyApplication;
  * `describe()` gives the graph. With a `provider` (or that of the last
  * application extended that has one), `repositories` are bound to it.
  */
-export declare function applicationOf<const Name extends string, const Extended extends readonly AnyApplication[] = readonly [], const Properties extends ApplicationCollections["properties"] = Record<never, never>, const Blueprints extends ApplicationCollections["blueprints"] = Record<never, never>, const Records extends ApplicationCollections["records"] = Record<never, never>, const Entities extends ApplicationCollections["entities"] = Record<never, never>, const Environments extends ApplicationCollections["environments"] = Record<never, never>, const Repositories extends ApplicationCollections["repositories"] = Record<never, never>>(settings: ApplicationSettings<Name, Extended, {
+export declare function applicationOf<const Name extends string, const Extended extends readonly AnyApplication[] = readonly [], const Properties extends ApplicationCollections["properties"] = Record<never, never>, const Blueprints extends ApplicationCollections["blueprints"] = Record<never, never>, const Records extends ApplicationCollections["records"] = Record<never, never>, const Entities extends ApplicationCollections["entities"] = Record<never, never>, const Environments extends ApplicationCollections["environments"] = Record<never, never>, const Repositories extends ApplicationCollections["repositories"] = Record<never, never>, const UseCases extends ApplicationCollections["useCases"] = Record<never, never>, const Commands extends ApplicationCollections["commands"] = Record<never, never>, const Outputs extends ApplicationCollections["outputs"] = Record<never, never>, const Exceptions extends ApplicationCollections["exceptions"] = Record<never, never>>(settings: ApplicationSettings<Name, Extended, {
     properties: Properties;
     blueprints: Blueprints;
     records: Records;
     entities: Entities;
     environments: Environments;
     repositories: Repositories;
+    useCases: UseCases;
+    commands: Commands;
+    outputs: Outputs;
+    exceptions: Exceptions;
 }>): IApplication<Name, MergedCollections<{
     properties: Properties;
     blueprints: Blueprints;
@@ -30,4 +34,8 @@ export declare function applicationOf<const Name extends string, const Extended
     entities: Entities;
     environments: Environments;
     repositories: Repositories;
+    useCases: UseCases;
+    commands: Commands;
+    outputs: Outputs;
+    exceptions: Exceptions;
 }, Extended>>;

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

@@ -27,3 +27,31 @@ export declare const UnregisteredRepositoryDependency: import("../../index.js").
     readonly repository: string;
     readonly dependency: string;
 }>;
+/** A dependency of a use case of the application (a use case, repository or environment) is not registered in it. */
+export declare const UnregisteredUseCaseDependency: import("../../index.js").DeclaredExceptionClass<{
+    readonly useCase: string;
+    readonly dependency: string;
+}>;
+/**
+ * The application provider is made by `providerFrom` and the application has
+ * not been started: `await app.start()` creates it.
+ */
+export declare const ApplicationNotStarted: import("../../index.js").DeclaredExceptionClass<{
+    /** The application, or none when `useApplication()` found none started. */
+    readonly application?: string;
+}>;
+/**
+ * `app.start()` was called while another application is the started one of
+ * the process; `start({ replace: true })` stops it and takes its place.
+ */
+export declare const ApplicationAlreadyStarted: import("../../index.js").DeclaredExceptionClass<{
+    readonly current: string;
+    readonly attempted: string;
+}>;
+/**
+ * `app.start()` found environments whose variables are missing or rejected;
+ * `details.environments` gives the keys of each, by name.
+ */
+export declare const InvalidApplicationEnvironment: import("../../index.js").DeclaredExceptionClass<{
+    readonly environments: Readonly<Record<string, readonly string[]>>;
+}>;

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

@@ -0,0 +1,33 @@
+import type { AnyApplication } from "./types/application.interface.js";
+/**
+ * Declares the type of the application `useApplication()` gives, by module
+ * augmentation, once per project:
+ *
+ * ```ts
+ * declare module "@afora/core" {
+ *   interface Register { application: typeof App }
+ * }
+ * ```
+ */
+export interface Register {
+}
+/** The application declared in `Register`, or any application. */
+export type RegisteredApplication = Register extends {
+    readonly application: infer Application extends AnyApplication;
+} ? Application : AnyApplication;
+/**
+ * The application started in this process, from anywhere, without importing
+ * it (so a hand-written use case or handler that the application imports can
+ * reach it without an import cycle). Throws `ApplicationNotStarted` when none
+ * is. Typed by `Register`.
+ */
+export declare function useApplication(): RegisteredApplication;
+/**
+ * Forgets the started application without stopping it, e.g. between tests,
+ * so that another one can start.
+ */
+export declare function resetApplication(): void;
+/** The started application of the process, if any. @internal */
+export declare function startedApplication(): AnyApplication | undefined;
+/** Makes `application` the started one. @internal */
+export declare function setStartedApplication(application: AnyApplication | undefined): void;

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

@@ -0,0 +1,51 @@
+import { type AnyEnvironment, type EnvironmentDependencies, type MergedEnvironment } from "../environment/environment.js";
+import type { IRepositoryProvider } from "../repository/types/repository.interface.js";
+import { Kind } from "../symbols/kind.js";
+/**
+ * A provider an application creates when it starts, from the variables of
+ * its environments: what `providerFrom` makes.
+ */
+export interface ProviderFactory<Environment extends EnvironmentDependencies = EnvironmentDependencies> {
+    readonly [Kind]: "provider-factory";
+    /** The environments whose variables `create` gets, as a list. */
+    readonly environments: readonly AnyEnvironment[];
+    readonly create: (env: MergedEnvironment<Environment>) => IRepositoryProvider | Promise<IRepositoryProvider>;
+}
+/**
+ * A provider made on `app.start()`: `create` gets the variables of
+ * `environmentDependencies` (one environment or a list, merged in order),
+ * read and validated then, e.g.
+ * `providerFrom(Database, (env) => drizzleProvider({ db: connect(env.DATABASE_URL), tables }))`.
+ */
+export declare function providerFrom<const Environment extends EnvironmentDependencies>(environmentDependencies: Environment, create: (env: MergedEnvironment<Environment>) => IRepositoryProvider | Promise<IRepositoryProvider>): ProviderFactory<Environment>;
+/** Whether `value` was made by `providerFrom`. */
+export declare function isProviderFactory(value: unknown): value is ProviderFactory;
+/**
+ * The provider the repositories of an application are bound to when it was
+ * declared with `providerFrom`: each call goes to the provider made on start,
+ * and throws `ApplicationNotStarted` before it.
+ * @internal
+ */
+export declare function deferredProvider(factory: ProviderFactory, application: string): IRepositoryProvider;
+/** Whether `provider` was made by `deferredProvider`. @internal */
+export declare function isDeferredProvider(provider: unknown): boolean;
+/** The environments the factory behind `provider` reads, if it is deferred. @internal */
+export declare function deferredEnvironments(provider: unknown): readonly AnyEnvironment[];
+/**
+ * Makes the provider behind `provider` once, from the variables of its
+ * environments (already validated by the caller); later calls give the same.
+ * @internal
+ */
+export declare function startDeferred(provider: IRepositoryProvider): Promise<IRepositoryProvider> | undefined;
+/**
+ * Closes the provider made on start and forgets it, so that calls throw
+ * `ApplicationNotStarted` again; a provider that is not deferred is closed.
+ * @internal
+ */
+export declare function stopProvider(provider: IRepositoryProvider): Promise<void>;
+/**
+ * Throws `InvalidCommandDeclaration` when `provider` cannot run the
+ * transactions of `commands` (it has no `transaction`, or says it has none).
+ * @internal
+ */
+export declare function checkTransactions(source: string, provider: IRepositoryProvider, commands: readonly string[]): void;

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

@@ -1,7 +1,14 @@
-import type { AnyEnvironment } from "../../environment/environment.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";
+import type { AnyOutput, StageDescription } from "../../output/types/output.interface.js";
 import type { RecordPluginDescriptor } from "../../record/types/plugin.interface.js";
+import type { ProviderDescription } from "../../repository/types/query.interface.js";
 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 { ProviderFactory } from "../start.js";
 type Named<Value> = Readonly<Record<string, Value>>;
 /** The declarations of an application, by name, one collection for each kind. */
 export interface ApplicationCollections {
@@ -11,8 +18,15 @@ export interface ApplicationCollections {
     readonly entities: Named<unknown>;
     readonly environments: Named<AnyEnvironment>;
     readonly repositories: Named<AnyRepository>;
+    readonly useCases: Named<AnyUseCaseClass>;
+    readonly commands: Named<AnyCommand>;
+    readonly outputs: Named<AnyOutput>;
+    readonly exceptions: Named<AnyExceptionClass>;
 }
-/** The keys of `ApplicationCollections`. */
+/**
+ * The keys of `ApplicationCollections`.
+ * @internal
+ */
 export type ApplicationCollectionKey = keyof ApplicationCollections;
 /** What `applicationOf` takes. */
 export interface ApplicationSettings<Name extends string, Extended extends readonly AnyApplication[], Collections extends ApplicationCollections> {
@@ -26,14 +40,27 @@ export interface ApplicationSettings<Name extends string, Extended extends reado
     readonly entities?: Collections["entities"];
     readonly environments?: Collections["environments"];
     readonly repositories?: Collections["repositories"];
+    /** Use cases, keyed by their `useCaseName`. */
+    readonly useCases?: Collections["useCases"];
+    /** Commands, keyed by their `commandName`; every use case of each must be in `useCases`. */
+    readonly commands?: Collections["commands"];
+    /** Outputs, keyed by their `outputName`; every command of each must be in `commands`. */
+    readonly outputs?: Collections["outputs"];
+    /** Exceptions made by `exceptionOf`, keyed by their `name`. */
+    readonly exceptions?: Collections["exceptions"];
     /**
      * The provider of the repositories that did not declare one; the
-     * repositories of the application read and write through it.
+     * 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`.
      */
-    readonly provider?: IRepositoryProvider;
+    readonly provider?: IRepositoryProvider | ProviderFactory;
 }
 type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
-/** `Own` with the declarations of `Extended` merged in. */
+/**
+ * `Own` with the declarations of `Extended` merged in.
+ * @internal
+ */
 export type MergedCollections<Own extends ApplicationCollections, Extended extends readonly AnyApplication[]> = {
     readonly [Key in ApplicationCollectionKey]: Own[Key] & UnionToIntersection<Extended[number][Key]>;
 };
@@ -56,12 +83,72 @@ export interface IApplication<Name extends string, Collections extends Applicati
      * 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.
+     */
+    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.
+     */
+    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.
+     */
+    readonly outputs: Collections["outputs"];
+    /** Its exceptions. */
+    readonly exceptions: Collections["exceptions"];
     /** The bound version of a repository registered in the application. */
     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;
+    /** 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. */
+    output<Output extends AnyOutput>(output: Output): Output;
     /** A new application with the declarations of `others` too; this one is left as it is. */
     extend<const Others extends readonly AnyApplication[]>(...others: Others): IApplication<Name, MergedCollections<Collections, Others>>;
     /** A format-neutral, JSON-serializable graph of its declarations. */
     describe(): ApplicationDescription;
+    /**
+     * Validates every environment it registers at once
+     * (`InvalidApplicationEnvironment`), makes the provider of `providerFrom`
+     * and checks the transactions of its commands against it. Idempotent: the
+     * same promise until it fails or `stop()` is called.
+     */
+    start(options?: ApplicationStartOptions): Promise<IApplication<Name, Collections>>;
+    /**
+     * Closes its provider (`close`, if it has one); a provider of
+     * `providerFrom` is made again by the next `start()`. It stops being the
+     * started application of the process.
+     */
+    stop(): Promise<void>;
+    /** The variables of an environment registered in the application. */
+    get<Environment extends AnyEnvironment>(environment: Environment): EnvironmentValue<Environment>;
+    /** The bound version of a command registered in the application. */
+    get<Command extends AnyCommand>(command: Command): Command;
+    /** The bound version of an output registered in the application. */
+    get<Output extends AnyOutput>(output: Output): Output;
+    /** The bound version of a use case registered in the application. */
+    get<UseCase extends AnyUseCaseClass>(useCase: UseCase): UseCase;
+    /** The bound version of a repository registered in the application. */
+    get<Repository extends AnyRepository>(repository: Repository): Repository;
+    /** Whether `start()` completed and `stop()` was not called since. */
+    readonly started: boolean;
+}
+/** What `app.start()` takes. */
+export interface ApplicationStartOptions {
+    /**
+     * Become the started application of the process (what `useApplication()`
+     * gives). Default `true`; another one already started throws
+     * `ApplicationAlreadyStarted`.
+     */
+    readonly register?: boolean;
+    /** Stop the started application of the process and take its place, e.g. on hot reload. Default `false`. */
+    readonly replace?: boolean;
 }
 /** Any application. */
 export type AnyApplication = IApplication<string, any>;
@@ -134,11 +221,98 @@ export interface RecordDescription {
     };
     readonly plugins: readonly RecordPluginDescriptor[];
 }
+/** What a use case depends on, by the name it has in the application. */
+export interface UseCaseDependencyDescription {
+    readonly kind: "use-case" | "repository" | "environment";
+    readonly ref: string;
+}
+/** A use case: its metadata, fields and what it depends on. */
+export interface UseCaseDescription {
+    readonly from: string;
+    /** The `useCaseName`, equal to its key. */
+    readonly name: string;
+    readonly description?: string;
+    readonly tags: readonly string[];
+    readonly deprecated: boolean;
+    readonly input: FieldsDescription;
+    readonly response: FieldsDescription;
+    readonly context?: FieldsDescription;
+    /**
+     * The names of the registered blueprints that are the `input`, `response`
+     * or `context` (their fields stay described above). Absent for the ones
+     * that are not registered.
+     */
+    readonly refs?: {
+        readonly input?: string;
+        readonly response?: string;
+        readonly context?: string;
+    };
+    /** A registered exception, or one exported by the package, by name. */
+    readonly errors: readonly ({
+        readonly kind: "exception";
+        readonly ref: string;
+    } | {
+        readonly kind: "core";
+        readonly name: string;
+    })[];
+    readonly dependencies: Readonly<Record<string, UseCaseDependencyDescription>>;
+    /**
+     * How it runs: `steps` when `execute` is the interpreter of the declared
+     * steps, `opaque` for a hand-written `execute`.
+     */
+    readonly implementation: {
+        readonly kind: "steps";
+        readonly steps: readonly UseCaseStepDescription[];
+    } | {
+        readonly kind: "opaque";
+    };
+}
+/** A command: its metadata, context, operations and policies. */
+export interface CommandDescription {
+    readonly from: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly tags: readonly string[];
+    readonly context?: FieldsDescription;
+    /** The name of the registered blueprint that is the `context`, if it is one. */
+    readonly refs?: {
+        readonly context?: string;
+    };
+    /** Each operation and the name of its use case in the application. */
+    readonly operations: Readonly<Record<string, {
+        readonly ref: string;
+    }>>;
+    readonly transaction: boolean;
+    /** The names of its environments, when it declares any. */
+    readonly environments?: readonly string[];
+    readonly events: "after-commit" | "manual" | {
+        readonly kind: "opaque";
+    };
+    readonly onEventError?: {
+        readonly kind: "opaque";
+    };
+}
+/** An output: its commands, statuses and pipe. */
+export interface OutputDescription {
+    readonly from: string;
+    readonly name: string;
+    readonly commands: readonly string[];
+    readonly statuses: Readonly<Record<string, number>>;
+    readonly pipe: readonly StageDescription[];
+}
+/** An exception: its layer and, when declared as a string, its message. */
+export interface ExceptionDescription {
+    readonly from: string;
+    readonly layer: ExceptionLayers;
+    readonly message?: 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 properties: Readonly<Record<string, PropertyDescription & {
         readonly from: string;
     }>>;
@@ -156,12 +330,17 @@ export interface ApplicationDescription {
         readonly from: string;
         readonly entity: string;
         readonly actions: readonly string[];
+        readonly deletion: "hard" | "soft";
         /** The names of the repositories of the entities its entity holds. */
         readonly relations: readonly string[];
         /** The names of its `environmentDependencies`. */
         readonly environments: readonly string[];
-        /** Whether it declared a provider of its own. */
-        readonly provider: boolean;
+        /** Its own provider, present only when it declared one. */
+        readonly provider?: ProviderDescription;
     }>>;
+    readonly useCases: Readonly<Record<string, UseCaseDescription>>;
+    readonly commands: Readonly<Record<string, CommandDescription>>;
+    readonly outputs: Readonly<Record<string, OutputDescription>>;
+    readonly exceptions: Readonly<Record<string, ExceptionDescription>>;
 }
 export {};

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

@@ -1,4 +1,4 @@
-import type { Static, TArray, TObject, TOptional, TSchema, TUnsafe } from "typebox";
+import type { Static, TArray, TObject, TOptional, TReadonly, TSchema, TUnsafe } from "typebox";
 import type { ParseResult } from "../../parse/types/parse.interface.js";
 import type { propertyOf } from "../../property/property.js";
 import type { OptionalProperty } from "../../property/types/optional-property.type.js";
@@ -59,7 +59,7 @@ type FieldMode = "data" | "value" | "input";
  * recurse into `AnyBlueprint` endlessly.
  */
 type FieldSchema<Field, Mode extends FieldMode> = 0 extends 1 & Field ? TSchema : Field extends {
-    readonly type: IPropertyType<infer SchemaType extends TSchema>;
+    readonly type: IPropertyType<infer SchemaType extends TSchema, any>;
 } ? SchemaType : Field extends AnyRecordClass ? RecordSchema<Field, Mode> : Field extends OptionalRecord<infer Record> ? TOptional<RecordSchema<Record, Mode>> : Field extends {
     readonly properties: infer Properties extends IBlueprintCollection;
     readonly optional: infer Optional;
@@ -83,26 +83,70 @@ type RecordInput<Record extends AnyRecordClass> = ConstructorParameters<Record>[
 type CollectionSchema<Properties extends IBlueprintCollection, Mode extends FieldMode> = TObject<{
     [Key in keyof Properties]: FieldSchema<Properties[Key], Mode>;
 }>;
-/** The schema of a single field of a blueprint; a record is its blueprint's object. */
+/**
+ * The schema of a single field of a blueprint; a record is its blueprint's object.
+ * @internal
+ */
 export type BlueprintPropertySchema<Field> = FieldSchema<Field, "data">;
 /** The object schema described by a collection, one key per field. */
 export type BlueprintSchema<Properties extends IBlueprintCollection> = CollectionSchema<Properties, "data">;
+/**
+ * The value of a single field of a blueprint, its records as `Mode` says:
+ * `Static` of its `FieldSchema`, read from the fields themselves. A property
+ * gives the value its type carries, so `Static` is never measured on a
+ * generic schema, which costs TypeScript about a second on every check.
+ */
+type FieldValue<Field, Mode extends FieldMode> = 0 extends 1 & Field ? Static<TSchema> : Field extends {
+    readonly type: IPropertyType<infer SchemaType, infer Value>;
+} ? 0 extends 1 & SchemaType ? Static<TSchema> : Value : Field extends AnyRecordClass ? RecordValueOf<Field, Mode> : Field extends OptionalRecord<infer Record> ? RecordValueOf<Record, Mode> : Field extends {
+    readonly properties: infer Properties extends IBlueprintCollection;
+} ? CollectionValue<Properties, Mode> : Field extends {
+    readonly item: infer Item;
+} ? FieldValue<Item, Mode>[] : never;
+/** The value of a record field, as `RecordSchema` describes it. */
+type RecordValueOf<Record extends AnyRecordClass, Mode extends FieldMode> = Mode extends "value" ? InstanceType<Record> : Mode extends "input" ? InstanceType<Record> | RecordInput<Record> | AcceptedBy<Record> : Record["blueprint"] extends IBlueprint<infer Properties, boolean> ? CollectionValue<Properties, "data"> : never;
+type ReadonlyOptionalKeys<Schemas> = {
+    [Key in keyof Schemas]: Schemas[Key] extends TReadonly<TSchema> ? Schemas[Key] extends TOptional<Schemas[Key]> ? Key : never : never;
+}[keyof Schemas];
+type ReadonlyKeys<Schemas> = {
+    [Key in keyof Schemas]: Schemas[Key] extends TReadonly<TSchema> ? Schemas[Key] extends TOptional<Schemas[Key]> ? never : Key : never;
+}[keyof Schemas];
+type OptionalKeys<Schemas> = {
+    [Key in keyof Schemas]: Schemas[Key] extends TOptional<TSchema> ? Schemas[Key] extends TReadonly<Schemas[Key]> ? never : Key : never;
+}[keyof Schemas];
+type RequiredKeys<Schemas> = keyof Omit<Schemas, ReadonlyOptionalKeys<Schemas> | ReadonlyKeys<Schemas> | OptionalKeys<Schemas>>;
+/**
+ * `Static` of `CollectionSchema`, built as TypeBox builds the value of an
+ * object (the same keys and modifiers, in the same order, so it displays the
+ * same), but from the value of each field. `Result` is a parameter so that no
+ * alias names the object.
+ */
+type CollectionValue<Properties extends IBlueprintCollection, Mode extends FieldMode, Schemas = {
+    [Key in keyof Properties]: FieldSchema<Properties[Key], Mode>;
+}, Values extends Record<PropertyKey, unknown> = {
+    [Key in keyof Properties]: FieldValue<Properties[Key], Mode>;
+}, WithModifiers extends Record<PropertyKey, unknown> = Evaluate<Readonly<Partial<Pick<Values, ReadonlyOptionalKeys<Schemas>>>> & Readonly<Pick<Values, ReadonlyKeys<Schemas>>> & Partial<Pick<Values, OptionalKeys<Schemas>>> & Required<Pick<Values, RequiredKeys<Schemas>>>>, Result = keyof Properties extends never ? object : {
+    [Key in keyof WithModifiers]: WithModifiers[Key];
+}> = Result;
+type Evaluate<Type> = {
+    [Key in keyof Type]: Type[Key];
+} & {};
 /**
  * The value accepted by a collection; optional fields become optional keys,
  * and a record field takes an instance of its class, e.g. `{ author: User }`.
  */
-export type BlueprintValue<Properties extends IBlueprintCollection> = Static<CollectionSchema<Properties, "value">>;
+export type BlueprintValue<Properties extends IBlueprintCollection> = CollectionValue<Properties, "value">;
 /**
  * What a blueprint accepts to build its value: as `BlueprintValue`, but a
  * record field also takes the plain input of its blueprint, which becomes an
  * instance of the record, e.g. `{ author: { name: "Jane" } }`.
  */
-export type BlueprintInput<Properties extends IBlueprintCollection> = Static<CollectionSchema<Properties, "input">>;
+export type BlueprintInput<Properties extends IBlueprintCollection> = CollectionValue<Properties, "input">;
 /**
  * The plain value of a collection, as its schema describes it: a record
  * field is the object of the record's blueprint, as its `toJSON` gives.
  */
-export type BlueprintData<Properties extends IBlueprintCollection> = Static<BlueprintSchema<Properties>>;
+export type BlueprintData<Properties extends IBlueprintCollection> = CollectionValue<Properties, "data">;
 type Override<Base, Overrides> = {
     [Key in keyof Base | keyof Overrides]: Key extends keyof Overrides ? Overrides[Key] : Key extends keyof Base ? Base[Key] : never;
 };
@@ -123,6 +167,7 @@ export type BlueprintPluginContext<Sources extends readonly {
 /**
  * The field factories of every plugin source, in order; a later source
  * replaces a factory of an earlier one with the same name.
+ * @internal
  */
 export type BlueprintFactoryContext<Sources extends readonly BlueprintSource[]> = Sources extends readonly [
     infer Head,
@@ -130,11 +175,17 @@ export type BlueprintFactoryContext<Sources extends readonly BlueprintSource[]>
 ] ? Override<Head extends {
     readonly factories?: infer Factories;
 } ? NonNullable<Factories> extends infer Defined extends IBlueprintFactories ? string extends keyof Defined ? Record<never, never> : Defined : Record<never, never> : Record<never, never>, BlueprintFactoryContext<Tail>> : Record<never, never>;
-/** The fields of the joined blueprints; a later one replaces a key of an earlier one. */
+/**
+ * The fields of the joined blueprints; a later one replaces a key of an earlier one.
+ * @internal
+ */
 export type JoinedProperties<Blueprints extends readonly {
     readonly properties: IBlueprintCollection;
 }[]> = BlueprintPluginContext<Blueprints> extends infer Properties extends IBlueprintCollection ? Properties : never;
-/** A list of every field of a collection, e.g. `{ tags: IBlueprintList<Tag> }`. */
+/**
+ * A list of every field of a collection, e.g. `{ tags: IBlueprintList<Tag> }`.
+ * @internal
+ */
 export type ListProperties<Properties> = {
     readonly [Key in keyof Properties]: Properties[Key] extends BlueprintField ? IBlueprintList<Properties[Key]> : never;
 };
@@ -162,11 +213,15 @@ export type BlueprintContext<Sources extends readonly BlueprintSource[]> = Calla
 /**
  * Every field of a collection, its properties callable with options, as
  * `ctx.number({ min: 1 })`.
+ * @internal
  */
 export type CallableProperties<Fields> = {
     readonly [Key in keyof Fields]: Fields[Key] extends AnyPropertyConstructor ? CallableProperty<Fields[Key]> : Fields[Key];
 };
-/** The optional version of every field of a collection, blueprints and records included. */
+/**
+ * The optional version of every field of a collection, blueprints and records included.
+ * @internal
+ */
 export type OptionalProperties<Properties> = {
     readonly [Key in keyof Properties]: Properties[Key] extends AnyPropertyConstructor ? OptionalProperty<Properties[Key]> : Properties[Key] extends AnyBlueprint ? OptionalBlueprint<Properties[Key]> : Properties[Key] extends AnyBlueprintList ? OptionalBlueprintList<Properties[Key]> : Properties[Key] extends AnyRecordClass ? OptionalRecord<Properties[Key]> : Properties[Key] extends AnyOptionalRecord ? Properties[Key] : never;
 };
@@ -178,7 +233,7 @@ export interface IBlueprint<Properties extends IBlueprintCollection, Optional ex
     /** The fields picked by the blueprint's definition. */
     readonly properties: Properties;
     /** The general schema of every field of the blueprint. */
-    readonly schema: ISchema<BlueprintSchema<Properties>>;
+    readonly schema: ISchema<BlueprintSchema<Properties>, BlueprintData<Properties>>;
     /** Whether, as a field of another blueprint, it accepts `undefined`. */
     readonly optional: Optional;
     /**
@@ -232,7 +287,7 @@ export interface IBlueprintList<Item extends BlueprintField, Optional extends bo
      */
     readonly "~standard": StandardSchemaV1.Props<ListShape<Item, "input", Optional>, ListShape<Item, "value", Optional>>;
 }
-type ListShape<Item, Mode extends FieldMode, Optional extends boolean> = Optional extends true ? Static<TArray<FieldSchema<Item, Mode>>> | undefined : Static<TArray<FieldSchema<Item, Mode>>>;
+type ListShape<Item, Mode extends FieldMode, Optional extends boolean> = Optional extends true ? FieldValue<Item, Mode>[] | undefined : FieldValue<Item, Mode>[];
 /** `List` as a field that accepts `undefined`. */
 export type OptionalBlueprintList<List extends AnyBlueprintList> = List extends IBlueprintList<infer Item, boolean> ? IBlueprintList<Item, true> : never;
 export {};

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

@@ -1,5 +1,6 @@
 import type { 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";
 /** What a mask of a field is: the mask of its item, of its keys, or nothing for a property. */
 type FieldMask<Field> = 0 extends 1 & Field ? object : Field extends AnyBlueprintList ? FieldMask<Field["item"]> : Field extends AnyBlueprint ? SliceMask<Field["properties"]> : Field extends AnyRecordClass ? SliceMask<Field["blueprint"]["properties"]> : Field extends AnyOptionalRecord ? SliceMask<Field["record"]["blueprint"]["properties"]> : never;
@@ -33,7 +34,9 @@ type SliceField<Field, Mask> = 0 extends 1 & Field ? never : Field extends AnyBl
  * `change` keys among them. A plain record, not an entity.
  */
 type SlicedRecord<Original extends AnyRecordClass, Mask> = SlicedProperties<Original["blueprint"]["properties"], Mask> extends infer Properties extends IBlueprintCollection ? RecordConstructor<Properties, KeptChange<InstanceType<Original>, keyof Properties>[], KeptUnique<Original, keyof Properties>, unknown, {
-    readonly blueprint: Original["blueprint"];
+    readonly [Meta]: {
+        readonly blueprint: Original["blueprint"];
+    };
 }> : never;
 type KeptChange<Instance, Keys> = Instance extends {
     readonly change: infer Change;
@@ -50,7 +53,9 @@ export type SlicedBlueprint<Properties, Mask> = AsBlueprint<SlicedProperties<Pro
  * the keys their blueprint requires) and lists.
  */
 export type SlicedValue<Value, Mask> = Value extends readonly (infer Item)[] ? SlicedValue<Item, Mask>[] : Value extends {
-    readonly blueprint: IBlueprint<infer Properties, boolean>;
+    readonly [Meta]: {
+        readonly blueprint: IBlueprint<infer Properties, boolean>;
+    };
     toJSON(): unknown;
 } ? SlicedValue<BlueprintData<Properties>, Mask> : Value extends {
     toJSON(): infer Json;

package/dist/core/command/command.d.ts

@@ -0,0 +1,25 @@
+import type { IBlueprintCollection } from "../blueprint/types/blueprint.interface.js";
+import { type EnvironmentDependencies } from "../environment/environment.js";
+import type { IRepositoryProvider } from "../repository/types/repository.interface.js";
+import type { AnyCommand, CommandOf, CommandSettings, CommandUseCases } from "./types/command.interface.js";
+/**
+ * Checks now that the repositories of `command` share a provider that has
+ * `transaction`, as its first call would; an application calls it when it
+ * binds the command to its provider.
+ * @internal
+ */
+export declare function verifyCommand(command: object): void;
+/**
+ * The provider whose transaction runs the calls of `command`, or `undefined`
+ * without a transaction or a repository.
+ * @internal
+ */
+export declare function commandTransactionProvider(command: object): IRepositoryProvider | undefined;
+/**
+ * Groups use cases under operation names and is the boundary of a call: the
+ * context is validated once, a transaction can wrap the use case, and the
+ * events it raised are handled by a policy once it succeeded.
+ */
+export declare function commandOf<const UseCases extends CommandUseCases, Context extends IBlueprintCollection | undefined = undefined, Environment extends EnvironmentDependencies | undefined = undefined>(settings: CommandSettings<UseCases, Context, Environment>): CommandOf<UseCases, Context, Environment>;
+/** Whether `value` is a command made by `commandOf`. */
+export declare function isCommand(value: unknown): value is AnyCommand;

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

@@ -0,0 +1,33 @@
+import type { Issue } from "../parse/types/parse.interface.js";
+/** `commandOf` got a setting it cannot use; `details.reason` says which. */
+export declare const InvalidCommandDeclaration: import("../../index.js").DeclaredExceptionClass<{
+    readonly reason: string;
+}>;
+/** A command was asked for an operation it does not declare. */
+export declare const UnknownCommandOperation: import("../../index.js").DeclaredExceptionClass<{
+    readonly operation: string;
+}>;
+/** The context of a call does not fit the context blueprint of the command. */
+export declare const InvalidCommandContext: import("../../index.js").DeclaredExceptionClass<{
+    readonly issues: readonly Issue[];
+}>;
+/**
+ * The `env` of a call holds a key no environment of the command declares, or
+ * a value its blueprint rejects. It is configuration, not input.
+ */
+export declare const InvalidCommandEnvironment: import("../../index.js").DeclaredExceptionClass<{
+    readonly keys: readonly string[];
+    readonly issues: readonly Issue[];
+}>;
+/**
+ * An event handler failed after the call succeeded (and, with a
+ * transaction, committed). `handled` events ran before the failure and
+ * `remaining` events after it were not handled.
+ */
+export declare const CommandEventFailed: import("../../index.js").DeclaredExceptionClass<{
+    readonly operation: string;
+    /** The failed event; absent when a handler policy failed. */
+    readonly event?: string;
+    readonly handled: number;
+    readonly remaining: number;
+}>;