@nocobase/client-v2 2.1.18 → 2.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.18",
+  "version": "2.1.20",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -27,11 +27,11 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/evaluators": "2.1.18",
-    "@nocobase/flow-engine": "2.1.18",
-    "@nocobase/sdk": "2.1.18",
-    "@nocobase/shared": "2.1.18",
-    "@nocobase/utils": "2.1.18",
+    "@nocobase/evaluators": "2.1.20",
+    "@nocobase/flow-engine": "2.1.20",
+    "@nocobase/sdk": "2.1.20",
+    "@nocobase/shared": "2.1.20",
+    "@nocobase/utils": "2.1.20",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -46,5 +46,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "2234b42b21c96d22a4b65a1f16a65ae61f434779"
+  "gitHead": "ca646ba28bb11da083e3436866552932ed780b6f"
 }

package/src/BaseApplication.tsx

@@ -431,6 +431,10 @@ export abstract class BaseApplication<
     return getSubAppName(this.getPublicPath()) || null;
   }
 
+  getCdnUrl() {
+    return window['__webpack_public_path__'] || this.getPublicPath();
+  }
+
   getPublicPath() {
     let publicPath = this.options.publicPath || '/';
     if (!publicPath.endsWith('/')) {

package/src/flow/actions/__tests__/dataScopeFilter.test.ts

@@ -64,6 +64,40 @@ describe('normalizeDataScopeFilter', () => {
     });
   });
 
+  it('prunes a missing URL search param variable', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.urlSearchParams.departmentId }}' }],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: undefined }],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toBeUndefined();
+  });
+
+  it('only prunes the missing URL search param condition from mixed filters', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        { path: 'departmentId', operator: '$eq', value: '{{ ctx.urlSearchParams.departmentId }}' },
+      ],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        { path: 'departmentId', operator: '$eq', value: undefined },
+      ],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ status: { $eq: 'active' } }],
+    });
+  });
+
   it('still prunes empty constant values', () => {
     const filter = {
       logic: '$and',
@@ -139,6 +173,34 @@ describe('normalizeDataScopeFilter', () => {
     expect(resource.removeFilterGroup).not.toHaveBeenCalled();
   });
 
+  it('dataScope handler removes data scope when a URL search param is missing', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+    };
+    const ctx = {
+      model: {
+        uid: 'field-1',
+        resource,
+      },
+      resolveJsonTemplate: vi.fn(async (template) => ({
+        ...template,
+        items: [{ ...template.items[0], value: undefined }],
+      })),
+    };
+    const params = {
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.urlSearchParams.departmentId }}' }],
+      },
+    };
+
+    await (dataScope as any).handler(ctx, params);
+
+    expect(resource.removeFilterGroup).toHaveBeenCalledWith('field-1');
+    expect(resource.addFilterGroup).not.toHaveBeenCalled();
+  });
+
   it('dataScope handler preserves current role as server-side variable', async () => {
     const engine = new FlowEngine();
     const resource = {

package/src/flow/actions/__tests__/openView.defineProps.route.test.tsx

@@ -12,6 +12,7 @@ import { describe, it, expect, vi } from 'vitest';
 import { RUNJS_OPEN_VIEW_ROUTE_STATE } from '@nocobase/flow-engine';
 import { openView } from '../openView';
 import { FlowPage } from '../../FlowPage';
+import { ROUTE_TRANSIENT_INPUT_ARGS_KEY } from '../../routeTransientInputArgs';
 
 describe('openView action - route mode defineProperties/defineMethods', () => {
   const createRouteManagedCtx = () => {
@@ -172,6 +173,56 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
     expect(defineMethodCalls).toContain('pong');
   });
 
+  it('passes formData through route navigation state', async () => {
+    const navigateTo = vi.fn();
+    const ctx: any = {
+      inputArgs: {
+        formData: {
+          start: '2026-06-24 08:00:00',
+          end: '2026-06-24 09:00:00',
+        },
+      },
+      engine: {
+        context: {},
+      },
+      model: {
+        uid: 'popup-uid',
+        context: {
+          defineProperty: vi.fn(),
+        },
+      },
+      view: {
+        navigation: {
+          navigateTo,
+        },
+      },
+      isNavigationEnabled: true,
+    };
+
+    await openView.handler(ctx, { navigation: true });
+
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+      },
+      {
+        state: {
+          [ROUTE_TRANSIENT_INPUT_ARGS_KEY]: {
+            'popup-uid': {
+              formData: {
+                start: '2026-06-24 08:00:00',
+                end: '2026-06-24 09:00:00',
+              },
+            },
+          },
+        },
+      },
+    );
+  });
+
   it('adds route state to first-stage navigation only for RunJS ctx.openView calls', async () => {
     const { ctx, navigateTo } = createFirstStageCtx({
       mode: 'dialog',
@@ -181,13 +232,16 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
 
     await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
 
-    expect(navigateTo).toHaveBeenCalledWith({
-      viewUid: 'popup-uid',
-      filterByTk: undefined,
-      sourceId: undefined,
-      tabUid: undefined,
-      openViewRouteState: { mode: 'dialog', size: 'large' },
-    });
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+        openViewRouteState: { mode: 'dialog', size: 'large' },
+      },
+      undefined,
+    );
   });
 
   it('normalizes first-stage RunJS route state mode on mobile layout', async () => {
@@ -200,13 +254,16 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
 
     await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
 
-    expect(navigateTo).toHaveBeenCalledWith({
-      viewUid: 'popup-uid',
-      filterByTk: undefined,
-      sourceId: undefined,
-      tabUid: undefined,
-      openViewRouteState: { mode: 'embed', size: 'large' },
-    });
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+        openViewRouteState: { mode: 'embed', size: 'large' },
+      },
+      undefined,
+    );
   });
 
   it('uses route replay mode and size before persisted openView defaults', async () => {
@@ -246,11 +303,14 @@ describe('openView action - route mode defineProperties/defineMethods', () => {
 
     await openView.handler(ctx, { mode: 'drawer', size: 'medium', navigation: true });
 
-    expect(navigateTo).toHaveBeenCalledWith({
-      viewUid: 'popup-uid',
-      filterByTk: undefined,
-      sourceId: undefined,
-      tabUid: undefined,
-    });
+    expect(navigateTo).toHaveBeenCalledWith(
+      {
+        viewUid: 'popup-uid',
+        filterByTk: undefined,
+        sourceId: undefined,
+        tabUid: undefined,
+      },
+      undefined,
+    );
   });
 });

package/src/flow/actions/dataScopeFilter.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { isVariableExpression, pruneFilter } from '@nocobase/flow-engine';
+import { extractPropertyPath, isVariableExpression, pruneFilter } from '@nocobase/flow-engine';
 import { transformFilter } from '@nocobase/utils/client';
 import _ from 'lodash';
 
@@ -45,6 +45,14 @@ function restorePreservedNull(value: any): any {
   return value;
 }
 
+function isUrlSearchParamsExpression(value: any) {
+  if (!isVariableExpression(value)) {
+    return false;
+  }
+
+  return extractPropertyPath(value)?.[0] === 'urlSearchParams';
+}
+
 function markEmptyVariableValues(rawNode: any, resolvedNode: any) {
   if (!rawNode || !resolvedNode || typeof rawNode !== 'object' || typeof resolvedNode !== 'object') {
     return;
@@ -57,6 +65,7 @@ function markEmptyVariableValues(rawNode: any, resolvedNode: any) {
     }
     if (
       isVariableExpression(rawNode.value) &&
+      !isUrlSearchParamsExpression(rawNode.value) &&
       (resolvedNode.value === undefined || resolvedNode.value === null || resolvedNode.value === '')
     ) {
       resolvedNode.value = PRESERVE_NULL;

package/src/flow/actions/openView.tsx

@@ -20,6 +20,7 @@ import React from 'react';
 import { FlowPage } from '../FlowPage';
 import { PageModel, RootPageModel } from '../models';
 import _ from 'lodash';
+import { ROUTE_TRANSIENT_INPUT_ARGS_KEY } from '../routeTransientInputArgs';
 
 type DirtyAwareFlowModel = FlowModel & {
   getUserModifiedFields?: () => Set<string> | undefined;
@@ -31,6 +32,15 @@ type BeforeCloseDirtyState = {
   formModelUids: string[];
 };
 
+const pickRouteTransientInputArgs = (inputArgs: Record<string, unknown>) => {
+  return _.pickBy(
+    {
+      formData: inputArgs.formData,
+    },
+    (value) => typeof value !== 'undefined',
+  );
+};
+
 function collectDirtyFormModelUids(model?: FlowModel | null, ignoredDirtyFormModelUids: string[] = []): string[] {
   if (!model) {
     return [];
@@ -363,7 +373,17 @@ export const openView = defineAction({
           tabUid: mergedTabUid,
           ...(effectiveRunJSOpenViewRouteState ? { openViewRouteState: effectiveRunJSOpenViewRouteState } : {}),
         };
-        ctx.view.navigation.navigateTo(nextView);
+        const transientInputArgs = pickRouteTransientInputArgs(inputArgs);
+        const navigationOptions = Object.keys(transientInputArgs).length
+          ? {
+              state: {
+                [ROUTE_TRANSIENT_INPUT_ARGS_KEY]: {
+                  [nextView.viewUid]: transientInputArgs,
+                },
+              },
+            }
+          : undefined;
+        ctx.view.navigation.navigateTo(nextView, navigationOptions);
         return;
       }
     }

package/src/flow/admin-shell/BaseLayoutModel.tsx

@@ -72,6 +72,7 @@ export interface LayoutRouteLike {
   id?: string;
   name?: string;
   pathname?: string;
+  state?: unknown;
   params?: Record<string, string | undefined>;
   layoutRouteName?: string;
   layoutBasePathname?: string;
@@ -179,6 +180,7 @@ export class BaseLayoutModel<
   currentLayoutRoute: LayoutRouteMatch | null = null;
   protected routeCoordinator?: BaseLayoutRouteCoordinator;
   private activePageUid = '';
+  private currentRouteState?: unknown;
   private layoutContentElement: HTMLElement | null = null;
   private readonly routePageMetaMap = new Map<string, RoutePageMeta>();
   private contextBindingsActive = false;
@@ -355,6 +357,7 @@ export class BaseLayoutModel<
 
     const layoutRoute = this.resolveLayoutRoute(routeLike);
     this.currentLayoutRoute = layoutRoute;
+    this.currentRouteState = routeLike.state;
     this.activePageUid = this.getPageUidFromLayoutRoute(layoutRoute);
     this.getCoordinator().syncRoute({
       ...routeLike,
@@ -379,6 +382,7 @@ export class BaseLayoutModel<
     }
 
     this.currentLayoutRoute = null;
+    this.currentRouteState = undefined;
     this.activePageUid = '';
     this.routeCoordinator?.syncRoute({});
   }
@@ -448,6 +452,7 @@ export class BaseLayoutModel<
         layoutRouteName: this.layout.routeName,
         pageUid: this.currentLayoutRoute.pageUid,
         pathname: this.currentLayoutRoute.pathname,
+        state: this.currentRouteState,
         layoutBasePathname: this.currentLayoutRoute.basePathname,
         layoutRoute: this.currentLayoutRoute,
       };

package/src/flow/admin-shell/BaseLayoutRouteCoordinator.ts

@@ -22,6 +22,7 @@ import { getOpenViewStepParams } from '../flows/openViewFlow';
 import { RouteModel } from '../models/base/RouteModel';
 import { resolveViewParamsToViewList, updateViewListHidden, type ViewItem } from '../resolveViewParamsToViewList';
 import type { LayoutDefinition } from '../../layout-manager/types';
+import { getRouteTransientInputArgs } from '../routeTransientInputArgs';
 
 export interface RoutePageMeta {
   active: boolean;
@@ -52,6 +53,7 @@ interface RoutePageRuntime {
   pendingOpenViewKeys: Set<string>;
   hasStepNavigated: boolean;
   currentPathname?: string;
+  currentRouteState?: unknown;
   forceStop: boolean;
   viewGeneration: number;
 }
@@ -60,6 +62,7 @@ interface RouteLike {
   layoutRouteName?: string;
   params?: { name?: string };
   pathname?: string;
+  state?: unknown;
   pageUid?: string;
   layoutBasePathname?: string;
   layoutRoute?: {
@@ -71,6 +74,7 @@ interface RouteLike {
 
 interface SyncRuntimeOptions {
   skipInitialStepNavigation?: boolean;
+  routeState?: unknown;
 }
 
 const hasUsableSourceId = (sourceId: unknown) => sourceId !== undefined && sourceId !== null && String(sourceId) !== '';
@@ -223,7 +227,8 @@ export class BaseLayoutRouteCoordinator {
       runtime.pendingOpenViewKeys.clear();
     }
     runtime.currentPathname = pathname;
-    this.syncRuntimeWithPathname(runtime, pathname);
+    runtime.currentRouteState = routeLike.state;
+    this.syncRuntimeWithPathname(runtime, pathname, { routeState: routeLike.state });
   }
 
   cleanupPage(pageUid: string) {
@@ -243,6 +248,7 @@ export class BaseLayoutRouteCoordinator {
     runtime.prevViewList = [];
     runtime.hasStepNavigated = false;
     runtime.currentPathname = undefined;
+    runtime.currentRouteState = undefined;
   }
 
   destroy() {
@@ -293,11 +299,12 @@ export class BaseLayoutRouteCoordinator {
 
       const viewStack = parsePathnameToViewParams(pathname, { basePath: this.basePathname });
       const viewList = resolveViewParamsToViewList(this.flowEngine, viewStack, runtime.routeModel);
+      const routeState = options.routeState;
 
       if (!options.skipInitialStepNavigation && this.shouldStepNavigate(runtime, viewList)) {
-        this.stepNavigate(viewList, 0);
+        this.stepNavigate(viewList, 0, routeState);
         runtime.hasStepNavigated = true;
-        this.scheduleInitialDeepLinkReplay(runtime, pathname);
+        this.scheduleInitialDeepLinkReplay(runtime, pathname, routeState);
         return;
       }
 
@@ -322,7 +329,7 @@ export class BaseLayoutRouteCoordinator {
 
       if (nextViewsToOpen.length) {
         this.markPendingOpenViews(runtime, nextViewsToOpen);
-        this.handleOpenViews(runtime, viewList, nextViewsToOpen, runtime.viewGeneration).catch((error) => {
+        this.handleOpenViews(runtime, viewList, nextViewsToOpen, runtime.viewGeneration, routeState).catch((error) => {
           console.error(`[NocoBase] Failed to open route-managed views:`, error);
         });
       }
@@ -360,7 +367,7 @@ export class BaseLayoutRouteCoordinator {
     return runtime.prevViewList.length === 0 && viewList.length > 1 && !runtime.hasStepNavigated;
   }
 
-  private scheduleInitialDeepLinkReplay(runtime: RoutePageRuntime, pathname: string) {
+  private scheduleInitialDeepLinkReplay(runtime: RoutePageRuntime, pathname: string, routeState?: unknown) {
     const viewGeneration = runtime.viewGeneration;
     Promise.resolve()
       .then(() => {
@@ -373,23 +380,25 @@ export class BaseLayoutRouteCoordinator {
           return;
         }
 
-        this.syncRuntimeWithPathname(runtime, pathname);
+        this.syncRuntimeWithPathname(runtime, pathname, { routeState });
       })
       .catch(() => {
         // ignore
       });
   }
 
-  private stepNavigate(viewList: ViewItem[], index: number) {
+  private stepNavigate(viewList: ViewItem[], index: number, routeState?: unknown) {
     if (!viewList[index]) {
       return;
     }
 
+    const navigationOptions = routeState ? { state: routeState } : undefined;
     if (index === 0) {
       new ViewNavigation(this.flowEngine.context, [], { basePath: this.basePathname }).navigateTo(
         viewList[index].params,
         {
           replace: true,
+          ...navigationOptions,
         },
       );
     } else {
@@ -397,10 +406,10 @@ export class BaseLayoutRouteCoordinator {
         this.flowEngine.context,
         viewList.slice(0, index).map((item) => item.params),
         { basePath: this.basePathname },
-      ).navigateTo(viewList[index].params);
+      ).navigateTo(viewList[index].params, navigationOptions);
     }
 
-    this.stepNavigate(viewList, index + 1);
+    this.stepNavigate(viewList, index + 1, routeState);
   }
 
   private replayActiveRuntimeViewsAfterLayoutContentElementChange() {
@@ -411,7 +420,10 @@ export class BaseLayoutRouteCoordinator {
 
       this.resetRuntimeViewStateForLayoutContentElementChange(runtime);
       if (runtime.meta.active) {
-        this.syncRuntimeWithPathname(runtime, runtime.currentPathname, { skipInitialStepNavigation: true });
+        this.syncRuntimeWithPathname(runtime, runtime.currentPathname, {
+          skipInitialStepNavigation: true,
+          routeState: runtime.currentRouteState,
+        });
       }
     });
   }
@@ -456,6 +468,7 @@ export class BaseLayoutRouteCoordinator {
     viewList: ViewItem[],
     viewsToOpen: ViewItem[],
     viewGeneration: number,
+    routeState?: unknown,
   ) {
     const missingModels = viewsToOpen.filter((v) => !v.model);
     if (missingModels.length > 0) {
@@ -475,7 +488,7 @@ export class BaseLayoutRouteCoordinator {
     }
 
     this.syncViewListVisibility(runtime, viewList);
-    this.openViews(runtime, viewList, viewsToOpen, 0, viewGeneration);
+    this.openViews(runtime, viewList, viewsToOpen, 0, viewGeneration, routeState);
   }
 
   private openViews(
@@ -484,6 +497,7 @@ export class BaseLayoutRouteCoordinator {
     viewsToOpen: ViewItem[],
     index: number,
     viewGeneration: number,
+    routeState?: unknown,
   ) {
     if (runtime.forceStop || runtime.viewGeneration !== viewGeneration) {
       return;
@@ -511,6 +525,7 @@ export class BaseLayoutRouteCoordinator {
         : openViewParams?.associationName;
     const openViewRouteState = viewItem.params.openViewRouteState;
     const openerUids = viewList.slice(0, viewItem.index).map((item) => item.params.viewUid);
+    const transientInputArgs = getRouteTransientInputArgs(routeState, viewItem.params.viewUid);
     const navigation = new ViewNavigation(
       this.flowEngine.context,
       viewList.slice(0, viewItem.index + 1).map((item) => item.params),
@@ -529,13 +544,14 @@ export class BaseLayoutRouteCoordinator {
         deactivateRef,
         openerUids,
         ...viewItem.params,
+        ...transientInputArgs,
         ...(openViewRouteState?.mode ? { mode: openViewRouteState.mode } : {}),
         ...(openViewRouteState?.size ? { size: openViewRouteState.size } : {}),
         pageActive: runtime.meta.active,
         activationControlledByLayout: true,
         navigation,
         onOpen: () => {
-          this.openViews(runtime, viewList, viewsToOpen, index + 1, viewGeneration);
+          this.openViews(runtime, viewList, viewsToOpen, index + 1, viewGeneration, routeState);
         },
         hidden: viewItem.hidden,
         isMobileLayout: !!this.layoutContext?.isMobileLayout,

package/src/flow/admin-shell/__tests__/AdminLayoutRouteCoordinator.test.ts

@@ -16,6 +16,7 @@ import { resolveViewParamsToViewList, updateViewListHidden, type ViewItem } from
 import { AdminLayoutRouteCoordinator } from '../AdminLayoutRouteCoordinator';
 import { BaseLayoutRouteCoordinator, toViewStack } from '../BaseLayoutRouteCoordinator';
 import { RouteModel } from '../../models/base/RouteModel';
+import { ROUTE_TRANSIENT_INPUT_ARGS_KEY } from '../../routeTransientInputArgs';
 
 vi.mock('../../resolveViewParamsToViewList', () => ({
   resolveViewParamsToViewList: vi.fn(),
@@ -210,6 +211,125 @@ describe('AdminLayoutRouteCoordinator', () => {
     expect(dispatchEvent.mock.calls[0][1].target).toBe(layoutContentElement);
   });
 
+  it('passes transient route state input args to the opened view', () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ RouteModel });
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        getRouteBySchemaUid: vi.fn(() => ({})),
+      },
+    });
+
+    const dispatchEvent = createDispatchEventMock();
+    const viewItem = createViewItem('test-route', dispatchEvent);
+    mockResolveViewParamsToViewList.mockReturnValue([viewItem]);
+    mockGetViewDiffAndUpdateHidden.mockReturnValue({
+      viewsToClose: [],
+      viewsToOpen: [viewItem],
+    });
+    mockGetOpenViewStepParams.mockReturnValue({
+      collectionName: '',
+      dataSourceKey: '',
+    });
+
+    const coordinator = new BaseLayoutRouteCoordinator(engine, { basePathname: '/admin' });
+    coordinator.registerPage('test-route', {
+      active: true,
+      layoutContentElement: document.createElement('div'),
+    });
+    coordinator.syncRoute({
+      pageUid: 'test-route',
+      pathname: '/admin/test-route',
+      state: {
+        usr: {
+          [ROUTE_TRANSIENT_INPUT_ARGS_KEY]: {
+            'test-route': {
+              formData: {
+                start: '2026-06-24 08:00:00',
+                end: '2026-06-24 09:00:00',
+              },
+            },
+          },
+        },
+      },
+    });
+
+    expect(dispatchEvent.mock.calls[0][1]).toMatchObject({
+      formData: {
+        start: '2026-06-24 08:00:00',
+        end: '2026-06-24 09:00:00',
+      },
+    });
+  });
+
+  it('keeps transient route state input args during initial deep-link replay', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ RouteModel });
+    const navigate = vi.fn();
+    engine.context.defineProperty('router', {
+      value: {
+        navigate,
+      },
+    });
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        getRouteBySchemaUid: vi.fn(() => ({})),
+      },
+    });
+
+    const rootDispatchEvent = createDispatchEventMock((_eventName, payload) => {
+      payload.onOpen?.();
+      return Promise.resolve();
+    });
+    const popupDispatchEvent = createDispatchEventMock();
+    const rootViewItem = createViewItem('test-route', rootDispatchEvent);
+    const popupViewItem = createViewItem('popup', popupDispatchEvent, 1);
+
+    mockResolveViewParamsToViewList.mockReturnValue([rootViewItem, popupViewItem]);
+    mockGetViewDiffAndUpdateHidden.mockReturnValue({
+      viewsToClose: [],
+      viewsToOpen: [rootViewItem, popupViewItem],
+    });
+    mockGetOpenViewStepParams.mockReturnValue({
+      collectionName: '',
+      dataSourceKey: '',
+    });
+
+    const routeState = {
+      [ROUTE_TRANSIENT_INPUT_ARGS_KEY]: {
+        popup: {
+          formData: {
+            start: '2026-06-24',
+            end: '2026-06-25',
+          },
+        },
+      },
+    };
+    const coordinator = new BaseLayoutRouteCoordinator(engine, { basePathname: '/admin' });
+    coordinator.registerPage('test-route', {
+      active: true,
+      layoutContentElement: document.createElement('div'),
+    });
+    coordinator.syncRoute({
+      pageUid: 'test-route',
+      pathname: '/admin/test-route/view/popup',
+      state: routeState,
+    });
+
+    expect(navigate).toHaveBeenCalledWith('/admin/test-route', { replace: true, state: routeState });
+    expect(navigate).toHaveBeenCalledWith('/admin/test-route/view/popup', { state: routeState });
+    expect(popupDispatchEvent).not.toHaveBeenCalled();
+
+    await Promise.resolve();
+
+    expect(popupDispatchEvent.mock.calls[0][1]).toMatchObject({
+      formData: {
+        start: '2026-06-24',
+        end: '2026-06-25',
+      },
+    });
+  });
+
   it('replays the active route view when the layout content element changes', () => {
     const engine = new FlowEngine();
     engine.registerModels({ RouteModel });