@afora/core 0.0.2 → 0.0.4

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;

package/dist/core/use-case/exceptions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A step of a use case is invalid: at declaration (`useCaseOf({ steps })`),
+ * or while the steps run (a `change` or `invoke` on something that is not a
+ * record or has no such member). `details.index` is the position of the step.
+ */
+export declare const InvalidUseCaseStep: import("../../index.js").DeclaredExceptionClass<{
+    readonly index: number;
+    readonly reason: string;
+    readonly code?: string;
+}>;

package/dist/core/use-case/scope.d.ts

@@ -0,0 +1,24 @@
+import type { ILogger } from "../logger/logger.js";
+import type { IRepositoryProvider } from "../repository/types/repository.interface.js";
+/**
+ * What a call carries to its repositories, internal: the providers that
+ * replace the ones the repositories declared (e.g. one inside a transaction).
+ */
+export interface ExecutionScope {
+    /** Provider used by the call for each provider the repositories declared. */
+    readonly providers: ReadonlyMap<IRepositoryProvider, IRepositoryProvider>;
+    /**
+     * The variables a command gives the call in place of those an environment
+     * loads, by environment: a use case that declares it gets these.
+     */
+    readonly environments?: ReadonlyMap<object, Readonly<Record<string, unknown>>>;
+    /** The logger of the application running the call, given by its command. */
+    readonly logger?: ILogger;
+}
+/**
+ * Key of the constructor options (and of the repository view) that carries
+ * the `ExecutionScope`. Not exported by the package: only the core passes it.
+ */
+export declare const ScopeKey: unique symbol;
+/** The provider `scope` gives the call in place of `provider`. */
+export declare function scopedProvider<Provider extends IRepositoryProvider>(scope: ExecutionScope | undefined, provider: Provider): Provider;

package/dist/core/use-case/steps/describe.d.ts

@@ -0,0 +1,13 @@
+import type { StepErrorDescription, UseCaseStepDescription } from "./types/steps.interface.js";
+/** How a class of a step is named in the descriptor. */
+export interface StepNames {
+    /** The registered name of a record or entity class. */
+    readonly record: (Class: unknown) => string;
+    /** The registered name of an exception, or `{ core }` for one the package exports. */
+    readonly error: (Class: unknown) => StepErrorDescription;
+}
+/**
+ * The steps as `describe()` gives them: the same data, with the classes of
+ * `build` and `ensure.error` by name and the function of `run` as `opaque`.
+ */
+export declare function describeSteps(steps: readonly Readonly<Record<string, unknown>>[], names: StepNames): UseCaseStepDescription[];

package/dist/core/use-case/steps/references.d.ts

@@ -0,0 +1,27 @@
+/** The names a step cannot bind with `as`: they are roots or escapes of values. */
+export declare const RESERVED_NAMES: readonly string[];
+/** Whether `value` is usable as the name of a step result or of a `run`. */
+export declare function isStepName(value: unknown): value is string;
+/** A reference split in its root (`input`, `context`, `env` or a bound name) and path. */
+export interface ParsedReference {
+    readonly root: string;
+    readonly path: readonly string[];
+}
+/** Splits `$root.a.0.b`; `undefined` when `text` is not a well-formed reference. */
+export declare function parseReference(text: string): ParsedReference | undefined;
+/** A plain object or array, the shapes a value is made of. */
+export declare function isPlain(value: unknown): value is Record<string, unknown>;
+/** What a walk over a value finds wrong in it. */
+export type ValueIssue = "invalid_value" | "invalid_reference";
+/**
+ * Visits every reference in `value` (a reference, a literal or a mapping),
+ * and reports the first thing that cannot be a value: a function, a class
+ * instance, `undefined`, or a malformed reference.
+ */
+export declare function walkValue(value: unknown, onReference: (reference: ParsedReference, text: string) => void, onIssue: (issue: ValueIssue, text: string) => never): void;
+/** Follows `path` from `from`; a missing segment is `undefined`, never an error. */
+export declare function followPath(from: unknown, path: readonly string[]): unknown;
+/** The value `value` stands for, with `lookup` resolving the references. */
+export declare function resolveValue(value: unknown, lookup: (reference: ParsedReference) => unknown): unknown;
+/** A copy of the data in `value`, frozen; classes and functions are kept as they are. */
+export declare function freezeData<Value>(value: Value): Value;

package/dist/core/use-case/steps/run.d.ts

@@ -0,0 +1,20 @@
+type Step = Readonly<Record<string, unknown>>;
+/** What the interpreter reads of the use case it runs for. */
+interface Host {
+    readonly input: unknown;
+    readonly context: unknown;
+    readonly constructor: {
+        readonly useCaseName: string;
+        readonly steps?: readonly Step[];
+    };
+}
+/**
+ * The `execute` of a use case declared with `steps`: runs them in order, each
+ * awaited, over the dependencies `execute` resolved, so that scope, events and
+ * trace frames work as in a hand-written `execute`. The wrapper of the
+ * constructor validates the response `return` gives.
+ */
+export declare function executeSteps(this: Host, dependencies?: Readonly<Record<string, unknown>>): Promise<unknown>;
+/** The steps a use case class interprets; `undefined` when its `execute` is hand-written. */
+export declare function interpretedStepsOf(UseCase: unknown): readonly Readonly<Record<string, unknown>>[] | undefined;
+export {};

package/dist/core/use-case/steps/types/steps.interface.d.ts

@@ -0,0 +1,153 @@
+import type { AnyRecordClass } from "../../../blueprint/types/blueprint.interface.js";
+import type { AnyRepository } from "../../../repository/types/repository.interface.js";
+import type { AnyExceptionClass, AnyUseCaseClass, UseCaseCollection } from "../../use-case.js";
+/** A reference to a value: `$input.email`, `$context.userId`, `$env.mail`, `$saved.tags.0`. */
+export type StepReference = `$${string}`;
+/**
+ * A value of a step: a reference, a JSON literal (`{ literal: x }` for a
+ * string that starts with `$`) or a mapping of values. Checked at execution.
+ */
+export type StepValue = StepReference | string | number | boolean | null | readonly StepValue[] | {
+    readonly [key: string]: StepValue;
+};
+/** The actions of a repository that only read. */
+export type StepReadAction = `findBy${string}` | `findManyBy${string}` | "findMany" | "exists" | "findPage" | "count";
+type RepositoryKeys<Dependencies> = {
+    [Key in keyof Dependencies & string]: Dependencies[Key] extends AnyRepository ? Key : never;
+}[keyof Dependencies & string];
+type UseCaseKeys<Dependencies> = {
+    [Key in keyof Dependencies & string]: Dependencies[Key] extends AnyUseCaseClass ? Key : never;
+}[keyof Dependencies & string];
+type ActionsOf<Repository> = Repository extends {
+    readonly actions: readonly (infer Action)[];
+} ? Action : never;
+/** `"users.findByEmail"`: a repository dependency and one of its read actions. */
+export type StepFindTarget<Dependencies> = {
+    [Key in RepositoryKeys<Dependencies>]: `${Key}.${Extract<ActionsOf<Dependencies[Key]>, StepReadAction>}`;
+}[RepositoryKeys<Dependencies>];
+/** The repository dependencies that have the action `Action`. */
+export type StepRepositoryWith<Dependencies, Action extends string> = {
+    [Key in RepositoryKeys<Dependencies>]: Action extends ActionsOf<Dependencies[Key]> ? Key : never;
+}[RepositoryKeys<Dependencies>];
+/** What an `ensure` checks. */
+export type StepEnsureKind = "exists" | "absent" | "equals" | "notEquals" | "true" | "false";
+/**
+ * One step of `useCaseOf({ steps })`: plain data, the same in TypeScript and
+ * in JSON but for the classes of `build` and `ensure.error` and the function
+ * of `run`. TypeScript checks the names of dependencies and actions; the
+ * values are checked by the blueprints at execution.
+ */
+export type UseCaseStep<Dependencies extends UseCaseCollection = UseCaseCollection> = {
+    /** `"<repository>.<read action>"`. */
+    readonly find: StepFindTarget<Dependencies>;
+    readonly args?: readonly StepValue[];
+    readonly as?: string;
+} | {
+    readonly ensure: "exists" | "absent" | "true" | "false";
+    readonly value: StepValue;
+    readonly other?: undefined;
+    readonly error: AnyExceptionClass;
+    readonly details?: StepValue;
+} | {
+    readonly ensure: "equals" | "notEquals";
+    readonly value: StepValue;
+    readonly other: StepValue;
+    readonly error: AnyExceptionClass;
+    readonly details?: StepValue;
+} | {
+    /** A record or entity class. */
+    readonly build: AnyRecordClass;
+    readonly values: StepValue;
+    readonly as: string;
+} | {
+    /** A reference to a record or entity. */
+    readonly change: StepReference;
+    readonly key: string;
+    readonly value: StepValue;
+    readonly as?: string;
+} | {
+    /** A reference to a record or entity. */
+    readonly invoke: StepReference;
+    readonly method: string;
+    readonly args?: readonly StepValue[];
+    readonly as?: string;
+} | {
+    readonly create: StepRepositoryWith<Dependencies, "create">;
+    readonly value: StepValue;
+    readonly as?: string;
+} | {
+    readonly update: StepRepositoryWith<Dependencies, "update">;
+    readonly value: StepValue;
+    readonly as?: string;
+} | {
+    readonly delete: StepRepositoryWith<Dependencies, "delete">;
+    readonly value: StepValue;
+    readonly as?: string;
+} | {
+    readonly call: UseCaseKeys<Dependencies>;
+    readonly input: StepValue;
+    readonly as?: string;
+} | {
+    readonly run: string;
+    readonly fn: (...args: any[]) => unknown;
+    readonly args?: readonly StepValue[];
+    readonly as?: string;
+} | {
+    readonly return: StepValue;
+};
+/** A core exception or one registered in the application, by name. */
+export type StepErrorDescription = string | {
+    readonly core: string;
+};
+/** A `UseCaseStep` as `describe()` gives it: classes by name, functions as `opaque`. */
+export type UseCaseStepDescription = {
+    readonly find: string;
+    readonly args?: readonly StepValue[];
+    readonly as?: string;
+} | {
+    readonly ensure: StepEnsureKind;
+    readonly value: StepValue;
+    readonly other?: StepValue;
+    readonly error: StepErrorDescription;
+    readonly details?: StepValue;
+} | {
+    readonly build: string;
+    readonly values: StepValue;
+    readonly as: string;
+} | {
+    readonly change: string;
+    readonly key: string;
+    readonly value: StepValue;
+    readonly as?: string;
+} | {
+    readonly invoke: string;
+    readonly method: string;
+    readonly args?: readonly StepValue[];
+    readonly as?: string;
+} | {
+    readonly create: string;
+    readonly value: StepValue;
+    readonly as?: string;
+} | {
+    readonly update: string;
+    readonly value: StepValue;
+    readonly as?: string;
+} | {
+    readonly delete: string;
+    readonly value: StepValue;
+    readonly as?: string;
+} | {
+    readonly call: string;
+    readonly input: StepValue;
+    readonly as?: string;
+} | {
+    readonly run: string;
+    readonly fn: {
+        readonly kind: "opaque";
+    };
+    readonly args?: readonly StepValue[];
+    readonly as?: string;
+} | {
+    readonly return: StepValue;
+};
+export {};

package/dist/core/use-case/steps/validate.d.ts

@@ -0,0 +1,17 @@
+import type { AnyBlueprint } from "../../blueprint/types/blueprint.interface.js";
+/** What `validateSteps` needs to know of the use case being declared. */
+export interface StepsDeclaration {
+    readonly name: string;
+    readonly blueprint: AnyBlueprint;
+    readonly context: AnyBlueprint | undefined;
+    readonly dependencies: Readonly<Record<string, unknown>>;
+    readonly errors: readonly unknown[];
+}
+/**
+ * Checks `steps` against the declaration of a use case and throws
+ * `InvalidUseCaseStep` (`details: { index, reason, code }`) on the first
+ * thing wrong: an unknown kind, a missing or extra field, a bad name, a
+ * reference to what is not declared or bound yet, an action the repository
+ * lacks, an error not in `errors`, or a missing, repeated or misplaced `return`.
+ */
+export declare function validateSteps(declaration: StepsDeclaration, steps: unknown): void;