@midscene/test 1.12.10-beta-20260920031616.0 → 1.13.0

package/dist/types/index.d.ts

@@ -1,115 +1,114 @@
-import { CaseRunResult as CaseRunResult_2 } from './engine/types';
-import type { TestRunReportDump } from '@midscene/core';
-import type { TestRunReportError } from '@midscene/core';
-import type { TestRunReportSource } from '@midscene/core';
-import type { TestRunReportSourceIndex } from '@midscene/core';
-import type { TestRunReportValue } from '@midscene/core';
-import { WorkflowDocumentRunResult as WorkflowDocumentRunResult_2 } from './engine/types';
+import { Awaitable } from '@midscene/core/internal/test-runner';
+import { buildTestRunReportDump } from '@midscene/core/internal/test-runner';
+import { CaseDefinition } from '@midscene/core/internal/test-runner';
+import { CaseExecutionContext } from '@midscene/core/internal/test-runner';
+import { CaseExecutionError } from '@midscene/core/internal/test-runner';
+import { CaseInput } from '@midscene/core/internal/test-runner';
+import { CaseNodePhase } from '@midscene/core/internal/test-runner';
+import { CaseRunner as CaseRunner_2 } from '@midscene/core/internal/test-runner';
+import { CaseRunStatus } from '@midscene/core/internal/test-runner';
+import { collectTestRunReportSources } from '@midscene/core/internal/test-runner';
+import type * as Core from '@midscene/core/internal/test-runner';
+import { createProjectRuntime } from '@midscene/core/internal/test-runner';
+import { DocumentNodePhase } from '@midscene/core/internal/test-runner';
+import { DuplicateNodeError } from '@midscene/core/internal/test-runner';
+import { DurationInput } from '@midscene/core/internal/test-runner';
+import { FatalDeviceError } from '@midscene/core/internal/test-runner';
+import { isFatalDeviceError } from '@midscene/core/internal/test-runner';
+import { JsonValue } from '@midscene/core/internal/test-runner';
+import { NodeCaseContext } from '@midscene/core/internal/test-runner';
+import { NodeDefinitionError } from '@midscene/core/internal/test-runner';
+import { NodeDocumentContext } from '@midscene/core/internal/test-runner';
+import { NodeExecutionError } from '@midscene/core/internal/test-runner';
+import { NodeExecutionPhase } from '@midscene/core/internal/test-runner';
+import { NodeExecutionReturn } from '@midscene/core/internal/test-runner';
+import { NodeInputSchema } from '@midscene/core/internal/test-runner';
+import { NodeInputValidationError } from '@midscene/core/internal/test-runner';
+import { NodeNotFoundError } from '@midscene/core/internal/test-runner';
+import { NodeRegistry as NodeRegistry_2 } from '@midscene/core/internal/test-runner';
+import { NodeReportCollector } from '@midscene/core/internal/test-runner';
+import { NodeReportTrace } from '@midscene/core/internal/test-runner';
+import { NodeResult } from '@midscene/core/internal/test-runner';
+import { NodeScopeTeardownError } from '@midscene/core/internal/test-runner';
+import { normalizeNodeExecutionError } from '@midscene/core/internal/test-runner';
+import { ProjectRuntime } from '@midscene/core/internal/test-runner';
+import { ProjectRuntimeOptions } from '@midscene/core/internal/test-runner';
+import { ProjectRuntimeResult } from '@midscene/core/internal/test-runner';
+import { ProjectSetupError } from '@midscene/core/internal/test-runner';
+import { ProjectTeardownError } from '@midscene/core/internal/test-runner';
+import { ResolveNodeForNormalization } from '@midscene/core/internal/test-runner';
+import { sanitizeReportError } from '@midscene/core/internal/test-runner';
+import { sanitizeReportText } from '@midscene/core/internal/test-runner';
+import { sanitizeReportValue } from '@midscene/core/internal/test-runner';
+import { StepExecutionInfo } from '@midscene/core/internal/test-runner';
+import { StepInput } from '@midscene/core/internal/test-runner';
+import { StepMetaInput } from '@midscene/core/internal/test-runner';
+import { StepStartHandler } from '@midscene/core/internal/test-runner';
+import { StepTimeoutError } from '@midscene/core/internal/test-runner';
+import { StepValue } from '@midscene/core/internal/test-runner';
+import { WorkflowDocumentDefinition } from '@midscene/core/internal/test-runner';
+import { WorkflowDocumentExecutionError } from '@midscene/core/internal/test-runner';
+import { WorkflowError } from '@midscene/core/internal/test-runner';
+import { WorkflowErrorOptions } from '@midscene/core/internal/test-runner';
+import { WorkflowLifecycleError } from '@midscene/core/internal/test-runner';
+import { WorkflowParseError } from '@midscene/core/internal/test-runner';
 import { z } from 'zod/v4';
 
-export declare type Awaitable<T> = T | Promise<T>;
+export { Awaitable }
 
-export declare function buildTestRunReportDump(result: TestProjectRunResult, index: TestRunReportSourceIndex): TestRunReportDump;
+export { buildTestRunReportDump }
 
-export declare interface CaseDefinition<TStep = StepInput> {
-    name: string;
-    tags?: readonly string[];
-    steps: readonly TStep[];
-}
+export { CaseDefinition }
 
-export declare interface CaseExecutionContext {
-    readonly caseId: string;
-    readonly runId: string;
-    readonly projectName: string;
-    readonly attemptIndex: number;
-    readonly name: string;
-    readonly sourcePath: string;
-    readonly caseIndex: number;
-}
+export { CaseExecutionContext }
 
-export declare class CaseExecutionError extends WorkflowError {
-    readonly result: CaseRunResult_2;
-    constructor(result: CaseRunResult_2);
-}
+export { CaseExecutionError }
 
-export declare interface CaseInput {
-    name?: string;
-    tags?: readonly string[];
-    steps: readonly StepInput[];
-}
+export { CaseInput }
 
-export declare type CaseNodePhase = 'beforeEach' | 'steps' | 'afterEach';
+export { CaseNodePhase }
 
-export declare class CaseRunner<TContext = undefined> {
+export declare type CaseRunner<TContext = undefined> = Omit<CaseRunner_2<TContext>, 'run' | 'register' | 'registry'> & {
     readonly registry: NodeRegistry;
-    readonly context: TContext;
-    constructor(options?: CaseRunnerOptions<TContext>);
-    register<TInput, TData>(node: NodeDefinition<TInput, TData, TContext>): this;
+    register<TInput, TData>(node: NodeDefinition<TInput, TData, TContext>): CaseRunner<TContext>;
     run(input: CaseInput): Promise<CaseRunResult>;
-}
+};
+
+export declare const CaseRunner: {
+    new <TContext = undefined>(options?: CaseRunnerOptions<TContext>): CaseRunner<TContext>;
+};
 
-export declare interface CaseRunnerOptions<TContext = undefined> {
+export declare type CaseRunnerOptions<TContext = undefined> = Omit<Core.CaseRunnerOptions<TContext>, 'nodes'> & {
     nodes?: readonly NodeDefinition<any, any, TContext>[];
-    context?: TContext;
-}
+};
 
-export declare interface CaseRunOutcome {
-    caseId: string;
-    projectName: string;
-    name: string;
-    sourcePath: string;
-    caseIndex: number;
-    status: CaseRunStatus;
+export 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';
-}
+};
 
-export declare interface CaseRunResult {
-    caseId: string;
-    runId: string;
-    projectName: string;
-    attemptIndex: number;
-    name: string;
-    sourcePath: string;
-    caseIndex: number;
-    status: 'success' | 'failed';
+export 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;
-}
+};
 
-export declare type CaseRunStatus = 'success' | 'failed' | 'not-run';
+export { CaseRunStatus }
 
-export declare interface CollectedCase {
-    caseId: string;
-    projectId: string;
-    sourcePath: string;
-    caseIndex: number;
+export declare type CollectedCase = Omit<Core.CollectedCase, 'definition'> & {
     definition: NormalizedCaseDefinition;
-}
+};
 
-export declare interface CollectedDocumentLifecycle {
-    beforeAll: readonly NormalizedStep[];
-    beforeEach: readonly NormalizedStep[];
-    afterEach: readonly NormalizedStep[];
-    afterAll: readonly NormalizedStep[];
-}
+export declare type CollectedDocumentLifecycle = {
+    [K in keyof Core.CollectedDocumentLifecycle]: readonly NormalizedStep[];
+};
 
-export declare interface CollectedWorkflowDocument {
-    documentId: string;
-    projectId: string;
-    sourcePath: string;
-    lifecycle: CollectedDocumentLifecycle;
+export declare type CollectedWorkflowDocument = Omit<Core.CollectedWorkflowDocument, 'cases' | 'lifecycle'> & {
     cases: readonly CollectedCase[];
-}
+    lifecycle: CollectedDocumentLifecycle;
+};
 
-export declare function collectTestRunReportSources(result: TestProjectRunResult): TestRunReportSource[];
+export { collectTestRunReportSources }
 
 export declare function collectWorkflowDocument(source: WorkflowDocumentSource, options: CollectWorkflowDocumentOptions): CollectedWorkflowDocument;
 
@@ -121,275 +120,131 @@ export declare interface CollectWorkflowDocumentOptions {
 
 export declare const createCaseId: (projectId: string, sourcePath: string, caseIndex: number) => string;
 
-export declare function createCaseRunner<TContext = undefined>(options?: CaseRunnerOptions<TContext>): CaseRunner<TContext>;
+export declare const createCaseRunner: <TContext = undefined>(options?: CaseRunnerOptions<TContext>) => CaseRunner<TContext>;
 
-export declare function createDocumentRuntime<TContext = undefined>(document: CollectedWorkflowDocument, options: CreateDocumentRuntimeOptions<TContext>): WorkflowDocumentRuntime<TContext>;
+export declare const createDocumentRuntime: <TContext = undefined>(document: CollectedWorkflowDocument, options: CreateDocumentRuntimeOptions<TContext>) => WorkflowDocumentRuntime<TContext>;
 
-export declare interface CreateDocumentRuntimeOptions<TContext = undefined> {
+export declare type CreateDocumentRuntimeOptions<TContext = undefined> = Omit<Core.CreateDocumentRuntimeOptions<TContext>, 'documentSetup' | 'documentAttemptIndex' | 'resolveNode' | 'onStepResult' | 'onResult'> & {
     resolveNode(name: string): NodeDefinition<any, any, TContext>;
-    project?: ResolvedExecutionProject<TContext>;
-    projectContext?: TContext;
-    signal?: AbortSignal;
-    defaultTimeoutMs?: number;
-    onStepStart?: StepStartHandler;
     onStepResult?: StepResultHandler;
-    onResult?(result: WorkflowDocumentRunResult): Awaitable<unknown>;
-    createDocumentRunId?(): string;
-}
+    onResult?(result: WorkflowDocumentRunResult): Core.Awaitable<unknown>;
+};
 
-export declare const createProjectRuntime: <TProjectContext = unknown>(options: ProjectRuntimeOptions<TProjectContext>) => ProjectRuntime<TProjectContext>;
+export { createProjectRuntime }
 
 export declare const createWorkflowDocumentId: (projectId: string, sourcePath: string) => string;
 
-export declare function defineNode<TSchema extends NodeInputSchema, TData = unknown, TContext = unknown>(options: DefineNodeWithSchemaOptions<TSchema, TData, TContext>): NodeDefinitionWithSchema<TSchema, TData, TContext>;
+declare interface DefineNativeNode {
+    <TSchema extends NodeInputSchema, TData = unknown, TContext = unknown>(options: DefineNodeWithSchemaOptions<TSchema, TData, TContext>): NodeDefinitionWithSchema<TSchema, TData, TContext>;
+    <TInput = unknown, TData = unknown, TContext = unknown>(options: DefineNodeOptions<TInput, TData, TContext>): NodeDefinition<TInput, TData, TContext>;
+}
 
-export declare function defineNode<TInput = unknown, TData = unknown, TContext = unknown>(options: DefineNodeOptions<TInput, TData, TContext>): NodeDefinition<TInput, TData, TContext>;
+export declare const defineNode: DefineNativeNode;
 
-export 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>;
-}
+export 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 type DefineNodeWithSchemaOptions<TSchema extends NodeInputSchema, TData = unknown, TContext = unknown> = Omit<DefineNodeOptions<z.output<TSchema>, TData, TContext>, 'inputSchema'> & {
+export declare type DefineNodeWithSchemaOptions<TSchema extends Core.NodeInputSchema, TData = unknown, TContext = unknown> = Omit<DefineNodeOptions<z.output<TSchema>, TData, TContext>, 'inputSchema'> & {
     inputSchema: TSchema;
 };
 
-export declare type DocumentNodePhase = 'beforeAll' | 'afterAll';
+export { DocumentNodePhase }
 
-export declare class DuplicateNodeError extends WorkflowError {
-    readonly node: string;
-    constructor(node: string);
-}
-
-export declare type DurationInput = number;
+export { DuplicateNodeError }
 
-export declare class FatalDeviceError extends WorkflowError {
-    constructor(message: string, cause?: unknown);
-}
+export { DurationInput }
 
-export declare const isFatalDeviceError: (error: unknown) => boolean;
+export { FatalDeviceError }
 
-declare type JsonPrimitive = string | number | boolean | null;
+export { isFatalDeviceError }
 
-declare type JsonValue = JsonPrimitive | readonly JsonValue[] | {
-    readonly [key: string]: JsonValue;
-};
+declare type NativeNodeContext<T> = T extends unknown ? Omit<T, '$' | 'onTeardown'> & {
+    $: Readonly<NormalizedStepMeta>;
+    onTeardown(teardown: NodeScopeTeardown): void;
+} : never;
 
-export declare interface NodeCaseContext extends CaseExecutionContext {
-    readonly phase: CaseNodePhase;
-    readonly stepIndex: number;
+export declare class NativeWorkflowFormatError extends WorkflowParseError {
+    readonly actualFormat: 'legacy' | 'legacy-batch' | 'mixed';
+    constructor(actualFormat: 'legacy' | 'legacy-batch' | 'mixed', sourcePath: string);
 }
 
-export declare interface NodeDefinition<TInput = unknown, TData = unknown, TContext = unknown> extends DefineNodeOptions<TInput, TData, TContext> {
-}
+export { NodeCaseContext }
 
-export declare class NodeDefinitionError extends WorkflowError {
-    constructor(message: string, details?: unknown);
-}
+export declare type NodeDefinition<TInput = unknown, TData = unknown, TContext = unknown> = DefineNodeOptions<TInput, TData, TContext>;
 
-export declare type NodeDefinitionWithSchema<TSchema extends NodeInputSchema, TData = unknown, TContext = unknown> = NodeDefinition<z.output<TSchema>, TData, TContext> & {
+export { NodeDefinitionError }
+
+export declare type NodeDefinitionWithSchema<TSchema extends Core.NodeInputSchema, TData = unknown, TContext = unknown> = NodeDefinition<z.output<TSchema>, TData, TContext> & {
     inputSchema: TSchema;
 };
 
-export declare interface NodeDocumentContext {
-    readonly documentId: string;
-    readonly documentRunId: string;
-    readonly projectId: string;
-    readonly projectName: string;
-    readonly sourcePath: string;
-    readonly phase: DocumentNodePhase;
-    readonly stepIndex: number;
-}
+export { NodeDocumentContext }
 
-export 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. */
-    $: 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;
-}
+export declare type NodeExecutionContext<TInput = unknown, TContext = unknown> = NativeNodeContext<Core.NodeExecutionContext<TInput, TContext>>;
 
-export declare class NodeExecutionError extends WorkflowError {
-    readonly node: string;
-    constructor(node: string, cause: unknown);
-}
+export { NodeExecutionError }
 
-export declare type NodeExecutionPhase = CaseNodePhase | DocumentNodePhase;
+export { NodeExecutionPhase }
 
-export declare type NodeExecutionReturn<TData = unknown> = Promise<NodeResult<TData> | void> | NodeResult<TData> | void;
+export { NodeExecutionReturn }
 
-export declare type NodeInputSchema = z.ZodObject;
+export { NodeInputSchema }
 
-export declare class NodeInputValidationError extends WorkflowError {
-    constructor(message: string, details?: unknown);
-    static fromZod(node: string, error: z.ZodError): NodeInputValidationError;
-}
+export { NodeInputValidationError }
 
-export declare class NodeNotFoundError extends WorkflowError {
-    readonly node: string;
-    constructor(node: string);
-}
+export { NodeNotFoundError }
 
-export declare class NodeRegistry {
-    #private;
-    constructor(nodes?: readonly NodeDefinition<any, any>[]);
-    register<TInput, TData>(node: NodeDefinition<TInput, TData>): this;
+export 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. */
-export declare interface NodeReportCollector {
-    addTrace(trace: NodeReportTrace): void;
-}
-
-/** A stable reference from one test Step to report detail data. */
-export declare interface NodeReportTrace {
-    type: 'midscene-execution';
-    executionId: string;
-}
-
-export declare interface NodeResult<TData = unknown> {
-    /** Human-readable summary for reports. */
-    summary?: string;
-    /** Structured data included in the step result. */
-    data?: TData;
-}
+};
 
-export declare type NodeScopeTeardown = () => Awaitable<NodeScopeTeardownResult | void>;
+export declare const NodeRegistry: {
+    new (nodes?: readonly NodeDefinition<any, any>[]): NodeRegistry;
+};
 
-export declare class NodeScopeTeardownError extends WorkflowError {
-    constructor(cause: unknown, details: {
-        scope: 'case' | 'document';
-        scopeId: string;
-        node: string;
-        registrationIndex: number;
-    });
-}
+export { NodeReportCollector }
 
-export declare interface NodeScopeTeardownResult {
-    /** Absolute paths to Midscene reports produced by this execution scope. */
-    reportPaths?: readonly string[];
-}
+export { NodeReportTrace }
 
-export declare type NormalizedCaseDefinition = CaseDefinition<NormalizedStep>;
+export { NodeResult }
 
-export declare interface NormalizedStep {
-    node: string;
-    input: Record<string, unknown>;
-    meta: NormalizedStepMeta;
-}
+export declare type NodeScopeTeardown = () => Core.Awaitable<NodeScopeTeardownOutput>;
 
-export declare interface NormalizedStepMeta {
-    timeoutMs?: number;
-    continueOnError: boolean;
-}
+export { NodeScopeTeardownError }
 
-export declare function normalizeNodeExecutionError(error: unknown, node: string): WorkflowError;
+declare type NodeScopeTeardownOutput = NodeScopeTeardownResult | void;
 
-export declare function normalizeStep(value: unknown, index?: number, resolveNode?: ResolveNodeForNormalization): NormalizedStep;
+export declare type NodeScopeTeardownResult = Omit<Core.NodeScopeTeardownResult, 'reportSources'>;
 
-export declare function normalizeSteps(steps: unknown, resolveNode?: ResolveNodeForNormalization): NormalizedStep[];
+export declare type NormalizedCaseDefinition = Core.CaseDefinition<NormalizedStep>;
 
-export declare interface ProjectRuntime<TProjectContext = unknown> {
-    readonly context: TProjectContext | undefined;
-    readonly signal: AbortSignal;
-    readonly canRun: boolean;
-    start(): Promise<ProjectRuntimeResult<TProjectContext>>;
-    finish(status?: 'success' | 'failed'): Promise<ProjectRuntimeResult<TProjectContext>>;
-    abort(reason?: unknown): void;
-}
+export declare type NormalizedStep = Omit<Core.NormalizedStep, 'meta'> & {
+    meta: NormalizedStepMeta;
+};
 
-export declare interface ProjectRuntimeOptions<TProjectContext = unknown> {
-    project: ResolvedExecutionProject<TProjectContext>;
-    setup?: ProjectSetupDefinition<TProjectContext>;
-    signal?: AbortSignal;
-}
+export declare type NormalizedStepMeta = Omit<Core.NormalizedStepMeta, 'captureResult' | 'resultName'>;
 
-export declare interface ProjectRuntimeResult<TProjectContext = unknown> {
-    projectName: string;
-    status: 'success' | 'failed';
-    setupError?: WorkflowError;
-    teardownErrors?: readonly WorkflowError[];
-    startedAt: string;
-    endedAt: string;
-    durationMs: number;
-}
+export { normalizeNodeExecutionError }
 
-declare interface ProjectSetupContext<TProjectContext = unknown> {
-    readonly project: ResolvedExecutionProject<TProjectContext>;
-    readonly env: Readonly<NodeJS.ProcessEnv>;
-    readonly signal: AbortSignal;
-    onTeardown(teardown: ProjectTeardown<TProjectContext>): void;
-}
+export declare const normalizeStep: (value: unknown, index?: number, resolveNode?: ResolveNodeForNormalization) => NormalizedStep;
 
-declare interface ProjectSetupDefinition<TProjectContext = unknown> {
-    name: string;
-    setup(ctx: ProjectSetupContext<TProjectContext>): Awaitable<TProjectContext>;
-}
+export declare const normalizeSteps: (values: unknown, resolveNode?: ResolveNodeForNormalization) => NormalizedStep[];
 
-export declare class ProjectSetupError extends WorkflowError {
-    constructor(cause: unknown, details: {
-        projectName: string;
-    });
-}
+export { ProjectRuntime }
 
-declare type ProjectTeardown<TProjectContext = unknown> = (ctx: ProjectTeardownContext<TProjectContext>) => Awaitable<void>;
+export { ProjectRuntimeOptions }
 
-declare interface ProjectTeardownContext<TProjectContext = unknown> {
-    readonly project: ResolvedExecutionProject<TProjectContext>;
-    readonly context: TProjectContext | undefined;
-    readonly status: 'success' | 'failed';
-    readonly setupError?: WorkflowError;
-}
+export { ProjectRuntimeResult }
 
-export declare class ProjectTeardownError extends WorkflowError {
-    constructor(cause: unknown, details: {
-        projectName: string;
-        registrationIndex: number;
-    });
-}
+export { ProjectSetupError }
 
-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 { ProjectTeardownError }
 
-export declare type ResolveNodeForNormalization = (name: string) => StringInputNodeDefinition | undefined;
+export { ResolveNodeForNormalization }
 
 export declare const resolveWorkflowVariables: (value: unknown, options: ResolveWorkflowVariablesOptions) => unknown;
 
@@ -399,172 +254,51 @@ export declare interface ResolveWorkflowVariablesOptions {
     location: VariableResolutionLocation;
 }
 
-export declare interface RunCollectedCaseOptions<TContext = undefined> {
+export declare type RunCollectedCaseOptions<TContext = undefined> = Omit<Core.RunCollectedCaseOptions<TContext>, 'reportScopeId' | 'resolveNode' | 'beforeEach' | 'afterEach' | 'onStepResult' | 'onResult'> & {
     resolveNode(name: string): NodeDefinition<any, any, TContext>;
     beforeEach?: readonly NormalizedStep[];
     afterEach?: readonly NormalizedStep[];
-    context?: TContext;
-    projectName?: string;
-    attemptIndex?: number;
-    signal?: AbortSignal;
-    defaultTimeoutMs?: number;
-    onStepStart?: StepStartHandler;
     onStepResult?: StepResultHandler;
-    onResult?(result: CaseRunResult): Awaitable<unknown>;
-    createRunId?(): string;
-}
+    onResult?(result: CaseRunResult): Core.Awaitable<unknown>;
+};
 
-export declare function runWorkflowDocument<TContext = undefined>(document: CollectedWorkflowDocument, options: RunWorkflowDocumentOptions<TContext>): Promise<WorkflowDocumentExecutionResult>;
+export declare const runWorkflowDocument: <TContext = undefined>(document: CollectedWorkflowDocument, options: RunWorkflowDocumentOptions<TContext>) => Promise<WorkflowDocumentExecutionResult>;
 
-export declare interface RunWorkflowDocumentOptions<TContext = undefined> {
+export declare type RunWorkflowDocumentOptions<TContext = undefined> = Omit<Core.RunWorkflowDocumentOptions<TContext>, 'documentSetup' | 'documentAttemptIndex' | 'resolveCaseReportScopeId' | 'resolveNode' | 'onStepResult' | 'onCaseStart' | 'isFatalError' | 'onCaseResult' | 'onCaseOutcome' | 'onDocumentResult' | 'createCaseRunId' | 'createDocumentRunId'> & {
     resolveNode(name: string): NodeDefinition<any, any, TContext>;
-    project?: ResolvedExecutionProject<TContext>;
-    projectContext?: TContext;
-    retry?: number;
-    signal?: AbortSignal;
-    defaultTimeoutMs?: number;
-    shouldStop?(): boolean;
-    stopReason?(): NonNullable<CaseRunOutcome['notRunReason']>;
-    isFatalError?(result: CaseRunResult): boolean;
-    onCaseStart?(collectedCase: CollectedCase): Awaitable<void>;
-    onStepStart?: StepStartHandler;
     onStepResult?: StepResultHandler;
-    onCaseResult?(result: CaseRunResult): Awaitable<unknown>;
-    onCaseOutcome?(result: CaseRunOutcome): Awaitable<unknown>;
-    onDocumentResult?(result: WorkflowDocumentRunResult): Awaitable<unknown>;
+    onCaseStart?(collectedCase: CollectedCase): Core.Awaitable<void>;
+    isFatalError?(result: CaseRunResult): boolean;
+    onCaseResult?(result: CaseRunResult): Core.Awaitable<unknown>;
+    onCaseOutcome?(result: CaseRunOutcome): Core.Awaitable<unknown>;
+    onDocumentResult?(result: WorkflowDocumentRunResult): Core.Awaitable<unknown>;
     createCaseRunId?(collectedCase: CollectedCase, attemptIndex: number): string;
     createDocumentRunId?(document: CollectedWorkflowDocument): string;
-}
-
-export declare function sanitizeReportError(error: unknown): TestRunReportError;
-
-export declare function sanitizeReportText(value: string, maximumLength?: number): string;
-
-/** Convert arbitrary Node input/output to a bounded, JSON-safe display value. */
-export declare function sanitizeReportValue(value: unknown): TestRunReportValue;
-
-export declare type StepExecutionInfo = {
-    scope: 'case';
-    node: string;
-    stepCount: number;
-    case: NodeCaseContext;
-    document?: never;
-} | {
-    scope: 'document';
-    node: string;
-    stepCount: number;
-    document: NodeDocumentContext;
-    case?: never;
 };
 
-export declare type StepInput = Record<string, unknown>;
-
-export declare interface StepMetaInput {
-    timeout?: DurationInput;
-    'continue-on-error'?: boolean;
-}
-
-export declare type StepResultHandler = (info: StepExecutionInfo, result: StepRunResult) => Awaitable<unknown>;
-
-export declare interface StepRunResult<TOutputData = unknown> {
-    phase: NodeExecutionPhase;
-    stepIndex: number;
-    node: string;
-    input: unknown;
-    meta: NormalizedStepMeta;
-    status: 'success' | 'failed';
-    continuedAfterError: boolean;
-    startedAt: string;
-    endedAt: string;
-    durationMs: number;
-    output?: NodeResult<TOutputData>;
-    error?: WorkflowError;
-    report?: {
-        traces: readonly NodeReportTrace[];
-    };
-}
+export { sanitizeReportError }
 
-export declare type StepStartHandler = (info: StepExecutionInfo) => Awaitable<unknown>;
+export { sanitizeReportText }
 
-export declare class StepTimeoutError extends WorkflowError {
-    readonly timeoutMs: number;
-    readonly node?: string;
-    constructor(timeoutMs: number, node?: string);
-}
+export { sanitizeReportValue }
 
-export declare type StepValue = string | Record<string, unknown>;
+export { StepExecutionInfo }
 
-declare interface StringInputNodeDefinition {
-    stringInputKey?: string | false;
-}
+export { StepInput }
 
-declare interface TestExecutionProjectRunResult {
-    projectId: string;
-    name: string;
-    status: 'success' | 'failed';
-    retry: number;
-    fileSelection: TestFileSelection;
-    tagSelection: Readonly<Required<TestTagSelection>>;
-    sourceCount: number;
-    selectedCaseCount: number;
-    filteredCaseCount: number;
-    lifecycle?: ProjectRuntimeResult;
-    cases: readonly TestProjectCaseRunResult[];
-    documents: readonly WorkflowDocumentRunResult[];
-    collectionErrors: readonly TestProjectCollectionError[];
-}
+export { StepMetaInput }
 
-declare interface TestFileSelection {
-    include: readonly string[];
-    exclude?: readonly string[];
-}
+export declare type StepResultHandler = (info: Core.StepExecutionInfo, result: StepRunResult) => Core.Awaitable<unknown>;
 
-declare type TestProjectCaseRunResult = CaseRunOutcome & {
-    documentId: string;
+export declare type StepRunResult<TData = unknown> = Omit<Core.StepRunResult<TData>, 'meta'> & {
+    meta: NormalizedStepMeta;
 };
 
-declare interface TestProjectCollectionError {
-    projectId: string;
-    projectName: string;
-    sourcePath: string;
-    error: WorkflowError;
-}
+export { StepStartHandler }
 
-declare interface TestProjectRunResult {
-    schemaVersion: 3;
-    runId: string;
-    startedAt: string;
-    endedAt: string;
-    durationMs: number;
-    status: 'success' | 'failed';
-    exitCode: 0 | 1;
-    resultDir: string;
-    summaryPath: string;
-    reportDir: string;
-    /** Absolute path to the unified Midscene Test HTML report. */
-    reportPath?: string;
-    summary: TestProjectRunSummary;
-    projects: readonly TestExecutionProjectRunResult[];
-    cases: readonly TestProjectCaseRunResult[];
-    documents: readonly WorkflowDocumentRunResult[];
-    collectionErrors: readonly TestProjectCollectionError[];
-}
+export { StepTimeoutError }
 
-declare interface TestProjectRunSummary {
-    total: number;
-    passed: number;
-    failed: number;
-    notRun: number;
-    filtered: number;
-    collectionErrors: number;
-    documentFailures: number;
-    projectFailures: number;
-}
-
-declare interface TestTagSelection {
-    include?: readonly string[];
-    exclude?: readonly string[];
-}
+export { StepValue }
 
 export declare interface VariableResolutionLocation {
     projectName: string;
@@ -574,74 +308,34 @@ export declare interface VariableResolutionLocation {
     caseIndex?: number;
 }
 
-export declare interface WorkflowDocumentDefinition {
-    beforeAll?: readonly StepInput[];
-    beforeEach?: readonly StepInput[];
-    cases: readonly CaseDefinition[];
-    afterEach?: readonly StepInput[];
-    afterAll?: readonly StepInput[];
-}
+export { WorkflowDocumentDefinition }
 
-export declare class WorkflowDocumentExecutionError extends WorkflowError {
-    readonly result: WorkflowDocumentRunResult_2;
-    constructor(result: WorkflowDocumentRunResult_2);
-}
+export { WorkflowDocumentExecutionError }
 
-export declare interface WorkflowDocumentExecutionResult {
+export declare type WorkflowDocumentExecutionResult = {
     document: WorkflowDocumentRunResult;
     cases: readonly CaseRunOutcome[];
-}
+};
 
-export declare interface WorkflowDocumentRunResult {
-    documentId: string;
-    documentRunId: string;
-    projectId: string;
-    projectName: string;
-    sourcePath: string;
-    status: 'success' | 'failed';
-    startedAt: string;
-    endedAt: string;
-    durationMs: number;
+export declare type WorkflowDocumentRunResult = Omit<Core.WorkflowDocumentRunResult, 'beforeAll' | 'afterAll' | 'reportSources' | 'reportScopeId'> & {
     beforeAll: StepRunResult[];
     afterAll: StepRunResult[];
-    teardownErrors?: WorkflowError[];
-    reportPaths?: string[];
-}
+};
 
-export declare interface WorkflowDocumentRuntime<TContext = undefined> {
-    readonly context: TContext;
-    readonly canRunCases: boolean;
+export declare type WorkflowDocumentRuntime<TContext = undefined> = Omit<Core.WorkflowDocumentRuntime<TContext>, 'signal' | 'start' | 'finish'> & {
     start(): Promise<WorkflowDocumentRunResult>;
     finish(): Promise<WorkflowDocumentRunResult>;
-}
+};
 
-export declare interface WorkflowDocumentSource {
-    projectId: string;
-    projectName?: string;
-    sourcePath: string;
-    absolutePath: string;
-}
+export declare type WorkflowDocumentSource = Omit<Core.WorkflowDocumentSource, 'invocationIndex'>;
 
-export declare class WorkflowError extends Error {
-    readonly code: string;
-    readonly details?: unknown;
-    constructor(message: string, options?: WorkflowErrorOptions);
-    toJSON(): Record<string, unknown>;
-}
+export { WorkflowError }
 
-export declare interface WorkflowErrorOptions {
-    code?: string;
-    details?: unknown;
-    cause?: unknown;
-}
+export { WorkflowErrorOptions }
 
-export declare class WorkflowLifecycleError extends WorkflowError {
-    constructor(message: string, details?: unknown);
-}
+export { WorkflowLifecycleError }
 
-export declare class WorkflowParseError extends WorkflowError {
-    constructor(message: string, details?: unknown, cause?: unknown);
-}
+export { WorkflowParseError }
 
 export { z }