@afora/core 0.0.2 → 0.0.3

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,21 @@
+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>>>;
+}
+/**
+ * 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;

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

@@ -1,8 +1,10 @@
 import type { AnyBlueprint, BlueprintInput, BlueprintValue, IBlueprint, IBlueprintCollection } from "../blueprint/types/blueprint.interface.js";
 import type { EntityEvent } from "../entity/event.js";
 import { type AnyEnvironment, type EnvironmentValue } from "../environment/environment.js";
+import { type DeclaredExceptionClass } from "../exception/exception.js";
 import type { AnyRepository } from "../repository/types/repository.interface.js";
 import { Kind } from "../symbols/kind.js";
+import type { UseCaseStep } from "./steps/types/steps.interface.js";
 /** A concrete UseCase declaration, usable as a dependency. */
 export interface AnyUseCaseClass {
     readonly [Kind]: "use-case";
@@ -10,11 +12,18 @@ export interface AnyUseCaseClass {
     readonly blueprint: AnyBlueprint;
     readonly response: AnyBlueprint;
     readonly dependencies: UseCaseCollection;
-    new (input: any): {
+    readonly context: AnyBlueprint | undefined;
+    readonly description: string | undefined;
+    readonly tags: readonly string[];
+    readonly deprecated: boolean;
+    readonly errors: readonly AnyExceptionClass[];
+    new (input: any, ...options: any[]): {
         execute(): Promise<unknown>;
         pullEvents(): EntityEvent[];
     };
 }
+/** Any class made by `exceptionOf`. */
+export type AnyExceptionClass = DeclaredExceptionClass<any>;
 /**
  * What a use case can depend on: another use case, a repository made by
  * `repositoryOf`, or an environment made by `environmentOf`.
@@ -29,6 +38,21 @@ type Declaration = {
 export type UseCaseInput<Class extends Declaration> = BlueprintInput<Class["blueprint"]["properties"]>;
 export type UseCaseResponse<Class extends Declaration> = BlueprintValue<Class["response"]["properties"]>;
 export type UseCaseDependencies<Class extends Declaration> = DependencyFunctions<Class["dependencies"]>;
+/** The context of a use case class, as `this.context` gives it; `undefined` without one. */
+export type UseCaseContext<Class extends {
+    readonly context: unknown;
+}> = Class["context"] extends IBlueprint<infer Properties> ? Readonly<BlueprintValue<Properties>> : undefined;
+/**
+ * The second argument of the constructor of a use case: `{ context }`,
+ * required when the use case declares a context, not accepted otherwise.
+ */
+export type UseCaseOptions<Context extends IBlueprintCollection | undefined = undefined> = Context extends IBlueprintCollection ? {
+    readonly context: BlueprintInput<Context>;
+} : {
+    readonly context?: undefined;
+};
+/** @internal */
+type OptionsArgs<Context extends IBlueprintCollection | undefined> = Context extends IBlueprintCollection ? [options: UseCaseOptions<Context>] : [];
 /**
  * What a use case gets for a dependency: a function for a use case, the
  * repository itself, or the variables of an environment.
@@ -44,36 +68,77 @@ export type DependencyFunctions<Dependencies extends UseCaseCollection> = {
 export type DependencyOverrides<Dependencies extends UseCaseCollection> = {
     readonly [Key in keyof Dependencies]?: Dependencies[Key] extends AnyRepository ? Partial<Dependencies[Key]> : DependencyOf<Dependencies[Key]>;
 };
-export interface UseCaseSettings<Input extends IBlueprintCollection, Output extends IBlueprintCollection, Dependencies extends UseCaseCollection> {
+export interface UseCaseSettings<Input extends IBlueprintCollection, Output extends IBlueprintCollection, Dependencies extends UseCaseCollection, Context extends IBlueprintCollection | undefined = undefined> {
     readonly name: string;
     readonly blueprint: IBlueprint<Input>;
     readonly response: IBlueprint<Output>;
     readonly dependencies?: Dependencies;
+    /** What the caller supplies with each call, e.g. the user and the request; validated by this blueprint. */
+    readonly context?: IBlueprint<Exclude<Context, undefined>>;
+    readonly description?: string;
+    readonly tags?: readonly string[];
+    readonly deprecated?: boolean;
+    /** The exceptions (made by `exceptionOf`) a caller should expect; documentation only. */
+    readonly errors?: readonly AnyExceptionClass[];
 }
-export declare const InvalidUseCaseDeclaration: import("../../index.js").DeclaredExceptionClass<{
+/** `UseCaseSettings` with the `steps` that are its `execute`. */
+export interface UseCaseStepsSettings<Input extends IBlueprintCollection, Output extends IBlueprintCollection, Dependencies extends UseCaseCollection, Context extends IBlueprintCollection | undefined = undefined> extends UseCaseSettings<Input, Output, Dependencies, Context> {
+    /**
+     * What the use case does, as data (see `UseCaseStep`): validated here,
+     * interpreted by its `execute`, and described by `describe()`.
+     */
+    readonly steps: readonly UseCaseStep<NoInfer<Dependencies>>[];
+}
+export declare const InvalidUseCaseDeclaration: DeclaredExceptionClass<{
     reason: string;
 }>;
-export declare const UseCaseAlreadyExecuted: import("../../index.js").DeclaredExceptionClass<undefined>;
-export declare const InvalidUseCaseDependencies: import("../../index.js").DeclaredExceptionClass<undefined>;
+export declare const UseCaseAlreadyExecuted: DeclaredExceptionClass<undefined>;
+export declare const InvalidUseCaseDependencies: DeclaredExceptionClass<undefined>;
 /** An operation with validated input, dependency functions and a drainable event queue. */
 export declare abstract class AbstractUseCase<Input extends IBlueprintCollection, Output extends IBlueprintCollection, Dependencies extends UseCaseCollection> {
     readonly input: Readonly<BlueprintValue<Input>>;
-    constructor(input: BlueprintInput<Input>);
+    constructor(input: BlueprintInput<Input>, ...args: unknown[]);
     /** Default parameter for implementations: `execute(deps = this.dependencies)`. */
     get dependencies(): DependencyFunctions<Dependencies>;
     abstract execute(dependencies?: DependencyOverrides<Dependencies>): Promise<BlueprintValue<Output>>;
     /** Immediately drains collected events; never executes their handlers. */
     pullEvents(): EntityEvent[];
 }
-export type UseCaseConstructor<Input extends IBlueprintCollection, Output extends IBlueprintCollection, Dependencies extends UseCaseCollection> = (abstract new (input: BlueprintInput<Input>) => AbstractUseCase<Input, Output, Dependencies>) & {
+/** What every use case class carries, abstract or not. */
+type UseCaseStatics<Input extends IBlueprintCollection, Output extends IBlueprintCollection, Dependencies extends UseCaseCollection, Context extends IBlueprintCollection | undefined> = {
     readonly [Kind]: "use-case";
     readonly useCaseName: string;
     readonly blueprint: IBlueprint<Input>;
     readonly response: IBlueprint<Output>;
     readonly dependencies: Dependencies;
+    /** The blueprint of the context of each call, or `undefined`. */
+    readonly context: Context extends IBlueprintCollection ? IBlueprint<Context> : undefined;
+    readonly description: string | undefined;
+    readonly tags: readonly string[];
+    readonly deprecated: boolean;
+    /** The exceptions a caller should expect. */
+    readonly errors: readonly AnyExceptionClass[];
+};
+/** What a use case instance carries beyond `AbstractUseCase`. */
+type UseCaseInstanceContext<Context extends IBlueprintCollection | undefined> = {
+    /** What the caller supplied with the call, parsed and frozen; `undefined` without a declared context. */
+    readonly context: Context extends IBlueprintCollection ? Readonly<BlueprintValue<Context>> : undefined;
 };
-/** Declares an abstract operation. Extend it and implement an async execute method. */
-export declare function useCaseOf<Input extends IBlueprintCollection, Output extends IBlueprintCollection, const Dependencies extends UseCaseCollection = Record<never, never>>(settings: UseCaseSettings<Input, Output, Dependencies>): UseCaseConstructor<Input, Output, Dependencies>;
+export type UseCaseConstructor<Input extends IBlueprintCollection, Output extends IBlueprintCollection, Dependencies extends UseCaseCollection, Context extends IBlueprintCollection | undefined = undefined> = (abstract new (input: BlueprintInput<Input>, ...options: OptionsArgs<Context>) => AbstractUseCase<Input, Output, Dependencies> & UseCaseInstanceContext<Context>) & UseCaseStatics<Input, Output, Dependencies, Context>;
+/**
+ * What `useCaseOf` gives with `steps`: concrete, its `execute` interprets the
+ * steps. A subclass may still override `execute`.
+ */
+export type StepsUseCaseConstructor<Input extends IBlueprintCollection, Output extends IBlueprintCollection, Dependencies extends UseCaseCollection, Context extends IBlueprintCollection | undefined = undefined> = (new (input: BlueprintInput<Input>, ...options: OptionsArgs<Context>) => Omit<AbstractUseCase<Input, Output, Dependencies>, "execute"> & UseCaseInstanceContext<Context> & {
+    execute(dependencies?: DependencyOverrides<Dependencies>): Promise<BlueprintValue<Output>>;
+}) & UseCaseStatics<Input, Output, Dependencies, Context>;
+/**
+ * Declares an operation. With `steps` the class is concrete: its `execute`
+ * interprets them. Without, it is abstract: extend it and implement an async
+ * execute method.
+ */
+export declare function useCaseOf<Input extends IBlueprintCollection, Output extends IBlueprintCollection, const Dependencies extends UseCaseCollection = Record<never, never>, Context extends IBlueprintCollection | undefined = undefined>(settings: UseCaseStepsSettings<Input, Output, Dependencies, Context>): StepsUseCaseConstructor<Input, Output, Dependencies, Context>;
+export declare function useCaseOf<Input extends IBlueprintCollection, Output extends IBlueprintCollection, const Dependencies extends UseCaseCollection = Record<never, never>, Context extends IBlueprintCollection | undefined = undefined>(settings: UseCaseSettings<Input, Output, Dependencies, Context>): UseCaseConstructor<Input, Output, Dependencies, Context>;
 export declare function isUseCaseClass(value: unknown): value is AnyUseCaseClass;
 export declare function isUseCase(value: unknown): value is AbstractUseCase<IBlueprintCollection, IBlueprintCollection, UseCaseCollection>;
 export {};

package/dist/experimental.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `@afora/core/experimental`: features that may change in any release. Not
+ * covered by the compatibility policy in `VERSIONING.md`.
+ */
+export { sliceOf, sliceValue } from "./core/blueprint/slice.js";
+export type { SlicedBlueprint, SlicedValue, SliceMask, ValueMask, } from "./core/blueprint/types/slice.interface.js";

package/dist/experimental.js

@@ -0,0 +1,123 @@
+import {
+  isBlueprint2,
+  isRecordClass2,
+  recordFieldOf2,
+  listOf2,
+  isBlueprintList2,
+  AbstractRecord2,
+  declareRecord,
+  UndeclaredBlueprintProperty2,
+  optionalOf2,
+  blueprintFromProperties
+} from "./index-hn82hm31.js";
+
+// src/core/blueprint/slice.ts
+function propertiesOfField(field) {
+  if (field === undefined)
+    return;
+  if (isBlueprintList2(field))
+    return propertiesOfField(field.item);
+  const record = recordFieldOf2(field);
+  if (record)
+    return record.record.blueprint.properties;
+  return isBlueprint2(field) ? field.properties : undefined;
+}
+function maskOf(selector, against) {
+  if (isRecordClass2(selector))
+    return maskOf(selector.blueprint, against);
+  if (isBlueprint2(selector)) {
+    return Object.fromEntries(Object.entries(selector.properties).map(([key, field]) => [key, fieldMaskOf(field, against?.[key])]));
+  }
+  return selector;
+}
+function fieldMaskOf(field, other) {
+  if (isBlueprintList2(field)) {
+    return fieldMaskOf(field.item, isBlueprintList2(other) ? other.item : other);
+  }
+  const record = recordFieldOf2(field);
+  if (record) {
+    if (record.record === recordFieldOf2(other)?.record)
+      return true;
+    return maskOf(record.record, propertiesOfField(other));
+  }
+  if (isBlueprint2(field)) {
+    return field === other ? true : maskOf(field, propertiesOfField(other));
+  }
+  return true;
+}
+function sliceCollection(properties, mask, path) {
+  const sliced = {};
+  for (const [key, selected] of Object.entries(mask)) {
+    if (!selected)
+      continue;
+    if (!Object.hasOwn(properties, key)) {
+      throw new UndeclaredBlueprintProperty2({
+        source: "blueprint",
+        details: { key: path + key }
+      });
+    }
+    sliced[key] = sliceField(properties[key], selected, path + key);
+  }
+  return sliced;
+}
+function slicedRecordOf(Original, mask, path) {
+  const source = Original.blueprint;
+  const blueprint = blueprintFromProperties(source.plugins, sliceCollection(source.properties, mask, `${path}.`));
+  const kept = (keys) => keys.filter((key) => Object.hasOwn(blueprint.properties, key));
+  const { sensitive, unique, change } = Original.options;
+  const Sliced = declareRecord(AbstractRecord2, blueprint, {
+    sensitive: kept(sensitive),
+    unique: kept(unique),
+    change: kept(change)
+  }, Original.name);
+  Object.defineProperty(Sliced, Symbol.hasInstance, {
+    value(value) {
+      return Function.prototype[Symbol.hasInstance].call(this, value) || value instanceof Original;
+    }
+  });
+  return Sliced;
+}
+function sliceField(field, selected, path) {
+  if (selected === true)
+    return field;
+  if (isBlueprintList2(field)) {
+    const list = listOf2(sliceField(field.item, selected, path), {
+      minItems: field.minItems,
+      maxItems: field.maxItems
+    });
+    return field.optional ? optionalOf2(list) : list;
+  }
+  const record = recordFieldOf2(field);
+  if (record) {
+    const sliced = slicedRecordOf(record.record, selected, path);
+    return record.optional ? optionalOf2(sliced) : sliced;
+  }
+  if (isBlueprint2(field)) {
+    const sliced = blueprintFromProperties(field.plugins, sliceCollection(field.properties, selected, `${path}.`));
+    return field.optional ? optionalOf2(sliced) : sliced;
+  }
+  throw new UndeclaredBlueprintProperty2({
+    source: "blueprint",
+    details: { key: `${path}.${Object.keys(selected)[0] ?? ""}` }
+  });
+}
+var sliceOf = (blueprint, selector) => blueprintFromProperties(blueprint.plugins, sliceCollection(blueprint.properties, maskOf(selector, blueprint.properties), ""));
+var sliceValue = (value, selector) => pick(value, maskOf(selector));
+function pick(value, mask) {
+  if (Array.isArray(value))
+    return value.map((item) => pick(item, mask));
+  if (typeof value !== "object" || value === null)
+    return value;
+  const source = isRecordClass2(value.constructor) ? value.toJSON() : value;
+  const picked = {};
+  for (const [key, selected] of Object.entries(mask)) {
+    if (!selected || !Object.hasOwn(source, key))
+      continue;
+    picked[key] = selected === true ? source[key] : pick(source[key], selected);
+  }
+  return picked;
+}
+export {
+  sliceOf,
+  sliceValue
+};