@lowdefy/e2e-utils 5.6.0 → 6.0.0

package/README.md

@@ -151,6 +151,8 @@ await ldf.url().expect.toMatch(/\/tickets\/\d+/);
 
 // Query params
 await ldf.urlQuery('filter').expect.toBe('active');
+// do.set navigates through the app router, so a Dynamic page re-resolves its
+// content for the new query before this resolves.
 await ldf.urlQuery('page').do.set('2');
 
 // Get raw values
@@ -205,6 +207,20 @@ const blockState = await ldf.block('name_input').state();
 const validation = await ldf.block('email_input').validation();
 ```
 
+### Keyboard Shortcuts
+
+A `mod` shortcut resolves to Cmd or Ctrl depending on the platform the **browser** reports, which
+Playwright emulates per project — a Desktop Chrome project reports Windows even on macOS. Derive the
+key from the page rather than from `process.platform`, or the test will press a key the app is not
+listening for:
+
+```javascript
+import { getShortcutModifier } from '@lowdefy/e2e-utils';
+
+const mod = await getShortcutModifier(ldf.page);
+await ldf.page.keyboard.press(`${mod}+k`);
+```
+
 ## Complete Example
 
 ```javascript

package/dist/assertions/api.js

@@ -0,0 +1,43 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { expect } from '@playwright/test';
+import { getApiState } from '../core/api.js';
+async function expectApi(page, { endpointId, loading, response, payload, timeout = 30000 }) {
+    if (loading !== undefined) {
+        await expect.poll(async ()=>{
+            const state = await getApiState(page, endpointId);
+            return state?.loading;
+        }, {
+            timeout
+        }).toBe(loading);
+    }
+    if (response !== undefined) {
+        await expect.poll(async ()=>{
+            const state = await getApiState(page, endpointId);
+            return state?.response;
+        }, {
+            timeout
+        }).toEqual(expect.objectContaining(response));
+    }
+    if (payload !== undefined) {
+        await expect.poll(async ()=>{
+            const state = await getApiState(page, endpointId);
+            return state?.payload;
+        }, {
+            timeout
+        }).toEqual(expect.objectContaining(payload));
+    }
+}
+export { expectApi };

package/dist/assertions/index.js

@@ -0,0 +1,20 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ export { expectState } from './state.js';
+export { expectRequest } from './requests.js';
+export { expectApi } from './api.js';
+export { expectNavigation } from './navigation.js';
+export { expectUrl, expectUrlQuery } from './url.js';
+export { expectValidationStatus, expectValidationError, expectValidationWarning, expectValidationSuccess } from './validation.js';

package/dist/assertions/navigation.js

@@ -0,0 +1,19 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { expect } from '@playwright/test';
+async function expectNavigation(page, urlPattern) {
+    await expect(page).toHaveURL(urlPattern);
+}
+export { expectNavigation };

package/dist/assertions/requests.js

@@ -0,0 +1,45 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { expect } from '@playwright/test';
+import { getRequestState } from '../core/requests.js';
+async function expectRequest(page, { requestId, loading, response, payload, timeout = 30000 }) {
+    if (loading !== undefined) {
+        await expect.poll(async ()=>{
+            const state = await getRequestState(page, requestId);
+            return state?.loading;
+        }, {
+            timeout
+        }).toBe(loading);
+    }
+    if (response !== undefined) {
+        await expect.poll(async ()=>{
+            const state = await getRequestState(page, requestId);
+            return state?.response;
+        }, {
+            timeout
+        }).toEqual(expect.objectContaining(response));
+    }
+    // Payload is stored in the request state by the Lowdefy engine.
+    // It's the evaluated payload from the request config (client-side).
+    if (payload !== undefined) {
+        await expect.poll(async ()=>{
+            const state = await getRequestState(page, requestId);
+            return state?.payload;
+        }, {
+            timeout
+        }).toEqual(expect.objectContaining(payload));
+    }
+}
+export { expectRequest };

package/dist/assertions/state.js

@@ -0,0 +1,26 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { expect } from '@playwright/test';
+import { get } from '@lowdefy/helpers';
+import { getState } from '../core/state.js';
+async function expectState(page, { key, value, timeout = 5000 }) {
+    await expect.poll(async ()=>{
+        const state = await getState(page);
+        return get(state, key);
+    }, {
+        timeout
+    }).toEqual(value);
+}
+export { expectState };

package/dist/assertions/url.js

@@ -0,0 +1,32 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { expect } from '@playwright/test';
+async function expectUrl(page, { url, timeout = 5000 }) {
+    if (!url) {
+        throw new Error('expectUrl requires a "url" parameter (string or RegExp).');
+    }
+    await expect(page).toHaveURL(url, {
+        timeout
+    });
+}
+async function expectUrlQuery(page, { key, value, timeout = 5000 }) {
+    await expect.poll(async ()=>{
+        const url = new URL(page.url());
+        return url.searchParams.get(key);
+    }, {
+        timeout
+    }).toBe(value);
+}
+export { expectUrl, expectUrlQuery };

package/dist/assertions/validation.js

@@ -0,0 +1,64 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { expect } from '@playwright/test';
+import { getValidation } from '../core/validation.js';
+async function expectValidationStatus(page, { blockId, status, timeout = 5000 }) {
+    await expect.poll(async ()=>{
+        const validation = await getValidation(page, blockId);
+        return validation?.status;
+    }, {
+        timeout
+    }).toBe(status);
+}
+async function expectValidationError(page, { blockId, message, timeout = 5000 }) {
+    await expect.poll(async ()=>{
+        const validation = await getValidation(page, blockId);
+        if (validation?.status !== 'error') return {
+            status: validation?.status
+        };
+        if (message && !validation?.errors?.includes(message)) {
+            return {
+                errors: validation?.errors
+            };
+        }
+        return true;
+    }, {
+        timeout
+    }).toBe(true);
+}
+async function expectValidationWarning(page, { blockId, message, timeout = 5000 }) {
+    await expect.poll(async ()=>{
+        const validation = await getValidation(page, blockId);
+        if (validation?.status !== 'warning') return {
+            status: validation?.status
+        };
+        if (message && !validation?.warnings?.includes(message)) {
+            return {
+                warnings: validation?.warnings
+            };
+        }
+        return true;
+    }, {
+        timeout
+    }).toBe(true);
+}
+async function expectValidationSuccess(page, { blockId, timeout = 5000 }) {
+    await expectValidationStatus(page, {
+        blockId,
+        status: 'success',
+        timeout
+    });
+}
+export { expectValidationStatus, expectValidationError, expectValidationWarning, expectValidationSuccess };

package/dist/config.js

@@ -94,10 +94,7 @@ function createMultiAppConfig({ apps = [], commandPrefix = '', testDir = 'e2e',
             url: `http://localhost:${app.port}/api/auth/session`,
             reuseExistingServer: true,
             timeout,
-            cwd: app.appDir,
-            env: {
-                NEXT_PUBLIC_LOWDEFY_E2E: 'true'
-            }
+            cwd: app.appDir
         };
     });
     return defineConfig({

package/dist/core/api.js

@@ -12,8 +12,7 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import { expect } from '@playwright/test';
-async function getApiState(page, endpointId) {
+*/ async function getApiState(page, endpointId) {
     return page.evaluate((id)=>{
         const lowdefy = window.lowdefy;
         return lowdefy?.apiResponses?.[id]?.[0];
@@ -23,30 +22,4 @@ async function getApiResponse(page, { endpointId }) {
     const state = await getApiState(page, endpointId);
     return state?.response;
 }
-async function expectApi(page, { endpointId, loading, response, payload, timeout = 30000 }) {
-    if (loading !== undefined) {
-        await expect.poll(async ()=>{
-            const state = await getApiState(page, endpointId);
-            return state?.loading;
-        }, {
-            timeout
-        }).toBe(loading);
-    }
-    if (response !== undefined) {
-        await expect.poll(async ()=>{
-            const state = await getApiState(page, endpointId);
-            return state?.response;
-        }, {
-            timeout
-        }).toEqual(expect.objectContaining(response));
-    }
-    if (payload !== undefined) {
-        await expect.poll(async ()=>{
-            const state = await getApiState(page, endpointId);
-            return state?.payload;
-        }, {
-            timeout
-        }).toEqual(expect.objectContaining(payload));
-    }
-}
-export { getApiState, getApiResponse, expectApi };
+export { getApiState, getApiResponse };

package/dist/core/index.js

@@ -12,9 +12,10 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ export { getBlock } from './locators.js';
-export { goto, waitForReady, expectNavigation, waitForPage } from './navigation.js';
-export { getRequestState, getRequestResponse, expectRequest } from './requests.js';
-export { getState, getBlockState, setState, expectState } from './state.js';
-export { getValidation, expectValidationError, expectValidationWarning, expectValidationSuccess } from './validation.js';
-export { expectUrl, expectUrlQuery, setUrlQuery } from './url.js';
+*/ export { getShortcutModifier } from './keyboard.js';
+export { getBlock } from './locators.js';
+export { goto, waitForReady, waitForPage } from './navigation.js';
+export { getRequestState, getRequestResponse } from './requests.js';
+export { getState, getBlockState, setState } from './state.js';
+export { getValidation } from './validation.js';
+export { setUrlQuery } from './url.js';

package/dist/core/keyboard.js

@@ -0,0 +1,23 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // A `mod` shortcut is resolved by tinykeys, which reads navigator.platform in the browser. That is
+// the platform Playwright emulates for the project's device, not the one the test runner is on — a
+// Desktop Chrome project reports Win32 even on macOS. Reading it from the page is what keeps the key
+// a test presses the same key the app is listening for. Mirrors tinykeys' own check.
+async function getShortcutModifier(page) {
+    const isApple = await page.evaluate(()=>/Mac|iPod|iPhone|iPad/.test(navigator.platform));
+    return isApple ? 'Meta' : 'Control';
+}
+export { getShortcutModifier };

package/dist/core/navigation.js

@@ -12,8 +12,7 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import { expect } from '@playwright/test';
-async function waitForReady(page) {
+*/ async function waitForReady(page) {
     // Wait for Lowdefy client to initialize (context exists)
     // Context key is "page:{pageId}" not just pageId
     await page.waitForFunction(()=>{
@@ -32,13 +31,10 @@ async function goto(page, path) {
     });
     await waitForReady(page);
 }
-async function expectNavigation(page, urlPattern) {
-    await expect(page).toHaveURL(urlPattern);
-}
 async function waitForPage(page, path) {
     await page.waitForURL(path, {
         waitUntil: 'domcontentloaded'
     });
     await waitForReady(page);
 }
-export { goto, waitForReady, expectNavigation, waitForPage };
+export { goto, waitForReady, waitForPage };

package/dist/core/requests.js

@@ -12,8 +12,7 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import { expect } from '@playwright/test';
-async function getRequestState(page, requestId) {
+*/ async function getRequestState(page, requestId) {
     return page.evaluate((reqId)=>{
         const lowdefy = window.lowdefy;
         const pageId = lowdefy?.pageId;
@@ -25,32 +24,4 @@ async function getRequestResponse(page, { requestId }) {
     const state = await getRequestState(page, requestId);
     return state?.response;
 }
-async function expectRequest(page, { requestId, loading, response, payload, timeout = 30000 }) {
-    if (loading !== undefined) {
-        await expect.poll(async ()=>{
-            const state = await getRequestState(page, requestId);
-            return state?.loading;
-        }, {
-            timeout
-        }).toBe(loading);
-    }
-    if (response !== undefined) {
-        await expect.poll(async ()=>{
-            const state = await getRequestState(page, requestId);
-            return state?.response;
-        }, {
-            timeout
-        }).toEqual(expect.objectContaining(response));
-    }
-    // Payload is stored in the request state by the Lowdefy engine.
-    // It's the evaluated payload from the request config (client-side).
-    if (payload !== undefined) {
-        await expect.poll(async ()=>{
-            const state = await getRequestState(page, requestId);
-            return state?.payload;
-        }, {
-            timeout
-        }).toEqual(expect.objectContaining(payload));
-    }
-}
-export { getRequestState, getRequestResponse, expectRequest };
+export { getRequestState, getRequestResponse };

package/dist/core/state.js

@@ -12,9 +12,7 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import { expect } from '@playwright/test';
-import { get } from '@lowdefy/helpers';
-async function getState(page) {
+*/ async function getState(page) {
     return page.evaluate(()=>{
         const lowdefy = window.lowdefy;
         const pageId = lowdefy?.pageId;
@@ -26,26 +24,18 @@ async function getBlockState(page, { blockId }) {
     return state?.[blockId];
 }
 async function setState(page, { key, value }) {
+    // context.methods.setState does not exist on engine contexts - the engine's
+    // action layer (see createSetState.js) writes state via State.set() and then
+    // triggers a re-render via context._internal.update().
     await page.evaluate(({ k, v })=>{
         const lowdefy = window.lowdefy;
         const pageId = lowdefy?.pageId;
         const context = lowdefy?.contexts?.[`page:${pageId}`];
-        if (context?.methods?.setState) {
-            context.methods.setState({
-                [k]: v
-            });
-        }
+        context._internal.State.set(k, v);
+        context._internal.update();
     }, {
         k: key,
         v: value
     });
 }
-async function expectState(page, { key, value, timeout = 5000 }) {
-    await expect.poll(async ()=>{
-        const state = await getState(page);
-        return get(state, key);
-    }, {
-        timeout
-    }).toEqual(value);
-}
-export { getState, getBlockState, setState, expectState };
+export { getState, getBlockState, setState };

package/dist/core/url.js

@@ -12,35 +12,78 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import { expect } from '@playwright/test';
-async function expectUrl(page, { url, timeout = 5000 }) {
-    if (!url) {
-        throw new Error('expectUrl requires a "url" parameter (string or RegExp).');
+*/ import { type } from '@lowdefy/helpers';
+import { waitForReady } from './navigation.js';
+// The client router's createUrl prepends basePath, so the pathname handed to it
+// must have basePath stripped or a basePath app receives it twice.
+function createTargetLocation({ basePath = '', href, key, value }) {
+    const url = new URL(href);
+    if (type.isNone(value)) {
+        url.searchParams.delete(key);
+    } else {
+        url.searchParams.set(key, value);
     }
-    await expect(page).toHaveURL(url, {
-        timeout
-    });
-}
-async function expectUrlQuery(page, { key, value, timeout = 5000 }) {
-    await expect.poll(async ()=>{
-        const url = new URL(page.url());
-        return url.searchParams.get(key);
-    }, {
-        timeout
-    }).toBe(value);
+    const pathname = basePath && url.pathname.startsWith(basePath) ? url.pathname.slice(basePath.length) : url.pathname;
+    return {
+        pathname,
+        query: url.searchParams.toString()
+    };
 }
+// Navigates through the app's own router rather than calling history.pushState
+// directly. A bare pushState updates the URL without notifying the router, so
+// the page config is never re-fetched and Dynamic pages keep serving content
+// resolved from the previous urlQuery. Routing through the router is what a
+// Link or SetUrlQuery action in the app does.
 async function setUrlQuery(page, { key, value }) {
-    await page.evaluate(({ k, v })=>{
-        const url = new URL(window.location.href);
-        if (v === null || v === undefined) {
-            url.searchParams.delete(k);
-        } else {
-            url.searchParams.set(k, v);
+    const { basePath, dynamic, href } = await page.evaluate(()=>{
+        const lowdefy = window.lowdefy;
+        const router = lowdefy?._internal?.router;
+        if (!router) {
+            throw new Error('Lowdefy client not initialized. Call goto() before setting urlQuery.');
         }
-        window.history.pushState({}, '', url);
-    }, {
-        k: key,
-        v: value
+        return {
+            basePath: router.basePath ?? '',
+            dynamic: lowdefy.contexts[`page:${lowdefy.pageId}`]?._internal?.pageConfig?.dynamic === true,
+            href: window.location.href
+        };
     });
+    // A router navigation always re-fetches the page config, and blocks reading
+    // _url_query re-render only once that config is applied. Listening starts
+    // before the navigation so the response cannot be missed.
+    const pageConfigFetched = page.waitForResponse((response)=>response.url().includes('/api/page/'), {
+        timeout: 30000
+    }).catch((error)=>{
+        // A response that never arrives must not hang the suite — fall through and
+        // let the test's own assertion report it. Anything else is a real fault.
+        if (error.name !== 'TimeoutError') throw error;
+    });
+    // A Dynamic page's content is resolved server-side from urlQuery, and the
+    // engine rebuilds its context whenever a new config object arrives (see
+    // getContext). Waiting for that rebuild proves the re-resolved content is in
+    // place; the response arriving only proves it is on its way. Static pages keep
+    // a memoized context, so there is no identity change to wait for.
+    const previousPageConfig = dynamic ? await page.evaluateHandle(()=>window.lowdefy.contexts[`page:${window.lowdefy.pageId}`]._internal.pageConfig) : null;
+    await page.evaluate(({ pathname, query })=>{
+        // scroll: false keeps the viewport where it was — a query change is not a
+        // page navigation from the test's point of view.
+        window.lowdefy._internal.router.push({
+            pathname,
+            query,
+            scroll: false
+        });
+    }, createTargetLocation({
+        basePath,
+        href,
+        key,
+        value
+    }));
+    await pageConfigFetched;
+    if (previousPageConfig) {
+        await page.waitForFunction((previous)=>window.lowdefy.contexts[`page:${window.lowdefy.pageId}`]?._internal?.pageConfig !== previous, previousPageConfig, {
+            timeout: 30000
+        });
+        await previousPageConfig.dispose();
+    }
+    await waitForReady(page);
 }
-export { expectUrl, expectUrlQuery, setUrlQuery };
+export { createTargetLocation, setUrlQuery };

package/dist/core/validation.js

@@ -12,8 +12,7 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import { expect } from '@playwright/test';
-async function getValidation(page, blockId) {
+*/ async function getValidation(page, blockId) {
     return page.evaluate((id)=>{
         const lowdefy = window.lowdefy;
         const pageId = lowdefy?.pageId;
@@ -22,51 +21,4 @@ async function getValidation(page, blockId) {
         return block?.validationEval?.output;
     }, blockId);
 }
-async function expectValidationStatus(page, { blockId, status, timeout = 5000 }) {
-    await expect.poll(async ()=>{
-        const validation = await getValidation(page, blockId);
-        return validation?.status;
-    }, {
-        timeout
-    }).toBe(status);
-}
-async function expectValidationError(page, { blockId, message, timeout = 5000 }) {
-    await expect.poll(async ()=>{
-        const validation = await getValidation(page, blockId);
-        if (validation?.status !== 'error') return {
-            status: validation?.status
-        };
-        if (message && !validation?.errors?.includes(message)) {
-            return {
-                errors: validation?.errors
-            };
-        }
-        return true;
-    }, {
-        timeout
-    }).toBe(true);
-}
-async function expectValidationWarning(page, { blockId, message, timeout = 5000 }) {
-    await expect.poll(async ()=>{
-        const validation = await getValidation(page, blockId);
-        if (validation?.status !== 'warning') return {
-            status: validation?.status
-        };
-        if (message && !validation?.warnings?.includes(message)) {
-            return {
-                warnings: validation?.warnings
-            };
-        }
-        return true;
-    }, {
-        timeout
-    }).toBe(true);
-}
-async function expectValidationSuccess(page, { blockId, timeout = 5000 }) {
-    await expectValidationStatus(page, {
-        blockId,
-        status: 'success',
-        timeout
-    });
-}
-export { getValidation, expectValidationStatus, expectValidationError, expectValidationWarning, expectValidationSuccess };
+export { getValidation };

package/dist/fixtures/index.js

@@ -20,6 +20,20 @@ import createPageManager from '../proxy/createPageManager.js';
 import { generateManifest, loadManifest } from '../testPrep/generateManifest.js';
 import { createMockManager, loadStaticMocks } from '../mocking/index.js';
 import { setUserCookie } from '../core/userCookie.js';
+import { expectState } from '../assertions/state.js';
+import { expectRequest } from '../assertions/requests.js';
+import { expectApi } from '../assertions/api.js';
+import { expectUrl, expectUrlQuery } from '../assertions/url.js';
+// The Playwright `expect` implementations createPageManager needs for its
+// `.expect.*` methods - injected here so createPageManager itself (exported from
+// the "./runtime" subpath too) never has to import @playwright/test.
+const assertions = {
+    expectState,
+    expectRequest,
+    expectApi,
+    expectUrl,
+    expectUrlQuery
+};
 const DEFAULT_BUILD_DIR = '.lowdefy/server/build';
 // Create test with ldf fixture
 export const test = base.extend({
@@ -149,7 +163,8 @@ export const test = base.extend({
             page,
             manifest,
             helperRegistry,
-            mockManager
+            mockManager,
+            assertions
         });
         await use(pageManager);
         await mockManager.cleanup();

package/dist/index.js

@@ -12,21 +12,34 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ // Core helpers
+*/ // Core helpers (runner-agnostic - also available from the "./runtime" subpath)
 import { escapeId } from './core/escapeId.js';
+import { getShortcutModifier } from './core/keyboard.js';
 import { getBlock } from './core/locators.js';
-import { goto, waitForReady, expectNavigation, waitForPage } from './core/navigation.js';
-import { getRequestState, getRequestResponse, expectRequest } from './core/requests.js';
-import { getState, getBlockState, setState, expectState } from './core/state.js';
-import { getValidation, expectValidationStatus, expectValidationError, expectValidationWarning, expectValidationSuccess } from './core/validation.js';
-import { expectUrl, expectUrlQuery, setUrlQuery } from './core/url.js';
+import { goto, waitForReady, waitForPage } from './core/navigation.js';
+import { getRequestState, getRequestResponse } from './core/requests.js';
+import { getState, getBlockState, setState } from './core/state.js';
+import { getValidation } from './core/validation.js';
+import { setUrlQuery } from './core/url.js';
 export { escapeId };
+export { getShortcutModifier };
 export { getBlock };
-export { goto, waitForReady, expectNavigation, waitForPage };
-export { getRequestState, getRequestResponse, expectRequest };
-export { getState, getBlockState, setState, expectState };
-export { getValidation, expectValidationStatus, expectValidationError, expectValidationWarning, expectValidationSuccess };
-export { expectUrl, expectUrlQuery, setUrlQuery };
+export { goto, waitForReady, waitForPage };
+export { getRequestState, getRequestResponse };
+export { getState, getBlockState, setState };
+export { getValidation };
+export { setUrlQuery };
+// Assertions (coupled to @playwright/test)
+import { expectNavigation } from './assertions/navigation.js';
+import { expectRequest } from './assertions/requests.js';
+import { expectState } from './assertions/state.js';
+import { expectValidationStatus, expectValidationError, expectValidationWarning, expectValidationSuccess } from './assertions/validation.js';
+import { expectUrl, expectUrlQuery } from './assertions/url.js';
+export { expectNavigation };
+export { expectRequest };
+export { expectState };
+export { expectValidationStatus, expectValidationError, expectValidationWarning, expectValidationSuccess };
+export { expectUrl, expectUrlQuery };
 // Test prep utilities
 import { generateManifest, loadManifest } from './testPrep/generateManifest.js';
 export { generateManifest, loadManifest };

package/dist/proxy/createBlockHelper.js

@@ -13,7 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { expect } from '@playwright/test';
-import { expectValidationError, expectValidationWarning, expectValidationSuccess } from '../core/validation.js';
+import { expectValidationError, expectValidationWarning, expectValidationSuccess } from '../assertions/validation.js';
 // Each block's e2e helper defines a `locator` function that targets the block element on the page.
 // Two locator patterns exist:
 //   - `#${escapeId(blockId)}` — for blocks that render `id={blockId}` on their root DOM element

package/dist/proxy/createPageManager.js

@@ -14,16 +14,26 @@
   limitations under the License.
 */ import { getBlock } from '../core/locators.js';
 import { waitForReady, waitForPage } from '../core/navigation.js';
-import { getState, getBlockState, setState, expectState } from '../core/state.js';
-import { getRequestState, getRequestResponse, expectRequest } from '../core/requests.js';
-import { getApiState, getApiResponse, expectApi } from '../core/api.js';
+import { getState, getBlockState, setState } from '../core/state.js';
+import { getRequestState, getRequestResponse } from '../core/requests.js';
+import { getApiState, getApiResponse } from '../core/api.js';
 import { getValidation } from '../core/validation.js';
-import { expectUrl, expectUrlQuery, setUrlQuery } from '../core/url.js';
+import { setUrlQuery } from '../core/url.js';
 import { setUserCookie, clearUserCookie } from '../core/userCookie.js';
 import { get, type } from '@lowdefy/helpers';
 import createBlockMethodProxy from './createBlockMethodProxy.js';
 import resolveTemplateId from './resolveTemplateId.js';
-function createPageManager({ page, manifest, helperRegistry, mockManager }) {
+// createPageManager itself stays free of @playwright/test (it is exported from the
+// "./runtime" subpath). The Playwright-backed `expect*` functions are injected via
+// `assertions` by the caller - the "./fixtures" ldf fixture wires these automatically.
+function requireAssertion(fn, name) {
+    if (type.isUndefined(fn)) {
+        throw new Error(`createPageManager: "${name}" assertion is not available on this instance. ` + `Import { ${name} } from "@lowdefy/e2e-utils" and pass it as assertions.${name}, ` + `or use the "@lowdefy/e2e-utils/fixtures" ldf fixture, which wires assertions automatically.`);
+    }
+    return fn;
+}
+function createPageManager({ page, manifest, helperRegistry, mockManager, assertions = {} }) {
+    const { expectState, expectRequest, expectApi, expectUrl, expectUrlQuery } = assertions;
     let currentBlockMap = null;
     let currentPageId = null;
     function ensurePageLoaded() {
@@ -142,17 +152,17 @@ function createPageManager({ page, manifest, helperRegistry, mockManager }) {
         request (requestId) {
             return {
                 expect: {
-                    toFinish: (opts)=>expectRequest(page, {
+                    toFinish: (opts)=>requireAssertion(expectRequest, 'expectRequest')(page, {
                             requestId,
                             loading: false,
                             ...opts
                         }),
-                    toHaveResponse: (response, opts)=>expectRequest(page, {
+                    toHaveResponse: (response, opts)=>requireAssertion(expectRequest, 'expectRequest')(page, {
                             requestId,
                             response,
                             ...opts
                         }),
-                    toHavePayload: (payload, opts)=>expectRequest(page, {
+                    toHavePayload: (payload, opts)=>requireAssertion(expectRequest, 'expectRequest')(page, {
                             requestId,
                             payload,
                             ...opts
@@ -168,17 +178,17 @@ function createPageManager({ page, manifest, helperRegistry, mockManager }) {
         api (endpointId) {
             return {
                 expect: {
-                    toFinish: (opts)=>expectApi(page, {
+                    toFinish: (opts)=>requireAssertion(expectApi, 'expectApi')(page, {
                             endpointId,
                             loading: false,
                             ...opts
                         }),
-                    toHaveResponse: (response, opts)=>expectApi(page, {
+                    toHaveResponse: (response, opts)=>requireAssertion(expectApi, 'expectApi')(page, {
                             endpointId,
                             response,
                             ...opts
                         }),
-                    toHavePayload: (payload, opts)=>expectApi(page, {
+                    toHavePayload: (payload, opts)=>requireAssertion(expectApi, 'expectApi')(page, {
                             endpointId,
                             payload,
                             ...opts
@@ -205,7 +215,7 @@ function createPageManager({ page, manifest, helperRegistry, mockManager }) {
                         })
                 },
                 expect: {
-                    toBe: (value, opts)=>expectState(page, {
+                    toBe: (value, opts)=>requireAssertion(expectState, 'expectState')(page, {
                             key,
                             value,
                             ...opts
@@ -218,11 +228,11 @@ function createPageManager({ page, manifest, helperRegistry, mockManager }) {
         url () {
             return {
                 expect: {
-                    toBe: (path, opts)=>expectUrl(page, {
+                    toBe: (path, opts)=>requireAssertion(expectUrl, 'expectUrl')(page, {
                             url: path,
                             ...opts
                         }),
-                    toMatch: (pattern, opts)=>expectUrl(page, {
+                    toMatch: (pattern, opts)=>requireAssertion(expectUrl, 'expectUrl')(page, {
                             url: pattern,
                             ...opts
                         })
@@ -240,7 +250,7 @@ function createPageManager({ page, manifest, helperRegistry, mockManager }) {
                         })
                 },
                 expect: {
-                    toBe: (value, opts)=>expectUrlQuery(page, {
+                    toBe: (value, opts)=>requireAssertion(expectUrlQuery, 'expectUrlQuery')(page, {
                             key,
                             value,
                             ...opts

package/dist/runtime.js

@@ -0,0 +1,33 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Runner-agnostic surface: reading/writing a Lowdefy Page via the Playwright
+// `page` interface, with no dependency on @playwright/test. Useful for driving
+// a page from tooling that isn't a Playwright test run (e.g. headless
+// inspection). The `expect*` assertion helpers live in "./assertions" and the
+// full test-authoring API (which does depend on @playwright/test) is exported
+// from "." and "./fixtures".
+export { escapeId } from './core/escapeId.js';
+export { getShortcutModifier } from './core/keyboard.js';
+export { getBlock } from './core/locators.js';
+export { goto, waitForReady, waitForPage } from './core/navigation.js';
+export { getRequestState, getRequestResponse } from './core/requests.js';
+export { getApiState, getApiResponse } from './core/api.js';
+export { getState, getBlockState, setState } from './core/state.js';
+export { getValidation } from './core/validation.js';
+export { setUrlQuery } from './core/url.js';
+export { setUserCookie, clearUserCookie } from './core/userCookie.js';
+export { generateManifest, loadManifest } from './testPrep/generateManifest.js';
+export { createMockManager, loadStaticMocks } from './mocking/index.js';
+export { default as createPageManager } from './proxy/createPageManager.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/e2e-utils",
-  "version": "5.6.0",
+  "version": "6.0.0",
   "license": "Apache-2.0",
   "description": "Lowdefy E2E Testing Utilities for Playwright",
   "homepage": "https://lowdefy.com",
@@ -30,22 +30,23 @@
   "exports": {
     ".": "./dist/index.js",
     "./config": "./dist/config.js",
-    "./fixtures": "./dist/fixtures/index.js"
+    "./fixtures": "./dist/fixtures/index.js",
+    "./runtime": "./dist/runtime.js"
   },
   "files": [
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/helpers": "5.6.0",
+    "@lowdefy/helpers": "6.0.0",
     "js-yaml": "4.1.0",
     "prompts": "2.4.2"
   },
   "peerDependencies": {
-    "@playwright/test": "1.50.1"
+    "@playwright/test": "1.59.1"
   },
   "devDependencies": {
-    "@swc/cli": "0.8.0",
-    "@swc/core": "1.15.18",
+    "@swc/cli": "0.8.1",
+    "@swc/core": "1.15.32",
     "copyfiles": "2.4.1",
     "jest": "28.1.3"
   },