@limetech/lime-scenario-harness 0.0.0-development

package/README.md

@@ -0,0 +1,120 @@
+# lime-scenario-harness
+
+The standard library for Lime CRM **scenario tests** — the Playwright suites
+that verify a package's user-facing behavior against a running Lime CRM,
+whether that is a CI boot or a deployed cloud environment.
+
+Published to public npm as `@limetech/lime-scenario-harness`. Extracted from
+the Packers team's e2e-verification proof of concept
+(solution-packers-dev#409).
+
+## Ownership rule
+
+Platform-shaped surfaces belong here: login and session handling, an API
+client for seeding and readback, tracked cleanup of test data, promoted-action
+interactions, translation assertions from a package's own shipped `en.po`,
+version-skew detection, the fault reporter, and `checkpoint()` evidence
+screenshots.
+
+Package knowledge — which action is "Close ticket", field names, dialogs —
+stays in each package's own helpers next to its specs.
+
+## What a spec imports
+
+```ts
+import {
+    test, // Playwright's test + fault reporter and `cleanup` fixtures
+    expect,
+    requireEnvironment, // unmet needs FAIL by default (PW_ALLOW_SKIPS=1 demotes to skips)
+    requireConfig,
+    checkpoint, // named screenshot attached to the report as evidence
+    createObject, // API client: seed, read back, update, delete
+    listObjects,
+    testDataName, // '[scenario-test] - <spec> <timestamp>' naming for seeded data
+    translation, // the English caption the package ships for a translation key
+    clickPromotedAction, // match actions by behavior, never caption
+    expectFrontendLoaded, // asserts the package's bundle loaded; warns on version skew
+} from '@limetech/lime-scenario-harness';
+```
+
+## Environment contract
+
+The target is described by one set of variables, shared with the composed
+scenario-test workflow in lime-workflows:
+
+| Variable                                | Meaning                                                                                    |
+| --------------------------------------- | ------------------------------------------------------------------------------------------ |
+| `LIME_BASE_URL`                         | App root of the target (the runner feeds it to Playwright's `baseURL`). Must end with `/`. |
+| `LIME_TEST_USER` / `LIME_TEST_PASSWORD` | Dedicated test user. Never personal credentials outside a throwaway local run.             |
+| `LIME_API_PREFIX`                       | API path prefix under the app root (cloud: `<app-name>/`, local: empty).                   |
+
+Runner-internal knobs, defaulting to the conventional layout under the
+runner's working directory:
+
+| Variable                   | Default              | Meaning                                                                                                                                                                                                                                                              |
+| -------------------------- | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `LIME_SCENARIO_STAGE_DIR`  | `./.discovered`      | Where discovery staged each package's files (one directory per Playwright project) and `versions.json`.                                                                                                                                                              |
+| `LIME_SCENARIO_AUTH_STATE` | `./.auth/state.json` | Where `authenticate()` saves the login session for `storageState`.                                                                                                                                                                                                   |
+| `PW_ALLOW_SKIPS`           | unset                | `1` demotes unmet `requireEnvironment` needs to skips. Only for tiers that knowingly run under-provisioned targets (a PR-gate boot without package data). A verification run against a provisioned environment must NOT set it: a silent skip there reads as a pass. |
+
+## Runner wiring
+
+One setup project logs in once; every suite reuses the session:
+
+```ts
+// auth.setup.ts — uses Playwright's plain `test`: the harness fault
+// reporter must not interfere with the login flow.
+import { test as setup } from '@playwright/test';
+import { authenticate } from '@limetech/lime-scenario-harness';
+
+setup('authenticate', async ({ page }) => {
+    await authenticate(page);
+});
+```
+
+```ts
+// playwright.config.ts (the shape; see the composed workflow for the real one)
+import { authStatePath } from '@limetech/lime-scenario-harness';
+
+export default defineConfig({
+    use: { baseURL: process.env.LIME_BASE_URL },
+    projects: [
+        // No storageState here: Playwright loads that file when it creates
+        // a context, so the setup project must run without one — the file
+        // does not exist until authenticate() writes it.
+        { name: 'setup', testMatch: /auth\.setup\.ts/ },
+        {
+            name: 'example-package',
+            testDir: './.discovered/example-package',
+            dependencies: ['setup'],
+            use: { storageState: authStatePath() },
+        },
+    ],
+});
+```
+
+Credentials are injected via the DOM (`setSilently`), not `fill()`:
+Playwright's HTML report prints `fill()` arguments verbatim, and reports are
+uploaded as CI artifacts that GitHub's log-only secret masking does not cover.
+
+## Test data
+
+Everything a spec seeds goes through the API, named with `testDataName()`
+(the `[scenario-test]` prefix), tracked on the `cleanup` fixture and removed
+after the test. Cleanup never fails a test but never passes silently either:
+targets are shared and persistent, so anything left behind is reported.
+Sweeps for data orphaned by crashed runs key on the exported
+`TEST_DATA_PREFIX`.
+
+## Developing
+
+```sh
+npm ci
+npm run build       # tsc → dist/
+npm test            # the harness's own unit tests (no browser involved)
+npm run format
+```
+
+Releases are semantic-release on push to `main` (conventional commits;
+`feat:`/`fix:` release). Publishing uses npm trusted publishing (OIDC) — no
+npm token exists in this repo.

package/dist/actions.d.ts

@@ -0,0 +1,47 @@
+import { type APIRequestContext, type Locator, type Page } from '@playwright/test';
+/**
+ * The promoted actions a limetype's card view configures - empty when the
+ * target configures none, throwing when the config cannot be read at all.
+ */
+export declare function getPromotedActions(request: APIRequestContext, limetype: string): Promise<unknown[]>;
+/**
+ * The component a form action configures for one of its fields, when the
+ * solution overrides the default input (e.g. a hierarchy picker instead
+ * of a plain relation picker).
+ */
+export declare function formFieldComponent(action: unknown, field: string): string | undefined;
+/** The literal string a standard-actions value config holds (constant or formula). */
+export declare function valueLiteral(value: unknown): string | undefined;
+/** The literal string an action writes to a field. A Jinja formula never equals a bare key. */
+export declare function writtenValue(action: unknown, field: string): string | undefined;
+/** The caption the action's button renders, en.po English when the label is a translation key. */
+export declare function buttonName(action: unknown): string;
+/**
+ * Clicks a promoted action, on the bar or behind its "+N" overflow menu.
+ *
+ * An overflowed item stays in the DOM at `opacity: 0`, which Playwright
+ * still counts as visible, so the path is decided by the item's reflected
+ * `is-visible` attribute instead. The overflow menu is portalled to the
+ * document body; the trigger's `aria-controls` names the portal container,
+ * scoping the menu-item lookup to the menu this bar opened.
+ */
+export declare function clickPromotedAction(page: Page, name: string): Promise<void>;
+/**
+ * Asserts the card offers no action with this caption, on the bar or behind
+ * its overflow.
+ *
+ * Waiting for the bar to hold any item at all comes first. An action bar
+ * rebuilds itself after a command runs, and an absence read off a bar that
+ * has not rendered yet is an absence of everything.
+ */
+export declare function expectPromotedActionGone(page: Page, name: string): Promise<void>;
+/** The dialog limepkg-standard-actions opens for an open-form action. */
+export declare function formDialog(page: Page): Locator;
+/**
+ * The dialog's confirm button - the one primary button in its footer.
+ * Located by shape rather than caption: the caption belongs to another
+ * package's catalog, which no spec can resolve.
+ */
+export declare function formDialogConfirm(page: Page): Locator;
+/** The dialog's cancel button: the footer button captioned Cancel. */
+export declare function formDialogCancel(page: Page): Locator;

package/dist/actions.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPromotedActions = getPromotedActions;
+exports.formFieldComponent = formFieldComponent;
+exports.valueLiteral = valueLiteral;
+exports.writtenValue = writtenValue;
+exports.buttonName = buttonName;
+exports.clickPromotedAction = clickPromotedAction;
+exports.expectPromotedActionGone = expectPromotedActionGone;
+exports.formDialog = formDialog;
+exports.formDialogConfirm = formDialogConfirm;
+exports.formDialogCancel = formDialogCancel;
+const test_1 = require("@playwright/test");
+const api_1 = require("./api");
+const translations_1 = require("./translations");
+/** A translation key ('helpdesk-park.quick_action.1d') as opposed to a
+ * caption typed straight into the config ('Close ticket'). */
+const TRANSLATION_KEY = /^\S+(\.\S+)+$/;
+/**
+ * The promoted actions a limetype's card view configures - empty when the
+ * target configures none, throwing when the config cannot be read at all.
+ */
+async function getPromotedActions(request, limetype) {
+    const configEnvelope = await (0, api_1.findConfig)(request, `webclient_views.${limetype}`);
+    const actions = (0, api_1.pick)(configEnvelope, 'config', 'general', 'promotedActions');
+    return Array.isArray(actions) ? actions : [];
+}
+/**
+ * The component a form action configures for one of its fields, when the
+ * solution overrides the default input (e.g. a hierarchy picker instead
+ * of a plain relation picker).
+ */
+function formFieldComponent(action, field) {
+    const name = (0, api_1.pick)(action, 'params', 'properties', field, 'options', 'component', 'name');
+    return typeof name === 'string' && name !== '' ? name : undefined;
+}
+/** The literal string a standard-actions value config holds (constant or formula). */
+function valueLiteral(value) {
+    const literal = (0, api_1.pick)(value, 'constant') ?? (0, api_1.pick)(value, 'formula');
+    return typeof literal === 'string' && literal !== '' ? literal : undefined;
+}
+/** The literal string an action writes to a field. A Jinja formula never equals a bare key. */
+function writtenValue(action, field) {
+    return valueLiteral((0, api_1.pick)(action, 'params', 'limeObject', field));
+}
+/** The caption the action's button renders, en.po English when the label is a translation key. */
+function buttonName(action) {
+    const label = (0, api_1.pick)(action, 'label');
+    if (typeof label !== 'string' || !label) {
+        throw new Error(`No caption derivable for action label ${JSON.stringify(label)}`);
+    }
+    return TRANSLATION_KEY.test(label) ? (0, translations_1.translation)(label) : label;
+}
+/**
+ * Clicks a promoted action, on the bar or behind its "+N" overflow menu.
+ *
+ * An overflowed item stays in the DOM at `opacity: 0`, which Playwright
+ * still counts as visible, so the path is decided by the item's reflected
+ * `is-visible` attribute instead. The overflow menu is portalled to the
+ * document body; the trigger's `aria-controls` names the portal container,
+ * scoping the menu-item lookup to the menu this bar opened.
+ */
+async function clickPromotedAction(page, name) {
+    const item = barItems(page)
+        .filter({ has: page.getByText(name, { exact: true }) })
+        .first();
+    await item.waitFor();
+    if ((await item.getAttribute('is-visible')) !== null) {
+        await item.getByRole('button', { name, exact: true }).click();
+        return;
+    }
+    const trigger = page.locator('limel-action-bar button[slot="trigger"]');
+    await trigger.click();
+    const menuId = await trigger.getAttribute('aria-controls');
+    if (!menuId) {
+        throw new Error('The overflow trigger names no menu (aria-controls)');
+    }
+    await page
+        .locator(`[id="${menuId}"]`)
+        .getByRole('menuitem', { name, exact: true })
+        .click();
+}
+/**
+ * Every action the bar holds, whether it shows one on the bar itself or
+ * hides it behind the "+N" overflow: `limel-action-bar` renders an item per
+ * action either way, and only dims the overflowed ones.
+ */
+function barItems(page) {
+    return page.locator('limel-action-bar limel-action-bar-item');
+}
+/**
+ * Asserts the card offers no action with this caption, on the bar or behind
+ * its overflow.
+ *
+ * Waiting for the bar to hold any item at all comes first. An action bar
+ * rebuilds itself after a command runs, and an absence read off a bar that
+ * has not rendered yet is an absence of everything.
+ */
+async function expectPromotedActionGone(page, name) {
+    await (0, test_1.expect)(barItems(page).first()).toBeAttached();
+    await (0, test_1.expect)(barItems(page).filter({ has: page.getByText(name, { exact: true }) })).toHaveCount(0);
+}
+/** The dialog limepkg-standard-actions opens for an open-form action. */
+function formDialog(page) {
+    return page.locator('lwc-limepkg-standard-actions-form-dialog');
+}
+/**
+ * The dialog's confirm button - the one primary button in its footer.
+ * Located by shape rather than caption: the caption belongs to another
+ * package's catalog, which no spec can resolve.
+ */
+function formDialogConfirm(page) {
+    return formDialog(page)
+        .locator('limel-button[slot="button"][primary]')
+        .getByRole('button');
+}
+/** The dialog's cancel button: the footer button captioned Cancel. */
+function formDialogCancel(page) {
+    return formDialog(page)
+        .locator('limel-button[slot="button"]')
+        .getByRole('button', { name: 'Cancel', exact: true });
+}

package/dist/api.d.ts

@@ -0,0 +1,81 @@
+import { APIRequestContext, APIResponse } from '@playwright/test';
+export interface LimeObject {
+    _id: number;
+    [key: string]: unknown;
+}
+export interface OptionValue {
+    key: string;
+    id: number;
+    text: string;
+}
+/**
+ * A path under the target's app root, carrying the deployment's API prefix
+ * (cloud environments serve the app from a named sub-path).
+ */
+export declare function targetUrl(path: string): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * Marks every record the harness seeds. Sweeps that remove data orphaned by
+ * crashed runs key on this exact string, so it is part of the contract.
+ */
+export declare const TEST_DATA_PREFIX = "[scenario-test]";
+/**
+ * The display name for a record a spec creates: prefixed so a human can
+ * tell test data from real data, timestamped so runs never collide.
+ */
+export declare function testDataName(specName: string): string;
+/** The value at a path of keys inside nested plain objects, else undefined. */
+export declare function pick(value: unknown, ...path: string[]): unknown;
+/** An option field's API value, validated. */
+export declare function optionValue(value: unknown): OptionValue;
+/**
+ * The stable key of an option field's API value (e.g. 'waiting_us'). Named
+ * accessors rather than reads off `optionValue`, because which of the three
+ * fields a spec uses matters: `key` is the contract a package ships, `text`
+ * is what a user sees, and `id` is a row number that differs between
+ * databases.
+ */
+export declare function optionKey(value: unknown): string;
+/** The display label of an option field's API value, in the session's locale. */
+export declare function optionText(value: unknown): string;
+/** Throws unless the response succeeded, quoting the body for diagnosis. */
+export declare function ensureOk(response: APIResponse, action: string): Promise<void>;
+export declare function createObject(request: APIRequestContext, limetype: string, data: Record<string, unknown>): Promise<LimeObject>;
+export declare function getObject(request: APIRequestContext, limetype: string, id: number): Promise<LimeObject>;
+/**
+ * The records in an api/v1 collection response, across the envelope shapes
+ * the API answers with (bare array/objects/_embedded). Records rather
+ * than limeobjects.
+ */
+export declare function collectionEntries(body: unknown): Record<string, unknown>[];
+/** The limeobjects among a collection response's records. */
+export declare function limeObjects(body: unknown): LimeObject[];
+/** The limeobjects a collection query answers with. */
+export declare function listObjects(request: APIRequestContext, limetype: string, params?: Record<string, string | number | boolean>): Promise<LimeObject[]>;
+/** Every record a collection query answers with, including id-less rows. */
+export declare function listEntries(request: APIRequestContext, limetype: string, params?: Record<string, string | number | boolean>): Promise<Record<string, unknown>[]>;
+export declare function updateObject(request: APIRequestContext, limetype: string, id: number, data: Record<string, unknown>): Promise<LimeObject>;
+/**
+ * Whether the limetype exists in the target, probed on the limetype
+ * metadata resource - false on 404. Other errors throw, so a broken
+ * environment cannot skip specs green.
+ */
+export declare function limetypeExists(request: APIRequestContext, limetype: string): Promise<boolean>;
+/**
+ * A config section's envelope, or undefined when the target configures none
+ * (404). Any other failure throws, so a spec cannot mistake a broken or
+ * unauthorized config read for an unconfigured environment.
+ */
+export declare function findConfig(request: APIRequestContext, configKey: string): Promise<Record<string, unknown> | undefined>;
+export declare function deleteObject(request: APIRequestContext, limetype: string, id: number): Promise<void>;
+/** Tracks created test objects and best-effort deletes them after the test. */
+export declare class Cleanup {
+    private request;
+    private items;
+    private disposers;
+    constructor(request: APIRequestContext);
+    track(limetype: string, id: number): void;
+    /** Registers a custom disposal (non-limeobject test data), run before tracked objects. */
+    defer(dispose: () => Promise<void>): void;
+    dispose(): Promise<void>;
+}

package/dist/api.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cleanup = exports.TEST_DATA_PREFIX = void 0;
+exports.targetUrl = targetUrl;
+exports.isRecord = isRecord;
+exports.testDataName = testDataName;
+exports.pick = pick;
+exports.optionValue = optionValue;
+exports.optionKey = optionKey;
+exports.optionText = optionText;
+exports.ensureOk = ensureOk;
+exports.createObject = createObject;
+exports.getObject = getObject;
+exports.collectionEntries = collectionEntries;
+exports.limeObjects = limeObjects;
+exports.listObjects = listObjects;
+exports.listEntries = listEntries;
+exports.updateObject = updateObject;
+exports.limetypeExists = limetypeExists;
+exports.findConfig = findConfig;
+exports.deleteObject = deleteObject;
+const config_1 = require("./config");
+const HTTP_NOT_FOUND = 404;
+/**
+ * A path under the target's app root, carrying the deployment's API prefix
+ * (cloud environments serve the app from a named sub-path).
+ */
+function targetUrl(path) {
+    return `${(0, config_1.apiPrefix)()}${path}`;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Marks every record the harness seeds. Sweeps that remove data orphaned by
+ * crashed runs key on this exact string, so it is part of the contract.
+ */
+exports.TEST_DATA_PREFIX = '[scenario-test]';
+/**
+ * The display name for a record a spec creates: prefixed so a human can
+ * tell test data from real data, timestamped so runs never collide.
+ */
+function testDataName(specName) {
+    return `${exports.TEST_DATA_PREFIX} - ${specName} ${Date.now()}`;
+}
+/** The value at a path of keys inside nested plain objects, else undefined. */
+function pick(value, ...path) {
+    let current = value;
+    for (const key of path) {
+        if (!isRecord(current)) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+/** An option field's API value, validated. */
+function optionValue(value) {
+    if (isRecord(value) &&
+        typeof value.id === 'number' &&
+        typeof value.key === 'string' &&
+        typeof value.text === 'string') {
+        return { id: value.id, key: value.key, text: value.text };
+    }
+    throw new Error(`Not an option value ({id, key, text}): ${JSON.stringify(value)}`);
+}
+/**
+ * The stable key of an option field's API value (e.g. 'waiting_us'). Named
+ * accessors rather than reads off `optionValue`, because which of the three
+ * fields a spec uses matters: `key` is the contract a package ships, `text`
+ * is what a user sees, and `id` is a row number that differs between
+ * databases.
+ */
+function optionKey(value) {
+    return optionValue(value).key;
+}
+/** The display label of an option field's API value, in the session's locale. */
+function optionText(value) {
+    return optionValue(value).text;
+}
+/** Throws unless the response succeeded, quoting the body for diagnosis. */
+async function ensureOk(response, action) {
+    if (!response.ok()) {
+        throw new Error(`Failed to ${action}: ${response.status()} ${(await response.text()).slice(0, 300)}`);
+    }
+}
+async function createObject(request, limetype, data) {
+    const response = await request.post(targetUrl(`api/v1/limeobject/${limetype}/`), { data });
+    await ensureOk(response, `create ${limetype}`);
+    return response.json();
+}
+async function getObject(request, limetype, id) {
+    const response = await request.get(targetUrl(`api/v1/limeobject/${limetype}/${id}/`));
+    await ensureOk(response, `get ${limetype}/${id}`);
+    return response.json();
+}
+/**
+ * The records in an api/v1 collection response, across the envelope shapes
+ * the API answers with (bare array/objects/_embedded). Records rather
+ * than limeobjects.
+ */
+function collectionEntries(body) {
+    const list = Array.isArray(body)
+        ? body
+        : (pick(body, 'objects') ??
+            pick(body, '_embedded', 'limeobjects') ??
+            pick(body, '_embedded', 'limeobject'));
+    if (!Array.isArray(list)) {
+        throw new Error(`Unexpected collection response: ${JSON.stringify(body).slice(0, 200)}`);
+    }
+    return list.filter(isRecord);
+}
+/** The limeobjects among a collection response's records. */
+function limeObjects(body) {
+    return collectionEntries(body).filter((entry) => typeof entry._id === 'number');
+}
+async function getCollection(request, limetype, params) {
+    const response = await request.get(targetUrl(`api/v1/limeobject/${limetype}/`), { params });
+    await ensureOk(response, `list ${limetype}`);
+    return response.json();
+}
+/** The limeobjects a collection query answers with. */
+async function listObjects(request, limetype, params = {}) {
+    return limeObjects(await getCollection(request, limetype, params));
+}
+/** Every record a collection query answers with, including id-less rows. */
+async function listEntries(request, limetype, params = {}) {
+    return collectionEntries(await getCollection(request, limetype, params));
+}
+async function updateObject(request, limetype, id, data) {
+    const response = await request.put(targetUrl(`api/v1/limeobject/${limetype}/${id}/`), { data });
+    await ensureOk(response, `update ${limetype}/${id}`);
+    return response.json();
+}
+/**
+ * Caches reads of what describes the target rather than its data (limetype
+ * metadata, admin config), otherwise re-fetched by every spec. Failures are
+ * never stored, and verification never writes config, so nothing goes stale.
+ */
+const targetFacts = new Map();
+async function targetFact(key, read) {
+    if (!targetFacts.has(key)) {
+        targetFacts.set(key, await read());
+    }
+    return targetFacts.get(key);
+}
+/**
+ * Whether the limetype exists in the target, probed on the limetype
+ * metadata resource - false on 404. Other errors throw, so a broken
+ * environment cannot skip specs green.
+ */
+async function limetypeExists(request, limetype) {
+    return targetFact(`limetype:${limetype}`, async () => {
+        const response = await request.get(targetUrl(`api/v1/limetype/${limetype}/`));
+        if (response.status() === HTTP_NOT_FOUND) {
+            return false;
+        }
+        await ensureOk(response, `probe limetype ${limetype}`);
+        return true;
+    });
+}
+/**
+ * A config section's envelope, or undefined when the target configures none
+ * (404). Any other failure throws, so a spec cannot mistake a broken or
+ * unauthorized config read for an unconfigured environment.
+ */
+async function findConfig(request, configKey) {
+    return targetFact(`config:${configKey}`, async () => {
+        const response = await request.get(targetUrl(`lime-admin/v2/config/${configKey}/`));
+        if (response.status() === HTTP_NOT_FOUND) {
+            return undefined;
+        }
+        await ensureOk(response, `get config ${configKey}`);
+        return response.json();
+    });
+}
+async function deleteObject(request, limetype, id) {
+    const response = await request.delete(targetUrl(`api/v1/limeobject/${limetype}/${id}/`));
+    await ensureOk(response, `delete ${limetype}/${id}`);
+}
+/** Tracks created test objects and best-effort deletes them after the test. */
+class Cleanup {
+    request;
+    items = [];
+    disposers = [];
+    constructor(request) {
+        this.request = request;
+    }
+    track(limetype, id) {
+        this.items.push({ limetype, id });
+    }
+    /** Registers a custom disposal (non-limeobject test data), run before tracked objects. */
+    defer(dispose) {
+        this.disposers.push(dispose);
+    }
+    async dispose() {
+        for (const dispose of this.disposers.reverse()) {
+            await bestEffort(dispose, 'a deferred disposal');
+        }
+        this.disposers = [];
+        for (const { limetype, id } of this.items.reverse()) {
+            await bestEffort(() => deleteObject(this.request, limetype, id), `${limetype}/${id}`);
+        }
+        this.items = [];
+    }
+}
+exports.Cleanup = Cleanup;
+/**
+ * Cleanup never fails a test - a teardown error would mask the result the
+ * run is about. It must not pass unnoticed either: verification targets are
+ * shared and persistent, so anything left behind accumulates there.
+ */
+async function bestEffort(dispose, what) {
+    try {
+        await dispose();
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        console.warn(`Cleanup left ${what} behind: ${detail}`);
+    }
+}

package/dist/auth.d.ts

@@ -0,0 +1,23 @@
+import { type Locator, type Page } from '@playwright/test';
+/**
+ * Sets an input's value via the DOM instead of fill(): the HTML report
+ * prints fill() arguments verbatim, and it is uploaded as a CI artifact
+ * that GitHub's log-only secret masking does not cover.
+ */
+export declare const setSilently: (locator: Locator, value: string) => Promise<void>;
+/**
+ * Logs the test user in through the form and saves the session to
+ * `authStatePath()` for every project to reuse via `storageState`.
+ *
+ * Call it from the runner's setup project with Playwright's *plain* `test`
+ * on purpose - the harness fault reporter must not interfere with the
+ * login flow:
+ *
+ *     import { test as setup } from '@playwright/test';
+ *     import { authenticate } from '@limetech/lime-scenario-harness';
+ *
+ *     setup('authenticate', async ({ page }) => {
+ *         await authenticate(page);
+ *     });
+ */
+export declare function authenticate(page: Page): Promise<void>;

package/dist/auth.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSilently = void 0;
+exports.authenticate = authenticate;
+const api_1 = require("./api");
+const config_1 = require("./config");
+/** The userdata key the webclient checks to decide on the first-login pop-up. */
+const PREFERENCES_KEY = 'webclient.user-preferences';
+/**
+ * Sets an input's value via the DOM instead of fill(): the HTML report
+ * prints fill() arguments verbatim, and it is uploaded as a CI artifact
+ * that GitHub's log-only secret masking does not cover.
+ */
+const setSilently = (locator, value) => locator.evaluate((el, v) => {
+    el.value = v;
+    el.dispatchEvent(new Event('input', { bubbles: true, composed: true }));
+    el.dispatchEvent(new Event('change', { bubbles: true }));
+}, value);
+exports.setSilently = setSilently;
+async function getJson(page, path) {
+    const response = await page.request.get((0, api_1.targetUrl)(path));
+    if (!response.ok()) {
+        throw new Error(`Failed to GET ${path}: ${response.status()}`);
+    }
+    return response.json();
+}
+/** The session's userdata entries, keyed as the webclient reads them. */
+async function userdata(page) {
+    const entries = await getJson(page, 'webclient/userdata/');
+    const byKey = new Map();
+    for (const entry of Array.isArray(entries) ? entries : []) {
+        const key = (0, api_1.pick)(entry, 'key');
+        if (typeof key === 'string') {
+            byKey.set(key, (0, api_1.pick)(entry, 'data'));
+        }
+    }
+    return byKey;
+}
+/**
+ * The suite asserts English captions (each package's en.po, platform
+ * buttons), so the session's effective webclient language must be English:
+ * the user's saved preference when it is among the active languages,
+ * otherwise the server default. Fails rather than skips - every project
+ * depends on this setup.
+ */
+async function requireEnglishSession(page, entries) {
+    const envelope = await getJson(page, 'lime-admin/v2/config/webclient/');
+    const fallback = (0, api_1.pick)(envelope, 'config', 'languages', 'language');
+    const active = (0, api_1.pick)(envelope, 'config', 'languages', 'languages');
+    const preferred = (0, api_1.pick)(entries.get(PREFERENCES_KEY), 'language');
+    const effective = typeof preferred === 'string' &&
+        preferred !== '' &&
+        Array.isArray(active) &&
+        active.includes(preferred)
+        ? preferred
+        : fallback;
+    if (typeof effective !== 'string' || !effective.startsWith('en')) {
+        throw new Error(`The webclient language for this session is ${JSON.stringify(effective)} - ` +
+            'the specs assert English captions, so set the test ' +
+            "user's language preference (or the solution default) to English");
+    }
+}
+/** The webclient opens the wizard when the user has no saved preferences.
+ * Its write-back on close is debounced; setup needs to await it else the write is lost.
+ */
+async function dismissFirstLoginWizard(page, entries) {
+    if (entries.get(PREFERENCES_KEY)) {
+        return;
+    }
+    const saved = page.waitForResponse((response) => response.url().includes(`webclient/userdata/${PREFERENCES_KEY}/`) &&
+        response.request().method() === 'POST');
+    await page.getByRole('button', { name: 'Save & close' }).click();
+    await saved;
+}
+/**
+ * Logs the test user in through the form and saves the session to
+ * `authStatePath()` for every project to reuse via `storageState`.
+ *
+ * Call it from the runner's setup project with Playwright's *plain* `test`
+ * on purpose - the harness fault reporter must not interfere with the
+ * login flow:
+ *
+ *     import { test as setup } from '@playwright/test';
+ *     import { authenticate } from '@limetech/lime-scenario-harness';
+ *
+ *     setup('authenticate', async ({ page }) => {
+ *         await authenticate(page);
+ *     });
+ */
+async function authenticate(page) {
+    const user = process.env.LIME_TEST_USER;
+    const password = process.env.LIME_TEST_PASSWORD;
+    if (!user || !password) {
+        throw new Error('LIME_TEST_USER and LIME_TEST_PASSWORD env vars are required (see README)');
+    }
+    await page.goto('client/login/');
+    await (0, exports.setSilently)(page.getByRole('textbox', { name: 'Username' }), user);
+    await (0, exports.setSilently)(page.getByRole('textbox', { name: 'Password' }), password);
+    await page.getByRole('button', { name: /sign in|log in/i }).click();
+    await page
+        .waitForURL((url) => !url.pathname.includes('/login'))
+        .catch(() => {
+        throw new Error('Login did not leave /login - check LIME_TEST_USER/LIME_TEST_PASSWORD');
+    });
+    const entries = await userdata(page);
+    await requireEnglishSession(page, entries);
+    await dismissFirstLoginWizard(page, entries);
+    await page.context().storageState({ path: (0, config_1.authStatePath)() });
+}

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolved per call rather than at module load: the harness lives in
+ * node_modules, so nothing about the runner's layout can be baked in at
+ * import time, and a runner may set the variables after importing.
+ */
+/** API path prefix under the target's app root (cloud deployments serve the app from a named sub-path). */
+export declare function apiPrefix(): string;
+/**
+ * Where the runner staged each discovered package's files, one directory
+ * per Playwright project name, plus versions.json.
+ */
+export declare function stageDir(): string;
+/**
+ * Saved login session (cookie), written by `authenticate` and read by every
+ * project via `storageState`. Keep it out of version control.
+ */
+export declare function authStatePath(): string;

package/dist/config.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiPrefix = apiPrefix;
+exports.stageDir = stageDir;
+exports.authStatePath = authStatePath;
+const path_1 = __importDefault(require("path"));
+/**
+ * Resolved per call rather than at module load: the harness lives in
+ * node_modules, so nothing about the runner's layout can be baked in at
+ * import time, and a runner may set the variables after importing.
+ */
+/** API path prefix under the target's app root (cloud deployments serve the app from a named sub-path). */
+function apiPrefix() {
+    return process.env.LIME_API_PREFIX ?? '';
+}
+/**
+ * Where the runner staged each discovered package's files, one directory
+ * per Playwright project name, plus versions.json.
+ */
+function stageDir() {
+    return (process.env.LIME_SCENARIO_STAGE_DIR ??
+        path_1.default.resolve(process.cwd(), '.discovered'));
+}
+/**
+ * Saved login session (cookie), written by `authenticate` and read by every
+ * project via `storageState`. Keep it out of version control.
+ */
+function authStatePath() {
+    return (process.env.LIME_SCENARIO_AUTH_STATE ??
+        path_1.default.resolve(process.cwd(), '.auth', 'state.json'));
+}

package/dist/fixtures.d.ts

@@ -0,0 +1,25 @@
+import { type APIRequestContext, type BrowserContext, type Page } from '@playwright/test';
+import { Cleanup } from './api';
+/** How long a readback waits for a write the action under test triggered */
+export declare const WRITE_SETTLE_MS = 15000;
+interface Fixtures {
+    reportErrors: void;
+    cleanup: Cleanup;
+}
+interface WorkerFixtures {
+    sharedContext: BrowserContext;
+}
+/** Playwright's `test` with the fault reporter and `cleanup` fixtures (see README). */
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & Fixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions & WorkerFixtures>;
+/**
+ * Declares what the spec needs from the target environment: the limetype
+ * it drives, the config it asserts against, the wiring that produces the
+ * effect. Unmet requirements fail by default - a silent skip would read
+ * as a pass; `PW_ALLOW_SKIPS=1` demotes them to skips (see README).
+ */
+export declare function requireEnvironment(provided: boolean, reason: string): asserts provided;
+/** Reads a config section and requires the target to have it, in one step. */
+export declare function requireConfig(request: APIRequestContext, configKey: string): Promise<Record<string, unknown>>;
+/** Attaches a named screenshot to the test report as verification evidence. */
+export declare function checkpoint(page: Page, name: string): Promise<void>;
+export {};

package/dist/fixtures.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = exports.WRITE_SETTLE_MS = void 0;
+exports.requireEnvironment = requireEnvironment;
+exports.requireConfig = requireConfig;
+exports.checkpoint = checkpoint;
+const test_1 = require("@playwright/test");
+const api_1 = require("./api");
+/**
+ * Read per call, not at module load: a consumer's playwright.config may
+ * import the harness before it runs dotenv, and this module loads with the
+ * barrel import.
+ */
+const allowSkips = () => process.env.PW_ALLOW_SKIPS === '1';
+const HTTP_CLIENT_ERROR = 400;
+/** How long a readback waits for a write the action under test triggered */
+exports.WRITE_SETTLE_MS = 15_000;
+/** Any host the Intercom widget loads itself and its content from. */
+const INTERCOM_HOST = /(^|\.)(intercom\.io|intercomcdn\.com|intercomassets\.com)/;
+/**
+ * Answers every Intercom request with no content, so the widget never boots.
+ * Left to load, it drops survey banners/discoverability over the UI at times.
+ * The banner's iframe swallows pointer events and times out
+ * whichever spec happens to be running.
+ */
+async function blockIntercom(context) {
+    await context.route((url) => INTERCOM_HOST.test(url.hostname), (route) => route.fulfill({ status: 204, body: '' }));
+}
+/** Playwright's `test` with the fault reporter and `cleanup` fixtures (see README). */
+exports.test = test_1.test.extend({
+    /**
+     * One browser context per worker rather than one per test: a fresh
+     * context starts with an empty HTTP cache and re-downloads the
+     * webclient and every package bundle against a cloud target.
+     * Pages stay per test; cookies and localStorage outlive a test (see README).
+     * `use` mixes context options with runner-level settings `newContext`
+     * rejects; those are stripped and the rest forwarded.
+     */
+    sharedContext: [
+        async ({ browser }, use, workerInfo) => {
+            const { trace, screenshot, launchOptions, defaultBrowserType, ...contextOptions } = workerInfo.project.use;
+            const context = await browser.newContext(contextOptions);
+            await blockIntercom(context);
+            await use(context);
+            await context.close();
+        },
+        { scope: 'worker' },
+    ],
+    page: async ({ sharedContext }, use) => {
+        const page = await sharedContext.newPage();
+        await use(page);
+        await page.close();
+    },
+    reportErrors: [
+        async ({ page }, use) => {
+            const faults = [];
+            const note = (message) => {
+                faults.push(message);
+                console.warn(message);
+            };
+            page.on('response', (response) => {
+                if (response.status() >= HTTP_CLIENT_ERROR) {
+                    note(`${response.url()} responded with ${response.status()}`);
+                }
+            });
+            page.on('pageerror', (error) => {
+                note(`page error: ${error.message}`);
+            });
+            page.on('console', (message) => {
+                if (message.type() === 'error') {
+                    note(`console error: ${message.text()} (${message.location().url})`);
+                }
+            });
+            await use();
+            if (faults.length > 0) {
+                await exports.test.info().attach(`${faults.length} browser fault(s)`, {
+                    body: faults.join('\n'),
+                    contentType: 'text/plain',
+                });
+            }
+        },
+        { auto: true },
+    ],
+    cleanup: async ({ request }, use) => {
+        const cleanup = new api_1.Cleanup(request);
+        await use(cleanup);
+        await cleanup.dispose();
+    },
+});
+/**
+ * Declares what the spec needs from the target environment: the limetype
+ * it drives, the config it asserts against, the wiring that produces the
+ * effect. Unmet requirements fail by default - a silent skip would read
+ * as a pass; `PW_ALLOW_SKIPS=1` demotes them to skips (see README).
+ */
+function requireEnvironment(provided, reason) {
+    if (provided) {
+        return;
+    }
+    if (allowSkips()) {
+        exports.test.skip(true, reason);
+        return;
+    }
+    throw new Error(`Environment not ready for this spec: ${reason}`);
+}
+/** Reads a config section and requires the target to have it, in one step. */
+async function requireConfig(request, configKey) {
+    const config = await (0, api_1.findConfig)(request, configKey);
+    requireEnvironment(config !== undefined, `the ${configKey} config is not set up in this environment`);
+    return config;
+}
+/** Attaches a named screenshot to the test report as verification evidence. */
+async function checkpoint(page, name) {
+    await exports.test.info().attach(name, {
+        body: await page.screenshot(),
+        contentType: 'image/png',
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { expect } from '@playwright/test';
+export * from './actions';
+export * from './api';
+export * from './auth';
+export * from './config';
+export * from './fixtures';
+export * from './translations';
+export * from './versions';

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expect = void 0;
+var test_1 = require("@playwright/test");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return test_1.expect; } });
+__exportStar(require("./actions"), exports);
+__exportStar(require("./api"), exports);
+__exportStar(require("./auth"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./fixtures"), exports);
+__exportStar(require("./translations"), exports);
+__exportStar(require("./versions"), exports);

package/dist/translations.d.ts

@@ -0,0 +1,17 @@
+/**
+ * msgid-msgstr pairs in a po catalog. Only single-line entries are parsed,
+ * which covers every message a package ships today; the multi-line form
+ * appears only in the catalog header, which carries no caption.
+ */
+export declare function parsePoCaptions(catalog: string): Map<string, string>;
+/**
+ * The caption a catalog holds for a translation key. Catalogs hold msgids
+ * unprefixed while a config carries them prefixed with the package's
+ * library name, so a key that misses is looked up again without its
+ * leading segment - which needs no assumption about how that name relates
+ * to the package's distribution name. Throws on unknown keys so a caption
+ * lookup can never silently target the wrong element.
+ */
+export declare function resolveCaption(captions: Map<string, string>, key: string): string;
+/** The English caption the running spec's package ships for a translation key. */
+export declare function translation(key: string): string;

package/dist/translations.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePoCaptions = parsePoCaptions;
+exports.resolveCaption = resolveCaption;
+exports.translation = translation;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+const fixtures_1 = require("./fixtures");
+const captionsByDir = new Map();
+/**
+ * The running spec's staged package directory (where the runner's discovery
+ * put its files). Taken from the project rather than the spec's own path,
+ * which would resolve to a subfolder for a package that groups its specs.
+ */
+function packageDir() {
+    return path_1.default.resolve((0, config_1.stageDir)(), fixtures_1.test.info().project.name);
+}
+/** Resolves the po escape sequences for quote and backslash. */
+const unescapePo = (value) => value.replace(/\\(["\\])/g, '$1');
+/**
+ * One msgid "..." line directly followed by its msgstr "..." line, with
+ * either line ending: a catalog read from a Windows checkout is CRLF, and
+ * `.` never matches the `\r`.
+ */
+const SINGLE_LINE_ENTRY = /^msgid "(.+)"\r?\nmsgstr "(.+)"\r?$/gm;
+/**
+ * msgid-msgstr pairs in a po catalog. Only single-line entries are parsed,
+ * which covers every message a package ships today; the multi-line form
+ * appears only in the catalog header, which carries no caption.
+ */
+function parsePoCaptions(catalog) {
+    const captions = new Map();
+    for (const [, msgid, msgstr] of catalog.matchAll(SINGLE_LINE_ENTRY)) {
+        captions.set(unescapePo(msgid), unescapePo(msgstr));
+    }
+    return captions;
+}
+function enPoCaptions(dir) {
+    let captions = captionsByDir.get(dir);
+    if (!captions) {
+        captions = parsePoCaptions(fs_1.default.readFileSync(path_1.default.join(dir, 'translations', 'en.po'), 'utf-8'));
+        captionsByDir.set(dir, captions);
+    }
+    return captions;
+}
+/**
+ * The caption a catalog holds for a translation key. Catalogs hold msgids
+ * unprefixed while a config carries them prefixed with the package's
+ * library name, so a key that misses is looked up again without its
+ * leading segment - which needs no assumption about how that name relates
+ * to the package's distribution name. Throws on unknown keys so a caption
+ * lookup can never silently target the wrong element.
+ */
+function resolveCaption(captions, key) {
+    const unprefixed = key.slice(key.indexOf('.') + 1);
+    const caption = captions.get(key) ?? captions.get(unprefixed);
+    if (!caption) {
+        throw new Error(`No en.po entry for ${key} (single-line entries only)`);
+    }
+    return caption;
+}
+/** The English caption the running spec's package ships for a translation key. */
+function translation(key) {
+    return resolveCaption(enPoCaptions(packageDir()), key);
+}

package/dist/versions.d.ts

@@ -0,0 +1,23 @@
+import { type Page } from '@playwright/test';
+/** The package frontend version the webclient loaded, if it loaded one. */
+export declare function loadedFrontendVersion(page: Page, packageName: string): Promise<string | undefined>;
+/**
+ * Whether two versions name the same release across the dialects in play:
+ * a wheel carries the PEP 440 form (`1.4.0b2`), a release tag the semver
+ * one (`v1.4.0-beta.2`).
+ */
+export declare function sameVersion(one: string, other: string): boolean;
+/**
+ * A warning message when the environment runs another version than the
+ * specs were staged from - undefined when they match, either version is
+ * unknown, or the specs were staged from a repo checkout.
+ */
+export declare function versionSkew(packageName: string, loadedVersion: string | undefined): string | undefined;
+/**
+ * Asserts the webclient loaded the package's own frontend bundle, and
+ * records which version it was. Skew against the version the specs were
+ * staged from is a warning, not a failure: nothing guarantees the
+ * checkout's lock and the deployed environment agree, and saying so is
+ * more useful than refusing to verify.
+ */
+export declare function expectFrontendLoaded(page: Page, packageName: string): Promise<void>;

package/dist/versions.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadedFrontendVersion = loadedFrontendVersion;
+exports.sameVersion = sameVersion;
+exports.versionSkew = versionSkew;
+exports.expectFrontendLoaded = expectFrontendLoaded;
+const test_1 = require("@playwright/test");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+const fixtures_1 = require("./fixtures");
+const versionsManifest = () => path_1.default.resolve((0, config_1.stageDir)(), 'versions.json');
+/** The package frontend version the webclient loaded, if it loaded one. */
+async function loadedFrontendVersion(page, packageName) {
+    const libName = packageName.replace(/-/g, '_');
+    return page.evaluate(({ packageName, libName }) => {
+        // …/<package-name>/<version>/dist/… (cloud CDN bundle)
+        const cdnBundle = new RegExp(`${packageName}/([^/]+)/dist/`);
+        // …/<lib_name>/lwc-package-<version>/… (locally served bundle)
+        const localBundle = new RegExp(`${libName}/lwc-[a-z]+-([^/]+)/`);
+        for (const entry of performance.getEntriesByType('resource')) {
+            const version = entry.name.match(cdnBundle)?.[1] ??
+                entry.name.match(localBundle)?.[1];
+            if (version) {
+                return version;
+            }
+        }
+        return undefined;
+    }, { packageName, libName });
+}
+function stagedVersion(packageName) {
+    const manifest = versionsManifest();
+    if (!fs_1.default.existsSync(manifest)) {
+        return undefined;
+    }
+    const staged = JSON.parse(fs_1.default.readFileSync(manifest, 'utf-8'));
+    return staged[packageName];
+}
+/** Normalizes the PEP 440 (1.4.0b1) and release-tag (1.4.0-beta.1) dialects to one form. */
+const normalize = (version) => version
+    .toLowerCase()
+    .replace('-alpha.', 'a')
+    .replace('-beta.', 'b')
+    .replace('-rc.', 'rc')
+    .replace('-dev.', '.dev');
+/**
+ * Whether two versions name the same release across the dialects in play:
+ * a wheel carries the PEP 440 form (`1.4.0b2`), a release tag the semver
+ * one (`v1.4.0-beta.2`).
+ */
+function sameVersion(one, other) {
+    return normalize(one) === normalize(other);
+}
+/**
+ * A warning message when the environment runs another version than the
+ * specs were staged from - undefined when they match, either version is
+ * unknown, or the specs were staged from a repo checkout.
+ */
+function versionSkew(packageName, loadedVersion) {
+    const staged = stagedVersion(packageName);
+    if (!staged ||
+        !loadedVersion ||
+        staged === 'local' ||
+        sameVersion(staged, loadedVersion)) {
+        return undefined;
+    }
+    return `Version skew: specs staged from ${packageName} ${staged}, environment runs ${loadedVersion}`;
+}
+/**
+ * Asserts the webclient loaded the package's own frontend bundle, and
+ * records which version it was. Skew against the version the specs were
+ * staged from is a warning, not a failure: nothing guarantees the
+ * checkout's lock and the deployed environment agree, and saying so is
+ * more useful than refusing to verify.
+ */
+async function expectFrontendLoaded(page, packageName) {
+    await test_1.expect
+        .poll(() => loadedFrontendVersion(page, packageName), {
+        message: `The webclient never loaded the ${packageName} frontend - is the package installed?`,
+    })
+        .toBeDefined();
+    const loaded = await loadedFrontendVersion(page, packageName);
+    fixtures_1.test.info().annotations.push({
+        type: 'loaded-version',
+        description: `${packageName} ${loaded}`,
+    });
+    const skew = versionSkew(packageName, loaded);
+    if (skew) {
+        console.warn(skew);
+        fixtures_1.test.info().annotations.push({
+            type: 'version-skew',
+            description: skew,
+        });
+    }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@limetech/lime-scenario-harness",
+  "version": "0.0.0-development",
+  "description": "Standard library for Lime CRM scenario tests: login, API seeding, tracked cleanup, translation assertions, evidence screenshots.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lundalogik/lime-scenario-harness.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "test": "playwright test",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.48.0 <2"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.58.0",
+    "@types/node": "^24.0.0",
+    "prettier": "^3.9.6",
+    "typescript": "^5.9.0"
+  }
+}