libmodulor 0.1.0 → 0.2.0

package/dist/esm/testing/impl/VitestAppTestSuiteRunner.d.ts

@@ -0,0 +1,10 @@
+import type { FilePath } from '../../dt/index.js';
+import type { FSManager } from '../../std/index.js';
+import type { AppTestSuiteRunner, Input } from '../workers/AppTestSuiteRunner.js';
+export declare class VitestAppTestSuiteRunner implements AppTestSuiteRunner {
+    private fsManager;
+    constructor(fsManager: FSManager);
+    exec({ appPath, skipCoverage, updateSnapshots, }: Input): Promise<void>;
+    coverageReportEntrypointPath(appPath: FilePath): Promise<FilePath>;
+    private coverageReportPath;
+}

package/dist/esm/testing/impl/VitestAppTestSuiteRunner.js

@@ -0,0 +1,51 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { createVitest } from 'vitest/node';
+import { APP_TEST_DIR_NAME, APP_TEST_REPORTS_DIR_NAME, } from '../../convention.js';
+let VitestAppTestSuiteRunner = class VitestAppTestSuiteRunner {
+    fsManager;
+    constructor(fsManager) {
+        this.fsManager = fsManager;
+    }
+    async exec({ appPath, skipCoverage, updateSnapshots, }) {
+        const testPath = this.fsManager.path(appPath, APP_TEST_DIR_NAME);
+        const excludePath = this.fsManager.path(testPath);
+        const runner = await createVitest('test', {
+            coverage: {
+                enabled: !skipCoverage,
+                exclude: [excludePath],
+                include: [appPath],
+                reportsDirectory: this.coverageReportPath(appPath),
+                reportOnFailure: false,
+            },
+            dir: appPath,
+            update: updateSnapshots,
+            watch: false,
+        });
+        await runner.start();
+    }
+    async coverageReportEntrypointPath(appPath) {
+        return this.fsManager.path(this.coverageReportPath(appPath), 'index.html');
+    }
+    coverageReportPath(appPath) {
+        const testPath = this.fsManager.path(appPath, APP_TEST_DIR_NAME);
+        return this.fsManager.path(testPath, APP_TEST_REPORTS_DIR_NAME, 'coverage');
+    }
+};
+VitestAppTestSuiteRunner = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __metadata("design:paramtypes", [Object])
+], VitestAppTestSuiteRunner);
+export { VitestAppTestSuiteRunner };

package/dist/esm/testing/impl/newNodeAppTester.d.ts

@@ -0,0 +1,3 @@
+import { type HostPort, type NumIndex } from '../../dt/index.js';
+import { AppTester, type AppTesterInitArgs } from '../AppTester.js';
+export declare function newNodeAppTester(serverPortRangeStart: HostPort, idx: NumIndex, args: Omit<AppTesterInitArgs, 'serverClientSettings'>): Promise<AppTester>;

package/dist/esm/testing/impl/newNodeAppTester.js

@@ -0,0 +1,67 @@
+import { Container } from 'inversify';
+import { TApiKey, TPassword, TUsername, } from '../../dt/index.js';
+import { STD_DEFAULT_JWT_MANAGER_SETTINGS, } from '../../std/index.js';
+import { TARGET_DEFAULT_SERVER_MANAGER_SETTINGS } from '../../target/lib/server/consts.js';
+import { NodeExpressServerManager } from '../../target/node-express-server/NodeExpressServerManager.js';
+import { FAKE_USER_ADMIN, FAKE_USER_REGULAR } from '../../uc/index.js';
+import { CONTAINER_OPTS } from '../../utils/index.js';
+import { bindCommon } from '../../utils/ioc/bindCommon.js';
+import { bindNodeCore } from '../../utils/ioc/bindNodeCore.js';
+import { bindServer } from '../../utils/ioc/bindServer.js';
+import { AppTester } from '../AppTester.js';
+import { optsAllSet } from '../opts.js';
+import { SimpleAppDocsEmitter } from './SimpleAppDocsEmitter.js';
+import { TypeScriptLibUCDefASTParser } from './TypeScriptLibUCDefASTParser.js';
+export async function newNodeAppTester(serverPortRangeStart, idx, args) {
+    const { configurator } = args;
+    const { logger_level } = optsAllSet(await configurator.opts());
+    const settings = {
+        ...STD_DEFAULT_JWT_MANAGER_SETTINGS,
+        ...TARGET_DEFAULT_SERVER_MANAGER_SETTINGS,
+        jwt_manager_audience: 'fik',
+        jwt_manager_issuer: 'fik',
+        jwt_manager_secret: new TPassword().example(),
+        logger_level,
+        server_basic_auth_entries: {
+            [new TUsername().example()]: new TPassword().example(),
+        },
+        server_binding_port: serverPortRangeStart + idx,
+        server_private_api_key_entries: [new TApiKey().example()],
+        server_public_api_key_entries: [new TApiKey().example()],
+    };
+    const container = new Container(CONTAINER_OPTS);
+    bindCommon(container, () => settings);
+    bindNodeCore(container);
+    bindServer(container);
+    container.bind('AppDocsEmitter').to(SimpleAppDocsEmitter);
+    container
+        .bind('ServerManager')
+        .to(NodeExpressServerManager)
+        .inSingletonScope();
+    container
+        .bind('UCDefASTParser')
+        .to(TypeScriptLibUCDefASTParser);
+    const tester = container.resolve(AppTester);
+    const jwtManager = container.get('JWTManager');
+    const apiKey = settings.server_private_api_key_entries[0];
+    const [basicAuth] = Object.entries(settings.server_basic_auth_entries);
+    const basic = basicAuth
+        ? { password: basicAuth[1], username: basicAuth[0] }
+        : undefined;
+    await tester.init({
+        ...args,
+        serverClientSettings: {
+            server_cookies_name_auth: settings.server_cookies_name_auth,
+            server_dangerously_set_api_key: apiKey,
+            server_dangerously_set_basic: basic,
+            server_dangerously_set_jwts: {
+                admin: await jwtManager.encode(FAKE_USER_ADMIN),
+                regular: await jwtManager.encode(FAKE_USER_REGULAR),
+            },
+            server_public_api_key: settings.server_public_api_key_entries[0] || null,
+            server_public_api_key_header_name: settings.server_public_api_key_header_name,
+            server_public_url: `http://${settings.server_binding_host}:${settings.server_binding_port}`,
+        },
+    });
+    return tester;
+}

package/dist/esm/testing/index.d.ts

@@ -0,0 +1,13 @@
+export type { AppDocsEmitter } from './workers/AppDocsEmitter.js';
+export type { AppTesterConfigurator, AppTesterConfiguratorAuthSettersConfig, AppTesterConfiguratorInputFillers, AppTesterConfiguratorSideEffects, AppTesterConfiguratorSideEffectsSerialized, AppTesterConfiguratorSpecificAssertions, } from './AppTesterConfigurator.js';
+export type { AppTestSuiteEmitter } from './workers/AppTestSuiteEmitter.js';
+export type { AppTestSuiteRunner } from './workers/AppTestSuiteRunner.js';
+export type { AppTesterCtx, AppTesterUCDRef } from './ctx.js';
+export type { AppTesterFlow, AppTesterFlowInputOverride } from './flow.js';
+export { type AppTesterOpts, type AppTesterOptsAllSet, type AppTesterTypeScriptOpts, DEFAULT_APP_TESTER_OPTS, } from './opts.js';
+export { type CustomUCAuthSetter, DEFAULT_UC_AUTH_SETTERS, type DefaultUCAuthSetter, type UCAuthSetterName, type UCAuthSetterSet, defaultUCAuthSetters, } from './uc-auth.js';
+export { type CustomUCInputFiller, DEFAULT_UC_INPUT_FILLERS, type DefaultUCInputFiller, type UCInputFiller, type UCInputFillerName, type UCInputFillerSet, allWithExamples, defaultUCInputFillers, onlyMandatoryWithExamples, onlySetProgrammaticallyWithExamples, } from './uc-input.js';
+export { UCDataStoreTester } from './UCDataStoreTester.js';
+export type { UCDefASTParser } from './UCDefASTParser.js';
+export type { UCExecutor, UCExecutorAssertion, UCExecutorExecOutput, } from './workers/UCExecutor.js';
+export { awaitForSrcImport, type TestData } from './utils.js';

package/dist/esm/testing/index.js

@@ -0,0 +1,5 @@
+export { DEFAULT_APP_TESTER_OPTS, } from './opts.js';
+export { DEFAULT_UC_AUTH_SETTERS, defaultUCAuthSetters, } from './uc-auth.js';
+export { DEFAULT_UC_INPUT_FILLERS, allWithExamples, defaultUCInputFillers, onlyMandatoryWithExamples, onlySetProgrammaticallyWithExamples, } from './uc-input.js';
+export { UCDataStoreTester } from './UCDataStoreTester.js';
+export { awaitForSrcImport } from './utils.js';

package/dist/esm/testing/opts.d.ts

@@ -0,0 +1,34 @@
+import type { FileName, FilePath } from '../dt/index.js';
+import type { LoggerSettings } from '../std/index.js';
+import type { RecursiveNonNullable } from '../utils/index.js';
+import type { AppTesterCtx } from './ctx.js';
+type AppTesterOptsAliasPrefix = string;
+type AppTesterOptsImportsList = string[];
+export interface AppTesterTypeScriptOpts {
+    module?: string;
+    moduleResolution?: string;
+    noCheck?: boolean;
+    skipLibCheck?: boolean;
+    target?: string;
+}
+export type AppTesterOpts = Partial<Pick<LoggerSettings, 'logger_level'>> & {
+    source?: {
+        imports?: {
+            external?: {
+                aliasPrefix?: AppTesterOptsAliasPrefix;
+                allowed?: AppTesterOptsImportsList;
+            };
+            internal?: {
+                maxDepth?: FilePath;
+                startChar?: string;
+            };
+        };
+        ts?: {
+            configFileName?: FileName;
+        } & AppTesterTypeScriptOpts;
+    };
+};
+export type AppTesterOptsAllSet = RecursiveNonNullable<AppTesterOpts>;
+export declare const DEFAULT_APP_TESTER_OPTS: AppTesterOptsAllSet;
+export declare function optsAllSet(opts: AppTesterCtx['opts']): AppTesterOptsAllSet;
+export {};

package/dist/esm/testing/opts.js

@@ -0,0 +1,50 @@
+export const DEFAULT_APP_TESTER_OPTS = {
+    logger_level: 'error',
+    source: {
+        imports: {
+            external: {
+                aliasPrefix: '@',
+                allowed: ['inversify', 'libmodulor'],
+            },
+            internal: {
+                maxDepth: '../../',
+                startChar: '.',
+            },
+        },
+        ts: {
+            configFileName: 'tsconfig.json',
+            module: 'NodeNext',
+            moduleResolution: 'NodeNext',
+            noCheck: true,
+            skipLibCheck: true,
+            target: 'ESNext',
+        },
+    },
+};
+export function optsAllSet(opts) {
+    const { logger_level, source: { imports: { external: { aliasPrefix, allowed }, internal: { maxDepth, startChar }, }, ts: { configFileName, module, moduleResolution, noCheck, skipLibCheck, target, }, }, } = DEFAULT_APP_TESTER_OPTS;
+    return {
+        logger_level: opts?.logger_level ?? logger_level,
+        source: {
+            imports: {
+                external: {
+                    aliasPrefix: opts?.source?.imports?.external?.aliasPrefix ??
+                        aliasPrefix,
+                    allowed: opts?.source?.imports?.external?.allowed ?? allowed,
+                },
+                internal: {
+                    maxDepth: opts?.source?.imports?.internal?.maxDepth ?? maxDepth,
+                    startChar: opts?.source?.imports?.internal?.startChar ?? startChar,
+                },
+            },
+            ts: {
+                configFileName: opts?.source?.ts?.configFileName ?? configFileName,
+                module: opts?.source?.ts?.module ?? module,
+                moduleResolution: opts?.source?.ts?.moduleResolution ?? moduleResolution,
+                noCheck: opts?.source?.ts?.noCheck ?? noCheck,
+                skipLibCheck: opts?.source?.ts?.skipLibCheck ?? skipLibCheck,
+                target: opts?.source?.ts?.target ?? target,
+            },
+        },
+    };
+}

package/dist/esm/testing/uc-auth.d.ts

@@ -0,0 +1,7 @@
+import { type UCAuth } from '../uc/index.js';
+export declare const DEFAULT_UC_AUTH_SETTERS: readonly ["ANONYMOUS", "ADMIN", "REGULAR"];
+export type DefaultUCAuthSetter = (typeof DEFAULT_UC_AUTH_SETTERS)[number];
+export type CustomUCAuthSetter = Capitalize<string>;
+export type UCAuthSetterName = DefaultUCAuthSetter | CustomUCAuthSetter;
+export type UCAuthSetterSet<T extends UCAuthSetterName = UCAuthSetterName> = Record<T, UCAuth | null>;
+export declare function defaultUCAuthSetters(): UCAuthSetterSet;

package/dist/esm/testing/uc-auth.js

@@ -0,0 +1,13 @@
+import { FAKE_USER_ADMIN, FAKE_USER_REGULAR, } from '../uc/index.js';
+export const DEFAULT_UC_AUTH_SETTERS = [
+    'ANONYMOUS',
+    'ADMIN',
+    'REGULAR',
+];
+export function defaultUCAuthSetters() {
+    return {
+        ANONYMOUS: null,
+        ADMIN: FAKE_USER_ADMIN,
+        REGULAR: FAKE_USER_REGULAR,
+    };
+}

package/dist/esm/testing/uc-input.d.ts

@@ -0,0 +1,11 @@
+import { type UC, type UCInput, type UCOPIBase } from '../uc/index.js';
+export type UCInputFiller<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (uc: UC<I, OPI0, OPI1>) => void;
+export declare const DEFAULT_UC_INPUT_FILLERS: readonly ["ALL_WITH_EXAMPLES", "ONLY_MANDATORY_WITH_EXAMPLES", "ONLY_SET_PROGRAMMATICALLY_WITH_EXAMPLES"];
+export type DefaultUCInputFiller = (typeof DEFAULT_UC_INPUT_FILLERS)[number];
+export type CustomUCInputFiller = string;
+export type UCInputFillerName = DefaultUCInputFiller | (CustomUCInputFiller & {});
+export type UCInputFillerSet<T extends UCInputFillerName = DefaultUCInputFiller, I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = Record<T, UCInputFiller<I, OPI0, OPI1>>;
+export declare function defaultUCInputFillers<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(): UCInputFillerSet<DefaultUCInputFiller, I, OPI0, OPI1>;
+export declare function allWithExamples<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): void;
+export declare function onlyMandatoryWithExamples<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): void;
+export declare function onlySetProgrammaticallyWithExamples<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): void;

package/dist/esm/testing/uc-input.js

@@ -0,0 +1,52 @@
+import { TFile } from '../dt/index.js';
+import { UCInputFieldChangeOperator, ucifIsMandatory, ucifMustBeFilledManually, ucifRepeatability, } from '../uc/index.js';
+export const DEFAULT_UC_INPUT_FILLERS = [
+    'ALL_WITH_EXAMPLES',
+    'ONLY_MANDATORY_WITH_EXAMPLES',
+    'ONLY_SET_PROGRAMMATICALLY_WITH_EXAMPLES',
+];
+export function defaultUCInputFillers() {
+    return {
+        ALL_WITH_EXAMPLES: allWithExamples,
+        ONLY_MANDATORY_WITH_EXAMPLES: onlyMandatoryWithExamples,
+        ONLY_SET_PROGRAMMATICALLY_WITH_EXAMPLES: onlySetProgrammaticallyWithExamples,
+    };
+}
+export function allWithExamples(uc) {
+    for (const f of uc.inputFieldsOrdered()) {
+        fillWithExample(f);
+    }
+}
+export function onlyMandatoryWithExamples(uc) {
+    for (const f of uc.inputFieldsOrdered()) {
+        if (!ucifIsMandatory(f.def)) {
+            continue;
+        }
+        fillWithExample(f);
+    }
+}
+export function onlySetProgrammaticallyWithExamples(uc) {
+    for (const f of uc.inputFieldsOrdered()) {
+        if (ucifMustBeFilledManually(f.def)) {
+            continue;
+        }
+        fillWithExample(f);
+    }
+}
+function fillWithExample(f) {
+    const { type } = f.def;
+    let val = type.getExamples()?.[0] ?? type.example();
+    if (type instanceof TFile) {
+        const file = val;
+        val = new File(['01010101010101010101010101010101'], file.path, {
+            type: file.type,
+        });
+    }
+    const [isRepeatable] = ucifRepeatability(f.def);
+    if (isRepeatable) {
+        f.setValue(UCInputFieldChangeOperator.ADD, val);
+    }
+    else {
+        f.setValue(UCInputFieldChangeOperator.SET, val);
+    }
+}

package/dist/esm/testing/utils.d.ts

@@ -0,0 +1,6 @@
+import type { FilePath, UIntDuration } from '../dt/index.js';
+export type TestData<I, O> = {
+    i: I;
+    o: O;
+}[];
+export declare function awaitForSrcImport(path: FilePath, timeoutInMs?: UIntDuration): Promise<void>;

package/dist/esm/testing/utils.js

@@ -0,0 +1,8 @@
+const ERR_SRC_IMPORTER_TIMEOUT = (path) => `Importing ${path} did not resolve within 5000ms. Check for any circular dependencies.`;
+export function awaitForSrcImport(path, timeoutInMs = 5000) {
+    return new Promise((_resolve, reject) => {
+        setTimeout(() => {
+            reject(new Error(ERR_SRC_IMPORTER_TIMEOUT(path)));
+        }, timeoutInMs);
+    });
+}

package/dist/esm/testing/workers/AppDocsEmitter.d.ts

@@ -0,0 +1,12 @@
+import type { FilePath } from '../../dt/index.js';
+import type { Worker } from '../../std/index.js';
+import type { Output as UCDefSourcesCheckerOutput } from './checkers/UCDefSourcesChecker.js';
+export interface Input {
+    appPath: FilePath;
+    ucDefSourcesCheckerOutput: UCDefSourcesCheckerOutput;
+}
+export interface Output {
+    outPath: FilePath;
+}
+export interface AppDocsEmitter extends Worker<Input, Promise<Output>> {
+}

package/dist/esm/testing/workers/AppDocsEmitter.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/testing/workers/AppTestReportEmitter.d.ts

@@ -0,0 +1,14 @@
+import type { FilePath } from '../../dt/index.js';
+import type { Worker } from '../../std/index.js';
+import type { AppTestSuiteSummary, AppTestSuiteTestResult } from './AppTestSuiteEmitter.js';
+export interface Input {
+    appPath: FilePath;
+    testResults: AppTestSuiteTestResult[];
+    testSummary: AppTestSuiteSummary;
+}
+export interface Output {
+    outPath: FilePath;
+}
+export interface AppTestReportEmitter extends Worker<Input, Promise<Output>> {
+    entrypointPath(appPath: FilePath): Promise<FilePath>;
+}

package/dist/esm/testing/workers/AppTestReportEmitter.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/testing/workers/AppTestSuiteEmitter.d.ts

@@ -0,0 +1,32 @@
+import type { FilePath, FreeTextShort, HostPort, JSONString, NumIndex, SemanticsVariant, UIntDuration, UIntQuantity } from '../../dt/index.js';
+import type { Worker } from '../../std/index.js';
+import type { UCInput, UCOPIBase } from '../../uc/index.js';
+import type { ExtractStrict } from '../../utils/index.js';
+import type { AppTesterConfiguratorSideEffects } from '../AppTesterConfigurator.js';
+import type { UCExecutorExecOutput } from './UCExecutor.js';
+export type AppTestName = FreeTextShort;
+export type AppTestSuiteStatus = ExtractStrict<SemanticsVariant, 'danger' | 'success' | 'warning'>;
+export interface AppTestSuiteTestResult<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    name: AppTestName;
+    out: UCExecutorExecOutput<I, OPI0, OPI1>;
+    sideEffects: AppTesterConfiguratorSideEffects | undefined;
+    status: AppTestSuiteStatus;
+}
+export interface AppTestSuiteSummary {
+    counts: Record<AppTestSuiteStatus, UIntQuantity>;
+}
+export type AppTestSnapshot = {
+    default: Record<AppTestName, `\n"${JSONString}"\n`>;
+};
+export interface Input {
+    appPath: FilePath;
+    depsMapping?: Map<string, string>;
+    idx: NumIndex;
+    monkeyTestingTimeoutInMs: UIntDuration;
+    serverPortRangeStart: HostPort;
+}
+export interface Output {
+    outPath: FilePath;
+}
+export interface AppTestSuiteEmitter extends Worker<Input, Promise<Output>> {
+}

package/dist/esm/testing/workers/AppTestSuiteEmitter.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/testing/workers/AppTestSuiteRunner.d.ts

@@ -0,0 +1,10 @@
+import type { FilePath } from '../../dt/index.js';
+import type { Worker } from '../../std/index.js';
+export interface Input {
+    appPath: FilePath;
+    skipCoverage: boolean;
+    updateSnapshots: boolean;
+}
+export interface AppTestSuiteRunner extends Worker<Input, Promise<void>> {
+    coverageReportEntrypointPath(appPath: FilePath): Promise<FilePath>;
+}

package/dist/esm/testing/workers/AppTestSuiteRunner.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/testing/workers/AppTesterCtxInitializer.d.ts

@@ -0,0 +1,17 @@
+import type { FilePath } from '../../dt/index.js';
+import { type FSManager, type Worker } from '../../std/index.js';
+import type { UCDefSource } from '../../uc/index.js';
+import { type SrcImporter } from '../../utils/index.js';
+import type { AppTesterCtx } from '../ctx.js';
+export interface Input {
+    appPath: FilePath;
+    srcImporter: SrcImporter<UCDefSource>;
+}
+export interface Output {
+    ctx: AppTesterCtx;
+}
+export declare class AppTesterCtxInitializer implements Worker<Input, Promise<Output>> {
+    private fsManager;
+    constructor(fsManager: FSManager);
+    exec({ appPath, srcImporter }: Input): Promise<Output>;
+}

package/dist/esm/testing/workers/AppTesterCtxInitializer.js

@@ -0,0 +1,57 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Container, inject, injectable } from 'inversify';
+import { APP_I18N_FILE_NAME, APP_MANIFEST_FILE_NAME, APP_SRC_DIR_NAME, APP_SRC_UCDS_DIR_NAME, UC_DEF_FILE_NAME_SUFFIX, } from '../../convention.js';
+import { FSManagerItemInfoType, } from '../../std/index.js';
+import { CONTAINER_OPTS } from '../../utils/index.js';
+let AppTesterCtxInitializer = class AppTesterCtxInitializer {
+    fsManager;
+    constructor(fsManager) {
+        this.fsManager = fsManager;
+    }
+    async exec({ appPath, srcImporter }) {
+        const container = new Container(CONTAINER_OPTS);
+        const srcDirPath = this.fsManager.path(appPath, APP_SRC_DIR_NAME);
+        const { Manifest: appManifest } = await srcImporter(this.fsManager.path(srcDirPath, APP_MANIFEST_FILE_NAME));
+        const { I18n: appI18n } = await srcImporter(this.fsManager.path(srcDirPath, APP_I18N_FILE_NAME));
+        const ucdsPath = this.fsManager.path(srcDirPath, APP_SRC_UCDS_DIR_NAME);
+        const filePaths = await this.fsManager.ls(ucdsPath);
+        const ucdFilePaths = filePaths.filter(({ path, type }) => path.endsWith(UC_DEF_FILE_NAME_SUFFIX) &&
+            type === FSManagerItemInfoType.FILE);
+        const ucdRefs = [];
+        for await (const { path } of ucdFilePaths) {
+            ucdRefs.push({
+                fileName: path,
+                source: await srcImporter(this.fsManager.path(ucdsPath, path)),
+                name: path.replace(UC_DEF_FILE_NAME_SUFFIX, ''),
+            });
+        }
+        ucdRefs.sort((a, b) => a.name.localeCompare(b.name));
+        return {
+            ctx: {
+                appI18n,
+                appManifest,
+                appPath,
+                container,
+                opts: undefined,
+                ucdRefs,
+            },
+        };
+    }
+};
+AppTesterCtxInitializer = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __metadata("design:paramtypes", [Object])
+], AppTesterCtxInitializer);
+export { AppTesterCtxInitializer };

package/dist/esm/testing/workers/UCExecutor.d.ts

@@ -0,0 +1,45 @@
+import type { AppManifest } from '../../app/index.js';
+import type { ErrorMessage } from '../../dt/index.js';
+import type { CryptoManager, CryptoManagerHash, Worker } from '../../std/index.js';
+import { type UCAuth, UCBuilder, type UCDef, type UCInput, type UCManager, type UCOPIBase, type UCOutput } from '../../uc/index.js';
+import type { UCAuthSetterName } from '../uc-auth.js';
+import type { UCInputFiller, UCInputFillerName } from '../uc-input.js';
+export type UCExecutorAssertion<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (exec: UCExecutorExecOutput<I, OPI0, OPI1>) => boolean;
+export interface UCExecutorExecOutput<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    args: Pick<Input<I, OPI0, OPI1>, 'auth' | 'authName' | 'inputFiller' | 'inputFillerName'>;
+    err: Error | null;
+    hash: CryptoManagerHash | null;
+    io: {
+        i: I | null;
+        o: UCOutput<OPI0, OPI1> | null;
+    };
+}
+export type UCExecutorExecOutputSerialized<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = Omit<UCExecutorExecOutput<I, OPI0, OPI1>, 'err'> & {
+    err: {
+        message?: ErrorMessage;
+        name: 'CustomError' | 'Error' | 'TypeError' | (string & {});
+    } | null;
+};
+export interface Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    appManifest: AppManifest;
+    auth: UCAuth | null;
+    authName: UCAuthSetterName;
+    inputFiller: UCInputFiller<I, OPI0, OPI1>;
+    inputFillerName: UCInputFillerName;
+    ucd: UCDef<I, OPI0, OPI1>;
+}
+export interface Output<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    out: UCExecutorExecOutput<I, OPI0, OPI1>;
+}
+export declare class UCExecutor implements Worker<Input, Promise<Output>> {
+    private cryptoManager;
+    private ucBuilder;
+    private ucManager;
+    private static HASH_ALG;
+    private static HASH_BTT_ENCODING;
+    private static HASH_SEP;
+    constructor(cryptoManager: CryptoManager, ucBuilder: UCBuilder, ucManager: UCManager);
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ appManifest, auth, authName, inputFiller, inputFillerName, ucd, }: Input<I, OPI0, OPI1>): Promise<Output<I, OPI0, OPI1>>;
+    overrideUCManager(ucManager: UCManager): void;
+    private execClient;
+}