@afora/core 0.0.2 → 0.0.3

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

@@ -8,10 +8,15 @@ 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";
 type SchemaValueType<SchemaType extends TSchema, Optional extends boolean = false> = Optional extends true ? TOptional<SchemaType> : SchemaType;
-type PropertyOfArgs<SchemaType extends TSchema, Optional extends boolean = false, Unique extends boolean = false> = {
+/**
+ * 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>> = {
     name: string;
     schema: SchemaType;
-    default?: Static<SchemaType>;
+    default?: NoInfer<Value>;
     optional?: Optional;
     /** A record masks its value in `toJSON`, at any depth, as `Password`. */
     sensitive?: boolean;
@@ -20,27 +25,33 @@ type PropertyOfArgs<SchemaType extends TSchema, Optional extends boolean = false
      * do not check it, repositories (or the database) enforce it.
      */
     unique?: Unique;
-    preHandle?: (value: Static<SchemaType>) => Static<SchemaType>;
-    afterHandle?: (value: Static<SchemaType>) => Static<SchemaType>;
+    preHandle?: (value: NoInfer<Value>) => NoInfer<Value>;
+    afterHandle?: (value: NoInfer<Value>) => NoInfer<Value>;
 };
-/** The instance type of a class declared with `propertyOf`. */
-export declare class DeclaredProperty<SchemaType extends TSchema> extends AbstractProperty<SchemaType> {
-    protected createDefinition(): AbstractDefineProperty<SchemaType>;
+/**
+ * The instance type of a class declared with `propertyOf`; `Value` is the
+ * value of its schema, as in `ISchema`.
+ */
+export declare class DeclaredProperty<SchemaType extends TSchema, Value = Static<SchemaType>> extends AbstractProperty<SchemaType, Value> {
+    protected createDefinition(): AbstractDefineProperty<SchemaType, Value>;
 }
-/** A class declared with `propertyOf`; extend it to add behavior, as `Id` does. */
-export interface PropertyClass<SchemaType extends TSchema> {
-    new (value: PropertyValue<SchemaType>): DeclaredProperty<SchemaType>;
-    readonly type: IPropertyType<SchemaType>;
+/**
+ * A class declared with `propertyOf`; extend it to add behavior, as `Id` does.
+ * `Value` is the value of its schema, as in `ISchema`.
+ */
+export interface PropertyClass<SchemaType extends TSchema, Value = Static<SchemaType>> {
+    new (value: PropertyValue<SchemaType, Value>): DeclaredProperty<SchemaType, Value>;
+    readonly type: IPropertyType<SchemaType, Value>;
     /** The value handled by the property, or every issue that rejects `value`; never throws. */
-    safeParse(value: unknown): ParseResult<PropertyValue<SchemaType>>;
+    safeParse(value: unknown): ParseResult<PropertyValue<SchemaType, Value>>;
     /** The Standard Schema of the class: `validate` gives the handled value. */
-    readonly "~standard": StandardSchemaV1.Props<PropertyValue<SchemaType>, PropertyValue<SchemaType>>;
+    readonly "~standard": StandardSchemaV1.Props<PropertyValue<SchemaType, Value>, PropertyValue<SchemaType, Value>>;
     /**
      * A subclass narrowed and documented by `options`, e.g.
      * `Integer.with({ min: 1, description: "Age in years" })`.
      */
-    with<Self extends AnyPropertyConstructor>(this: Self, options: PropertyOptions<SchemaType>): Self;
+    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>> & UniqueMark<Unique>;
+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 {};

package/dist/core/property/types/abstract-property-constructor.type.d.ts

@@ -1,13 +1,14 @@
-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 type { AbstractProperty } from "../abstract-property.js";
 import type { PropertyValue } from "./property-constructor.type.js";
 import type { IPropertyType } from "./property-type.interface.js";
-export type AbstractPropertyConstructor<SchemaType extends TSchema> = {
-    new (value: PropertyValue<SchemaType>): AbstractProperty<SchemaType>;
-    readonly type: IPropertyType<SchemaType>;
-    demo(): AbstractProperty<SchemaType>;
-    safeParse(value: unknown): ParseResult<PropertyValue<SchemaType>>;
-    readonly "~standard": StandardSchemaV1.Props<PropertyValue<SchemaType>, PropertyValue<SchemaType>>;
+/** A property class; `Value` is the value of its schema, as in `ISchema`. */
+export type AbstractPropertyConstructor<SchemaType extends TSchema, Value = Static<SchemaType>> = {
+    new (value: PropertyValue<SchemaType, Value>): AbstractProperty<SchemaType, Value>;
+    readonly type: IPropertyType<SchemaType, Value>;
+    demo(): AbstractProperty<SchemaType, Value>;
+    safeParse(value: unknown): ParseResult<PropertyValue<SchemaType, Value>>;
+    readonly "~standard": StandardSchemaV1.Props<PropertyValue<SchemaType, Value>, PropertyValue<SchemaType, Value>>;
 };

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

@@ -3,10 +3,11 @@ import type { ParseResult } from "../../parse/types/parse.interface.js";
 import { State } from "../../symbols/state.js";
 import type { PropertyStates } from "../enums/property-states.js";
 import type { IPropertyType } from "./property-type.interface.js";
-export interface IDefineProperty<SchemaType extends TSchema> {
+/** How a property handles its value; `Value` is the value of its schema, as in `ISchema`. */
+export interface IDefineProperty<SchemaType extends TSchema, Value = Static<SchemaType>> {
     [State]: PropertyStates;
-    get type(): IPropertyType<SchemaType>;
-    make(value: Static<SchemaType>): Static<SchemaType>;
+    get type(): IPropertyType<SchemaType, Value>;
+    make(value: Value): Value;
     /** Like `make`, but returns the issues of a rejected value instead of throwing. */
-    parse(value: unknown): ParseResult<Static<SchemaType>>;
+    parse(value: unknown): ParseResult<Value>;
 }

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

@@ -11,10 +11,10 @@ import type { IPropertyType, UniqueTypeOf } from "./property-type.interface.js";
  * own methods and statics (e.g. `Password#verify`, `Id.generate`) are kept.
  */
 export type OptionalProperty<Property extends AnyPropertyConstructor> = Property extends {
-    readonly type: IPropertyType<infer SchemaType>;
+    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>>): AbstractProperty<TOptional<SchemaType>> & Omit<InstanceType<Property>, keyof AbstractProperty<TSchema>>;
-    readonly type: IPropertyType<TOptional<SchemaType>> & UniqueTypeOf<Property>;
-    safeParse(value: unknown): ParseResult<PropertyValue<TOptional<SchemaType>>>;
-    readonly "~standard": StandardSchemaV1.Props<PropertyValue<TOptional<SchemaType>>, PropertyValue<TOptional<SchemaType>>>;
+    new (value: PropertyValue<TOptional<SchemaType>, Value>): AbstractProperty<TOptional<SchemaType>, Value> & Omit<InstanceType<Property>, keyof AbstractProperty<TSchema>>;
+    readonly type: IPropertyType<TOptional<SchemaType>, Value> & UniqueTypeOf<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-collection.type.d.ts

@@ -7,8 +7,8 @@ import type { IPropertyType } from "./property-type.interface.js";
  * to `unknown`, which a constructor taking a narrower value would reject.
  */
 export type AnyPropertyConstructor = {
-    new (value: any): AbstractProperty<any>;
-    readonly type: IPropertyType<any>;
+    new (value: any): AbstractProperty<any, any>;
+    readonly type: IPropertyType<any, any>;
     safeParse(value: unknown): ParseResult<any>;
     readonly "~standard": StandardSchemaV1.Props<any, any>;
 };

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

@@ -1,2 +1,6 @@
 import type { Static, TOptional, TSchema } from "typebox";
-export type PropertyValue<SchemaType extends TSchema> = SchemaType extends TOptional<TSchema> ? Static<SchemaType> | undefined : Static<SchemaType>;
+/**
+ * The value a property holds: the value of its schema, or `undefined` too
+ * when it is optional. `Value` is the value of the schema, as in `ISchema`.
+ */
+export type PropertyValue<SchemaType extends TSchema, Value = Static<SchemaType>> = SchemaType extends TOptional<TSchema> ? Value | undefined : Value;

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

@@ -46,7 +46,7 @@ export interface StringConstraints {
  * What `Property.with` and `ctx.<property>(options)` take: the metadata of any
  * property, plus the constraints of its kind of schema, for strings and numbers.
  */
-export type PropertyOptions<SchemaType extends TSchema> = PropertyMetadata<NonNullable<Static<SchemaType>>> & (SchemaType extends TString ? StringConstraints : SchemaType extends TNumber | TInteger ? NumberConstraints : unknown);
+export type PropertyOptions<SchemaType extends TSchema, Value = Static<SchemaType>> = PropertyMetadata<NonNullable<Value>> & (SchemaType extends TString ? StringConstraints : SchemaType extends TNumber | TInteger ? NumberConstraints : unknown);
 /**
  * Brands a `CallableProperty` with the property it stands for.
  *
@@ -60,18 +60,27 @@ export declare const Callable: unique symbol;
 export type CallableProperty<Property extends {
     readonly type: IPropertyType<TSchema>;
 }> = Property & {
-    (options?: PropertyOptions<SchemaOfProperty<Property>>): Property;
+    (options?: OptionsOfProperty<Property>): Property;
     readonly [Callable]: Property;
 };
-/** The schema of a property class. */
-type SchemaOfProperty<Property> = Property extends {
-    readonly type: IPropertyType<infer SchemaType>;
-} ? SchemaType : TSchema;
-/** `Field`, or the property it stands for when it is a `CallableProperty`, as a blueprint stores it. */
+/**
+ * The `PropertyOptions` of a property class, from its schema and the value
+ * its type carries, so `Static` is not measured again.
+ */
+type OptionsOfProperty<Property> = Property extends {
+    readonly type: IPropertyType<infer SchemaType, infer Value>;
+} ? PropertyOptions<SchemaType, Value> : PropertyOptions<TSchema>;
+/**
+ * `Field`, or the property it stands for when it is a `CallableProperty`, as a blueprint stores it.
+ * @internal
+ */
 export type StoredField<Field> = Field extends {
     readonly [Callable]: infer Property;
 } ? Property : Field;
-/** `StoredField` of every field of a collection. */
+/**
+ * `StoredField` of every field of a collection.
+ * @internal
+ */
 export type StoredFields<Fields> = {
     [Key in keyof Fields]: StoredField<Fields[Key]>;
 };

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

@@ -1,11 +1,15 @@
 import type { Static, TSchema } from "typebox";
 import type { ISchema } from "../../schema/types/schema.interface.js";
 import { Demo } from "../../symbols/demo.js";
-export interface IPropertyType<SchemaType extends TSchema> {
+/**
+ * What a property declares about itself. `Value` is the value of its schema,
+ * computed where `SchemaType` is known, as in `ISchema`.
+ */
+export interface IPropertyType<SchemaType extends TSchema, Value = Static<SchemaType>> {
     /** Value used by `demo()`; it is the property's `default`, when there is one. */
-    readonly [Demo]: Static<SchemaType> | undefined;
+    readonly [Demo]: Value | undefined;
     readonly name: string;
-    readonly schema: ISchema<SchemaType>;
+    readonly schema: ISchema<SchemaType, Value>;
     readonly optional?: boolean;
     /** Whether a record masks its value in `toJSON`, at any depth. */
     readonly sensitive?: boolean;

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

@@ -1,7 +1,8 @@
-import type { TSchema } from "typebox";
+import type { Static, TSchema } from "typebox";
 import type { AbstractDefineProperty } from "../define-property.js";
 import type { PropertyValue } from "./property-constructor.type.js";
-export interface IProperty<SchemaType extends TSchema> {
-    readonly definition: AbstractDefineProperty<SchemaType>;
-    readonly value: PropertyValue<SchemaType>;
+/** A property instance; `Value` is the value of its schema, as in `ISchema`. */
+export interface IProperty<SchemaType extends TSchema, Value = Static<SchemaType>> {
+    readonly definition: AbstractDefineProperty<SchemaType, Value>;
+    readonly value: PropertyValue<SchemaType, Value>;
 }

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

@@ -1,7 +1,13 @@
 import type { BlueprintData, 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";
+/** The statics of a class made by `recordOf`, that its records read. */
+interface RecordDeclaration<Properties extends IBlueprintCollection> {
+    readonly blueprint: IBlueprint<Properties>;
+    readonly options: RecordSettings<Properties>;
+}
 /**
  * The names of the record's own members, and of those every object inherits
  * (`toString`, `valueOf`, `__proto__`...), which no key of a blueprint can take.
@@ -32,8 +38,10 @@ export declare function recordFieldDataOf(field: BlueprintField | undefined, val
  * and the one it replaced.
  */
 export declare function storeRecordValue(record: {
-    readonly blueprint: {
-        readonly properties: IBlueprintCollection;
+    readonly [Meta]: {
+        readonly blueprint: {
+            readonly properties: IBlueprintCollection;
+        };
     };
 }, key: string, value: unknown): {
     readonly next: unknown;
@@ -47,8 +55,7 @@ export declare const RecordPluginHooks: unique symbol;
  */
 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> {
-    readonly blueprint: IBlueprint<Properties>;
-    readonly options: RecordSettings<Properties>;
+    get [Meta](): RecordDeclaration<Properties>;
     constructor(value: BlueprintInput<Properties>);
     /**
      * An instance of the class for `value`, each key handled, or every issue
@@ -82,3 +89,4 @@ export declare abstract class AbstractRecord<Properties extends IBlueprintCollec
      */
     protected onSet(): RecordEffects<IRecord<Properties>>;
 }
+export {};

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

@@ -90,13 +90,17 @@ export interface IRecordPluginCatalog<Plugins extends Readonly<globalThis.Record
     /** `resolve` for each of `references`, e.g. `JSON.parse(JSON.stringify(Post.plugins))`. */
     resolveAll(references: readonly RecordPluginReference[]): readonly AnyRecordPlugin[];
 }
-/** The plugins of a catalog made of `Plugins`, by name. */
+/**
+ * The plugins of a catalog made of `Plugins`, by name.
+ * @internal
+ */
 export type RecordPluginsByName<Plugins extends readonly AnyRecordPlugin[]> = {
     readonly [Plugin in Plugins[number] as Plugin["name"]]: Plugin;
 };
 /**
  * What `options.plugins` picks from: the plugins of every catalog, by name; a
  * later catalog replaces a plugin of an earlier one with the same name.
+ * @internal
  */
 export type RecordPluginContext<Catalogs extends readonly IRecordPluginCatalog[]> = Catalogs extends readonly [
     infer Head extends IRecordPluginCatalog,
@@ -111,7 +115,10 @@ type PluginProperties<Plugin> = Plugin extends {
         readonly blueprint: IBlueprint<infer Properties, boolean>;
     };
 } ? Properties : never;
-/** The fields of a record, and those of each of its plugins. */
+/**
+ * The fields of a record, and those of each of its plugins.
+ * @internal
+ */
 export type WithPluginProperties<Properties extends IBlueprintCollection, Plugins extends readonly AnyRecordPlugin[]> = [Plugins[number]] extends [never] ? Properties : Properties & UnionToIntersection<PluginProperties<Plugins[number]>> extends infer Merged ? {
     readonly [Key in keyof Merged]: Merged[Key];
 } : never;
@@ -119,7 +126,10 @@ export type WithPluginProperties<Properties extends IBlueprintCollection, Plugin
 type PluginInstance<Plugin> = Plugin extends {
     readonly record: abstract new (value: never) => infer Instance;
 } ? Instance : never;
-/** What the plugins add to the records they are applied to: their keys and methods. */
+/**
+ * What the plugins add to the records they are applied to: their keys and methods.
+ * @internal
+ */
 export type PluginMembers<Plugins extends readonly AnyRecordPlugin[]> = [
     Plugins[number]
 ] extends [never] ? unknown : UnionToIntersection<PluginInstance<Plugins[number]>>;

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

@@ -1,14 +1,25 @@
-import type { BlueprintData, BlueprintInput, BlueprintValue, IBlueprint, IBlueprintCollection, RecordAccepts } from "../../blueprint/types/blueprint.interface.js";
+import type { AnyBlueprint, BlueprintData, BlueprintInput, BlueprintValue, IBlueprint, IBlueprintCollection, RecordAccepts } from "../../blueprint/types/blueprint.interface.js";
 import type { ParseResult } from "../../parse/types/parse.interface.js";
 import type { StandardSchemaV1 } from "../../standard/standard-schema.js";
 import type { Kind } from "../../symbols/kind.js";
+import type { Meta } from "../../symbols/meta.js";
 import type { AbstractRecord } from "../abstract-record.js";
 import type { AnyRecordPlugin, RecordPluginsOption, RecordUniqueKeys } from "./plugin.interface.js";
 /** The value of a record, read from its blueprint. */
-export type RecordValue<Record extends AnyRecordShape> = Record["blueprint"] extends IBlueprint<infer Properties> ? BlueprintValue<Properties> : never;
-/** Anything with a blueprint, as records are. */
+export type RecordValue<Record extends AnyRecordShape> = Record extends {
+    readonly [Meta]: {
+        readonly blueprint: IBlueprint<infer Properties>;
+    };
+} ? BlueprintValue<Properties> : Record extends {
+    readonly blueprint: IBlueprint<infer Properties>;
+} ? BlueprintValue<Properties> : never;
+/** A record instance's metadata, or a record class's statics. */
 type AnyRecordShape = {
-    readonly blueprint: IBlueprint<any>;
+    readonly blueprint: AnyBlueprint;
+} | {
+    readonly [Meta]: {
+        readonly blueprint: AnyBlueprint;
+    };
 };
 /** A side effect of a change to a key: its new value and the one it replaced. */
 export type RecordEffect<Value> = (value: Value, previous: Value) => void;
@@ -81,10 +92,11 @@ type RecordChangeMethods<Self, Properties extends IBlueprintCollection, Key exte
     readonly [K in Key]: (value: K extends keyof BlueprintValue<Properties> ? BlueprintValue<Properties>[K] : never) => Self;
 };
 export interface IRecord<Properties extends IBlueprintCollection> {
-    /** The blueprint whose shape the record implements. */
-    readonly blueprint: IBlueprint<Properties>;
-    /** Which keys are sensitive, unique or have a `change.<key>` method. */
-    readonly options: RecordSettings<Properties>;
+    /** Declaration metadata, separate from domain keys. */
+    readonly [Meta]: {
+        readonly blueprint: IBlueprint<Properties>;
+        readonly options: RecordSettings<Properties>;
+    };
     /** The value with the sensitive keys, and every `sensitive` property, masked. */
     toJSON(): Readonly<Partial<BlueprintData<Properties>>>;
 }

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

@@ -1,3 +1,7 @@
+/** A query contains unsupported keys, ordering or pagination. */
+export declare const InvalidRepositoryQuery: import("../../index.js").DeclaredExceptionClass<{
+    readonly reason: string;
+}>;
 /** `repositoryOf` got something other than an entity, actions and a provider. */
 export declare const InvalidRepositoryDeclaration: import("../../index.js").DeclaredExceptionClass<{
     readonly reason: string;

package/dist/core/repository/in-memory.d.ts

@@ -3,5 +3,8 @@ import type { IRepositoryProvider } from "./types/repository.interface.js";
  * A provider that keeps the values in memory, one table per entity class,
  * enforcing its unique keys. Each `repositoryOf` without a provider gets its
  * own; repositories given the same one share the tables of their entities.
+ * Its `transaction` works on isolated snapshots: commits on success, discards
+ * on rejection, runs one at a time and makes other operations wait; nested
+ * transactions are savepoints.
  */
 export declare function inMemoryProvider(): IRepositoryProvider;

package/dist/core/repository/provider.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderDescription, ProviderOptions, ProviderSettings } from "./types/query.interface.js";
+import type { IRepositoryProvider } from "./types/repository.interface.js";
+/** Creates a provider once and attaches an immutable, serializable declaration out of band. */
+export declare function providerOf<Options extends ProviderOptions = ProviderOptions, Provider extends IRepositoryProvider = IRepositoryProvider>(settings: ProviderSettings<Options, Provider>): Provider;
+/** Describes a named provider; an anonymous one needs an explicit import on extraction. */
+export declare function providerDescriptionOf(provider: IRepositoryProvider): ProviderDescription;

package/dist/core/repository/query.d.ts

@@ -0,0 +1,9 @@
+import type { RepositoryQuery } from "./types/query.interface.js";
+import type { RepositoryContext, RepositoryData } from "./types/repository.interface.js";
+/** Validates query structure and optionally normalizes domain values for storage. */
+export declare function prepareQuery(context: RepositoryContext, input?: unknown, map?: (key: string, value: unknown) => unknown): RepositoryQuery;
+/** Structural JSON/data equality without depending on object key insertion order. */
+export declare function sameValue(a: unknown, b: unknown): boolean;
+export declare function matchesQuery(data: RepositoryData, query: RepositoryQuery): boolean;
+/** The rows of `query` after ordering, offset and limit. */
+export declare function selectRows(rows: Iterable<RepositoryData>, query: RepositoryQuery): RepositoryData[];

package/dist/core/repository/references.d.ts

@@ -1,3 +1,4 @@
+import { type ExecutionScope } from "../use-case/scope.js";
 import { type RepositoryState } from "./state.js";
 import type { AnyRepositoryEntity, RepositoryData } from "./types/repository.interface.js";
 /** The relations of a repository of `entity` named `name`, one for each entity class it holds. */
@@ -11,6 +12,7 @@ export type ReferenceSession = Map<RepositoryState, Map<string, object>>;
  * entity they hold replaced by the entity, loaded in one batch for each
  * relation. An entity loaded twice in `session` is the same instance. Throws
  * `InvalidRepositoryData`, caused by `RepositoryEntityNotFound`, for an id
- * with no entity.
+ * with no entity. The providers of the `scope` of the call, if any, replace
+ * those of the relations.
  */
-export declare function resolveReferences(state: RepositoryState, datas: readonly RepositoryData[], session: ReferenceSession): Promise<readonly RepositoryData[]>;
+export declare function resolveReferences(state: RepositoryState, datas: readonly RepositoryData[], session: ReferenceSession, scope?: ExecutionScope): Promise<readonly RepositoryData[]>;

package/dist/core/repository/repository.d.ts

@@ -7,6 +7,8 @@ export interface RepositorySettings<Entity extends AnyRepositoryEntity, Actions
     readonly entity: Entity;
     /** Its methods, e.g. `["findById", "findByEmail", "findManyByName", "create"]`. */
     readonly actions: Actions;
+    /** Physically remove rows (default), or retain them with `deletedAt`. */
+    readonly deletion?: "hard" | "soft";
     /** How it reads and writes; a new `inMemoryProvider()` by default. */
     readonly provider?: IRepositoryProvider<MergedEnvironment<Environment>>;
     /** The environments the provider gets, merged, as `context.env`. */
@@ -49,8 +51,8 @@ export declare abstract class AbstractRepository<Entity extends AnyRepositoryEnt
  * A repository of `entity` with the methods of `actions`: `findBy<Key>` for a
  * unique key (`id`, `options.unique`, a `unique` property), giving the entity
  * or `undefined`; `findManyBy<Key>` for any other key, giving a list;
- * `create`, `update`, `delete`
- * and `count`. Every method is async and reads and writes through `provider`
+ * `create`, `update`, `delete`, `count`, and the queries `findMany`,
+ * `exists` and `findPage`. Every method is async and reads and writes through `provider`
  * (a new `inMemoryProvider()` by default), which gets the variables of
  * `environmentDependencies` as `context.env`. The repository can be a
  * dependency of a use case, and `RepositoryOf` extends it with a class.

package/dist/core/repository/state.d.ts

@@ -5,6 +5,7 @@ export interface RepositoryState {
     readonly name: string;
     readonly entity: AnyRepositoryEntity;
     readonly actions: readonly string[];
+    readonly deletion: "hard" | "soft";
     readonly provider: IRepositoryProvider;
     /** Whether `settings.provider` was given, and not the default one. */
     readonly explicitProvider: boolean;
@@ -24,7 +25,10 @@ export declare function contextOf(state: RepositoryState): RepositoryContext;
 export interface RepositoryInspection {
     readonly entity: AnyRepositoryEntity;
     readonly actions: readonly string[];
+    readonly deletion: "hard" | "soft";
     readonly explicitProvider: boolean;
+    /** The provider, only when the repository declared it. */
+    readonly provider: IRepositoryProvider | undefined;
     readonly environments: readonly object[];
     /** The repository state of each related entity class; compare with `inspect(...).state`. */
     readonly relations: readonly object[];

package/dist/core/repository/types/query.interface.d.ts

@@ -0,0 +1,67 @@
+import type { EntityInstanceOf, EntityKeyOf, EntityValueOf, IRepositoryProvider, QueryValueOf } from "./repository.interface.js";
+type QueryKey<Entity> = unknown extends Entity ? string : EntityKeyOf<Entity>;
+type QueryValue<Entity, Key extends string> = unknown extends Entity ? unknown : Key extends keyof EntityValueOf<Entity> ? QueryValueOf<EntityValueOf<Entity>[Key]> : unknown;
+/** Equality, or membership in a list. Conditions on different keys are ANDed. */
+export type RepositoryWhere<Entity = unknown> = {
+    readonly [Key in QueryKey<Entity>]?: QueryValue<Entity, Key> | {
+        readonly in: readonly QueryValue<Entity, Key>[];
+    };
+};
+/** Ordered lexicographically; ties retain provider order. Missing values sort first. */
+export interface RepositoryOrder<Key extends string = string> {
+    readonly key: Key;
+    readonly direction?: "asc" | "desc";
+}
+/** The v2 query shared by providers and typed repository reads. */
+export interface RepositoryQuery<Entity = unknown> {
+    readonly where?: RepositoryWhere<Entity>;
+    readonly orderBy?: readonly RepositoryOrder<QueryKey<Entity>>[];
+    /** Nonnegative integer; zero returns an empty result. */
+    readonly limit?: number;
+    /** Nonnegative integer, applied before limit. */
+    readonly offset?: number;
+    /** Include destroyed rows; repository defaults depend on its deletion policy. */
+    readonly withDeleted?: boolean;
+}
+/** A page and the unpaginated number of matching live (or explicitly included) rows. */
+export interface RepositoryPage<Entity> {
+    readonly items: readonly EntityInstanceOf<Entity>[];
+    readonly total: number;
+    readonly limit: number;
+    readonly offset: number;
+}
+export interface RepositoryFindMany<Entity> {
+    findMany(query?: RepositoryQuery<Entity>): Promise<EntityInstanceOf<Entity>[]>;
+}
+export interface RepositoryExists<Entity> {
+    exists(query?: RepositoryQuery<Entity>): Promise<boolean>;
+}
+export interface RepositoryFindPage<Entity> {
+    /** Defaults to limit 20 and offset 0. */
+    findPage(query?: RepositoryQuery<Entity>): Promise<RepositoryPage<Entity>>;
+}
+/** JSON values retained in provider descriptors, including explicit import references. */
+export type ProviderOption = null | boolean | number | string | readonly ProviderOption[] | {
+    readonly [key: string]: ProviderOption;
+};
+export type ProviderOptions = Readonly<Record<string, ProviderOption>>;
+/** A named provider can be reconstructed; opaque providers require an import mapping. */
+export type ProviderDescription = {
+    readonly kind: "provider";
+    readonly name: string;
+    readonly options: ProviderOptions;
+} | {
+    readonly kind: "opaque";
+};
+/** Equality and `in` are mandatory; additional operators are advertised here. */
+export interface ProviderCapabilities {
+    readonly operators?: readonly string[];
+    readonly transactions?: boolean;
+}
+/** Declaration input for a named provider, implemented by providerOf in T10. */
+export interface ProviderSettings<Options extends ProviderOptions = ProviderOptions, Provider extends IRepositoryProvider = IRepositoryProvider> {
+    readonly name: string;
+    readonly options?: Options;
+    readonly create: (options: Options) => Provider;
+}
+export {};

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

@@ -3,6 +3,7 @@ import type { AbstractEntity, EntityUniqueKeys } from "../../entity/abstract-ent
 import type { AnyEntityClass } from "../../entity/event.js";
 import type { RecordSettings } from "../../record/types/record.interface.js";
 import type { AbstractRepository } from "../repository.js";
+import type { ProviderCapabilities, RepositoryExists, RepositoryFindMany, RepositoryFindPage, RepositoryQuery } from "./query.interface.js";
 /** Any class made by `entityOf`, or extending one, that a repository holds. */
 export type AnyRepositoryEntity = AnyRecordClass & AnyEntityClass & {
     readonly [EntityUniqueKeys]: readonly string[];
@@ -42,8 +43,8 @@ export interface RepositoryDelete<Entity> {
     delete(entity: EntityInstanceOf<Entity> | string): Promise<EntityInstanceOf<Entity>>;
 }
 /** `count`: how many entities it holds. */
-export interface RepositoryCount {
-    count(): Promise<number>;
+export interface RepositoryCount<Entity = unknown> {
+    count(query?: RepositoryQuery<Entity>): Promise<number>;
 }
 /** The `findBy<Key>` of `Actions`, one for each unique key: the entity, or `undefined`. */
 export type RepositoryFindBy<Entity, Actions extends string = string> = {
@@ -64,10 +65,11 @@ export type RepositoryFindManyBy<Entity, Actions extends string = string> = {
 /**
  * The methods of `Actions` for `Entity`. Declared as methods, not properties,
  * so that a class extending a repository can override them.
+ * @internal
  */
-export type RepositoryMethods<Entity, Actions extends string = string> = RepositoryFindBy<Entity, Actions> & RepositoryFindManyBy<Entity, Actions> & ("create" extends Actions ? RepositoryCreate<Entity> : unknown) & ("update" extends Actions ? RepositoryUpdate<Entity> : unknown) & ("delete" extends Actions ? RepositoryDelete<Entity> : unknown) & ("count" extends Actions ? RepositoryCount : unknown);
+export type RepositoryMethods<Entity, Actions extends string = string> = RepositoryFindBy<Entity, Actions> & RepositoryFindManyBy<Entity, Actions> & ("create" extends Actions ? RepositoryCreate<Entity> : unknown) & ("update" extends Actions ? RepositoryUpdate<Entity> : unknown) & ("delete" extends Actions ? RepositoryDelete<Entity> : unknown) & ("count" extends Actions ? RepositoryCount<Entity> : unknown) & ("findMany" extends Actions ? RepositoryFindMany<Entity> : unknown) & ("exists" extends Actions ? RepositoryExists<Entity> : unknown) & ("findPage" extends Actions ? RepositoryFindPage<Entity> : unknown);
 /** A method a repository of `Entity` can have, e.g. `"findByEmail"`. */
-export type RepositoryAction<Entity> = keyof RepositoryFindBy<Entity> | keyof RepositoryFindManyBy<Entity> | "create" | "update" | "delete" | "count";
+export type RepositoryAction<Entity> = keyof RepositoryFindBy<Entity> | keyof RepositoryFindManyBy<Entity> | "create" | "update" | "delete" | "count" | "findMany" | "exists" | "findPage";
 /**
  * A repository of `Entity` with the methods of `Actions`, whose provider gets
  * `Environment` as `context.env`, e.g.
@@ -96,17 +98,15 @@ export interface RepositoryContext<Environment = unknown> {
  * `RepositoryEntityNotFound` for an unknown id.
  */
 export interface IRepositoryProvider<Environment = unknown> {
-    findOne(context: RepositoryContext<Environment>, key: string, value: unknown): Promise<RepositoryData | undefined>;
-    findMany(context: RepositoryContext<Environment>, key: string, value: unknown): Promise<readonly RepositoryData[]>;
+    findOne(context: RepositoryContext<Environment>, query?: RepositoryQuery): Promise<RepositoryData | undefined>;
+    findMany(context: RepositoryContext<Environment>, query?: RepositoryQuery): Promise<readonly RepositoryData[]>;
     insert(context: RepositoryContext<Environment>, data: RepositoryData): Promise<void>;
     update(context: RepositoryContext<Environment>, data: RepositoryData): Promise<void>;
     remove(context: RepositoryContext<Environment>, id: string): Promise<void>;
-    count(context: RepositoryContext<Environment>): Promise<number>;
-    /**
-     * Optional: every value whose `key` is one of `values`, in a single call.
-     * A repository uses it to load the entities another one holds by id, and
-     * calls `findOne` for each id when it is missing.
-     */
-    findIn?(context: RepositoryContext<Environment>, key: string, values: readonly unknown[]): Promise<readonly RepositoryData[]>;
+    count(context: RepositoryContext<Environment>, query?: RepositoryQuery): Promise<number>;
+    readonly capabilities?: ProviderCapabilities;
+    transaction?<Result>(run: (provider: IRepositoryProvider<Environment>) => Promise<Result>): Promise<Result>;
+    /** Releases what the provider holds (connections, files); `app.stop()` calls it. */
+    close?(): void | Promise<void>;
 }
 export {};

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

@@ -1,8 +1,15 @@
 import type { Static, TSchema } from "typebox";
 import type { Validator } from "typebox/compile";
-export type ISchemaType<SchemaType extends TSchema> = Validator<Record<string, TSchema>, SchemaType>;
-export interface ISchema<SchemaType extends TSchema> {
-    match(value: unknown): value is Static<SchemaType>;
+/**
+ * The compiled validator of a schema. `Value` is the schema's value, computed
+ * once where `SchemaType` is known: TypeScript then relates two of them by
+ * their values, without measuring `Static` itself, which costs about a second
+ * on every check.
+ */
+export type ISchemaType<SchemaType extends TSchema, Value = Static<SchemaType>> = Validator<Record<string, TSchema>, SchemaType, Value, Value>;
+/** A schema; `Value` is its value, as in `ISchemaType`. */
+export interface ISchema<SchemaType extends TSchema, Value = Static<SchemaType>> {
+    match(value: unknown): value is Value;
     /**
      * Whether `value` has the structure of the schema (its types), ignoring
      * constraints such as `minLength`, `format`, `pattern` or `const`.
@@ -10,5 +17,5 @@ export interface ISchema<SchemaType extends TSchema> {
     matchShape(value: unknown): boolean;
     errors(value: unknown): string[];
     toString(): string;
-    get type(): ISchemaType<SchemaType>;
+    get type(): ISchemaType<SchemaType, Value>;
 }

package/dist/core/symbols/meta.d.ts

@@ -0,0 +1,2 @@
+/** Declaration metadata, separate from the string keys of a record's domain. */
+export declare const Meta: unique symbol;