playwright-order-manager 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.0] - 2026-03-30
+
+### First release
+
+- `OrderedExecution` — pure bucketing algorithm with `basic` and `priority` modes
+- `TestOrderManager` — full CLI orchestrator (discover → plan → execute → report)
+- `OrderedReportParser` — parses Playwright JSON reports into typed objects
+- `OrderedSummary` — writes JSON summary and self-contained HTML report
+- Playwright fixtures via `playwright-order-manager/fixtures` subpath export
+- `@runFirst` / `@runLast` boundary tags
+- `@P1` / `@P2` / `@P3` / `@P4` priority tags
+- Three failure policies: `critical`, `continue`, `immediate`
+- HTML report with progress bar, bucket navigation, flaky detection,
+  collapsible sections, and inline error preview
+- CLI via `npx pw-order`
+- Full TypeScript types exported for consumers

package/README.md

@@ -0,0 +1,240 @@
+# playwright-order-manager
+
+Priority-ordered test execution for Playwright. Run your most critical tests first, get faster feedback on failures, and keep your CI pipeline moving.
+
+---
+
+## Why
+
+Playwright runs tests in parallel by default, which is fast but gives you no control over *which* tests run first. If your most critical test (say, user login) fails, you still wait for hundreds of other tests to finish before you find out.
+
+`playwright-order-manager` solves this by:
+
+- Grouping tests into **buckets** by priority (`@P1` → `@P2` → `@P3` → `@P4`)
+- Running buckets **one at a time**, highest priority first
+- Stopping early if a critical bucket fails — no wasted CI time
+- Writing an **HTML report** showing exactly what ran, in what order, and why it failed
+
+---
+
+## Installation
+```bash
+npm install --save-dev playwright-order-manager
+```
+
+**Requirements:**
+- Node.js >= 18
+- `@playwright/test` >= 1.40 (installed separately as a peer dependency)
+
+---
+
+## Quick Start
+
+### Step 1 — Tag your tests
+
+Add priority tags to your tests. The tag goes in the test title:
+```typescript
+import { test, expect } from 'playwright-order-manager/fixtures';
+
+// Runs first — highest priority
+test('@P1 user can log in', async ({ page }) => {
+  await page.goto('/login');
+  // ...
+});
+
+// Runs second
+test('@P2 user can view dashboard', async ({ page }) => {
+  // ...
+});
+
+// Always runs before everything else
+test('@runFirst seed the database', async ({ page }) => {
+  // ...
+});
+
+// Always runs after everything else
+test('@runLast clean up test data', async ({ page }) => {
+  // ...
+});
+```
+
+> **Important:** Import `test` from `playwright-order-manager` instead of
+> `@playwright/test`. Everything else (`expect`, `Page`, `Browser`, etc.)
+> works exactly the same — it is a drop-in replacement.
+
+---
+
+### Step 2 — Copy the merge config template
+```bash
+cp node_modules/playwright-order-manager/templates/playwright.merge.config.ts .
+```
+
+---
+
+### Step 3 — Run
+```bash
+npx pw-order
+```
+
+That's it. The runner will:
+1. Discover all your tests
+2. Group them into priority buckets
+3. Execute buckets in order
+4. Write an HTML report to `./ordered-results/ordered-report.html`
+
+---
+
+## Execution Order
+
+Given tests tagged with various priorities, the execution order is always:
+```
+[@runFirst tests]  →  [@P1 tests]  →  [@P2 tests]  →  [@P3 tests]  →  [@P4 tests]  →  [untagged tests]  →  [@runLast tests]
+```
+
+- Empty buckets are skipped entirely
+- `@runLast` always executes, even if earlier buckets failed — it is your cleanup guarantee
+
+---
+
+## CLI Reference
+```bash
+npx pw-order [options]
+```
+
+| Flag | Description | Default |
+|---|---|---|
+| `--order-mode` | `priority` or `basic` | `priority` |
+| `--failure-policy` | `critical`, `continue`, or `immediate` | `critical` |
+| `--project` | Playwright project name (e.g. `chromium`) | all projects |
+| `--config` | Path to your `playwright.config.ts` | `./playwright.config.ts` |
+| `--report-root` | Directory for output files | `./ordered-results` |
+
+**Examples:**
+```bash
+# Run with a specific project
+npx pw-order --project=chromium
+
+# Continue running even after failures
+npx pw-order --failure-policy=continue
+
+# Stop immediately on any failure
+npx pw-order --failure-policy=immediate
+
+# Custom config path
+npx pw-order --config=./e2e/playwright.config.ts
+```
+
+---
+
+## Failure Policies
+
+| Policy | Behaviour |
+|---|---|
+| `critical` | Stop the run if a bucket marked **critical** fails. Only `@runFirst` buckets are critical by default. |
+| `immediate` | Stop on the very first failure, regardless of bucket. |
+| `continue` | Never stop early. Always run all buckets and collect all results. |
+
+---
+
+## Environment Variables
+
+All CLI flags have equivalent environment variables. Useful for CI pipelines:
+
+| Variable | Equivalent Flag |
+|---|---|
+| `ORDER_MODE` | `--order-mode` |
+| `FAILURE_POLICY` | `--failure-policy` |
+| `ORDERED_REPORT_ROOT` | `--report-root` |
+| `PLAYWRIGHT_CONFIG` | `--config` |
+| `PLAYWRIGHT_PROJECT` | `--project` (comma-separated for multiple) |
+| `ORDERED_DEBUG` | Enables verbose debug logging |
+
+---
+
+## Programmatic Usage
+
+If you want to embed ordered execution into your own script:
+```typescript
+import { TestOrderManager } from 'playwright-order-manager';
+
+const exitCode = await TestOrderManager.run({
+  orderMode:    'priority',
+  failurePolicy: 'continue',
+  project:       'chromium',
+  reportRoot:    './test-output',
+});
+
+process.exit(exitCode);
+```
+
+---
+
+## Using `OrderedExecution` directly
+
+If you only want the bucketing algorithm without the full runner:
+```typescript
+import { OrderedExecution, RunnerConstants } from 'playwright-order-manager';
+import type { DiscoveredTestCase } from 'playwright-order-manager';
+
+const tests: DiscoveredTestCase[] = [ /* ... */ ];
+
+const buckets = OrderedExecution.buildBuckets({
+  tests,
+  orderMode: 'priority',
+});
+
+const { runFirst, middle, runLast } = OrderedExecution.groupBuckets(buckets);
+```
+
+---
+
+## Output Files
+
+After a run, the `ordered-results/` directory contains:
+
+| File | Description |
+|---|---|
+| `ordered-report.html` | Full HTML report — open in any browser |
+| `ordered-summary.json` | Machine-readable summary of the entire run |
+| `ordered-discovery.json` | List of all discovered tests (written during `--list` phase) |
+| `bucket-N-*.json` | Per-bucket Playwright JSON reports (intermediate, safe to delete) |
+
+---
+
+## HTML Report Features
+
+The HTML report is self-contained — no internet connection required. It includes:
+
+- Overall pass/fail status with progress bar
+- Bucket navigation bar — jump to any bucket, colour-coded by result
+- Per-bucket execution timestamps — see exactly when each bucket ran
+- Per-test tags — verify tests landed in the correct bucket
+- Flaky test detection — tests that passed only after retries are marked
+- Collapsible buckets — passing buckets auto-collapse when failures exist
+- Inline error preview — first line of error visible without expanding
+
+---
+
+## CI Integration
+
+### GitHub Actions
+```yaml
+- name: Run ordered tests
+  run: npx pw-order --project=chromium
+  env:
+    ORDER_MODE: priority
+    FAILURE_POLICY: critical
+
+- name: Upload report
+  uses: actions/upload-artifact@v4
+  if: always()
+  with:
+    name: ordered-test-report
+    path: ordered-results/
+```
+
+---
+
+## Licence
+
+MIT © [rajeshyemul](https://github.com/rajeshyemul)

package/bin/run.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+/**
+ * bin/run.js — CLI entry point for playwright-order-manager
+ *
+ * This file is intentionally plain JavaScript (not TypeScript).
+ * It runs directly from node_modules/.bin/pw-order and calls into
+ * the compiled dist/ output.
+ *
+ * Usage:
+ *   npx pw-order
+ *   npx pw-order --project=chromium
+ *   npx pw-order --project=chromium --order-mode=priority
+ *
+ * All flags are forwarded to the runner. Playwright-specific flags
+ * (like --project) are forwarded directly to Playwright.
+ * Runner-specific flags (like --order-mode) are parsed here.
+ */
+
+'use strict';
+
+const { TestOrderManager } = require('../dist/runner/TestOrderManager');
+
+// =============================================================================
+// CLI ARG PARSING
+// We keep this intentionally simple — no external arg-parsing library.
+// The supported flags are few and well-defined.
+// =============================================================================
+
+/**
+ * Parses a single --key=value or --key value argument pair.
+ * Returns { key, value } or null if the arg doesn't match the expected key.
+ */
+function parseFlag(args, flag) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    // --flag=value form
+    if (arg.startsWith(`--${flag}=`)) {
+      return arg.slice(`--${flag}=`.length);
+    }
+
+    // --flag value form (next arg is the value)
+    if (arg === `--${flag}` && i + 1 < args.length) {
+      return args[i + 1];
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Collects all args that are NOT recognised runner flags.
+ * These get forwarded to Playwright as extraArgs.
+ */
+function collectExtraArgs(args) {
+  const runnerFlags = new Set([
+    '--order-mode',
+    '--failure-policy',
+    '--report-root',
+    '--config',
+    '--merge-config',
+    '--project',
+  ]);
+
+  const extra = [];
+  let i = 0;
+
+  while (i < args.length) {
+    const arg = args[i];
+
+    // Check if this is a known runner flag in --flag=value form
+    const isKnownFlagWithEquals = [...runnerFlags].some((f) =>
+      arg.startsWith(`${f}=`) || arg === f
+    );
+
+    if (isKnownFlagWithEquals) {
+      // If it's --flag value form (no =), skip the next arg too
+      if (!arg.includes('=')) i++;
+      i++;
+      continue;
+    }
+
+    extra.push(arg);
+    i++;
+  }
+
+  return extra;
+}
+
+// =============================================================================
+// MAIN
+// =============================================================================
+
+async function main() {
+  // argv[0] = node, argv[1] = this script, argv[2+] = user args
+  const args = process.argv.slice(2);
+
+  // Parse runner-specific flags
+  const orderMode     = parseFlag(args, 'order-mode');
+  const failurePolicy = parseFlag(args, 'failure-policy');
+  const reportRoot    = parseFlag(args, 'report-root');
+  const config        = parseFlag(args, 'config');
+  const mergeConfig   = parseFlag(args, 'merge-config');
+  const project       = parseFlag(args, 'project');
+
+  // Everything else gets forwarded to Playwright unchanged
+  const extraArgs = collectExtraArgs(args);
+
+  // Build the RunConfig — only include fields that were actually provided
+  // so that env vars and defaults fill in the rest correctly
+  const runConfig = {};
+
+  if (orderMode)     runConfig.orderMode            = orderMode;
+  if (failurePolicy) runConfig.failurePolicy         = failurePolicy;
+  if (reportRoot)    runConfig.reportRoot            = reportRoot;
+  if (config)        runConfig.playwrightConfigPath  = config;
+  if (mergeConfig)   runConfig.mergeConfigPath       = mergeConfig;
+  if (project)       runConfig.project               = project;
+  if (extraArgs.length > 0) runConfig.extraArgs      = extraArgs;
+
+  let exitCode = 1;
+
+  try {
+    exitCode = await TestOrderManager.run(runConfig);
+  } catch (err) {
+    console.error(`[pw-order] Unexpected error: ${err.message}`);
+    exitCode = 1;
+  }
+
+  process.exit(exitCode);
+}
+
+main();

package/dist/constants/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * RunnerConstants — the single source of truth for all tags, tokens, and defaults.
+ *
+ * Every magic string in the package comes from here.
+ * No file should ever hardcode '@P1' or '@runFirst' directly.
+ */
+export declare const RunnerConstants: {
+    /**
+     * Tests tagged with this run in their own bucket before all other buckets.
+     * Example test tag: test('@runFirst should seed the database', ...)
+     */
+    readonly RUN_FIRST_TAG: "@runFirst";
+    /**
+     * Tests tagged with this run in their own bucket after all other buckets.
+     * Example test tag: test('@runLast should clean up test data', ...)
+     */
+    readonly RUN_LAST_TAG: "@runLast";
+    /**
+     * All valid priority tags, in execution order (highest to lowest).
+     * `as const` makes this a readonly tuple: ['@P1', '@P2', '@P3', '@P4']
+     * This means TypeScript knows the exact values, not just `string[]`.
+     */
+    readonly PRIORITY_TAGS: readonly ["@P1", "@P2", "@P3", "@P4"];
+    /**
+     * Used as the bucket key for tests that have no priority tag at all.
+     * These tests run after all prioritized buckets.
+     */
+    readonly NO_PRIORITY_TOKEN: "NoPriority";
+    readonly DEFAULTS: {
+        /**
+         * The default OrderMode when ORDER_MODE env var is not set.
+         * 'priority' means tests are grouped by @P1/@P2/@P3/@P4 tags.
+         */
+        readonly ORDER_MODE: "priority";
+        /**
+         * The default FailurePolicy when FAILURE_POLICY env var is not set.
+         * 'critical' means: stop the run if a critical bucket fails.
+         */
+        readonly FAILURE_POLICY: "critical";
+        /**
+         * The default folder where run output is written.
+         * Relative to wherever the user runs the CLI command from.
+         */
+        readonly REPORT_ROOT: "ordered-results";
+        /**
+         * Default filename for the summary JSON written after a full run.
+         */
+        readonly SUMMARY_FILENAME: "ordered-summary.json";
+        /**
+         * Default filename for the HTML report written after a full run.
+         */
+        readonly REPORT_FILENAME: "ordered-report.html";
+        /**
+         * Default filename for the discovery output written during --list phase.
+         */
+        readonly DISCOVERY_FILENAME: "ordered-discovery.json";
+    };
+    readonly BUCKET_KEYS: {
+        /** The bucket containing @runFirst tests */
+        readonly RUN_FIRST: "boundary-run-first";
+        /** The bucket containing @runLast tests */
+        readonly RUN_LAST: "boundary-run-last";
+        /** The bucket containing tests with no priority tag */
+        readonly NO_PRIORITY: "none";
+    };
+};
+/**
+ * The type of PRIORITY_TAGS entries, derived directly from the array.
+ * Results in: '@P1' | '@P2' | '@P3' | '@P4'
+ */
+export type PriorityTagValue = typeof RunnerConstants.PRIORITY_TAGS[number];
+//# sourceMappingURL=index.d.ts.map

package/dist/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,eAAe;IAQ1B;;;OAGG;;IAGH;;;OAGG;;IASH;;;;OAIG;;IAQH;;;OAGG;;;QASD;;;WAGG;;QAGH;;;WAGG;;QAGH;;;WAGG;;QAGH;;WAEG;;QAGH;;WAEG;;QAGH;;WAEG;;;;QAWH,4CAA4C;;QAG5C,2CAA2C;;QAG3C,uDAAuD;;;CAIjD,CAAC;AASX;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAC1B,OAAO,eAAe,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC"}

package/dist/constants/index.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerConstants = void 0;
+/**
+ * RunnerConstants — the single source of truth for all tags, tokens, and defaults.
+ *
+ * Every magic string in the package comes from here.
+ * No file should ever hardcode '@P1' or '@runFirst' directly.
+ */
+exports.RunnerConstants = {
+    // ===========================================================================
+    // BOUNDARY TAGS
+    // These tags, when attached to a test, force it into a special bucket
+    // that runs before or after everything else.
+    // ===========================================================================
+    /**
+     * Tests tagged with this run in their own bucket before all other buckets.
+     * Example test tag: test('@runFirst should seed the database', ...)
+     */
+    RUN_FIRST_TAG: '@runFirst',
+    /**
+     * Tests tagged with this run in their own bucket after all other buckets.
+     * Example test tag: test('@runLast should clean up test data', ...)
+     */
+    RUN_LAST_TAG: '@runLast',
+    // ===========================================================================
+    // PRIORITY TAGS
+    // Used to group tests into priority buckets.
+    // P1 = highest priority (runs first), P4 = lowest priority (runs last).
+    // ===========================================================================
+    /**
+     * All valid priority tags, in execution order (highest to lowest).
+     * `as const` makes this a readonly tuple: ['@P1', '@P2', '@P3', '@P4']
+     * This means TypeScript knows the exact values, not just `string[]`.
+     */
+    PRIORITY_TAGS: ['@P1', '@P2', '@P3', '@P4'],
+    // ===========================================================================
+    // TOKENS
+    // Internal identifiers used in bucket keys and report labels.
+    // ===========================================================================
+    /**
+     * Used as the bucket key for tests that have no priority tag at all.
+     * These tests run after all prioritized buckets.
+     */
+    NO_PRIORITY_TOKEN: 'NoPriority',
+    // ===========================================================================
+    // DEFAULTS
+    // Fallback values used when the user hasn't configured something explicitly.
+    // ===========================================================================
+    DEFAULTS: {
+        /**
+         * The default OrderMode when ORDER_MODE env var is not set.
+         * 'priority' means tests are grouped by @P1/@P2/@P3/@P4 tags.
+         */
+        ORDER_MODE: 'priority',
+        /**
+         * The default FailurePolicy when FAILURE_POLICY env var is not set.
+         * 'critical' means: stop the run if a critical bucket fails.
+         */
+        FAILURE_POLICY: 'critical',
+        /**
+         * The default folder where run output is written.
+         * Relative to wherever the user runs the CLI command from.
+         */
+        REPORT_ROOT: 'ordered-results',
+        /**
+         * Default filename for the summary JSON written after a full run.
+         */
+        SUMMARY_FILENAME: 'ordered-summary.json',
+        /**
+         * Default filename for the HTML report written after a full run.
+         */
+        REPORT_FILENAME: 'ordered-report.html',
+        /**
+         * Default filename for the discovery output written during --list phase.
+         */
+        DISCOVERY_FILENAME: 'ordered-discovery.json',
+    },
+    // ===========================================================================
+    // BUCKET KEYS
+    // Stable string identifiers for each bucket type.
+    // Used as keys in BucketPlan and BucketExecutionRecord.
+    // ===========================================================================
+    BUCKET_KEYS: {
+        /** The bucket containing @runFirst tests */
+        RUN_FIRST: 'boundary-run-first',
+        /** The bucket containing @runLast tests */
+        RUN_LAST: 'boundary-run-last',
+        /** The bucket containing tests with no priority tag */
+        NO_PRIORITY: 'none',
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/constants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACU,QAAA,eAAe,GAAG;IAE7B,8EAA8E;IAC9E,gBAAgB;IAChB,sEAAsE;IACtE,6CAA6C;IAC7C,8EAA8E;IAE9E;;;OAGG;IACH,aAAa,EAAE,WAAW;IAE1B;;;OAGG;IACH,YAAY,EAAE,UAAU;IAExB,8EAA8E;IAC9E,gBAAgB;IAChB,6CAA6C;IAC7C,wEAAwE;IACxE,8EAA8E;IAE9E;;;;OAIG;IACH,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAU;IAEpD,8EAA8E;IAC9E,SAAS;IACT,8DAA8D;IAC9D,8EAA8E;IAE9E;;;OAGG;IACH,iBAAiB,EAAE,YAAY;IAE/B,8EAA8E;IAC9E,WAAW;IACX,6EAA6E;IAC7E,8EAA8E;IAE9E,QAAQ,EAAE;QACR;;;WAGG;QACH,UAAU,EAAE,UAAmB;QAE/B;;;WAGG;QACH,cAAc,EAAE,UAAmB;QAEnC;;;WAGG;QACH,WAAW,EAAE,iBAAiB;QAE9B;;WAEG;QACH,gBAAgB,EAAE,sBAAsB;QAExC;;WAEG;QACH,eAAe,EAAE,qBAAqB;QAEtC;;WAEG;QACH,kBAAkB,EAAE,wBAAwB;KAC7C;IAED,8EAA8E;IAC9E,cAAc;IACd,kDAAkD;IAClD,wDAAwD;IACxD,8EAA8E;IAE9E,WAAW,EAAE;QACX,4CAA4C;QAC5C,SAAS,EAAE,oBAAoB;QAE/B,2CAA2C;QAC3C,QAAQ,EAAE,mBAAmB;QAE7B,uDAAuD;QACvD,WAAW,EAAE,MAAM;KACpB;CAEO,CAAC"}

package/dist/core/OrderedExecution.d.ts

@@ -0,0 +1,52 @@
+import type { BucketPlan, BuildBucketOptions } from '../types';
+export declare class OrderedExecution {
+    /**
+     * Takes a flat list of discovered tests and groups them into ordered buckets.
+     *
+     * This is the core algorithm of the entire package. The buckets returned
+     * here define the execution order — the runner executes them one by one,
+     * in the order they appear in this array.
+     *
+     * @param options - See BuildBucketOptions in types/index.ts
+     * @returns An ordered array of BucketPlan objects, ready for execution
+     *
+     * @example
+     * ```typescript
+     * const buckets = OrderedExecution.buildBuckets({
+     *   tests: discoveredTests,
+     *   orderMode: 'priority',
+     * });
+     * // buckets[0] = runFirst tests (if any)
+     * // buckets[1] = @P1 tests (if any)
+     * // buckets[2] = @P2 tests (if any)
+     * // ...and so on
+     * ```
+     */
+    static buildBuckets(options: BuildBucketOptions): BucketPlan[];
+    /**
+     * Splits an array of buckets into three phases for the runner to process.
+     *
+     * Why split into phases?
+     * The runner needs to handle the runFirst bucket specially — if it fails
+     * and the FailurePolicy is 'critical', we stop before running any middle
+     * buckets. Similarly, runLast should always attempt to run (cleanup)
+     * even if middle buckets failed.
+     *
+     * @param buckets - The output from buildBuckets()
+     * @returns An object with three arrays: runFirst, middle, runLast
+     *
+     * @example
+     * ```typescript
+     * const { runFirst, middle, runLast } = OrderedExecution.groupBuckets(buckets);
+     * // Run runFirst phase, check failure policy
+     * // Run middle phase buckets in order
+     * // Run runLast phase regardless of middle results
+     * ```
+     */
+    static groupBuckets(buckets: BucketPlan[]): {
+        runFirst: BucketPlan[];
+        middle: BucketPlan[];
+        runLast: BucketPlan[];
+    };
+}
+//# sourceMappingURL=OrderedExecution.d.ts.map

package/dist/core/OrderedExecution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrderedExecution.d.ts","sourceRoot":"","sources":["../../src/core/OrderedExecution.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,UAAU,EACV,kBAAkB,EAEnB,MAAM,UAAU,CAAC;AAiNlB,qBAAa,gBAAgB;IAC3B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,kBAAkB,GAAG,UAAU,EAAE;IAyC9D;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG;QAC1C,QAAQ,EAAE,UAAU,EAAE,CAAC;QACvB,MAAM,EAAE,UAAU,EAAE,CAAC;QACrB,OAAO,EAAE,UAAU,EAAE,CAAC;KACvB;CAiBF"}