@midscene/test 1.12.10-beta-20260920031616.0 → 1.13.0

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

@@ -1,66 +1,39 @@
+import { Awaitable } from '@midscene/core/internal/test-runner';
 import { CommonAgentTestRunnerApi } from '@midscene/core/agent/test';
-import type { z } from 'zod/v4';
-
-declare type Awaitable<T> = T | Promise<T>;
-
-declare interface CaseExecutionContext {
-    readonly caseId: string;
-    readonly runId: string;
-    readonly projectName: string;
-    readonly attemptIndex: number;
-    readonly name: string;
-    readonly sourcePath: string;
-    readonly caseIndex: number;
-}
-
-declare type CaseNodePhase = 'beforeEach' | 'steps' | 'afterEach';
-
-declare interface CaseRunOutcome {
-    caseId: string;
-    projectName: string;
-    name: string;
-    sourcePath: string;
-    caseIndex: number;
-    status: CaseRunStatus;
+import type * as Core from '@midscene/core/internal/test-runner';
+import type { ExecutionProjectDefinition as ExecutionProjectDefinition_2 } from '@midscene/core/internal/test-runner';
+import { JsonPrimitive } from '@midscene/core/internal/test-runner';
+import { JsonValue } from '@midscene/core/internal/test-runner';
+import { NodeRegistry as NodeRegistry_2 } from '@midscene/core/internal/test-runner';
+import { ProjectRuntimeResult } from '@midscene/core/internal/test-runner';
+import { ProjectSetupContext } from '@midscene/core/internal/test-runner';
+import { ProjectSetupDefinition } from '@midscene/core/internal/test-runner';
+import { ProjectTeardown } from '@midscene/core/internal/test-runner';
+import { ProjectTeardownContext } from '@midscene/core/internal/test-runner';
+import { ResolvedExecutionProject } from '@midscene/core/internal/test-runner';
+import { TestFileSelection } from '@midscene/core/internal/test-runner';
+import { TestTagSelection } from '@midscene/core/internal/test-runner';
+import { WorkflowError } from '@midscene/core/internal/test-runner';
+import { WorkflowReportSource } from '@midscene/core/internal/test-runner';
+
+declare type CaseRunOutcome = Omit<Core.CaseRunOutcome, 'onFailure' | 'run' | 'attempts'> & {
     run?: CaseRunResult;
     attempts?: readonly CaseRunResult[];
-    notRunReason?: 'document-start-failed' | 'project-preflight-failed' | 'project-setup-failed' | 'interrupted' | 'bail' | 'fatal-error';
-}
+};
 
-declare interface CaseRunResult {
-    caseId: string;
-    runId: string;
-    projectName: string;
-    attemptIndex: number;
-    name: string;
-    sourcePath: string;
-    caseIndex: number;
-    status: 'success' | 'failed';
+declare type CaseRunResult = Omit<Core.CaseRunResult, 'beforeEach' | 'steps' | 'afterEach' | 'reportSources' | 'reportScopeId'> & {
     beforeEach: StepRunResult[];
     steps: StepRunResult[];
     afterEach: StepRunResult[];
-    teardownErrors?: WorkflowError[];
-    reportPaths?: string[];
-    startedAt: string;
-    endedAt: string;
-    durationMs: number;
-}
-
-declare type CaseRunStatus = 'success' | 'failed' | 'not-run';
+};
 
 export declare const createTestRunId: (date?: Date, uuid?: `${string}-${string}-${string}-${string}-${string}`) => string;
 
 export declare const DEFAULT_TEST_FILE_SELECTION: TestFileSelection;
 
-declare interface DefineNodeOptions<TInput = unknown, TData = unknown, TContext = unknown> {
-    name: string;
-    title?: string;
-    description?: string;
-    /** Object field populated by string shorthand. Omit or set false to disable it. */
-    stringInputKey?: string | false;
-    inputSchema?: NodeInputSchema;
-    execute(execution: NodeExecutionContext<TInput, TContext>): NodeExecutionReturn<TData>;
-}
+declare type DefineNodeOptions<TInput = unknown, TData = unknown, TContext = unknown> = Omit<Core.DefineNodeOptions<TInput, TData, TContext>, 'execute'> & {
+    execute(ctx: NodeExecutionContext<TInput, TContext>): Core.NodeExecutionReturn<TData>;
+};
 
 export declare const defineProjectSetup: <TProjectContext>(definition: ProjectSetupDefinition<TProjectContext>) => ProjectSetupDefinition<TProjectContext>;
 
@@ -70,24 +43,13 @@ export declare const discoverTestConfig: (projectRoot: string) => string | undef
 
 export declare const discoverTestFiles: (projectRoot: string, selection?: TestFileSelection) => string[];
 
-declare type DocumentNodePhase = 'beforeAll' | 'afterAll';
-
-export declare interface ExecutionProjectDefinition<TProjectContext = unknown> {
-    name: string;
-    setup?: ProjectSetupDefinition<TProjectContext>;
-    /** Project-local Nodes override global Nodes with the same name. */
-    nodes?: readonly NodeDefinition<any, any, TProjectContext>[];
-    files?: TestFileSelection;
-    tags?: TestTagSelection;
-    retry?: number;
-    variables?: Readonly<Record<string, JsonValue>>;
-}
+export declare type ExecutionProjectDefinition<TContext = unknown> = Omit<ExecutionProjectDefinition_2<TContext>, 'nodes'> & {
+    nodes?: readonly NodeDefinition<any, any, TContext>[];
+};
 
-export declare type JsonPrimitive = string | number | boolean | null;
+export { JsonPrimitive }
 
-export declare type JsonValue = JsonPrimitive | readonly JsonValue[] | {
-    readonly [key: string]: JsonValue;
-};
+export { JsonValue }
 
 export declare interface LoadedExecutionProject<TProjectContext = unknown> extends ResolvedExecutionProject<TProjectContext> {
     /** Effective Nodes: globals plus project-local overrides. */
@@ -110,61 +72,20 @@ declare interface MidsceneExecutionRef {
 }
 
 declare type MidsceneUIAgent = CommonAgentTestRunnerApi & {
+    _prepareForTestRunner?(): void;
+    _createReportSource?(scopeId: string): Promise<WorkflowReportSource | undefined>;
+    flushReport?(): Promise<string | undefined>;
     addDumpUpdateListener?(listener: (dump: string, execution?: MidsceneExecutionRef) => void): () => void;
 };
 
-declare interface NodeCaseContext extends CaseExecutionContext {
-    readonly phase: CaseNodePhase;
-    readonly stepIndex: number;
-}
-
-declare interface NodeDefinition<TInput = unknown, TData = unknown, TContext = unknown> extends DefineNodeOptions<TInput, TData, TContext> {
-}
-
-declare interface NodeDocumentContext {
-    readonly documentId: string;
-    readonly documentRunId: string;
-    readonly projectId: string;
-    readonly projectName: string;
-    readonly sourcePath: string;
-    readonly phase: DocumentNodePhase;
-    readonly stepIndex: number;
-}
-
-declare type NodeExecutionContext<TInput = unknown, TContext = unknown> = NodeExecutionContextBase<TInput, TContext> & ({
-    /** The node is running for one case. */
-    scope: 'case';
-    /** Identity and phase information for the case being executed. */
-    case: NodeCaseContext;
-    document?: never;
-} | {
-    /** The node is running for the workflow document. */
-    scope: 'document';
-    /** Identity and phase information for the document being executed. */
-    document: NodeDocumentContext;
-    case?: never;
-});
-
-declare interface NodeExecutionContextBase<TInput = unknown, TContext = unknown> {
-    /** The validated node input without `$`. */
-    input: TInput;
-    /** The normalized engine metadata for this step. */
+declare type NativeNodeContext<T> = T extends unknown ? Omit<T, '$' | 'onTeardown'> & {
     $: Readonly<NormalizedStepMeta>;
-    /** The timeout and cancellation signal for this step. */
-    signal: AbortSignal;
-    /** Resources shared by the current workflow document. */
-    context: TContext;
-    /** Register resource cleanup for the current case attempt or document. */
     onTeardown(teardown: NodeScopeTeardown): void;
-    /** Attach report detail references to the current Step result. */
-    report: NodeReportCollector;
-}
+} : never;
 
-declare type NodeExecutionPhase = CaseNodePhase | DocumentNodePhase;
+declare type NodeDefinition<TInput = unknown, TData = unknown, TContext = unknown> = DefineNodeOptions<TInput, TData, TContext>;
 
-declare type NodeExecutionReturn<TData = unknown> = Promise<NodeResult<TData> | void> | NodeResult<TData> | void;
-
-declare type NodeInputSchema = z.ZodObject;
+declare type NodeExecutionContext<TInput = unknown, TContext = unknown> = NativeNodeContext<Core.NodeExecutionContext<TInput, TContext>>;
 
 /** Options passed to an external package's synchronous createMidsceneTestNodes() factory. */
 export declare interface NodePackageOptions<TContext, TAgent = MidsceneUIAgent> {
@@ -172,87 +93,34 @@ export declare interface NodePackageOptions<TContext, TAgent = MidsceneUIAgent>
     getAgent(execution: NodeExecutionContext<unknown, TContext>): Awaitable<TAgent>;
 }
 
-declare class NodeRegistry {
-    #private;
-    constructor(nodes?: readonly NodeDefinition<any, any>[]);
-    register<TInput, TData>(node: NodeDefinition<TInput, TData>): this;
+declare type NodeRegistry = Omit<NodeRegistry_2, 'get' | 'require' | 'register' | 'definitions'> & {
     get(name: string): NodeDefinition<any, any> | undefined;
     require(name: string): NodeDefinition<any, any>;
-    has(name: string): boolean;
-    names(): string[];
+    register<TInput, TData>(node: NodeDefinition<TInput, TData>): NodeRegistry;
     definitions(): readonly NodeDefinition<any, any, any>[];
-}
-
-/** Collects report references produced while the current Step is executing. */
-declare interface NodeReportCollector {
-    addTrace(trace: NodeReportTrace): void;
-}
-
-/** A stable reference from one test Step to report detail data. */
-declare interface NodeReportTrace {
-    type: 'midscene-execution';
-    executionId: string;
-}
+};
 
-declare interface NodeResult<TData = unknown> {
-    /** Human-readable summary for reports. */
-    summary?: string;
-    /** Structured data included in the step result. */
-    data?: TData;
-}
+declare const NodeRegistry: {
+    new (nodes?: readonly NodeDefinition<any, any>[]): NodeRegistry;
+};
 
-declare type NodeScopeTeardown = () => Awaitable<NodeScopeTeardownResult | void>;
+declare type NodeScopeTeardown = () => Core.Awaitable<NodeScopeTeardownOutput>;
 
-declare interface NodeScopeTeardownResult {
-    /** Absolute paths to Midscene reports produced by this execution scope. */
-    reportPaths?: readonly string[];
-}
+declare type NodeScopeTeardownOutput = NodeScopeTeardownResult | void;
 
-declare interface NormalizedStepMeta {
-    timeoutMs?: number;
-    continueOnError: boolean;
-}
+declare type NodeScopeTeardownResult = Omit<Core.NodeScopeTeardownResult, 'reportSources'>;
 
-declare interface ProjectRuntimeResult<TProjectContext = unknown> {
-    projectName: string;
-    status: 'success' | 'failed';
-    setupError?: WorkflowError;
-    teardownErrors?: readonly WorkflowError[];
-    startedAt: string;
-    endedAt: string;
-    durationMs: number;
-}
+declare type NormalizedStepMeta = Omit<Core.NormalizedStepMeta, 'captureResult' | 'resultName'>;
 
-export declare interface ProjectSetupContext<TProjectContext = unknown> {
-    readonly project: ResolvedExecutionProject<TProjectContext>;
-    readonly env: Readonly<NodeJS.ProcessEnv>;
-    readonly signal: AbortSignal;
-    onTeardown(teardown: ProjectTeardown<TProjectContext>): void;
-}
+export { ProjectSetupContext }
 
-export declare interface ProjectSetupDefinition<TProjectContext = unknown> {
-    name: string;
-    setup(ctx: ProjectSetupContext<TProjectContext>): Awaitable<TProjectContext>;
-}
+export { ProjectSetupDefinition }
 
-export declare type ProjectTeardown<TProjectContext = unknown> = (ctx: ProjectTeardownContext<TProjectContext>) => Awaitable<void>;
+export { ProjectTeardown }
 
-export declare interface ProjectTeardownContext<TProjectContext = unknown> {
-    readonly project: ResolvedExecutionProject<TProjectContext>;
-    readonly context: TProjectContext | undefined;
-    readonly status: 'success' | 'failed';
-    readonly setupError?: WorkflowError;
-}
+export { ProjectTeardownContext }
 
-export declare interface ResolvedExecutionProject<TProjectContext = unknown> {
-    readonly projectId: string;
-    readonly name: string;
-    readonly setup?: ProjectSetupDefinition<TProjectContext>;
-    readonly files?: TestFileSelection;
-    readonly tags: Readonly<Required<TestTagSelection>>;
-    readonly retry: number;
-    readonly variables: Readonly<Record<string, JsonValue>>;
-}
+export { ResolvedExecutionProject }
 
 export declare interface ResolvedTestOptions {
     maxConcurrency: number;
@@ -264,29 +132,17 @@ export declare interface ResolvedTestOutputDefinition {
     reportDir: string;
 }
 
+/** Native Test entry for cases/steps workflow documents. */
 export declare function runTestProject(options?: TestProjectRunOptions): Promise<TestProjectRunResult>;
 
-declare interface StepRunResult<TOutputData = unknown> {
-    phase: NodeExecutionPhase;
-    stepIndex: number;
-    node: string;
-    input: unknown;
+declare type StepRunResult<TData = unknown> = Omit<Core.StepRunResult<TData>, 'meta'> & {
     meta: NormalizedStepMeta;
-    status: 'success' | 'failed';
-    continuedAfterError: boolean;
-    startedAt: string;
-    endedAt: string;
-    durationMs: number;
-    output?: NodeResult<TOutputData>;
-    error?: WorkflowError;
-    report?: {
-        traces: readonly NodeReportTrace[];
-    };
-}
+};
 
 export declare interface TestExecutionProjectRunResult {
     projectId: string;
     name: string;
+    platform: string;
     status: 'success' | 'failed';
     retry: number;
     fileSelection: TestFileSelection;
@@ -300,10 +156,7 @@ export declare interface TestExecutionProjectRunResult {
     collectionErrors: readonly TestProjectCollectionError[];
 }
 
-export declare interface TestFileSelection {
-    include: readonly string[];
-    exclude?: readonly string[];
-}
+export { TestFileSelection }
 
 export declare interface TestOptions {
     maxConcurrency?: number;
@@ -317,6 +170,7 @@ export declare interface TestOutputDefinition {
 
 export declare type TestProjectCaseRunResult = CaseRunOutcome & {
     documentId: string;
+    documentRunId?: string;
 };
 
 export declare interface TestProjectCollectionError {
@@ -361,6 +215,8 @@ export declare interface TestProjectRunResult {
     cases: readonly TestProjectCaseRunResult[];
     documents: readonly WorkflowDocumentRunResult[];
     collectionErrors: readonly TestProjectCollectionError[];
+    /** Infrastructure/publication failures; completed Case results stay intact. */
+    errors?: readonly WorkflowError[];
 }
 
 export declare interface TestProjectRunSummary {
@@ -374,40 +230,13 @@ export declare interface TestProjectRunSummary {
     projectFailures: number;
 }
 
-export declare interface TestTagSelection {
-    include?: readonly string[];
-    exclude?: readonly string[];
-}
+export { TestTagSelection }
 
 export declare const validateTestFileSelection: (value: unknown, label?: string) => TestFileSelection | undefined;
 
-declare interface WorkflowDocumentRunResult {
-    documentId: string;
-    documentRunId: string;
-    projectId: string;
-    projectName: string;
-    sourcePath: string;
-    status: 'success' | 'failed';
-    startedAt: string;
-    endedAt: string;
-    durationMs: number;
+declare type WorkflowDocumentRunResult = Omit<Core.WorkflowDocumentRunResult, 'beforeAll' | 'afterAll' | 'reportSources' | 'reportScopeId'> & {
     beforeAll: StepRunResult[];
     afterAll: StepRunResult[];
-    teardownErrors?: WorkflowError[];
-    reportPaths?: string[];
-}
-
-declare class WorkflowError extends Error {
-    readonly code: string;
-    readonly details?: unknown;
-    constructor(message: string, options?: WorkflowErrorOptions);
-    toJSON(): Record<string, unknown>;
-}
-
-declare interface WorkflowErrorOptions {
-    code?: string;
-    details?: unknown;
-    cause?: unknown;
-}
+};
 
 export { }