@afora/core 0.0.6 → 0.0.7

package/dist/{index-3nd9bjnc.js → index-r78dsvtc.js}

@@ -1000,6 +1000,17 @@ function versionParts(version) {
   const [, major, minor, patch] = SEMVER.exec(version);
   return [Number(major), Number(minor), Number(patch)];
 }
+function satisfies(available, requested) {
+  const [major, minor, patch] = versionParts(available);
+  const [wantedMajor, wantedMinor, wantedPatch] = versionParts(requested);
+  if (major !== wantedMajor)
+    return false;
+  if (major === 0 && minor !== wantedMinor)
+    return false;
+  if (minor !== wantedMinor)
+    return minor > wantedMinor;
+  return patch >= wantedPatch;
+}
 var HOOKS = ["onSet", "onSetAll"];
 var internals = new WeakMap;
 function pluginsOf2(value) {
@@ -1277,6 +1288,60 @@ function declareRecord(Base, declared, { plugins = [], name: declaredName, ...de
 var CHANGE_MEMBER = "change";
 var changeNamespaces = new WeakMap;
 
+// src/core/blueprint/optional.ts
+import { Type } from "typebox";
+var cache2 = new WeakMap;
+function optionalOf2(given) {
+  const field = fieldOf(given);
+  const cached = cache2.get(field);
+  if (cached)
+    return cached;
+  if (isOptionalRecord2(field))
+    return field;
+  if (isRecordClass2(field)) {
+    const optional = Object.freeze(withStandard({
+      [Kind2]: "record",
+      record: field,
+      optional: true
+    }, (value) => value === undefined ? { value } : field.safeParse(value)));
+    cache2.set(field, optional);
+    return optional;
+  }
+  if (isBlueprint2(field)) {
+    if (field.optional)
+      return field;
+    const optional = {
+      ...field,
+      optional: true,
+      safeParse: (value) => value === undefined ? { value } : field.safeParse(value)
+    };
+    Object.freeze(withStandard(optional, (value) => optional.safeParse(value)));
+    cache2.set(field, optional);
+    return optional;
+  }
+  if (isBlueprintList2(field)) {
+    if (field.optional)
+      return field;
+    const optional = standardListOf({ ...field, optional: true });
+    cache2.set(field, optional);
+    return optional;
+  }
+  const Property = field;
+  if (Property.type.optional)
+    return Property;
+  const base = Property.type;
+  const SchemaConstructor = schemaOf2(base.name, Type.Optional(base.schema.type.Type()));
+  const type = {
+    ...base,
+    schema: new SchemaConstructor,
+    optional: true
+  };
+  const Optional = derivePropertyOf(Property, type);
+  recordPropertyLineage(Optional, { kind: "optional", base: Property });
+  cache2.set(Property, Optional);
+  return Optional;
+}
+
 // src/core/blueprint/exceptions.ts
 var ReservedBlueprintKey2 = exceptionOf2({
   layer: "blueprint" /* Blueprint */,
@@ -1305,7 +1370,7 @@ var InvalidPropertyValue2 = exceptionOf2({
 import { Type as Type3 } from "typebox";
 
 // src/core/property/property.ts
-import { Type } from "typebox";
+import { Type as Type2 } from "typebox";
 
 // src/core/symbols/state.ts
 var State2 = Symbol("state");
@@ -1523,7 +1588,7 @@ function propertyOf2({
   preHandle: onPreHandle,
   afterHandle: onAfterHandle
 }) {
-  const valueSchema = optional ? Type.Optional(schema) : schema;
+  const valueSchema = optional ? Type2.Optional(schema) : schema;
   const SchemaConstructor = schemaOf2(name, valueSchema);
   const type = {
     [Demo2]: _default,
@@ -1555,60 +1620,6 @@ function propertyOf2({
   return Property;
 }
 
-// src/core/blueprint/optional.ts
-import { Type as Type2 } from "typebox";
-var cache2 = new WeakMap;
-function optionalOf2(given) {
-  const field = fieldOf(given);
-  const cached = cache2.get(field);
-  if (cached)
-    return cached;
-  if (isOptionalRecord2(field))
-    return field;
-  if (isRecordClass2(field)) {
-    const optional = Object.freeze(withStandard({
-      [Kind2]: "record",
-      record: field,
-      optional: true
-    }, (value) => value === undefined ? { value } : field.safeParse(value)));
-    cache2.set(field, optional);
-    return optional;
-  }
-  if (isBlueprint2(field)) {
-    if (field.optional)
-      return field;
-    const optional = {
-      ...field,
-      optional: true,
-      safeParse: (value) => value === undefined ? { value } : field.safeParse(value)
-    };
-    Object.freeze(withStandard(optional, (value) => optional.safeParse(value)));
-    cache2.set(field, optional);
-    return optional;
-  }
-  if (isBlueprintList2(field)) {
-    if (field.optional)
-      return field;
-    const optional = standardListOf({ ...field, optional: true });
-    cache2.set(field, optional);
-    return optional;
-  }
-  const Property = field;
-  if (Property.type.optional)
-    return Property;
-  const base = Property.type;
-  const SchemaConstructor = schemaOf2(base.name, Type2.Optional(base.schema.type.Type()));
-  const type = {
-    ...base,
-    schema: new SchemaConstructor,
-    optional: true
-  };
-  const Optional = derivePropertyOf(Property, type);
-  recordPropertyLineage(Optional, { kind: "optional", base: Property });
-  cache2.set(Property, Optional);
-  return Optional;
-}
-
 // src/core/blueprint/blueprint.ts
 function blueprintBuilderOf2(...base) {
   return (sourcesOrDefine, maybeDefine) => {
@@ -1707,4 +1718,4 @@ function schemaOfField(key, field) {
   });
 }
 
-export { __export, isProperty2, schemaOf2, Demo2, recordPropertyLineage, propertyLineageOf2, fieldOf, Kind2, isBlueprint2, isRecordClass2, isOptionalRecord2, recordFieldOf2, recordNameOf2, declaredRecordNameOf, listOf2, isBlueprintList2, ExceptionLayers2, UNEXPECTED_ERROR2, Exception2, isDeclaredException, declaredMessageOf, exceptionOf2, Meta2, InvalidRecordValue2, InvalidRecordDeclaration2, UndeclaredRecordProperty2, ReservedRecordKey2, InvalidRecordPlugin2, RecordPluginConflict2, UnknownRecordPlugin2, IncompatibleRecordPlugin2, exports_exceptions, MASK2, RESERVED_RECORD_KEYS2, recordDataOf, recordFieldDataOf, storeRecordValue, runRecordEffects, AbstractRecord2, IdentifiedRecord, isVersion, versionParts, pluginsOf2, isRecordPlugin2, hasPlugin2, recordPluginOf2, recordBuilderOf2, pluginContextOf, recordOf3, declareRecord, ReservedBlueprintKey2, UndeclaredBlueprintProperty2, exports_exceptions2, PropertyRequired2, InvalidPropertyValue2, exports_exceptions3, State2, AbstractProperty2, PropertyStates2, AbstractDefineProperty2, propertyOf2, optionalOf2, blueprintBuilderOf2, blueprintFromProperties };
+export { __export, isProperty2, schemaOf2, Demo2, recordPropertyLineage, propertyLineageOf2, fieldOf, Kind2, isBlueprint2, isRecordClass2, isOptionalRecord2, recordFieldOf2, recordNameOf2, declaredRecordNameOf, listOf2, isBlueprintList2, ExceptionLayers2, UNEXPECTED_ERROR2, Exception2, isDeclaredException, declaredMessageOf, exceptionOf2, Meta2, InvalidRecordValue2, InvalidRecordDeclaration2, UndeclaredRecordProperty2, ReservedRecordKey2, InvalidRecordPlugin2, RecordPluginConflict2, UnknownRecordPlugin2, IncompatibleRecordPlugin2, exports_exceptions, MASK2, RESERVED_RECORD_KEYS2, recordDataOf, recordFieldDataOf, storeRecordValue, runRecordEffects, AbstractRecord2, IdentifiedRecord, isVersion, satisfies, pluginsOf2, isRecordPlugin2, hasPlugin2, recordPluginOf2, recordBuilderOf2, pluginContextOf, recordOf3, declareRecord, optionalOf2, ReservedBlueprintKey2, UndeclaredBlueprintProperty2, exports_exceptions2, PropertyRequired2, InvalidPropertyValue2, exports_exceptions3, State2, AbstractProperty2, PropertyStates2, AbstractDefineProperty2, propertyOf2, blueprintBuilderOf2, blueprintFromProperties };

package/dist/index.d.ts

@@ -13,9 +13,9 @@ export { optionalOf } from "./core/blueprint/optional.js";
 export { isOptionalRecord, isRecordClass, recordFieldOf, } from "./core/blueprint/record-field.js";
 export type { AnyBlueprint, AnyBlueprintList, AnyOptionalRecord, AnyRecordClass, BlueprintBuilder, BlueprintContext, BlueprintData, BlueprintDefinition, BlueprintField, BlueprintHelpers, BlueprintInput, BlueprintListOptions, BlueprintPluginContext, BlueprintSchema, BlueprintSource, BlueprintValue, IBlueprint, IBlueprintCollection, IBlueprintList, OptionalBlueprint, OptionalBlueprintList, OptionalRecord, } from "./core/blueprint/types/blueprint.interface.js";
 export type { BlueprintFactory, IBlueprintFactories, IBlueprintPlugin, } from "./core/blueprint/types/blueprint-plugin.interface.js";
-export { commandOf, isCommand } from "./core/command/command.js";
+export { commandBuilderOf, isCommand } from "./core/command/command.js";
 export { CommandEventFailed, InvalidCommandContext, InvalidCommandDeclaration, InvalidCommandEnvironment, UnknownCommandOperation, } from "./core/command/exceptions.js";
-export type { AnyCommand, CommandEnvOption, CommandEventErrorHandler, CommandEventHandler, CommandEventInfo, CommandEvents, CommandExecution, CommandInput, CommandOf, CommandOperation, CommandOptions, CommandResponse, CommandSettings, CommandUseCases, } from "./core/command/types/command.interface.js";
+export type { AnyCommand, CommandBuilder, CommandBuilderSettings, CommandEnvOption, CommandEventErrorHandler, CommandEventHandler, CommandEventInfo, CommandEvents, CommandExecution, CommandInput, CommandOf, CommandOperation, CommandOptions, CommandResponse, CommandSettings, CommandUseCases, CommandUseCasesOption, } from "./core/command/types/command.interface.js";
 export { AbstractEntity, ENTITY_IDENTITY_KEYS, EntityUniqueKeys, RESERVED_ENTITY_KEYS, } from "./core/entity/abstract-entity.js";
 export { entityBuilderOf, isEntity, isEntityClass } from "./core/entity/entity.js";
 export type { AnyEntityClass, EntityEvent, EntityEventReference, EntityEvents, EventDefinition, EventHandlerContext, } from "./core/entity/event.js";
@@ -50,6 +50,8 @@ export { AbstractProperty } from "./core/property/abstract-property.js";
 export { AbstractDefineProperty } from "./core/property/define-property.js";
 export { PropertyStates } from "./core/property/enums/property-states.js";
 export { InvalidPropertyValue, PropertyRequired, } from "./core/property/exceptions.js";
+export type { IPropertyInput } from "./core/property/input.js";
+export { PropertyInput, propertyInputOf } from "./core/property/input.js";
 export { isProperty } from "./core/property/is-property.js";
 export type { PropertyLineage } from "./core/property/lineage.js";
 export { propertyLineageOf } from "./core/property/lineage.js";
@@ -79,7 +81,7 @@ export { providerDescriptionOf, providerOf } from "./core/repository/provider.js
 export type { RepositorySettings } from "./core/repository/repository.js";
 export { AbstractRepository, isRepository, RepositoryOf, repositoryOf, } from "./core/repository/repository.js";
 export type { ProviderCapabilities, ProviderDescription, ProviderOption, ProviderOptions, ProviderQuery, ProviderSettings, RepositoryCursorPage, RepositoryCursorQuery, RepositoryExists, RepositoryFindCursor, RepositoryFindMany, RepositoryFindPage, RepositoryOrder, RepositoryPage, RepositoryQuery, RepositoryWhere, } from "./core/repository/types/query.interface.js";
-export type { AnyRepository, AnyRepositoryEntity, EntityInstanceOf, EntityKeyOf, EntityNonUniqueKeyOf, EntityUniqueKeyOf, EntityValueOf, IRepositoryProvider, QueryValueOf, RepositoryAction, RepositoryContext, RepositoryCount, RepositoryCreate, RepositoryCreateInput, RepositoryData, RepositoryDelete, RepositoryFindBy, RepositoryFindManyBy, RepositoryUpdate, } from "./core/repository/types/repository.interface.js";
+export type { AnyRepository, AnyRepositoryEntity, EntityInstanceOf, EntityKeyOf, EntityNonUniqueKeyOf, EntityUniqueKeyOf, EntityValueOf, IRepositoryProvider, QueryValueOf, RepositoryAction, RepositoryContext, RepositoryCount, RepositoryCreate, RepositoryCreateInput, RepositoryData, RepositoryDelete, RepositoryFindBy, RepositoryFindManyBy, RepositoryRestore, RepositoryUpdate, } from "./core/repository/types/repository.interface.js";
 export type { SchemaClass } from "./core/schema/schema.js";
 export { schemaOf } from "./core/schema/schema.js";
 export type { ISchema, ISchemaType, } from "./core/schema/types/schema.interface.js";
@@ -88,19 +90,24 @@ export { Demo } from "./core/symbols/demo.js";
 export { Kind } from "./core/symbols/kind.js";
 export { Meta } from "./core/symbols/meta.js";
 export { State } from "./core/symbols/state.js";
-export { InvalidUseCaseStep } from "./core/use-case/exceptions.js";
-export type { StepEnsureKind, StepErrorDescription, StepFindTarget, StepReadAction, StepReference, StepRepositoryWith, StepValue, UseCaseStep, UseCaseStepDescription, } from "./core/use-case/steps/types/steps.interface.js";
+export { IncompatibleUseCasePlugin, InvalidUseCasePlugin, InvalidUseCaseStep, UnknownUseCasePlugin, UseCaseEntityConflict, UseCaseEntityNotFound, UseCaseInvalidCredentials, UseCaseUnavailable, } from "./core/use-case/exceptions.js";
+export { isUseCasePlugin, useCaseOriginOf, useCasePluginOf, } from "./core/use-case/plugin.js";
+export { isUseCaseCatalog, useCaseCatalogOf, } from "./core/use-case/plugin-catalog.js";
+export type { StepArgs, StepEnsureKind, StepErrorDescription, StepFindTarget, StepReadAction, StepReference, StepRepositoryWith, StepValue, UseCaseStep, UseCaseStepDescription, } from "./core/use-case/steps/types/steps.interface.js";
+export { useCaseTargetOf } from "./core/use-case/target.js";
+export type { AnyUseCasePlugin, EntityOfRepository, IUseCaseCatalog, IUseCasePlugin, MissingRecordPlugin, MissingRepositoryAction, UseCaseCompilation, UseCaseContextOf, UseCaseFieldPlan, UseCaseMaker, UseCaseOriginInfo, UseCasePluginContext, UseCasePluginDescriptor, UseCasePluginRequirements, UseCasePluginSettings, UseCasePluginsByName, UseCaseTarget, UseCaseTargetInfo, } from "./core/use-case/types/plugin.interface.js";
 export type { AnyExceptionClass, AnyUseCaseClass, DependencyFunctions, DependencyOf, DependencyOverrides, StepsUseCaseConstructor, UseCaseCollection, UseCaseConstructor, UseCaseContext, UseCaseDependencies, UseCaseDependency, UseCaseInput, UseCaseOptions, UseCaseResponse, UseCaseSettings, UseCaseStepsSettings, } from "./core/use-case/use-case.js";
 export { AbstractUseCase, InvalidUseCaseDeclaration, InvalidUseCaseDependencies, isUseCase, isUseCaseClass, UseCaseAlreadyExecuted, useCaseOf, } from "./core/use-case/use-case.js";
 export { blueprintOf } from "./std/blueprint.js";
 export { Std } from "./std/blueprint-plugin.js";
+export { commandOf } from "./std/command.js";
 export { entityOf } from "./std/entity.js";
 export { Email, Ip, Phone, Url } from "./std/properties/contact.js";
 export type { EnumClass } from "./std/properties/enum.js";
 export { enumOf } from "./std/properties/enum.js";
 export { SchemaProperty } from "./std/properties/headless.js";
 export { Id, Slug } from "./std/properties/identity.js";
-export { isPasswordHash, PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, PASSWORD_SPECIAL_CHARACTERS, Password, passwordIssues, } from "./std/properties/password.js";
+export { isPasswordHash, PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH, PASSWORD_SPECIAL_CHARACTERS, Password, PlainPassword, passwordIssues, } from "./std/properties/password.js";
 export { BooleanProperty, Integer, NumberProperty, StringProperty, Text, } from "./std/properties/primitives.js";
 export { CreatedAt, DateProperty, DateTime, DeletedAt, UpdatedAt, } from "./std/properties/time.js";
 export { recordOf } from "./std/record.js";
@@ -108,3 +115,5 @@ export { Archivable, Authenticatable, Ownable, Publishable, StdRecordPlugins, Ta
 export type { IdGenerator, PasswordHasher, RuntimeServices, } from "./std/runtime.js";
 export { configure, PasswordHasherRequired, resetRuntime, SyncVerifyUnsupported, } from "./std/runtime.js";
 export { StdStages } from "./std/stages.js";
+export { StdUseCases } from "./std/use-cases/index.js";
+export type { ArchiveMaker, CreateMaker, DeleteMaker, GetMaker, ListMaker, LoginMaker, PublishMaker, RegisterMaker, RestoreMaker, StdCreateOptions, StdEntityOptions, StdLifecycleOptions, StdListOptions, StdOwnerOption, StdUseCaseContext, StdUseCaseErrors, StdUseCaseOptions, StdUseCasePlugins, TagMaker, UpdateMaker, } from "./std/use-cases/types.js";

package/dist/index.js

@@ -48,6 +48,16 @@ import {
   RepositoryOf2,
   isRepository2,
   InvalidUseCaseStep2,
+  InvalidUseCasePlugin2,
+  UnknownUseCasePlugin2,
+  IncompatibleUseCasePlugin2,
+  UseCaseUnavailable2,
+  UseCaseEntityNotFound2,
+  UseCaseEntityConflict2,
+  UseCaseInvalidCredentials2,
+  PropertyInput2,
+  propertyInputOf2,
+  useCaseTargetOf2,
   InvalidUseCaseDeclaration2,
   UseCaseAlreadyExecuted2,
   InvalidUseCaseDependencies2,
@@ -55,12 +65,17 @@ import {
   useCaseOf2,
   isUseCaseClass2,
   isUseCase2,
+  isUseCasePlugin2,
+  useCaseOriginOf2,
+  useCasePluginOf2,
+  isUseCaseCatalog2,
+  useCaseCatalogOf2,
   InvalidCommandDeclaration2,
   UnknownCommandOperation2,
   InvalidCommandContext2,
   InvalidCommandEnvironment2,
   CommandEventFailed2,
-  commandOf2,
+  commandBuilderOf2,
   isCommand2,
   InvalidOpenAPIModel2,
   InvalidOutputStage2,
@@ -110,6 +125,7 @@ import {
   PASSWORD_SPECIAL_CHARACTERS2,
   isPasswordHash2,
   passwordIssues2,
+  PlainPassword2,
   Password2,
   StringProperty2,
   Text2,
@@ -123,6 +139,8 @@ import {
   DeletedAt2,
   Std2,
   blueprintOf2,
+  StdUseCases2,
+  commandOf2,
   Publishable2,
   Archivable2,
   Taggable2,
@@ -132,7 +150,7 @@ import {
   entityOf2,
   recordOf2,
   StdStages2
-} from "./index-gbgc40xe.js";
+} from "./index-q6hggpzw.js";
 import {
   isProperty2,
   schemaOf2,
@@ -167,6 +185,7 @@ import {
   hasPlugin2,
   recordPluginOf2,
   recordBuilderOf2,
+  optionalOf2,
   ReservedBlueprintKey2,
   UndeclaredBlueprintProperty2,
   PropertyRequired2,
@@ -176,9 +195,8 @@ import {
   PropertyStates2,
   AbstractDefineProperty2,
   propertyOf2,
-  optionalOf2,
   blueprintBuilderOf2
-} from "./index-3nd9bjnc.js";
+} from "./index-r78dsvtc.js";
 export {
   AbstractDefineProperty2 as AbstractDefineProperty,
   AbstractEntity2 as AbstractEntity,
@@ -209,6 +227,7 @@ export {
   Id2 as Id,
   ImmutableEntityKey2 as ImmutableEntityKey,
   IncompatibleRecordPlugin2 as IncompatibleRecordPlugin,
+  IncompatibleUseCasePlugin2 as IncompatibleUseCasePlugin,
   Integer2 as Integer,
   InvalidApplicationDeclaration2 as InvalidApplicationDeclaration,
   InvalidApplicationEnvironment2 as InvalidApplicationEnvironment,
@@ -230,6 +249,7 @@ export {
   InvalidRepositoryQuery2 as InvalidRepositoryQuery,
   InvalidUseCaseDeclaration2 as InvalidUseCaseDeclaration,
   InvalidUseCaseDependencies2 as InvalidUseCaseDependencies,
+  InvalidUseCasePlugin2 as InvalidUseCasePlugin,
   InvalidUseCaseStep2 as InvalidUseCaseStep,
   Ip2 as Ip,
   Kind2 as Kind,
@@ -246,6 +266,8 @@ export {
   Password2 as Password,
   PasswordHasherRequired2 as PasswordHasherRequired,
   Phone2 as Phone,
+  PlainPassword2 as PlainPassword,
+  PropertyInput2 as PropertyInput,
   PropertyRequired2 as PropertyRequired,
   PropertyStates2 as PropertyStates,
   ProviderNotBound2 as ProviderNotBound,
@@ -265,6 +287,7 @@ export {
   Std2 as Std,
   StdRecordPlugins2 as StdRecordPlugins,
   StdStages2 as StdStages,
+  StdUseCases2 as StdUseCases,
   StringProperty2 as StringProperty,
   SyncVerifyUnsupported2 as SyncVerifyUnsupported,
   Taggable2 as Taggable,
@@ -274,16 +297,22 @@ export {
   UndeclaredRecordProperty2 as UndeclaredRecordProperty,
   UnknownCommandOperation2 as UnknownCommandOperation,
   UnknownRecordPlugin2 as UnknownRecordPlugin,
+  UnknownUseCasePlugin2 as UnknownUseCasePlugin,
   UnregisteredApplicationReference2 as UnregisteredApplicationReference,
   UnregisteredRepositoryDependency2 as UnregisteredRepositoryDependency,
   UnregisteredUseCaseDependency2 as UnregisteredUseCaseDependency,
   UpdatedAt2 as UpdatedAt,
   Url2 as Url,
   UseCaseAlreadyExecuted2 as UseCaseAlreadyExecuted,
+  UseCaseEntityConflict2 as UseCaseEntityConflict,
+  UseCaseEntityNotFound2 as UseCaseEntityNotFound,
+  UseCaseInvalidCredentials2 as UseCaseInvalidCredentials,
+  UseCaseUnavailable2 as UseCaseUnavailable,
   applicationOf2 as applicationOf,
   blueprintBuilderOf2 as blueprintBuilderOf,
   blueprintOf2 as blueprintOf,
   blueprintPluginOf2 as blueprintPluginOf,
+  commandBuilderOf2 as commandBuilderOf,
   commandOf2 as commandOf,
   configure2 as configure,
   consoleLogProvider2 as consoleLogProvider,
@@ -315,7 +344,9 @@ export {
   isRecordPlugin2 as isRecordPlugin,
   isRepository2 as isRepository,
   isUseCase2 as isUseCase,
+  isUseCaseCatalog2 as isUseCaseCatalog,
   isUseCaseClass2 as isUseCaseClass,
+  isUseCasePlugin2 as isUseCasePlugin,
   jsonLogProvider2 as jsonLogProvider,
   listOf2 as listOf,
   logFrom2 as logFrom,
@@ -330,6 +361,7 @@ export {
   passwordIssues2 as passwordIssues,
   pluginsOf2 as pluginsOf,
   problemOf2 as problemOf,
+  propertyInputOf2 as propertyInputOf,
   propertyLineageOf2 as propertyLineageOf,
   propertyOf2 as propertyOf,
   providerDescriptionOf2 as providerDescriptionOf,
@@ -356,5 +388,9 @@ export {
   toOpenAPI2 as toOpenAPI,
   transformOf2 as transformOf,
   useApplication2 as useApplication,
-  useCaseOf2 as useCaseOf
+  useCaseCatalogOf2 as useCaseCatalogOf,
+  useCaseOf2 as useCaseOf,
+  useCaseOriginOf2 as useCaseOriginOf,
+  useCasePluginOf2 as useCasePluginOf,
+  useCaseTargetOf2 as useCaseTargetOf
 };

package/dist/std/command.d.ts

@@ -0,0 +1,11 @@
+import type { CommandBuilder } from "../core/command/types/command.interface.js";
+import type { StdUseCaseContext } from "./use-cases/types.js";
+/**
+ * Groups use cases under operation names and is the boundary of a call: the
+ * context is validated once, a transaction can wrap the use case, and the
+ * events it raised are handled by a policy once it succeeded. `useCases` is
+ * an object of use case classes, or a function of the standard use cases
+ * (`StdUseCases`) that gives one:
+ * `(ctx) => ({ create: ctx.create(Posts), custom: MyUseCase })`.
+ */
+export declare const commandOf: CommandBuilder<StdUseCaseContext>;

package/dist/std/properties/password.d.ts

@@ -1,10 +1,23 @@
 import { Type } from "typebox";
+import { type IPropertyInput, PropertyInput } from "../../core/property/input.js";
 export declare const PASSWORD_MIN_LENGTH = 7;
 export declare const PASSWORD_MAX_LENGTH = 128;
 export declare const PASSWORD_SPECIAL_CHARACTERS = "!@#$%^&*()-_=+[]{}|\\;:'\",.<>/?`~";
 export declare function isPasswordHash(value: string): boolean;
 /** The rules a plain password breaks; empty when it is strong enough. */
 export declare function passwordIssues(value: string): string[];
+declare const PlainPassword_base: import("../../index.js").PropertyClass<Type.TString, string> & {
+    readonly type: {
+        readonly sensitive: true;
+    };
+};
+/**
+ * A password as a person types it, checked against the password rules
+ * (`passwordIssues`); sensitive. It is what an input takes for a `Password`,
+ * which stores the hash.
+ */
+export declare class PlainPassword extends PlainPassword_base {
+}
 declare const Password_base: import("../../index.js").PropertyClass<Type.TString, string> & {
     readonly type: {
         readonly sensitive: true;
@@ -13,9 +26,11 @@ declare const Password_base: import("../../index.js").PropertyClass<Type.TString
 /**
  * A password stored as an Argon2 hash. The constructor only accepts a hash,
  * e.g. one read from the database; `Password.hash` turns a plain password
- * into one.
+ * into one. Under `PropertyInput` it says so to what derives inputs: they
+ * take a `PlainPassword` and hash it.
  */
 export declare class Password extends Password_base {
+    static readonly [PropertyInput]: IPropertyInput<string>;
     /** Validates `plain` against the password rules and hashes it with the configured hasher (argon2id by default). */
     static hash(plain: string): Promise<Password>;
     /** Whether `input` is the password this hash was made from. */

package/dist/std/use-cases/auth.d.ts

@@ -0,0 +1,5 @@
+import type { LoginMaker, RegisterMaker } from "./types.js";
+/** Stores an authenticatable entity, unless its email is taken. */
+export declare const register: import("../../index.js").IUseCasePlugin<"register", RegisterMaker>;
+/** Gives the authenticatable entity of an email, when the password matches. */
+export declare const login: import("../../index.js").IUseCasePlugin<"login", LoginMaker>;

package/dist/std/use-cases/crud.d.ts

@@ -0,0 +1,23 @@
+import type { UseCaseCompilation, UseCaseTargetInfo } from "../../core/use-case/types/plugin.interface.js";
+import type { AnyExceptionClass } from "../../core/use-case/use-case.js";
+import { type Options, type Step } from "./shared.js";
+import type { CreateMaker, DeleteMaker, GetMaker, ListMaker, RestoreMaker, UpdateMaker } from "./types.js";
+/**
+ * The declaration of `create` and of `register`, which adds `before` and
+ * its errors: an input of the keys of the entity, the entity built from it
+ * and stored.
+ */
+export declare function createCompilation(target: UseCaseTargetInfo, options: Options, verb: string, before?: readonly Step[], errors?: readonly AnyExceptionClass[]): UseCaseCompilation;
+/** Builds an entity from the input and stores it. */
+export declare const create: import("../../index.js").IUseCasePlugin<"create", CreateMaker>;
+/** Gives the entity of an id. */
+export declare const get: import("../../index.js").IUseCasePlugin<"get", GetMaker>;
+/** Gives a page of entities. */
+export declare const list: import("../../index.js").IUseCasePlugin<"list", ListMaker>;
+/** Changes the keys the input gives, of those the entity lets change. */
+export declare const update: import("../../index.js").IUseCasePlugin<"update", UpdateMaker>;
+/** Deletes the entity of an id, as the repository deletes: for good, or softly. */
+declare const remove: import("../../index.js").IUseCasePlugin<"delete", DeleteMaker>;
+export { remove as delete_ };
+/** Brings back a soft-deleted entity. */
+export declare const restore: import("../../index.js").IUseCasePlugin<"restore", RestoreMaker>;

package/dist/std/use-cases/index.d.ts

@@ -0,0 +1,11 @@
+import type { IUseCaseCatalog } from "../../core/use-case/types/plugin.interface.js";
+import type { StdUseCasePlugins } from "./types.js";
+/**
+ * The standard use cases, by name, for the `useCases` of `commandOf` to
+ * pick from, as `(ctx) => ({ create: ctx.create(Posts) })`: `create`, `get`,
+ * `list`, `update`, `delete` and `restore` for any entity; `publish`,
+ * `unpublish`, `archive`, `unarchive`, `tag` and `untag` for the entities
+ * with those record plugins; `register` and `login` for the
+ * authenticatable ones. `StdUseCases.context` is that `ctx`.
+ */
+export declare const StdUseCases: IUseCaseCatalog<StdUseCasePlugins>;

package/dist/std/use-cases/lifecycle.d.ts

@@ -0,0 +1,13 @@
+import type { ArchiveMaker, PublishMaker, TagMaker } from "./types.js";
+/** Publishes the entity of an id. */
+export declare const publish: import("../../index.js").IUseCasePlugin<"publish", PublishMaker>;
+/** Makes the entity of an id a draft again. */
+export declare const unpublish: import("../../index.js").IUseCasePlugin<"unpublish", PublishMaker>;
+/** Archives the entity of an id. */
+export declare const archive: import("../../index.js").IUseCasePlugin<"archive", ArchiveMaker>;
+/** Makes the archived entity of an id active again. */
+export declare const unarchive: import("../../index.js").IUseCasePlugin<"unarchive", ArchiveMaker>;
+/** Adds tags to the entity of an id. */
+export declare const tag: import("../../index.js").IUseCasePlugin<"tag", TagMaker>;
+/** Removes tags from the entity of an id. */
+export declare const untag: import("../../index.js").IUseCasePlugin<"untag", TagMaker>;

package/dist/std/use-cases/shared.d.ts

@@ -0,0 +1,60 @@
+import type { BlueprintField } from "../../core/blueprint/types/blueprint.interface.js";
+import type { UseCaseCompilation, UseCaseFieldPlan, UseCaseTargetInfo } from "../../core/use-case/types/plugin.interface.js";
+import type { AnyExceptionClass } from "../../core/use-case/use-case.js";
+/** A blueprint of the fields given, with no context of properties. */
+export declare const fields: import("../../index.js").BlueprintBuilder<readonly []>;
+export type Options = Readonly<Record<string, unknown>>;
+export type Step = Readonly<Record<string, unknown>>;
+export declare const capitalize: (key: string) => string;
+/** A value given in options as a step takes it: a string that starts with `$` is not a reference. */
+export declare function literal(value: unknown): unknown;
+/** The option `key`, checked to be one of the `allowed` options of the use case. */
+export declare function checkOptions(target: UseCaseTargetInfo, options: Options, allowed: readonly string[]): void;
+/** The name, description, tags and `deprecated` of the use case. */
+export declare function metaOf(target: UseCaseTargetInfo, options: Options, verb: string): Pick<UseCaseCompilation, "name" | "description" | "tags" | "deprecated">;
+/** The key of the response that holds the entity: the option `as`, `item` by default. */
+export declare function asOf(target: UseCaseTargetInfo, options: Options): string;
+/** The error of `kind` the options give, else `fallback`. */
+export declare function errorOf(target: UseCaseTargetInfo, options: Options, kind: "notFound" | "conflict" | "invalid" | "owner", fallback: AnyExceptionClass): AnyExceptionClass;
+/** The list of names an option gives, each a key of the entity. */
+export declare function keysOf(target: UseCaseTargetInfo, options: Options, option: string): readonly UseCaseFieldPlan[];
+/** The object an option gives, by key of the entity. */
+export declare function valuesOf(target: UseCaseTargetInfo, options: Options, option: string): Readonly<Record<string, unknown>>;
+/** Who owns the entity, as the option `owner` says. */
+export interface Owner {
+    readonly plan: UseCaseFieldPlan;
+    /** The key of the context that holds the id of the caller. */
+    readonly context: string;
+    /** The field of that context key: an id. */
+    readonly field: BlueprintField;
+    /** The reference to the id of the owner of the entity bound as `item`. */
+    readonly reference: string;
+}
+/**
+ * The option `owner: { key?, context }`: `key` (`ownerId` by default) holds
+ * the owner, an id or an entity, and `context` names the context key with
+ * the id of the caller.
+ */
+export declare function ownerOf(target: UseCaseTargetInfo, options: Options): Owner | undefined;
+/** The context blueprint an owner needs, if there is one. */
+export declare function contextOf(owner: Owner | undefined): Pick<UseCaseCompilation, "context">;
+/**
+ * The steps that load the entity of `$input.id` as `item`, throw `notFound`
+ * when there is none, and when it is not the caller's.
+ */
+export declare function loadSteps(owner: Owner | undefined, notFound: AnyExceptionClass): Step[];
+/** The id field of the entity of `target`. */
+export declare const idOf: (target: UseCaseTargetInfo) => BlueprintField;
+/** The classes of `errors`, each once. */
+export declare const distinct: (...errors: readonly AnyExceptionClass[]) => AnyExceptionClass[];
+/**
+ * A use case over one entity found by id: `{ id }` in, `{ [as]: entity }`
+ * out; loads it, checks the owner, runs `steps` (which leave the entity to
+ * give under `result`) and gives it.
+ */
+export declare function entityUseCase(target: UseCaseTargetInfo, options: Options, verb: string, allowed: readonly string[], steps: (context: {
+    readonly owner: Owner | undefined;
+}) => {
+    readonly steps: readonly Step[];
+    readonly result: string;
+}): UseCaseCompilation;