@midscene/core 1.12.10-beta-20260920031616.0 → 1.13.0

package/dist/es/test-runner/engine/run-collected-case.mjs

@@ -0,0 +1,193 @@
+import { getDebug } from "@midscene/shared/logger";
+import { uuid } from "@midscene/shared/utils";
+import { NodeScopeTeardownError, WorkflowLifecycleError } from "../errors.mjs";
+import { executeStep } from "./execute-step.mjs";
+import { WorkflowExecutionFailure, asExecutionError } from "./execution-failure.mjs";
+import { ResourceCleanupDeferredError, cleanupScopeResources, createResourceScope } from "./resource-operations.mjs";
+import { reportPathsFromTeardown } from "./scope-teardown.mjs";
+async function runCollectedCase(collectedCase, options) {
+    const phases = {
+        beforeEach: options.beforeEach ?? [],
+        steps: collectedCase.definition.steps,
+        afterEach: options.afterEach ?? []
+    };
+    const nodes = {
+        beforeEach: phases.beforeEach.map((step)=>options.resolveNode(step.node)),
+        steps: phases.steps.map((step)=>options.resolveNode(step.node)),
+        afterEach: phases.afterEach.map((step)=>options.resolveNode(step.node))
+    };
+    const resourceScope = createResourceScope(options.signal);
+    const scopeSignal = resourceScope.signal;
+    const runId = options.createRunId?.() ?? uuid();
+    const startedAt = new Date();
+    const beforeEach = [];
+    const steps = [];
+    const afterEach = [];
+    const teardownStack = [];
+    let acceptingTeardowns = true;
+    const onTeardown = (node, teardown)=>{
+        if (!acceptingTeardowns) throw new WorkflowLifecycleError('Node teardown can only be registered while a case attempt is running.', {
+            runId,
+            node
+        });
+        if ('function' != typeof teardown) throw new WorkflowLifecycleError('Node onTeardown() requires a teardown function.', {
+            runId,
+            node
+        });
+        teardownStack.push({
+            registrationIndex: teardownStack.length,
+            node,
+            teardown
+        });
+    };
+    const runPhase = async (phase, results, signal = scopeSignal)=>{
+        for (const [stepIndex, step] of phases[phase].entries()){
+            const caseContext = {
+                caseId: collectedCase.caseId,
+                runId,
+                projectName: options.projectName ?? collectedCase.projectId,
+                attemptIndex: options.attemptIndex ?? 0,
+                name: collectedCase.definition.name,
+                sourcePath: collectedCase.sourcePath,
+                caseIndex: collectedCase.caseIndex,
+                phase,
+                stepIndex
+            };
+            const stepInfo = {
+                scope: 'case',
+                node: step.node,
+                stepCount: phases[phase].length,
+                case: caseContext
+            };
+            await options.onStepStart?.(stepInfo);
+            const result = await executeStep(step, nodes[phase][stepIndex], {
+                scope: 'case',
+                case: caseContext
+            }, options.context, {
+                signal,
+                defaultTimeoutMs: options.defaultTimeoutMs,
+                onTeardown
+            });
+            results.push(result);
+            await options.onStepResult?.(stepInfo, result);
+            if ('failed' === result.status && !result.continuedAfterError) break;
+        }
+    };
+    const executionErrors = [];
+    try {
+        await runPhase('beforeEach', beforeEach);
+        if (!beforeEach.some((step)=>'failed' === step.status)) await runPhase('steps', steps);
+    } catch (error) {
+        executionErrors.push(error);
+    }
+    const teardownErrors = [];
+    const reportPaths = new Set();
+    const reportSources = [];
+    const cleanupExecutionErrors = [];
+    let deferredCleanup = false;
+    const cleanup = async ()=>{
+        const priorTeardownErrors = teardownErrors.length;
+        acceptingTeardowns = false;
+        for (const { registrationIndex, node, teardown } of teardownStack.reverse())try {
+            const released = await teardown();
+            reportSources.push(...released?.reportSources ?? []);
+            for (const path of reportPathsFromTeardown(released))reportPaths.add(path);
+        } catch (error) {
+            teardownErrors.push(new NodeScopeTeardownError(error, {
+                scope: 'case',
+                scopeId: runId,
+                node,
+                registrationIndex
+            }));
+        }
+        if (deferredCleanup) {
+            const errors = [
+                ...cleanupExecutionErrors,
+                ...teardownErrors.slice(priorTeardownErrors)
+            ];
+            if (errors.length) throw new AggregateError(errors, 'Deferred Case cleanup failed');
+        }
+    };
+    try {
+        if (phases.afterEach.length || teardownStack.length) await cleanupScopeResources(scopeSignal, cleanup, {
+            beforeCleanup: async (cleanupSignal)=>{
+                try {
+                    await runPhase('afterEach', afterEach, cleanupSignal);
+                } catch (error) {
+                    executionErrors.push(error);
+                    cleanupExecutionErrors.push(error);
+                }
+            },
+            onDeferredError: (error)=>getDebug('runner:cleanup', {
+                    console: true
+                })(`Deferred Case cleanup failed: ${String(error)}`)
+        });
+        else acceptingTeardowns = false;
+    } catch (error) {
+        deferredCleanup = error instanceof ResourceCleanupDeferredError;
+        if (!deferredCleanup) acceptingTeardowns = false;
+        teardownErrors.push(new NodeScopeTeardownError(error, {
+            scope: 'case',
+            scopeId: runId,
+            node: 'resource-drain',
+            registrationIndex: -1
+        }));
+    }
+    const endedAt = new Date();
+    const result = {
+        caseId: collectedCase.caseId,
+        runId,
+        projectName: options.projectName ?? collectedCase.projectId,
+        attemptIndex: options.attemptIndex ?? 0,
+        name: collectedCase.definition.name,
+        sourcePath: collectedCase.sourcePath,
+        caseIndex: collectedCase.caseIndex,
+        status: executionErrors.length > 0 || beforeEach.some((step)=>'failed' === step.status) || steps.some((step)=>'failed' === step.status) || afterEach.some((step)=>'failed' === step.status) || teardownErrors.length > 0 ? 'failed' : 'success',
+        beforeEach: [
+            ...beforeEach
+        ],
+        steps: [
+            ...steps
+        ],
+        afterEach: [
+            ...afterEach
+        ],
+        ...executionErrors.length ? {
+            executionErrors: executionErrors.map(asExecutionError)
+        } : {},
+        ...teardownErrors.length > 0 ? {
+            teardownErrors: [
+                ...teardownErrors
+            ]
+        } : {},
+        ...reportPaths.size > 0 ? {
+            reportPaths: [
+                ...reportPaths
+            ]
+        } : {},
+        ...reportSources.length ? {
+            reportSources: [
+                ...reportSources
+            ]
+        } : {},
+        ...options.reportScopeId ? {
+            reportScopeId: options.reportScopeId
+        } : {},
+        startedAt: startedAt.toISOString(),
+        endedAt: endedAt.toISOString(),
+        durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime())
+    };
+    try {
+        await options.onResult?.(result);
+    } catch (error) {
+        executionErrors.push(error);
+        result.status = 'failed';
+        result.executionErrors = executionErrors.map(asExecutionError);
+    }
+    resourceScope.dispose();
+    if (executionErrors.length) throw new WorkflowExecutionFailure(result, executionErrors);
+    return result;
+}
+export { runCollectedCase };
+
+//# sourceMappingURL=run-collected-case.mjs.map

package/dist/es/test-runner/engine/run-collected-case.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner/engine/run-collected-case.mjs","sources":["../../../../src/test-runner/engine/run-collected-case.ts"],"sourcesContent":["import { getDebug } from '@midscene/shared/logger';\nimport { uuid as randomUUID } from '@midscene/shared/utils';\nimport { NodeScopeTeardownError, WorkflowLifecycleError } from '../errors';\nimport type { CollectedCase, NormalizedStep } from '../parser/types';\nimport { executeStep } from './execute-step';\nimport {\n  WorkflowExecutionFailure,\n  asExecutionError,\n} from './execution-failure';\nimport {\n  ResourceCleanupDeferredError,\n  cleanupScopeResources,\n  createResourceScope,\n} from './resource-operations';\nimport { reportPathsFromTeardown } from './scope-teardown';\nimport type {\n  CaseNodePhase,\n  CaseRunResult,\n  NodeCaseContext,\n  NodeScopeTeardown,\n  RunCollectedCaseOptions,\n  StepRunResult,\n} from './types';\n\nexport async function runCollectedCase<TContext = undefined>(\n  collectedCase: CollectedCase,\n  options: RunCollectedCaseOptions<TContext>,\n): Promise<CaseRunResult> {\n  const phases: Record<CaseNodePhase, readonly NormalizedStep[]> = {\n    beforeEach: options.beforeEach ?? [],\n    steps: collectedCase.definition.steps,\n    afterEach: options.afterEach ?? [],\n  };\n  const nodes = {\n    beforeEach: phases.beforeEach.map((step) => options.resolveNode(step.node)),\n    steps: phases.steps.map((step) => options.resolveNode(step.node)),\n    afterEach: phases.afterEach.map((step) => options.resolveNode(step.node)),\n  };\n  const resourceScope = createResourceScope(options.signal);\n  const scopeSignal = resourceScope.signal;\n  const runId = options.createRunId?.() ?? randomUUID();\n  const startedAt = new Date();\n  const beforeEach: StepRunResult[] = [];\n  const steps: StepRunResult[] = [];\n  const afterEach: StepRunResult[] = [];\n  const teardownStack: Array<{\n    registrationIndex: number;\n    node: string;\n    teardown: NodeScopeTeardown;\n  }> = [];\n  let acceptingTeardowns = true;\n\n  const onTeardown = (node: string, teardown: NodeScopeTeardown): void => {\n    if (!acceptingTeardowns) {\n      throw new WorkflowLifecycleError(\n        'Node teardown can only be registered while a case attempt is running.',\n        { runId, node },\n      );\n    }\n    if (typeof teardown !== 'function') {\n      throw new WorkflowLifecycleError(\n        'Node onTeardown() requires a teardown function.',\n        { runId, node },\n      );\n    }\n    teardownStack.push({\n      registrationIndex: teardownStack.length,\n      node,\n      teardown,\n    });\n  };\n\n  const runPhase = async (\n    phase: CaseNodePhase,\n    results: StepRunResult[],\n    signal = scopeSignal,\n  ): Promise<void> => {\n    for (const [stepIndex, step] of phases[phase].entries()) {\n      const caseContext: NodeCaseContext = {\n        caseId: collectedCase.caseId,\n        runId,\n        projectName: options.projectName ?? collectedCase.projectId,\n        attemptIndex: options.attemptIndex ?? 0,\n        name: collectedCase.definition.name,\n        sourcePath: collectedCase.sourcePath,\n        caseIndex: collectedCase.caseIndex,\n        phase,\n        stepIndex,\n      };\n      const stepInfo = {\n        scope: 'case' as const,\n        node: step.node,\n        stepCount: phases[phase].length,\n        case: caseContext,\n      };\n      await options.onStepStart?.(stepInfo);\n      const result = await executeStep(\n        step,\n        nodes[phase][stepIndex],\n        { scope: 'case', case: caseContext },\n        options.context as TContext,\n        {\n          signal,\n          defaultTimeoutMs: options.defaultTimeoutMs,\n          onTeardown,\n        },\n      );\n      results.push(result);\n      await options.onStepResult?.(stepInfo, result);\n      if (result.status === 'failed' && !result.continuedAfterError) break;\n    }\n  };\n\n  const executionErrors: unknown[] = [];\n  try {\n    await runPhase('beforeEach', beforeEach);\n    if (!beforeEach.some((step) => step.status === 'failed')) {\n      await runPhase('steps', steps);\n    }\n  } catch (error) {\n    executionErrors.push(error);\n  }\n  const teardownErrors: NodeScopeTeardownError[] = [];\n  const reportPaths = new Set<string>();\n  const reportSources: import('./types').WorkflowReportSource[] = [];\n  const cleanupExecutionErrors: unknown[] = [];\n  let deferredCleanup = false;\n  const cleanup = async () => {\n    const priorTeardownErrors = teardownErrors.length;\n    acceptingTeardowns = false;\n    for (const {\n      registrationIndex,\n      node,\n      teardown,\n    } of teardownStack.reverse()) {\n      try {\n        const released = await teardown();\n        reportSources.push(...(released?.reportSources ?? []));\n        for (const path of reportPathsFromTeardown(released)) {\n          reportPaths.add(path);\n        }\n      } catch (error) {\n        teardownErrors.push(\n          new NodeScopeTeardownError(error, {\n            scope: 'case',\n            scopeId: runId,\n            node,\n            registrationIndex,\n          }),\n        );\n      }\n    }\n    if (deferredCleanup) {\n      const errors = [\n        ...cleanupExecutionErrors,\n        ...teardownErrors.slice(priorTeardownErrors),\n      ];\n      if (errors.length)\n        throw new AggregateError(errors, 'Deferred Case cleanup failed');\n    }\n  };\n  try {\n    if (phases.afterEach.length || teardownStack.length)\n      await cleanupScopeResources(scopeSignal, cleanup, {\n        beforeCleanup: async (cleanupSignal) => {\n          try {\n            await runPhase('afterEach', afterEach, cleanupSignal);\n          } catch (error) {\n            executionErrors.push(error);\n            cleanupExecutionErrors.push(error);\n          }\n        },\n        onDeferredError: (error) =>\n          getDebug('runner:cleanup', { console: true })(\n            `Deferred Case cleanup failed: ${String(error)}`,\n          ),\n      });\n    else acceptingTeardowns = false;\n  } catch (error) {\n    deferredCleanup = error instanceof ResourceCleanupDeferredError;\n    if (!deferredCleanup) acceptingTeardowns = false;\n    teardownErrors.push(\n      new NodeScopeTeardownError(error, {\n        scope: 'case',\n        scopeId: runId,\n        node: 'resource-drain',\n        registrationIndex: -1,\n      }),\n    );\n  }\n  const endedAt = new Date();\n  const result: CaseRunResult = {\n    caseId: collectedCase.caseId,\n    runId,\n    projectName: options.projectName ?? collectedCase.projectId,\n    attemptIndex: options.attemptIndex ?? 0,\n    name: collectedCase.definition.name,\n    sourcePath: collectedCase.sourcePath,\n    caseIndex: collectedCase.caseIndex,\n    status:\n      executionErrors.length > 0 ||\n      beforeEach.some((step) => step.status === 'failed') ||\n      steps.some((step) => step.status === 'failed') ||\n      afterEach.some((step) => step.status === 'failed') ||\n      teardownErrors.length > 0\n        ? 'failed'\n        : 'success',\n    beforeEach: [...beforeEach],\n    steps: [...steps],\n    afterEach: [...afterEach],\n    ...(executionErrors.length\n      ? { executionErrors: executionErrors.map(asExecutionError) }\n      : {}),\n    ...(teardownErrors.length > 0\n      ? { teardownErrors: [...teardownErrors] }\n      : {}),\n    ...(reportPaths.size > 0 ? { reportPaths: [...reportPaths] } : {}),\n    ...(reportSources.length ? { reportSources: [...reportSources] } : {}),\n    ...(options.reportScopeId ? { reportScopeId: options.reportScopeId } : {}),\n    startedAt: startedAt.toISOString(),\n    endedAt: endedAt.toISOString(),\n    durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime()),\n  };\n\n  try {\n    await options.onResult?.(result);\n  } catch (error) {\n    executionErrors.push(error);\n    result.status = 'failed';\n    result.executionErrors = executionErrors.map(asExecutionError);\n  }\n  resourceScope.dispose();\n  if (executionErrors.length)\n    throw new WorkflowExecutionFailure(result, executionErrors);\n  return result;\n}\n"],"names":["runCollectedCase","collectedCase","options","phases","nodes","step","resourceScope","createResourceScope","scopeSignal","runId","randomUUID","startedAt","Date","beforeEach","steps","afterEach","teardownStack","acceptingTeardowns","onTeardown","node","teardown","WorkflowLifecycleError","runPhase","phase","results","signal","stepIndex","caseContext","stepInfo","result","executeStep","executionErrors","error","teardownErrors","reportPaths","Set","reportSources","cleanupExecutionErrors","deferredCleanup","cleanup","priorTeardownErrors","registrationIndex","released","path","reportPathsFromTeardown","NodeScopeTeardownError","errors","AggregateError","cleanupScopeResources","cleanupSignal","getDebug","String","ResourceCleanupDeferredError","endedAt","asExecutionError","Math","WorkflowExecutionFailure"],"mappings":";;;;;;;AAwBO,eAAeA,iBACpBC,aAA4B,EAC5BC,OAA0C;IAE1C,MAAMC,SAA2D;QAC/D,YAAYD,QAAQ,UAAU,IAAI,EAAE;QACpC,OAAOD,cAAc,UAAU,CAAC,KAAK;QACrC,WAAWC,QAAQ,SAAS,IAAI,EAAE;IACpC;IACA,MAAME,QAAQ;QACZ,YAAYD,OAAO,UAAU,CAAC,GAAG,CAAC,CAACE,OAASH,QAAQ,WAAW,CAACG,KAAK,IAAI;QACzE,OAAOF,OAAO,KAAK,CAAC,GAAG,CAAC,CAACE,OAASH,QAAQ,WAAW,CAACG,KAAK,IAAI;QAC/D,WAAWF,OAAO,SAAS,CAAC,GAAG,CAAC,CAACE,OAASH,QAAQ,WAAW,CAACG,KAAK,IAAI;IACzE;IACA,MAAMC,gBAAgBC,oBAAoBL,QAAQ,MAAM;IACxD,MAAMM,cAAcF,cAAc,MAAM;IACxC,MAAMG,QAAQP,QAAQ,WAAW,QAAQQ;IACzC,MAAMC,YAAY,IAAIC;IACtB,MAAMC,aAA8B,EAAE;IACtC,MAAMC,QAAyB,EAAE;IACjC,MAAMC,YAA6B,EAAE;IACrC,MAAMC,gBAID,EAAE;IACP,IAAIC,qBAAqB;IAEzB,MAAMC,aAAa,CAACC,MAAcC;QAChC,IAAI,CAACH,oBACH,MAAM,IAAII,uBACR,yEACA;YAAEZ;YAAOU;QAAK;QAGlB,IAAI,AAAoB,cAApB,OAAOC,UACT,MAAM,IAAIC,uBACR,mDACA;YAAEZ;YAAOU;QAAK;QAGlBH,cAAc,IAAI,CAAC;YACjB,mBAAmBA,cAAc,MAAM;YACvCG;YACAC;QACF;IACF;IAEA,MAAME,WAAW,OACfC,OACAC,SACAC,SAASjB,WAAW;QAEpB,KAAK,MAAM,CAACkB,WAAWrB,KAAK,IAAIF,MAAM,CAACoB,MAAM,CAAC,OAAO,GAAI;YACvD,MAAMI,cAA+B;gBACnC,QAAQ1B,cAAc,MAAM;gBAC5BQ;gBACA,aAAaP,QAAQ,WAAW,IAAID,cAAc,SAAS;gBAC3D,cAAcC,QAAQ,YAAY,IAAI;gBACtC,MAAMD,cAAc,UAAU,CAAC,IAAI;gBACnC,YAAYA,cAAc,UAAU;gBACpC,WAAWA,cAAc,SAAS;gBAClCsB;gBACAG;YACF;YACA,MAAME,WAAW;gBACf,OAAO;gBACP,MAAMvB,KAAK,IAAI;gBACf,WAAWF,MAAM,CAACoB,MAAM,CAAC,MAAM;gBAC/B,MAAMI;YACR;YACA,MAAMzB,QAAQ,WAAW,GAAG0B;YAC5B,MAAMC,SAAS,MAAMC,YACnBzB,MACAD,KAAK,CAACmB,MAAM,CAACG,UAAU,EACvB;gBAAE,OAAO;gBAAQ,MAAMC;YAAY,GACnCzB,QAAQ,OAAO,EACf;gBACEuB;gBACA,kBAAkBvB,QAAQ,gBAAgB;gBAC1CgB;YACF;YAEFM,QAAQ,IAAI,CAACK;YACb,MAAM3B,QAAQ,YAAY,GAAG0B,UAAUC;YACvC,IAAIA,AAAkB,aAAlBA,OAAO,MAAM,IAAiB,CAACA,OAAO,mBAAmB,EAAE;QACjE;IACF;IAEA,MAAME,kBAA6B,EAAE;IACrC,IAAI;QACF,MAAMT,SAAS,cAAcT;QAC7B,IAAI,CAACA,WAAW,IAAI,CAAC,CAACR,OAASA,AAAgB,aAAhBA,KAAK,MAAM,GACxC,MAAMiB,SAAS,SAASR;IAE5B,EAAE,OAAOkB,OAAO;QACdD,gBAAgB,IAAI,CAACC;IACvB;IACA,MAAMC,iBAA2C,EAAE;IACnD,MAAMC,cAAc,IAAIC;IACxB,MAAMC,gBAA0D,EAAE;IAClE,MAAMC,yBAAoC,EAAE;IAC5C,IAAIC,kBAAkB;IACtB,MAAMC,UAAU;QACd,MAAMC,sBAAsBP,eAAe,MAAM;QACjDhB,qBAAqB;QACrB,KAAK,MAAM,EACTwB,iBAAiB,EACjBtB,IAAI,EACJC,QAAQ,EACT,IAAIJ,cAAc,OAAO,GACxB,IAAI;YACF,MAAM0B,WAAW,MAAMtB;YACvBgB,cAAc,IAAI,IAAKM,UAAU,iBAAiB,EAAE;YACpD,KAAK,MAAMC,QAAQC,wBAAwBF,UACzCR,YAAY,GAAG,CAACS;QAEpB,EAAE,OAAOX,OAAO;YACdC,eAAe,IAAI,CACjB,IAAIY,uBAAuBb,OAAO;gBAChC,OAAO;gBACP,SAASvB;gBACTU;gBACAsB;YACF;QAEJ;QAEF,IAAIH,iBAAiB;YACnB,MAAMQ,SAAS;mBACVT;mBACAJ,eAAe,KAAK,CAACO;aACzB;YACD,IAAIM,OAAO,MAAM,EACf,MAAM,IAAIC,eAAeD,QAAQ;QACrC;IACF;IACA,IAAI;QACF,IAAI3C,OAAO,SAAS,CAAC,MAAM,IAAIa,cAAc,MAAM,EACjD,MAAMgC,sBAAsBxC,aAAa+B,SAAS;YAChD,eAAe,OAAOU;gBACpB,IAAI;oBACF,MAAM3B,SAAS,aAAaP,WAAWkC;gBACzC,EAAE,OAAOjB,OAAO;oBACdD,gBAAgB,IAAI,CAACC;oBACrBK,uBAAuB,IAAI,CAACL;gBAC9B;YACF;YACA,iBAAiB,CAACA,QAChBkB,SAAS,kBAAkB;oBAAE,SAAS;gBAAK,GACzC,CAAC,8BAA8B,EAAEC,OAAOnB,QAAQ;QAEtD;aACGf,qBAAqB;IAC5B,EAAE,OAAOe,OAAO;QACdM,kBAAkBN,iBAAiBoB;QACnC,IAAI,CAACd,iBAAiBrB,qBAAqB;QAC3CgB,eAAe,IAAI,CACjB,IAAIY,uBAAuBb,OAAO;YAChC,OAAO;YACP,SAASvB;YACT,MAAM;YACN,mBAAmB;QACrB;IAEJ;IACA,MAAM4C,UAAU,IAAIzC;IACpB,MAAMiB,SAAwB;QAC5B,QAAQ5B,cAAc,MAAM;QAC5BQ;QACA,aAAaP,QAAQ,WAAW,IAAID,cAAc,SAAS;QAC3D,cAAcC,QAAQ,YAAY,IAAI;QACtC,MAAMD,cAAc,UAAU,CAAC,IAAI;QACnC,YAAYA,cAAc,UAAU;QACpC,WAAWA,cAAc,SAAS;QAClC,QACE8B,gBAAgB,MAAM,GAAG,KACzBlB,WAAW,IAAI,CAAC,CAACR,OAASA,AAAgB,aAAhBA,KAAK,MAAM,KACrCS,MAAM,IAAI,CAAC,CAACT,OAASA,AAAgB,aAAhBA,KAAK,MAAM,KAChCU,UAAU,IAAI,CAAC,CAACV,OAASA,AAAgB,aAAhBA,KAAK,MAAM,KACpC4B,eAAe,MAAM,GAAG,IACpB,WACA;QACN,YAAY;eAAIpB;SAAW;QAC3B,OAAO;eAAIC;SAAM;QACjB,WAAW;eAAIC;SAAU;QACzB,GAAIgB,gBAAgB,MAAM,GACtB;YAAE,iBAAiBA,gBAAgB,GAAG,CAACuB;QAAkB,IACzD,CAAC,CAAC;QACN,GAAIrB,eAAe,MAAM,GAAG,IACxB;YAAE,gBAAgB;mBAAIA;aAAe;QAAC,IACtC,CAAC,CAAC;QACN,GAAIC,YAAY,IAAI,GAAG,IAAI;YAAE,aAAa;mBAAIA;aAAY;QAAC,IAAI,CAAC,CAAC;QACjE,GAAIE,cAAc,MAAM,GAAG;YAAE,eAAe;mBAAIA;aAAc;QAAC,IAAI,CAAC,CAAC;QACrE,GAAIlC,QAAQ,aAAa,GAAG;YAAE,eAAeA,QAAQ,aAAa;QAAC,IAAI,CAAC,CAAC;QACzE,WAAWS,UAAU,WAAW;QAChC,SAAS0C,QAAQ,WAAW;QAC5B,YAAYE,KAAK,GAAG,CAAC,GAAGF,QAAQ,OAAO,KAAK1C,UAAU,OAAO;IAC/D;IAEA,IAAI;QACF,MAAMT,QAAQ,QAAQ,GAAG2B;IAC3B,EAAE,OAAOG,OAAO;QACdD,gBAAgB,IAAI,CAACC;QACrBH,OAAO,MAAM,GAAG;QAChBA,OAAO,eAAe,GAAGE,gBAAgB,GAAG,CAACuB;IAC/C;IACAhD,cAAc,OAAO;IACrB,IAAIyB,gBAAgB,MAAM,EACxB,MAAM,IAAIyB,yBAAyB3B,QAAQE;IAC7C,OAAOF;AACT"}

package/dist/es/test-runner/engine/run-workflow-document.mjs

@@ -0,0 +1,155 @@
+import { createDocumentRuntime } from "./document-runtime.mjs";
+import { WorkflowExecutionFailure, asExecutionError } from "./execution-failure.mjs";
+import { runCollectedCase } from "./run-collected-case.mjs";
+const asNotRun = (collectedCase, projectName, reason)=>({
+        caseId: collectedCase.caseId,
+        projectName,
+        name: collectedCase.definition.name,
+        sourcePath: collectedCase.sourcePath,
+        caseIndex: collectedCase.caseIndex,
+        ...collectedCase.definition.onFailure ? {
+            onFailure: collectedCase.definition.onFailure
+        } : {},
+        status: 'not-run',
+        notRunReason: reason
+    });
+async function runWorkflowDocument(document, options) {
+    const signal = options.signal ?? new AbortController().signal;
+    const createDocumentRunId = options.createDocumentRunId;
+    const createCaseRunId = options.createCaseRunId;
+    const projectName = options.project?.name ?? document.projectId;
+    const retry = options.retry ?? options.project?.retry ?? 0;
+    if (!Number.isInteger(retry) || retry < 0) throw new TypeError('Workflow document retry must be a non-negative integer.');
+    const runtime = createDocumentRuntime(document, {
+        documentSetup: options.documentSetup,
+        documentAttemptIndex: options.documentAttemptIndex,
+        resolveNode: options.resolveNode,
+        project: options.project,
+        projectContext: options.projectContext,
+        signal,
+        defaultTimeoutMs: options.defaultTimeoutMs,
+        onStepStart: options.onStepStart,
+        onStepResult: options.onStepResult,
+        onResult: async (result)=>{
+            await options.documentSetup?.onDocumentResult?.(result, runtime.context);
+            await options.onDocumentResult?.(result);
+        },
+        createDocumentRunId: createDocumentRunId ? ()=>createDocumentRunId(document) : void 0
+    });
+    const cases = [];
+    let runtimeStarted = false;
+    let documentResult;
+    const executionErrors = [];
+    let fatalError = false;
+    let stoppedByCase = false;
+    try {
+        runtimeStarted = true;
+        const startedDocument = await runtime.start();
+        if (runtime.canRunCases) for (const collectedCase of document.cases){
+            if (stoppedByCase || fatalError || signal.aborted || options.shouldStop?.()) {
+                const outcome = asNotRun(collectedCase, projectName, signal.aborted ? options.stopReason?.() ?? 'interrupted' : fatalError ? 'fatal-error' : stoppedByCase ? 'bail' : options.stopReason?.() ?? 'interrupted');
+                cases.push(outcome);
+                await options.onCaseOutcome?.(outcome);
+                continue;
+            }
+            await options.onCaseStart?.(collectedCase);
+            const attempts = [];
+            for(let attemptIndex = 0; attemptIndex <= retry; attemptIndex += 1){
+                let attemptFailure;
+                const run = await runCollectedCase(collectedCase, {
+                    resolveNode: options.resolveNode,
+                    beforeEach: document.lifecycle.beforeEach,
+                    afterEach: document.lifecycle.afterEach,
+                    context: runtime.context,
+                    projectName,
+                    attemptIndex,
+                    signal: runtime.signal,
+                    defaultTimeoutMs: options.defaultTimeoutMs,
+                    onStepStart: options.onStepStart,
+                    onStepResult: options.onStepResult,
+                    onResult: options.onCaseResult,
+                    reportScopeId: options.resolveCaseReportScopeId?.(collectedCase, attemptIndex, startedDocument.documentRunId),
+                    createRunId: createCaseRunId ? ()=>createCaseRunId(collectedCase, attemptIndex) : void 0
+                }).catch((error)=>{
+                    if (!(error instanceof WorkflowExecutionFailure)) throw error;
+                    attemptFailure = error;
+                    return attemptFailure.result;
+                });
+                attempts.push(run);
+                if (attemptFailure) {
+                    cases.push({
+                        caseId: collectedCase.caseId,
+                        projectName,
+                        name: collectedCase.definition.name,
+                        sourcePath: collectedCase.sourcePath,
+                        caseIndex: collectedCase.caseIndex,
+                        ...collectedCase.definition.onFailure ? {
+                            onFailure: collectedCase.definition.onFailure
+                        } : {},
+                        status: 'failed',
+                        run,
+                        attempts
+                    });
+                    throw attemptFailure;
+                }
+                fatalError = options.isFatalError?.(run) ?? false;
+                if ('success' === run.status || !!run.teardownErrors?.length || fatalError || signal.aborted || options.shouldStop?.()) break;
+            }
+            const run = attempts.at(-1);
+            const outcome = {
+                caseId: collectedCase.caseId,
+                projectName,
+                name: collectedCase.definition.name,
+                sourcePath: collectedCase.sourcePath,
+                caseIndex: collectedCase.caseIndex,
+                ...collectedCase.definition.onFailure ? {
+                    onFailure: collectedCase.definition.onFailure
+                } : {},
+                status: run.status,
+                run,
+                attempts
+            };
+            cases.push(outcome);
+            stoppedByCase = 'failed' === outcome.status && 'stop-document' === collectedCase.definition.onFailure;
+            await options.onCaseOutcome?.(outcome);
+        }
+        else {
+            const reason = signal.aborted ? options.stopReason?.() ?? 'interrupted' : 'document-start-failed';
+            cases.push(...document.cases.map((collectedCase)=>asNotRun(collectedCase, projectName, reason)));
+        }
+    } catch (error) {
+        executionErrors.push(...error instanceof WorkflowExecutionFailure ? error.errors : [
+            error
+        ]);
+    } finally{
+        if (runtimeStarted) try {
+            documentResult = await runtime.finish();
+        } catch (error) {
+            if (error instanceof WorkflowExecutionFailure) {
+                documentResult = error.result;
+                for (const failure of error.errors)if (!executionErrors.includes(failure)) executionErrors.push(failure);
+            } else executionErrors.push(error);
+        }
+    }
+    if (!documentResult) {
+        if (executionErrors.length) throw new AggregateError(executionErrors, 'Workflow execution did not produce a document result.');
+        throw new Error(`Workflow document "${document.sourcePath}" did not produce a result.`);
+    }
+    if (executionErrors.length) {
+        const completed = new Set(cases.map((outcome)=>outcome.caseId));
+        cases.push(...document.cases.filter((item)=>!completed.has(item.caseId)).map((item)=>asNotRun(item, projectName, 'interrupted')));
+        documentResult.status = 'failed';
+        documentResult.executionErrors = executionErrors.map(asExecutionError);
+        throw new WorkflowExecutionFailure({
+            document: documentResult,
+            cases
+        }, executionErrors);
+    }
+    return {
+        document: documentResult,
+        cases
+    };
+}
+export { runWorkflowDocument };
+
+//# sourceMappingURL=run-workflow-document.mjs.map

package/dist/es/test-runner/engine/run-workflow-document.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner/engine/run-workflow-document.mjs","sources":["../../../../src/test-runner/engine/run-workflow-document.ts"],"sourcesContent":["import type { CollectedCase, CollectedWorkflowDocument } from '../parser/types';\nimport { createDocumentRuntime } from './document-runtime';\nimport {\n  WorkflowExecutionFailure,\n  asExecutionError,\n} from './execution-failure';\nimport { runCollectedCase } from './run-collected-case';\nimport type {\n  CaseRunOutcome,\n  CaseRunResult,\n  RunWorkflowDocumentOptions,\n  WorkflowDocumentExecutionResult,\n  WorkflowDocumentRunResult,\n} from './types';\n\nconst asNotRun = (\n  collectedCase: CollectedCase,\n  projectName: string,\n  reason: NonNullable<CaseRunOutcome['notRunReason']>,\n): CaseRunOutcome => ({\n  caseId: collectedCase.caseId,\n  projectName,\n  name: collectedCase.definition.name,\n  sourcePath: collectedCase.sourcePath,\n  caseIndex: collectedCase.caseIndex,\n  ...(collectedCase.definition.onFailure\n    ? { onFailure: collectedCase.definition.onFailure }\n    : {}),\n  status: 'not-run',\n  notRunReason: reason,\n});\n\nexport async function runWorkflowDocument<TContext = undefined>(\n  document: CollectedWorkflowDocument,\n  options: RunWorkflowDocumentOptions<TContext>,\n): Promise<WorkflowDocumentExecutionResult> {\n  const signal = options.signal ?? new AbortController().signal;\n  const createDocumentRunId = options.createDocumentRunId;\n  const createCaseRunId = options.createCaseRunId;\n  const projectName = options.project?.name ?? document.projectId;\n  const retry = options.retry ?? options.project?.retry ?? 0;\n  if (!Number.isInteger(retry) || retry < 0) {\n    throw new TypeError(\n      'Workflow document retry must be a non-negative integer.',\n    );\n  }\n  const runtime = createDocumentRuntime(document, {\n    documentSetup: options.documentSetup,\n    documentAttemptIndex: options.documentAttemptIndex,\n    resolveNode: options.resolveNode,\n    project: options.project,\n    projectContext: options.projectContext,\n    signal,\n    defaultTimeoutMs: options.defaultTimeoutMs,\n    onStepStart: options.onStepStart,\n    onStepResult: options.onStepResult,\n    onResult: async (result) => {\n      await options.documentSetup?.onDocumentResult?.(result, runtime.context);\n      await options.onDocumentResult?.(result);\n    },\n    createDocumentRunId: createDocumentRunId\n      ? () => createDocumentRunId(document)\n      : undefined,\n  });\n  const cases: CaseRunOutcome[] = [];\n  let runtimeStarted = false;\n  let documentResult: WorkflowDocumentRunResult | undefined;\n  const executionErrors: unknown[] = [];\n  let fatalError = false;\n  let stoppedByCase = false;\n\n  try {\n    runtimeStarted = true;\n    const startedDocument = await runtime.start();\n\n    if (!runtime.canRunCases) {\n      const reason = signal.aborted\n        ? (options.stopReason?.() ?? 'interrupted')\n        : 'document-start-failed';\n      cases.push(\n        ...document.cases.map((collectedCase) =>\n          asNotRun(collectedCase, projectName, reason),\n        ),\n      );\n    } else {\n      for (const collectedCase of document.cases) {\n        if (\n          stoppedByCase ||\n          fatalError ||\n          signal.aborted ||\n          options.shouldStop?.()\n        ) {\n          const outcome = asNotRun(\n            collectedCase,\n            projectName,\n            signal.aborted\n              ? (options.stopReason?.() ?? 'interrupted')\n              : fatalError\n                ? 'fatal-error'\n                : stoppedByCase\n                  ? 'bail'\n                  : (options.stopReason?.() ?? 'interrupted'),\n          );\n          cases.push(outcome);\n          await options.onCaseOutcome?.(outcome);\n          continue;\n        }\n\n        await options.onCaseStart?.(collectedCase);\n        const attempts = [];\n        for (let attemptIndex = 0; attemptIndex <= retry; attemptIndex += 1) {\n          let attemptFailure:\n            | WorkflowExecutionFailure<CaseRunResult>\n            | undefined;\n          const run = await runCollectedCase(collectedCase, {\n            resolveNode: options.resolveNode,\n            beforeEach: document.lifecycle.beforeEach,\n            afterEach: document.lifecycle.afterEach,\n            context: runtime.context,\n            projectName,\n            attemptIndex,\n            signal: runtime.signal,\n            defaultTimeoutMs: options.defaultTimeoutMs,\n            onStepStart: options.onStepStart,\n            onStepResult: options.onStepResult,\n            onResult: options.onCaseResult,\n            reportScopeId: options.resolveCaseReportScopeId?.(\n              collectedCase,\n              attemptIndex,\n              startedDocument.documentRunId,\n            ),\n            createRunId: createCaseRunId\n              ? () => createCaseRunId(collectedCase, attemptIndex)\n              : undefined,\n          }).catch((error: unknown) => {\n            if (!(error instanceof WorkflowExecutionFailure)) throw error;\n            attemptFailure = error as WorkflowExecutionFailure<CaseRunResult>;\n            return attemptFailure.result;\n          });\n          attempts.push(run);\n          if (attemptFailure) {\n            cases.push({\n              caseId: collectedCase.caseId,\n              projectName,\n              name: collectedCase.definition.name,\n              sourcePath: collectedCase.sourcePath,\n              caseIndex: collectedCase.caseIndex,\n              ...(collectedCase.definition.onFailure\n                ? { onFailure: collectedCase.definition.onFailure }\n                : {}),\n              status: 'failed',\n              run,\n              attempts,\n            });\n            throw attemptFailure;\n          }\n          fatalError = options.isFatalError?.(run) ?? false;\n          if (\n            run.status === 'success' ||\n            // Retrying cannot repair cleanup/report publication and would\n            // replay actions that may already have completed successfully.\n            !!run.teardownErrors?.length ||\n            fatalError ||\n            signal.aborted ||\n            options.shouldStop?.()\n          )\n            break;\n        }\n        const run = attempts.at(-1)!;\n        const outcome: CaseRunOutcome = {\n          caseId: collectedCase.caseId,\n          projectName,\n          name: collectedCase.definition.name,\n          sourcePath: collectedCase.sourcePath,\n          caseIndex: collectedCase.caseIndex,\n          ...(collectedCase.definition.onFailure\n            ? { onFailure: collectedCase.definition.onFailure }\n            : {}),\n          status: run.status,\n          run,\n          attempts,\n        };\n        cases.push(outcome);\n        stoppedByCase =\n          outcome.status === 'failed' &&\n          collectedCase.definition.onFailure === 'stop-document';\n        await options.onCaseOutcome?.(outcome);\n      }\n    }\n  } catch (error) {\n    executionErrors.push(\n      ...(error instanceof WorkflowExecutionFailure ? error.errors : [error]),\n    );\n  } finally {\n    if (runtimeStarted) {\n      try {\n        documentResult = await runtime.finish();\n      } catch (error) {\n        if (error instanceof WorkflowExecutionFailure) {\n          documentResult = error.result as WorkflowDocumentRunResult;\n          for (const failure of error.errors)\n            if (!executionErrors.includes(failure))\n              executionErrors.push(failure);\n        } else executionErrors.push(error);\n      }\n    }\n  }\n\n  if (!documentResult) {\n    if (executionErrors.length)\n      throw new AggregateError(\n        executionErrors,\n        'Workflow execution did not produce a document result.',\n      );\n    throw new Error(\n      `Workflow document \"${document.sourcePath}\" did not produce a result.`,\n    );\n  }\n  if (executionErrors.length) {\n    const completed = new Set(cases.map((outcome) => outcome.caseId));\n    cases.push(\n      ...document.cases\n        .filter((item) => !completed.has(item.caseId))\n        .map((item) => asNotRun(item, projectName, 'interrupted')),\n    );\n    documentResult.status = 'failed';\n    documentResult.executionErrors = executionErrors.map(asExecutionError);\n    throw new WorkflowExecutionFailure(\n      { document: documentResult, cases },\n      executionErrors,\n    );\n  }\n  return { document: documentResult, cases };\n}\n"],"names":["asNotRun","collectedCase","projectName","reason","runWorkflowDocument","document","options","signal","AbortController","createDocumentRunId","createCaseRunId","retry","Number","TypeError","runtime","createDocumentRuntime","result","undefined","cases","runtimeStarted","documentResult","executionErrors","fatalError","stoppedByCase","startedDocument","outcome","attempts","attemptIndex","attemptFailure","run","runCollectedCase","error","WorkflowExecutionFailure","failure","AggregateError","Error","completed","Set","item","asExecutionError"],"mappings":"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"}

package/dist/es/test-runner/engine/scheduler.mjs

@@ -0,0 +1,27 @@
+async function runDocumentAttempts(options, run) {
+    for(let attemptIndex = 0; attemptIndex <= options.retry; attemptIndex++){
+        if (options.signal.aborted || options.shouldStop()) return;
+        const status = await run(attemptIndex);
+        if ('failed' !== status) return;
+    }
+}
+async function runConcurrentJobs(items, options, run) {
+    let next = 0;
+    const worker = async ()=>{
+        while(next < items.length && !options.shouldStop()){
+            const index = next++;
+            await run(items[index], index);
+        }
+    };
+    const workers = await Promise.allSettled(Array.from({
+        length: Math.min(options.concurrency, items.length)
+    }, worker));
+    const errors = workers.flatMap((result)=>'rejected' === result.status ? [
+            result.reason
+        ] : []);
+    if (1 === errors.length) throw errors[0];
+    if (errors.length) throw new AggregateError(errors, 'Document scheduling failed');
+}
+export { runConcurrentJobs, runDocumentAttempts };
+
+//# sourceMappingURL=scheduler.mjs.map

package/dist/es/test-runner/engine/scheduler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner/engine/scheduler.mjs","sources":["../../../../src/test-runner/engine/scheduler.ts"],"sourcesContent":["/** A rejected attempt is an infrastructure failure and is never replayed. */\nexport async function runDocumentAttempts(\n  options: { retry: number; signal: AbortSignal; shouldStop(): boolean },\n  run: (attemptIndex: number) => Promise<'success' | 'failed' | undefined>,\n): Promise<void> {\n  for (let attemptIndex = 0; attemptIndex <= options.retry; attemptIndex++) {\n    if (options.signal.aborted || options.shouldStop()) return;\n    const status = await run(attemptIndex);\n    if (status !== 'failed') return;\n  }\n}\n\n/** Ordered admission, bounded concurrency, results in invocation order. */\nexport async function runConcurrentJobs<T>(\n  items: readonly T[],\n  options: { concurrency: number; shouldStop(): boolean },\n  run: (item: T, index: number) => Promise<void>,\n): Promise<void> {\n  let next = 0;\n  const worker = async () => {\n    while (next < items.length && !options.shouldStop()) {\n      const index = next++;\n      await run(items[index], index);\n    }\n  };\n  const workers = await Promise.allSettled(\n    Array.from({ length: Math.min(options.concurrency, items.length) }, worker),\n  );\n  const errors = workers.flatMap((result) =>\n    result.status === 'rejected' ? [result.reason] : [],\n  );\n  if (errors.length === 1) throw errors[0];\n  if (errors.length)\n    throw new AggregateError(errors, 'Document scheduling failed');\n}\n"],"names":["runDocumentAttempts","options","run","attemptIndex","status","runConcurrentJobs","items","next","worker","index","workers","Promise","Array","Math","errors","result","AggregateError"],"mappings":"AACO,eAAeA,oBACpBC,OAAsE,EACtEC,GAAwE;IAExE,IAAK,IAAIC,eAAe,GAAGA,gBAAgBF,QAAQ,KAAK,EAAEE,eAAgB;QACxE,IAAIF,QAAQ,MAAM,CAAC,OAAO,IAAIA,QAAQ,UAAU,IAAI;QACpD,MAAMG,SAAS,MAAMF,IAAIC;QACzB,IAAIC,AAAW,aAAXA,QAAqB;IAC3B;AACF;AAGO,eAAeC,kBACpBC,KAAmB,EACnBL,OAAuD,EACvDC,GAA8C;IAE9C,IAAIK,OAAO;IACX,MAAMC,SAAS;QACb,MAAOD,OAAOD,MAAM,MAAM,IAAI,CAACL,QAAQ,UAAU,GAAI;YACnD,MAAMQ,QAAQF;YACd,MAAML,IAAII,KAAK,CAACG,MAAM,EAAEA;QAC1B;IACF;IACA,MAAMC,UAAU,MAAMC,QAAQ,UAAU,CACtCC,MAAM,IAAI,CAAC;QAAE,QAAQC,KAAK,GAAG,CAACZ,QAAQ,WAAW,EAAEK,MAAM,MAAM;IAAE,GAAGE;IAEtE,MAAMM,SAASJ,QAAQ,OAAO,CAAC,CAACK,SAC9BA,AAAkB,eAAlBA,OAAO,MAAM,GAAkB;YAACA,OAAO,MAAM;SAAC,GAAG,EAAE;IAErD,IAAID,AAAkB,MAAlBA,OAAO,MAAM,EAAQ,MAAMA,MAAM,CAAC,EAAE;IACxC,IAAIA,OAAO,MAAM,EACf,MAAM,IAAIE,eAAeF,QAAQ;AACrC"}

package/dist/es/test-runner/engine/scope-teardown.mjs

@@ -0,0 +1,16 @@
+import { isAbsolute } from "node:path";
+const reportPathsFromTeardown = (result)=>{
+    if (void 0 === result) return [];
+    if ('object' != typeof result || null === result || Array.isArray(result)) throw new TypeError('Node teardown result must be an object or undefined.');
+    const paths = result.reportPaths;
+    if (void 0 === paths) return [];
+    if (!Array.isArray(paths)) throw new TypeError('Node teardown reportPaths must be an array.');
+    return paths.map((path, index)=>{
+        if ('string' != typeof path || 0 === path.trim().length) throw new TypeError(`Node teardown reportPaths[${index}] must be a non-empty string.`);
+        if (!isAbsolute(path)) throw new TypeError(`Node teardown reportPaths[${index}] must be an absolute path.`);
+        return path;
+    });
+};
+export { reportPathsFromTeardown };
+
+//# sourceMappingURL=scope-teardown.mjs.map

package/dist/es/test-runner/engine/scope-teardown.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner/engine/scope-teardown.mjs","sources":["../../../../src/test-runner/engine/scope-teardown.ts"],"sourcesContent":["import { isAbsolute } from 'node:path';\nimport type { NodeScopeTeardownResult } from './types';\n\nexport const reportPathsFromTeardown = (\n  // biome-ignore lint/suspicious/noConfusingVoidType: this consumes the intentional void teardown return.\n  result: NodeScopeTeardownResult | void,\n): readonly string[] => {\n  if (result === undefined) return [];\n  if (typeof result !== 'object' || result === null || Array.isArray(result)) {\n    throw new TypeError('Node teardown result must be an object or undefined.');\n  }\n  const paths = result.reportPaths;\n  if (paths === undefined) return [];\n  if (!Array.isArray(paths)) {\n    throw new TypeError('Node teardown reportPaths must be an array.');\n  }\n  return paths.map((path, index) => {\n    if (typeof path !== 'string' || path.trim().length === 0) {\n      throw new TypeError(\n        `Node teardown reportPaths[${index}] must be a non-empty string.`,\n      );\n    }\n    if (!isAbsolute(path)) {\n      throw new TypeError(\n        `Node teardown reportPaths[${index}] must be an absolute path.`,\n      );\n    }\n    return path;\n  });\n};\n"],"names":["reportPathsFromTeardown","result","undefined","Array","TypeError","paths","path","index","isAbsolute"],"mappings":";AAGO,MAAMA,0BAA0B,CAErCC;IAEA,IAAIA,AAAWC,WAAXD,QAAsB,OAAO,EAAE;IACnC,IAAI,AAAkB,YAAlB,OAAOA,UAAuBA,AAAW,SAAXA,UAAmBE,MAAM,OAAO,CAACF,SACjE,MAAM,IAAIG,UAAU;IAEtB,MAAMC,QAAQJ,OAAO,WAAW;IAChC,IAAII,AAAUH,WAAVG,OAAqB,OAAO,EAAE;IAClC,IAAI,CAACF,MAAM,OAAO,CAACE,QACjB,MAAM,IAAID,UAAU;IAEtB,OAAOC,MAAM,GAAG,CAAC,CAACC,MAAMC;QACtB,IAAI,AAAgB,YAAhB,OAAOD,QAAqBA,AAAuB,MAAvBA,KAAK,IAAI,GAAG,MAAM,EAChD,MAAM,IAAIF,UACR,CAAC,0BAA0B,EAAEG,MAAM,6BAA6B,CAAC;QAGrE,IAAI,CAACC,WAAWF,OACd,MAAM,IAAIF,UACR,CAAC,0BAA0B,EAAEG,MAAM,2BAA2B,CAAC;QAGnE,OAAOD;IACT;AACF"}