@aidc-toolkit/app-extension 1.0.28-beta → 1.0.32-beta

package/src/proxy.ts

@@ -1,8 +1,7 @@
 import {
     type AbstractConstructor,
     type Constructor,
-    getLogger,
-    LogLevels,
+    loggableValue,
     omit,
     type TypedAbstractConstructor
 } from "@aidc-toolkit/core";
@@ -12,7 +11,8 @@ import type {
     ClassDescriptor,
     ExtendsParameterDescriptor,
     MethodDescriptor,
-    ParameterDescriptor
+    ParameterDescriptor,
+    ReplacementParameterDescriptor
 } from "./descriptor.js";
 import { LibProxy } from "./lib-proxy.js";
 import type { ErrorExtends } from "./type.js";
@@ -20,7 +20,7 @@ import type { ErrorExtends } from "./type.js";
 /**
  * Remaining parameters past first parameter in constructor.
  */
-type RemainingParameters<TConstructor extends TypedAbstractConstructor<TConstructor>> =
+type RemainingConstructorParameters<TConstructor extends TypedAbstractConstructor<TConstructor>> =
     TConstructor extends abstract new (arg0: infer _P0, ...args: infer P) => InstanceType<TConstructor> ? P : never;
 
 /**
@@ -37,13 +37,13 @@ type RemainingParameters<TConstructor extends TypedAbstractConstructor<TConstruc
  * Proxy class constructor type.
  */
 type ProxyClassConstructor<
-    ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt,
-    T extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt>,
+    ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt,
+    T extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>,
     IsAbstract extends boolean,
     TConstructor extends TypedAbstractConstructor<TConstructor>
 > = IsAbstract extends true ?
-    AbstractConstructor<[appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>, ...args: RemainingParameters<TConstructor>], T> :
-    Constructor<[appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>], T>;
+    AbstractConstructor<[appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>, ...args: RemainingConstructorParameters<TConstructor>], T> :
+    Constructor<[appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>], T>;
 
 /**
  * Class decorator type. Defines the parameters passed to a class decorator function and the return type as identical to
@@ -62,11 +62,11 @@ type ProxyClassConstructor<
  * Narrowed proxy class constructor type.
  */
 type ClassDecorator<
-    ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt,
-    T extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt>,
+    ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt,
+    T extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>,
     IsAbstract extends boolean,
     TConstructor extends TypedAbstractConstructor<TConstructor>,
-    TProxyClassConstructor extends ProxyClassConstructor<ThrowError, TError, TInvocationContext, TBigInt, T, IsAbstract, TConstructor>
+    TProxyClassConstructor extends ProxyClassConstructor<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt, T, IsAbstract, TConstructor>
 > = (Target: TProxyClassConstructor, context: ClassDecoratorContext<TProxyClassConstructor>) => TProxyClassConstructor;
 
 /**
@@ -87,9 +87,9 @@ type InterimMethodDescriptor = Omit<MethodDescriptor, "functionName" | "namespac
 /**
  * Subset of method descriptor used in call to decorator.
  */
-type DecoratorMethodDescriptor = Omit<InterimMethodDescriptor, "name" | "parameterDescriptors"> & {
+interface DecoratorMethodDescriptor extends Omit<InterimMethodDescriptor, "name" | "parameterDescriptors"> {
     parameterDescriptors: Array<ParameterDescriptor | ExtendsParameterDescriptor>;
-};
+}
 
 /**
  * Subset of class descriptor used during decoration process.
@@ -100,8 +100,8 @@ type InterimClassDescriptor =
 /**
  * Subset of class descriptor used in call to decorator.
  */
-interface DecoratorClassDescriptor extends Omit<InterimClassDescriptor, "replaceParameterDescriptors"> {
-    readonly replaceParameterDescriptors?: ReadonlyArray<Omit<Required<ClassDescriptor>["replaceParameterDescriptors"][number], "replacement"> & {
+interface DecoratorClassDescriptor extends Omit<InterimClassDescriptor, "replacementParameterDescriptors"> {
+    readonly replacementParameterDescriptors?: ReadonlyArray<Omit<ReplacementParameterDescriptor, "replacement"> & {
         readonly replacement: ParameterDescriptor | ExtendsParameterDescriptor;
     }>;
 }
@@ -144,7 +144,12 @@ interface Interim {
  */
 interface TargetLogger {
     /**
-     * Log a method call.
+     * Logger.
+     */
+    readonly logger: Logger<object>;
+
+    /**
+     * Build a function that returns a loggable value for a method call.
      *
      * @param methodName
      * Method name.
@@ -155,18 +160,13 @@ interface TargetLogger {
      * @param result
      * Output result.
      */
-    log: (methodName: string, args: unknown[], result: unknown) => void;
+    callBuilder: (methodName: string, args: unknown[], result: unknown) => () => unknown;
 }
 
 /**
  * Proxy class.
  */
 export class Proxy {
-    /**
-     * Logger.
-     */
-    readonly #logger: Logger<unknown> = getLogger(LogLevels.Info);
-
     /**
      * Abstract class descriptors map, keyed on declaration class name. Abstract classes are not used directly by target
      * applications.
@@ -183,49 +183,6 @@ export class Proxy {
      */
     #interim: Interim | undefined = undefined;
 
-    /**
-     * Get the proper JSON representation of a value.
-     *
-     * @param value
-     * Value.
-     *
-     * @returns
-     * Replacement value.
-     */
-    static #jsonValue(value: unknown): unknown {
-        let replacementValue: unknown;
-
-        switch (typeof value) {
-            case "string":
-            case "number":
-            case "boolean":
-            case "undefined":
-                replacementValue = value;
-                break;
-
-            case "bigint":
-                // Big integers not supported in JSON.
-                replacementValue = value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER ? Number(value) : value.toString(10);
-                break;
-
-            case "object":
-                if (value === null) {
-                    replacementValue = value;
-                } else if (Array.isArray(value)) {
-                    replacementValue = value.map(entry => Proxy.#jsonValue(entry));
-                } else {
-                    replacementValue = Object.fromEntries(Object.entries(value).map(([k, v]) => [k, Proxy.#jsonValue(v)]));
-                }
-                break;
-
-            case "symbol":
-            case "function":
-                throw new Error(`Unsupported ${typeof value} value type`);
-        }
-
-        return replacementValue;
-    }
-
     /**
      * Describe a proxy class.
      *
@@ -251,17 +208,17 @@ export class Proxy {
      * Function with which to decorate the class.
      */
     describeClass<
-        ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt,
-        T extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt>,
+        ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt,
+        T extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>,
         IsAbstract extends boolean,
         TConstructor extends TypedAbstractConstructor<TConstructor>,
-        TProxyClassConstructor extends ProxyClassConstructor<ThrowError, TError, TInvocationContext, TBigInt, T, IsAbstract, TConstructor>
-    >(isAbstract: IsAbstract, decoratorClassDescriptor: DecoratorClassDescriptor = {}): ClassDecorator<ThrowError, TError, TInvocationContext, TBigInt, T, IsAbstract, TConstructor, TProxyClassConstructor> {
-        const interimClassDescriptor: InterimClassDescriptor = decoratorClassDescriptor.replaceParameterDescriptors === undefined ?
-            omit(decoratorClassDescriptor, "replaceParameterDescriptors") :
+        TProxyClassConstructor extends ProxyClassConstructor<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt, T, IsAbstract, TConstructor>
+    >(isAbstract: IsAbstract, decoratorClassDescriptor: DecoratorClassDescriptor = {}): ClassDecorator<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt, T, IsAbstract, TConstructor, TProxyClassConstructor> {
+        const interimClassDescriptor: InterimClassDescriptor = decoratorClassDescriptor.replacementParameterDescriptors === undefined ?
+            omit(decoratorClassDescriptor, "replacementParameterDescriptors") :
             {
                 ...decoratorClassDescriptor,
-                replaceParameterDescriptors: decoratorClassDescriptor.replaceParameterDescriptors.map(replaceParameterDescriptor => ({
+                replacementParameterDescriptors: decoratorClassDescriptor.replacementParameterDescriptors.map(replaceParameterDescriptor => ({
                     ...replaceParameterDescriptor,
                     replacement: expandParameterDescriptor(replaceParameterDescriptor.replacement)
                 }))
@@ -312,7 +269,7 @@ export class Proxy {
 
             if (baseClassDescriptor !== undefined) {
                 const baseClassMethodDescriptors = baseClassDescriptor.methodDescriptors;
-                const replaceParameterDescriptors = decoratorClassDescriptor.replaceParameterDescriptors;
+                const replaceParameterDescriptors = decoratorClassDescriptor.replacementParameterDescriptors;
 
                 if (replaceParameterDescriptors !== undefined) {
                     const replacementParameterDescriptorsMap = new Map(replaceParameterDescriptors.map(replaceParameterDescriptor => [replaceParameterDescriptor.name, expandParameterDescriptor(replaceParameterDescriptor.replacement)]));
@@ -389,7 +346,7 @@ export class Proxy {
             // Third capture group, separated by optional period, is:
             // - single uppercase letter followed by zero or more characters (remainder of string); or
             // - zero characters (empty string).
-            const objectNameGroups = /^(?<namespaceFirstWord>[A-Z]+[0-9]*|[A-Z][^A-Z.]*)(?<namespaceRemaining>[A-Z][^.]*|)\.?(?<className>[A-Z].*|)$/.exec(namespaceClassName)?.groups;
+            const objectNameGroups = /^(?<namespaceFirstWord>[A-Z]+[0-9]*|[A-Z][^A-Z.]*)(?<namespaceRemaining>[A-Z][^.]*|)\.?(?<className>[A-Z].*|)$/u.exec(namespaceClassName)?.groups;
 
             if (objectNameGroups === undefined) {
                 throw new Error(`${namespaceClassName} is not a valid namespace-qualified class name`);
@@ -413,30 +370,35 @@ export class Proxy {
 
             this.#interim = undefined;
 
-            const logger = this.#logger;
-
             return class extends Target implements TargetLogger {
+                /**
+                 * Get the logger.
+                 */
+                get logger(): Logger<object> {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type hierarchy is known.
+                    return (this as unknown as T).appExtension.logger;
+                }
+
                 /**
                  * @inheritDoc
                  */
-                log(methodName: string, args: unknown[], result: unknown): void {
-                    // // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Type hierarchy is known.
-                    // const appExtension = (this as unknown as T).appExtension;
-
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Method name is known to be valid at this point.
-                    const methodDescriptor = methodDescriptorsMap.get(methodName)!;
-
-                    logger.info(JSON.stringify({
-                        namespace: decoratorClassDescriptor.namespace,
-                        className: name,
-                        methodName,
-                        functionName: methodDescriptor.functionName,
-                        parameters: methodDescriptor.parameterDescriptors.map((parameterDescriptor, index) => ({
-                            name: parameterDescriptor.name,
-                            value: args[index]
-                        })),
-                        result: Proxy.#jsonValue(result)
-                    }, null, 2));
+                callBuilder(methodName: string, args: unknown[], result: unknown): () => unknown {
+                    return () => {
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Method name is known to be valid at this point.
+                        const methodDescriptor = methodDescriptorsMap.get(methodName)!;
+
+                        return {
+                            namespace: decoratorClassDescriptor.namespace,
+                            className: name,
+                            methodName,
+                            functionName: methodDescriptor.functionName,
+                            parameters: methodDescriptor.parameterDescriptors.map((parameterDescriptor, index) => ({
+                                name: parameterDescriptor.name,
+                                value: loggableValue(args[index])
+                            })),
+                            result: loggableValue(result)
+                        };
+                    };
                 }
             };
         };
@@ -458,9 +420,14 @@ export class Proxy {
         return (target: (this: TThis, ...args: TArguments) => TReturn, context: ClassMethodDecoratorContext<TThis>): (this: TThis, ...args: TArguments) => TReturn => {
             const name = context.name;
 
-            // Validate that method descriptor is applied within an appropriate class and has a valid name.
-            if (this.#interim === undefined || typeof name !== "string" || context.static || context.private) {
-                throw new Error(`${String(name)} is not defined within a supported class, has an invalid name, is static, or is private`);
+            // Validate that method descriptor is applied within an appropriate class.
+            if (this.#interim === undefined) {
+                throw new Error(`Class for method ${String(name)} does not have a descriptor`);
+            }
+
+            // Validate that method descriptor has a valid name and is neither static nor private.
+            if (typeof name !== "string" || context.static || context.private) {
+                throw new Error(`Method ${String(name)} has an invalid name, is static, or is private`);
             }
 
             let anyOptional = false;
@@ -485,10 +452,36 @@ export class Proxy {
             });
 
             return function methodProxy(this: TThis, ...args: TArguments): TReturn {
-                const result = target.call(this, ...args);
-
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Class has been modified to add log method.
-                (this as TargetLogger).log(name, args, result);
+                const targetLogger = this as TargetLogger;
+
+                let result: TReturn;
+
+                try {
+                    result = target.call(this, ...args);
+
+                    // Stream methods are responsible for their own logging.
+                    if (decoratorMethodDescriptor.isStream !== true) {
+                        if (!(result instanceof Promise)) {
+                            targetLogger.logger.trace(targetLogger.callBuilder(name, args, result));
+                        } else {
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Promise interception pattern.
+                            result = result.then((promisedResult: unknown) => {
+                                targetLogger.logger.trace(targetLogger.callBuilder(name, args, promisedResult));
+
+                                return promisedResult;
+                            }).catch((e: unknown) => {
+                                targetLogger.logger.error(targetLogger.callBuilder(name, args, e));
+
+                                throw e;
+                            }) as TReturn;
+                        }
+                    }
+                } catch (e: unknown) {
+                    targetLogger.logger.error(targetLogger.callBuilder(name, args, e));
+
+                    throw e;
+                }
 
                 return result;
             };

package/src/streaming.ts

@@ -0,0 +1,13 @@
+import type { ErrorExtends, MatrixResult } from "./type.js";
+
+/**
+ * Streaming consumer callback, returned by application extension implementation.
+ */
+export type StreamingConsumerCallback<TResult, ThrowError extends boolean, TError extends ErrorExtends<ThrowError>> =
+    (result: MatrixResult<TResult, ThrowError, TError>) => void;
+
+/**
+ * Streaming cancelled callback, passed to application extension implementation.
+ */
+export type StreamingCancelledCallback =
+    () => void;

package/src/type.ts

@@ -68,8 +68,9 @@ export interface SheetRange extends Sheet, Range {
 export type Matrix<T> = T[][];
 
 /**
- * Function result, possibly including an error result. If the application framework reports errors through the return
- * value, the result is the union of the result type and the error type; otherwise, it's just the result type.
+ * Function singleton return, possibly including an error return. If the application extension reports errors through
+ * the return value, the result is the union of the return type and the error type; otherwise, it's just the return
+ * type.
  *
  * @template TResult
  * Result type.
@@ -80,12 +81,12 @@ export type Matrix<T> = T[][];
  * @template TError
  * Error type.
  */
-export type ResultError<TResult, ThrowError extends boolean, TError extends ErrorExtends<ThrowError>> = ThrowError extends false ? TResult | TError : TResult;
+export type SingletonResult<TResult, ThrowError extends boolean, TError extends ErrorExtends<ThrowError>> = ThrowError extends false ? TResult | TError : TResult;
 
 /**
- * Function result as matrix, possibly including an error result in each element. If the application framework reports
- * errors through the return value, the individual element result is the union of the result type and the error type;
- * otherwise, it's just the result type.
+ * Function matrix return, possibly including an error return in each element. If the application extension reports
+ * errors through the return value, the individual element result is the union of the return type and the error type;
+ * otherwise, it's just the return type.
  *
  * @template TResult
  * Result type.
@@ -96,4 +97,4 @@ export type ResultError<TResult, ThrowError extends boolean, TError extends Erro
  * @template TError
  * Error type.
  */
-export type MatrixResultError<TResult, ThrowError extends boolean, TError extends ErrorExtends<ThrowError>> = Matrix<ResultError<TResult, ThrowError, TError>>;
+export type MatrixResult<TResult, ThrowError extends boolean, TError extends ErrorExtends<ThrowError>> = Matrix<SingletonResult<TResult, ThrowError, TError>>;

package/src/utility/character-set-proxy.ts

@@ -11,14 +11,9 @@ import {
     Sequence
 } from "@aidc-toolkit/utility";
 import type { AppExtension } from "../app-extension.js";
-import {
-    type ExtendsParameterDescriptor,
-    type ParameterDescriptor,
-    Types
-} from "../descriptor.js";
-import { LibProxy } from "../lib-proxy.js";
+import { type ExtendsParameterDescriptor, type ParameterDescriptor, Types } from "../descriptor.js";
 import { expandParameterDescriptor, proxy } from "../proxy.js";
-import type { ErrorExtends, Matrix, MatrixResultError, ResultError } from "../type.js";
+import type { ErrorExtends, Matrix, MatrixResult } from "../type.js";
 import {
     exclusionAnyParameterDescriptor,
     exclusionFirstZeroParameterDescriptor,
@@ -46,10 +41,10 @@ const valueForSParameterDescriptor: ExtendsParameterDescriptor = {
 };
 
 @proxy.describeClass(true)
-export abstract class CharacterSetValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends StringProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+export abstract class CharacterSetValidatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends StringProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
     readonly #characterSetValidator: CharacterSetValidator;
 
-    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>, characterSetValidator: CharacterSetValidator) {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>, characterSetValidator: CharacterSetValidator) {
         super(appExtension);
 
         this.#characterSetValidator = characterSetValidator;
@@ -60,7 +55,7 @@ export abstract class CharacterSetValidatorProxy<ThrowError extends boolean, TEr
         isMatrix: true,
         parameterDescriptors: [validateSParameterDescriptor, exclusionNoneParameterDescriptor]
     })
-    validate(matrixSs: Matrix<string>, exclusion: Nullishable<Exclusion>): MatrixResultError<string, ThrowError, TError> {
+    validate(matrixSs: Matrix<string>, exclusion: Nullishable<Exclusion>): Matrix<string> {
         return this.validateString(this.#characterSetValidator, matrixSs, {
             exclusion: exclusion ?? undefined
         } satisfies CharacterSetValidation);
@@ -71,16 +66,16 @@ export abstract class CharacterSetValidatorProxy<ThrowError extends boolean, TEr
         isMatrix: true,
         parameterDescriptors: [validateSParameterDescriptor, exclusionNoneParameterDescriptor]
     })
-    isValid(matrixSs: Matrix<string>, exclusion: Nullishable<Exclusion>): MatrixResultError<boolean, ThrowError, TError> {
+    isValid(matrixSs: Matrix<string>, exclusion: Nullishable<Exclusion>): Matrix<boolean> {
         return this.isValidString(this.validate(matrixSs, exclusion));
     }
 }
 
 @proxy.describeClass(true)
-export abstract class CharacterSetCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetValidatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+export abstract class CharacterSetCreatorProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends CharacterSetValidatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
     readonly #characterSetCreator: CharacterSetCreator;
 
-    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>, characterSetCreator: CharacterSetCreator) {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>, characterSetCreator: CharacterSetCreator) {
         super(appExtension, characterSetCreator);
 
         this.#characterSetCreator = characterSetCreator;
@@ -91,11 +86,13 @@ export abstract class CharacterSetCreatorProxy<ThrowError extends boolean, TErro
         isMatrix: true,
         parameterDescriptors: [lengthParameterDescriptor, valueParameterDescriptor, exclusionNoneParameterDescriptor, tweakParameterDescriptor]
     })
-    create(length: number, matrixValues: Matrix<number | bigint>, exclusion: Nullishable<Exclusion>, tweak: Nullishable<number | bigint>): MatrixResultError<string, ThrowError, TError> {
+    create(length: number, matrixValues: Matrix<number | bigint>, exclusion: Nullishable<Exclusion>, tweak: Nullishable<number | bigint>): MatrixResult<string, ThrowError, TError> {
         const exclusionOrUndefined = exclusion ?? undefined;
         const tweakOrUndefined = tweak ?? undefined;
 
-        return this.mapMatrix(matrixValues, value => this.#characterSetCreator.create(length, value, exclusionOrUndefined, tweakOrUndefined));
+        return this.matrixResult(matrixValues, value =>
+            this.#characterSetCreator.create(length, value, exclusionOrUndefined, tweakOrUndefined)
+        );
     }
 
     @proxy.describeMethod({
@@ -104,13 +101,15 @@ export abstract class CharacterSetCreatorProxy<ThrowError extends boolean, TErro
         isMatrix: true,
         parameterDescriptors: [lengthParameterDescriptor, startValueParameterDescriptor, countParameterDescriptor, exclusionNoneParameterDescriptor, tweakParameterDescriptor]
     })
-    createSequence(length: number, startValue: number, count: number, exclusion: Nullishable<Exclusion>, tweak: Nullishable<number | bigint>): Matrix<string> {
-        this.appExtension.validateSequenceCount(count);
-
+    createSequence(length: number, startValue: number, count: number, exclusion: Nullishable<Exclusion>, tweak: Nullishable<number | bigint>): MatrixResult<string, ThrowError, TError> {
         const exclusionOrUndefined = exclusion ?? undefined;
         const tweakOrUndefined = tweak ?? undefined;
 
-        return LibProxy.matrixResult(this.#characterSetCreator.create(length, new Sequence(startValue, count), exclusionOrUndefined, tweakOrUndefined));
+        return this.iterableResult(() => {
+            this.appExtension.validateSequenceCount(count);
+
+            return this.#characterSetCreator.create(length, new Sequence(startValue, count), exclusionOrUndefined, tweakOrUndefined);
+        });
     }
 
     @proxy.describeMethod({
@@ -118,40 +117,42 @@ export abstract class CharacterSetCreatorProxy<ThrowError extends boolean, TErro
         isMatrix: true,
         parameterDescriptors: [valueForSParameterDescriptor, exclusionNoneParameterDescriptor, tweakParameterDescriptor]
     })
-    valueFor(matrixSs: Matrix<string>, exclusion: Nullishable<Exclusion>, tweak: Nullishable<number | bigint>): MatrixResultError<ResultError<TBigInt, ThrowError, TError>, ThrowError, TError> {
+    valueFor(matrixSs: Matrix<string>, exclusion: Nullishable<Exclusion>, tweak: Nullishable<number | bigint>): MatrixResult<TBigInt, ThrowError, TError> {
         const exclusionOrUndefined = exclusion ?? undefined;
         const tweakOrUndefined = tweak ?? undefined;
 
-        return this.mapMatrix(matrixSs, s => this.mapBigInt(this.#characterSetCreator.valueFor(s, exclusionOrUndefined, tweakOrUndefined)));
+        return this.matrixResult(matrixSs, s =>
+            this.mapBigInt(this.#characterSetCreator.valueFor(s, exclusionOrUndefined, tweakOrUndefined))
+        );
     }
 }
 
 @proxy.describeClass(false, {
     methodInfix: "Numeric",
-    replaceParameterDescriptors: [
+    replacementParameterDescriptors: [
         {
             name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
             replacement: exclusionFirstZeroParameterDescriptor
         }
     ]
 })
-export class NumericProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
-    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+export class NumericProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) {
         super(appExtension, NUMERIC_CREATOR);
     }
 }
 
 @proxy.describeClass(false, {
     methodInfix: "Hexadecimal",
-    replaceParameterDescriptors: [
+    replacementParameterDescriptors: [
         {
             name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
             replacement: exclusionAnyParameterDescriptor
         }
     ]
 })
-export class HexadecimalProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
-    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+export class HexadecimalProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) {
         super(appExtension, HEXADECIMAL_CREATOR);
     }
 }
@@ -159,23 +160,23 @@ export class HexadecimalProxy<ThrowError extends boolean, TError extends ErrorEx
 @proxy.describeClass(false, {
     methodInfix: "Alphabetic"
 })
-export class AlphabeticProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
-    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+export class AlphabeticProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) {
         super(appExtension, ALPHABETIC_CREATOR);
     }
 }
 
 @proxy.describeClass(false, {
     methodInfix: "Alphanumeric",
-    replaceParameterDescriptors: [
+    replacementParameterDescriptors: [
         {
             name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
             replacement: exclusionAnyParameterDescriptor
         }
     ]
 })
-export class AlphanumericProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TBigInt> {
-    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TBigInt>) {
+export class AlphanumericProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends CharacterSetCreatorProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
+    constructor(appExtension: AppExtension<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt>) {
         super(appExtension, ALPHANUMERIC_CREATOR);
     }
 }

package/src/utility/reg-exp-proxy.ts

@@ -2,7 +2,7 @@ import type { Nullishable } from "@aidc-toolkit/core";
 import { RegExpValidator } from "@aidc-toolkit/utility";
 import { type ParameterDescriptor, Types } from "../descriptor.js";
 import { proxy } from "../proxy.js";
-import type { ErrorExtends, Matrix, MatrixResultError } from "../type.js";
+import type { ErrorExtends, Matrix } from "../type.js";
 import { validateSParameterDescriptor } from "./string-descriptor.js";
 import { StringProxy } from "./string-proxy.js";
 
@@ -23,18 +23,19 @@ const errorMessageParameterDescriptor: ParameterDescriptor = {
 @proxy.describeClass(false, {
     methodInfix: "RegExp"
 })
-export class RegExpProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends StringProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+export class RegExpProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends StringProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
     @proxy.describeMethod({
         type: Types.String,
         isMatrix: true,
         parameterDescriptors: [regExpParameterDescriptor, validateSParameterDescriptor, errorMessageParameterDescriptor]
     })
-    validate(regExp: string, matrixSs: Matrix<string>, errorMessage: Nullishable<string>): MatrixResultError<string, ThrowError, TError> {
+    validate(regExp: string, matrixSs: Matrix<string>, errorMessage: Nullishable<string>): Matrix<string> {
         return this.validateString(new class extends RegExpValidator {
             protected override createErrorMessage(s: string): string {
-                return errorMessage ?? super.createErrorMessage(s);
+                // Replace {{s}} with the invalid string.
+                return errorMessage?.replace(/\{\{s\}\}/ug, s) ?? super.createErrorMessage(s);
             }
-        }(new RegExp(regExp)), matrixSs);
+        }(new RegExp(regExp, "u")), matrixSs);
     }
 
     @proxy.describeMethod({
@@ -42,7 +43,7 @@ export class RegExpProxy<ThrowError extends boolean, TError extends ErrorExtends
         isMatrix: true,
         parameterDescriptors: [regExpParameterDescriptor, validateSParameterDescriptor]
     })
-    isValid(regExp: string, matrixSs: Matrix<string>): MatrixResultError<boolean, ThrowError, TError> {
+    isValid(regExp: string, matrixSs: Matrix<string>): Matrix<boolean> {
         return this.isValidString(this.validate(regExp, matrixSs, undefined));
     }
 }

package/src/utility/string-proxy.ts

@@ -1,15 +1,11 @@
 import type { StringValidation, StringValidator } from "@aidc-toolkit/utility";
 import { LibProxy } from "../lib-proxy.js";
-import type { ErrorExtends, Matrix, MatrixResultError } from "../type.js";
+import type { ErrorExtends, Matrix } from "../type.js";
 
-export abstract class StringProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TBigInt> {
+export abstract class StringProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
     protected validateString<TStringValidation extends StringValidation>(validator: StringValidator<TStringValidation>, matrixSs: Matrix<string>, validation?: TStringValidation): Matrix<string> {
-        return LibProxy.mapMatrixRangeError(matrixSs, (s) => {
+        return this.matrixErrorResult(matrixSs, (s) => {
             validator.validate(s, validation);
         });
     }
-
-    protected isValidString(matrixValidateResults: MatrixResultError<string, ThrowError, TError>): MatrixResultError<boolean, ThrowError, TError> {
-        return this.mapMatrix(matrixValidateResults, validateResult => validateResult === "");
-    }
 }