@aidc-toolkit/app-extension 1.0.31-beta → 1.0.33-beta

package/src/proxy.ts

@@ -1,19 +1,19 @@
 import {
     type AbstractConstructor,
     type Constructor,
-    getLogger,
-    type LogLevel,
-    LogLevels,
+    loggableValue,
     omit,
     type TypedAbstractConstructor
 } from "@aidc-toolkit/core";
 import type { Logger } from "tslog";
 import type { AppExtension } from "./app-extension.js";
-import type {
-    ClassDescriptor,
-    ExtendsParameterDescriptor,
-    MethodDescriptor,
-    ParameterDescriptor
+import {
+    type ClassDescriptor,
+    type ExtendsParameterDescriptor,
+    type MethodDescriptor,
+    Multiplicities,
+    type ParameterDescriptor,
+    type ReplacementParameterDescriptor
 } from "./descriptor.js";
 import { LibProxy } from "./lib-proxy.js";
 import type { ErrorExtends } from "./type.js";
@@ -21,7 +21,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;
 
 /**
@@ -38,13 +38,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
@@ -63,11 +63,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;
 
 /**
@@ -88,21 +88,22 @@ 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.
  */
-type InterimClassDescriptor =
-    Omit<ClassDescriptor, "name" | "namespaceClassName" | "objectName" | "methodDescriptors">;
+interface InterimClassDescriptor extends Omit<ClassDescriptor, "name" | "category" | "namespaceClassName" | "objectName" | "methodDescriptors"> {
+    readonly category?: string;
+}
 
 /**
  * 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;
     }>;
 }
@@ -145,10 +146,12 @@ interface Interim {
  */
 interface TargetLogger {
     /**
-     * Log a method call.
-     *
-     * @param logLevel
-     * Log level.
+     * Logger.
+     */
+    readonly logger: Logger<object>;
+
+    /**
+     * Build a function that returns a loggable value for a method call.
      *
      * @param methodName
      * Method name.
@@ -159,7 +162,7 @@ interface TargetLogger {
      * @param result
      * Output result.
      */
-    log: (logLevel: LogLevel, methodName: string, args: unknown[], result: unknown) => void;
+    callBuilder: (methodName: string, args: unknown[], result: unknown) => () => unknown;
 }
 
 /**
@@ -167,71 +170,26 @@ interface TargetLogger {
  */
 export class Proxy {
     /**
-     * Logger.
+     * Abstract class descriptors map, keyed on declaration class. Abstract classes are not used directly by target
+     * applications.
      */
-    // TODO Add configuration parameter to output JSON.
-    // TODO Change this to LogLevels.Trace when configuration available.
-    readonly #logger: Logger<unknown> = getLogger(LogLevels.Info);
+    readonly #abstractClassDescriptorsMap = new Map<typeof LibProxy, ClassDescriptor>();
 
     /**
-     * Abstract class descriptors map, keyed on declaration class name. Abstract classes are not used directly by target
-     * applications.
+     * Concrete class descriptors map, keyed on declaration class.
      */
-    readonly #abstractClassDescriptorsMap = new Map<string, ClassDescriptor>();
+    readonly #concreteClassDescriptorsMap = new Map<typeof LibProxy, ClassDescriptor>();
 
     /**
-     * Concrete class descriptors map, keyed on declaration class name.
+     * Namespace class names set for duplicate detection.
      */
-    readonly #concreteClassDescriptorsMap = new Map<string, ClassDescriptor>();
+    readonly #namespaceClassNamesSet = new Set<string>();
 
     /**
      * Interim object.
      */
     #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.
      *
@@ -257,17 +215,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)
                 }))
@@ -281,44 +239,41 @@ export class Proxy {
         this.#interim = interim;
 
         return (Target: TProxyClassConstructor, context: ClassDecoratorContext<TProxyClassConstructor>) => {
-            const name = context.name;
+            const className = context.name;
 
             // Validate that class descriptor is applied within an appropriate class.
-            if (typeof name !== "string") {
-                throw new Error(`${String(name)} has an invalid name`);
+            if (className === undefined) {
+                throw new Error("Class has no name");
             }
 
-            const namespacePrefix = decoratorClassDescriptor.namespace === undefined ? "" : `${decoratorClassDescriptor.namespace}.`;
-            const namespaceClassName = `${namespacePrefix}${name}`;
-
             const abstractClassDescriptorsMap = this.#abstractClassDescriptorsMap;
             const concreteClassDescriptorsMap = this.#concreteClassDescriptorsMap;
 
-            if (abstractClassDescriptorsMap.has(namespaceClassName) || concreteClassDescriptorsMap.has(namespaceClassName)) {
-                throw new Error(`Duplicate class ${namespaceClassName}`);
-            }
-
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Class hierarchy is known.
-            let baseClassType: typeof LibProxy = Target as unknown as typeof LibProxy;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Target is known to be of type LibProxy.
+            const targetClassType = Target as unknown as typeof LibProxy;
+            let baseClassType = targetClassType;
             let baseClassDescriptor: ClassDescriptor | undefined;
 
             do {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Class hierarchy is known.
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Class hierarchy is known to stop at LibProxy.
                 baseClassType = Object.getPrototypeOf(baseClassType) as typeof LibProxy;
 
-                const namespaceBaseClassName = `${namespacePrefix}${baseClassType.name}`;
-
-                // Look first within the namespace and then in no namespace, in both abstract class descriptors map and concrete class descriptors map.
-                baseClassDescriptor =
-                    abstractClassDescriptorsMap.get(namespaceBaseClassName) ?? abstractClassDescriptorsMap.get(baseClassType.name) ??
-                    concreteClassDescriptorsMap.get(namespaceBaseClassName) ?? concreteClassDescriptorsMap.get(baseClassType.name);
+                // Look in both abstract class descriptors map and concrete class descriptors map.
+                baseClassDescriptor = abstractClassDescriptorsMap.get(baseClassType) ?? concreteClassDescriptorsMap.get(baseClassType);
             } while (baseClassType !== LibProxy && baseClassDescriptor === undefined);
 
+            let namespace = interimClassDescriptor.namespace;
+            let category = interimClassDescriptor.category;
+
             let interimMethodDescriptors: InterimMethodDescriptor[];
 
             if (baseClassDescriptor !== undefined) {
+                // Inherit namespace and category from base class if not explicitly defined.
+                namespace ??= baseClassDescriptor.namespace;
+                category ??= baseClassDescriptor.category;
+
                 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)]));
@@ -335,6 +290,19 @@ export class Proxy {
                 interimMethodDescriptors = [];
             }
 
+            const namespacePrefix = namespace === undefined ? "" : `${namespace}.`;
+            const namespaceClassName = `${namespacePrefix}${className}`;
+
+            if (this.#namespaceClassNamesSet.has(namespaceClassName)) {
+                throw new Error(`Duplicate class ${namespaceClassName}`);
+            }
+
+            if (category === undefined) {
+                throw new Error(`Missing category for ${namespaceClassName}`);
+            }
+
+            this.#namespaceClassNamesSet.add(namespaceClassName);
+
             // Replace base class method descriptors with matching names or append new method descriptor.
             for (const classInterimMethodDescriptor of interim.methodDescriptors) {
                 const existingIndex = interimMethodDescriptors.findIndex(interimMethodDescriptor => interimMethodDescriptor.name === classInterimMethodDescriptor.name);
@@ -395,21 +363,23 @@ 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`);
             }
 
             const classDescriptor: ClassDescriptor = {
-                name,
                 ...interimClassDescriptor,
+                name: className,
+                namespace,
+                category,
                 namespaceClassName,
                 objectName: `${objectNameGroups["namespaceFirstWord"].toLowerCase()}${objectNameGroups["namespaceRemaining"]}${objectNameGroups["className"]}`,
                 methodDescriptors
             };
 
-            (isAbstract ? abstractClassDescriptorsMap : concreteClassDescriptorsMap).set(namespaceClassName, classDescriptor);
+            (isAbstract ? abstractClassDescriptorsMap : concreteClassDescriptorsMap).set(targetClassType, classDescriptor);
 
             const methodDescriptorsMap = new Map<string, MethodDescriptor>();
 
@@ -419,30 +389,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(logLevel: LogLevel, 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.log(logLevel, "", 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,
+                            className,
+                            methodName,
+                            functionName: methodDescriptor.functionName,
+                            parameters: methodDescriptor.parameterDescriptors.map((parameterDescriptor, index) => ({
+                                name: parameterDescriptor.name,
+                                value: loggableValue(args[index])
+                            })),
+                            result: loggableValue(result)
+                        };
+                    };
                 }
             };
         };
@@ -464,9 +439,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;
@@ -474,19 +454,24 @@ export class Proxy {
             // Expand all parameter descriptors.
             const parameterDescriptors = decoratorMethodDescriptor.parameterDescriptors.map((decoratorParameterDescriptor) => {
                 const parameterDescriptor = expandParameterDescriptor(decoratorParameterDescriptor);
+                const parameterName = parameterDescriptor.name;
 
                 if (!parameterDescriptor.isRequired) {
                     anyOptional = true;
                 } else if (anyOptional) {
-                    throw new Error(`Parameter ${parameterDescriptor.name} descriptor of method ${name} is required but prior parameter descriptor is optional`);
+                    throw new Error(`Parameter ${parameterName} descriptor of method ${name} is required but prior parameter descriptor is optional`);
+                }
+
+                if ((parameterDescriptor.multiplicity === Multiplicities.Array || parameterDescriptor.multiplicity === Multiplicities.Matrix) && decoratorMethodDescriptor.multiplicity !== Multiplicities.Matrix) {
+                    throw new Error(`Parameter ${parameterName} descriptor of method ${name} is array or matrix but method descriptor is not matrix`);
                 }
 
                 return parameterDescriptor;
             });
 
             this.#interim.methodDescriptors.push({
-                name,
                 ...decoratorMethodDescriptor,
+                name,
                 parameterDescriptors
             });
 
@@ -499,10 +484,25 @@ export class Proxy {
                 try {
                     result = target.call(this, ...args);
 
-                    // TODO Change this to LogLevels.Trace when configuration available.
-                    targetLogger.log(LogLevels.Info, name, args, result);
+                    // 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.log(LogLevels.Error, name, args, e instanceof Error ? `${e.name}: ${e.message}` : `Unknown exception: ${String(e)}`);
+                    targetLogger.logger.error(targetLogger.callBuilder(name, args, e));
 
                     throw e;
                 }
@@ -513,10 +513,10 @@ export class Proxy {
     }
 
     /**
-     * Get the class descriptors map.
+     * Get the class descriptors.
      */
-    get classDescriptorsMap(): Map<string, ClassDescriptor> {
-        return this.#concreteClassDescriptorsMap;
+    get classDescriptors(): MapIterator<ClassDescriptor> {
+        return this.#concreteClassDescriptorsMap.values();
     }
 }
 

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-descriptor.ts

@@ -1,9 +1,9 @@
-import { type ExtendsParameterDescriptor, type ParameterDescriptor, Types } from "../descriptor.js";
+import { type ExtendsParameterDescriptor, Multiplicities, type ParameterDescriptor, Types } from "../descriptor.js";
 
 const exclusionParameterDescriptor: ParameterDescriptor = {
     name: "exclusion",
     type: Types.Number,
-    isMatrix: false,
+    multiplicity: Multiplicities.Singleton,
     isRequired: false
 };