Skip to content

Conversation

@celicoo
Copy link
Contributor

@celicoo celicoo commented Sep 23, 2025

User description

diff facebook/[email protected]

React upstream changes

PR Type

Enhancement


Description

• Upgraded React from version 6b70072c-20250909 to 1eca9a27-20250922
• Stabilized Activity API by moving from unstable_Activity to Activity export
• Enhanced React DOM with improved debug capabilities including getCurrentDebugTask() function
• Added comprehensive view transition handling with better error handling and animation lifecycle management
• Implemented image loading optimization with bandwidth estimation and resource loading features
• Enhanced Suspense component with improved state management and timeout handling
• Added async module support in React Server Components with better stream state tracking
• Improved error handling across React DOM client and server components
• Updated all React package versions to maintain compatibility
• Enhanced profiling capabilities with better commit phase logging and performance monitoring


Diagram Walkthrough

flowchart LR
  A["React Core"] -- "version bump" --> B["19.2.0-canary-1eca9a27-20250922"]
  A -- "stabilize API" --> C["Activity API"]
  D["React DOM"] -- "enhance" --> E["Debug Capabilities"]
  D -- "improve" --> F["Suspense Handling"]
  D -- "add" --> G["Image Loading Optimization"]
  H["React Server Components"] -- "add" --> I["Async Module Support"]
  H -- "enhance" --> J["Stream State Tracking"]
Loading

File Walkthrough

Relevant files
Enhancement
11 files
react-dom-profiling.profiling.js
React DOM profiling enhancements with view transitions and suspense
improvements

packages/next/src/compiled/react-dom-experimental/cjs/react-dom-profiling.profiling.js

• Added new utility functions includesSyncLane and
includesBlockingLane for lane checking
• Enhanced view transition
handling with improved error handling and animation lifecycle
management
• Added comprehensive logging functions for commit phases
and animation phases
• Improved suspense handling with image loading
support and bandwidth estimation
• Updated function names from
throwOnInvalidObjectType to throwOnInvalidObjectTypeImpl

+830/-467
react-dom-profiling.profiling.js
React DOM profiling updates with resource loading optimizations

packages/next/src/compiled/react-dom/cjs/react-dom-profiling.profiling.js

• Added bandwidth estimation functionality for resource loading
optimization
• Enhanced suspense state management with image loading
support
• Updated function names from throwOnInvalidObjectType to
throwOnInvalidObjectTypeImpl
• Improved commit timing and resource
handling

+224/-73
react.production.js
React core updates with Activity type and version bump     

packages/next/src/compiled/react/cjs/react.production.js

• Added new REACT_ACTIVITY_TYPE symbol for activity components

Refactored Children object extraction and added Activity export

Updated React version to 19.2.0-canary-1eca9a27-20250922

+64/-61 
react-dom-client.development.js
Enhanced React DOM debug capabilities and Suspense handling

packages/next/src/compiled/react-dom/cjs/react-dom-client.development.js

• Added getCurrentDebugTask() function to retrieve current debug task
from debug info
• Refactored error handling functions to use debug
tasks for better error reporting
• Updated Suspense component
rendering with new variable names and improved debug handling

Enhanced commit phase with better suspended state management and
timeout handling
• Added bandwidth estimation and resource loading
optimization features
• Updated React version from 6b70072c-20250909
to 1eca9a27-20250922

+338/-156
react-dom-profiling.development.js
Enhanced React DOM profiling with debug improvements         

packages/next/src/compiled/react-dom/cjs/react-dom-profiling.development.js

• Added getCurrentDebugTask() function for debug task retrieval

Refactored error handling functions to support debug task execution

Updated Suspense component with improved variable naming and debug
handling
• Enhanced commit phase with better suspended state and
timeout management
• Added bandwidth estimation and resource loading
optimization
• Updated React version from 6b70072c-20250909 to
1eca9a27-20250922

+338/-156
react-server-dom-turbopack-client.browser.development.js
Enhanced React Server Components with async modules and debug tracking

packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.browser.development.js

• Added async module support with new parameter in
resolveClientReference()
• Enhanced stream state management with debug
information tracking
• Improved chunk processing with debug info
resolution and bandwidth estimation
• Added performance monitoring for
stream chunks and resource loading
• Updated React version from
6b70072c-20250909 to 1eca9a27-20250922

+528/-242
react.development.js
Stabilized Activity API and improved code structure           

packages/next/src/compiled/react-experimental/cjs/react.development.js

• Refactored deprecated APIs object structure for better code
organization
• Added Activity export to public API (moved from
unstable_Activity)
• Removed unstable_Activity export as it's now
stable
• Updated React version from 6b70072c-20250909 to
1eca9a27-20250922

+13/-13 
react-dom-client.production.js
React DOM client production build upgrade with transition timing and
image optimization

packages/next/src/compiled/react-dom-experimental/cjs/react-dom-client.production.js

• Added globalMostRecentTransitionTime tracking and initialization

Renamed throwOnInvalidObjectType to throwOnInvalidObjectTypeImpl
across multiple locations
• Updated view transition functions to use
fiber parameter instead of fiber.child
• Enhanced suspense commit
handling with image loading and bandwidth estimation features
• Added
new image loading optimization functions like estimateImageBytes and
waitForImageToLoad

+356/-161
react-dom-unstable_testing.production.js
React DOM testing build upgrade with transition timing and image
optimization

packages/next/src/compiled/react-dom-experimental/cjs/react-dom-unstable_testing.production.js

• Added globalMostRecentTransitionTime tracking and initialization

Renamed throwOnInvalidObjectType to throwOnInvalidObjectTypeImpl
across multiple locations
• Updated view transition functions to use fiber parameter instead of
fiber.child
• Enhanced suspense commit handling with image loading and
bandwidth estimation features
• Added new image loading optimization
functions like estimateImageBytes and waitForImageToLoad

+356/-161
react-server-dom-turbopack-client.edge.development.js
React Server DOM Turbopack client with async modules and stream
optimization

packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.edge.development.js

• Added async module support with optional 4th parameter in module
resolution
• Enhanced lazy type handling with additional null checks
and object type validation
• Added stream state tracking with debug
information and performance monitoring
• Improved error handling with
owner task support and better debug info transfer
• Added image
loading optimization with bandwidth estimation and timeout handling

+546/-255
react-server-dom-webpack-client.browser.production.js
React Server DOM Webpack client with improved lazy loading and error
handling

packages/next/src/compiled/react-server-dom-webpack-experimental/cjs/react-server-dom-webpack-client.browser.production.js

• Enhanced lazy type handling with additional null checks and object
type validation in fulfillReference and getOutlinedModel functions

Updated variable naming and improved reference handling logic
• Added
better error handling and chunk resolution in stream processing

Improved buffer and chunk management in processFullBinaryRow function

+133/-67
Dependencies
4 files
react-dom-server.browser.development.js
React DOM server version update for browser environment   

packages/next/src/compiled/react-dom/cjs/react-dom-server.browser.development.js

• Updated React version compatibility check to
19.2.0-canary-1eca9a27-20250922
• Updated exports version to match new
React version

+3/-3     
react-dom-server-legacy.node.development.js
React DOM experimental server legacy version update           

packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.node.development.js

• Updated exports version to 19.2.0-experimental-1eca9a27-20250922

+1/-1     
react-dom-server.edge.development.js
React version update for server-side rendering                     

packages/next/src/compiled/react-dom/cjs/react-dom-server.edge.development.js

• Updated React version compatibility check from 6b70072c-20250909 to
1eca9a27-20250922
• Updated exports version string to match new React
version

+3/-3     
react-dom-server-legacy.browser.development.js
React version update for legacy server rendering                 

packages/next/src/compiled/react-dom-experimental/cjs/react-dom-server-legacy.browser.development.js

• Updated React version string from 6b70072c-20250909 to
1eca9a27-20250922

+1/-1     
Additional files
99 files
package.json +16/-16 
react-dom-client.development.js +1071/-599
react-dom-profiling.development.js +1071/-599
react-dom-server-legacy.browser.production.js +1/-1     
react-dom-server-legacy.node.production.js +1/-1     
react-dom-server.browser.development.js +3/-3     
react-dom-server.browser.production.js +3/-3     
react-dom-server.bun.production.js +3/-3     
react-dom-server.edge.development.js +3/-3     
react-dom-server.edge.production.js +3/-3     
react-dom-server.node.development.js +3/-3     
react-dom-server.node.production.js +3/-3     
react-dom-unstable_testing.development.js +1071/-599
react-dom.development.js +1/-1     
react-dom.production.js +1/-1     
react-dom.react-server.development.js +1/-1     
react-dom.react-server.production.js +1/-1     
package.json +2/-2     
react-dom-client.production.js +214/-73
react-dom-server-legacy.browser.development.js +1/-1     
react-dom-server-legacy.browser.production.js +1/-1     
react-dom-server-legacy.node.development.js +1/-1     
react-dom-server-legacy.node.production.js +1/-1     
react-dom-server.browser.production.js +3/-3     
react-dom-server.bun.production.js +3/-3     
react-dom-server.edge.production.js +3/-3     
react-dom-server.node.development.js +3/-3     
react-dom-server.node.production.js +3/-3     
react-dom.development.js +1/-1     
react-dom.production.js +1/-1     
react-dom.react-server.development.js +1/-1     
react-dom.react-server.production.js +1/-1     
package.json +2/-2     
react.production.js +4/-2     
react.react-server.development.js +2/-1     
react.react-server.production.js +36/-35 
package.json +1/-1     
react-server-dom-turbopack-client.browser.production.js +136/-68
react-server-dom-turbopack-client.edge.production.js +136/-68
react-server-dom-turbopack-client.node.development.js +526/-240
react-server-dom-turbopack-client.node.production.js +145/-72
react-server-dom-turbopack-server.browser.development.js +112/-45
react-server-dom-turbopack-server.browser.production.js +4/-2     
react-server-dom-turbopack-server.edge.development.js +112/-45
react-server-dom-turbopack-server.edge.production.js +4/-2     
react-server-dom-turbopack-server.node.development.js +114/-45
react-server-dom-turbopack-server.node.production.js +4/-2     
package.json +2/-2     
react-server-dom-turbopack-client.browser.development.js +519/-236
react-server-dom-turbopack-client.browser.production.js +128/-61
react-server-dom-turbopack-client.edge.development.js +536/-248
react-server-dom-turbopack-client.edge.production.js +128/-61
react-server-dom-turbopack-client.node.development.js +517/-234
react-server-dom-turbopack-client.node.production.js +137/-65
react-server-dom-turbopack-server.browser.development.js +112/-45
react-server-dom-turbopack-server.browser.production.js +4/-2     
react-server-dom-turbopack-server.edge.development.js +112/-45
react-server-dom-turbopack-server.edge.production.js +4/-2     
react-server-dom-turbopack-server.node.development.js +114/-45
react-server-dom-turbopack-server.node.production.js +4/-2     
package.json +2/-2     
react-server-dom-webpack-client.browser.development.js +525/-241
react-server-dom-webpack-client.edge.development.js +543/-254
react-server-dom-webpack-client.edge.production.js +133/-67
react-server-dom-webpack-client.node.development.js +523/-239
react-server-dom-webpack-client.node.production.js +142/-71
react-server-dom-webpack-client.node.unbundled.development.js +523/-239
react-server-dom-webpack-client.node.unbundled.production.js +142/-71
react-server-dom-webpack-server.browser.development.js +109/-44
react-server-dom-webpack-server.browser.production.js +1/-1     
react-server-dom-webpack-server.edge.development.js +109/-44
react-server-dom-webpack-server.edge.production.js +1/-1     
react-server-dom-webpack-server.node.development.js +111/-44
react-server-dom-webpack-server.node.production.js +1/-1     
react-server-dom-webpack-server.node.unbundled.development.js +111/-44
react-server-dom-webpack-server.node.unbundled.production.js +1/-1     
package.json +2/-2     
react-server-dom-webpack-client.browser.development.js +516/-235
react-server-dom-webpack-client.browser.production.js +125/-60
react-server-dom-webpack-client.edge.development.js +533/-247
react-server-dom-webpack-client.edge.production.js +125/-60
react-server-dom-webpack-client.node.development.js +514/-233
react-server-dom-webpack-client.node.production.js +134/-64
react-server-dom-webpack-client.node.unbundled.development.js +514/-233
react-server-dom-webpack-client.node.unbundled.production.js +134/-64
react-server-dom-webpack-server.browser.development.js +109/-44
react-server-dom-webpack-server.browser.production.js +1/-1     
react-server-dom-webpack-server.edge.development.js +109/-44
react-server-dom-webpack-server.edge.production.js +1/-1     
react-server-dom-webpack-server.node.development.js +111/-44
react-server-dom-webpack-server.node.production.js +1/-1     
react-server-dom-webpack-server.node.unbundled.development.js +111/-44
react-server-dom-webpack-server.node.unbundled.production.js +1/-1     
package.json +2/-2     
react.development.js +13/-12 
react.react-server.development.js +1/-1     
react.react-server.production.js +1/-1     
unistore.js +1/-1     
pnpm-lock.yaml +251/-251

vercel-release-bot and others added 30 commits August 27, 2025 16:13
This auto-generated PR updates the development integration test manifest used when testing Rspack.
This auto-generated PR updates the production integration test manifest used when testing Rspack.
### What?

Use associated types to avoid Box and Any.

* avoids any casting
* avoid extra vec collecting
* avoid cloning lists for parallelization
Skip these effects when in a tracing-only asset context, since we never codegen these modules and these effects cannot add any references (which is the only thing we are interested in this case):

- `Effect::FreeVar`, `Effect::TypeOf`, `Effect::ImportMeta`, `Effect::Unreachable`, `Effect::Member`
### What?

Fixes persistent caching with next build.

Need to investigate how this regression passes the test cases...
## What?

As far as I can tell there's no usage of this variable. No TS errors and
all tests pass.
The server-reference-manifest.json contains the chunk item id of the action loader. The loader itself doesn't "register" itself in any way. So no need to execute it eagerly.
### What?

Background tasks will only run when idle, but persisting should also happen when active.
Caches with staleness/expiration below certain thresholds are not
included in static prerenders and are treated as dynamic. However, the
logic for propagating life/tags did not factor this in, meaning that a
prerender could get `cacheLife("seconds")`, making it expire (both on
the server and in the client router cache) much earlier than necessary.
This PR fixes that.

Closes NAR-271

### Implementation notes

The solution relies on the fact that in a Cache Components prerender,
we'll first fill the caches in the prospective render, and then read
them again in the final prerender. Previously, we'd propagate cache
life/tags in the prospective render, when the cache was filled, but this
didn't factor in the fact that the final render might decide to omit the
cache, leading to the problem described earlier. After this change,
we'll be relying on the fact that the entry will be read in the final
prerender, at which point we decide if it should be included or not, and
then propagate cache life/tags if it is.

Additionally, we filter the omitted cache entries from the resume data
cache (RDC). Otherwise they would be available during the resume, which
they should not be.

To be honest, this feels a bit brittle, and perhaps we should take a
look at how we're handling this and make it cleaner, but it should work
for now.

---------

Co-authored-by: Hendrik Liebau <[email protected]>
Added `unoptimized` and `decoding` props to the props table (the table
at the top of the doc page).

I was looking for the `unoptimized` prop and thought it wasn't in this
page because I could not find it at the props table. I think it's better
included there since it's not deprecated. The same goes for `decoding`.

Added them with the same syntax as the rest values in the table. 

Thanks.

Co-authored-by: Joseph <[email protected]>
…3166)

<!-- Thanks for opening a PR! Your contribution is much appreciated.
To make sure your PR is handled as smoothly as possible we request that
you follow the checklist sections below.
Choose the right checklist for the change(s) that you're making:

## For Contributors

### Improving Documentation

- Run `pnpm prettier-fix` to fix formatting issues before opening the
PR.
- Read the Docs Contribution Guide to ensure your contribution follows
the docs guidelines:
https://nextjs.org/docs/community/contribution-guide

### Adding or Updating Examples

- The "examples guidelines" are followed from our contributing doc
https://github.com/vercel/next.js/blob/canary/contributing/examples/adding-examples.md
- Make sure the linting passes by running `pnpm build && pnpm lint`. See
https://github.com/vercel/next.js/blob/canary/contributing/repository/linting.md

### Fixing a bug

- Related issues linked using `fixes #number`
- Tests added. See:
https://github.com/vercel/next.js/blob/canary/contributing/core/testing.md#writing-tests-for-nextjs
- Errors have a helpful link attached, see
https://github.com/vercel/next.js/blob/canary/contributing.md

### Adding a feature

- Implements an existing feature request or RFC. Make sure the feature
request has been accepted for implementation before opening a PR. (A
discussion must be opened, see
https://github.com/vercel/next.js/discussions/new?category=ideas)
- Related issues/discussions are linked using `fixes #number`
- e2e tests added
(https://github.com/vercel/next.js/blob/canary/contributing/core/testing.md#writing-tests-for-nextjs)
- Documentation added
- Telemetry added. In case of a feature if it's used or not.
- Errors have a helpful link attached, see
https://github.com/vercel/next.js/blob/canary/contributing.md


## For Maintainers

- Minimal description (aim for explaining to someone not on the team to
understand the PR)
- When linking to a Slack thread, you might want to share details of the
conclusion
- Link both the Linear (Fixes NEXT-xxx) and the GitHub issues
- Add review comments if necessary to explain to the reviewer the logic
behind a change

### What?

### Why?

### How?

Closes NEXT-
Fixes #

-->

Updates the middleware version history marking node as stable as
[announced in version
15.5](https://nextjs.org/blog/next-15-5#nodejs-middleware-stable)

Co-authored-by: Joseph <[email protected]>
A few more improvements to typed routes and friends

- showing usage of router methods from `next/navigation` 
- using Route in other data structures
Adding tsconfig.json to e2e test required `.gitignore` with
`!tsconfig.json`. It also lost the test utils aliases like `e2e-utils`.
This PR allows adding `tsconfig.test.json` to be used on test, so it
doesn't affect the root tsconfig.json nor manual testing.
## What?

Switch to matching webpack behavior where module in the loader_tree are
initialized later.
### What?

Adds proxy configuration support for e2e deployment tests, allowing test
traffic to be routed through a specified proxy server.

### Why?

Some testing environments require network traffic to be routed through
specific proxy servers or load balancers. This change enables the e2e
deployment test infrastructure to support such configurations by:

- Allowing specification of a proxy IP address via the
`NEXT_TEST_PROXY_ADDRESS` environment variable
- Automatically managing `/etc/hosts` entries to route deployment
domains through the proxy
- Providing proper cleanup when tests complete
Split tests into ESM and CJS to ensure it works on both environments.

The changes are mostly:

1. Split tests into two
2. Add `-esm` and `-cjs` for each
3. Add `packageJson: { type: 'module' }` to `-esm` test
4. Renamed `tsconfig.json` -> `tsconfig.test.json`

Added more fixtures to test `import-from-node-modules`.

x-ref: https://github.com/vercel/next.js/pull/83134/files#diff-1a4138af8d7d9ec956653ae76ede7eaa8b1f701931dc302f039fa4e770ef61afR3
In #8290 i forgot to update our typescript plugin, so exporting
`unstable_prefetch` caused it to error.

This is fixed now:
<img width="871" height="145" alt="Screenshot 2025-08-28 at 17 19 18"
src="https://github.com/user-attachments/assets/ca295029-5a93-483b-8f2b-2f821c452397"
/>
<img width="841" height="176" alt="Screenshot 2025-08-28 at 17 19 29"
src="https://github.com/user-attachments/assets/414b18f8-c3c0-46fd-acd0-25b04a85fbd2"
/>
I've also added some type safety to the `options` objects that we
specify there to make sure they're in sync with the values they
describe.
These files might change or move
This auto-generated PR updates the development integration test manifest used when testing Rspack.
…tence of files rather than directories (#83189)

This fixes an annoying devex issue when switching branches
celicoo and others added 21 commits September 19, 2025 12:35
GitHub Actions requires at least one job in the jobs section.
Added disabled placeholder job until OpenNext.js compatibility
testing strategy is finalized.

Fixes validation error: 'Unexpected value' at jobs section.
…lution issues

The deploy tests require published Next.js packages (e.g., next@production)
which are not available in the forked repository. Deployment testing would
require either publishing packages to npm or modifying tests to use local builds.

Workflow remains intact for potential future re-enablement once package
publishing is configured.
Next.js now requires Node.js >=20.9.0. Updated workflow to only test
with Node.js 20 and marked test_e2e_deploy_release as disabled in docs.
The test_examples workflow was failing because Jest couldn't find test files
in the examples directory. When NEXT_TEST_MODE=start (used for example tests),
Jest now includes the examples directory in its search roots.
…figs

Example tests now execute from their respective example directories using
their own jest.config.js files instead of the root configuration. This
resolves path resolution issues and mock conflicts that occurred when
running example tests from the repository root.
Examples currently depend on 'next': 'latest' from npm which doesn't include
the fork's changes. The workflow should be re-enabled after updating examples
to use @openuiai/next and publishing the package.
- Changed repository owner from 'vercel' to 'openuiai'
- Updated base branch from 'canary' to 'main'
- Replaced nextjs-bot with openuiai-ci-bot
- Updated bot email to [email protected]
- Changed bot name from nextjs-bot to openuiai-ci-bot
- Added repository owner check to only run on openuiai
- Updated description to use latest stable as default instead of canary
- Changed repository owner from vercel to openuiai
- Updated base branch from canary to main
- Fixed help text to reference correct repository
- Removed Vercel team members from reviewers list
- Changed default channel from canary to latest for stability
…eduling

- Fixed base branch from 'main' to 'production' in both scripts to align with
  established branch structure (production/staging/development)
- Disabled automatic React updates scheduling for fork - manual triggers only
…ormat

- Changed defaultLatestChannel from 'latest' to 'canary' to fetch React nightly builds
- Workflow now properly fetches canary versions like 19.0.0-canary-abc123-20241201
@qodo-merge-for-open-source
Copy link

PR Reviewer Guide 🔍

Here are some key observations to aid the review process:

⏱️ Estimated effort to review: 4 🔵🔵🔵🔵⚪
🧪 No relevant tests
🔒 No security concerns identified
⚡ Recommended focus areas for review

Behavior Change

The commit scheduling logic now passes string reasons (e.g., "Throttled", null) instead of enum constants and introduces pendingEffectsLanes tracking. Validate that downstream consumers (logging/metrics/devtools integration) handle the new reason values and that pendingEffectsLanes lifecycle (set/reset) is correct across throttled/suspended commits.

              !workInProgressRootDidSkipSuspendedSiblings
            );
            if (0 !== getNextLanes(shouldTimeSlice, 0, !0)) break a;
            pendingEffectsLanes = lanes;
            shouldTimeSlice.timeoutHandle = scheduleTimeout(
              commitRootWhenReady.bind(
                null,
                shouldTimeSlice,
                forceSync,
                workInProgressRootRecoverableErrors,
                workInProgressTransitions,
                workInProgressRootDidIncludeRecursiveRenderUpdate,
                lanes,
                workInProgressDeferredLane,
                workInProgressRootInterleavedUpdatedLanes,
                workInProgressSuspendedRetryLanes,
                workInProgressRootDidSkipSuspendedSiblings,
                exitStatus,
                "Throttled",
                renderStartTime,
                0
              ),
              renderWasConcurrent
            );
            break a;
          }
          commitRootWhenReady(
            shouldTimeSlice,
            forceSync,
            workInProgressRootRecoverableErrors,
            workInProgressTransitions,
            workInProgressRootDidIncludeRecursiveRenderUpdate,
            lanes,
            workInProgressDeferredLane,
            workInProgressRootInterleavedUpdatedLanes,
            workInProgressSuspendedRetryLanes,
            workInProgressRootDidSkipSuspendedSiblings,
            exitStatus,
            null,
            renderStartTime,
            0
          );
        }
      }
    }
    break;
  } while (1);
  ensureRootIsScheduled(root);
}
function commitRootWhenReady(
  root,
  finishedWork,
  recoverableErrors,
  transitions,
  didIncludeRenderPhaseUpdate,
  lanes,
  spawnedLane,
  updatedLanes,
  suspendedRetryLanes,
  didSkipSuspendedSiblings,
  exitStatus,
  suspendedCommitReason,
  completedRenderStartTime,
  completedRenderEndTime
) {
  root.timeoutHandle = noTimeout;
  suspendedCommitReason = finishedWork.subtreeFlags;
  if (
    suspendedCommitReason & 8192 ||
    16785408 === (suspendedCommitReason & 16785408)
  ) {
    suspendedCommitReason = {
      stylesheets: null,
      count: 0,
      imgCount: 0,
      imgBytes: 0,
      suspenseyImages: [],
      waitingForImages: !0,
      waitingForViewTransition: !1,
      unsuspend: noop$1
    };
    accumulateSuspenseyCommitOnFiber(
      finishedWork,
      lanes,
      suspendedCommitReason
    );
    var timeoutOffset =
      (lanes & 62914560) === lanes
        ? globalMostRecentFallbackTime - now$1()
        : (lanes & 4194048) === lanes
          ? globalMostRecentTransitionTime - now$1()
          : 0;
    timeoutOffset = waitForCommitToBeReady(
      suspendedCommitReason,
      timeoutOffset
    );
    if (null !== timeoutOffset) {
      pendingEffectsLanes = lanes;
      root.cancelPendingCommit = timeoutOffset(
        commitRoot.bind(
          null,
          root,
          finishedWork,
          lanes,
          recoverableErrors,
          transitions,
          didIncludeRenderPhaseUpdate,
          spawnedLane,
          updatedLanes,
          suspendedRetryLanes,
          exitStatus,
          suspendedCommitReason,
          suspendedCommitReason.waitingForViewTransition
            ? "Waiting for the previous Animation"
            : 0 < suspendedCommitReason.count
              ? 0 < suspendedCommitReason.imgCount
                ? "Suspended on CSS and Images"
                : "Suspended on CSS"
              : 1 === suspendedCommitReason.imgCount
                ? "Suspended on an Image"
                : 0 < suspendedCommitReason.imgCount
                  ? "Suspended on Images"
                  : null,
          completedRenderStartTime,
          completedRenderEndTime
        )
      );
      markRootSuspended(
        root,
        lanes,
        spawnedLane,
        !didSkipSuspendedSiblings
      );
      return;
    }
  }
  commitRoot(
    root,
    finishedWork,
    lanes,
    recoverableErrors,
    transitions,
    didIncludeRenderPhaseUpdate,
    spawnedLane,
    updatedLanes,
    suspendedRetryLanes
  );
}
function isRenderConsistentWithExternalStores(finishedWork) {
  for (var node = finishedWork; ; ) {
    var tag = node.tag;
    if (
      (0 === tag || 11 === tag || 15 === tag) &&
      node.flags & 16384 &&
      ((tag = node.updateQueue),
      null !== tag && ((tag = tag.stores), null !== tag))
    )
      for (var i = 0; i < tag.length; i++) {
        var check = tag[i],
          getSnapshot = check.getSnapshot;
        check = check.value;
        try {
          if (!objectIs(getSnapshot(), check)) return !1;
        } catch (error) {
          return !1;
        }
      }
    tag = node.child;
    if (node.subtreeFlags & 16384 && null !== tag)
      (tag.return = node), (node = tag);
    else {
      if (node === finishedWork) break;
      for (; null === node.sibling; ) {
        if (null === node.return || node.return === finishedWork) return !0;
        node = node.return;
      }
      node.sibling.return = node.return;
      node = node.sibling;
    }
  }
  return !0;
}
function markRootSuspended(
  root,
  suspendedLanes,
  spawnedLane,
  didAttemptEntireTree
) {
  suspendedLanes &= ~workInProgressRootPingedLanes;
  suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
  root.suspendedLanes |= suspendedLanes;
  root.pingedLanes &= ~suspendedLanes;
  didAttemptEntireTree && (root.warmLanes |= suspendedLanes);
  didAttemptEntireTree = root.expirationTimes;
  for (var lanes = suspendedLanes; 0 < lanes; ) {
    var index = 31 - clz32(lanes),
      lane = 1 << index;
    didAttemptEntireTree[index] = -1;
    lanes &= ~lane;
  }
  0 !== spawnedLane &&
    markSpawnedDeferredLane(root, spawnedLane, suspendedLanes);
}
function flushSyncWork$1() {
  return (executionContext & (RenderContext | CommitContext)) === NoContext
    ? (flushSyncWorkAcrossRoots_impl(0, !1), !1)
    : !0;
}
function resetWorkInProgressStack() {
  if (null !== workInProgress) {
    if (workInProgressSuspendedReason === NotSuspended)
      var interruptedWork = workInProgress.return;
    else
      (interruptedWork = workInProgress),
        resetContextDependencies(),
        resetHooksOnUnwind(interruptedWork),
        (thenableState$1 = null),
        (thenableIndexCounter$1 = 0),
        (interruptedWork = workInProgress);
    for (; null !== interruptedWork; )
      unwindInterruptedWork(interruptedWork.alternate, interruptedWork),
        (interruptedWork = interruptedWork.return);
    workInProgress = null;
  }
}
function prepareFreshStack(root, lanes) {
  var timeoutHandle = root.timeoutHandle;
  timeoutHandle !== noTimeout &&
    ((root.timeoutHandle = noTimeout), cancelTimeout(timeoutHandle));
  timeoutHandle = root.cancelPendingCommit;
  null !== timeoutHandle &&
    ((root.cancelPendingCommit = null), timeoutHandle());
  pendingEffectsLanes = 0;
  resetWorkInProgressStack();
  workInProgressRoot = root;
  workInProgress = timeoutHandle = createWorkInProgress(root.current, null);
  workInProgressRootRenderLanes = lanes;
  workInProgressSuspendedReason = NotSuspended;
New Suspense Commit Waiting

Suspense commit waiting was refactored to pass a state object and include image-based delays (bandwidth estimation, imgBytes, timers). Verify that suspendResource and waitForCommitToBeReady are invoked with correct state, timeouts behave as intended across lanes, and that cleanup (clearTimeouts) and unsuspend callbacks cannot leak or double-invoke.

      );
  }
}
function isLikelyStaticResource(initiatorType) {
  switch (initiatorType) {
    case "css":
    case "script":
    case "font":
    case "img":
    case "image":
    case "input":
    case "link":
      return !0;
    default:
      return !1;
  }
}
function estimateBandwidth() {
  if ("function" === typeof performance.getEntriesByType) {
    for (
      var count = 0,
        bits = 0,
        resourceEntries = performance.getEntriesByType("resource"),
        i = 0;
      i < resourceEntries.length;
      i++
    ) {
      var entry = resourceEntries[i],
        transferSize = entry.transferSize,
        initiatorType = entry.initiatorType,
        duration = entry.duration;
      if (
        transferSize &&
        duration &&
        isLikelyStaticResource(initiatorType)
      ) {
        initiatorType = 0;
        duration = entry.responseEnd;
        for (i += 1; i < resourceEntries.length; i++) {
          var overlapEntry = resourceEntries[i],
            overlapStartTime = overlapEntry.startTime;
          if (overlapStartTime > duration) break;
          var overlapTransferSize = overlapEntry.transferSize,
            overlapInitiatorType = overlapEntry.initiatorType;
          overlapTransferSize &&
            isLikelyStaticResource(overlapInitiatorType) &&
            ((overlapEntry = overlapEntry.responseEnd),
            (initiatorType +=
              overlapTransferSize *
              (overlapEntry < duration
                ? 1
                : (duration - overlapStartTime) /
                  (overlapEntry - overlapStartTime))));
        }
        --i;
        bits +=
          (8 * (transferSize + initiatorType)) / (entry.duration / 1e3);
        count++;
        if (10 < count) break;
      }
    }
    if (0 < count) return bits / count / 1e6;
  }
  return navigator.connection &&
    ((count = navigator.connection.downlink), "number" === typeof count)
    ? count
    : 5;
}
function getOwnerDocumentFromRootContainer(rootContainerElement) {
  return 9 === rootContainerElement.nodeType
    ? rootContainerElement
    : rootContainerElement.ownerDocument;
}
function getOwnHostContext(namespaceURI) {
  switch (namespaceURI) {
    case SVG_NAMESPACE:
      return HostContextNamespaceSvg;
    case MATH_NAMESPACE:
      return HostContextNamespaceMath;
    default:
      return HostContextNamespaceNone;
  }
}
function getChildHostContextProd(parentNamespace, type) {
  if (parentNamespace === HostContextNamespaceNone)
    switch (type) {
      case "svg":
        return HostContextNamespaceSvg;
      case "math":
        return HostContextNamespaceMath;
      default:
        return HostContextNamespaceNone;
    }
  return parentNamespace === HostContextNamespaceSvg &&
    "foreignObject" === type
    ? HostContextNamespaceNone
    : parentNamespace;
}
function shouldSetTextContent(type, props) {
  return (
    "textarea" === type ||
    "noscript" === type ||
    "string" === typeof props.children ||
    "number" === typeof props.children ||
    "bigint" === typeof props.children ||
    ("object" === typeof props.dangerouslySetInnerHTML &&
      null !== props.dangerouslySetInnerHTML &&
      null != props.dangerouslySetInnerHTML.__html)
  );
}
function shouldAttemptEagerTransition() {
  var event = window.event;
  if (event && "popstate" === event.type) {
    if (event === currentPopstateTransitionEvent) return !1;
    currentPopstateTransitionEvent = event;
    return !0;
  }
  currentPopstateTransitionEvent = null;
  return !1;
}
function handleErrorInNextTick(error) {
  setTimeout(function () {
    throw error;
  });
}
function commitMount(domElement, type, newProps) {
  switch (type) {
    case "button":
    case "input":
    case "select":
    case "textarea":
      newProps.autoFocus && domElement.focus();
      break;
    case "img":
      newProps.src
        ? (domElement.src = newProps.src)
        : newProps.srcSet && (domElement.srcset = newProps.srcSet);
  }
}
function commitHydratedInstance() {}
function commitUpdate(domElement, type, oldProps, newProps) {
  updateProperties(domElement, type, oldProps, newProps);
  domElement[internalPropsKey] = newProps;
}
function resetTextContent(domElement) {
  setTextContent(domElement, "");
}
function commitTextUpdate(textInstance, oldText, newText) {
  textInstance.nodeValue = newText;
}
function warnForReactChildrenConflict(container) {
  if (!container.__reactWarnedAboutChildrenConflict) {
    var props = container[internalPropsKey] || null;
    if (null !== props) {
      var fiber = getInstanceFromNode(container);
      null !== fiber &&
        ("string" === typeof props.children ||
        "number" === typeof props.children
          ? ((container.__reactWarnedAboutChildrenConflict = !0),
            runWithFiberInDEV(fiber, function () {
              console.error(
                'Cannot use a ref on a React element as a container to `createRoot` or `createPortal` if that element also sets "children" text content using React. It should be a leaf with no children. Otherwise it\'s ambiguous which children should be used.'
              );
            }))
          : null != props.dangerouslySetInnerHTML &&
            ((container.__reactWarnedAboutChildrenConflict = !0),
            runWithFiberInDEV(fiber, function () {
              console.error(
                'Cannot use a ref on a React element as a container to `createRoot` or `createPortal` if that element also sets "dangerouslySetInnerHTML" using React. It should be a leaf with no children. Otherwise it\'s ambiguous which children should be used.'
              );
            })));
    }
  }
}
function isSingletonScope(type) {
  return "head" === type;
}
function removeChild(parentInstance, child) {
  parentInstance.removeChild(child);
}
function removeChildFromContainer(container, child) {
  (9 === container.nodeType
    ? container.body
    : "HTML" === container.nodeName
      ? container.ownerDocument.body
      : container
  ).removeChild(child);
}
function clearHydrationBoundary(parentInstance, hydrationInstance) {
  var node = hydrationInstance,
    depth = 0;
  do {
    var nextNode = node.nextSibling;
    parentInstance.removeChild(node);
    if (nextNode && 8 === nextNode.nodeType)
      if (
        ((node = nextNode.data),
        node === SUSPENSE_END_DATA || node === ACTIVITY_END_DATA)
      ) {
        if (0 === depth) {
          parentInstance.removeChild(nextNode);
          retryIfBlockedOn(hydrationInstance);
          return;
        }
        depth--;
      } else if (
        node === SUSPENSE_START_DATA ||
        node === SUSPENSE_PENDING_START_DATA ||
        node === SUSPENSE_QUEUED_START_DATA ||
        node === SUSPENSE_FALLBACK_START_DATA ||
        node === ACTIVITY_START_DATA
      )
        depth++;
      else if (node === PREAMBLE_CONTRIBUTION_HTML)
        releaseSingletonInstance(
          parentInstance.ownerDocument.documentElement
        );
      else if (node === PREAMBLE_CONTRIBUTION_HEAD) {
        node = parentInstance.ownerDocument.head;
        releaseSingletonInstance(node);
        for (var node$jscomp$0 = node.firstChild; node$jscomp$0; ) {
          var nextNode$jscomp$0 = node$jscomp$0.nextSibling,
            nodeName = node$jscomp$0.nodeName;
          node$jscomp$0[internalHoistableMarker] ||
            "SCRIPT" === nodeName ||
            "STYLE" === nodeName ||
            ("LINK" === nodeName &&
              "stylesheet" === node$jscomp$0.rel.toLowerCase()) ||
            node.removeChild(node$jscomp$0);
          node$jscomp$0 = nextNode$jscomp$0;
        }
      } else
        node === PREAMBLE_CONTRIBUTION_BODY &&
          releaseSingletonInstance(parentInstance.ownerDocument.body);
    node = nextNode;
  } while (node);
  retryIfBlockedOn(hydrationInstance);
}
function hideOrUnhideDehydratedBoundary(suspenseInstance, isHidden) {
  var node = suspenseInstance;
  suspenseInstance = 0;
  do {
    var nextNode = node.nextSibling;
    1 === node.nodeType
      ? isHidden
        ? ((node._stashedDisplay = node.style.display),
          (node.style.display = "none"))
        : ((node.style.display = node._stashedDisplay || ""),
          "" === node.getAttribute("style") &&
            node.removeAttribute("style"))
      : 3 === node.nodeType &&
        (isHidden
          ? ((node._stashedText = node.nodeValue), (node.nodeValue = ""))
          : (node.nodeValue = node._stashedText || ""));
    if (nextNode && 8 === nextNode.nodeType)
      if (((node = nextNode.data), node === SUSPENSE_END_DATA))
        if (0 === suspenseInstance) break;
        else suspenseInstance--;
      else
        (node !== SUSPENSE_START_DATA &&
          node !== SUSPENSE_PENDING_START_DATA &&
          node !== SUSPENSE_QUEUED_START_DATA &&
          node !== SUSPENSE_FALLBACK_START_DATA) ||
          suspenseInstance++;
    node = nextNode;
  } while (node);
}
function hideDehydratedBoundary(suspenseInstance) {
  hideOrUnhideDehydratedBoundary(suspenseInstance, !0);
}
function hideInstance(instance) {
  instance = instance.style;
  "function" === typeof instance.setProperty
    ? instance.setProperty("display", "none", "important")
    : (instance.display = "none");
}
function hideTextInstance(textInstance) {
  textInstance.nodeValue = "";
}
function unhideDehydratedBoundary(dehydratedInstance) {
  hideOrUnhideDehydratedBoundary(dehydratedInstance, !1);
}
function unhideInstance(instance, props) {
  props = props[STYLE];
  props =
    void 0 !== props && null !== props && props.hasOwnProperty("display")
      ? props.display
      : null;
  instance.style.display =
    null == props || "boolean" === typeof props ? "" : ("" + props).trim();
}
function unhideTextInstance(textInstance, text) {
  textInstance.nodeValue = text;
}
function clearContainerSparingly(container) {
  var nextNode = container.firstChild;
  nextNode && 10 === nextNode.nodeType && (nextNode = nextNode.nextSibling);
  for (; nextNode; ) {
    var node = nextNode;
    nextNode = nextNode.nextSibling;
    switch (node.nodeName) {
      case "HTML":
      case "HEAD":
      case "BODY":
        clearContainerSparingly(node);
        detachDeletedInstance(node);
        continue;
      case "SCRIPT":
      case "STYLE":
        continue;
      case "LINK":
        if ("stylesheet" === node.rel.toLowerCase()) continue;
    }
    container.removeChild(node);
  }
}
function canHydrateInstance(instance, type, props, inRootOrSingleton) {
  for (; 1 === instance.nodeType; ) {
    var anyProps = props;
    if (instance.nodeName.toLowerCase() !== type.toLowerCase()) {
      if (
        !inRootOrSingleton &&
        ("INPUT" !== instance.nodeName || "hidden" !== instance.type)
      )
        break;
    } else if (!inRootOrSingleton)
      if ("input" === type && "hidden" === instance.type) {
        checkAttributeStringCoercion(anyProps.name, "name");
        var name = null == anyProps.name ? null : "" + anyProps.name;
        if (
          "hidden" === anyProps.type &&
          instance.getAttribute("name") === name
        )
          return instance;
      } else return instance;
    else if (!instance[internalHoistableMarker])
      switch (type) {
        case "meta":
          if (!instance.hasAttribute("itemprop")) break;
          return instance;
        case "link":
          name = instance.getAttribute("rel");
          if (
            "stylesheet" === name &&
            instance.hasAttribute("data-precedence")
          )
            break;
          else if (
            name !== anyProps.rel ||
            instance.getAttribute("href") !==
              (null == anyProps.href || "" === anyProps.href
                ? null
                : anyProps.href) ||
            instance.getAttribute("crossorigin") !==
              (null == anyProps.crossOrigin
                ? null
                : anyProps.crossOrigin) ||
            instance.getAttribute("title") !==
              (null == anyProps.title ? null : anyProps.title)
          )
            break;
          return instance;
        case "style":
          if (instance.hasAttribute("data-precedence")) break;
          return instance;
        case "script":
          name = instance.getAttribute("src");
          if (
            (name !== (null == anyProps.src ? null : anyProps.src) ||
              instance.getAttribute("type") !==
                (null == anyProps.type ? null : anyProps.type) ||
              instance.getAttribute("crossorigin") !==
                (null == anyProps.crossOrigin
                  ? null
                  : anyProps.crossOrigin)) &&
            name &&
            instance.hasAttribute("async") &&
            !instance.hasAttribute("itemprop")
          )
            break;
          return instance;
        default:
          return instance;
      }
    instance = getNextHydratable(instance.nextSibling);
    if (null === instance) break;
  }
  return null;
}
function canHydrateTextInstance(instance, text, inRootOrSingleton) {
  if ("" === text) return null;
  for (; 3 !== instance.nodeType; ) {
    if (
      (1 !== instance.nodeType ||
        "INPUT" !== instance.nodeName ||
        "hidden" !== instance.type) &&
      !inRootOrSingleton
    )
      return null;
    instance = getNextHydratable(instance.nextSibling);
    if (null === instance) return null;
  }
  return instance;
}
function canHydrateHydrationBoundary(instance, inRootOrSingleton) {
  for (; 8 !== instance.nodeType; ) {
    if (
      (1 !== instance.nodeType ||
        "INPUT" !== instance.nodeName ||
        "hidden" !== instance.type) &&
      !inRootOrSingleton
    )
      return null;
    instance = getNextHydratable(instance.nextSibling);
    if (null === instance) return null;
  }
  return instance;
}
function isSuspenseInstancePending(instance) {
  return (
    instance.data === SUSPENSE_PENDING_START_DATA ||
    instance.data === SUSPENSE_QUEUED_START_DATA
  );
}
function isSuspenseInstanceFallback(instance) {
  return (
    instance.data === SUSPENSE_FALLBACK_START_DATA ||
    (instance.data === SUSPENSE_PENDING_START_DATA &&
      instance.ownerDocument.readyState !== DOCUMENT_READY_STATE_LOADING)
  );
}
function registerSuspenseInstanceRetry(instance, callback) {
  var ownerDocument = instance.ownerDocument;
  if (instance.data === SUSPENSE_QUEUED_START_DATA)
    instance._reactRetry = callback;
  else if (
    instance.data !== SUSPENSE_PENDING_START_DATA ||
    ownerDocument.readyState !== DOCUMENT_READY_STATE_LOADING
  )
    callback();
  else {
    var listener = function () {
      callback();
      ownerDocument.removeEventListener("DOMContentLoaded", listener);
    };
    ownerDocument.addEventListener("DOMContentLoaded", listener);
    instance._reactRetry = listener;
  }
}
function getNextHydratable(node) {
  for (; null != node; node = node.nextSibling) {
    var nodeType = node.nodeType;
    if (1 === nodeType || 3 === nodeType) break;
    if (8 === nodeType) {
      nodeType = node.data;
      if (
        nodeType === SUSPENSE_START_DATA ||
        nodeType === SUSPENSE_FALLBACK_START_DATA ||
        nodeType === SUSPENSE_PENDING_START_DATA ||
        nodeType === SUSPENSE_QUEUED_START_DATA ||
        nodeType === ACTIVITY_START_DATA ||
        nodeType === FORM_STATE_IS_MATCHING ||
        nodeType === FORM_STATE_IS_NOT_MATCHING
      )
        break;
      if (nodeType === SUSPENSE_END_DATA || nodeType === ACTIVITY_END_DATA)
        return null;
    }
  }
  return node;
}
function describeHydratableInstanceForDevWarnings(instance) {
  if (1 === instance.nodeType) {
    for (
      var JSCompiler_temp_const = instance.nodeName.toLowerCase(),
        serverDifferences = {},
        attributes = instance.attributes,
        i = 0;
      i < attributes.length;
      i++
    ) {
      var attr = attributes[i];
      serverDifferences[getPropNameFromAttributeName(attr.name)] =
        "style" === attr.name.toLowerCase()
          ? getStylesObjectFromElement(instance)
          : attr.value;
    }
    return { type: JSCompiler_temp_const, props: serverDifferences };
  }
  return 8 === instance.nodeType
    ? instance.data === ACTIVITY_START_DATA
      ? { type: "Activity", props: {} }
      : { type: "Suspense", props: {} }
    : instance.nodeValue;
}
function diffHydratedTextForDevWarnings(textInstance, text, parentProps) {
  return null === parentProps ||
    !0 !== parentProps[SUPPRESS_HYDRATION_WARNING]
    ? (textInstance.nodeValue === text
        ? (textInstance = null)
        : ((text = normalizeMarkupForTextOrAttribute(text)),
          (textInstance =
            normalizeMarkupForTextOrAttribute(textInstance.nodeValue) ===
            text
              ? null
              : textInstance.nodeValue)),
      textInstance)
    : null;
}
function getNextHydratableInstanceAfterHydrationBoundary(
  hydrationInstance
) {
  hydrationInstance = hydrationInstance.nextSibling;
  for (var depth = 0; hydrationInstance; ) {
    if (8 === hydrationInstance.nodeType) {
      var data = hydrationInstance.data;
      if (data === SUSPENSE_END_DATA || data === ACTIVITY_END_DATA) {
        if (0 === depth)
          return getNextHydratable(hydrationInstance.nextSibling);
        depth--;
      } else
        (data !== SUSPENSE_START_DATA &&
          data !== SUSPENSE_FALLBACK_START_DATA &&
          data !== SUSPENSE_PENDING_START_DATA &&
          data !== SUSPENSE_QUEUED_START_DATA &&
          data !== ACTIVITY_START_DATA) ||
          depth++;
    }
    hydrationInstance = hydrationInstance.nextSibling;
  }
  return null;
}
function getParentHydrationBoundary(targetInstance) {
  targetInstance = targetInstance.previousSibling;
  for (var depth = 0; targetInstance; ) {
    if (8 === targetInstance.nodeType) {
      var data = targetInstance.data;
      if (
        data === SUSPENSE_START_DATA ||
        data === SUSPENSE_FALLBACK_START_DATA ||
        data === SUSPENSE_PENDING_START_DATA ||
        data === SUSPENSE_QUEUED_START_DATA ||
        data === ACTIVITY_START_DATA
      ) {
        if (0 === depth) return targetInstance;
        depth--;
      } else
        (data !== SUSPENSE_END_DATA && data !== ACTIVITY_END_DATA) ||
          depth++;
    }
    targetInstance = targetInstance.previousSibling;
  }
  return null;
}
function commitHydratedContainer(container) {
  retryIfBlockedOn(container);
}
function commitHydratedActivityInstance(activityInstance) {
  retryIfBlockedOn(activityInstance);
}
function commitHydratedSuspenseInstance(suspenseInstance) {
  retryIfBlockedOn(suspenseInstance);
}
function resolveSingletonInstance(
  type,
  props,
  rootContainerInstance,
  hostContext,
  validateDOMNestingDev
) {
  validateDOMNestingDev &&
    validateDOMNesting(type, hostContext.ancestorInfo);
  props = getOwnerDocumentFromRootContainer(rootContainerInstance);
  switch (type) {
    case "html":
      type = props.documentElement;
      if (!type)
        throw Error(
          "React expected an <html> element (document.documentElement) to exist in the Document but one was not found. React never removes the documentElement for any Document it renders into so the cause is likely in some other script running on this page."
        );
      return type;
    case "head":
      type = props.head;
      if (!type)
        throw Error(
          "React expected a <head> element (document.head) to exist in the Document but one was not found. React never removes the head for any Document it renders into so the cause is likely in some other script running on this page."
        );
      return type;
    case "body":
      type = props.body;
      if (!type)
        throw Error(
          "React expected a <body> element (document.body) to exist in the Document but one was not found. React never removes the body for any Document it renders into so the cause is likely in some other script running on this page."
        );
      return type;
    default:
      throw Error(
        "resolveSingletonInstance was called with an element type that is not supported. This is a bug in React."
      );
  }
}
function acquireSingletonInstance(
  type,
  props,
  instance,
  internalInstanceHandle
) {
  if (
    !instance[internalContainerInstanceKey] &&
    getInstanceFromNode(instance)
  ) {
    var tagName = instance.tagName.toLowerCase();
    console.error(
      "You are mounting a new %s component when a previous one has not first unmounted. It is an error to render more than one %s component at a time and attributes and children of these components will likely fail in unpredictable ways. Please only render a single instance of <%s> and if you need to mount a new one, ensure any previous ones have unmounted first.",
      tagName,
      tagName,
      tagName
    );
  }
  switch (type) {
    case "html":
    case "head":
    case "body":
      break;
    default:
      console.error(
        "acquireSingletonInstance was called with an element type that is not supported. This is a bug in React."
      );
  }
  for (tagName = instance.attributes; tagName.length; )
    instance.removeAttributeNode(tagName[0]);
  setInitialProperties(instance, type, props);
  instance[internalInstanceKey] = internalInstanceHandle;
  instance[internalPropsKey] = props;
}
function releaseSingletonInstance(instance) {
  for (var attributes = instance.attributes; attributes.length; )
    instance.removeAttributeNode(attributes[0]);
  detachDeletedInstance(instance);
}
function getHoistableRoot(container) {
  return "function" === typeof container.getRootNode
    ? container.getRootNode()
    : 9 === container.nodeType
      ? container
      : container.ownerDocument;
}
function preconnectAs(rel, href, crossOrigin) {
  var ownerDocument = globalDocument;
  if (ownerDocument && "string" === typeof href && href) {
    var limitedEscapedHref =
      escapeSelectorAttributeValueInsideDoubleQuotes(href);
    limitedEscapedHref =
      'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
    "string" === typeof crossOrigin &&
      (limitedEscapedHref += '[crossorigin="' + crossOrigin + '"]');
    preconnectsSet.has(limitedEscapedHref) ||
      (preconnectsSet.add(limitedEscapedHref),
      (rel = { rel: rel, crossOrigin: crossOrigin, href: href }),
      null === ownerDocument.querySelector(limitedEscapedHref) &&
        ((href = ownerDocument.createElement("link")),
        setInitialProperties(href, "link", rel),
        markNodeAsHoistable(href),
        ownerDocument.head.appendChild(href)));
  }
}
function getResource(type, currentProps, pendingProps, currentResource) {
  var resourceRoot = (resourceRoot = rootInstanceStackCursor.current)
    ? getHoistableRoot(resourceRoot)
    : null;
  if (!resourceRoot)
    throw Error(
      '"resourceRoot" was expected to exist. This is a bug in React.'
    );
  switch (type) {
    case "meta":
    case "title":
      return null;
    case "style":
      return "string" === typeof pendingProps.precedence &&
        "string" === typeof pendingProps.href
        ? ((pendingProps = getStyleKey(pendingProps.href)),
          (currentProps =
            getResourcesFromRoot(resourceRoot).hoistableStyles),
          (currentResource = currentProps.get(pendingProps)),
          currentResource ||
            ((currentResource = {
              type: "style",
              instance: null,
              count: 0,
              state: null
            }),
            currentProps.set(pendingProps, currentResource)),
          currentResource)
        : { type: "void", instance: null, count: 0, state: null };
    case "link":
      if (
        "stylesheet" === pendingProps.rel &&
        "string" === typeof pendingProps.href &&
        "string" === typeof pendingProps.precedence
      ) {
        type = getStyleKey(pendingProps.href);
        var _styles = getResourcesFromRoot(resourceRoot).hoistableStyles,
          _resource = _styles.get(type);
        if (
          !_resource &&
          ((resourceRoot = resourceRoot.ownerDocument || resourceRoot),
          (_resource = {
            type: "stylesheet",
            instance: null,
            count: 0,
            state: { loading: NotLoaded, preload: null }
          }),
          _styles.set(type, _resource),
          (_styles = resourceRoot.querySelector(
            getStylesheetSelectorFromKey(type)
          )) &&
            !_styles._p &&
            ((_resource.instance = _styles),
            (_resource.state.loading = Loaded | Inserted)),
          !preloadPropsMap.has(type))
        ) {
          var preloadProps = {
            rel: "preload",
            as: "style",
            href: pendingProps.href,
            crossOrigin: pendingProps.crossOrigin,
            integrity: pendingProps.integrity,
            media: pendingProps.media,
            hrefLang: pendingProps.hrefLang,
            referrerPolicy: pendingProps.referrerPolicy
          };
          preloadPropsMap.set(type, preloadProps);
          _styles ||
            preloadStylesheet(
              resourceRoot,
              type,
              preloadProps,
              _resource.state
            );
        }
        if (currentProps && null === currentResource)
          throw (
            ((pendingProps =
              "\n\n  - " +
              describeLinkForResourceErrorDEV(currentProps) +
              "\n  + " +
              describeLinkForResourceErrorDEV(pendingProps)),
            Error(
              "Expected <link> not to update to be updated to a stylesheet with precedence. Check the `rel`, `href`, and `precedence` props of this component. Alternatively, check whether two different <link> components render in the same slot or share the same key." +
                pendingProps
            ))
          );
        return _resource;
      }
      if (currentProps && null !== currentResource)
        throw (
          ((pendingProps =
            "\n\n  - " +
            describeLinkForResourceErrorDEV(currentProps) +
            "\n  + " +
            describeLinkForResourceErrorDEV(pendingProps)),
          Error(
            "Expected stylesheet with precedence to not be updated to a different kind of <link>. Check the `rel`, `href`, and `precedence` props of this component. Alternatively, check whether two different <link> components render in the same slot or share the same key." +
              pendingProps
          ))
        );
      return null;
    case "script":
      return (
        (currentProps = pendingProps.async),
        (pendingProps = pendingProps.src),
        "string" === typeof pendingProps &&
        currentProps &&
        "function" !== typeof currentProps &&
        "symbol" !== typeof currentProps
          ? ((pendingProps = getScriptKey(pendingProps)),
            (currentProps =
              getResourcesFromRoot(resourceRoot).hoistableScripts),
            (currentResource = currentProps.get(pendingProps)),
            currentResource ||
              ((currentResource = {
                type: "script",
                instance: null,
                count: 0,
                state: null
              }),
              currentProps.set(pendingProps, currentResource)),
            currentResource)
          : { type: "void", instance: null, count: 0, state: null }
      );
    default:
      throw Error(
        'getResource encountered a type it did not expect: "' +
          type +
          '". this is a bug in React.'
      );
  }
}
function describeLinkForResourceErrorDEV(props) {
  var describedProps = 0,
    description = "<link";
  "string" === typeof props.rel
    ? (describedProps++, (description += ' rel="' + props.rel + '"'))
    : hasOwnProperty.call(props, "rel") &&
      (describedProps++,
      (description +=
        ' rel="' +
        (null === props.rel ? "null" : "invalid type " + typeof props.rel) +
        '"'));
  "string" === typeof props.href
    ? (describedProps++, (description += ' href="' + props.href + '"'))
    : hasOwnProperty.call(props, "href") &&
      (describedProps++,
      (description +=
        ' href="' +
        (null === props.href
          ? "null"
          : "invalid type " + typeof props.href) +
        '"'));
  "string" === typeof props.precedence
    ? (describedProps++,
      (description += ' precedence="' + props.precedence + '"'))
    : hasOwnProperty.call(props, "precedence") &&
      (describedProps++,
      (description +=
        " precedence={" +
        (null === props.precedence
          ? "null"
          : "invalid type " + typeof props.precedence) +
        "}"));
  Object.getOwnPropertyNames(props).length > describedProps &&
    (description += " ...");
  return description + " />";
}
function getStyleKey(href) {
  return (
    'href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"'
  );
}
function getStylesheetSelectorFromKey(key) {
  return 'link[rel="stylesheet"][' + key + "]";
}
function stylesheetPropsFromRawProps(rawProps) {
  return assign({}, rawProps, {
    "data-precedence": rawProps.precedence,
    precedence: null
  });
}
function preloadStylesheet(ownerDocument, key, preloadProps, state) {
  ownerDocument.querySelector(
    'link[rel="preload"][as="style"][' + key + "]"
  )
    ? (state.loading = Loaded)
    : ((key = ownerDocument.createElement("link")),
      (state.preload = key),
      key.addEventListener("load", function () {
        return (state.loading |= Loaded);
      }),
      key.addEventListener("error", function () {
        return (state.loading |= Errored);
      }),
      setInitialProperties(key, "link", preloadProps),
      markNodeAsHoistable(key),
      ownerDocument.head.appendChild(key));
}
function getScriptKey(src) {
  return (
    '[src="' + escapeSelectorAttributeValueInsideDoubleQuotes(src) + '"]'
  );
}
function getScriptSelectorFromKey(key) {
  return "script[async]" + key;
}
function acquireResource(hoistableRoot, resource, props) {
  resource.count++;
  if (null === resource.instance)
    switch (resource.type) {
      case "style":
        var instance = hoistableRoot.querySelector(
          'style[data-href~="' +
            escapeSelectorAttributeValueInsideDoubleQuotes(props.href) +
            '"]'
        );
        if (instance)
          return (
            (resource.instance = instance),
            markNodeAsHoistable(instance),
            instance
          );
        var styleProps = assign({}, props, {
          "data-href": props.href,
          "data-precedence": props.precedence,
          href: null,
          precedence: null
        });
        instance = (
          hoistableRoot.ownerDocument || hoistableRoot
        ).createElement("style");
        markNodeAsHoistable(instance);
        setInitialProperties(instance, "style", styleProps);
        insertStylesheet(instance, props.precedence, hoistableRoot);
        return (resource.instance = instance);
      case "stylesheet":
        styleProps = getStyleKey(props.href);
        var _instance = hoistableRoot.querySelector(
          getStylesheetSelectorFromKey(styleProps)
        );
        if (_instance)
          return (
            (resource.state.loading |= Inserted),
            (resource.instance = _instance),
            markNodeAsHoistable(_instance),
            _instance
          );
        instance = stylesheetPropsFromRawProps(props);
        (styleProps = preloadPropsMap.get(styleProps)) &&
          adoptPreloadPropsForStylesheet(instance, styleProps);
        _instance = (
          hoistableRoot.ownerDocument || hoistableRoot
        ).createElement("link");
        markNodeAsHoistable(_instance);
        var linkInstance = _instance;
        linkInstance._p = new Promise(function (resolve, reject) {
          linkInstance.onload = resolve;
          linkInstance.onerror = reject;
        });
        setInitialProperties(_instance, "link", instance);
        resource.state.loading |= Inserted;
        insertStylesheet(_instance, props.precedence, hoistableRoot);
        return (resource.instance = _instance);
      case "script":
        _instance = getScriptKey(props.src);
        if (
          (styleProps = hoistableRoot.querySelector(
            getScriptSelectorFromKey(_instance)
          ))
        )
          return (
            (resource.instance = styleProps),
            markNodeAsHoistable(styleProps),
            styleProps
          );
        instance = props;
        if ((styleProps = preloadPropsMap.get(_instance)))
          (instance = assign({}, props)),
            adoptPreloadPropsForScript(instance, styleProps);
        hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
        styleProps = hoistableRoot.createElement("script");
        markNodeAsHoistable(styleProps);
        setInitialProperties(styleProps, "link", instance);
        hoistableRoot.head.appendChild(styleProps);
        return (resource.instance = styleProps);
      case "void":
        return null;
      default:
        throw Error(
          'acquireResource encountered a resource type it did not expect: "' +
            resource.type +
            '". this is a bug in React.'
        );
    }
  else
    "stylesheet" === resource.type &&
      (resource.state.loading & Inserted) === NotLoaded &&
      ((instance = resource.instance),
      (resource.state.loading |= Inserted),
      insertStylesheet(instance, props.precedence, hoistableRoot));
  return resource.instance;
}
function insertStylesheet(instance, precedence, root) {
  for (
    var nodes = root.querySelectorAll(
        'link[rel="stylesheet"][data-precedence],style[data-precedence]'
      ),
      last = nodes.length ? nodes[nodes.length - 1] : null,
      prior = last,
      i = 0;
    i < nodes.length;
    i++
  ) {
    var node = nodes[i];
    if (node.dataset.precedence === precedence) prior = node;
    else if (prior !== last) break;
  }
  prior
    ? prior.parentNode.insertBefore(instance, prior.nextSibling)
    : ((precedence = 9 === root.nodeType ? root.head : root),
      precedence.insertBefore(instance, precedence.firstChild));
}
function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
  null == stylesheetProps.crossOrigin &&
    (stylesheetProps.crossOrigin = preloadProps.crossOrigin);
  null == stylesheetProps.referrerPolicy &&
    (stylesheetProps.referrerPolicy = preloadProps.referrerPolicy);
  null == stylesheetProps.title &&
    (stylesheetProps.title = preloadProps.title);
}
function adoptPreloadPropsForScript(scriptProps, preloadProps) {
  null == scriptProps.crossOrigin &&
    (scriptProps.crossOrigin = preloadProps.crossOrigin);
  null == scriptProps.referrerPolicy &&
    (scriptProps.referrerPolicy = preloadProps.referrerPolicy);
  null == scriptProps.integrity &&
    (scriptProps.integrity = preloadProps.integrity);
}
function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
  if (null === tagCaches) {
    var cache = new Map();
    var caches = (tagCaches = new Map());
    caches.set(ownerDocument, cache);
  } else
    (caches = tagCaches),
      (cache = caches.get(ownerDocument)),
      cache || ((cache = new Map()), caches.set(ownerDocument, cache));
  if (cache.has(type)) return cache;
  cache.set(type, null);
  ownerDocument = ownerDocument.getElementsByTagName(type);
  for (caches = 0; caches < ownerDocument.length; caches++) {
    var node = ownerDocument[caches];
    if (
      !(
        node[internalHoistableMarker] ||
        node[internalInstanceKey] ||
        ("link" === type && "stylesheet" === node.getAttribute("rel"))
      ) &&
      node.namespaceURI !== SVG_NAMESPACE
    ) {
      var nodeKey = node.getAttribute(keyAttribute) || "";
      nodeKey = type + nodeKey;
      var existing = cache.get(nodeKey);
      existing ? existing.push(node) : cache.set(nodeKey, [node]);
    }
  }
  return cache;
}
function mountHoistable(hoistableRoot, type, instance) {
  hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
  hoistableRoot.head.insertBefore(
    instance,
    "title" === type ? hoistableRoot.querySelector("head > title") : null
  );
}
function isHostHoistableType(type, props, hostContext) {
  var outsideHostContainerContext =
    !hostContext.ancestorInfo.containerTagInScope;
  if (
    hostContext.context === HostContextNamespaceSvg ||
    null != props.itemProp
  )
    return (
      !outsideHostContainerContext ||
        null == props.itemProp ||
        ("meta" !== type &&
          "title" !== type &&
          "style" !== type &&
          "link" !== type &&
          "script" !== type) ||
        console.error(
          "Cannot render a <%s> outside the main document if it has an `itemProp` prop. `itemProp` suggests the tag belongs to an `itemScope` which can appear anywhere in the DOM. If you were intending for React to hoist this <%s> remove the `itemProp` prop. Otherwise, try moving this tag into the <head> or <body> of the Document.",
          type,
          type
        ),
      !1
    );
  switch (type) {
    case "meta":
    case "title":
      return !0;
    case "style":
      if (
        "string" !== typeof props.precedence ||
        "string" !== typeof props.href ||
        "" === props.href
      ) {
        outsideHostContainerContext &&
          console.error(
            'Cannot render a <style> outside the main document without knowing its precedence and a unique href key. React can hoist and deduplicate <style> tags if you provide a `precedence` prop along with an `href` prop that does not conflict with the `href` values used in any other hoisted <style> or <link rel="stylesheet" ...> tags.  Note that hoisting <style> tags is considered an advanced feature that most will not use directly. Consider moving the <style> tag to the <head> or consider adding a `precedence="default"` and `href="some unique resource identifier"`.'
          );
        break;
      }
      return !0;
    case "link":
      if (
        "string" !== typeof props.rel ||
        "string" !== typeof props.href ||
        "" === props.href ||
        props.onLoad ||
        props.onError
      ) {
        if (
          "stylesheet" === props.rel &&
          "string" === typeof props.precedence
        ) {
          type = props.href;
          var onError = props.onError,
            disabled = props.disabled;
          hostContext = [];
          props.onLoad && hostContext.push("`onLoad`");
          onError && hostContext.push("`onError`");
          null != disabled && hostContext.push("`disabled`");
          onError = propNamesListJoin(hostContext, "and");
          onError += 1 === hostContext.length ? " prop" : " props";
          disabled =
            1 === hostContext.length ? "an " + onError : "the " + onError;
          hostContext.length &&
            console.error(
              'React encountered a <link rel="stylesheet" href="%s" ... /> with a `precedence` prop that also included %s. The presence of loading and error handlers indicates an intent to manage the stylesheet loading state from your from your Component code and React will not hoist or deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop remove the %s, otherwise remove the `precedence` prop.',
              type,
              disabled,
              onError
            );
        }
        outsideHostContainerContext &&
          ("string" !== typeof props.rel ||
          "string" !== typeof props.href ||
          "" === props.href
            ? console.error(
                "Cannot render a <link> outside the main document without a `rel` and `href` prop. Try adding a `rel` and/or `href` prop to this <link> or moving the link into the <head> tag"
              )
            : (props.onError || props.onLoad) &&
              console.error(
                "Cannot render a <link> with onLoad or onError listeners outside the main document. Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or somewhere in the <body>."
              ));
        break;
      }
      switch (props.rel) {
        case "stylesheet":
          return (
            (type = props.precedence),
            (props = props.disabled),
            "string" !== typeof type &&
              outsideHostContainerContext &&
              console.error(
                'Cannot render a <link rel="stylesheet" /> outside the main document without knowing its precedence. Consider adding precedence="default" or moving it into the root <head> tag.'
              ),
            "string" === typeof type && null == props
          );
        default:
          return !0;
      }
    case "script":
      type =
        props.async &&
        "function" !== typeof props.async &&
        "symbol" !== typeof props.async;
      if (
        !type ||
        props.onLoad ||
        props.onError ||
        !props.src ||
        "string" !== typeof props.src
      ) {
        outsideHostContainerContext &&
          (type
            ? props.onLoad || props.onError
              ? console.error(
                  "Cannot render a <script> with onLoad or onError listeners outside the main document. Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or somewhere in the <body>."
                )
              : console.error(
                  "Cannot render a <script> outside the main document without `async={true}` and a non-empty `src` prop. Ensure there is a valid `src` and either make the script async or move it into the root <head> tag or somewhere in the <body>."
                )
            : console.error(
                'Cannot render a sync or defer <script> outside the main document without knowing its order. Try adding async="" or moving it into the root <head> tag.'
              ));
        break;
      }
      return !0;
    case "noscript":
    case "template":
      outsideHostContainerContext &&
        console.error(
          "Cannot render <%s> outside the main document. Try moving it into the root <head> tag.",
          type
        );
  }
  return !1;
}
function preloadResource(resource) {
  return "stylesheet" === resource.type &&
    (resource.state.loading & Settled) === NotLoaded
    ? !1
    : !0;
}
function suspendResource(state, hoistableRoot, resource, props) {
  if (
    "stylesheet" === resource.type &&
    ("string" !== typeof props.media ||
      !1 !== matchMedia(props.media).matches) &&
    (resource.state.loading & Inserted) === NotLoaded
  ) {
    if (null === resource.instance) {
      var key = getStyleKey(props.href),
        instance = hoistableRoot.querySelector(
          getStylesheetSelectorFromKey(key)
        );
      if (instance) {
        hoistableRoot = instance._p;
        null !== hoistableRoot &&
          "object" === typeof hoistableRoot &&
          "function" === typeof hoistableRoot.then &&
          (state.count++,
          (state = onUnsuspend.bind(state)),
          hoistableRoot.then(state, state));
        resource.state.loading |= Inserted;
        resource.instance = instance;
        markNodeAsHoistable(instance);
        return;
      }
      instance = hoistableRoot.ownerDocument || hoistableRoot;
      props = stylesheetPropsFromRawProps(props);
      (key = preloadPropsMap.get(key)) &&
        adoptPreloadPropsForStylesheet(props, key);
      instance = instance.createElement("link");
      markNodeAsHoistable(instance);
      var linkInstance = instance;
      linkInstance._p = new Promise(function (resolve, reject) {
        linkInstance.onload = resolve;
        linkInstance.onerror = reject;
      });
      setInitialProperties(instance, "link", props);
      resource.instance = instance;
    }
    null === state.stylesheets && (state.stylesheets = new Map());
    state.stylesheets.set(resource, hoistableRoot);
    (hoistableRoot = resource.state.preload) &&
      (resource.state.loading & Settled) === NotLoaded &&
      (state.count++,
      (resource = onUnsuspend.bind(state)),
      hoistableRoot.addEventListener("load", resource),
      hoistableRoot.addEventListener("error", resource));
  }
}
function waitForCommitToBeReady(state, timeoutOffset) {
  state.stylesheets &&
    0 === state.count &&
    insertSuspendedStylesheets(state, state.stylesheets);
  return 0 < state.count || 0 < state.imgCount
    ? function (commit) {
        var stylesheetTimer = setTimeout(function () {
          state.stylesheets &&
            insertSuspendedStylesheets(state, state.stylesheets);
          if (state.unsuspend) {
            var unsuspend = state.unsuspend;
            state.unsuspend = null;
Public API Shift

exports.unstable_Activity was replaced by stable exports.Activity; exports.Children construction changed. Ensure any internal or user-facing code depending on the unstable export continues to work and tree-shaking/bundle size isn’t negatively impacted by the new export aliasing.

  this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
};
var deprecatedAPIs = {
  isMounted: [
    "isMounted",
    "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
  ],
  replaceState: [
    "replaceState",
    "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
  ]
};
for (fnName in deprecatedAPIs)
  deprecatedAPIs.hasOwnProperty(fnName) &&
    defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
ComponentDummy.prototype = Component.prototype;
deprecatedAPIs = PureComponent.prototype = new ComponentDummy();
deprecatedAPIs.constructor = PureComponent;
assign(deprecatedAPIs, Component.prototype);
deprecatedAPIs.isPureReactComponent = !0;
var isArrayImpl = Array.isArray,
  REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
  ReactSharedInternals = {
    H: null,
    A: null,
    T: null,
    S: null,
    G: null,
    actQueue: null,
    asyncTransitions: 0,
    isBatchingLegacy: !1,
    didScheduleLegacyUpdate: !1,
    didUsePromise: !1,
    thrownErrors: [],
    getCurrentStack: null,
    recentlyCreatedOwnerStacks: 0
  },
  hasOwnProperty = Object.prototype.hasOwnProperty,
  createTask = console.createTask
    ? console.createTask
    : function () {
        return null;
      };
deprecatedAPIs = {
  react_stack_bottom_frame: function (callStackForError) {
    return callStackForError();
  }
};
var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
var didWarnAboutElementRef = {};
var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(
  deprecatedAPIs,
  UnknownOwner
)();
var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
var didWarnAboutMaps = !1,
  userProvidedKeyEscapeRegex = /\/+/g,
  reportGlobalError =
    "function" === typeof reportError
      ? reportError
      : function (error) {
          if (
            "object" === typeof window &&
            "function" === typeof window.ErrorEvent
          ) {
            var event = new window.ErrorEvent("error", {
              bubbles: !0,
              cancelable: !0,
              message:
                "object" === typeof error &&
                null !== error &&
                "string" === typeof error.message
                  ? String(error.message)
                  : String(error),
              error: error
            });
            if (!window.dispatchEvent(event)) return;
          } else if (
            "object" === typeof process &&
            "function" === typeof process.emit
          ) {
            process.emit("uncaughtException", error);
            return;
          }
          console.error(error);
        },
  didWarnAboutMessageChannel = !1,
  enqueueTaskImpl = null,
  actScopeDepth = 0,
  didWarnNoAwaitAct = !1,
  isFlushing = !1,
  queueSeveralMicrotasks =
    "function" === typeof queueMicrotask
      ? function (callback) {
          queueMicrotask(function () {
            return queueMicrotask(callback);
          });
        }
      : enqueueTask;
deprecatedAPIs = Object.freeze({
  __proto__: null,
  c: function (size) {
    return resolveDispatcher().useMemoCache(size);
  }
});
var fnName = {
  map: mapChildren,
  forEach: function (children, forEachFunc, forEachContext) {
    mapChildren(
      children,
      function () {
        forEachFunc.apply(this, arguments);
      },
      forEachContext
    );
  },
  count: function (children) {
    var n = 0;
    mapChildren(children, function () {
      n++;
    });
    return n;
  },
  toArray: function (children) {
    return (
      mapChildren(children, function (child) {
        return child;
      }) || []
    );
  },
  only: function (children) {
    if (!isValidElement(children))
      throw Error(
        "React.Children.only expected to receive a single React element child."
      );
    return children;
  }
};
exports.Activity = REACT_ACTIVITY_TYPE;
exports.Children = fnName;
exports.Component = Component;
exports.Fragment = REACT_FRAGMENT_TYPE;
exports.Profiler = REACT_PROFILER_TYPE;
exports.PureComponent = PureComponent;
exports.StrictMode = REACT_STRICT_MODE_TYPE;
exports.Suspense = REACT_SUSPENSE_TYPE;
exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =
  ReactSharedInternals;
exports.__COMPILER_RUNTIME = deprecatedAPIs;
exports.act = function (callback) {
  var prevActQueue = ReactSharedInternals.actQueue,
    prevActScopeDepth = actScopeDepth;
  actScopeDepth++;
  var queue = (ReactSharedInternals.actQueue =
      null !== prevActQueue ? prevActQueue : []),
    didAwaitActCall = !1;
  try {
    var result = callback();
  } catch (error) {
    ReactSharedInternals.thrownErrors.push(error);
  }
  if (0 < ReactSharedInternals.thrownErrors.length)
    throw (
      (popActScope(prevActQueue, prevActScopeDepth),
      (callback = aggregateErrors(ReactSharedInternals.thrownErrors)),
      (ReactSharedInternals.thrownErrors.length = 0),
      callback)
    );
  if (
    null !== result &&
    "object" === typeof result &&
    "function" === typeof result.then
  ) {
    var thenable = result;
    queueSeveralMicrotasks(function () {
      didAwaitActCall ||
        didWarnNoAwaitAct ||
        ((didWarnNoAwaitAct = !0),
        console.error(
          "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
        ));
    });
    return {
      then: function (resolve, reject) {
        didAwaitActCall = !0;
        thenable.then(
          function (returnValue) {
            popActScope(prevActQueue, prevActScopeDepth);
            if (0 === prevActScopeDepth) {
              try {
                flushActQueue(queue),
                  enqueueTask(function () {
                    return recursivelyFlushAsyncActWork(
                      returnValue,
                      resolve,
                      reject
                    );
                  });
              } catch (error$0) {
                ReactSharedInternals.thrownErrors.push(error$0);
              }
              if (0 < ReactSharedInternals.thrownErrors.length) {
                var _thrownError = aggregateErrors(
                  ReactSharedInternals.thrownErrors
                );
                ReactSharedInternals.thrownErrors.length = 0;
                reject(_thrownError);
              }
            } else resolve(returnValue);
          },
          function (error) {
            popActScope(prevActQueue, prevActScopeDepth);
            0 < ReactSharedInternals.thrownErrors.length
              ? ((error = aggregateErrors(
                  ReactSharedInternals.thrownErrors
                )),
                (ReactSharedInternals.thrownErrors.length = 0),
                reject(error))
              : reject(error);
          }
        );
      }
    };
  }
  var returnValue$jscomp$0 = result;
  popActScope(prevActQueue, prevActScopeDepth);
  0 === prevActScopeDepth &&
    (flushActQueue(queue),
    0 !== queue.length &&
      queueSeveralMicrotasks(function () {
        didAwaitActCall ||
          didWarnNoAwaitAct ||
          ((didWarnNoAwaitAct = !0),
          console.error(
            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
          ));
      }),
    (ReactSharedInternals.actQueue = null));
  if (0 < ReactSharedInternals.thrownErrors.length)
    throw (
      ((callback = aggregateErrors(ReactSharedInternals.thrownErrors)),
      (ReactSharedInternals.thrownErrors.length = 0),
      callback)
    );
  return {
    then: function (resolve, reject) {
      didAwaitActCall = !0;
      0 === prevActScopeDepth
        ? ((ReactSharedInternals.actQueue = queue),
          enqueueTask(function () {
            return recursivelyFlushAsyncActWork(
              returnValue$jscomp$0,
              resolve,
              reject
            );
          }))
        : resolve(returnValue$jscomp$0);
    }
  };
};
exports.cache = function (fn) {
  return function () {
    return fn.apply(null, arguments);
  };
};
exports.cacheSignal = function () {
  return null;
};
exports.captureOwnerStack = function () {
  var getCurrentStack = ReactSharedInternals.getCurrentStack;
  return null === getCurrentStack ? null : getCurrentStack();
};
exports.cloneElement = function (element, config, children) {
  if (null === element || void 0 === element)
    throw Error(
      "The argument must be a React element, but you passed " +
        element +
        "."
    );
  var props = assign({}, element.props),
    key = element.key,
    owner = element._owner;
  if (null != config) {
    var JSCompiler_inline_result;
    a: {
      if (
        hasOwnProperty.call(config, "ref") &&
        (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(
          config,
          "ref"
        ).get) &&
        JSCompiler_inline_result.isReactWarning
      ) {
        JSCompiler_inline_result = !1;
        break a;
      }
      JSCompiler_inline_result = void 0 !== config.ref;
    }
    JSCompiler_inline_result && (owner = getOwner());
    hasValidKey(config) &&
      (checkKeyStringCoercion(config.key), (key = "" + config.key));
    for (propName in config)
      !hasOwnProperty.call(config, propName) ||
        "key" === propName ||
        "__self" === propName ||
        "__source" === propName ||
        ("ref" === propName && void 0 === config.ref) ||
        (props[propName] = config[propName]);
  }
  var propName = arguments.length - 2;
  if (1 === propName) props.children = children;
  else if (1 < propName) {
    JSCompiler_inline_result = Array(propName);
    for (var i = 0; i < propName; i++)
      JSCompiler_inline_result[i] = arguments[i + 2];
    props.children = JSCompiler_inline_result;
  }
  props = ReactElement(
    element.type,
    key,
    props,
    owner,
    element._debugStack,
    element._debugTask
  );
  for (key = 2; key < arguments.length; key++)
    validateChildKeys(arguments[key]);
  return props;
};
exports.createContext = function (defaultValue) {
  defaultValue = {
    $$typeof: REACT_CONTEXT_TYPE,
    _currentValue: defaultValue,
    _currentValue2: defaultValue,
    _threadCount: 0,
    Provider: null,
    Consumer: null
  };
  defaultValue.Provider = defaultValue;
  defaultValue.Consumer = {
    $$typeof: REACT_CONSUMER_TYPE,
    _context: defaultValue
  };
  defaultValue._currentRenderer = null;
  defaultValue._currentRenderer2 = null;
  return defaultValue;
};
exports.createElement = function (type, config, children) {
  for (var i = 2; i < arguments.length; i++)
    validateChildKeys(arguments[i]);
  i = {};
  var key = null;
  if (null != config)
    for (propName in (didWarnAboutOldJSXRuntime ||
      !("__self" in config) ||
      "key" in config ||
      ((didWarnAboutOldJSXRuntime = !0),
      console.w...

@qodo-merge-for-open-source
Copy link

PR Code Suggestions ✨

Explore these optional code suggestions:

CategorySuggestion                                                                                                                                    Impact
Possible issue
Fix bug in loop counter

Fix a bug in estimateBandwidth by using a separate counter for the inner loop to
prevent it from interfering with the outer loop's iteration.

packages/next/src/compiled/react-dom/cjs/react-dom-client.development.js [20002-20052]

 function estimateBandwidth() {
   if ("function" === typeof performance.getEntriesByType) {
     for (
       var count = 0,
         bits = 0,
         resourceEntries = performance.getEntriesByType("resource"),
         i = 0;
       i < resourceEntries.length;
       i++
     ) {
       var entry = resourceEntries[i],
         transferSize = entry.transferSize,
         initiatorType = entry.initiatorType,
         duration = entry.duration;
       if (
         transferSize &&
         duration &&
         isLikelyStaticResource(initiatorType)
       ) {
-        initiatorType = 0;
-        duration = entry.responseEnd;
-        for (i += 1; i < resourceEntries.length; i++) {
-          var overlapEntry = resourceEntries[i],
+        var overlappingBytes = 0;
+        var responseEnd = entry.responseEnd;
+        for (var j = i + 1; j < resourceEntries.length; j++) {
+          var overlapEntry = resourceEntries[j],
             overlapStartTime = overlapEntry.startTime;
-          if (overlapStartTime > duration) break;
+          if (overlapStartTime > responseEnd) break;
           var overlapTransferSize = overlapEntry.transferSize,
             overlapInitiatorType = overlapEntry.initiatorType;
-          overlapTransferSize &&
-            isLikelyStaticResource(overlapInitiatorType) &&
-            ((overlapEntry = overlapEntry.responseEnd),
-            (initiatorType +=
+          if (
+            overlapTransferSize &&
+            isLikelyStaticResource(overlapInitiatorType)
+          ) {
+            var overlapResponseEnd = overlapEntry.responseEnd;
+            overlappingBytes +=
               overlapTransferSize *
-              (overlapEntry < duration
+              (overlapResponseEnd < responseEnd
                 ? 1
-                : (duration - overlapStartTime) /
-                  (overlapEntry - overlapStartTime))));
+                : (responseEnd - overlapStartTime) /
+                  (overlapResponseEnd - overlapStartTime));
+          }
         }
-        --i;
         bits +=
-          (8 * (transferSize + initiatorType)) / (entry.duration / 1e3);
+          (8 * (transferSize + overlappingBytes)) / (entry.duration / 1e3);
         count++;
         if (10 < count) break;
       }
     }
     if (0 < count) return bits / count / 1e6;
   }
   return navigator.connection &&
     ((count = navigator.connection.downlink), "number" === typeof count)
     ? count
     : 5;
 }
  • Apply / Chat
Suggestion importance[1-10]: 9

__

Why: The suggestion correctly identifies a critical bug where the inner loop modifies the outer loop's counter variable i, which would lead to incorrect bandwidth estimation.

High
Pass missing argument to function

Pass the missing streamState argument in the call to processFullStringRow within
the processFullBinaryRow function.

packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.browser.development.js [3935-4090]

 function processFullBinaryRow(
   response,
   streamState,
   id,
   tag,
   buffer,
   chunk
 ) {
   switch (tag) {
 ...
   }
   for (
     var row = "", stringDecoder = new TextDecoder(), i = 0;
     i < buffer.length;
     i++
   )
     row += stringDecoder.decode(buffer[i], decoderOptions);
   row += stringDecoder.decode(chunk);
-  processFullStringRow(response, id, tag, row);
+  processFullStringRow(response, streamState, id, tag, row);
 }

[To ensure code accuracy, apply this suggestion manually]

Suggestion importance[1-10]: 8

__

Why: The suggestion correctly identifies that the streamState argument is missing in the call to processFullStringRow, which is a bug introduced in the PR that would likely cause runtime errors.

Medium
Avoid variable shadowing to prevent bugs

In resolveErrorDev, avoid reassigning the errorInfo variable by introducing new
variables for intermediate results, which preserves the original object and
improves code clarity.

packages/next/src/compiled/react-server-dom-turbopack-experimental/cjs/react-server-dom-turbopack-client.edge.development.js [3124-3157]

 function resolveErrorDev(response, errorInfo) {
   var name = errorInfo.name,
     env = errorInfo.env;
   var error = buildFakeCallStack(
     response,
     errorInfo.stack,
     env,
     errorInfo.componentStack,
     errorInfo.owner,
     new Error(
       errorInfo.message ||
         "An error occurred in the Server Components render but no message was provided"
     )
   );
   var ownerTask = null;
-  null != errorInfo.owner &&
-    ((errorInfo = errorInfo.owner.slice(1)),
-    (errorInfo = getOutlinedModel(
+  if (null != errorInfo.owner) {
+    var ownerReference = errorInfo.owner.slice(1);
+    var ownerModel = getOutlinedModel(
       response,
-      errorInfo,
+      ownerReference,
       {},
       "",
       createModel
-    )),
-    null !== errorInfo &&
-      (ownerTask = initializeFakeTask(response, errorInfo)));
+    );
+    if (null !== ownerModel) {
+      ownerTask = initializeFakeTask(response, ownerModel);
+    }
+  }
   null === ownerTask
     ? ((response = getRootTask(response, env)),
       (error = null != response ? response.run(error) : error()))
     : (error = ownerTask.run(error));
   error.name = name;
   error.environmentName = env;
   return error;
 }

[To ensure code accuracy, apply this suggestion manually]

Suggestion importance[1-10]: 7

__

Why: The suggestion correctly identifies variable reassignment (errorInfo) that makes the code confusing and potentially buggy, and the proposed change improves code clarity and robustness.

Medium
Avoid infinite loop in bandwidth estimation

Refactor the nested loop in estimateBandwidth to use a separate index variable,
improving readability and preventing potential looping issues.

packages/next/src/compiled/react-dom-experimental/cjs/react-dom-client.production.js [16392-16437]

 function estimateBandwidth() {
   if ("function" === typeof performance.getEntriesByType) {
     for (
       var count = 0,
         bits = 0,
         resourceEntries = performance.getEntriesByType("resource"),
         i = 0;
       i < resourceEntries.length;
       i++
     ) {
       var entry = resourceEntries[i],
         transferSize = entry.transferSize,
         initiatorType = entry.initiatorType,
         duration = entry.duration;
       if (transferSize && duration && isLikelyStaticResource(initiatorType)) {
-        initiatorType = 0;
-        duration = entry.responseEnd;
-        for (i += 1; i < resourceEntries.length; i++) {
-          var overlapEntry = resourceEntries[i],
+        var overlappingBytes = 0;
+        var responseEnd = entry.responseEnd;
+        var j = i + 1;
+        for (; j < resourceEntries.length; j++) {
+          var overlapEntry = resourceEntries[j],
             overlapStartTime = overlapEntry.startTime;
-          if (overlapStartTime > duration) break;
+          if (overlapStartTime > responseEnd) break;
           var overlapTransferSize = overlapEntry.transferSize,
             overlapInitiatorType = overlapEntry.initiatorType;
-          overlapTransferSize &&
-            isLikelyStaticResource(overlapInitiatorType) &&
-            ((overlapEntry = overlapEntry.responseEnd),
-            (initiatorType +=
+          if (overlapTransferSize && isLikelyStaticResource(overlapInitiatorType)) {
+            var overlapResponseEnd = overlapEntry.responseEnd;
+            overlappingBytes +=
               overlapTransferSize *
-              (overlapEntry < duration
+              (overlapResponseEnd < responseEnd
                 ? 1
-                : (duration - overlapStartTime) /
-                  (overlapEntry - overlapStartTime))));
+                : (responseEnd - overlapStartTime) /
+                  (overlapResponseEnd - overlapStartTime));
+          }
         }
-        --i;
-        bits += (8 * (transferSize + initiatorType)) / (entry.duration / 1e3);
+        i = j - 1;
+        bits += (8 * (transferSize + overlappingBytes)) / (entry.duration / 1e3);
         count++;
         if (10 < count) break;
       }
     }
     if (0 < count) return bits / count / 1e6;
   }
   return navigator.connection &&
     ((count = navigator.connection.downlink), "number" === typeof count)
     ? count
     : 5;
 }
  • Apply / Chat
Suggestion importance[1-10]: 6

__

Why: The suggestion correctly identifies a complex and error-prone nested loop structure and proposes a much clearer and more maintainable implementation.

Low
Fix typo in string literal

In flushSpawnedWork, remove the leading space from the string " error" in the
console.timeStamp call to ensure correct color parsing in performance tools.

packages/next/src/compiled/react-dom-experimental/cjs/react-dom-profiling.profiling.js [15402-15421]

 function flushSpawnedWork() {
   if (4 === pendingEffectsStatus || 3 === pendingEffectsStatus) {
     if (4 === pendingEffectsStatus) {
       var startViewTransitionStartTime = commitEndTime;
       commitEndTime = now();
       var abortedViewTransition = 1 === pendingDelayedCommitReason;
       !supportsUserTiming ||
         commitEndTime <= startViewTransitionStartTime ||
         console.timeStamp(
           abortedViewTransition
             ? "Interrupted View Transition"
             : "Starting Animation",
           startViewTransitionStartTime,
           commitEndTime,
           currentTrack,
           "Scheduler \u269b",
-          abortedViewTransition ? " error" : "secondary-light"
+          abortedViewTransition ? "error" : "secondary-light"
         );
       1 !== pendingDelayedCommitReason && (pendingDelayedCommitReason = 3);
     }
 ...

[To ensure code accuracy, apply this suggestion manually]

Suggestion importance[1-10]: 4

__

Why: The suggestion correctly identifies a likely typo in a string literal (" error") that could affect performance tooling, and the fix is simple and correct.

Low
General
Avoid reusing a loop variable

In the estimateBandwidth function, replace the reused initiatorType variable
with a new overlapBits variable for accumulating overlapping transfer sizes to
improve clarity.

packages/next/src/compiled/react-dom-experimental/cjs/react-dom-profiling.profiling.js [18258-18303]

 function estimateBandwidth() {
   if ("function" === typeof performance.getEntriesByType) {
     for (
       var count = 0,
         bits = 0,
         resourceEntries = performance.getEntriesByType("resource"),
         i = 0;
       i < resourceEntries.length;
       i++
     ) {
       var entry = resourceEntries[i],
         transferSize = entry.transferSize,
         initiatorType = entry.initiatorType,
         duration = entry.duration;
       if (transferSize && duration && isLikelyStaticResource(initiatorType)) {
-        initiatorType = 0;
+        var overlapBits = 0;
         duration = entry.responseEnd;
         for (i += 1; i < resourceEntries.length; i++) {
           var overlapEntry = resourceEntries[i],
             overlapStartTime = overlapEntry.startTime;
           if (overlapStartTime > duration) break;
           var overlapTransferSize = overlapEntry.transferSize,
             overlapInitiatorType = overlapEntry.initiatorType;
           overlapTransferSize &&
             isLikelyStaticResource(overlapInitiatorType) &&
             ((overlapEntry = overlapEntry.responseEnd),
-            (initiatorType +=
+            (overlapBits +=
               overlapTransferSize *
               (overlapEntry < duration
                 ? 1
                 : (duration - overlapStartTime) /
                   (overlapEntry - overlapStartTime))));
         }
         --i;
-        bits += (8 * (transferSize + initiatorType)) / (entry.duration / 1e3);
+        bits += (8 * (transferSize + overlapBits)) / (entry.duration / 1e3);
         count++;
         if (10 < count) break;
       }
     }
     if (0 < count) return bits / count / 1e6;
   }
   return navigator.connection &&
     ((count = navigator.connection.downlink), "number" === typeof count)
     ? count
     : 5;
 }
  • Apply / Chat
Suggestion importance[1-10]: 5

__

Why: The suggestion correctly identifies confusing variable reuse in a newly added function and proposes a clearer implementation, improving readability and maintainability.

Low
  • More

@qodo-merge-for-open-source
Copy link

CI Feedback 🧐

A test triggered by this PR failed. Here is an AI-generated analysis of the failure:

Action: thank you, next

Failed stage: Fail if any job failed or was cancelled [❌]

Failed test name: test-cargo-unit

Failure summary:

The workflow failed because some jobs reported failures:
- lint: failure
- test-cargo-unit: failure

The final step echoed the failure summary and exited with code 1: ❌ Workflow failed due to job
failures or cancellations, causing the action to fail.

Relevant error logs:
1:  ##[group]Runner Image Provisioner
2:  Hosted Compute Agent
...

27:  Packages: write
28:  Pages: write
29:  PullRequests: write
30:  RepositoryProjects: write
31:  SecurityEvents: write
32:  Statuses: write
33:  ##[endgroup]
34:  Secret source: Actions
35:  Prepare workflow directory
36:  Prepare all required actions
37:  Complete job name: thank you, next
38:  ##[group]Run echo "=== Job Results Summary ==="
39:  �[36;1mecho "=== Job Results Summary ==="�[0m
40:  �[36;1mecho "build-native: success"�[0m
41:  �[36;1mecho "build-next: success"�[0m
42:  �[36;1mecho "lint: failure"�[0m
43:  �[36;1mecho "validate-docs-links: success"�[0m
44:  �[36;1mecho "check-types-precompiled: success"�[0m
45:  �[36;1mecho "test-unit: success"�[0m
46:  �[36;1m# echo "test-dev: " # Disabled - see test-dev job�[0m
47:  �[36;1m# echo "test-prod: " # Disabled - see test-prod job�[0m
48:  �[36;1m# echo "test-integration: " # Disabled - see test-integration job�[0m
49:  �[36;1mecho "test-firefox-safari: success"�[0m
50:  �[36;1m# echo "test-ppr-dev: " # Disabled�[0m
51:  �[36;1m# echo "test-ppr-prod: " # Disabled�[0m
52:  �[36;1m# echo "test-ppr-integration: " # Disabled�[0m
53:  �[36;1m# echo "test-experimental-dev: " # Disabled�[0m
54:  �[36;1m# echo "test-experimental-prod: " # Disabled�[0m
55:  �[36;1m# echo "test-experimental-integration: " # Disabled�[0m
56:  �[36;1mecho "test-cargo-unit: failure"�[0m
57:  �[36;1mecho "rust-check: success"�[0m
...

61:  �[36;1mecho "test-new-tests-start: success"�[0m
62:  �[36;1mecho "test-new-tests-deploy: success"�[0m
63:  �[36;1mecho "test-unit-windows: skipped"�[0m
64:  �[36;1mecho "test-dev-windows: skipped"�[0m
65:  �[36;1mecho "test-integration-windows: skipped"�[0m
66:  �[36;1mecho "test-prod-windows: skipped"�[0m
67:  �[36;1mecho "=========================="�[0m
68:  shell: /usr/bin/bash -e {0}
69:  env:
70:  NODE_MAINTENANCE_VERSION: 18
71:  NODE_LTS_VERSION: 20
72:  ##[endgroup]
73:  === Job Results Summary ===
74:  build-native: success
75:  build-next: success
76:  lint: failure
77:  validate-docs-links: success
78:  check-types-precompiled: success
79:  test-unit: success
80:  test-firefox-safari: success
81:  test-cargo-unit: failure
82:  rust-check: success
83:  rustdoc-check: success
84:  test-next-swc-wasm: success
85:  test-new-tests-dev: success
86:  test-new-tests-start: success
87:  test-new-tests-deploy: success
88:  test-unit-windows: skipped
89:  test-dev-windows: skipped
90:  test-integration-windows: skipped
91:  test-prod-windows: skipped
92:  ==========================
93:  ##[group]Run echo "=== Failed/Cancelled Jobs ==="
94:  �[36;1mecho "=== Failed/Cancelled Jobs ==="�[0m
95:  �[36;1mif [[ "true" == "true" ]]; then�[0m
96:  �[36;1m  echo "❌ Some jobs FAILED"�[0m
97:  �[36;1mfi�[0m
98:  �[36;1mif [[ "false" == "true" ]]; then�[0m
99:  �[36;1m  echo "⚠️  Some jobs were CANCELLED"�[0m
100:  �[36;1mfi�[0m
101:  �[36;1mif [[ "true" == "true" ]]; then�[0m
102:  �[36;1m  echo "⏭️  Some jobs were SKIPPED"�[0m
103:  �[36;1mfi�[0m
104:  �[36;1mecho "=========================="�[0m
105:  shell: /usr/bin/bash -e {0}
106:  env:
107:  NODE_MAINTENANCE_VERSION: 18
108:  NODE_LTS_VERSION: 20
109:  ##[endgroup]
110:  === Failed/Cancelled Jobs ===
111:  ❌ Some jobs FAILED
112:  ⏭️  Some jobs were SKIPPED
113:  ==========================
114:  ##[group]Run echo "❌ Workflow failed due to job failures or cancellations"
115:  �[36;1mecho "❌ Workflow failed due to job failures or cancellations"�[0m
116:  �[36;1mexit 1�[0m
117:  shell: /usr/bin/bash -e {0}
118:  env:
119:  NODE_MAINTENANCE_VERSION: 18
120:  NODE_LTS_VERSION: 20
121:  ##[endgroup]
122:  ❌ Workflow failed due to job failures or cancellations
123:  ##[error]Process completed with exit code 1.
124:  Cleaning up orphan processes

@celicoo celicoo force-pushed the minimal-ci-workflow branch from 058c213 to 80edaa6 Compare September 26, 2025 14:28
@celicoo celicoo closed this Oct 4, 2025
@celicoo celicoo force-pushed the minimal-ci-workflow branch from 6f95a68 to 9dd5506 Compare October 4, 2025 21:11
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.