testeranto 0.90.0 → 0.100.0

package/dist/types/src/Node.d.ts

@@ -1,10 +1,13 @@
 import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
 import type { IBaseTest, ITestImplementation, ITestSpecification } from "./Types.js";
-import { ITestInterface, INodeTestInterface } from "./lib/types.js";
+import { ITestInterface } from "./lib/types.js";
 export declare class NodeTesteranto<TestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> extends Testeranto<TestShape> {
     constructor(input: TestShape["iinput"], testSpecification: ITestSpecification<TestShape>, testImplementation: ITestImplementation<TestShape>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<TestShape>>);
-    receiveTestResourceConfig(partialTestResource: string): Promise<string[]>;
+    receiveTestResourceConfig(partialTestResource: string): Promise<{
+        features: string[];
+        failed: number;
+    }>;
 }
-declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testInterface: Partial<INodeTestInterface<ITestShape>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
+declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: any, testInterface: INodeTestInterface<ITestShape>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
 export default _default;

package/dist/types/src/PM/index.d.ts

@@ -1,3 +1,5 @@
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser";
+import { ScreenRecorderOptions } from "puppeteer-core/lib/esm/puppeteer";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 export declare abstract class PM {
     server: any;
@@ -13,8 +15,9 @@ export declare abstract class PM {
     abstract end(accessObject: {
         uid: number;
     }): boolean;
-    abstract customScreenShot(opts: object): any;
-    abstract screencast(opts: object): any;
+    abstract customScreenShot(opts: object, page?: string): any;
+    abstract screencast(opts: ScreenRecorderOptions, p?: any): any;
+    abstract screencastStop(s: string): any;
     abstract page(): string | undefined;
     abstract click(selector: string): any;
     abstract focusOn(selector: string): any;
@@ -23,4 +26,9 @@ export declare abstract class PM {
     abstract getAttribute(selector: string, attribute: string): any;
     abstract isDisabled(selector: string): boolean;
     abstract $(selector: string): any;
+    abstract newPage(): CdpPage;
+    abstract goto(p: any, url: string): any;
+    abstract closePage(p: any): any;
+    abstract waitForSelector(p: any, sel: string): any;
+    abstract customclose(): any;
 }

package/dist/types/src/PM/main.d.ts

@@ -1,12 +1,13 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
+import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
 import fs from "fs";
-import { Browser } from "puppeteer-core";
+import { Browser, LaunchOptions } from "puppeteer-core";
 import { PassThrough } from "stream";
 import { IBuiltConfig, ITestTypes } from "../lib/types";
-import { PM } from "./index.js";
 import { ITLog } from "../lib/index.js";
+import { PM } from "./index.js";
 export declare class PM_Main extends PM {
     browser: Browser;
     shutdownMode: boolean;
@@ -15,9 +16,14 @@ export declare class PM_Main extends PM {
     queue: any[];
     registry: Record<string, boolean>;
     constructor(configs: IBuiltConfig);
+    customclose(): void;
+    waitForSelector(p: string, s: string): any;
+    closePage(p: any): any;
+    newPage(): CdpPage;
+    goto(p: any, url: string): any;
     $(selector: string): boolean;
     screencast(opts: object): void;
-    customScreenShot(opts: object): void;
+    customScreenShot(opts: object, cdpPage?: CdpPage): void;
     end(accessObject: {
         uid: number;
     }): boolean;
@@ -36,14 +42,15 @@ export declare class PM_Main extends PM {
     getValue(value: string): void;
     getAttribute(selector: string, attribute: string): void;
     isDisabled(selector: string): boolean;
-    startPuppeteer(options: any, destfolder: string): Promise<any>;
+    screencastStop(s: string): void;
+    startPuppeteer(options: LaunchOptions, destfolder: string): Promise<any>;
     shutDown(): void;
     checkForShutdown: () => void;
     register: (src: string) => void;
     deregister: (src: string) => void;
     launchNode: (src: string, dest: string) => Promise<void>;
-    launchWebSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<unknown>;
+    launchWebSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<Page>;
     launchNodeSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<void>;
-    launchWeb: (t: string, dest: string, sidecars: ITestTypes[]) => void;
-    receiveFeatures: (features: string[], destFolder: string) => void;
+    launchWeb: (t: string, dest: string) => void;
+    receiveFeatures: (features: string[], destFolder: string, srcTest: string) => void;
 }

package/dist/types/src/PM/node.d.ts

@@ -1,15 +1,20 @@
 /// <reference types="node" />
 /// <reference types="node" />
+import { ScreencastOptions } from "puppeteer-core";
 import { PassThrough } from "stream";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 import { PM } from "./index.js";
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
 declare type PuppetMasterServer = Record<string, Promise<any>>;
 export declare class PM_Node extends PM {
     server: PuppetMasterServer;
     testResourceConfiguration: ITTestResourceConfiguration;
     constructor(t: ITTestResourceConfiguration);
+    waitForSelector(p: string, s: string): any;
+    closePage(p: any): string;
+    goto(cdpPage: CdpPage, url: string): any;
+    newPage(): CdpPage;
     $(selector: string): boolean;
-    screencast(opts: object): void;
     isDisabled(selector: string): boolean;
     getAttribute(selector: string, attribute: string): void;
     getValue(selector: string): void;
@@ -17,7 +22,9 @@ export declare class PM_Node extends PM {
     typeInto(value: string): void;
     page(): any;
     click(selector: string): string | undefined;
-    customScreenShot(opts: object): any;
+    screencast(opts: ScreencastOptions, page: CdpPage): any;
+    screencastStop(p: string): any;
+    customScreenShot(opts: ScreencastOptions, cdpPage: CdpPage): any;
     existsSync(destFolder: string): boolean;
     mkdirSync(): any;
     write(writeObject: {

package/dist/types/src/PM/web.d.ts

@@ -3,13 +3,19 @@
 import { PassThrough } from "stream";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 import { PM } from "./index.js";
-import { ScreenshotOptions } from "puppeteer-core";
+import { ScreencastOptions, ScreenshotOptions } from "puppeteer-core";
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
 declare type PuppetMasterServer = Record<string, Promise<any>>;
 export declare class PM_Web extends PM {
     server: PuppetMasterServer;
     constructor(t: ITTestResourceConfiguration);
+    waitForSelector(p: string, s: string): any;
+    screencast(opts: ScreencastOptions): any;
+    screencastStop(recorder: string): any;
+    closePage(p: any): string;
+    goto(p: any, url: string): any;
+    newPage(): CdpPage;
     $(selector: string): boolean;
-    screencast(opts: object): void;
     isDisabled(selector: string): boolean;
     getAttribute(selector: string, attribute: string): any;
     getValue(selector: string): any;
@@ -19,7 +25,7 @@ export declare class PM_Web extends PM {
     click(selector: string): any;
     customScreenShot(opts: ScreenshotOptions): any;
     existsSync(destFolder: string): boolean;
-    mkdirSync(): any;
+    mkdirSync(x: any): any;
     write(writeObject: {
         uid: number;
     }, contents: string): any;

package/dist/types/src/SubPackages/puppeteer.d.ts

@@ -2,5 +2,5 @@ import { IBaseTest, IPartialNodeInterface, ITestImplementation, ITestSpecificati
 declare type IInput = string;
 export declare type IImpl<ISpec extends IBaseTest> = ITestImplementation<ISpec>;
 export declare type ISpec<T extends IBaseTest> = ITestSpecification<T>;
-declare const _default: <ITestShape extends any>(testInput: IInput, testSpecifications: ISpec<ITestShape>, testImplementations: ITestImplementation<ITestShape, object>, testInterface?: Partial<import("../lib/types.js").INodeTestInterface<ITestShape>> | undefined) => Promise<import("../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any>(testInput: IInput, testSpecifications: ISpec<ITestShape>, testImplementations: any, testInterface?: Partial<import("../Types").INodeTestInterface<ITestShape>> | undefined) => Promise<import("../lib/core.js").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react/component/node.d.ts

@@ -3,5 +3,5 @@ import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Typ
 declare type IInput = typeof React.Component;
 export declare type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<ISpec, object>;
 export declare type ISpec<T extends IBaseTest> = ITestSpecification<T>;
-declare const _default: <ITestShape extends any, IState>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any, IState>(testImplementations: any, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react/component/web.d.ts

@@ -3,5 +3,5 @@ import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Typ
 declare type IInput = typeof React.Component;
 export declare type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<ISpec, object>;
 export declare type ISpec<T extends IBaseTest> = ITestSpecification<T>;
-declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react/jsx/node.d.ts

@@ -1,4 +1,4 @@
-import { IPartialInterface } from "../../../Types";
-import { ITestImpl, ITestSpec, IInput } from "./index.js";
-declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface: Partial<import("../../../lib/types.js").ITestInterface<ITestShape>>) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+import { IBaseTest, IPartialInterface } from "../../../Types";
+import { ITestSpec, IInput } from "./index.js";
+declare const _default: <ITestShape extends IBaseTest<IInput, number, number, number, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: any, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface?: Partial<import("../../../Types").ITestInterface<ITestShape>>) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react/jsx/web.d.ts

@@ -1,4 +1,4 @@
 import { IPartialWebInterface } from "../../../Types";
-import { ITestImpl, ITestSpec, IInput } from "./index.js";
-declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface: Partial<import("../../../lib/types").IWebTestInterface<ITestShape>>) => Promise<import("../../../lib/core").default<ITestShape>>;
+import { ITestSpec, IInput } from "./index.js";
+declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface: Partial<import("../../../Types").IWebTestInterface<ITestShape>>) => Promise<import("../../../lib/core").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react-dom/component/node.d.ts

@@ -1,12 +1,12 @@
 import React, { ReactNode } from "react";
 import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
 import Stream from "stream";
-import { ITestImplementation, ITestSpecification } from "../../../Types";
+import { ITestSpecification } from "../../../Types";
 declare type IInput = typeof React.Component;
 export declare type IThenShape = any;
 export declare type ISelection = ReactNode;
 export declare type IStore = ReactNode;
 export declare type ISubject = ReactNode;
 export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
-declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react-dom/component/web.d.ts

@@ -7,5 +7,5 @@ export declare type IStore = {
     reactElement: any;
     domRoot: ReactDom.Root;
 };
-declare const _default: <ITestShape extends any, IWhen, IGiven>(testInput: IInput, testSpecifications: ITestSpecification<ITestShape>, testImplementations: any, testInterface?: IPartialWebInterface<any>) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any, IWhen, IGiven>(testInput: IInput, testSpecifications: ITestSpecification<ITestShape>, testImplementations: ITestImplementation<ITestShape, any>, testInterface?: IPartialWebInterface<any>) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react-dom/jsx/node.d.ts

@@ -2,5 +2,5 @@ import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server
 import Stream from 'stream';
 import { ITestImplementation, ITestSpecification } from "../../../Types";
 export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
-declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpecification<ITestShape>, testInput: ITestShape["iinput"]) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, any>, testSpecifications: ITestSpecification<ITestShape>, testInput: ITestShape["iinput"]) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react-dom/jsx/web.d.ts

@@ -1,5 +1,5 @@
-import { ITestImplementation, ITestSpecification } from "../../../Types";
+import { ITestSpecification } from "../../../Types";
 import type { IInput } from "./index";
 export declare type ISubject = HTMLElement;
-declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react-test-renderer/MemoExoticComponent/node.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { ITestImplementation, ITestSpecification } from "../../../Types";
+import { ITestSpecification } from "../../../Types";
 declare type IInput = React.MemoExoticComponent<() => JSX.Element>;
-declare const _default: <ITestShape extends any, PropShape>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
+declare const _default: <ITestShape extends any, PropShape>(testImplementations: any, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react-test-renderer/component/interface.d.ts

@@ -1,7 +1,7 @@
 import renderer from "react-test-renderer";
 import { ISelection, IStore } from ".";
 export declare const testInterface: {
-    beforeEach: (CComponent: any, propsAndChildren: any) => Promise<renderer.ReactTestRenderer>;
+    beforeEach: (CComponent: any, propsAndChildren: () => any) => Promise<renderer.ReactTestRenderer>;
     andWhen: (renderer: renderer.ReactTestRenderer, whenCB: any) => Promise<renderer.ReactTestRenderer>;
     butThen: (s: IStore, thenCB: any, tr: any) => Promise<ISelection>;
     afterEach: (store: IStore, ndx: any, artificer: any) => Promise<{}>;

package/dist/types/src/SubPackages/react-test-renderer/component/node.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
-import { IImpl, ISpec, IInput } from "./index.js";
-declare const _default: <ITestShape extends any, IProps, IState>(testImplementations: IImpl<ITestShape>, testSpecifications: ISpec<ITestShape>, testInput: {
+import { ISpec, IInput } from "./index.js";
+declare const _default: <ITestShape extends any, IProps, IState>(testImplementations: any, testSpecifications: ISpec<ITestShape>, testInput: {
     new (props: IProps | Readonly<IProps>): import("react").Component<IProps, IState, any>;
     new (props: IProps, context: any): import("react").Component<IProps, IState, any>;
     contextType?: import("react").Context<any> | undefined;

package/dist/types/src/SubPackages/react-test-renderer/component/web.d.ts

@@ -1,3 +1,3 @@
-import { IImpl, ISpec, IInput } from "./index.js";
-declare const _default: <ITestShape extends any, IProps, IState>(testImplementations: IImpl<ITestShape>, testSpecifications: ISpec<ITestShape>, testInput: IInput<any, any>) => Promise<import("../../../lib/core").default<ITestShape>>;
+import { ISpec, IInput } from "./index.js";
+declare const _default: <ITestShape extends any, IProps, IState>(testImplementations: any, testSpecifications: ISpec<ITestShape>, testInput: IInput<any, any>) => Promise<import("../../../lib/core").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react-test-renderer/fc/node.d.ts

@@ -1,8 +1,8 @@
 import React from "react";
-import { ITestSpecification, ITestImplementation, IBaseTest } from "../../../Types";
+import { ITestSpecification, IBaseTest } from "../../../Types";
 export declare type IInput = React.FC;
 export declare type IWhenShape = unknown;
 export declare type IThenShape = unknown;
 export declare type ISpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
-declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react-test-renderer/fc/web.d.ts

@@ -1,8 +1,8 @@
 import React from "react";
-import { ITestSpecification, ITestImplementation, IBaseTest } from "../../../Types";
+import { ITestSpecification, IBaseTest } from "../../../Types";
 export declare type IInput = React.FC;
 export declare type IWhenShape = unknown;
 export declare type IThenShape = unknown;
 export declare type ISpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
-declare const _default: <ITestShape extends any, IPropShape>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
+declare const _default: <ITestShape extends any, IPropShape>(testImplementations: any, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react-test-renderer/jsx/node.d.ts

@@ -1,6 +1,7 @@
-import type { ITestImpl, ITestSpec } from "../jsx-promised";
+import { IBaseTest } from "../../../Types";
+import type { ITestSpec } from "../jsx-promised";
 import { IInput } from "./index.js";
-declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface2?: {
+declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(testImplementations: any, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface2?: {
     butThen: (s: import("react-test-renderer").ReactTestRenderer, thenCB: any, tr: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
     beforeEach: (CComponent: any, props: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
     andWhen: (renderer: import("react-test-renderer").ReactTestRenderer, whenCB: (any: any) => any) => Promise<import("react-test-renderer").ReactTestRenderer>;

package/dist/types/src/SubPackages/react-test-renderer/jsx/web.d.ts

@@ -1,6 +1,6 @@
-import { ITestImpl, ITestSpec } from "../jsx-promised";
+import { ITestSpec } from "../jsx-promised";
 import { IInput } from "./index.js";
-declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface2?: {
+declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface2?: {
     butThen: (s: import("react-test-renderer").ReactTestRenderer, thenCB: any, tr: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
     beforeEach: (CComponent: any, props: any) => Promise<import("react-test-renderer").ReactTestRenderer>;
     andWhen: (renderer: import("react-test-renderer").ReactTestRenderer, whenCB: (any: any) => any) => Promise<import("react-test-renderer").ReactTestRenderer>;

package/dist/types/src/SubPackages/react-test-renderer/jsx-promised/node.d.ts

@@ -1,4 +1,4 @@
 import { IInput } from ".";
-import { ITestImpl, ITestSpec } from "../../react/jsx";
-declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
+import { ITestSpec } from "../../react/jsx";
+declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react-test-renderer/jsx-promised/web.d.ts

@@ -1,4 +1,4 @@
-import { ITestImpl, ITestSpec } from "../../react/jsx";
+import { ITestSpec } from "../../react/jsx";
 import { IInput } from "./index";
-declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
+declare const _default: <ITestShape extends any>(testImplementations: any, testSpecifications: ITestSpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
 export default _default;

package/dist/types/src/Types.d.ts

@@ -1,39 +1,63 @@
-import { ITTestResourceRequest, ITestCheckCallback } from "./lib/index.js";
+import { ITTestResourceConfiguration, ITestArtificer, ITestCheckCallback } from "./lib/index.js";
 import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen, BaseGiven } from "./lib/abstractBase.js";
-import Testeranto from "./lib/core.js";
-import { INodeTestInterface, ITestInterface, IWebTestInterface } from "./lib/types.js";
 import { PM } from "./PM/index.js";
-export declare type IPartialInterface<I extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = Partial<ITestInterface<I>>;
-export declare type IPartialNodeInterface<I extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = Partial<INodeTestInterface<I>>;
+export declare type IWebTestInterface<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = {
+    assertThis: (x: ITestShape["then"]) => void;
+    andWhen: (store: ITestShape["istore"], whenCB: ITestShape["when"], testResource: ITTestResourceConfiguration, utils: PM) => Promise<ITestShape["istore"]>;
+    butThen: (store: ITestShape["istore"], thenCB: any, testResource: ITTestResourceConfiguration, utils: PM) => Promise<ITestShape["iselection"]>;
+    afterAll: (store: ITestShape["istore"], artificer: ITestArtificer, utils: PM) => any;
+    afterEach: (store: ITestShape["istore"], key: string, artificer: ITestArtificer, utils: PM) => Promise<unknown>;
+    beforeAll: (input: ITestShape["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, utils: PM) => Promise<ITestShape["isubject"]>;
+    beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any, utils: PM) => Promise<ITestShape["istore"]>;
+};
+export declare type INodeTestInterface<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = {
+    assertThis: (x: I["then"]) => void;
+    andWhen: (store: I["istore"], whenCB: I["when"], testResource: ITTestResourceConfiguration, utils: PM) => Promise<I["istore"]>;
+    butThen: (store: I["istore"], thenCB: any, testResource: ITTestResourceConfiguration, utils: PM) => Promise<I["iselection"]>;
+    afterAll: (store: I["istore"], artificer: ITestArtificer, pm: PM) => any;
+    afterEach: (store: I["istore"], key: string, artificer: ITestArtificer, pm: PM) => Promise<unknown>;
+    beforeAll: (input: I["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, pm: PM) => Promise<I["isubject"]>;
+    beforeEach: (subject: I["isubject"], initializer: (c?: any) => I["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any, pm: PM) => Promise<I["istore"]>;
+};
+export declare type ITestInterface<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = {
+    assertThis: (x: I["then"]) => void;
+    andWhen: (store: I["istore"], whenCB: I["when"], testResource: ITTestResourceConfiguration, pm: PM) => Promise<I["istore"]>;
+    butThen: (store: I["istore"], thenCB: I["then"], testResource: ITTestResourceConfiguration, pm: PM) => Promise<I["iselection"]>;
+    afterAll: (store: I["istore"], artificer: ITestArtificer, pm: PM) => any;
+    afterEach: (store: I["istore"], key: string, artificer: ITestArtificer, pm: PM) => Promise<unknown>;
+    beforeAll: (input: I["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, pm: PM) => Promise<I["isubject"]>;
+    beforeEach: (subject: I["isubject"], initializer: (c?: any) => I["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any, pm: PM) => Promise<I["istore"]>;
+};
+export declare type IPartialInterface<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = Partial<ITestInterface<I>>;
+export declare type IPartialNodeInterface<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = Partial<INodeTestInterface<I>>;
 export declare type IPartialWebInterface<I extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = Partial<IWebTestInterface<I>>;
-export declare type IEntry<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = (input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testInterface: IPartialInterface<ITestShape>, testResourceRequirement: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
-export declare type ITestSpecification<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = (Suite: {
-    [K in keyof ITestShape["suites"]]: (name: string, givens: IGivens<ITestShape>, checks: BaseCheck<ITestShape>[]) => BaseSuite<ITestShape>;
+export declare type ITestSpecification<I extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = (Suite: {
+    [K in keyof I["suites"]]: (name: string, givens: IGivens<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>, checks: BaseCheck<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>[]) => BaseSuite<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>;
 }, Given: {
-    [K in keyof ITestShape["givens"]]: (features: string[], whens: BaseWhen<ITestShape>[], thens: BaseThen<ITestShape>[], ...xtrasB: ITestShape["givens"][K]) => BaseGiven<ITestShape>;
+    [K in keyof I["givens"]]: (features: string[], whens: BaseWhen<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>[], thens: BaseThen<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>[], ...xtrasB: I["givens"][K]) => BaseGiven<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>;
 }, When: {
-    [K in keyof ITestShape["whens"]]: (...xtrasC: ITestShape["whens"][K]) => BaseWhen<ITestShape>;
+    [K in keyof I["whens"]]: (...xtrasC: I["whens"][K]) => BaseWhen<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>;
 }, Then: {
-    [K in keyof ITestShape["thens"]]: (...xtrasD: ITestShape["thens"][K]) => BaseThen<ITestShape>;
-}, Check: ITestCheckCallback<ITestShape>) => any[];
-export declare type ITestImplementation<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>, IMod = object> = Modify<{
+    [K in keyof I["thens"]]: (...xtrasD: I["thens"][K]) => BaseThen<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>;
+}, Check: ITestCheckCallback<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>) => any[];
+export declare type ITestImplementation<IN extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, OUT extends Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = {
     suites: {
-        [K in keyof ITestShape["suites"]]: string;
+        [K in keyof OUT["suites"]]: string;
     };
     givens: {
-        [K in keyof ITestShape["givens"]]: (...Ig: ITestShape["givens"][K]) => ITestShape["given"];
+        [K in keyof OUT["givens"]]: (...Ig: OUT["givens"][K]) => IN["given"];
     };
     whens: {
-        [K in keyof ITestShape["whens"]]: (...Iw: ITestShape["whens"][K]) => (zel: ITestShape["iselection"], utils: PM) => Promise<ITestShape["when"]>;
+        [K in keyof OUT["whens"]]: (...Iw: OUT["whens"][K]) => (zel: IN["iselection"], utils: PM) => Promise<IN["when"]>;
     };
     thens: {
-        [K in keyof ITestShape["thens"]]: (...It: ITestShape["thens"][K]) => (ssel: ITestShape["iselection"], utils: PM) => ITestShape["then"];
+        [K in keyof OUT["thens"]]: (...It: OUT["thens"][K]) => (ssel: IN["iselection"], utils: PM) => IN["then"];
     };
     checks: {
-        [K in keyof ITestShape["checks"]]: (...Ic: ITestShape["checks"][K]) => ITestShape["given"];
+        [K in keyof OUT["checks"]]: (...Ic: OUT["checks"][K]) => IN["given"];
     };
-}, IMod>;
-declare type Modify<T, R> = Omit<T, keyof R> & R;
+};
+export declare type Modify<T, R> = Omit<T, keyof R> & R;
 export declare type IBaseTest<IInput, ISubject, IStore, ISelection, IGiven, IWhen, IThen, ISuites extends Record<string, any>, IGivens extends Record<string, any>, IWhens extends Record<string, any>, IThens extends Record<string, any>, IChecks extends Record<string, any>> = {
     iinput: IInput;
     isubject: ISubject;
@@ -48,4 +72,19 @@ export declare type IBaseTest<IInput, ISubject, IStore, ISelection, IGiven, IWhe
     thens: IThens;
     checks: IChecks;
 };
-export {};
+export declare type Ibdd_out<ISuites extends Record<string, any>, IGivens extends Record<string, any>, IWhens extends Record<string, any>, IThens extends Record<string, any>, IChecks extends Record<string, any>> = {
+    suites: ISuites;
+    givens: IGivens;
+    whens: IWhens;
+    thens: IThens;
+    checks: IChecks;
+};
+export declare type Ibdd_in<IInput, ISubject, IStore, ISelection, IGiven, IWhen, IThen> = {
+    iinput: IInput;
+    isubject: ISubject;
+    istore: IStore;
+    iselection: ISelection;
+    given: IGiven;
+    when: IWhen;
+    then: IThen;
+};

package/dist/types/src/Web.d.ts

@@ -1,10 +1,10 @@
 import type { IBaseTest, ITestImplementation, ITestSpecification } from "./Types";
 import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
-import { ITestInterface, IWebTestInterface } from "./lib/types";
+import { IFinalResults, ITestInterface } from "./lib/types";
 export declare class WebTesteranto<TestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> extends Testeranto<TestShape> {
     constructor(input: TestShape["iinput"], testSpecification: ITestSpecification<TestShape>, testImplementation: ITestImplementation<TestShape>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<TestShape>>);
-    receiveTestResourceConfig(partialTestResource: any): Promise<string[]>;
+    receiveTestResourceConfig(partialTestResource: any): Promise<IFinalResults>;
 }
-declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testInterface: Partial<IWebTestInterface<ITestShape>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
+declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: any, testInterface: IWebTestInterface<ITestShape>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
 export default _default;

package/dist/types/src/lib/abstractBase.d.ts

@@ -15,6 +15,7 @@ export declare abstract class BaseSuite<ITestShape extends IBaseTest<unknown, un
     toObj(): {
         name: string;
         givens: {
+            key: string;
             name: string;
             whens: {
                 name: string;
@@ -46,9 +47,11 @@ export declare abstract class BaseGiven<ITestShape extends IBaseTest<unknown, un
     recommendedFsPath: string;
     givenCB: ITestShape["given"];
     initialValues: any;
+    key: string;
     constructor(name: string, features: string[], whens: BaseWhen<ITestShape>[], thens: BaseThen<ITestShape>[], givenCB: ITestShape["given"], initialValues: any);
-    beforeAll(store: ITestShape["istore"], artifactory: ITestArtifactory): ITestShape["istore"];
+    beforeAll(store: ITestShape["istore"], initializer: any, artifactory: any, testResource: any, initialValues: any, pm: any): ITestShape["istore"];
     toObj(): {
+        key: string;
         name: string;
         whens: {
             name: string;
@@ -61,8 +64,9 @@ export declare abstract class BaseGiven<ITestShape extends IBaseTest<unknown, un
         error: (string | Error | undefined)[] | null;
         features: string[];
     };
-    abstract givenThat(subject: ITestShape["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: ITestShape["given"], pm: PM): Promise<ITestShape["istore"]>;
+    abstract givenThat(subject: ITestShape["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: ITestShape["given"], initialValues: any, pm: PM): Promise<ITestShape["istore"]>;
     afterEach(store: ITestShape["istore"], key: string, artifactory: ITestArtifactory, pm: PM): Promise<unknown>;
+    abstract uberCatcher(e: any): any;
     give(subject: ITestShape["isubject"], key: string, testResourceConfiguration: ITTestResourceConfiguration, tester: (t: Awaited<ITestShape["then"]> | undefined) => boolean, artifactory: ITestArtifactory, tLog: ITLog, pm: PM, suiteNdx: number): Promise<ITestShape["istore"]>;
 }
 export declare abstract class BaseWhen<ITestShape extends IBaseTest> {

package/dist/types/src/lib/core.d.ts

@@ -1,8 +1,8 @@
 import { IBaseTest, ITestSpecification, ITestImplementation } from "../Types.js";
-import { ITestInterface } from "./types.js";
+import { IFinalResults, ITestInterface } from "./types.js";
 import { ITTestResourceRequest } from "./index.js";
 import { ClassBuilder } from "./classBuilder.js";
 export default abstract class Testeranto<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> extends ClassBuilder<ITestShape> {
-    constructor(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape>, testResourceRequirement: ITTestResourceRequest | undefined, testInterface: Partial<ITestInterface<ITestShape>>);
-    abstract receiveTestResourceConfig(partialTestResource: string): Promise<string[]>;
+    constructor(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape>, testResourceRequirement: ITTestResourceRequest | undefined, testInterface: Partial<ITestInterface<ITestShape>>, uberCatcher: (cb: any) => void);
+    abstract receiveTestResourceConfig(partialTestResource: string): Promise<IFinalResults>;
 }

package/dist/types/src/lib/index.d.ts

@@ -3,7 +3,7 @@ import { IBaseTest } from "../Types.js";
 import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen } from "./abstractBase.js";
 import { ITestInterface } from "./types.js";
 export declare const BaseTestInterface: ITestInterface<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>;
-export declare const DefaultTestInterface: (p: Partial<ITestInterface<any>>) => ITestInterface<any>;
+export declare const DefaultTestInterface: (p: ITestInterface<any>) => ITestInterface<any>;
 export declare type ITTestResourceConfiguration = {
     name: string;
     fs: string;