@lowdefy/e2e-utils 0.0.0-experimental-20260720072521 → 0.0.0-experimental-20260720135014

package/dist/config.js

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

package/dist/core/api.js

@@ -12,7 +12,8 @@
   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.
-*/ async function getApiState(page, endpointId) {
+*/ import { expect } from '@playwright/test';
+async function getApiState(page, endpointId) {
     return page.evaluate((id)=>{
         const lowdefy = window.lowdefy;
         return lowdefy?.apiResponses?.[id]?.[0];
@@ -22,4 +23,30 @@ async function getApiResponse(page, { endpointId }) {
     const state = await getApiState(page, endpointId);
     return state?.response;
 }
-export { getApiState, getApiResponse };
+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 };

package/dist/core/index.js

@@ -13,8 +13,8 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ 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';
+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';

package/dist/core/navigation.js

@@ -12,7 +12,8 @@
   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.
-*/ async function waitForReady(page) {
+*/ import { expect } from '@playwright/test';
+async function waitForReady(page) {
     // Wait for Lowdefy client to initialize (context exists)
     // Context key is "page:{pageId}" not just pageId
     await page.waitForFunction(()=>{
@@ -31,10 +32,13 @@ 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, waitForPage };
+export { goto, waitForReady, expectNavigation, waitForPage };

package/dist/core/requests.js

@@ -12,7 +12,8 @@
   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.
-*/ async function getRequestState(page, requestId) {
+*/ import { expect } from '@playwright/test';
+async function getRequestState(page, requestId) {
     return page.evaluate((reqId)=>{
         const lowdefy = window.lowdefy;
         const pageId = lowdefy?.pageId;
@@ -24,4 +25,32 @@ async function getRequestResponse(page, { requestId }) {
     const state = await getRequestState(page, requestId);
     return state?.response;
 }
-export { getRequestState, getRequestResponse };
+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 };

package/dist/core/state.js

@@ -12,7 +12,9 @@
   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.
-*/ async function getState(page) {
+*/ import { expect } from '@playwright/test';
+import { get } from '@lowdefy/helpers';
+async function getState(page) {
     return page.evaluate(()=>{
         const lowdefy = window.lowdefy;
         const pageId = lowdefy?.pageId;
@@ -24,18 +26,26 @@ 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}`];
-        context._internal.State.set(k, v);
-        context._internal.update();
+        if (context?.methods?.setState) {
+            context.methods.setState({
+                [k]: v
+            });
+        }
     }, {
         k: key,
         v: value
     });
 }
-export { getState, getBlockState, setState };
+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 };

package/dist/core/url.js

@@ -12,7 +12,24 @@
   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.
-*/ async function setUrlQuery(page, { key, value }) {
+*/ 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);
+}
+async function setUrlQuery(page, { key, value }) {
     await page.evaluate(({ k, v })=>{
         const url = new URL(window.location.href);
         if (v === null || v === undefined) {
@@ -26,4 +43,4 @@
         v: value
     });
 }
-export { setUrlQuery };
+export { expectUrl, expectUrlQuery, setUrlQuery };

package/dist/core/validation.js

@@ -12,7 +12,8 @@
   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.
-*/ async function getValidation(page, blockId) {
+*/ import { expect } from '@playwright/test';
+async function getValidation(page, blockId) {
     return page.evaluate((id)=>{
         const lowdefy = window.lowdefy;
         const pageId = lowdefy?.pageId;
@@ -21,4 +22,51 @@
         return block?.validationEval?.output;
     }, blockId);
 }
-export { getValidation };
+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 };

package/dist/fixtures/index.js

@@ -20,20 +20,6 @@ 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({
@@ -163,8 +149,7 @@ export const test = base.extend({
             page,
             manifest,
             helperRegistry,
-            mockManager,
-            assertions
+            mockManager
         });
         await use(pageManager);
         await mockManager.cleanup();

package/dist/index.js

@@ -12,32 +12,21 @@
   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 (runner-agnostic - also available from the "./runtime" subpath)
+*/ // Core helpers
 import { escapeId } from './core/escapeId.js';
 import { getBlock } from './core/locators.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';
+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';
 export { escapeId };
 export { getBlock };
-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 };
+export { goto, waitForReady, expectNavigation, waitForPage };
+export { getRequestState, getRequestResponse, expectRequest };
+export { getState, getBlockState, setState, expectState };
+export { getValidation, expectValidationStatus, expectValidationError, expectValidationWarning, expectValidationSuccess };
+export { expectUrl, expectUrlQuery, setUrlQuery };
 // 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 '../assertions/validation.js';
+import { expectValidationError, expectValidationWarning, expectValidationSuccess } from '../core/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,26 +14,16 @@
   limitations under the License.
 */ import { getBlock } from '../core/locators.js';
 import { waitForReady, waitForPage } from '../core/navigation.js';
-import { getState, getBlockState, setState } from '../core/state.js';
-import { getRequestState, getRequestResponse } from '../core/requests.js';
-import { getApiState, getApiResponse } from '../core/api.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 { getValidation } from '../core/validation.js';
-import { setUrlQuery } from '../core/url.js';
+import { expectUrl, expectUrlQuery, 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';
-// 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;
+function createPageManager({ page, manifest, helperRegistry, mockManager }) {
     let currentBlockMap = null;
     let currentPageId = null;
     function ensurePageLoaded() {
@@ -152,17 +142,17 @@ function createPageManager({ page, manifest, helperRegistry, mockManager, assert
         request (requestId) {
             return {
                 expect: {
-                    toFinish: (opts)=>requireAssertion(expectRequest, 'expectRequest')(page, {
+                    toFinish: (opts)=>expectRequest(page, {
                             requestId,
                             loading: false,
                             ...opts
                         }),
-                    toHaveResponse: (response, opts)=>requireAssertion(expectRequest, 'expectRequest')(page, {
+                    toHaveResponse: (response, opts)=>expectRequest(page, {
                             requestId,
                             response,
                             ...opts
                         }),
-                    toHavePayload: (payload, opts)=>requireAssertion(expectRequest, 'expectRequest')(page, {
+                    toHavePayload: (payload, opts)=>expectRequest(page, {
                             requestId,
                             payload,
                             ...opts
@@ -178,17 +168,17 @@ function createPageManager({ page, manifest, helperRegistry, mockManager, assert
         api (endpointId) {
             return {
                 expect: {
-                    toFinish: (opts)=>requireAssertion(expectApi, 'expectApi')(page, {
+                    toFinish: (opts)=>expectApi(page, {
                             endpointId,
                             loading: false,
                             ...opts
                         }),
-                    toHaveResponse: (response, opts)=>requireAssertion(expectApi, 'expectApi')(page, {
+                    toHaveResponse: (response, opts)=>expectApi(page, {
                             endpointId,
                             response,
                             ...opts
                         }),
-                    toHavePayload: (payload, opts)=>requireAssertion(expectApi, 'expectApi')(page, {
+                    toHavePayload: (payload, opts)=>expectApi(page, {
                             endpointId,
                             payload,
                             ...opts
@@ -215,7 +205,7 @@ function createPageManager({ page, manifest, helperRegistry, mockManager, assert
                         })
                 },
                 expect: {
-                    toBe: (value, opts)=>requireAssertion(expectState, 'expectState')(page, {
+                    toBe: (value, opts)=>expectState(page, {
                             key,
                             value,
                             ...opts
@@ -228,11 +218,11 @@ function createPageManager({ page, manifest, helperRegistry, mockManager, assert
         url () {
             return {
                 expect: {
-                    toBe: (path, opts)=>requireAssertion(expectUrl, 'expectUrl')(page, {
+                    toBe: (path, opts)=>expectUrl(page, {
                             url: path,
                             ...opts
                         }),
-                    toMatch: (pattern, opts)=>requireAssertion(expectUrl, 'expectUrl')(page, {
+                    toMatch: (pattern, opts)=>expectUrl(page, {
                             url: pattern,
                             ...opts
                         })
@@ -250,7 +240,7 @@ function createPageManager({ page, manifest, helperRegistry, mockManager, assert
                         })
                 },
                 expect: {
-                    toBe: (value, opts)=>requireAssertion(expectUrlQuery, 'expectUrlQuery')(page, {
+                    toBe: (value, opts)=>expectUrlQuery(page, {
                             key,
                             value,
                             ...opts

package/package.json

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

package/dist/assertions/api.js

@@ -1,43 +0,0 @@
-/*
-  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

@@ -1,20 +0,0 @@
-/*
-  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

@@ -1,19 +0,0 @@
-/*
-  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

@@ -1,45 +0,0 @@
-/*
-  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

@@ -1,26 +0,0 @@
-/*
-  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

@@ -1,32 +0,0 @@
-/*
-  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

@@ -1,64 +0,0 @@
-/*
-  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/runtime.js

@@ -1,32 +0,0 @@
-/*
-  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 { 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';