testeranto 0.128.0 → 0.134.0

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

@@ -0,0 +1,6 @@
+import { Sidecar } from "./lib/Sidecar";
+import { PM_Node_Sidecar } from "./PM/nodeSidecar";
+export declare abstract class NodeSidecar extends Sidecar {
+    pm: PM_Node_Sidecar;
+    constructor(t: any);
+}

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

@@ -0,0 +1,23 @@
+import { IBuiltConfig, IRunTime, ISummary } from "../Types.js";
+import { PM_Base } from "./base.js";
+export declare abstract class PM_WithEslintAndTsc extends PM_Base {
+    name: string;
+    mode: "once" | "dev";
+    summary: ISummary;
+    constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev");
+    tscCheck: ({ entrypoint, addableFiles, platform, }: {
+        platform: IRunTime;
+        entrypoint: string;
+        addableFiles: string[];
+    }) => Promise<void>;
+    eslintCheck: (entrypoint: string, platform: IRunTime, addableFiles: string[]) => Promise<void>;
+    makePrompt: (entryPoint: string, addableFiles: string[], platform: IRunTime) => Promise<void>;
+    typeCheckIsRunning: (src: string) => void;
+    typeCheckIsNowDone: (src: string, failures: number) => void;
+    lintIsRunning: (src: string) => void;
+    lintIsNowDone: (src: string, failures: number) => void;
+    bddTestIsRunning: (src: string) => void;
+    bddTestIsNowDone: (src: string, failures: number) => void;
+    writeBigBoard: () => void;
+    checkForShutdown: () => void;
+}

package/dist/types/src/PM/__tests__/nodeSidecar.testeranto.d.ts

@@ -0,0 +1,20 @@
+import { PM_Node_Sidecar } from "../nodeSidecar";
+import { Ibdd_out, Ibdd_in } from "../../Types";
+type I = Ibdd_in<PM_Node_Sidecar, PM_Node_Sidecar, unknown, unknown, unknown, unknown, unknown>;
+type O = Ibdd_out<{
+    SidecarInitialized: [null];
+}, {
+    SidecarReady: [];
+}, {
+    SendTestMessage: [string];
+    VerifyCleanup: [];
+}, {
+    MessageReceived: [string];
+    ListenersCleaned: [];
+}, {
+    SidecarState: unknown;
+}>;
+declare const _default: Promise<import("../../lib/core").default<IT, O, {
+    whens: import("../../Types").TestWhenImplementation<I, O>;
+}>>;
+export default _default;

package/dist/types/src/PM/__tests__/pureSidecar.testeranto.d.ts

@@ -0,0 +1,20 @@
+import { PM_Pure_Sidecar } from "../pureSidecar";
+import { Ibdd_out, Ibdd_in } from "../../Types";
+type I = Ibdd_in<PM_Pure_Sidecar, PM_Pure_Sidecar, unknown, unknown, unknown, unknown, unknown>;
+type O = Ibdd_out<{
+    SidecarInitialized: [null];
+}, {
+    SidecarReady: [];
+}, {
+    SendTestMessage: [string];
+    VerifyCleanup: [];
+}, {
+    MessageReceived: [string];
+    ListenersCleaned: [];
+}, {
+    SidecarState: unknown;
+}>;
+declare const _default: Promise<import("../../lib/core").default<IT, O, {
+    whens: import("../../Types").TestWhenImplementation<I, O>;
+}>>;
+export default _default;

package/dist/types/src/PM/__tests__/webSidecar.testeranto.d.ts

@@ -0,0 +1,20 @@
+import { PM_Web_Sidecar } from "../webSidecar";
+import { Ibdd_out, Ibdd_in } from "../../Types";
+type I = Ibdd_in<PM_Web_Sidecar, PM_Web_Sidecar, unknown, unknown, unknown, unknown, unknown>;
+type O = Ibdd_out<{
+    SidecarInitialized: [null];
+}, {
+    SidecarReady: [];
+}, {
+    SendTestMessage: [string];
+    VerifyCleanup: [];
+}, {
+    MessageReceived: [string];
+    ListenersCleaned: [];
+}, {
+    SidecarState: unknown;
+}>;
+declare const _default: Promise<import("../../lib/core").default<IT, O, {
+    whens: import("../../Types").TestWhenImplementation<I, O>;
+}>>;
+export default _default;

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

@@ -6,15 +6,16 @@ export declare abstract class PM_Base {
     browser: Browser;
     configs: IBuiltConfig;
     constructor(configs: IBuiltConfig);
+    abstract launchSideCar(n: number, testName: string, projectName: string): any;
     customclose(): void;
     waitForSelector(p: string, s: string): any;
     closePage(p: any): any;
-    newPage(): Promise<Page>;
+    newPage(): Promise<string>;
     goto(p: any, url: string): any;
-    $(selector: string, p: string): Promise<boolean>;
+    $(selector: string, p: string): Promise<any>;
     pages(): Promise<string[]>;
     screencast(ssOpts: ScreenshotOptions, testName: string, page: Page): Promise<Uint8Array<ArrayBufferLike>>;
-    customScreenShot(ssOpts: ScreenshotOptions, testName: string, page: Page): Promise<Uint8Array<ArrayBufferLike>>;
+    customScreenShot(ssOpts: ScreenshotOptions, testName: string, pageUid: any): Promise<Uint8Array<ArrayBufferLike>>;
     end(uid: number): Promise<boolean>;
     existsSync(destFolder: string): boolean;
     mkdirSync(fp: string): Promise<string | false | undefined>;
@@ -22,12 +23,12 @@ export declare abstract class PM_Base {
     createWriteStream(filepath: string, testName: string): Promise<number>;
     testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
     write(uid: number, contents: string): Promise<boolean>;
-    page(): string | undefined;
+    page(p: any): string | undefined;
     click(selector: string, page: Page): Promise<void>;
     focusOn(selector: string, p: string): Promise<void>;
     typeInto(value: string, p: string): Promise<void>;
-    getValue(value: string, p: string): void;
     getAttribute(selector: string, attribute: string, p: string): void;
+    getInnerHtml(selector: string, p: string): Promise<unknown>;
     isDisabled(selector: string, p: string): void;
     screencastStop(s: string): Promise<void>;
     doInPage(p: string, cb: (p: Page) => unknown): Promise<void>;

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

@@ -7,7 +7,7 @@ export declare abstract class PM {
     abstract start(): Promise<void>;
     abstract stop(): Promise<void>;
     abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): any;
-    abstract $(selector: string): any;
+    abstract $(selector: string, page: string): any;
     abstract click(selector: string): any;
     abstract closePage(p: any): any;
     abstract createWriteStream(filepath: string, testName: string): Promise<string>;
@@ -16,8 +16,8 @@ export declare abstract class PM {
     abstract end(uid: number): Promise<boolean>;
     abstract existsSync(fp: string): Promise<boolean>;
     abstract focusOn(selector: string): any;
-    abstract getAttribute(selector: string, attribute: string): any;
-    abstract getValue(value: string): any;
+    abstract getAttribute(selector: string, attribute: string, page: string): any;
+    abstract getInnerHtml(selector: string, page: string): any;
     abstract goto(p: any, url: string): any;
     abstract isDisabled(selector: string): Promise<boolean>;
     abstract mkdirSync(a: string): any;
@@ -30,4 +30,6 @@ export declare abstract class PM {
     abstract waitForSelector(p: any, sel: string): any;
     abstract write(uid: number, contents: string): Promise<boolean>;
     abstract writeFileSync(f: string, c: string, t: string): Promise<boolean>;
+    abstract launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
+    abstract stopSideCar(n: number): Promise<any>;
 }

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

@@ -1,47 +1,44 @@
+import { ChildProcess } from "node:child_process";
 import { Page } from "puppeteer-core/lib/esm/puppeteer";
 import fs from "fs";
-import { IRunnables } from "../lib/index.js";
-import { ISummary } from "../utils";
+import { IRunnables, ITTestResourceConfiguration } from "../lib/index.js";
 import { IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
-import { PM_Base } from "./base.js";
-export declare class PM_Main extends PM_Base {
-    name: string;
+import { Sidecar } from "../lib/Sidecar.js";
+import { PM_WithEslintAndTsc } from "./PM_WithEslintAndTsc.js";
+export declare class PM_Main extends PM_WithEslintAndTsc {
     ports: Record<number, boolean>;
     queue: any[];
-    mode: "once" | "dev";
-    bigBoard: ISummary;
     webMetafileWatcher: fs.FSWatcher;
     nodeMetafileWatcher: fs.FSWatcher;
     importMetafileWatcher: fs.FSWatcher;
+    pureSidecars: Record<number, Sidecar>;
+    nodeSidecars: Record<number, ChildProcess>;
+    webSidecars: Record<number, Page>;
     constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev");
+    stopSideCar(uid: number): Promise<any>;
+    launchSideCar(n: number, name: string): Promise<[number, ITTestResourceConfiguration]>;
     mapping(): [string, (...a: any[]) => any][];
     start(): Promise<void>;
+    launchExternalTest(externalTestName: string, externalTest: {
+        watch: string[];
+        exec: string;
+    }): Promise<void>;
     stop(): Promise<void>;
     getRunnables: (tests: ITestTypes[], testName: string, payload?: {
         nodeEntryPoints: {};
+        nodeEntryPointSidecars: {};
         webEntryPoints: {};
-        importEntryPoints: {};
+        webEntryPointSidecars: {};
+        pureEntryPoints: {};
+        pureEntryPointSidecars: {};
     }) => IRunnables;
     metafileOutputs(platform: IRunTime): Promise<void>;
-    tscCheck: ({ entrypoint, addableFiles, platform, }: {
-        platform: IRunTime;
-        entrypoint: string;
-        addableFiles: string[];
-    }) => Promise<void>;
-    eslintCheck: (entrypoint: string, platform: IRunTime, addableFiles: string[]) => Promise<void>;
-    makePrompt: (entryPoint: string, addableFiles: string[], platform: IRunTime) => Promise<void>;
-    checkForShutdown: () => void;
-    typeCheckIsRunning: (src: string) => void;
-    typeCheckIsNowDone: (src: string, failures: number) => void;
-    lintIsRunning: (src: string) => void;
-    lintIsNowDone: (src: string, failures: number) => void;
-    bddTestIsRunning: (src: string) => void;
-    bddTestIsNowDone: (src: string, failures: number) => void;
     launchPure: (src: string, dest: string) => Promise<void>;
     launchNode: (src: string, dest: string) => Promise<void>;
-    launchWebSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<Page>;
-    launchNodeSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<void>;
+    launchWebSideCar: (testConfig: ITestTypes) => Promise<[number, ITTestResourceConfiguration]>;
+    launchNodeSideCar: (sidecar: ITestTypes) => Promise<[number, ITTestResourceConfiguration]>;
+    stopPureSideCar: (uid: number) => Promise<void>;
+    launchPureSideCar: (sidecar: ITestTypes) => Promise<[number, ITTestResourceConfiguration]>;
     launchWeb: (src: string, dest: string) => Promise<void>;
-    receiveFeatures: (features: string[], destFolder: string, srcTest: string, platform: IRunTime) => void;
-    writeBigBoard: () => void;
+    receiveFeaturesV2: (reportDest: string, srcTest: string, platform: IRunTime) => void;
 }

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

@@ -6,26 +6,28 @@ import { PM } from ".";
 export declare class PM_Node extends PM {
     testResourceConfiguration: ITTestResourceConfiguration;
     client: net.Socket;
-    constructor(t: ITTestResourceConfiguration);
+    constructor(t: ITTestResourceConfiguration, ipcFile: string);
     start(): Promise<void>;
     stop(): Promise<void>;
     send<I>(command: string, ...argz: any[]): Promise<I>;
+    launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
+    stopSideCar(n: number): Promise<any>;
     pages(): Promise<string[]>;
     waitForSelector(p: string, s: string): any;
     closePage(p: any): Promise<unknown>;
     goto(page: string, url: string): Promise<unknown>;
     newPage(): Promise<string>;
-    $(selector: string): Promise<unknown>;
+    $(selector: string, page: string): Promise<unknown>;
     isDisabled(selector: string): Promise<boolean>;
-    getAttribute(selector: string, attribute: string): Promise<unknown>;
-    getValue(selector: string): Promise<unknown>;
+    getAttribute(selector: string, attribute: string, p: string): Promise<unknown>;
+    getInnerHtml(selector: string, p: string): Promise<unknown>;
     focusOn(selector: string): Promise<unknown>;
     typeInto(selector: string): Promise<unknown>;
     page(): Promise<string | undefined>;
     click(selector: string): Promise<unknown>;
     screencast(opts: ScreencastOptions, page: string): Promise<unknown>;
     screencastStop(p: string): Promise<unknown>;
-    customScreenShot(opts: ScreencastOptions, page?: string): Promise<unknown>;
+    customScreenShot(x: ScreencastOptions, y?: string): Promise<unknown>;
     existsSync(destFolder: string): Promise<boolean>;
     mkdirSync(): Promise<unknown>;
     write(uid: number, contents: string): Promise<boolean>;
@@ -33,6 +35,6 @@ export declare class PM_Node extends PM {
     createWriteStream(filepath: string): Promise<string>;
     end(uid: any): Promise<boolean>;
     customclose(): Promise<unknown>;
-    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (p: Promise<void>) => void): (fPath: string, value: string | Buffer | PassThrough) => void;
     startPuppeteer(options?: any): any;
 }

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

@@ -0,0 +1,13 @@
+import net from "net";
+import { ITTestResourceConfiguration } from "../lib";
+import { PM_sidecar } from "./sidecar";
+export declare class PM_Node_Sidecar extends PM_sidecar {
+    testResourceConfiguration: ITTestResourceConfiguration;
+    client: net.Socket;
+    mockListener?: jest.Mock;
+    constructor(t: ITTestResourceConfiguration);
+    start(stopper: () => any): Promise<void>;
+    stop(): Promise<void>;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (p: Promise<void>) => void): (fPath: string, value: string | Buffer | PassThrough) => void;
+    send<I>(command: string, ...argz: any[]): Promise<I>;
+}

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

@@ -1,15 +1,17 @@
 import { ScreencastOptions } from "puppeteer-core";
 import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
-import { PassThrough } from "stream";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 import { PM } from ".";
 type PuppetMasterServer = Record<string, Promise<any>>;
 export declare class PM_Pure extends PM {
+    getInnerHtml(selector: string, page: string): Promise<string>;
+    stopSideCar(uid: number): Promise<boolean>;
     server: PuppetMasterServer;
     testResourceConfiguration: ITTestResourceConfiguration;
     constructor(t: ITTestResourceConfiguration);
     start(): Promise<void>;
     stop(): Promise<void>;
+    launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
     pages(): any;
     waitForSelector(p: string, s: string): any;
     closePage(p: any): string;
@@ -33,7 +35,6 @@ export declare class PM_Pure extends PM {
     createWriteStream(filepath: string): any;
     end(uid: number): any;
     customclose(): void;
-    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
-    startPuppeteer(options?: any): any;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): void;
 }
 export {};

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

@@ -0,0 +1,11 @@
+import net from "net";
+import { ITTestResourceConfiguration } from "../lib";
+import { PM_sidecar } from "./sidecar";
+export declare class PM_Pure_Sidecar extends PM_sidecar {
+    testResourceConfiguration: ITTestResourceConfiguration;
+    client: net.Socket;
+    constructor(t: ITTestResourceConfiguration);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send<I>(command: string, ...argz: any[]): Promise<I>;
+}

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

@@ -0,0 +1,8 @@
+import { ITTestResourceConfiguration } from "../lib";
+import { ITLog } from "../lib";
+export declare abstract class PM_sidecar {
+    testResourceConfiguration: ITTestResourceConfiguration;
+    abstract start(stopper: () => any): Promise<void>;
+    abstract stop(): Promise<void>;
+    testArtiFactoryfileWriter(tLog: ITLog, callback: (p: Promise<void>) => void): (fPath: string, value: unknown) => void;
+}

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

@@ -1,33 +1,43 @@
 import { PassThrough } from "stream";
 import { ScreencastOptions, ScreenshotOptions } from "puppeteer-core";
-import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
+declare module "puppeteer-core" {
+    interface Frame {
+        _id: string;
+    }
+}
+import { Page } from "puppeteer-core";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
-export declare class PM_Web {
+import { PM } from ".";
+export declare class PM_Web extends PM {
     testResourceConfiguration: ITTestResourceConfiguration;
     constructor(t: ITTestResourceConfiguration);
     start(): Promise<void>;
     stop(): Promise<void>;
+    getInnerHtml(selector: string, page: string): void;
+    pages(): Promise<string[]>;
+    stopSideCar(n: number): Promise<any>;
+    launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]>;
     waitForSelector(p: string, s: string): any;
-    screencast(opts: ScreencastOptions, page: Page): any;
+    screencast(o: ScreencastOptions, p: string | Page): Promise<string>;
     screencastStop(recorder: string): any;
     closePage(p: any): string;
     goto(p: any, url: string): any;
-    newPage(): CdpPage;
+    newPage(): any;
     $(selector: string): boolean;
     isDisabled(selector: string): Promise<boolean>;
     getAttribute(selector: string, attribute: string): any;
     getValue(selector: number): any;
     focusOn(selector: string): any;
     typeInto(value: string): any;
-    page(): string | undefined;
+    page(x?: any): Promise<string | undefined>;
     click(selector: string): any;
-    customScreenShot(opts: ScreenshotOptions, page: Page): any;
-    existsSync(destFolder: string): boolean;
+    customScreenShot(x: ScreenshotOptions, y: any): any;
+    existsSync(destFolder: string): Promise<boolean>;
     mkdirSync(x: any): any;
     write(uid: number, contents: string): Promise<boolean>;
     writeFileSync(filepath: string, contents: string): any;
     createWriteStream(filepath: string): any;
-    end(uid: number): boolean;
+    end(uid: number): Promise<boolean>;
     customclose(): void;
     testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise: any) => void): (fPath: any, value: string | Buffer | PassThrough) => void;
 }

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

@@ -0,0 +1,11 @@
+import net from "net";
+import { ITTestResourceConfiguration } from "../lib";
+import { PM_sidecar } from "./sidecar";
+export declare class PM_Web_Sidecar extends PM_sidecar {
+    testResourceConfiguration: ITTestResourceConfiguration;
+    client: net.Socket;
+    constructor(t: ITTestResourceConfiguration);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send<I>(command: string, ...argz: any[]): Promise<I>;
+}

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

@@ -0,0 +1,8 @@
+import { ITTestResourceConfiguration } from "./lib";
+import { Sidecar } from "./lib/Sidecar";
+import { PM_Pure_Sidecar } from "./PM/pureSidecar";
+export declare class PureSideCar extends Sidecar {
+    pm: PM_Pure_Sidecar;
+    start(t: ITTestResourceConfiguration): void;
+    stop(): void;
+}

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

@@ -1,69 +1,132 @@
 import { Plugin } from "esbuild";
 import { ITTestResourceConfiguration } from "./lib/index.js";
-import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen, BaseGiven } from "./lib/abstractBase.js";
-import { IPM, ITestCheckCallback } from "./lib/types.js";
 import { PM } from "./PM/index.js";
-export type ITestInterface<I extends IT = IT> = {
-    assertThis: (x: I["then"]) => any;
-    andWhen: (store: I["istore"], whenCB: I["when"], testResource: ITTestResourceConfiguration, pm: IPM) => Promise<I["istore"]>;
-    butThen: (store: I["istore"], thenCB: I["then"], testResource: ITTestResourceConfiguration, pm: IPM) => Promise<I["iselection"]>;
-    afterAll: (store: I["istore"], pm: IPM) => any;
-    afterEach: (store: I["istore"], key: string, pm: IPM) => Promise<unknown>;
-    beforeAll: (input: I["iinput"], testResource: ITTestResourceConfiguration, pm: IPM) => Promise<I["isubject"]>;
-    beforeEach: (subject: I["isubject"], initializer: (c?: any) => I["given"], testResource: ITTestResourceConfiguration, initialValues: any, pm: IPM) => Promise<I["istore"]>;
-};
-export type IWebTestInterface<I extends IT> = ITestInterface<I>;
-export type INodeTestInterface<I extends IT> = ITestInterface<I>;
-export type IPartialInterface<I extends IT> = Partial<ITestInterface<I>>;
-export type IPartialNodeInterface<I extends IT> = Partial<INodeTestInterface<I>>;
-export type IPartialWebInterface<I extends IT> = Partial<IWebTestInterface<I>>;
-export type IT = Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>;
-export type OT = Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>;
-export type ITestSpecification<I extends IT, O extends OT> = (Suite: {
+import { IT, OT } from "../dist/types/src/Types.js";
+import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen, BaseGiven } from "./lib/abstractBase.js";
+import { ITestCheckCallback } from "./lib/types.js";
+export type TestSummary = {
+    testName: string;
+    errors?: {
+        runtime?: number;
+        type?: number;
+        static?: number;
+    };
+    prompt?: string;
+    failedFeatures: string[];
+};
+export type TestLifecycle<Subject, State, Selection> = {
+    beforeAll?: (input: any) => Promise<Subject>;
+    beforeEach?: (subject: Subject) => Promise<State>;
+    executeStep?: (state: State) => Promise<State>;
+    verifyStep?: (state: State) => Promise<Selection>;
+    afterEach?: (state: State) => Promise<void>;
+    afterAll?: (state: State) => Promise<void>;
+    assert?: (result: Selection) => void;
+};
+export type TestDefinition<Subject, State, Selection> = {
+    subject: Subject;
+    given?: (input: any) => State;
+    when?: (state: State) => State | Promise<State>;
+    then?: (state: State) => Selection | Promise<Selection>;
+    resources?: ITTestResourceConfiguration;
+    pm?: typeof PM;
+};
+export type TestSuite = {
+    name: string;
+    tests: TestDefinition<any, any, any>[];
+    features?: string[];
+};
+export type RuntimeConfig = {
+    type: "node" | "web" | "pure" | "spawn";
+    ports?: number[];
+    plugins?: Plugin[];
+};
+export type ProjectConfig = {
+    name: string;
+    sourceDir: string;
+    testSuites: TestSuite[];
+    runtime: RuntimeConfig;
+    minify?: boolean;
+    debug?: boolean;
+};
+export type SuiteSpecification<I extends IT, O extends OT> = {
     [K in keyof O["suites"]]: (name: string, givens: IGivens<I>, checks: BaseCheck<I>[]) => BaseSuite<I, O>;
-}, Given: {
+};
+export type GivenSpecification<I extends IT, O extends OT> = {
     [K in keyof O["givens"]]: (features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], ...xtrasB: O["givens"][K]) => BaseGiven<I>;
-}, When: {
+};
+export type WhenSpecification<I extends IT, O extends OT> = {
     [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
-}, Then: {
+};
+export type ThenSpecification<I extends IT, O extends OT> = {
     [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
-}, Check: ITestCheckCallback<I, O>) => any[];
-export type ITestImplementation<I extends IT, O extends OT, modifier = {}> = Modify<{
-    suites: {
-        [K in keyof O["suites"]]: string;
-    };
-    givens: {
-        [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
-    };
-    whens: {
-        [K in keyof O["whens"]]: (...Iw: O["whens"][K]) => (zel: I["iselection"], utils: PM) => Promise<I["when"]>;
-    };
-    thens: {
-        [K in keyof O["thens"]]: (...It: O["thens"][K]) => (ssel: I["iselection"], utils: PM) => I["then"];
-    };
-    checks: {
-        [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
-    };
+};
+export type ITestSpecification<I extends IT, O extends OT> = (Suite: SuiteSpecification<I, O>, Given: GivenSpecification<I, O>, When: WhenSpecification<I, O>, Then: ThenSpecification<I, O>, Check: ITestCheckCallback<I, O>) => any[];
+export type TestSuiteImplementation<O extends OT> = {
+    [K in keyof O["suites"]]: string;
+};
+export type TestGivenImplementation<I extends IT, O extends OT> = {
+    [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
+};
+export type TestWhenImplementation<I extends IT, O extends OT> = {
+    [K in keyof O["whens"]]: (...Iw: O["whens"][K]) => (zel: I["iselection"], tr: ITTestResourceConfiguration, utils: PM) => Promise<I["when"]>;
+};
+export type TestThenImplementation<I extends IT, O extends OT> = {
+    [K in keyof O["thens"]]: (...It: O["thens"][K]) => (ssel: I["iselection"], utils: PM) => I["then"];
+};
+export type TestCheckImplementation<I extends IT, O extends OT> = {
+    [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
+};
+export type ITestImplementation<I extends IT, O extends OT, modifier = {
+    whens: TestWhenImplementation<I, O>;
+}> = Modify<{
+    suites: TestSuiteImplementation<O>;
+    givens: TestGivenImplementation<I, O>;
+    whens: TestWhenImplementation<I, O>;
+    thens: TestThenImplementation<I, O>;
+    checks: TestCheckImplementation<I, O>;
 }, modifier>;
 export type Modify<T, R> = Omit<T, keyof R> & R;
-export type Ibdd_out<ISuites extends Record<string, any> = Record<string, any>, IGivens extends Record<string, any> = Record<string, any>, IWhens extends Record<string, any> = Record<string, any>, IThens extends Record<string, any> = Record<string, any>, IChecks extends Record<string, any> = Record<string, any>> = {
+export type TestSuiteShape = Record<string, any>;
+export type TestGivenShape = Record<string, any>;
+export type TestWhenShape = Record<string, any>;
+export type TestThenShape = Record<string, any>;
+export type TestCheckShape = Record<string, any>;
+export type Ibdd_out<ISuites extends TestSuiteShape = TestSuiteShape, IGivens extends TestGivenShape = TestGivenShape, IWhens extends TestWhenShape = TestWhenShape, IThens extends TestThenShape = TestThenShape, IChecks extends TestCheckShape = TestCheckShape> = {
     suites: ISuites;
     givens: IGivens;
     whens: IWhens;
     thens: IThens;
     checks: IChecks;
 };
-export type Ibdd_in<IInput, ISubject, IStore, ISelection, IGiven, IWhen, IThen> = {
+/**
+ * Defines the input shape for BDD test definitions.
+ * This is the core type that structures all test operations.
+ */
+export type Ibdd_in<IInput, // Type of initial test input
+ISubject, // Type of object being tested
+IStore, // Type for storing test state between steps
+ISelection, // Type for selecting state for assertions
+IGiven, // Type for Given step functions
+IWhen, // Type for When step functions
+IThen> = {
+    /** Initial input required to start tests */
     iinput: IInput;
+    /** The subject being tested (class, function, etc) */
     isubject: ISubject;
+    /** Complete test state storage */
     istore: IStore;
+    /** Selected portion of state for assertions */
     iselection: ISelection;
+    /** Function type for Given steps */
     given: IGiven;
+    /** Function type for When steps */
     when: IWhen;
+    /** Function type for Then steps */
     then: IThen;
 };
 export type IPluginFactory = (register?: (entrypoint: string, sources: string[]) => any, entrypoints?: string[]) => Plugin;
-export type IRunTime = `node` | `web` | "pure";
+export type IRunTime = `node` | `web` | "pure" | `spawn`;
 export type ITestTypes = [string, IRunTime, {
     ports: number;
 }, ITestTypes[]];
@@ -71,6 +134,10 @@ export type ITestconfig = {
     clearScreen: boolean;
     debugger: boolean;
     externals: string[];
+    externalTests: Record<string, {
+        watch: string[];
+        exec: string;
+    }>;
     featureIngestor: (s: string) => Promise<string>;
     importPlugins: IPluginFactory[];
     minify: boolean;
@@ -79,7 +146,6 @@ export type ITestconfig = {
     src: string;
     tests: ITestTypes[];
     webPlugins: IPluginFactory[];
-    reportDomain: string;
 };
 export type IBuiltConfig = {
     buildDir: string;

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

@@ -0,0 +1,8 @@
+import { ITTestResourceConfiguration } from "./lib";
+import { Sidecar } from "./lib/Sidecar";
+import { PM_Web_Sidecar } from "./PM/webSidecar";
+export declare class WebSideCar extends Sidecar {
+    start(t: ITTestResourceConfiguration): void;
+    stop(): void;
+    pm: PM_Web_Sidecar;
+}

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

@@ -0,0 +1,2 @@
+import type { Plugin } from 'esbuild';
+export declare const consoleDetectorPlugin: Plugin;

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

@@ -0,0 +1,5 @@
+import { ITTestResourceConfiguration } from ".";
+export declare abstract class Sidecar {
+    abstract start(t: ITTestResourceConfiguration): any;
+    abstract stop(): any;
+}