@afora/core 0.0.2 → 0.0.3

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

@@ -0,0 +1,102 @@
+import type { BlueprintInput, IBlueprint, IBlueprintCollection } from "../../blueprint/types/blueprint.interface.js";
+import type { EntityEvent } from "../../entity/event.js";
+import type { AnyEnvironment, EnvironmentDependencies, MergedEnvironment } from "../../environment/environment.js";
+import type { Kind } from "../../symbols/kind.js";
+import type { AnyUseCaseClass, UseCaseInput, UseCaseOptions, UseCaseResponse } from "../../use-case/use-case.js";
+/** The use cases of a command, by operation name. */
+export type CommandUseCases = Readonly<Record<string, AnyUseCaseClass>>;
+/** What a handler policy gets next to the events. */
+export interface CommandEventInfo {
+    readonly command: AnyCommand;
+    readonly operation: string;
+    /** The context of the call, validated by the command's blueprint if it has one. */
+    readonly context: unknown;
+    /** The variables of the command's environments, with the `env` of the call over them. */
+    readonly env: Readonly<Record<string, unknown>>;
+}
+/** Handles all the events of a call, once it succeeded. */
+export type CommandEventHandler = (events: readonly EntityEvent[], info: CommandEventInfo) => void | Promise<void>;
+/**
+ * What the command does with the events of a call, after it commits:
+ * `"after-commit"` awaits `event.handle()` in order, `"manual"` leaves them
+ * to `execute`, a function receives them all.
+ */
+export type CommandEvents = "after-commit" | "manual" | CommandEventHandler;
+/** Called when an event fails with the `"after-commit"` policy; the next event still runs. */
+export type CommandEventErrorHandler = (error: unknown, event: EntityEvent, info: CommandEventInfo) => void | Promise<void>;
+export interface CommandSettings<UseCases extends CommandUseCases, Context extends IBlueprintCollection | undefined = undefined, Environment extends EnvironmentDependencies | undefined = undefined> {
+    readonly name: string;
+    readonly description?: string;
+    readonly tags?: readonly string[];
+    /** What the caller supplies with each call; validated once by this blueprint. */
+    readonly context?: IBlueprint<Exclude<Context, undefined>>;
+    readonly useCases: UseCases;
+    /** Runs every call in a transaction of the provider of the repositories. Default `false`. */
+    readonly transaction?: boolean;
+    /**
+     * One environment, or a list merged in order: read on first use as
+     * `command.env`, given to the event handlers, and to the use cases that
+     * declare the same environment, with the `env` of a call over them.
+     */
+    readonly environmentDependencies?: Environment;
+    readonly events?: CommandEvents;
+    readonly onEventError?: CommandEventErrorHandler;
+}
+/** The names of the operations of a command. */
+export type CommandOperation<Command extends {
+    readonly useCases: object;
+}> = keyof Command["useCases"] & string;
+/** The input of an operation. */
+export type CommandInput<Command extends {
+    readonly useCases: CommandUseCases;
+}, Op extends CommandOperation<Command>> = UseCaseInput<Command["useCases"][Op]>;
+/** The response of an operation. */
+export type CommandResponse<Command extends {
+    readonly useCases: CommandUseCases;
+}, Op extends CommandOperation<Command>> = UseCaseResponse<Command["useCases"][Op]>;
+/**
+ * The options of a call: `{ context }` of the command when it declares one,
+ * otherwise those of the use case.
+ */
+export type CommandOptions<Class extends AnyUseCaseClass, Context extends IBlueprintCollection | undefined, Environment extends EnvironmentDependencies | undefined = undefined> = Context extends IBlueprintCollection ? [
+    options: {
+        readonly context: BlueprintInput<Context>;
+    } & CommandEnvOption<Environment>
+] : Class["context"] extends IBlueprint<infer Properties> ? [options: UseCaseOptions<Properties> & CommandEnvOption<Environment>] : Environment extends undefined ? [] : [options?: CommandEnvOption<Environment>];
+/**
+ * The `env` a call can give, when the command declares environments: some of
+ * their variables, in place of the loaded ones for this call.
+ */
+export type CommandEnvOption<Environment extends EnvironmentDependencies | undefined> = Environment extends undefined ? {
+    readonly env?: undefined;
+} : {
+    readonly env?: Partial<MergedEnvironment<Environment>>;
+};
+/** What `execute` gives: the response and the events, with no policy applied. */
+export interface CommandExecution<Value> {
+    readonly value: Value;
+    readonly events: EntityEvent[];
+}
+/** A command made by `commandOf`. */
+export interface CommandOf<UseCases extends CommandUseCases, Context extends IBlueprintCollection | undefined = undefined, in out Environment extends EnvironmentDependencies | undefined = undefined> {
+    readonly [Kind]: "command";
+    readonly commandName: string;
+    readonly description: string | undefined;
+    readonly tags: readonly string[];
+    readonly context: Context extends IBlueprintCollection ? IBlueprint<Context> : undefined;
+    readonly useCases: Readonly<UseCases>;
+    readonly transaction: boolean;
+    /** The environments of `environmentDependencies`, as a list. */
+    readonly environments: readonly AnyEnvironment[];
+    /** Their variables, merged; read and validated on first use (`InvalidEnvironment`). */
+    readonly env: MergedEnvironment<Environment>;
+    readonly events: CommandEvents;
+    readonly onEventError: CommandEventErrorHandler | undefined;
+    readonly operations: readonly (keyof UseCases & string)[];
+    /** Runs `op` and applies the event policy; gives its response. */
+    run<Op extends keyof UseCases & string>(op: Op, input: UseCaseInput<UseCases[Op]>, ...options: CommandOptions<UseCases[Op], Context, Environment>): Promise<UseCaseResponse<UseCases[Op]>>;
+    /** Runs `op` and gives the response and the events, without applying the policy. */
+    execute<Op extends keyof UseCases & string>(op: Op, input: UseCaseInput<UseCases[Op]>, ...options: CommandOptions<UseCases[Op], Context, Environment>): Promise<CommandExecution<UseCaseResponse<UseCases[Op]>>>;
+}
+/** Any command. */
+export type AnyCommand = CommandOf<any, any, any>;

package/dist/core/environment/environment.d.ts

@@ -24,7 +24,10 @@ export type AnyEnvironment = IEnvironment<any>;
 export type EnvironmentValue<Environment extends AnyEnvironment> = ReturnType<Environment["load"]>;
 /** One environment, or a list of them, whose variables are merged in order. */
 export type EnvironmentDependencies = AnyEnvironment | readonly AnyEnvironment[];
-/** The variables of every environment of `Dependencies`, merged. */
+/**
+ * The variables of every environment of `Dependencies`, merged.
+ * @internal
+ */
 export type MergedEnvironment<Dependencies extends EnvironmentDependencies | undefined> = Dependencies extends AnyEnvironment ? EnvironmentValue<Dependencies> : Dependencies extends readonly AnyEnvironment[] ? UnionToIntersection<EnvironmentValue<Dependencies[number]>> & Readonly<Record<never, never>> : Readonly<Record<never, never>>;
 type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
 /** A variable of the environment is missing or rejected by its blueprint. */

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

@@ -47,6 +47,10 @@ export interface DeclaredExceptionClass<Details = undefined> {
     readonly layer: ExceptionLayers;
     from: typeof Exception.from;
 }
+/** Whether `value` is a class made by `exceptionOf`. */
+export declare function isDeclaredException(value: unknown): value is DeclaredExceptionClass<never>;
+/** The message `exceptionOf` got, when it was a string; `undefined` otherwise. */
+export declare function declaredMessageOf(Declared: DeclaredExceptionClass<never>): string | undefined;
 /**
  * Declares an exception of `layer`, e.g.
  * `throw new PropertyRequired({ source: "email" })`. Its `details` are typed

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

@@ -0,0 +1,4 @@
+/** Counts `Exception` classes the package exports from a module the core cannot import. */
+export declare function markExported(...classes: readonly unknown[]): void;
+/** Whether `Declared` is an exception class exported by the package. */
+export declare function isExportedException(Declared: unknown): boolean;

package/dist/core/json.d.ts

@@ -0,0 +1,10 @@
+/** A JSON value. */
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+/**
+ * A deep, frozen copy of `value`, which must be finite, acyclic JSON made of
+ * plain objects and arrays. `subject` names it in the messages (e.g.
+ * "Provider options") and `fail` raises the error of the caller.
+ */
+export declare function frozenJson(value: unknown, subject: string, fail: (reason: string) => never, seen?: Set<object>): JsonValue;

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

@@ -0,0 +1,8 @@
+/** `outputOf`, an operation patch or a stage got something it cannot use; `details.reason` says what. */
+export declare const InvalidOutputStage: import("../../index.js").DeclaredExceptionClass<{
+    readonly reason: string;
+}>;
+/** Two operations of an output share an id. */
+export declare const DuplicateOperation: import("../../index.js").DeclaredExceptionClass<{
+    readonly id: string;
+}>;

package/dist/core/output/openapi-sink.d.ts

@@ -0,0 +1,83 @@
+import type { OpenAPISchema } from "../openapi/types/openapi.interface.js";
+import type { OperationDescriptor } from "./types/output.interface.js";
+declare const METHODS: readonly ["get", "post", "put", "patch", "delete"];
+/** An HTTP method an operation can be routed to. */
+export type OpenAPIMethod = (typeof METHODS)[number];
+/** The options of the `openapi` sink. */
+export interface OpenAPISinkOptions {
+    readonly info: {
+        readonly title: string;
+        readonly version: string;
+        readonly description?: string;
+    };
+    readonly servers?: readonly {
+        readonly url: string;
+        readonly description?: string;
+    }[];
+    /** Prefix of every path, e.g. `"/api"`. Empty by default. */
+    readonly basePath?: string;
+    /** Method and path by operation id, e.g. `{ "Users.login": { path: "/session" } }`. */
+    readonly route?: {
+        readonly [operationId: string]: {
+            readonly method?: OpenAPIMethod;
+            readonly path?: string;
+        };
+    };
+}
+/** An OpenAPI 3.1 document. */
+export interface OpenAPIDocument {
+    readonly openapi: "3.1.0";
+    readonly info: OpenAPISinkOptions["info"];
+    readonly servers?: OpenAPISinkOptions["servers"];
+    readonly paths: {
+        readonly [path: string]: Record<string, unknown>;
+    };
+    readonly components: {
+        readonly schemas: {
+            readonly [name: string]: OpenAPISchema;
+        };
+    };
+}
+/** The options that route operations: shared by the sinks that serve HTTP. */
+export interface RouteOptions {
+    readonly basePath?: string;
+    readonly route?: OpenAPISinkOptions["route"];
+}
+/** Where an operation is served. */
+export interface OperationRoute {
+    readonly method: OpenAPIMethod;
+    /** `basePath` included. */
+    readonly path: string;
+}
+/**
+ * Why `basePath` and `route` are not valid routing options, naming them
+ * `where.basePath` and `where.route`; `undefined` when they are.
+ */
+export declare function routeOptionsIssue(options: RouteOptions, where: string): string | undefined;
+/**
+ * The route of every operation, by id: `POST {basePath}/{kebab(command)}/{kebab(operation)}`,
+ * changed per operation id with `route`. Throws `InvalidOutputStage` (with
+ * `source`) when `route` names an unknown operation or two operations share a
+ * method and path. The routing of the `openapi` sink and of the sinks that
+ * serve HTTP.
+ */
+export declare function operationRoutes(operations: readonly OperationDescriptor[], options: RouteOptions, source?: string): ReadonlyMap<string, OperationRoute>;
+/**
+ * Builds an OpenAPI 3.1 document from the operations.
+ *
+ * Routes: `POST {basePath}/{kebab(command)}/{kebab(operation)}`, changed per
+ * operation id with `route`; two operations on one method and path throw
+ * `InvalidOutputStage`. The `operationId` is the id with its dot as an
+ * underscore (`Users.register` -> `Users_register`), unique or the build
+ * throws. `get` and `delete` send the input as query parameters, which needs
+ * every input field to be a scalar property. Responses: `200` with the
+ * response schema, `400` and `500` always, and the status of each declared
+ * error (`statusOf`: `statuses` of the output, else 422). Operations carry no
+ * repository dependencies, so `404` and `409` appear only when an error that
+ * maps to them is declared. Records and entities reachable from inputs and
+ * responses are named by class name in `components.schemas`, beside `Problem`
+ * (RFC 9457). The `context` of an operation is transport-specific and not
+ * part of the document; sinks that serve HTTP map it (headers, middleware).
+ */
+export declare const openapi: import("./types/output.interface.js").SinkFactory<OpenAPIDocument, OpenAPISinkOptions>;
+export {};

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

@@ -0,0 +1,19 @@
+import type { AnyOutput, OperationDescriptor, OperationPatch, OutputOf, OutputSettings, PipeResult, Stage } from "./types/output.interface.js";
+/**
+ * A modified copy of `operation`. Only `meta` (replaced), `tags`,
+ * `description`, `deprecated` and `invoke` can change; `kind`, `version`,
+ * `id`, `command`, `name`, `useCase`, `input`, `response`, `context` and
+ * `errors` cannot, and a patch naming them throws `InvalidOutputStage`.
+ */
+export declare function operationOf(operation: OperationDescriptor, patch: OperationPatch): OperationDescriptor;
+/**
+ * An output turns commands into operations and runs them through a pipe of
+ * stages: transforms change them, and a last sink builds something concrete
+ * (an OpenAPI document, an HTTP app, ...). The operations are computed once,
+ * at declaration; `build()` runs the sink the first time it is called.
+ * Throws `InvalidOutputStage` (or `DuplicateOperation`) for a bad declaration.
+ * `commands` takes commands, applications (all their commands) or a mix.
+ */
+export declare function outputOf<const Pipe extends readonly Stage[] = readonly []>(settings: OutputSettings<Pipe>): OutputOf<PipeResult<Pipe>>;
+/** Whether `value` is an output made by `outputOf`. */
+export declare function isOutput(value: unknown): value is AnyOutput;

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

@@ -0,0 +1,15 @@
+import type { Problem, ProblemOptions } from "./types/output.interface.js";
+/** The media type of a problem response. */
+export declare const PROBLEM_MEDIA_TYPE = "application/problem+json";
+/**
+ * An RFC 9457 problem for `error`. `issues` (`path`, `code`, `message`; no
+ * values or causes) is present only for a 400, `trace` only with `debug`,
+ * and the `detail` of a 5xx is `"Internal error."` unless `debug` is set, so
+ * internal messages do not leak.
+ */
+export declare function problemOf(error: unknown, options: ProblemOptions): Problem;
+/**
+ * The JSON a sink sends: `JSON.parse(JSON.stringify(value))`. Every record
+ * goes through its `toJSON`, so sensitive values are always masked.
+ */
+export declare function outputValueOf(value: unknown): unknown;

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

@@ -0,0 +1,14 @@
+/** The options of `select`. */
+export interface SelectOptions {
+    /** Keep operations that have any of these tags. */
+    tags?: string[];
+    /** Keep only these operation ids, e.g. `"Users.register"`. */
+    operations?: string[];
+    /** Drop these operation ids. */
+    exclude?: string[];
+}
+/**
+ * Keeps the operations that match every given option: `tags` (any of),
+ * `operations` (ids to keep) and `exclude` (ids to drop).
+ */
+export declare const select: import("./types/output.interface.js").TransformFactory<SelectOptions>;

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

@@ -0,0 +1,24 @@
+import type { IStageCatalog, SinkFactory, SinkSettings, Stage, StageDescription, StageFactory, StageOptions, TransformFactory, TransformSettings } from "./types/output.interface.js";
+/** A factory of transform stages: `select({ tags: ["public"] })`. */
+export declare function transformOf<Options extends object = StageOptions>(settings: TransformSettings<Options>): TransformFactory<Options>;
+/** A factory of sink stages: `openapi({ info })`. */
+export declare function sinkOf<Result, Options extends object = StageOptions>(settings: SinkSettings<Result, Options>): SinkFactory<Result, Options>;
+/**
+ * What a stage is: its kind, name and JSON options when it came from a
+ * factory, `{ kind: "opaque" }` otherwise (a hand-written stage needs an
+ * import mapping to be extracted).
+ */
+export declare function stageDescriptionOf(stage: Stage): StageDescription;
+/**
+ * Whether a factory made by `transformOf` or `sinkOf` builds transforms or
+ * sinks, without calling it; `undefined` for any other function.
+ */
+export declare function stageKindOf(factory: StageFactory): "transform" | "sink" | undefined;
+/** Whether `value` is shaped as a stage (made by a factory or written by hand). */
+export declare function isStage(value: unknown): value is Stage;
+/**
+ * A catalog of stage `factories`, by name: what resolves the name and
+ * options of a JSON pipe back to a stage. Throws `InvalidOutputStage` for a
+ * function that is not a factory or for two with the same name.
+ */
+export declare function stageCatalogOf<const Factories extends readonly StageFactory[]>(...stages: Factories): IStageCatalog;

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

@@ -0,0 +1,17 @@
+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.
+ */
+export declare function raisedOf(error: Exception): Exception;
+/**
+ * The HTTP-style status of an error, in this order: `statuses` by exception
+ * name; 400 for invalid input or context (and any exception whose
+ * `details.issues` is a list, except `InvalidCommandEnvironment`, a 500); 404 for a missing entity or operation; 409 for
+ * a unique violation; 422 for a class in `operation.errors`; 500 for the
+ * rest, errors that are not exceptions included. Exceptions match by name,
+ * or by class for `operation.errors`.
+ */
+export declare function statusOf(error: unknown, operation?: Pick<OperationDescriptor, "errors">, statuses?: OutputStatuses): number;

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

@@ -0,0 +1,171 @@
+import type { AnyBlueprint } from "../../blueprint/types/blueprint.interface.js";
+import type { AnyCommand } from "../../command/types/command.interface.js";
+import type { JsonValue } from "../../json.js";
+import type { Kind } from "../../symbols/kind.js";
+import type { AnyExceptionClass } from "../../use-case/use-case.js";
+/** The options of a stage: a JSON object. */
+export type StageOptions = {
+    readonly [key: string]: JsonValue;
+};
+/** An HTTP-style status by exception name. */
+export type OutputStatuses = Readonly<Record<string, number>>;
+/** The call of an operation: `context` is what the command (or use case) declares. */
+export interface OperationCallOptions {
+    readonly context?: unknown;
+}
+/**
+ * One operation of a command, as an output sees it. Frozen; transforms change
+ * a copy with `operationOf`.
+ */
+export interface OperationDescriptor {
+    readonly kind: "operation";
+    readonly version: 1;
+    /** `"Users.register"`. */
+    readonly id: string;
+    /** The name of the command. */
+    readonly command: string;
+    /** The operation name inside the command. */
+    readonly name: string;
+    /** The `useCaseName`. */
+    readonly useCase: string;
+    /** The use case description, else the command one. */
+    readonly description?: string;
+    /** The command tags, then the use case ones, deduplicated. */
+    readonly tags: readonly string[];
+    readonly deprecated: boolean;
+    readonly input: AnyBlueprint;
+    readonly response: AnyBlueprint;
+    /** The command context, else the use case one. */
+    readonly context?: AnyBlueprint;
+    /** The `errors` of the use case. */
+    readonly errors: readonly AnyExceptionClass[];
+    /** Set by transforms; `{}` initially. */
+    readonly meta: Readonly<Record<string, unknown>>;
+    /** `command.run(name, input, options)`. */
+    invoke(input: unknown, options?: OperationCallOptions): Promise<unknown>;
+}
+/** What `operationOf` can change. */
+export interface OperationPatch {
+    readonly meta?: Readonly<Record<string, unknown>>;
+    readonly tags?: readonly string[];
+    readonly description?: string | undefined;
+    readonly deprecated?: boolean;
+    readonly invoke?: OperationDescriptor["invoke"];
+}
+/** What a stage knows about the output running it. */
+export interface StageContext {
+    readonly output: {
+        readonly name: string;
+        readonly statuses: OutputStatuses;
+    };
+}
+/** A stage that changes (or removes, with `null`) each operation. */
+export interface TransformStage<Options extends object = StageOptions> {
+    readonly kind: "transform";
+    readonly name?: string;
+    readonly options?: Options;
+    apply(operation: OperationDescriptor, context: StageContext): OperationDescriptor | null;
+}
+/** The last stage: builds something concrete out of the operations. */
+export interface SinkStage<Result = unknown, Options extends object = StageOptions> {
+    readonly kind: "sink";
+    readonly name?: string;
+    readonly options?: Options;
+    build(operations: readonly OperationDescriptor[], context: StageContext): Result;
+}
+/** Any stage. */
+export type Stage = TransformStage<any> | SinkStage<any, any>;
+type AnyTransform = TransformStage<any>;
+type AnySink<Result> = SinkStage<Result, any>;
+/** What a stage is, out of band: a name and JSON options, or opaque. */
+export type StageDescription = {
+    readonly kind: "transform" | "sink";
+    readonly name: string;
+    readonly options: StageOptions;
+} | {
+    readonly kind: "opaque";
+};
+export interface TransformSettings<Options extends object> {
+    readonly name: string;
+    /** Returns the operation, a changed copy, or `null` to remove it. */
+    readonly apply: (operation: OperationDescriptor, options: Options, context: StageContext) => OperationDescriptor | null;
+    /** Why `options` cannot be used, or `undefined`. Checked when the stage is made. */
+    readonly validate?: (options: Options) => string | undefined;
+}
+export interface SinkSettings<Result, Options extends object> {
+    readonly name: string;
+    readonly build: (operations: readonly OperationDescriptor[], options: Options, context: StageContext) => Result;
+    /** Why `options` cannot be used, or `undefined`. Checked when the stage is made. */
+    readonly validate?: (options: Options) => string | undefined;
+}
+/** Makes a stage from JSON options. */
+export type TransformFactory<Options extends object = StageOptions> = (options?: Options) => TransformStage<Options>;
+export type SinkFactory<Result = unknown, Options extends object = StageOptions> = (options?: Options) => SinkStage<Result, Options>;
+/** Any stage factory. */
+export type StageFactory = TransformFactory<any> | SinkFactory<any, any>;
+/** Stage factories by name. */
+export interface IStageCatalog<Factories extends Readonly<Record<string, StageFactory>> = Readonly<Record<string, StageFactory>>> {
+    readonly [Kind]: "stage-catalog";
+    readonly stages: Factories;
+    readonly list: readonly StageFactory[];
+    /** Makes the stage `name` with `options`; throws `InvalidOutputStage` for an unknown name. */
+    resolve(name: string, options?: StageOptions): Stage;
+}
+/** The result of the sink at the end of a pipe, or `never` when there is none. */
+export type PipeResult<Pipe extends readonly Stage[]> = Pipe extends readonly [
+    ...Stage[],
+    SinkStage<infer Result, any>
+] ? Result : never;
+/** An application, as far as an output is concerned: it gives its commands. */
+export interface OutputApplication {
+    readonly [Kind]: "application";
+    readonly commands: Readonly<Record<string, AnyCommand>>;
+}
+/** What an output takes its commands from. */
+export type OutputSource = AnyCommand | OutputApplication;
+export interface OutputSettings<Pipe extends readonly Stage[]> {
+    readonly name: string;
+    /** The commands the output exposes: commands, applications (all their commands) or a mix. */
+    readonly commands: OutputApplication | readonly OutputSource[];
+    /** HTTP-style status by exception name. */
+    readonly statuses?: OutputStatuses;
+    readonly pipe?: Pipe;
+}
+/** An output made by `outputOf`. */
+export interface OutputOf<Result = never> {
+    readonly [Kind]: "output";
+    readonly outputName: string;
+    readonly commands: readonly AnyCommand[];
+    /** The operations after the transforms, in declaration order. */
+    readonly operations: readonly OperationDescriptor[];
+    readonly stages: readonly Stage[];
+    readonly statuses: OutputStatuses;
+    /** The result of the sink (memoized); throws when the pipe has no sink. */
+    build(): Result;
+    /** The result of the sink when the last stage is one, else a new, unnamed output. */
+    pipe<Built>(...stages: [...AnyTransform[], AnySink<Built>]): Built;
+    pipe(...stages: Stage[]): OutputOf<never>;
+}
+/** Any output. */
+export type AnyOutput = OutputOf<any>;
+/** An RFC 9457 problem. */
+export interface Problem {
+    readonly type: string;
+    readonly title: string;
+    readonly status: number;
+    readonly detail: string;
+    readonly layer?: string;
+    /** Only for a 400 with validation issues. */
+    readonly issues?: readonly {
+        readonly path: readonly (string | number)[];
+        readonly code: string;
+        readonly message: string;
+    }[];
+    /** Only with `debug`. */
+    readonly trace?: string;
+}
+export interface ProblemOptions {
+    readonly status: number;
+    readonly debug?: boolean;
+}
+export {};

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

@@ -1,4 +1,4 @@
-import type { TSchema } from "typebox";
+import type { Static, TSchema } from "typebox";
 import type { ParseResult } from "../parse/types/parse.interface.js";
 import type { StandardSchemaV1 } from "../standard/standard-schema.js";
 import { State } from "../symbols/state.js";
@@ -9,11 +9,12 @@ 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 } from "./types/property-type.interface.js";
-export declare abstract class AbstractProperty<SchemaType extends TSchema> implements IProperty<SchemaType> {
+/** A property instance; `Value` is the value of its schema, as in `ISchema`. */
+export declare abstract class AbstractProperty<SchemaType extends TSchema, Value = Static<SchemaType>> implements IProperty<SchemaType, Value> {
     get [State](): PropertyStates;
-    readonly definition: AbstractDefineProperty<SchemaType>;
-    readonly value: PropertyValue<SchemaType>;
-    constructor(value: PropertyValue<SchemaType>);
+    readonly definition: AbstractDefineProperty<SchemaType, Value>;
+    readonly value: PropertyValue<SchemaType, Value>;
+    constructor(value: PropertyValue<SchemaType, Value>);
     /**
      * Builds an instance from the property's `default` value. Throws if the
      * property is required and has no `default`.
@@ -32,11 +33,11 @@ export declare abstract class AbstractProperty<SchemaType extends TSchema> imple
      * `pattern`... are checked along with its own constraints, which they can
      * only narrow. Its demo value is `default`, or the first of `examples`.
      */
-    static with<Self extends AnyPropertyConstructor>(this: Self, options: PropertyOptions<Self["type"] extends IPropertyType<infer SchemaType> ? SchemaType : never>): Self;
+    static with<Self extends AnyPropertyConstructor>(this: Self, options: Self["type"] extends IPropertyType<infer SchemaType, infer Value> ? PropertyOptions<SchemaType, Value> : never): Self;
     /**
      * The Standard Schema of the class it is read from, a subclass included:
      * `validate` gives the handled value, or the issues that reject it.
      */
     static get "~standard"(): StandardSchemaV1.Props<any, any>;
-    protected abstract createDefinition(): AbstractDefineProperty<SchemaType>;
+    protected abstract createDefinition(): AbstractDefineProperty<SchemaType, Value>;
 }

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

@@ -4,15 +4,16 @@ import { State } from "../symbols/state.js";
 import { PropertyStates } from "./enums/property-states.js";
 import type { IDefineProperty } from "./types/define-property.interface.js";
 import type { IPropertyType } from "./types/property-type.interface.js";
-export declare abstract class AbstractDefineProperty<SchemaType extends TSchema> implements IDefineProperty<SchemaType> {
+/** How a property handles its value; `Value` is the value of its schema, as in `ISchema`. */
+export declare abstract class AbstractDefineProperty<SchemaType extends TSchema, Value = Static<SchemaType>> implements IDefineProperty<SchemaType, Value> {
     [State]: PropertyStates;
-    abstract get type(): IPropertyType<SchemaType>;
+    abstract get type(): IPropertyType<SchemaType, Value>;
     /**
      * The value handled by the property; throws `PropertyRequired` for
      * `undefined` on a required property, and `InvalidPropertyValue` (or the
      * exception of a handler) for a value it rejects.
      */
-    make(value: Static<SchemaType>): Static<SchemaType>;
+    make(value: Value): Value;
     /**
      * Like `make`, but never throws: the handled value, or an issue for each
      * reason the value is rejected, whose `cause` is the exception `make` would
@@ -21,11 +22,11 @@ export declare abstract class AbstractDefineProperty<SchemaType extends TSchema>
      * `Exception`, from any step, rejects the value too, as the cause of an
      * `InvalidPropertyValue`.
      */
-    parse(value: unknown): ParseResult<Static<SchemaType>>;
-    protected preHandle(value: Static<SchemaType>): Static<SchemaType>;
-    protected afterHandle(value: Static<SchemaType>): Static<SchemaType>;
+    parse(value: unknown): ParseResult<Value>;
+    protected preHandle(value: Value): Value;
+    protected afterHandle(value: Value): Value;
     /** The value, or `MISMATCH` when the schema rejects it. */
-    protected handle(value: Static<SchemaType>): Static<SchemaType>;
+    protected handle(value: Value): Value;
     /** `attempt`, with the error of any step as a failure. */
     private attemptWithoutThrowing;
     /** Runs the pipeline, updating the state, and tells why it stopped if it did. */