@harnessed-ts/gherkin 0.0.0-stage → 0.7.0

package/CHANGELOG.md

@@ -0,0 +1,53 @@
+# @harnessed-ts/gherkin
+
+## 0.7.0
+
+### Minor Changes
+
+- ec06bdf: Vue, Solid, Svelte and Angular join React and Ember as conformance-tested UI frameworks, and node:test, Bun and Nightwatch join the runners.
+
+  New packages: `@harnessed-ts/nightwatch` drives Nightwatch 3 through the injected resolver, under Nightwatch's own runner and its Mocha runner, in end-to-end and component tests (`@nightwatch/react`, `@nightwatch/vue`), with cross-origin frames. `@harnessed-ts/angular` drives zoneless Angular 21+: every action settles at `fixture.whenStable()`, or at the `ApplicationRef`'s for an app bootstrapped without TestBed, and `goto()` drives a provided router.
+
+  `@harnessed-ts/core/register` loads TypeScript harnesses under `node --import`: esbuild strips the types, lowers standard decorators and `accessor`, and compiles JSX. `@harnessed-ts/core/bun` does the same as a `bun test` preload, so harnesses keep the standard decorator protocol whatever `experimentalDecorators` the tsconfig sets.
+
+  `@harnessed-ts/dom/matchers/bun` registers the matchers with `bun:test`. The dom driver runs on happy-dom too: it focuses the frames leading to an interaction's target, finds a frame's `<iframe>` where `frameElement` is unset, and reads a select's selection off `options`.
+
+  `@harnessed-ts/resolve/webdriver` holds the WebDriver half of injected resolution, shared by the WebdriverIO and Nightwatch drivers. `@harnessed-ts/gherkin/nightwatch` adapts the cucumber-js world to Nightwatch's Cucumber runner.
+
+  `@harnessed-ts/playwright`, and `@harnessed-ts/cypress` under `realEvents`, give the page a task after every action, so a read straight after it sees what a framework that renders on a timer (zoneless Angular) has rendered. The injectable resolver installs on the page's `window` rather than the script's global, which under Firefox's WebDriver is a sandbox in front of it.
+
+  `@harnessed-ts/conformance` exports `fixtureParity()`, the per-view parity check a port of the fixture to another framework runs, naming the first place its markup parts from the React original; it detects a simulated DOM from the DOM's own window.
+
+  `@harnessed-ts/eslint-plugin` recognises Nightwatch's, Angular's and Vue Test Utils' raw queries, and looks in `nightwatch/` by default. `npx @harnessed-ts/claude install` detects Angular, Nightwatch, node:test and Bun.
+
+### Patch Changes
+
+- Updated dependencies [ec06bdf]
+  - @harnessed-ts/core@0.7.0
+  - @harnessed-ts/nightwatch@0.7.0
+
+## 0.6.0
+
+### Patch Changes
+
+- Updated dependencies [e324e94]
+  - @harnessed-ts/core@0.6.0
+
+## 0.5.0
+
+### Patch Changes
+
+- @harnessed-ts/core@0.5.0
+
+## 0.4.0
+
+### Minor Changes
+
+- 9666a3d: New `@harnessed-ts/gherkin`: a scenario-scoped world, a typed page registry (`definePages`) and a `{page}` parameter type (`pageParameter`) that rejects an unknown page name at step matching, with adapters for playwright-bdd (`/playwright-bdd`, `withWorld`), cucumber-js (`/cucumber`, `HarnessedWorld`), @badeball/cypress-cucumber-preprocessor (`/cypress`, `cypressWorld`) and ember-cli-yadda or plain Yadda (`/yadda`, `yaddaWorld`, with a `$page` term from `pageDictionary`). `@harnessed-ts/playwright/bdd` re-exports `withWorld` from it, deprecated for one release.
+
+### Patch Changes
+
+- Updated dependencies [9666a3d]
+- Updated dependencies [9666a3d]
+- Updated dependencies [1823546]
+  - @harnessed-ts/core@0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joe Gaudet, Jay Seo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,28 @@
-# Temporary Holding Version
+# @harnessed-ts/gherkin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Gherkin support for [harnessed](https://github.com/joegaudet/harnessed#readme)
+harnesses: a scenario-scoped world for the pages a scenario builds up, a typed
+page registry, and a `{page}` parameter type that matches only registered
+names, so a typo in a feature fails at step matching.
+
+```ts
+import { definePages, pageParameter } from '@harnessed-ts/gherkin'
+
+export const pages = definePages({ checkout: CheckoutPage })
+defineParameterType(pageParameter(pages)) // the runner's own defineParameterType
+```
+
+One adapter per runner gives the world a scenario's lifetime:
+
+| Import                                 | Runner                                  | Gives you                         |
+| -------------------------------------- | --------------------------------------- | --------------------------------- |
+| `@harnessed-ts/gherkin/playwright-bdd` | playwright-bdd                          | `withWorld`, a `world` fixture    |
+| `@harnessed-ts/gherkin/cucumber`       | cucumber-js                             | `HarnessedWorld`                  |
+| `@harnessed-ts/gherkin/nightwatch`     | Nightwatch's Cucumber runner            | `HarnessedWorld`, `nightwatchEnv` |
+| `@harnessed-ts/gherkin/cypress`        | @badeball/cypress-cucumber-preprocessor | `cypressWorld`                    |
+| `@harnessed-ts/gherkin/yadda`          | ember-cli-yadda                         | `yaddaWorld`, `pageDictionary`    |
+
+Each runner is an optional peer dependency; install the one you use. Setup for
+each, with examples: [Using with Gherkin](https://github.com/joegaudet/harnessed#using-with-gherkin).
+
+MIT © Joe Gaudet, Jay Seo

package/dist/chunk-6AIO5EWN.js

@@ -0,0 +1,40 @@
+// src/index.ts
+function definePages(pages) {
+  const names = Object.keys(pages).sort((a, b) => b.length - a.length);
+  if (names.length === 0) {
+    throw new Error("harnessed: definePages() needs at least one page.");
+  }
+  const has = (name) => Object.prototype.hasOwnProperty.call(pages, name);
+  return {
+    names,
+    has,
+    open(name, env) {
+      if (!has(name)) {
+        throw new Error(`harnessed: no page named "${name}". Registered: ${names.join(", ")}.`);
+      }
+      const Page = pages[name];
+      return new Page(env);
+    }
+  };
+}
+function escape(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function pageParameter(registry, options = {}) {
+  return {
+    name: options.name ?? "page",
+    regexp: new RegExp(registry.names.map(escape).join("|")),
+    transformer: (match) => {
+      if (!registry.has(match)) throw new Error(`harnessed: no page named "${match}".`);
+      return match;
+    },
+    useForSnippets: false
+  };
+}
+function createWorld() {
+  return {};
+}
+
+export { createWorld, definePages, pageParameter };
+//# sourceMappingURL=chunk-6AIO5EWN.js.map
+//# sourceMappingURL=chunk-6AIO5EWN.js.map

package/dist/chunk-6AIO5EWN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";AAkCO,SAAS,YAA+B,KAAA,EAA2B;AACxE,EAAA,MAAM,KAAA,GAAS,MAAA,CAAO,IAAA,CAAK,KAAK,CAAA,CAA8B,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,CAAE,MAAA,GAAS,CAAA,CAAE,MAAM,CAAA;AAChG,EAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AAGtB,IAAA,MAAM,IAAI,MAAM,mDAAmD,CAAA;AAAA,EACrE;AACA,EAAA,MAAM,GAAA,GAAM,CAAC,IAAA,KACX,MAAA,CAAO,UAAU,cAAA,CAAe,IAAA,CAAK,OAAO,IAAI,CAAA;AAClD,EAAA,OAAO;AAAA,IACL,KAAA;AAAA,IACA,GAAA;AAAA,IACA,IAAA,CAAK,MAAM,GAAA,EAAK;AAEd,MAAA,IAAI,CAAC,GAAA,CAAI,IAAI,CAAA,EAAG;AACd,QAAA,MAAM,IAAI,MAAM,CAAA,0BAAA,EAA6B,IAAI,kBAAkB,KAAA,CAAM,IAAA,CAAK,IAAI,CAAC,CAAA,CAAA,CAAG,CAAA;AAAA,MACxF;AACA,MAAA,MAAM,IAAA,GAAO,MAAM,IAAI,CAAA;AACvB,MAAA,OAAO,IAAI,KAAK,GAAG,CAAA;AAAA,IACrB;AAAA,GACF;AACF;AAcA,SAAS,OAAO,IAAA,EAAsB;AACpC,EAAA,OAAO,IAAA,CAAK,OAAA,CAAQ,qBAAA,EAAuB,MAAM,CAAA;AACnD;AAYO,SAAS,aAAA,CACd,QAAA,EACA,OAAA,GAA6B,EAAC,EACa;AAC3C,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,QAAQ,IAAA,IAAQ,MAAA;AAAA,IACtB,MAAA,EAAQ,IAAI,MAAA,CAAO,QAAA,CAAS,KAAA,CAAM,IAAI,MAAM,CAAA,CAAE,IAAA,CAAK,GAAG,CAAC,CAAA;AAAA,IACvD,aAAa,CAAA,KAAA,KAAS;AAGpB,MAAA,IAAI,CAAC,QAAA,CAAS,GAAA,CAAI,KAAK,CAAA,QAAS,IAAI,KAAA,CAAM,CAAA,0BAAA,EAA6B,KAAK,CAAA,EAAA,CAAI,CAAA;AAChF,MAAA,OAAO,KAAA;AAAA,IACT,CAAA;AAAA,IACA,cAAA,EAAgB;AAAA,GAClB;AACF;AAMO,SAAS,WAAA,GAA6B;AAC3C,EAAA,OAAO,EAAC;AACV","file":"chunk-6AIO5EWN.js","sourcesContent":["import type { EnvConfig } from '@harnessed-ts/core'\n\n/**\n * Gherkin support for harnessed: what every runner needs, with no runner in it.\n *\n * - A **world** — the scenario-scoped bag where steps keep the pages a scenario\n *   builds up. Steps are separate functions, so the obvious place for a harness\n *   is a module-level `let`, which leaks into the next scenario the moment a\n *   runner reuses a worker. Each runner adapter gives the bag the right lifetime.\n * - A **page registry** — the pages a feature can name, so a step reads\n *   `Given I open the checkout page` and gets a `CheckoutPage`, typed.\n * - A **`{page}` parameter type** built from the registry, so a feature naming\n *   an unknown page fails at step matching, where the typo is, rather than deep\n *   inside a step.\n *\n * Step bodies stay hand-written: the feature's wording is the team's, not a\n * mirror of method names.\n */\n\n/** Anything a page registry can construct: a page or component harness class. */\nexport type PageConstructor<T = object> = new (env: EnvConfig) => T\n\nexport type PageMap = Record<string, PageConstructor>\n\n/** The pages a feature can name. */\nexport interface PageRegistry<P extends PageMap> {\n  /** Every registered name, longest first — the order a matcher must try them. */\n  readonly names: ReadonlyArray<keyof P & string>\n  /** Whether `name` is registered: narrows a string from a step to a page name. */\n  has(name: string): name is keyof P & string\n  /** Constructs the named page with the scenario's env. */\n  open<N extends keyof P & string>(name: N, env: EnvConfig): InstanceType<P[N]>\n}\n\nexport function definePages<P extends PageMap>(pages: P): PageRegistry<P> {\n  const names = (Object.keys(pages) as Array<keyof P & string>).sort((a, b) => b.length - a.length)\n  if (names.length === 0) {\n    // `{page}` is an alternation of the names; with none it is the empty\n    // pattern, which matches anywhere and would let any step through.\n    throw new Error('harnessed: definePages() needs at least one page.')\n  }\n  const has = (name: string): name is keyof P & string =>\n    Object.prototype.hasOwnProperty.call(pages, name)\n  return {\n    names,\n    has,\n    open(name, env) {\n      // Own names only: `constructor` and the rest of Object.prototype are not pages.\n      if (!has(name)) {\n        throw new Error(`harnessed: no page named \"${name}\". Registered: ${names.join(', ')}.`)\n      }\n      const Page = pages[name]\n      return new Page(env) as InstanceType<P[typeof name]>\n    },\n  }\n}\n\n/**\n * A cucumber-expression parameter type, in the shape every runner's\n * `defineParameterType` takes: @cucumber/cucumber, playwright-bdd and\n * @badeball/cypress-cucumber-preprocessor alike.\n */\nexport interface ParameterTypeDefinition<T> {\n  name: string\n  regexp: RegExp\n  transformer: (match: string) => T\n  useForSnippets?: boolean\n}\n\nfunction escape(text: string): string {\n  return text.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/**\n * `{page}` for step patterns: matches exactly the registered names (longest\n * first, so `checkout summary` wins over `checkout`) and hands the step the\n * name, typed. Name it something else with `{ name }`.\n *\n * ```ts\n * defineParameterType(pageParameter(pages))\n * Given('I open the {page} page', async function (name) { … pages.open(name, env) })\n * ```\n */\nexport function pageParameter<P extends PageMap>(\n  registry: PageRegistry<P>,\n  options: { name?: string } = {},\n): ParameterTypeDefinition<keyof P & string> {\n  return {\n    name: options.name ?? 'page',\n    regexp: new RegExp(registry.names.map(escape).join('|')),\n    transformer: match => {\n      // The regexp only admits registered names, so this cannot fail; it is\n      // here so a hand-built pattern that bypasses it still gets a clear error.\n      if (!registry.has(match)) throw new Error(`harnessed: no page named \"${match}\".`)\n      return match\n    },\n    useForSnippets: false,\n  }\n}\n\n/**\n * A fresh, empty world. Adapters call this once per scenario; it exists so the\n * bag's type is written once, where the steps declare it.\n */\nexport function createWorld<W>(): Partial<W> {\n  return {}\n}\n"]}

package/dist/chunk-MMY7SRBU.js

@@ -0,0 +1,28 @@
+import { createWorld } from './chunk-6AIO5EWN.js';
+import { World } from '@cucumber/cucumber';
+
+var HarnessedWorld = class extends World {
+  /** The scenario's bag. Starts empty; cucumber builds a new world per scenario. */
+  bag = createWorld();
+  /** The env every harness in the scenario is built with. Set it in a `Before`. */
+  env;
+  /** The pages features can name. Assign the registry in a subclass. */
+  pages;
+  constructor(options) {
+    super(options);
+  }
+  /** Constructs a registered page with the scenario's env. */
+  open(name) {
+    if (this.pages === void 0) {
+      throw new Error("harnessed: this world has no page registry. Assign `pages` in a subclass.");
+    }
+    if (this.env === void 0) {
+      throw new Error("harnessed: this world has no env yet. Set `this.env` in a Before hook.");
+    }
+    return this.pages.open(name, this.env);
+  }
+};
+
+export { HarnessedWorld };
+//# sourceMappingURL=chunk-MMY7SRBU.js.map
+//# sourceMappingURL=chunk-MMY7SRBU.js.map

package/dist/chunk-MMY7SRBU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cucumber.ts"],"names":[],"mappings":";;;AAkCO,IAAM,cAAA,GAAN,cAGG,KAAA,CAAM;AAAA;AAAA,EAEd,MAAkB,WAAA,EAAe;AAAA;AAAA,EAEjC,GAAA;AAAA;AAAA,EAEA,KAAA;AAAA,EAEA,YAAY,OAAA,EAAwB;AAClC,IAAA,KAAA,CAAM,OAAO,CAAA;AAAA,EACf;AAAA;AAAA,EAGA,KAAiC,IAAA,EAA6B;AAC5D,IAAA,IAAI,IAAA,CAAK,UAAU,MAAA,EAAW;AAC5B,MAAA,MAAM,IAAI,MAAM,2EAA2E,CAAA;AAAA,IAC7F;AACA,IAAA,IAAI,IAAA,CAAK,QAAQ,MAAA,EAAW;AAC1B,MAAA,MAAM,IAAI,MAAM,wEAAwE,CAAA;AAAA,IAC1F;AACA,IAAA,OAAO,IAAA,CAAK,KAAA,CAAM,IAAA,CAAK,IAAA,EAAM,KAAK,GAAG,CAAA;AAAA,EACvC;AACF","file":"chunk-MMY7SRBU.js","sourcesContent":["import { World } from '@cucumber/cucumber'\nimport type { IWorldOptions } from '@cucumber/cucumber'\nimport type { EnvConfig } from '@harnessed-ts/core'\nimport { createWorld } from './index'\nimport type { PageMap, PageRegistry } from './index'\n\n/**\n * A cucumber-js World with the harnessed pieces on it. Cucumber constructs one\n * per scenario, so everything here is scenario-scoped by construction.\n *\n * ```ts\n * const pageMap = { checkout: CheckoutPage }\n * const pages = definePages(pageMap)\n *\n * class AppWorld extends HarnessedWorld<{ checkout: CheckoutPage }, typeof pageMap> {\n *   override pages = pages\n * }\n * setWorldConstructor(AppWorld)\n * defineParameterType(pageParameter(pages))\n *\n * // One browser for the run; a page per scenario.\n * let browser: Browser\n * BeforeAll(async () => {\n *   browser = await chromium.launch()\n * })\n * Before(async function (this: AppWorld) {\n *   this.env = pw(await browser.newPage()) // or wdio(browser), …\n * })\n * Given('I open the {page} page', async function (this: AppWorld, name: 'checkout') {\n *   this.bag.checkout = this.open(name)\n *   await this.bag.checkout.goto()\n * })\n * ```\n */\nexport class HarnessedWorld<\n  W = Record<string, unknown>,\n  P extends PageMap = PageMap,\n> extends World {\n  /** The scenario's bag. Starts empty; cucumber builds a new world per scenario. */\n  bag: Partial<W> = createWorld<W>()\n  /** The env every harness in the scenario is built with. Set it in a `Before`. */\n  env: EnvConfig | undefined\n  /** The pages features can name. Assign the registry in a subclass. */\n  pages: PageRegistry<P> | undefined\n\n  constructor(options: IWorldOptions) {\n    super(options)\n  }\n\n  /** Constructs a registered page with the scenario's env. */\n  open<N extends keyof P & string>(name: N): InstanceType<P[N]> {\n    if (this.pages === undefined) {\n      throw new Error('harnessed: this world has no page registry. Assign `pages` in a subclass.')\n    }\n    if (this.env === undefined) {\n      throw new Error('harnessed: this world has no env yet. Set `this.env` in a Before hook.')\n    }\n    return this.pages.open(name, this.env)\n  }\n}\n"]}

package/dist/cucumber.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var cucumber = require('@cucumber/cucumber');
+
+// src/cucumber.ts
+
+// src/index.ts
+function createWorld() {
+  return {};
+}
+
+// src/cucumber.ts
+var HarnessedWorld = class extends cucumber.World {
+  /** The scenario's bag. Starts empty; cucumber builds a new world per scenario. */
+  bag = createWorld();
+  /** The env every harness in the scenario is built with. Set it in a `Before`. */
+  env;
+  /** The pages features can name. Assign the registry in a subclass. */
+  pages;
+  constructor(options) {
+    super(options);
+  }
+  /** Constructs a registered page with the scenario's env. */
+  open(name) {
+    if (this.pages === void 0) {
+      throw new Error("harnessed: this world has no page registry. Assign `pages` in a subclass.");
+    }
+    if (this.env === void 0) {
+      throw new Error("harnessed: this world has no env yet. Set `this.env` in a Before hook.");
+    }
+    return this.pages.open(name, this.env);
+  }
+};
+
+exports.HarnessedWorld = HarnessedWorld;
+//# sourceMappingURL=cucumber.cjs.map
+//# sourceMappingURL=cucumber.cjs.map

package/dist/cucumber.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/cucumber.ts"],"names":["World"],"mappings":";;;;;;;AAwGO,SAAS,WAAA,GAA6B;AAC3C,EAAA,OAAO,EAAC;AACV;;;ACxEO,IAAM,cAAA,GAAN,cAGGA,cAAA,CAAM;AAAA;AAAA,EAEd,MAAkB,WAAA,EAAe;AAAA;AAAA,EAEjC,GAAA;AAAA;AAAA,EAEA,KAAA;AAAA,EAEA,YAAY,OAAA,EAAwB;AAClC,IAAA,KAAA,CAAM,OAAO,CAAA;AAAA,EACf;AAAA;AAAA,EAGA,KAAiC,IAAA,EAA6B;AAC5D,IAAA,IAAI,IAAA,CAAK,UAAU,MAAA,EAAW;AAC5B,MAAA,MAAM,IAAI,MAAM,2EAA2E,CAAA;AAAA,IAC7F;AACA,IAAA,IAAI,IAAA,CAAK,QAAQ,MAAA,EAAW;AAC1B,MAAA,MAAM,IAAI,MAAM,wEAAwE,CAAA;AAAA,IAC1F;AACA,IAAA,OAAO,IAAA,CAAK,KAAA,CAAM,IAAA,CAAK,IAAA,EAAM,KAAK,GAAG,CAAA;AAAA,EACvC;AACF","file":"cucumber.cjs","sourcesContent":["import type { EnvConfig } from '@harnessed-ts/core'\n\n/**\n * Gherkin support for harnessed: what every runner needs, with no runner in it.\n *\n * - A **world** — the scenario-scoped bag where steps keep the pages a scenario\n *   builds up. Steps are separate functions, so the obvious place for a harness\n *   is a module-level `let`, which leaks into the next scenario the moment a\n *   runner reuses a worker. Each runner adapter gives the bag the right lifetime.\n * - A **page registry** — the pages a feature can name, so a step reads\n *   `Given I open the checkout page` and gets a `CheckoutPage`, typed.\n * - A **`{page}` parameter type** built from the registry, so a feature naming\n *   an unknown page fails at step matching, where the typo is, rather than deep\n *   inside a step.\n *\n * Step bodies stay hand-written: the feature's wording is the team's, not a\n * mirror of method names.\n */\n\n/** Anything a page registry can construct: a page or component harness class. */\nexport type PageConstructor<T = object> = new (env: EnvConfig) => T\n\nexport type PageMap = Record<string, PageConstructor>\n\n/** The pages a feature can name. */\nexport interface PageRegistry<P extends PageMap> {\n  /** Every registered name, longest first — the order a matcher must try them. */\n  readonly names: ReadonlyArray<keyof P & string>\n  /** Whether `name` is registered: narrows a string from a step to a page name. */\n  has(name: string): name is keyof P & string\n  /** Constructs the named page with the scenario's env. */\n  open<N extends keyof P & string>(name: N, env: EnvConfig): InstanceType<P[N]>\n}\n\nexport function definePages<P extends PageMap>(pages: P): PageRegistry<P> {\n  const names = (Object.keys(pages) as Array<keyof P & string>).sort((a, b) => b.length - a.length)\n  if (names.length === 0) {\n    // `{page}` is an alternation of the names; with none it is the empty\n    // pattern, which matches anywhere and would let any step through.\n    throw new Error('harnessed: definePages() needs at least one page.')\n  }\n  const has = (name: string): name is keyof P & string =>\n    Object.prototype.hasOwnProperty.call(pages, name)\n  return {\n    names,\n    has,\n    open(name, env) {\n      // Own names only: `constructor` and the rest of Object.prototype are not pages.\n      if (!has(name)) {\n        throw new Error(`harnessed: no page named \"${name}\". Registered: ${names.join(', ')}.`)\n      }\n      const Page = pages[name]\n      return new Page(env) as InstanceType<P[typeof name]>\n    },\n  }\n}\n\n/**\n * A cucumber-expression parameter type, in the shape every runner's\n * `defineParameterType` takes: @cucumber/cucumber, playwright-bdd and\n * @badeball/cypress-cucumber-preprocessor alike.\n */\nexport interface ParameterTypeDefinition<T> {\n  name: string\n  regexp: RegExp\n  transformer: (match: string) => T\n  useForSnippets?: boolean\n}\n\nfunction escape(text: string): string {\n  return text.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/**\n * `{page}` for step patterns: matches exactly the registered names (longest\n * first, so `checkout summary` wins over `checkout`) and hands the step the\n * name, typed. Name it something else with `{ name }`.\n *\n * ```ts\n * defineParameterType(pageParameter(pages))\n * Given('I open the {page} page', async function (name) { … pages.open(name, env) })\n * ```\n */\nexport function pageParameter<P extends PageMap>(\n  registry: PageRegistry<P>,\n  options: { name?: string } = {},\n): ParameterTypeDefinition<keyof P & string> {\n  return {\n    name: options.name ?? 'page',\n    regexp: new RegExp(registry.names.map(escape).join('|')),\n    transformer: match => {\n      // The regexp only admits registered names, so this cannot fail; it is\n      // here so a hand-built pattern that bypasses it still gets a clear error.\n      if (!registry.has(match)) throw new Error(`harnessed: no page named \"${match}\".`)\n      return match\n    },\n    useForSnippets: false,\n  }\n}\n\n/**\n * A fresh, empty world. Adapters call this once per scenario; it exists so the\n * bag's type is written once, where the steps declare it.\n */\nexport function createWorld<W>(): Partial<W> {\n  return {}\n}\n","import { World } from '@cucumber/cucumber'\nimport type { IWorldOptions } from '@cucumber/cucumber'\nimport type { EnvConfig } from '@harnessed-ts/core'\nimport { createWorld } from './index'\nimport type { PageMap, PageRegistry } from './index'\n\n/**\n * A cucumber-js World with the harnessed pieces on it. Cucumber constructs one\n * per scenario, so everything here is scenario-scoped by construction.\n *\n * ```ts\n * const pageMap = { checkout: CheckoutPage }\n * const pages = definePages(pageMap)\n *\n * class AppWorld extends HarnessedWorld<{ checkout: CheckoutPage }, typeof pageMap> {\n *   override pages = pages\n * }\n * setWorldConstructor(AppWorld)\n * defineParameterType(pageParameter(pages))\n *\n * // One browser for the run; a page per scenario.\n * let browser: Browser\n * BeforeAll(async () => {\n *   browser = await chromium.launch()\n * })\n * Before(async function (this: AppWorld) {\n *   this.env = pw(await browser.newPage()) // or wdio(browser), …\n * })\n * Given('I open the {page} page', async function (this: AppWorld, name: 'checkout') {\n *   this.bag.checkout = this.open(name)\n *   await this.bag.checkout.goto()\n * })\n * ```\n */\nexport class HarnessedWorld<\n  W = Record<string, unknown>,\n  P extends PageMap = PageMap,\n> extends World {\n  /** The scenario's bag. Starts empty; cucumber builds a new world per scenario. */\n  bag: Partial<W> = createWorld<W>()\n  /** The env every harness in the scenario is built with. Set it in a `Before`. */\n  env: EnvConfig | undefined\n  /** The pages features can name. Assign the registry in a subclass. */\n  pages: PageRegistry<P> | undefined\n\n  constructor(options: IWorldOptions) {\n    super(options)\n  }\n\n  /** Constructs a registered page with the scenario's env. */\n  open<N extends keyof P & string>(name: N): InstanceType<P[N]> {\n    if (this.pages === undefined) {\n      throw new Error('harnessed: this world has no page registry. Assign `pages` in a subclass.')\n    }\n    if (this.env === undefined) {\n      throw new Error('harnessed: this world has no env yet. Set `this.env` in a Before hook.')\n    }\n    return this.pages.open(name, this.env)\n  }\n}\n"]}

package/dist/cucumber.d.ts

@@ -0,0 +1,44 @@
+import { World } from '@cucumber/cucumber';
+import type { IWorldOptions } from '@cucumber/cucumber';
+import type { EnvConfig } from '@harnessed-ts/core';
+import type { PageMap, PageRegistry } from './index';
+/**
+ * A cucumber-js World with the harnessed pieces on it. Cucumber constructs one
+ * per scenario, so everything here is scenario-scoped by construction.
+ *
+ * ```ts
+ * const pageMap = { checkout: CheckoutPage }
+ * const pages = definePages(pageMap)
+ *
+ * class AppWorld extends HarnessedWorld<{ checkout: CheckoutPage }, typeof pageMap> {
+ *   override pages = pages
+ * }
+ * setWorldConstructor(AppWorld)
+ * defineParameterType(pageParameter(pages))
+ *
+ * // One browser for the run; a page per scenario.
+ * let browser: Browser
+ * BeforeAll(async () => {
+ *   browser = await chromium.launch()
+ * })
+ * Before(async function (this: AppWorld) {
+ *   this.env = pw(await browser.newPage()) // or wdio(browser), …
+ * })
+ * Given('I open the {page} page', async function (this: AppWorld, name: 'checkout') {
+ *   this.bag.checkout = this.open(name)
+ *   await this.bag.checkout.goto()
+ * })
+ * ```
+ */
+export declare class HarnessedWorld<W = Record<string, unknown>, P extends PageMap = PageMap> extends World {
+    /** The scenario's bag. Starts empty; cucumber builds a new world per scenario. */
+    bag: Partial<W>;
+    /** The env every harness in the scenario is built with. Set it in a `Before`. */
+    env: EnvConfig | undefined;
+    /** The pages features can name. Assign the registry in a subclass. */
+    pages: PageRegistry<P> | undefined;
+    constructor(options: IWorldOptions);
+    /** Constructs a registered page with the scenario's env. */
+    open<N extends keyof P & string>(name: N): InstanceType<P[N]>;
+}
+//# sourceMappingURL=cucumber.d.ts.map

package/dist/cucumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cucumber.d.ts","sourceRoot":"","sources":["../src/cucumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,cAAc,CACzB,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3B,CAAC,SAAS,OAAO,GAAG,OAAO,CAC3B,SAAQ,KAAK;IACb,kFAAkF;IAClF,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,CAAmB;IAClC,iFAAiF;IACjF,GAAG,EAAE,SAAS,GAAG,SAAS,CAAA;IAC1B,sEAAsE;IACtE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAAA;gBAEtB,OAAO,EAAE,aAAa;IAIlC,4DAA4D;IAC5D,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAS9D"}

package/dist/cucumber.js

@@ -0,0 +1,4 @@
+export { HarnessedWorld } from './chunk-MMY7SRBU.js';
+import './chunk-6AIO5EWN.js';
+//# sourceMappingURL=cucumber.js.map
+//# sourceMappingURL=cucumber.js.map

package/dist/cucumber.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"cucumber.js"}

package/dist/cypress.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+// src/index.ts
+function createWorld() {
+  return {};
+}
+
+// src/cypress.ts
+function isHookRegistrar(value) {
+  return typeof value === "function";
+}
+function globalBeforeEach() {
+  const hook = Reflect.get(globalThis, "beforeEach");
+  if (!isHookRegistrar(hook)) {
+    throw new Error(
+      "harnessed: cypressWorld() found no global beforeEach. Call it at the top level of a step definitions file, which Cypress bundles into the spec, or pass { beforeEach }."
+    );
+  }
+  return hook;
+}
+function cypressWorld(options = {}) {
+  const beforeEach = options.beforeEach ?? globalBeforeEach();
+  let current;
+  beforeEach(() => {
+    current = createWorld();
+  });
+  return {
+    world() {
+      if (current === void 0) {
+        throw new Error(
+          "harnessed: no scenario is running yet, so there is no world. Call world() inside a step, not at the top level of a step definitions file."
+        );
+      }
+      return current;
+    }
+  };
+}
+
+exports.cypressWorld = cypressWorld;
+//# sourceMappingURL=cypress.cjs.map
+//# sourceMappingURL=cypress.cjs.map

package/dist/cypress.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/cypress.ts"],"names":[],"mappings":";;;AAwGO,SAAS,WAAA,GAA6B;AAC3C,EAAA,OAAO,EAAC;AACV;;;ACrFA,SAAS,gBAAgB,KAAA,EAAwC;AAC/D,EAAA,OAAO,OAAO,KAAA,KAAU,UAAA;AAC1B;AAEA,SAAS,gBAAA,GAAkC;AACzC,EAAA,MAAM,IAAA,GAAgB,OAAA,CAAQ,GAAA,CAAI,UAAA,EAAY,YAAY,CAAA;AAC1D,EAAA,IAAI,CAAC,eAAA,CAAgB,IAAI,CAAA,EAAG;AAC1B,IAAA,MAAM,IAAI,KAAA;AAAA,MACR;AAAA,KAEF;AAAA,EACF;AACA,EAAA,OAAO,IAAA;AACT;AAiCO,SAAS,YAAA,CAAgB,OAAA,GAA+B,EAAC,EAAoB;AAClF,EAAA,MAAM,UAAA,GAAa,OAAA,CAAQ,UAAA,IAAc,gBAAA,EAAiB;AAC1D,EAAA,IAAI,OAAA;AACJ,EAAA,UAAA,CAAW,MAAM;AACf,IAAA,OAAA,GAAU,WAAA,EAAe;AAAA,EAC3B,CAAC,CAAA;AACD,EAAA,OAAO;AAAA,IACL,KAAA,GAAQ;AACN,MAAA,IAAI,YAAY,MAAA,EAAW;AACzB,QAAA,MAAM,IAAI,KAAA;AAAA,UACR;AAAA,SAEF;AAAA,MACF;AACA,MAAA,OAAO,OAAA;AAAA,IACT;AAAA,GACF;AACF","file":"cypress.cjs","sourcesContent":["import type { EnvConfig } from '@harnessed-ts/core'\n\n/**\n * Gherkin support for harnessed: what every runner needs, with no runner in it.\n *\n * - A **world** — the scenario-scoped bag where steps keep the pages a scenario\n *   builds up. Steps are separate functions, so the obvious place for a harness\n *   is a module-level `let`, which leaks into the next scenario the moment a\n *   runner reuses a worker. Each runner adapter gives the bag the right lifetime.\n * - A **page registry** — the pages a feature can name, so a step reads\n *   `Given I open the checkout page` and gets a `CheckoutPage`, typed.\n * - A **`{page}` parameter type** built from the registry, so a feature naming\n *   an unknown page fails at step matching, where the typo is, rather than deep\n *   inside a step.\n *\n * Step bodies stay hand-written: the feature's wording is the team's, not a\n * mirror of method names.\n */\n\n/** Anything a page registry can construct: a page or component harness class. */\nexport type PageConstructor<T = object> = new (env: EnvConfig) => T\n\nexport type PageMap = Record<string, PageConstructor>\n\n/** The pages a feature can name. */\nexport interface PageRegistry<P extends PageMap> {\n  /** Every registered name, longest first — the order a matcher must try them. */\n  readonly names: ReadonlyArray<keyof P & string>\n  /** Whether `name` is registered: narrows a string from a step to a page name. */\n  has(name: string): name is keyof P & string\n  /** Constructs the named page with the scenario's env. */\n  open<N extends keyof P & string>(name: N, env: EnvConfig): InstanceType<P[N]>\n}\n\nexport function definePages<P extends PageMap>(pages: P): PageRegistry<P> {\n  const names = (Object.keys(pages) as Array<keyof P & string>).sort((a, b) => b.length - a.length)\n  if (names.length === 0) {\n    // `{page}` is an alternation of the names; with none it is the empty\n    // pattern, which matches anywhere and would let any step through.\n    throw new Error('harnessed: definePages() needs at least one page.')\n  }\n  const has = (name: string): name is keyof P & string =>\n    Object.prototype.hasOwnProperty.call(pages, name)\n  return {\n    names,\n    has,\n    open(name, env) {\n      // Own names only: `constructor` and the rest of Object.prototype are not pages.\n      if (!has(name)) {\n        throw new Error(`harnessed: no page named \"${name}\". Registered: ${names.join(', ')}.`)\n      }\n      const Page = pages[name]\n      return new Page(env) as InstanceType<P[typeof name]>\n    },\n  }\n}\n\n/**\n * A cucumber-expression parameter type, in the shape every runner's\n * `defineParameterType` takes: @cucumber/cucumber, playwright-bdd and\n * @badeball/cypress-cucumber-preprocessor alike.\n */\nexport interface ParameterTypeDefinition<T> {\n  name: string\n  regexp: RegExp\n  transformer: (match: string) => T\n  useForSnippets?: boolean\n}\n\nfunction escape(text: string): string {\n  return text.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/**\n * `{page}` for step patterns: matches exactly the registered names (longest\n * first, so `checkout summary` wins over `checkout`) and hands the step the\n * name, typed. Name it something else with `{ name }`.\n *\n * ```ts\n * defineParameterType(pageParameter(pages))\n * Given('I open the {page} page', async function (name) { … pages.open(name, env) })\n * ```\n */\nexport function pageParameter<P extends PageMap>(\n  registry: PageRegistry<P>,\n  options: { name?: string } = {},\n): ParameterTypeDefinition<keyof P & string> {\n  return {\n    name: options.name ?? 'page',\n    regexp: new RegExp(registry.names.map(escape).join('|')),\n    transformer: match => {\n      // The regexp only admits registered names, so this cannot fail; it is\n      // here so a hand-built pattern that bypasses it still gets a clear error.\n      if (!registry.has(match)) throw new Error(`harnessed: no page named \"${match}\".`)\n      return match\n    },\n    useForSnippets: false,\n  }\n}\n\n/**\n * A fresh, empty world. Adapters call this once per scenario; it exists so the\n * bag's type is written once, where the steps declare it.\n */\nexport function createWorld<W>(): Partial<W> {\n  return {}\n}\n","import { createWorld } from './index'\n\n/**\n * How a hook gets registered: Mocha's `beforeEach`, which Cypress provides as a\n * global, or anything with its shape.\n */\nexport type HookRegistrar = (fn: () => void) => void\n\nexport interface CypressWorldOptions {\n  /**\n   * Registers the reset that runs before each scenario. Defaults to the global\n   * `beforeEach` Cypress provides in a spec bundle.\n   */\n  beforeEach?: HookRegistrar\n}\n\nexport interface CypressWorld<W> {\n  /** The current scenario's bag. Read it inside a step, never at module level. */\n  world(): Partial<W>\n}\n\nfunction isHookRegistrar(value: unknown): value is HookRegistrar {\n  return typeof value === 'function'\n}\n\nfunction globalBeforeEach(): HookRegistrar {\n  const hook: unknown = Reflect.get(globalThis, 'beforeEach')\n  if (!isHookRegistrar(hook)) {\n    throw new Error(\n      'harnessed: cypressWorld() found no global beforeEach. Call it at the top level of a ' +\n        'step definitions file, which Cypress bundles into the spec, or pass { beforeEach }.',\n    )\n  }\n  return hook\n}\n\n/**\n * A scenario-scoped world for @badeball/cypress-cucumber-preprocessor.\n *\n * Every scenario in a feature runs in the same spec bundle, so a module-level\n * `let` in a step file carries the last scenario's pages into the next one. This\n * registers a `beforeEach` that starts each scenario with an empty world; steps\n * run as Cypress commands, in order, so each one sees what the steps before it\n * left there. Steps reach the world through `world()`, never through `this`.\n *\n * Harness calls are promises, so a step runs them inside the Cypress driver's\n * bridge (`cy.harnessEnv`, `cy.harness`) — one command each:\n *\n * ```ts\n * import { defineParameterType, When } from '@badeball/cypress-cucumber-preprocessor'\n *\n * const pages = definePages({ checkout: CheckoutPage })\n * defineParameterType(pageParameter(pages))\n * const { world } = cypressWorld<{ checkout: CheckoutPage }>()\n *\n * When('I open the {page} page', (name: 'checkout') => {\n *   cy.harnessEnv(async env => {\n *     const page = pages.open(name, env)\n *     await page.goto()\n *     world().checkout = page\n *   })\n * })\n * ```\n *\n * Call it once, at the top level of a step definitions file, and share the\n * `world` it returns: each call is a separate world.\n */\nexport function cypressWorld<W>(options: CypressWorldOptions = {}): CypressWorld<W> {\n  const beforeEach = options.beforeEach ?? globalBeforeEach()\n  let current: Partial<W> | undefined\n  beforeEach(() => {\n    current = createWorld<W>()\n  })\n  return {\n    world() {\n      if (current === undefined) {\n        throw new Error(\n          'harnessed: no scenario is running yet, so there is no world. Call world() inside ' +\n            'a step, not at the top level of a step definitions file.',\n        )\n      }\n      return current\n    },\n  }\n}\n"]}

package/dist/cypress.d.ts

@@ -0,0 +1,49 @@
+/**
+ * How a hook gets registered: Mocha's `beforeEach`, which Cypress provides as a
+ * global, or anything with its shape.
+ */
+export type HookRegistrar = (fn: () => void) => void;
+export interface CypressWorldOptions {
+    /**
+     * Registers the reset that runs before each scenario. Defaults to the global
+     * `beforeEach` Cypress provides in a spec bundle.
+     */
+    beforeEach?: HookRegistrar;
+}
+export interface CypressWorld<W> {
+    /** The current scenario's bag. Read it inside a step, never at module level. */
+    world(): Partial<W>;
+}
+/**
+ * A scenario-scoped world for @badeball/cypress-cucumber-preprocessor.
+ *
+ * Every scenario in a feature runs in the same spec bundle, so a module-level
+ * `let` in a step file carries the last scenario's pages into the next one. This
+ * registers a `beforeEach` that starts each scenario with an empty world; steps
+ * run as Cypress commands, in order, so each one sees what the steps before it
+ * left there. Steps reach the world through `world()`, never through `this`.
+ *
+ * Harness calls are promises, so a step runs them inside the Cypress driver's
+ * bridge (`cy.harnessEnv`, `cy.harness`) — one command each:
+ *
+ * ```ts
+ * import { defineParameterType, When } from '@badeball/cypress-cucumber-preprocessor'
+ *
+ * const pages = definePages({ checkout: CheckoutPage })
+ * defineParameterType(pageParameter(pages))
+ * const { world } = cypressWorld<{ checkout: CheckoutPage }>()
+ *
+ * When('I open the {page} page', (name: 'checkout') => {
+ *   cy.harnessEnv(async env => {
+ *     const page = pages.open(name, env)
+ *     await page.goto()
+ *     world().checkout = page
+ *   })
+ * })
+ * ```
+ *
+ * Call it once, at the top level of a step definitions file, and share the
+ * `world` it returns: each call is a separate world.
+ */
+export declare function cypressWorld<W>(options?: CypressWorldOptions): CypressWorld<W>;
+//# sourceMappingURL=cypress.d.ts.map

package/dist/cypress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cypress.d.ts","sourceRoot":"","sources":["../src/cypress.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;AAEpD,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,UAAU,CAAC,EAAE,aAAa,CAAA;CAC3B;AAED,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,gFAAgF;IAChF,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAAA;CACpB;AAiBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAE,mBAAwB,GAAG,YAAY,CAAC,CAAC,CAAC,CAiBlF"}

package/dist/cypress.js

@@ -0,0 +1,36 @@
+import { createWorld } from './chunk-6AIO5EWN.js';
+
+// src/cypress.ts
+function isHookRegistrar(value) {
+  return typeof value === "function";
+}
+function globalBeforeEach() {
+  const hook = Reflect.get(globalThis, "beforeEach");
+  if (!isHookRegistrar(hook)) {
+    throw new Error(
+      "harnessed: cypressWorld() found no global beforeEach. Call it at the top level of a step definitions file, which Cypress bundles into the spec, or pass { beforeEach }."
+    );
+  }
+  return hook;
+}
+function cypressWorld(options = {}) {
+  const beforeEach = options.beforeEach ?? globalBeforeEach();
+  let current;
+  beforeEach(() => {
+    current = createWorld();
+  });
+  return {
+    world() {
+      if (current === void 0) {
+        throw new Error(
+          "harnessed: no scenario is running yet, so there is no world. Call world() inside a step, not at the top level of a step definitions file."
+        );
+      }
+      return current;
+    }
+  };
+}
+
+export { cypressWorld };
+//# sourceMappingURL=cypress.js.map
+//# sourceMappingURL=cypress.js.map

package/dist/cypress.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cypress.ts"],"names":[],"mappings":";;;AAqBA,SAAS,gBAAgB,KAAA,EAAwC;AAC/D,EAAA,OAAO,OAAO,KAAA,KAAU,UAAA;AAC1B;AAEA,SAAS,gBAAA,GAAkC;AACzC,EAAA,MAAM,IAAA,GAAgB,OAAA,CAAQ,GAAA,CAAI,UAAA,EAAY,YAAY,CAAA;AAC1D,EAAA,IAAI,CAAC,eAAA,CAAgB,IAAI,CAAA,EAAG;AAC1B,IAAA,MAAM,IAAI,KAAA;AAAA,MACR;AAAA,KAEF;AAAA,EACF;AACA,EAAA,OAAO,IAAA;AACT;AAiCO,SAAS,YAAA,CAAgB,OAAA,GAA+B,EAAC,EAAoB;AAClF,EAAA,MAAM,UAAA,GAAa,OAAA,CAAQ,UAAA,IAAc,gBAAA,EAAiB;AAC1D,EAAA,IAAI,OAAA;AACJ,EAAA,UAAA,CAAW,MAAM;AACf,IAAA,OAAA,GAAU,WAAA,EAAe;AAAA,EAC3B,CAAC,CAAA;AACD,EAAA,OAAO;AAAA,IACL,KAAA,GAAQ;AACN,MAAA,IAAI,YAAY,MAAA,EAAW;AACzB,QAAA,MAAM,IAAI,KAAA;AAAA,UACR;AAAA,SAEF;AAAA,MACF;AACA,MAAA,OAAO,OAAA;AAAA,IACT;AAAA,GACF;AACF","file":"cypress.js","sourcesContent":["import { createWorld } from './index'\n\n/**\n * How a hook gets registered: Mocha's `beforeEach`, which Cypress provides as a\n * global, or anything with its shape.\n */\nexport type HookRegistrar = (fn: () => void) => void\n\nexport interface CypressWorldOptions {\n  /**\n   * Registers the reset that runs before each scenario. Defaults to the global\n   * `beforeEach` Cypress provides in a spec bundle.\n   */\n  beforeEach?: HookRegistrar\n}\n\nexport interface CypressWorld<W> {\n  /** The current scenario's bag. Read it inside a step, never at module level. */\n  world(): Partial<W>\n}\n\nfunction isHookRegistrar(value: unknown): value is HookRegistrar {\n  return typeof value === 'function'\n}\n\nfunction globalBeforeEach(): HookRegistrar {\n  const hook: unknown = Reflect.get(globalThis, 'beforeEach')\n  if (!isHookRegistrar(hook)) {\n    throw new Error(\n      'harnessed: cypressWorld() found no global beforeEach. Call it at the top level of a ' +\n        'step definitions file, which Cypress bundles into the spec, or pass { beforeEach }.',\n    )\n  }\n  return hook\n}\n\n/**\n * A scenario-scoped world for @badeball/cypress-cucumber-preprocessor.\n *\n * Every scenario in a feature runs in the same spec bundle, so a module-level\n * `let` in a step file carries the last scenario's pages into the next one. This\n * registers a `beforeEach` that starts each scenario with an empty world; steps\n * run as Cypress commands, in order, so each one sees what the steps before it\n * left there. Steps reach the world through `world()`, never through `this`.\n *\n * Harness calls are promises, so a step runs them inside the Cypress driver's\n * bridge (`cy.harnessEnv`, `cy.harness`) — one command each:\n *\n * ```ts\n * import { defineParameterType, When } from '@badeball/cypress-cucumber-preprocessor'\n *\n * const pages = definePages({ checkout: CheckoutPage })\n * defineParameterType(pageParameter(pages))\n * const { world } = cypressWorld<{ checkout: CheckoutPage }>()\n *\n * When('I open the {page} page', (name: 'checkout') => {\n *   cy.harnessEnv(async env => {\n *     const page = pages.open(name, env)\n *     await page.goto()\n *     world().checkout = page\n *   })\n * })\n * ```\n *\n * Call it once, at the top level of a step definitions file, and share the\n * `world` it returns: each call is a separate world.\n */\nexport function cypressWorld<W>(options: CypressWorldOptions = {}): CypressWorld<W> {\n  const beforeEach = options.beforeEach ?? globalBeforeEach()\n  let current: Partial<W> | undefined\n  beforeEach(() => {\n    current = createWorld<W>()\n  })\n  return {\n    world() {\n      if (current === undefined) {\n        throw new Error(\n          'harnessed: no scenario is running yet, so there is no world. Call world() inside ' +\n            'a step, not at the top level of a step definitions file.',\n        )\n      }\n      return current\n    },\n  }\n}\n"]}

package/dist/index.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+// src/index.ts
+function definePages(pages) {
+  const names = Object.keys(pages).sort((a, b) => b.length - a.length);
+  if (names.length === 0) {
+    throw new Error("harnessed: definePages() needs at least one page.");
+  }
+  const has = (name) => Object.prototype.hasOwnProperty.call(pages, name);
+  return {
+    names,
+    has,
+    open(name, env) {
+      if (!has(name)) {
+        throw new Error(`harnessed: no page named "${name}". Registered: ${names.join(", ")}.`);
+      }
+      const Page = pages[name];
+      return new Page(env);
+    }
+  };
+}
+function escape(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function pageParameter(registry, options = {}) {
+  return {
+    name: options.name ?? "page",
+    regexp: new RegExp(registry.names.map(escape).join("|")),
+    transformer: (match) => {
+      if (!registry.has(match)) throw new Error(`harnessed: no page named "${match}".`);
+      return match;
+    },
+    useForSnippets: false
+  };
+}
+function createWorld() {
+  return {};
+}
+
+exports.createWorld = createWorld;
+exports.definePages = definePages;
+exports.pageParameter = pageParameter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;AAkCO,SAAS,YAA+B,KAAA,EAA2B;AACxE,EAAA,MAAM,KAAA,GAAS,MAAA,CAAO,IAAA,CAAK,KAAK,CAAA,CAA8B,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,CAAE,MAAA,GAAS,CAAA,CAAE,MAAM,CAAA;AAChG,EAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AAGtB,IAAA,MAAM,IAAI,MAAM,mDAAmD,CAAA;AAAA,EACrE;AACA,EAAA,MAAM,GAAA,GAAM,CAAC,IAAA,KACX,MAAA,CAAO,UAAU,cAAA,CAAe,IAAA,CAAK,OAAO,IAAI,CAAA;AAClD,EAAA,OAAO;AAAA,IACL,KAAA;AAAA,IACA,GAAA;AAAA,IACA,IAAA,CAAK,MAAM,GAAA,EAAK;AAEd,MAAA,IAAI,CAAC,GAAA,CAAI,IAAI,CAAA,EAAG;AACd,QAAA,MAAM,IAAI,MAAM,CAAA,0BAAA,EAA6B,IAAI,kBAAkB,KAAA,CAAM,IAAA,CAAK,IAAI,CAAC,CAAA,CAAA,CAAG,CAAA;AAAA,MACxF;AACA,MAAA,MAAM,IAAA,GAAO,MAAM,IAAI,CAAA;AACvB,MAAA,OAAO,IAAI,KAAK,GAAG,CAAA;AAAA,IACrB;AAAA,GACF;AACF;AAcA,SAAS,OAAO,IAAA,EAAsB;AACpC,EAAA,OAAO,IAAA,CAAK,OAAA,CAAQ,qBAAA,EAAuB,MAAM,CAAA;AACnD;AAYO,SAAS,aAAA,CACd,QAAA,EACA,OAAA,GAA6B,EAAC,EACa;AAC3C,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,QAAQ,IAAA,IAAQ,MAAA;AAAA,IACtB,MAAA,EAAQ,IAAI,MAAA,CAAO,QAAA,CAAS,KAAA,CAAM,IAAI,MAAM,CAAA,CAAE,IAAA,CAAK,GAAG,CAAC,CAAA;AAAA,IACvD,aAAa,CAAA,KAAA,KAAS;AAGpB,MAAA,IAAI,CAAC,QAAA,CAAS,GAAA,CAAI,KAAK,CAAA,QAAS,IAAI,KAAA,CAAM,CAAA,0BAAA,EAA6B,KAAK,CAAA,EAAA,CAAI,CAAA;AAChF,MAAA,OAAO,KAAA;AAAA,IACT,CAAA;AAAA,IACA,cAAA,EAAgB;AAAA,GAClB;AACF;AAMO,SAAS,WAAA,GAA6B;AAC3C,EAAA,OAAO,EAAC;AACV","file":"index.cjs","sourcesContent":["import type { EnvConfig } from '@harnessed-ts/core'\n\n/**\n * Gherkin support for harnessed: what every runner needs, with no runner in it.\n *\n * - A **world** — the scenario-scoped bag where steps keep the pages a scenario\n *   builds up. Steps are separate functions, so the obvious place for a harness\n *   is a module-level `let`, which leaks into the next scenario the moment a\n *   runner reuses a worker. Each runner adapter gives the bag the right lifetime.\n * - A **page registry** — the pages a feature can name, so a step reads\n *   `Given I open the checkout page` and gets a `CheckoutPage`, typed.\n * - A **`{page}` parameter type** built from the registry, so a feature naming\n *   an unknown page fails at step matching, where the typo is, rather than deep\n *   inside a step.\n *\n * Step bodies stay hand-written: the feature's wording is the team's, not a\n * mirror of method names.\n */\n\n/** Anything a page registry can construct: a page or component harness class. */\nexport type PageConstructor<T = object> = new (env: EnvConfig) => T\n\nexport type PageMap = Record<string, PageConstructor>\n\n/** The pages a feature can name. */\nexport interface PageRegistry<P extends PageMap> {\n  /** Every registered name, longest first — the order a matcher must try them. */\n  readonly names: ReadonlyArray<keyof P & string>\n  /** Whether `name` is registered: narrows a string from a step to a page name. */\n  has(name: string): name is keyof P & string\n  /** Constructs the named page with the scenario's env. */\n  open<N extends keyof P & string>(name: N, env: EnvConfig): InstanceType<P[N]>\n}\n\nexport function definePages<P extends PageMap>(pages: P): PageRegistry<P> {\n  const names = (Object.keys(pages) as Array<keyof P & string>).sort((a, b) => b.length - a.length)\n  if (names.length === 0) {\n    // `{page}` is an alternation of the names; with none it is the empty\n    // pattern, which matches anywhere and would let any step through.\n    throw new Error('harnessed: definePages() needs at least one page.')\n  }\n  const has = (name: string): name is keyof P & string =>\n    Object.prototype.hasOwnProperty.call(pages, name)\n  return {\n    names,\n    has,\n    open(name, env) {\n      // Own names only: `constructor` and the rest of Object.prototype are not pages.\n      if (!has(name)) {\n        throw new Error(`harnessed: no page named \"${name}\". Registered: ${names.join(', ')}.`)\n      }\n      const Page = pages[name]\n      return new Page(env) as InstanceType<P[typeof name]>\n    },\n  }\n}\n\n/**\n * A cucumber-expression parameter type, in the shape every runner's\n * `defineParameterType` takes: @cucumber/cucumber, playwright-bdd and\n * @badeball/cypress-cucumber-preprocessor alike.\n */\nexport interface ParameterTypeDefinition<T> {\n  name: string\n  regexp: RegExp\n  transformer: (match: string) => T\n  useForSnippets?: boolean\n}\n\nfunction escape(text: string): string {\n  return text.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/**\n * `{page}` for step patterns: matches exactly the registered names (longest\n * first, so `checkout summary` wins over `checkout`) and hands the step the\n * name, typed. Name it something else with `{ name }`.\n *\n * ```ts\n * defineParameterType(pageParameter(pages))\n * Given('I open the {page} page', async function (name) { … pages.open(name, env) })\n * ```\n */\nexport function pageParameter<P extends PageMap>(\n  registry: PageRegistry<P>,\n  options: { name?: string } = {},\n): ParameterTypeDefinition<keyof P & string> {\n  return {\n    name: options.name ?? 'page',\n    regexp: new RegExp(registry.names.map(escape).join('|')),\n    transformer: match => {\n      // The regexp only admits registered names, so this cannot fail; it is\n      // here so a hand-built pattern that bypasses it still gets a clear error.\n      if (!registry.has(match)) throw new Error(`harnessed: no page named \"${match}\".`)\n      return match\n    },\n    useForSnippets: false,\n  }\n}\n\n/**\n * A fresh, empty world. Adapters call this once per scenario; it exists so the\n * bag's type is written once, where the steps declare it.\n */\nexport function createWorld<W>(): Partial<W> {\n  return {}\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+import type { EnvConfig } from '@harnessed-ts/core';
+/**
+ * Gherkin support for harnessed: what every runner needs, with no runner in it.
+ *
+ * - A **world** — the scenario-scoped bag where steps keep the pages a scenario
+ *   builds up. Steps are separate functions, so the obvious place for a harness
+ *   is a module-level `let`, which leaks into the next scenario the moment a
+ *   runner reuses a worker. Each runner adapter gives the bag the right lifetime.
+ * - A **page registry** — the pages a feature can name, so a step reads
+ *   `Given I open the checkout page` and gets a `CheckoutPage`, typed.
+ * - A **`{page}` parameter type** built from the registry, so a feature naming
+ *   an unknown page fails at step matching, where the typo is, rather than deep
+ *   inside a step.
+ *
+ * Step bodies stay hand-written: the feature's wording is the team's, not a
+ * mirror of method names.
+ */
+/** Anything a page registry can construct: a page or component harness class. */
+export type PageConstructor<T = object> = new (env: EnvConfig) => T;
+export type PageMap = Record<string, PageConstructor>;
+/** The pages a feature can name. */
+export interface PageRegistry<P extends PageMap> {
+    /** Every registered name, longest first — the order a matcher must try them. */
+    readonly names: ReadonlyArray<keyof P & string>;
+    /** Whether `name` is registered: narrows a string from a step to a page name. */
+    has(name: string): name is keyof P & string;
+    /** Constructs the named page with the scenario's env. */
+    open<N extends keyof P & string>(name: N, env: EnvConfig): InstanceType<P[N]>;
+}
+export declare function definePages<P extends PageMap>(pages: P): PageRegistry<P>;
+/**
+ * A cucumber-expression parameter type, in the shape every runner's
+ * `defineParameterType` takes: @cucumber/cucumber, playwright-bdd and
+ * @badeball/cypress-cucumber-preprocessor alike.
+ */
+export interface ParameterTypeDefinition<T> {
+    name: string;
+    regexp: RegExp;
+    transformer: (match: string) => T;
+    useForSnippets?: boolean;
+}
+/**
+ * `{page}` for step patterns: matches exactly the registered names (longest
+ * first, so `checkout summary` wins over `checkout`) and hands the step the
+ * name, typed. Name it something else with `{ name }`.
+ *
+ * ```ts
+ * defineParameterType(pageParameter(pages))
+ * Given('I open the {page} page', async function (name) { … pages.open(name, env) })
+ * ```
+ */
+export declare function pageParameter<P extends PageMap>(registry: PageRegistry<P>, options?: {
+    name?: string;
+}): ParameterTypeDefinition<keyof P & string>;
+/**
+ * A fresh, empty world. Adapters call this once per scenario; it exists so the
+ * bag's type is written once, where the steps declare it.
+ */
+export declare function createWorld<W>(): Partial<W>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAEnD;;;;;;;;;;;;;;;GAeG;AAEH,iFAAiF;AACjF,MAAM,MAAM,eAAe,CAAC,CAAC,GAAG,MAAM,IAAI,KAAK,GAAG,EAAE,SAAS,KAAK,CAAC,CAAA;AAEnE,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AAErD,oCAAoC;AACpC,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,OAAO;IAC7C,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAA;IAC/C,iFAAiF;IACjF,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,MAAM,CAAC,GAAG,MAAM,CAAA;IAC3C,yDAAyD;IACzD,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CAC9E;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAqBxE;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,CAAC,CAAA;IACjC,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAMD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,OAAO,EAC7C,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,EACzB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAC9B,uBAAuB,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAY3C;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAE3C"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createWorld, definePages, pageParameter } from './chunk-6AIO5EWN.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}