testeranto 0.74.0 → 0.79.0

package/dist/types/build-tests.d.ts

@@ -0,0 +1,3 @@
+import { ITProject } from "./src/Project";
+declare const _default: ITProject;
+export default _default;

package/dist/types/init-docs.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Promise<void>;
+export default _default;

package/dist/types/run-tests.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Promise<void>;
+export default _default;

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

@@ -0,0 +1 @@
+export declare const execCommand: (command: any) => Promise<void>;

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

@@ -0,0 +1,2 @@
+declare const _default: (partialConfig: any) => Promise<void>;
+export default _default;

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

@@ -0,0 +1,6 @@
+import Testeranto from "./lib/core.js";
+import { ITTestResourceRequest } from "./lib/index.js";
+import type { IBaseTest, ITestImplementation, ITestSpecification } from "./Types.js";
+import { INodeTestInterface } from "./lib/types.js";
+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>>;
+export default _default;

package/dist/types/{PM → src/PM}/index.d.ts

@@ -1,4 +1,4 @@
-import { Browser } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser";
+import { Browser, Page } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 export declare abstract class PM {
     server: any;
@@ -8,7 +8,7 @@ export declare abstract class PM {
     abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): any;
     abstract createWriteStream(filepath: string): any;
     abstract writeFileSync(fp: string, contents: string): any;
-    abstract mkdirSync(): any;
+    abstract mkdirSync(a: string): any;
     abstract existsSync(fp: string): boolean;
     abstract write(accessObject: {
         uid: number;
@@ -16,4 +16,5 @@ export declare abstract class PM {
     abstract end(accessObject: {
         uid: number;
     }): boolean;
+    abstract customScreenShot(opts: object, page: Page): any;
 }

package/dist/types/{PM → src/PM}/main.d.ts

@@ -1,17 +1,22 @@
 /// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 import fs from "fs";
 import { PassThrough } from "stream";
-import { ITLog } from "../lib";
-import { IBuiltConfig } from "../lib/types";
+import { IBuiltConfig, ITestTypes } from "../lib/types";
 import { PM } from "./index.js";
+import { ITLog } from "../lib/index.js";
 export declare class PM_Main extends PM {
+    customScreenShot(opts: object): void;
     configs: IBuiltConfig;
     ports: Record<number, boolean>;
     queue: any[];
     constructor(configs: IBuiltConfig);
     startPuppeteer(options: any, destfolder: string): Promise<any>;
     launchNode: (src: string, dest: string) => Promise<void>;
-    launchWeb: (t: string, dest: string) => void;
+    launchWebSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<unknown>;
+    launchNodeSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<void>;
+    launchWeb: (t: string, dest: string, sidecars: ITestTypes[]) => void;
     end(accessObject: {
         uid: number;
     }): boolean;

package/dist/types/{PM → src/PM}/node.d.ts

@@ -3,11 +3,13 @@
 import { PassThrough } from "stream";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 import { PM } from "./index.js";
+import { Page } 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);
+    customScreenShot(opts: object, page: Page): any;
     existsSync(destFolder: string): boolean;
     mkdirSync(): any;
     write(writeObject: {

package/dist/types/{PM → src/PM}/web.d.ts

@@ -7,6 +7,7 @@ declare type PuppetMasterServer = Record<string, Promise<any>>;
 export declare class PM_Web extends PM {
     server: PuppetMasterServer;
     constructor(t: ITTestResourceConfiguration);
+    customScreenShot(opts: object): void;
     existsSync(destFolder: string): boolean;
     mkdirSync(): any;
     write(writeObject: {

package/dist/types/{Project.d.ts → src/Project.d.ts}

@@ -2,6 +2,6 @@ import { IBaseConfig, IRunTime } from "./lib/types.js";
 export declare class ITProject {
     config: IBaseConfig;
     mode: `up` | `down`;
-    constructor(config: IBaseConfig);
+    constructor(configs: IBaseConfig);
     getSecondaryEndpointsPoints(runtime?: IRunTime): string[];
 }

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

@@ -0,0 +1,2 @@
+declare const _default: (partialConfig: any) => Promise<void>;
+export default _default;

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

@@ -0,0 +1,6 @@
+import { IBaseTest, IPartialNodeInterface, ITestImplementation, ITestSpecification } from "../Types";
+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>>;
+export default _default;

package/dist/types/{SubPackages → 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 IBaseTest<any, 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: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

package/dist/types/{SubPackages → 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 IBaseTest<any, any>>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, object>, 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

@@ -0,0 +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>>;
+export default _default;

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

@@ -0,0 +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>>;
+export default _default;

package/dist/types/{SubPackages → 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 { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+import { ITestImplementation, 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 IBaseTest<any, any>>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, object>, 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

@@ -0,0 +1,11 @@
+import React from "react";
+import ReactDom from "react-dom/client";
+import { IPartialWebInterface, ITestImplementation, ITestSpecification } from "../../../Types";
+declare type IInput = typeof React.Component;
+export declare type IStore = {
+    htmlElement: HTMLElement;
+    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>>;
+export default _default;

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

@@ -0,0 +1,6 @@
+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>>;
+export default _default;

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

@@ -0,0 +1,5 @@
+import { ITestImplementation, 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>>;
+export default _default;

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

@@ -0,0 +1,5 @@
+import React from "react";
+import { ITestImplementation, 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>>;
+export default _default;

package/dist/types/{SubPackages → src/SubPackages}/react-test-renderer/component/index.d.ts

@@ -11,10 +11,3 @@ export declare type IStore = renderer.ReactTestRenderer;
 export declare type ISubject = renderer.ReactTestRenderer;
 export declare type IImpl<ITestShape extends IBaseTest> = ITestImplementation<ITestShape>;
 export declare type ISpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
-export declare const testInterface: {
-    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<{}>;
-    afterAll: (store: IStore, artificer: any) => void;
-};

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

@@ -0,0 +1,9 @@
+import renderer from "react-test-renderer";
+import { ISelection, IStore } from ".";
+export declare const testInterface: {
+    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<{}>;
+    afterAll: (store: IStore, artificer: any) => void;
+};

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

@@ -1,7 +1,6 @@
 /// <reference types="react" />
-import type { IBaseTest } from "../../../Types";
 import { IImpl, ISpec, IInput } from "./index.js";
-declare const _default: <ITestShape extends IBaseTest<any, any>, IProps, IState>(testImplementations: IImpl<ITestShape>, testSpecifications: ISpec<ITestShape>, testInput: {
+declare const _default: <ITestShape extends any, IProps, IState>(testImplementations: IImpl<ITestShape>, 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

@@ -0,0 +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>>;
+export default _default;

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

@@ -4,5 +4,5 @@ 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 IBaseTest<any, any>>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

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

@@ -4,5 +4,5 @@ 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 IBaseTest<any, 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: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core").default<ITestShape>>;
 export default _default;

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

@@ -1,7 +1,6 @@
-import { IBaseTest } from "../../../Types";
 import type { ITestImpl, ITestSpec } from "../jsx-promised";
 import { IInput } from "./index.js";
-declare const _default: <ITestShape extends IBaseTest<any, any>>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface2?: {
+declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, 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/{SubPackages → src/SubPackages}/react-test-renderer/jsx/web.d.ts

@@ -1,7 +1,6 @@
-import { IBaseTest } from "../../../Types";
 import { ITestImpl, ITestSpec } from "../jsx-promised";
 import { IInput } from "./index.js";
-declare const _default: <ITestShape extends IBaseTest<any, any>>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface2?: {
+declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, 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

@@ -0,0 +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>>;
+export default _default;

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

@@ -0,0 +1,4 @@
+import { ITestImpl, 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>>;
+export default _default;

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

@@ -0,0 +1,51 @@
+import { ITTestResourceRequest, 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 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>;
+}, Given: {
+    [K in keyof ITestShape["givens"]]: (features: string[], whens: BaseWhen<ITestShape>[], thens: BaseThen<ITestShape>[], ...xtrasB: ITestShape["givens"][K]) => BaseGiven<ITestShape>;
+}, When: {
+    [K in keyof ITestShape["whens"]]: (...xtrasC: ITestShape["whens"][K]) => BaseWhen<ITestShape>;
+}, 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<{
+    suites: {
+        [K in keyof ITestShape["suites"]]: string;
+    };
+    givens: {
+        [K in keyof ITestShape["givens"]]: (...Ig: ITestShape["givens"][K]) => ITestShape["given"];
+    };
+    whens: {
+        [K in keyof ITestShape["whens"]]: (...Iw: ITestShape["whens"][K]) => (zel: ITestShape["iselection"], utils: PM) => ITestShape["when"];
+    };
+    thens: {
+        [K in keyof ITestShape["thens"]]: (...It: ITestShape["thens"][K]) => (ssel: ITestShape["iselection"]) => ITestShape["then"];
+    };
+    checks: {
+        [K in keyof ITestShape["checks"]]: (...Ic: ITestShape["checks"][K]) => ITestShape["given"];
+    };
+}, IMod>;
+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;
+    istore: IStore;
+    iselection: ISelection;
+    given: IGiven;
+    when: IWhen;
+    then: IThen;
+    suites: ISuites;
+    givens: IGivens;
+    whens: IWhens;
+    thens: IThens;
+    checks: IChecks;
+};
+export {};

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

@@ -0,0 +1,6 @@
+import type { IBaseTest, ITestImplementation, ITestSpecification } from "./Types";
+import Testeranto from "./lib/core.js";
+import { ITTestResourceRequest } from "./lib/index.js";
+import { IWebTestInterface } from "./lib/types";
+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>>;
+export default _default;

package/dist/types/src/esbuildConfigs/inputFilesPlugin.d.ts

@@ -0,0 +1,5 @@
+declare const _default: (platform: "web" | "node", entryPoints: Set<string> | string[]) => {
+    name: string;
+    setup(build: any): void;
+};
+export default _default;

package/dist/types/{lib → src/lib}/abstractBase.d.ts

@@ -1,8 +1,8 @@
 import { IBaseTest } from "../Types";
-import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
 import { PM } from "../PM/index.js";
-export declare type IGivens<ITestShape extends IBaseTest> = Record<string, BaseGiven<ITestShape>>;
-export declare abstract class BaseSuite<ITestShape extends IBaseTest> {
+import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
+export declare type IGivens<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>>> = Record<string, BaseGiven<ITestShape>>;
+export declare abstract class BaseSuite<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>>> {
     name: string;
     givens: IGivens<ITestShape>;
     checks: BaseCheck<ITestShape>[];
@@ -33,7 +33,7 @@ export declare abstract class BaseSuite<ITestShape extends IBaseTest> {
     afterAll(store: ITestShape["istore"], artifactory: ITestArtifactory, pm: PM): ITestShape["istore"];
     run(input: ITestShape["iinput"], testResourceConfiguration: ITTestResourceConfiguration, artifactory: (fPath: string, value: unknown) => void, tLog: (...string: any[]) => void, pm: PM): Promise<BaseSuite<ITestShape>>;
 }
-export declare abstract class BaseGiven<ITestShape extends IBaseTest> {
+export declare abstract class BaseGiven<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>>> {
     name: string;
     features: string[];
     whens: BaseWhen<ITestShape>[];
@@ -75,7 +75,7 @@ export declare abstract class BaseWhen<ITestShape extends IBaseTest> {
     };
     test(store: ITestShape["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM, key: string): Promise<any>;
 }
-export declare abstract class BaseThen<ITestShape extends IBaseTest> {
+export declare abstract class BaseThen<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>>> {
     name: string;
     thenCB: (storeState: ITestShape["iselection"]) => ITestShape["then"];
     error: boolean;
@@ -84,10 +84,10 @@ export declare abstract class BaseThen<ITestShape extends IBaseTest> {
         name: string;
         error: boolean;
     };
-    abstract butThen(store: ITestShape["istore"], thenCB: any, testResourceConfiguration?: any): Promise<ITestShape["iselection"]>;
-    test(store: ITestShape["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM): Promise<ITestShape["then"] | undefined>;
+    abstract butThen(store: ITestShape["istore"], thenCB: any, testResourceConfiguration: ITTestResourceConfiguration, pm: PM): Promise<ITestShape["iselection"]>;
+    test(store: ITestShape["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM, filepath: string): Promise<ITestShape["then"] | undefined>;
 }
-export declare abstract class BaseCheck<ITestShape extends IBaseTest> {
+export declare abstract class BaseCheck<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>>> {
     name: string;
     features: string[];
     checkCB: (whens: any, thens: any) => any;

package/dist/types/{lib → src/lib}/basebuilder.d.ts

@@ -3,7 +3,7 @@ import { IBaseTest, ITestSpecification } from "../Types.js";
 import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "./types.js";
 import { BaseCheck, BaseWhen, BaseThen, BaseGiven } from "./abstractBase.js";
 import { PM } from "../PM/index.js";
-export declare abstract class BaseBuilder<ITestShape extends IBaseTest, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
+export declare abstract class BaseBuilder<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>>, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
     readonly input: ITestShape["iinput"];
     specs: any;
     assertThis: (t: ITestShape["then"]) => {};

package/dist/types/{lib → src/lib}/classBuilder.d.ts

@@ -2,6 +2,6 @@ import { IBaseTest, ITestImplementation, ITestSpecification } from "../Types.js"
 import { BaseBuilder } from "./basebuilder.js";
 import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "./types.js";
 import { ITTestResourceRequest } from "./index.js";
-export declare abstract class ClassBuilder<ITestShape extends IBaseTest> extends BaseBuilder<ITestShape, any, any, any, any, any> {
+export declare abstract class ClassBuilder<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 BaseBuilder<ITestShape, any, any, any, any, any> {
     constructor(testImplementation: ITestImplementation<ITestShape, any>, testSpecification: ITestSpecification<ITestShape>, input: ITestShape["iinput"], suiteKlasser: ISuiteKlasser<ITestShape>, givenKlasser: IGivenKlasser<ITestShape>, whenKlasser: IWhenKlasser<ITestShape>, thenKlasser: IThenKlasser<ITestShape>, checkKlasser: ICheckKlasser<ITestShape>, testResourceRequirement: ITTestResourceRequest);
 }

package/dist/types/{lib → src/lib}/core.d.ts

@@ -2,7 +2,7 @@ import { IBaseTest, ITestSpecification, ITestImplementation } from "../Types.js"
 import { ITestInterface } from "./types.js";
 import { ITTestResourceRequest } from "./index.js";
 import { ClassBuilder } from "./classBuilder.js";
-export default abstract class Testeranto<ITestShape extends IBaseTest> extends ClassBuilder<ITestShape> {
+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): any;
 }

package/dist/types/{lib → src/lib}/index.d.ts

@@ -2,7 +2,7 @@ import { PM } from "../PM/index.js";
 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>;
+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 type ITTestResourceConfiguration = {
     name: string;
@@ -29,14 +29,14 @@ export declare type ITestArtificer = (key: string, data: any) => void;
 declare type ITest = {
     toObj(): object;
     name: string;
-    givens: IGivens<IBaseTest>;
-    checks: BaseCheck<IBaseTest>[];
+    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>>>[];
     testResourceConfiguration: ITTestResourceConfiguration;
 };
 export declare type ITestJob<T = PM> = {
     toObj(): object;
     test: ITest;
-    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<IBaseTest>>;
+    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>>;
     testResourceRequirement: ITTestResourceRequirement;
     receiveTestResourceConfig: (pm: PM) => Promise<{
         failed: number;
@@ -49,7 +49,7 @@ export declare type ITestResults = Promise<{
 }>[];
 export declare const defaultTestResourceRequirement: ITTestResourceRequest;
 export declare type ITestArtifactory = (key: string, value: unknown) => unknown;
-export declare type ITestCheckCallback<ITestShape extends IBaseTest> = {
+export declare type ITestCheckCallback<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>>> = {
     [K in keyof ITestShape["checks"]]: (name: string, features: string[], callbackA: (whens: {
         [K in keyof ITestShape["whens"]]: (...unknown: any[]) => BaseWhen<ITestShape>;
     }, thens: {

package/dist/types/{lib → src/lib}/types.d.ts

@@ -9,14 +9,13 @@ export declare type ITestTypes = [string, IRunTime, {
 export declare type IJsonConfig = {
     outdir: string;
     tests: ITestTypes[];
-    features: string;
+    botEmail: string;
 };
 export declare type IBaseConfig = {
     clearScreen: boolean;
     debugger: boolean;
     devMode: boolean;
     externals: string[];
-    features: string;
     minify: boolean;
     nodePlugins: any[];
     outbase: string;
@@ -24,39 +23,40 @@ export declare type IBaseConfig = {
     ports: string[];
     tests: ITestTypes[];
     webPlugins: any[];
+    botEmail: string;
 };
 export declare type IBuiltConfig = {
     buildDir: string;
 } & IBaseConfig;
-export declare type IWebTestInterface<ITestShape extends IBaseTest> = {
+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) => Promise<ITestShape["istore"]>;
+    andWhen: (store: ITestShape["istore"], whenCB: ITestShape["when"], testResource: ITTestResourceConfiguration, utils: PM) => Promise<ITestShape["istore"]>;
     butThen: (store: ITestShape["istore"], thenCB: any, testResource: ITTestResourceConfiguration) => 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<ITestShape extends IBaseTest> = {
+export declare type INodeTestInterface<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) => Promise<ITestShape["istore"]>;
-    butThen: (store: ITestShape["istore"], thenCB: any, testResource: ITTestResourceConfiguration) => Promise<ITestShape["iselection"]>;
+    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, pm: PM) => any;
     afterEach: (store: ITestShape["istore"], key: string, artificer: ITestArtificer, pm: PM) => Promise<unknown>;
     beforeAll: (input: ITestShape["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, pm: PM) => Promise<ITestShape["isubject"]>;
-    beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any) => Promise<ITestShape["istore"]>;
+    beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any, pm: PM) => Promise<ITestShape["istore"]>;
 };
-export declare type ITestInterface<ITestShape extends IBaseTest> = {
+export declare type ITestInterface<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, pm: PM) => Promise<ITestShape["istore"]>;
-    butThen: (store: ITestShape["istore"], thenCB: any, testResource: ITTestResourceConfiguration) => Promise<ITestShape["iselection"]>;
+    butThen: (store: ITestShape["istore"], thenCB: any, testResource: ITTestResourceConfiguration, pm: PM) => Promise<ITestShape["iselection"]>;
     afterAll: (store: ITestShape["istore"], artificer: ITestArtificer, pm: PM) => any;
     afterEach: (store: ITestShape["istore"], key: string, artificer: ITestArtificer, pm: PM) => Promise<unknown>;
     beforeAll: (input: ITestShape["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, pm: PM) => Promise<ITestShape["isubject"]>;
     beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any, pm: PM) => Promise<ITestShape["istore"]>;
 };
-export declare type ISuiteKlasser<ITestShape extends IBaseTest> = (name: string, index: number, givens: IGivens<ITestShape>, checks: BaseCheck<ITestShape>[]) => BaseSuite<ITestShape>;
-export declare type IGivenKlasser<ITestShape extends IBaseTest> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<ITestShape>;
-export declare type IWhenKlasser<ITestShape extends IBaseTest> = (s: any, o: any) => BaseWhen<ITestShape>;
-export declare type IThenKlasser<ITestShape extends IBaseTest> = (s: any, o: any) => BaseThen<ITestShape>;
-export declare type ICheckKlasser<ITestShape extends IBaseTest> = (n: any, f: any, cb: any, w: any, t: any) => BaseCheck<ITestShape>;
+export declare type ISuiteKlasser<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>>> = (name: string, index: number, givens: IGivens<ITestShape>, checks: BaseCheck<ITestShape>[]) => BaseSuite<ITestShape>;
+export declare type IGivenKlasser<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>>> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<ITestShape>;
+export declare type IWhenKlasser<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>>> = (s: any, o: any) => BaseWhen<ITestShape>;
+export declare type IThenKlasser<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>>> = (s: any, o: any) => BaseThen<ITestShape>;
+export declare type ICheckKlasser<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>>> = (n: any, f: any, cb: any, w: any, t: any) => BaseCheck<ITestShape>;

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

@@ -0,0 +1,2 @@
+import { IBuiltConfig, IRunTime } from "./lib/types";
+export declare const destinationOfRuntime: (f: string, r: IRunTime, configs: IBuiltConfig) => string;

package/dist/types/testeranto.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    botEmail: string;
+    taskman: string;
+    outdir: string;
+    tests: (string | never[] | {
+        ports: number;
+    })[][];
+    debugger: boolean;
+    clearScreen: boolean;
+    devMode: boolean;
+    minify: boolean;
+    outbase: string;
+    ports: never[];
+    externals: never[];
+};
+export default _default;