testeranto 0.49.9 → 0.62.0

package/dist/types/Features.d.ts

@@ -1,4 +1,4 @@
-import Graph from "graphology";
+import Graph from "graphology/dist/graphology.umd.js";
 declare const DirectedGraph: any;
 declare abstract class TesterantoGraph {
     name: string;
@@ -44,19 +44,19 @@ export declare class TesterantoFeatures {
         features: {
             inNetworks: {
                 network: string;
-                neighbors: string[];
+                neighbors: any;
             }[];
             name: string;
         }[];
         networks: ({
             name: string;
-            graph: Graph<import("graphology-types").Attributes, import("graphology-types").Attributes, import("graphology-types").Attributes>;
+            graph: Graph;
         } | {
             name: string;
-            graph: Graph<import("graphology-types").Attributes, import("graphology-types").Attributes, import("graphology-types").Attributes>;
+            graph: Graph;
         } | {
             name: string;
-            graph: Graph<import("graphology-types").Attributes, import("graphology-types").Attributes, import("graphology-types").Attributes>;
+            graph: Graph;
         })[];
     };
 }

package/dist/types/Node.d.ts

@@ -1,12 +1,5 @@
-import { ITTestResourceConfiguration, ITTestResourceRequest, ITTestShape, ITestArtificer, ITestSpecification } from "./core.js";
-declare const _default: <TestShape extends ITTestShape, IInput, ISubject, IStore, ISelection, IWhenShape, IThenShape, IState>(input: IInput, testSpecification: ITestSpecification<TestShape, ISubject, IStore, ISelection, IThenShape>, testImplementation: any, testInterface: {
-    actionHandler?: ((b: (...any: any[]) => any) => any) | undefined;
-    andWhen: (store: IStore, actioner: any, testResource: ITTestResourceConfiguration) => Promise<ISelection>;
-    butThen?: ((store: IStore, callback: any, testResource: ITTestResourceConfiguration) => Promise<ISelection>) | undefined;
-    assertioner?: ((t: IThenShape) => any) | undefined;
-    afterAll?: ((store: IStore, artificer: ITestArtificer) => any) | undefined;
-    afterEach?: ((store: IStore, key: string, artificer: ITestArtificer) => Promise<unknown>) | undefined;
-    beforeAll?: ((input: IInput, artificer: ITestArtificer) => Promise<ISubject>) | undefined;
-    beforeEach?: ((subject: ISubject, initialValues: any, testResource: ITTestResourceConfiguration, artificer: ITestArtificer) => Promise<IStore>) | undefined;
-}, testResourceRequirement?: ITTestResourceRequest) => Promise<void>;
+import Testeranto from "./lib/core.js";
+import { ITTestResourceRequest } from "./lib/index.js";
+import type { IBaseTest, INodeTestInterface, ITestImplementation, ITestSpecification } from "./Types.js";
+declare const _default: <ITestShape extends IBaseTest>(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/NodeWriter.d.ts

@@ -1,2 +1,2 @@
-import { ILogWriter } from "./core";
+import { ILogWriter } from "./lib/index.js";
 export declare const NodeWriter: ILogWriter;

package/dist/types/Project.d.ts

@@ -1,33 +1,8 @@
-import WebSocket from 'ws';
-import { TesterantoFeatures } from "./Features";
-import { IBaseConfig, IRunTime, ITestTypes } from "./Types";
-import { ITTestResourceRequirement } from './core';
-declare type ISchedulerProtocols = `ipc` | `ws`;
+import { IBaseConfig, IRunTime } from "./Types";
 export declare class ITProject {
-    clearScreen: boolean;
-    devMode: boolean;
-    exitCodes: Record<number, string>;
-    features: TesterantoFeatures;
+    config: IBaseConfig;
     mode: `up` | `down`;
-    ports: Record<string, string>;
-    tests: ITestTypes[];
-    websockets: Record<string, WebSocket>;
-    resourceQueue: {
-        requirement: ITTestResourceRequirement;
-        protocol: ISchedulerProtocols;
-    }[];
-    private spinCycle;
-    private spinAnimation;
     constructor(config: IBaseConfig);
-    requestResource(requirement: ITTestResourceRequirement, protocol: ISchedulerProtocols): void;
     getSecondaryEndpointsPoints(runtime?: IRunTime): string[];
     initiateShutdown(reason: string): void;
-    private shutdown;
-    private spinner;
-    private releaseTestResourceWs;
-    private releaseTestResourcePm2;
-    private allocateViaWs;
-    private allocateViaIpc;
-    private mainLoop;
 }
-export {};

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

@@ -0,0 +1,6 @@
+import { IBaseTest, IPartialInterface, ITestImplementation, ITestSpecification } from "../Types";
+declare type IInput = string;
+export declare type IImpl<ISpec extends IBaseTest> = ITestImplementation<ISpec, object>;
+export declare type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+declare const _default: <ITestShape extends IBaseTest>(testInput: IInput, testSpecifications: ISpec<ITestShape>, testImplementations: ITestImplementation<ITestShape, object>, testInterface?: Partial<import("../Types").ITestInterface<ITestShape>> | undefined) => Promise<import("../lib/core.js").default<ITestShape>>;
+export default _default;

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

@@ -0,0 +1,7 @@
+import React from "react";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+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, IState>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

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

@@ -0,0 +1,7 @@
+import React from "react";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+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>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/SubPackages/react/jsx/index.d.ts

@@ -0,0 +1,15 @@
+import { CElement } from "react";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+export declare type IWhenShape = any;
+export declare type IThenShape = any;
+export declare type InitialState = unknown;
+export declare type IInput = () => JSX.Element;
+export declare type ISelection = CElement<any, any>;
+export declare type IStore = CElement<any, any>;
+export declare type ISubject = CElement<any, any>;
+export declare type ITestImpl<ITestShape extends IBaseTest> = ITestImplementation<ITestShape, object>;
+export declare type ITestSpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
+export declare const testInterface: {
+    beforeEach: (x: any, ndx: any, testRsource: any, artificer: any) => Promise<IStore>;
+    andWhen: (s: IStore, whenCB: any) => Promise<ISelection>;
+};

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

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

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

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

package/dist/types/{subPackages → SubPackages}/react-dom/component/node.d.ts

@@ -1,14 +1,12 @@
 import React, { ReactNode } from "react";
 import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
 import Stream from 'stream';
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
 declare type IInput = typeof React.Component;
-declare type InitialState = unknown;
-declare type IWhenShape = any;
 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 ITTestShape>(testImplementations: ITestImplementation<unknown, React.ReactNode, any, any, ITestShape>, testSpecifications: ITestSpecification<ITestShape, React.ReactNode, React.ReactNode, React.ReactNode, any>, testInput: IInput) => Promise<void>;
+declare const _default: <ITestShape extends IBaseTest>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ITestSpecification<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

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

@@ -0,0 +1,5 @@
+import React from "react";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+declare type IInput = typeof React.Component;
+declare const _default: <ITestShape extends IBaseTest, IWhen, IGiven>(testInput: IInput, testSpecifications: ITestSpecification<ITestShape>, testImplementations: any) => void;
+export default _default;

package/dist/types/{subPackages → SubPackages}/react-dom/jsx/index.d.ts

@@ -1,6 +1,6 @@
-export declare type IInput = () => JSX.Element;
+export declare type IInput = (props?: any) => JSX.Element;
 export declare type IState = unknown;
-export declare type IWhenShape = any;
-export declare type IThenShape = any;
 export declare type ISelection = HTMLElement;
 export declare type IStore = HTMLElement;
+export declare type IWhenShape = any;
+export declare type IThenShape = any;

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 import React from "react";
 import renderer from "react-test-renderer";
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
+import type { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
 export declare type ISuper<T> = T extends infer U ? U : object;
 export declare type IInput<P, S> = typeof React.Component<P, S>;
 export declare type InitialState = unknown;
@@ -9,12 +9,12 @@ export declare type IThenShape = any;
 export declare type ISelection = renderer.ReactTestRenderer;
 export declare type IStore = renderer.ReactTestRenderer;
 export declare type ISubject = renderer.ReactTestRenderer;
-export declare type IImpl<ITestShape extends ITTestShape, IProps> = ITestImplementation<IProps, renderer.ReactTestRenderer, IWhenShape, IThenShape, ITestShape>;
-export declare type ISpec<ITestShape extends ITTestShape> = ITestSpecification<ITestShape, ISubject, IStore, ISelection, IThenShape>;
+export declare type IImpl<ITestShape extends IBaseTest, IProps> = ITestImplementation<ITestShape, object>;
+export declare type ISpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
 export declare const testInterface: {
-    beforeEach: (CComponent: any, props: any) => Promise<renderer.ReactTestRenderer>;
-    andWhen: (renderer: renderer.ReactTestRenderer, actioner: any) => Promise<renderer.ReactTestRenderer>;
-    butThen: (s: IStore) => Promise<ISelection>;
+    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/react-test-renderer/component/node.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { IBaseTest } from "../../../Types";
+import { IImpl, ISpec, IInput } from "./index.js";
+declare const _default: <ITestShape extends IBaseTest, IProps, IState>(testImplementations: IImpl<ITestShape, object>, 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;
+}) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

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

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

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

@@ -0,0 +1,8 @@
+import React from "react";
+import { ITestSpecification, ITestImplementation, 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 IBaseTest>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

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

@@ -0,0 +1,8 @@
+import React from "react";
+import { ITestSpecification, ITestImplementation, 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 IBaseTest, IPropShape>(testImplementations: ITestImplementation<ITestShape, object>, testSpecifications: ISpec<ITestShape>, testInput: IInput) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

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

@@ -1,5 +1,5 @@
 import renderer from "react-test-renderer";
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
 export declare type IWhenShape = any;
 export declare type IThenShape = any;
 export declare type InitialState = unknown;
@@ -7,9 +7,10 @@ export declare type IInput = (props?: any) => JSX.Element;
 export declare type ISelection = renderer.ReactTestRenderer;
 export declare type IStore = renderer.ReactTestRenderer;
 export declare type ISubject = renderer.ReactTestRenderer;
-export declare type ITestImpl<ITestShape extends ITTestShape> = ITestImplementation<InitialState, ISelection, IWhenShape, IThenShape, ITestShape>;
-export declare type ITestSpec<ITestShape extends ITTestShape> = ITestSpecification<ITestShape, ISubject, IStore, ISelection, IThenShape>;
+export declare type ITestImpl<ITestShape extends IBaseTest> = ITestImplementation<ITestShape, object>;
+export declare type ITestSpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
 export declare const testInterface: {
+    butThen: (s: IStore, thenCB: any, tr: any) => Promise<ISelection>;
     beforeEach: (CComponent: any, props: any) => Promise<renderer.ReactTestRenderer>;
-    andWhen: (renderer: renderer.ReactTestRenderer, actioner: () => (any: any) => any) => Promise<renderer.ReactTestRenderer>;
+    andWhen: (renderer: renderer.ReactTestRenderer, whenCB: (any: any) => any) => Promise<renderer.ReactTestRenderer>;
 };

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

@@ -0,0 +1,9 @@
+import { IBaseTest } from "../../../Types";
+import type { ITestImpl, ITestSpec } from "../jsx-promised";
+import { IInput } from "./index.js";
+declare const _default: <ITestShape extends IBaseTest>(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>;
+}) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { IInput } from "./index.js";
+import { IBaseTest } from "../../../Types";
+import { ITestImpl, ITestSpec } from "../jsx-promised";
+declare const _default: <ITestShape extends IBaseTest>(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>;
+}) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+export default _default;

package/dist/types/{subPackages → SubPackages}/react-test-renderer/jsx-promised/index.d.ts

@@ -1,5 +1,5 @@
 import renderer from "react-test-renderer";
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
 export declare type IWhenShape = any;
 export declare type IThenShape = any;
 export declare type InitialState = unknown;
@@ -7,9 +7,9 @@ export declare type IInput = Promise<JSX.Element>;
 export declare type ISelection = renderer.ReactTestRenderer;
 export declare type IStore = renderer.ReactTestRenderer;
 export declare type ISubject = renderer.ReactTestRenderer;
-export declare type ITestImpl<ITestShape extends ITTestShape> = ITestImplementation<InitialState, ISelection, IWhenShape, IThenShape, ITestShape>;
-export declare type ITestSpec<ITestShape extends ITTestShape> = ITestSpecification<ITestShape, ISubject, IStore, ISelection, IThenShape>;
+export declare type ITestImpl<ITestShape extends IBaseTest> = ITestImplementation<ITestShape, object>;
+export declare type ITestSpec<ITestShape extends IBaseTest> = ITestSpecification<ITestShape>;
 export declare const testInterface: {
     beforeEach: (CComponent: any) => Promise<renderer.ReactTestRenderer>;
-    andWhen: (renderer: renderer.ReactTestRenderer, actioner: () => (any: any) => any) => Promise<renderer.ReactTestRenderer>;
+    andWhen: (renderer: renderer.ReactTestRenderer, whenCB: () => (any: any) => any) => Promise<renderer.ReactTestRenderer>;
 };

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

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

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

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

package/dist/types/Types.d.ts

@@ -1,18 +1,131 @@
+import { BrowserWindow } from "electron";
+import { Page, Browser } from "puppeteer-core";
+import { ITTestResourceConfiguration, ITTestResourceRequest, ITestArtificer, ITestCheckCallback } from "./lib/index.js";
+import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen, BaseGiven } from "./lib/abstractBase.js";
+import Testeranto from "./lib/core.js";
+export declare type IBuiltConfig = {
+    buildDir: string;
+    modules: {
+        module: unknown;
+        test: string;
+        runtime: IRunTime;
+    }[];
+};
+export declare type INodeUtils = TBrowser;
+export declare type IWebUtils = BrowserWindow;
+export declare type IUtils = INodeUtils | IWebUtils;
+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 class TBrowser {
+    browser: Browser;
+    constructor(browser: Browser);
+    pages(): Promise<Page[]>;
+}
+export declare type ITTestShape = {
+    suites: any;
+    givens: any;
+    whens: any;
+    thens: any;
+    checks: any;
+};
+export declare type IJsonConfig = {
+    outdir: string;
+    tests: ITestTypes[];
+    features: string;
+};
 export declare type IBaseConfig = {
+    outdir: string;
+    tests: ITestTypes[];
+    features: string;
+    externals: string[];
     clearScreen: boolean;
     devMode: boolean;
-    features: string;
     webPlugins: any[];
     nodePlugins: any[];
     minify: boolean;
     outbase: string;
-    outdir: string;
     ports: string[];
-    tests: string;
+    debugger: boolean;
 };
+export declare type IPartialInterface<I extends IBaseTest> = Partial<ITestInterface<I>>;
+export declare type IPartialNodeInterface<I extends IBaseTest> = Partial<INodeTestInterface<I>>;
+export declare type IEntry<ITestShape extends IBaseTest> = (input: ITestShape['iinput'], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testInterface: IPartialInterface<ITestShape>, testResourceRequirement: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
 export declare type IRunTime = `node` | `web`;
 export declare type ITestTypes = [
     string,
     IRunTime,
     ITestTypes[]
 ];
+export declare type ITestSpecification<ITestShape extends IBaseTest> = (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, IMod> = 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']) => 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>;
+export declare type ITestInterface<ITestShape extends IBaseTest> = {
+    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']>;
+    afterAll: (store: ITestShape['istore'], artificer: ITestArtificer, utils: IUtils) => any;
+    afterEach: (store: ITestShape['istore'], key: string, artificer: ITestArtificer) => Promise<unknown>;
+    beforeAll: (input: ITestShape['iinput'], testResource: ITTestResourceConfiguration, artificer: ITestArtificer) => Promise<ITestShape['isubject']>;
+    beforeEach: (subject: ITestShape['isubject'], initializer: (c?: any) => ITestShape['given'], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any) => Promise<ITestShape['istore']>;
+};
+export declare type INodeTestInterface<ITestShape extends IBaseTest> = {
+    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']>;
+    afterAll: (store: ITestShape['istore'], artificer: ITestArtificer, browser: INodeUtils) => any;
+    afterEach: (store: ITestShape['istore'], key: string, artificer: ITestArtificer) => Promise<unknown>;
+    beforeAll: (input: ITestShape['iinput'], testResource: ITTestResourceConfiguration, artificer: ITestArtificer) => Promise<ITestShape['isubject']>;
+    beforeEach: (subject: ITestShape['isubject'], initializer: (c?: any) => ITestShape['given'], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any) => Promise<ITestShape['istore']>;
+} & ITestInterface<ITestShape>;
+declare type Modify<T, R> = Omit<T, keyof R> & R;
+export declare type IBaseTest = {
+    iinput: any;
+    isubject: any;
+    istore: any;
+    iselection: any;
+    given: any;
+    when: any;
+    then: any;
+    suites: Record<string, any[]>;
+    givens: Record<string, any[]>;
+    whens: Record<string, any[]>;
+    thens: Record<string, any[]>;
+    checks: Record<string, any[]>;
+};
+export declare type ITestShaper<T extends IBaseTest, modifier> = {
+    given: any;
+    when: any;
+    then: any;
+    suites: any;
+    givens: any;
+    whens: any;
+    thens: any;
+    checks: any;
+};
+export {};

package/dist/types/Web.d.ts

@@ -1,12 +1,5 @@
-import { ITTestResourceConfiguration, ITTestResourceRequest, ITTestShape, ITestArtificer, ITestSpecification } from "./core";
-declare const _default: <TestShape extends ITTestShape, IInput, ISubject, IStore, ISelection, WhenShape, IThenShape, IState>(input: IInput, testSpecification: ITestSpecification<TestShape, ISubject, IStore, ISelection, IThenShape>, testImplementation: any, testInterface: {
-    actionHandler?: ((b: (...any: any[]) => any) => any) | undefined;
-    andWhen: (store: IStore, actioner: any, testResource: ITTestResourceConfiguration) => Promise<ISelection>;
-    butThen?: ((store: IStore, callback: any, testResource: ITTestResourceConfiguration) => Promise<ISelection>) | undefined;
-    assertioner?: ((t: IThenShape) => any) | undefined;
-    afterAll?: ((store: IStore, artificer: ITestArtificer) => any) | undefined;
-    afterEach?: ((store: IStore, key: string, artificer: ITestArtificer) => Promise<unknown>) | undefined;
-    beforeAll?: ((input: IInput, artificer: ITestArtificer) => Promise<ISubject>) | undefined;
-    beforeEach?: ((subject: ISubject, initialValues: any, testResource: ITTestResourceConfiguration, artificer: ITestArtificer) => Promise<IStore>) | undefined;
-}, testResourceRequirement?: ITTestResourceRequest) => Promise<void>;
+import type { IBaseTest, ITestImplementation, ITestInterface, ITestSpecification } from "./Types";
+import Testeranto from "./lib/core.js";
+import { ITTestResourceRequest } from "./lib/index.js";
+declare const _default: <ITestShape extends IBaseTest>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testInterface: Partial<ITestInterface<ITestShape>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
 export default _default;

package/dist/types/esbuildConfigs/features.d.ts

@@ -0,0 +1,4 @@
+import { IBaseConfig } from "../Types";
+import { BuildOptions } from "esbuild";
+declare const _default: (config: IBaseConfig) => BuildOptions;
+export default _default;

package/dist/types/esbuildConfigs/index.d.ts

@@ -0,0 +1,4 @@
+import { BuildOptions } from "esbuild";
+import { IBaseConfig } from "../Types";
+declare const _default: (config: IBaseConfig) => BuildOptions;
+export default _default;

package/dist/types/esbuildConfigs/node.d.ts

@@ -0,0 +1,4 @@
+import { BuildOptions } from "esbuild";
+import { IBaseConfig } from "../Types";
+declare const _default: (config: IBaseConfig, entryPoints: Set<string> | string[]) => BuildOptions;
+export default _default;

package/dist/types/esbuildConfigs/tests.d.ts

@@ -0,0 +1,4 @@
+import { IBaseConfig } from "../Types";
+import { BuildOptions } from "esbuild";
+declare const _default: (config: IBaseConfig) => BuildOptions;
+export default _default;

package/dist/types/esbuildConfigs/web.d.ts

@@ -0,0 +1,4 @@
+import { BuildOptions } from "esbuild";
+import { IBaseConfig } from "../Types";
+declare const _default: (config: IBaseConfig, entryPoints: Set<string> | string[]) => BuildOptions;
+export default _default;