@harnessed-ts/gherkin 0.0.0-stage → 0.6.0

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# @harnessed-ts/gherkin
+
+## 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,27 @@
-# 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/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/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,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=cucumber.js.map
+//# sourceMappingURL=cucumber.js.map

package/dist/cucumber.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":"cucumber.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/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"}

package/dist/playwright-bdd.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+// src/index.ts
+function createWorld() {
+  return {};
+}
+
+// src/playwright-bdd.ts
+function withWorld(base) {
+  const extended = base.extend({
+    // Playwright requires the object-destructuring pattern here: it reads the
+    // destructured names to work out what this fixture depends on, and rejects a
+    // plain parameter outright. Empty means it depends on nothing.
+    world: async ({}, use) => {
+      await use(createWorld());
+    }
+  });
+  return extended;
+}
+
+exports.withWorld = withWorld;
+//# sourceMappingURL=playwright-bdd.cjs.map
+//# sourceMappingURL=playwright-bdd.cjs.map

package/dist/playwright-bdd.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/playwright-bdd.ts"],"names":[],"mappings":";;;AAwGO,SAAS,WAAA,GAA6B;AAC3C,EAAA,OAAO,EAAC;AACV;;;AC7DO,SAAS,UAAgB,IAAA,EAA0B;AACxD,EAAA,MAAM,QAAA,GAAY,KAAqB,MAAA,CAAwB;AAAA;AAAA;AAAA;AAAA,IAI7D,KAAA,EAAO,OAAO,EAAC,EAAG,GAAA,KAA8C;AAC9D,MAAA,MAAM,GAAA,CAAI,aAAgB,CAAA;AAAA,IAC5B;AAAA,GACD,CAAA;AACD,EAAA,OAAO,QAAA;AACT","file":"playwright-bdd.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 type { TestType } from '@playwright/test'\nimport { createWorld } from './index'\n\n/**\n * A scenario-scoped bag for the pages a Gherkin scenario builds up.\n *\n * Steps are separate functions, so the obvious place to put a harness is a\n * module-level `let` — which breaks the moment Playwright reuses a worker,\n * because the next scenario inherits the last one's state. A fixture is\n * per-scenario, so it cannot leak.\n */\nexport interface WorldFixture<W> {\n  world: Partial<W>\n}\n\n/**\n * A structural stand-in for \"some Playwright test object\", used to call `extend`.\n *\n * Deliberately not used as a bound on `withWorld`'s `T`. Playwright's real\n * `TestType` is not assignable to this one — its concrete fixture args do not\n * satisfy an index-signature record — so constraining `T` rejects the very thing\n * callers pass. The conditional return type is what gives misuse a readable\n * error instead.\n */\ntype AnyTestType = TestType<Record<string, unknown>, Record<string, unknown>>\n\n/**\n * The base test type with the world fixture added. Written as a conditional so\n * the base's own fixtures survive — returning the base type unchanged would make\n * `world` invisible to every step that destructures it.\n */\nexport type WithWorld<T, W> =\n  T extends TestType<infer TestArgs, infer WorkerArgs>\n    ? TestType<TestArgs & WorldFixture<W>, WorkerArgs>\n    : never\n\n/**\n * Adds a `world` fixture to any Playwright-shaped `test` — plain\n * `@playwright/test` or playwright-bdd's.\n *\n * ```ts\n * export const test = withWorld<World, typeof apiTest>(apiTest)\n * const { Given, When, Then } = createBdd(test)\n * ```\n */\nexport function withWorld<W, T>(base: T): WithWorld<T, W> {\n  const extended = (base as AnyTestType).extend<WorldFixture<W>>({\n    // Playwright requires the object-destructuring pattern here: it reads the\n    // destructured names to work out what this fixture depends on, and rejects a\n    // plain parameter outright. Empty means it depends on nothing.\n    world: async ({}, use: (value: Partial<W>) => Promise<void>) => {\n      await use(createWorld<W>())\n    },\n  })\n  return extended as unknown as WithWorld<T, W>\n}\n"]}

package/dist/playwright-bdd.d.ts

@@ -0,0 +1,29 @@
+import type { TestType } from '@playwright/test';
+/**
+ * A scenario-scoped bag for the pages a Gherkin scenario builds up.
+ *
+ * Steps are separate functions, so the obvious place to put a harness is a
+ * module-level `let` — which breaks the moment Playwright reuses a worker,
+ * because the next scenario inherits the last one's state. A fixture is
+ * per-scenario, so it cannot leak.
+ */
+export interface WorldFixture<W> {
+    world: Partial<W>;
+}
+/**
+ * The base test type with the world fixture added. Written as a conditional so
+ * the base's own fixtures survive — returning the base type unchanged would make
+ * `world` invisible to every step that destructures it.
+ */
+export type WithWorld<T, W> = T extends TestType<infer TestArgs, infer WorkerArgs> ? TestType<TestArgs & WorldFixture<W>, WorkerArgs> : never;
+/**
+ * Adds a `world` fixture to any Playwright-shaped `test` — plain
+ * `@playwright/test` or playwright-bdd's.
+ *
+ * ```ts
+ * export const test = withWorld<World, typeof apiTest>(apiTest)
+ * const { Given, When, Then } = createBdd(test)
+ * ```
+ */
+export declare function withWorld<W, T>(base: T): WithWorld<T, W>;
+//# sourceMappingURL=playwright-bdd.d.ts.map

package/dist/playwright-bdd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwright-bdd.d.ts","sourceRoot":"","sources":["../src/playwright-bdd.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGhD;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;CAClB;AAaD;;;;GAIG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,IACxB,CAAC,SAAS,QAAQ,CAAC,MAAM,QAAQ,EAAE,MAAM,UAAU,CAAC,GAChD,QAAQ,CAAC,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,GAChD,KAAK,CAAA;AAEX;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAUxD"}

package/dist/playwright-bdd.js

@@ -0,0 +1,18 @@
+import { createWorld } from './chunk-6AIO5EWN.js';
+
+// src/playwright-bdd.ts
+function withWorld(base) {
+  const extended = base.extend({
+    // Playwright requires the object-destructuring pattern here: it reads the
+    // destructured names to work out what this fixture depends on, and rejects a
+    // plain parameter outright. Empty means it depends on nothing.
+    world: async ({}, use) => {
+      await use(createWorld());
+    }
+  });
+  return extended;
+}
+
+export { withWorld };
+//# sourceMappingURL=playwright-bdd.js.map
+//# sourceMappingURL=playwright-bdd.js.map

package/dist/playwright-bdd.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/playwright-bdd.ts"],"names":[],"mappings":";;;AA6CO,SAAS,UAAgB,IAAA,EAA0B;AACxD,EAAA,MAAM,QAAA,GAAY,KAAqB,MAAA,CAAwB;AAAA;AAAA;AAAA;AAAA,IAI7D,KAAA,EAAO,OAAO,EAAC,EAAG,GAAA,KAA8C;AAC9D,MAAA,MAAM,GAAA,CAAI,aAAgB,CAAA;AAAA,IAC5B;AAAA,GACD,CAAA;AACD,EAAA,OAAO,QAAA;AACT","file":"playwright-bdd.js","sourcesContent":["import type { TestType } from '@playwright/test'\nimport { createWorld } from './index'\n\n/**\n * A scenario-scoped bag for the pages a Gherkin scenario builds up.\n *\n * Steps are separate functions, so the obvious place to put a harness is a\n * module-level `let` — which breaks the moment Playwright reuses a worker,\n * because the next scenario inherits the last one's state. A fixture is\n * per-scenario, so it cannot leak.\n */\nexport interface WorldFixture<W> {\n  world: Partial<W>\n}\n\n/**\n * A structural stand-in for \"some Playwright test object\", used to call `extend`.\n *\n * Deliberately not used as a bound on `withWorld`'s `T`. Playwright's real\n * `TestType` is not assignable to this one — its concrete fixture args do not\n * satisfy an index-signature record — so constraining `T` rejects the very thing\n * callers pass. The conditional return type is what gives misuse a readable\n * error instead.\n */\ntype AnyTestType = TestType<Record<string, unknown>, Record<string, unknown>>\n\n/**\n * The base test type with the world fixture added. Written as a conditional so\n * the base's own fixtures survive — returning the base type unchanged would make\n * `world` invisible to every step that destructures it.\n */\nexport type WithWorld<T, W> =\n  T extends TestType<infer TestArgs, infer WorkerArgs>\n    ? TestType<TestArgs & WorldFixture<W>, WorkerArgs>\n    : never\n\n/**\n * Adds a `world` fixture to any Playwright-shaped `test` — plain\n * `@playwright/test` or playwright-bdd's.\n *\n * ```ts\n * export const test = withWorld<World, typeof apiTest>(apiTest)\n * const { Given, When, Then } = createBdd(test)\n * ```\n */\nexport function withWorld<W, T>(base: T): WithWorld<T, W> {\n  const extended = (base as AnyTestType).extend<WorldFixture<W>>({\n    // Playwright requires the object-destructuring pattern here: it reads the\n    // destructured names to work out what this fixture depends on, and rejects a\n    // plain parameter outright. Empty means it depends on nothing.\n    world: async ({}, use: (value: Partial<W>) => Promise<void>) => {\n      await use(createWorld<W>())\n    },\n  })\n  return extended as unknown as WithWorld<T, W>\n}\n"]}

package/dist/yadda.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+var Yadda = require('yadda');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Yadda__default = /*#__PURE__*/_interopDefault(Yadda);
+
+// src/yadda.ts
+
+// src/index.ts
+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 {};
+}
+
+// src/yadda.ts
+var extended = /* @__PURE__ */ new WeakMap();
+function pageDictionary(registry, options = {}) {
+  const { regexp, transformer } = pageParameter(registry);
+  const term = options.term ?? "page";
+  const dictionary = options.dictionary ?? new Yadda__default.default.Dictionary();
+  const pattern = `(${regexp.source})`;
+  const terms = extended.get(dictionary) ?? /* @__PURE__ */ new Map();
+  extended.set(dictionary, terms);
+  const existing = terms.get(term);
+  if (existing === pattern) return dictionary;
+  if (existing !== void 0) {
+    throw new Error(
+      `harnessed: this dictionary already defines $${term} with other pages. Give the second registry its own term.`
+    );
+  }
+  const convert = (match, next, ..._unused) => {
+    if (typeof match !== "string" || typeof next !== "function") {
+      throw new Error(`harnessed: $${term} expects one capture and Yadda's callback.`);
+    }
+    let page;
+    try {
+      page = transformer(match);
+    } catch (error) {
+      next(error);
+      return;
+    }
+    next(null, page);
+  };
+  dictionary.define(term, pattern, convert);
+  terms.set(term, pattern);
+  return dictionary;
+}
+function yaddaWorld() {
+  return {
+    steps(options) {
+      return createSteps(options);
+    }
+  };
+}
+function createSteps(options) {
+  const { pages, env } = options;
+  const language = options.language ?? Yadda__default.default.localisation.English;
+  const library = language.localise(
+    new Yadda__default.default.ContextParamLibrary(options.dictionary ?? pageDictionary(pages))
+  );
+  const world = createWorld();
+  const open = (name) => pages.open(name, env());
+  const wrap = (step) => async (context, ...rest) => {
+    await step({ world, open, context }, ...rest.slice(0, -1));
+  };
+  const promise = { mode: "promise" };
+  const anyKeyword = `(?:${["given", "when", "then"].map((keyword) => language.translate(keyword)).join("|")})`;
+  return {
+    world,
+    library,
+    given(signature, step) {
+      library.given(signature, wrap(step), void 0, promise);
+      return this;
+    },
+    when(signature, step) {
+      library.when(signature, wrap(step), void 0, promise);
+      return this;
+    },
+    then(signature, step) {
+      library.then(signature, wrap(step), void 0, promise);
+      return this;
+    },
+    step(signature, step) {
+      const signatures = Array.isArray(signature) ? signature : [signature];
+      library.define(
+        signatures.map((one) => withKeyword(anyKeyword, one)),
+        wrap(step),
+        void 0,
+        promise
+      );
+      return this;
+    }
+  };
+}
+function withKeyword(keyword, signature) {
+  const source = signature instanceof RegExp ? signature.source : signature;
+  return `^(?:\\s)*${keyword}\\s+${source.replace(/^\^/, "")}`;
+}
+
+exports.pageDictionary = pageDictionary;
+exports.yaddaWorld = yaddaWorld;
+//# sourceMappingURL=yadda.cjs.map
+//# sourceMappingURL=yadda.cjs.map

package/dist/yadda.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/yadda.ts"],"names":["Yadda"],"mappings":"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","file":"yadda.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 type { EnvConfig } from '@harnessed-ts/core'\nimport Yadda from 'yadda'\nimport { createWorld, pageParameter } from './index'\nimport type { PageMap, PageRegistry } from './index'\n\n/**\n * The page terms each dictionary was given, and the pattern each one matches.\n * Yadda refuses to define a term twice, and ember-cli-yadda calls a steps\n * module's default export once per scenario, so extending a module-level\n * dictionary there would throw from the second scenario on. Copying it instead\n * is no answer: Yadda's `merge` drops converters.\n */\nconst extended = new WeakMap<Yadda.Dictionary, Map<string, string>>()\n\n/**\n * A Yadda dictionary with a `$page` term built from a page registry — the same\n * names and pattern as `{page}`, so the two cannot drift. A step reading\n * `I open the $page page` matches only a registered name (longest first), and a\n * feature naming an unknown page fails as an undefined step, where the typo is.\n *\n * Pass `dictionary` to add the term to one that already defines others, and\n * `term` to call it something else. Adding the same term to the same dictionary\n * again returns it unchanged, so it is safe inside a per-scenario steps function.\n */\nexport function pageDictionary<P extends PageMap>(\n  registry: PageRegistry<P>,\n  options: { term?: string; dictionary?: Yadda.Dictionary } = {},\n): Yadda.Dictionary {\n  const { regexp, transformer } = pageParameter(registry)\n  const term = options.term ?? 'page'\n  const dictionary = options.dictionary ?? new Yadda.Dictionary()\n  const pattern = `(${regexp.source})`\n  const terms = extended.get(dictionary) ?? new Map<string, string>()\n  extended.set(dictionary, terms)\n  const existing = terms.get(term)\n  if (existing === pattern) return dictionary\n  if (existing !== undefined) {\n    throw new Error(\n      `harnessed: this dictionary already defines $${term} with other pages. ` +\n        'Give the second registry its own term.',\n    )\n  }\n  // A callback converter, not an async one: Yadda tells an async converter by\n  // its constructor's name, which a transpiler that rewrites async functions (an\n  // Ember build's Babel) changes. A callback converter's captures are its arity\n  // less the callback, so this names exactly two parameters and checks them;\n  // they are optional, and the rest parameter there, only because Yadda types a\n  // callback converter as any number of captures followed by the callback.\n  const convert = (\n    match?: string | Yadda.ConverterCallback,\n    next?: string | Yadda.ConverterCallback,\n    ..._unused: Array<string | Yadda.ConverterCallback>\n  ): void => {\n    if (typeof match !== 'string' || typeof next !== 'function') {\n      throw new Error(`harnessed: $${term} expects one capture and Yadda's callback.`)\n    }\n    let page: keyof P & string\n    try {\n      page = transformer(match)\n    } catch (error) {\n      next(error)\n      return\n    }\n    next(null, page)\n  }\n  dictionary.define(term, pattern, convert)\n  terms.set(term, pattern)\n  return dictionary\n}\n\n/** What a harnessed Yadda step receives first. */\nexport interface YaddaScenario<W, P extends PageMap> {\n  /** The scenario's bag: empty when the scenario starts, shared by its steps. */\n  readonly world: Partial<W>\n  /** Constructs a registered page with the scenario's env. */\n  open<N extends keyof P & string>(name: N): InstanceType<P[N]>\n  /**\n   * Yadda's own context for the step: `step` (the line being run) and whatever\n   * the runner passed in — ember-cli-yadda's `ctx`, and the QUnit test context.\n   */\n  readonly context: Readonly<Record<string, unknown>>\n}\n\n/** A step: the scenario first, then the values its signature captured. */\nexport type YaddaStep<W, P extends PageMap, A extends unknown[]> = (\n  scenario: YaddaScenario<W, P>,\n  ...args: A\n) => unknown\n\nexport interface YaddaStepsOptions<P extends PageMap> {\n  /** The pages features can name. Defines `$page` unless `dictionary` is given. */\n  pages: PageRegistry<P>\n  /**\n   * The env pages are built with. Called each time a step opens a page, so it\n   * can read per-test state — `() => ember()` in an application test.\n   */\n  env: () => EnvConfig\n  /** The dictionary signatures expand against. Defaults to `pageDictionary(pages)`. */\n  dictionary?: Yadda.Dictionary\n  /** The step keywords' language. Defaults to English. */\n  language?: Yadda.Language\n}\n\n/** A step library whose steps share one world. */\nexport interface YaddaSteps<W, P extends PageMap> {\n  /** The world this library's steps share. */\n  readonly world: Partial<W>\n  /** The Yadda library to run: what an ember-cli-yadda steps module returns. */\n  readonly library: Yadda.BaseLibrary\n  given<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this\n  when<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this\n  then<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this\n  /** A step that matches after any keyword: `Given`, `When`, `Then`, `And`, `But`. */\n  step<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this\n}\n\n/** Fixes the world's type; `steps` then infers the pages from the registry. */\nexport interface YaddaWorld<W> {\n  /** A fresh step library with a fresh, empty world. Build one per scenario. */\n  steps<P extends PageMap>(options: YaddaStepsOptions<P>): YaddaSteps<W, P>\n}\n\n/**\n * Yadda steps with a scenario-scoped world and the page registry. Steps are\n * plain (arrow) functions taking the scenario first, then what their signature\n * captured; every step is awaited.\n *\n * The world belongs to the library `steps()` builds, so build one per scenario —\n * which is what ember-cli-yadda already does: it calls a steps module's default\n * export inside each scenario's test.\n *\n * ```ts\n * // tests/acceptance/steps/checkout-steps.ts\n * const pages = definePages({ checkout: CheckoutPage })\n * const checkout = yaddaWorld<{ checkout: CheckoutPage }>()\n *\n * export default function (assert: Assert) {\n *   const steps = checkout.steps({ pages, env: () => ember() })\n *   steps.when('I open the $page page', async ({ world, open }, name: 'checkout') => {\n *     world.checkout = open(name)\n *     await world.checkout.goto()\n *   })\n *   return steps.library\n * }\n * ```\n *\n * The world's type is a call of its own because TypeScript cannot take one type\n * argument explicitly and infer another; `steps` infers the pages.\n */\nexport function yaddaWorld<W = Record<string, unknown>>(): YaddaWorld<W> {\n  return {\n    steps<P extends PageMap>(options: YaddaStepsOptions<P>) {\n      return createSteps<W, P>(options)\n    },\n  }\n}\n\nfunction createSteps<W, P extends PageMap>(options: YaddaStepsOptions<P>): YaddaSteps<W, P> {\n  const { pages, env } = options\n  const language = options.language ?? Yadda.localisation.English\n  const library = language.localise(\n    new Yadda.ContextParamLibrary(options.dictionary ?? pageDictionary(pages)),\n  )\n  const world = createWorld<W>()\n  const open = <N extends keyof P & string>(name: N): InstanceType<P[N]> => pages.open(name, env())\n\n  // Yadda passes the step's context first and, in promise mode, its completion\n  // callback last; a harnessed step sees neither, only the scenario and the\n  // captured values. Promise mode is explicit so Yadda never guesses from the\n  // wrapper's arity.\n  const wrap =\n    <A extends unknown[]>(step: YaddaStep<W, P, A>) =>\n    async (context: Record<string, unknown>, ...rest: unknown[]): Promise<void> => {\n      await step({ world, open, context }, ...(rest.slice(0, -1) as A))\n    }\n  const promise: Yadda.DefineOptions = { mode: 'promise' }\n\n  // Every step keyword the language has, as one alternation: `the world is\n  // empty` is the same step after `Given` as after `Then`.\n  const anyKeyword = `(?:${['given', 'when', 'then'].map(keyword => language.translate(keyword)).join('|')})`\n\n  return {\n    world,\n    library,\n    given(signature, step) {\n      library.given(signature, wrap(step), undefined, promise)\n      return this\n    },\n    when(signature, step) {\n      library.when(signature, wrap(step), undefined, promise)\n      return this\n    },\n    then(signature, step) {\n      library.then(signature, wrap(step), undefined, promise)\n      return this\n    },\n    step(signature, step) {\n      const signatures = Array.isArray(signature) ? signature : [signature]\n      library.define(\n        signatures.map(one => withKeyword(anyKeyword, one)),\n        wrap(step),\n        undefined,\n        promise,\n      )\n      return this\n    },\n  }\n}\n\n/** Prefixes a signature with a keyword pattern, the way a Yadda language does. */\nfunction withKeyword(keyword: string, signature: string | RegExp): string {\n  const source = signature instanceof RegExp ? signature.source : signature\n  return `^(?:\\\\s)*${keyword}\\\\s+${source.replace(/^\\^/, '')}`\n}\n"]}

package/dist/yadda.d.ts

@@ -0,0 +1,90 @@
+import type { EnvConfig } from '@harnessed-ts/core';
+import Yadda from 'yadda';
+import type { PageMap, PageRegistry } from './index';
+/**
+ * A Yadda dictionary with a `$page` term built from a page registry — the same
+ * names and pattern as `{page}`, so the two cannot drift. A step reading
+ * `I open the $page page` matches only a registered name (longest first), and a
+ * feature naming an unknown page fails as an undefined step, where the typo is.
+ *
+ * Pass `dictionary` to add the term to one that already defines others, and
+ * `term` to call it something else. Adding the same term to the same dictionary
+ * again returns it unchanged, so it is safe inside a per-scenario steps function.
+ */
+export declare function pageDictionary<P extends PageMap>(registry: PageRegistry<P>, options?: {
+    term?: string;
+    dictionary?: Yadda.Dictionary;
+}): Yadda.Dictionary;
+/** What a harnessed Yadda step receives first. */
+export interface YaddaScenario<W, P extends PageMap> {
+    /** The scenario's bag: empty when the scenario starts, shared by its steps. */
+    readonly world: Partial<W>;
+    /** Constructs a registered page with the scenario's env. */
+    open<N extends keyof P & string>(name: N): InstanceType<P[N]>;
+    /**
+     * Yadda's own context for the step: `step` (the line being run) and whatever
+     * the runner passed in — ember-cli-yadda's `ctx`, and the QUnit test context.
+     */
+    readonly context: Readonly<Record<string, unknown>>;
+}
+/** A step: the scenario first, then the values its signature captured. */
+export type YaddaStep<W, P extends PageMap, A extends unknown[]> = (scenario: YaddaScenario<W, P>, ...args: A) => unknown;
+export interface YaddaStepsOptions<P extends PageMap> {
+    /** The pages features can name. Defines `$page` unless `dictionary` is given. */
+    pages: PageRegistry<P>;
+    /**
+     * The env pages are built with. Called each time a step opens a page, so it
+     * can read per-test state — `() => ember()` in an application test.
+     */
+    env: () => EnvConfig;
+    /** The dictionary signatures expand against. Defaults to `pageDictionary(pages)`. */
+    dictionary?: Yadda.Dictionary;
+    /** The step keywords' language. Defaults to English. */
+    language?: Yadda.Language;
+}
+/** A step library whose steps share one world. */
+export interface YaddaSteps<W, P extends PageMap> {
+    /** The world this library's steps share. */
+    readonly world: Partial<W>;
+    /** The Yadda library to run: what an ember-cli-yadda steps module returns. */
+    readonly library: Yadda.BaseLibrary;
+    given<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this;
+    when<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this;
+    then<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this;
+    /** A step that matches after any keyword: `Given`, `When`, `Then`, `And`, `But`. */
+    step<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this;
+}
+/** Fixes the world's type; `steps` then infers the pages from the registry. */
+export interface YaddaWorld<W> {
+    /** A fresh step library with a fresh, empty world. Build one per scenario. */
+    steps<P extends PageMap>(options: YaddaStepsOptions<P>): YaddaSteps<W, P>;
+}
+/**
+ * Yadda steps with a scenario-scoped world and the page registry. Steps are
+ * plain (arrow) functions taking the scenario first, then what their signature
+ * captured; every step is awaited.
+ *
+ * The world belongs to the library `steps()` builds, so build one per scenario —
+ * which is what ember-cli-yadda already does: it calls a steps module's default
+ * export inside each scenario's test.
+ *
+ * ```ts
+ * // tests/acceptance/steps/checkout-steps.ts
+ * const pages = definePages({ checkout: CheckoutPage })
+ * const checkout = yaddaWorld<{ checkout: CheckoutPage }>()
+ *
+ * export default function (assert: Assert) {
+ *   const steps = checkout.steps({ pages, env: () => ember() })
+ *   steps.when('I open the $page page', async ({ world, open }, name: 'checkout') => {
+ *     world.checkout = open(name)
+ *     await world.checkout.goto()
+ *   })
+ *   return steps.library
+ * }
+ * ```
+ *
+ * The world's type is a call of its own because TypeScript cannot take one type
+ * argument explicitly and infer another; `steps` infers the pages.
+ */
+export declare function yaddaWorld<W = Record<string, unknown>>(): YaddaWorld<W>;
+//# sourceMappingURL=yadda.d.ts.map

package/dist/yadda.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yadda.d.ts","sourceRoot":"","sources":["../src/yadda.ts"],"names":[],"mappings":"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"}

package/dist/yadda.js

@@ -0,0 +1,90 @@
+import { pageParameter, createWorld } from './chunk-6AIO5EWN.js';
+import Yadda from 'yadda';
+
+var extended = /* @__PURE__ */ new WeakMap();
+function pageDictionary(registry, options = {}) {
+  const { regexp, transformer } = pageParameter(registry);
+  const term = options.term ?? "page";
+  const dictionary = options.dictionary ?? new Yadda.Dictionary();
+  const pattern = `(${regexp.source})`;
+  const terms = extended.get(dictionary) ?? /* @__PURE__ */ new Map();
+  extended.set(dictionary, terms);
+  const existing = terms.get(term);
+  if (existing === pattern) return dictionary;
+  if (existing !== void 0) {
+    throw new Error(
+      `harnessed: this dictionary already defines $${term} with other pages. Give the second registry its own term.`
+    );
+  }
+  const convert = (match, next, ..._unused) => {
+    if (typeof match !== "string" || typeof next !== "function") {
+      throw new Error(`harnessed: $${term} expects one capture and Yadda's callback.`);
+    }
+    let page;
+    try {
+      page = transformer(match);
+    } catch (error) {
+      next(error);
+      return;
+    }
+    next(null, page);
+  };
+  dictionary.define(term, pattern, convert);
+  terms.set(term, pattern);
+  return dictionary;
+}
+function yaddaWorld() {
+  return {
+    steps(options) {
+      return createSteps(options);
+    }
+  };
+}
+function createSteps(options) {
+  const { pages, env } = options;
+  const language = options.language ?? Yadda.localisation.English;
+  const library = language.localise(
+    new Yadda.ContextParamLibrary(options.dictionary ?? pageDictionary(pages))
+  );
+  const world = createWorld();
+  const open = (name) => pages.open(name, env());
+  const wrap = (step) => async (context, ...rest) => {
+    await step({ world, open, context }, ...rest.slice(0, -1));
+  };
+  const promise = { mode: "promise" };
+  const anyKeyword = `(?:${["given", "when", "then"].map((keyword) => language.translate(keyword)).join("|")})`;
+  return {
+    world,
+    library,
+    given(signature, step) {
+      library.given(signature, wrap(step), void 0, promise);
+      return this;
+    },
+    when(signature, step) {
+      library.when(signature, wrap(step), void 0, promise);
+      return this;
+    },
+    then(signature, step) {
+      library.then(signature, wrap(step), void 0, promise);
+      return this;
+    },
+    step(signature, step) {
+      const signatures = Array.isArray(signature) ? signature : [signature];
+      library.define(
+        signatures.map((one) => withKeyword(anyKeyword, one)),
+        wrap(step),
+        void 0,
+        promise
+      );
+      return this;
+    }
+  };
+}
+function withKeyword(keyword, signature) {
+  const source = signature instanceof RegExp ? signature.source : signature;
+  return `^(?:\\s)*${keyword}\\s+${source.replace(/^\^/, "")}`;
+}
+
+export { pageDictionary, yaddaWorld };
+//# sourceMappingURL=yadda.js.map
+//# sourceMappingURL=yadda.js.map

package/dist/yadda.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/yadda.ts"],"names":[],"mappings":"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","file":"yadda.js","sourcesContent":["import type { EnvConfig } from '@harnessed-ts/core'\nimport Yadda from 'yadda'\nimport { createWorld, pageParameter } from './index'\nimport type { PageMap, PageRegistry } from './index'\n\n/**\n * The page terms each dictionary was given, and the pattern each one matches.\n * Yadda refuses to define a term twice, and ember-cli-yadda calls a steps\n * module's default export once per scenario, so extending a module-level\n * dictionary there would throw from the second scenario on. Copying it instead\n * is no answer: Yadda's `merge` drops converters.\n */\nconst extended = new WeakMap<Yadda.Dictionary, Map<string, string>>()\n\n/**\n * A Yadda dictionary with a `$page` term built from a page registry — the same\n * names and pattern as `{page}`, so the two cannot drift. A step reading\n * `I open the $page page` matches only a registered name (longest first), and a\n * feature naming an unknown page fails as an undefined step, where the typo is.\n *\n * Pass `dictionary` to add the term to one that already defines others, and\n * `term` to call it something else. Adding the same term to the same dictionary\n * again returns it unchanged, so it is safe inside a per-scenario steps function.\n */\nexport function pageDictionary<P extends PageMap>(\n  registry: PageRegistry<P>,\n  options: { term?: string; dictionary?: Yadda.Dictionary } = {},\n): Yadda.Dictionary {\n  const { regexp, transformer } = pageParameter(registry)\n  const term = options.term ?? 'page'\n  const dictionary = options.dictionary ?? new Yadda.Dictionary()\n  const pattern = `(${regexp.source})`\n  const terms = extended.get(dictionary) ?? new Map<string, string>()\n  extended.set(dictionary, terms)\n  const existing = terms.get(term)\n  if (existing === pattern) return dictionary\n  if (existing !== undefined) {\n    throw new Error(\n      `harnessed: this dictionary already defines $${term} with other pages. ` +\n        'Give the second registry its own term.',\n    )\n  }\n  // A callback converter, not an async one: Yadda tells an async converter by\n  // its constructor's name, which a transpiler that rewrites async functions (an\n  // Ember build's Babel) changes. A callback converter's captures are its arity\n  // less the callback, so this names exactly two parameters and checks them;\n  // they are optional, and the rest parameter there, only because Yadda types a\n  // callback converter as any number of captures followed by the callback.\n  const convert = (\n    match?: string | Yadda.ConverterCallback,\n    next?: string | Yadda.ConverterCallback,\n    ..._unused: Array<string | Yadda.ConverterCallback>\n  ): void => {\n    if (typeof match !== 'string' || typeof next !== 'function') {\n      throw new Error(`harnessed: $${term} expects one capture and Yadda's callback.`)\n    }\n    let page: keyof P & string\n    try {\n      page = transformer(match)\n    } catch (error) {\n      next(error)\n      return\n    }\n    next(null, page)\n  }\n  dictionary.define(term, pattern, convert)\n  terms.set(term, pattern)\n  return dictionary\n}\n\n/** What a harnessed Yadda step receives first. */\nexport interface YaddaScenario<W, P extends PageMap> {\n  /** The scenario's bag: empty when the scenario starts, shared by its steps. */\n  readonly world: Partial<W>\n  /** Constructs a registered page with the scenario's env. */\n  open<N extends keyof P & string>(name: N): InstanceType<P[N]>\n  /**\n   * Yadda's own context for the step: `step` (the line being run) and whatever\n   * the runner passed in — ember-cli-yadda's `ctx`, and the QUnit test context.\n   */\n  readonly context: Readonly<Record<string, unknown>>\n}\n\n/** A step: the scenario first, then the values its signature captured. */\nexport type YaddaStep<W, P extends PageMap, A extends unknown[]> = (\n  scenario: YaddaScenario<W, P>,\n  ...args: A\n) => unknown\n\nexport interface YaddaStepsOptions<P extends PageMap> {\n  /** The pages features can name. Defines `$page` unless `dictionary` is given. */\n  pages: PageRegistry<P>\n  /**\n   * The env pages are built with. Called each time a step opens a page, so it\n   * can read per-test state — `() => ember()` in an application test.\n   */\n  env: () => EnvConfig\n  /** The dictionary signatures expand against. Defaults to `pageDictionary(pages)`. */\n  dictionary?: Yadda.Dictionary\n  /** The step keywords' language. Defaults to English. */\n  language?: Yadda.Language\n}\n\n/** A step library whose steps share one world. */\nexport interface YaddaSteps<W, P extends PageMap> {\n  /** The world this library's steps share. */\n  readonly world: Partial<W>\n  /** The Yadda library to run: what an ember-cli-yadda steps module returns. */\n  readonly library: Yadda.BaseLibrary\n  given<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this\n  when<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this\n  then<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this\n  /** A step that matches after any keyword: `Given`, `When`, `Then`, `And`, `But`. */\n  step<A extends unknown[]>(signature: Yadda.Signature, step: YaddaStep<W, P, A>): this\n}\n\n/** Fixes the world's type; `steps` then infers the pages from the registry. */\nexport interface YaddaWorld<W> {\n  /** A fresh step library with a fresh, empty world. Build one per scenario. */\n  steps<P extends PageMap>(options: YaddaStepsOptions<P>): YaddaSteps<W, P>\n}\n\n/**\n * Yadda steps with a scenario-scoped world and the page registry. Steps are\n * plain (arrow) functions taking the scenario first, then what their signature\n * captured; every step is awaited.\n *\n * The world belongs to the library `steps()` builds, so build one per scenario —\n * which is what ember-cli-yadda already does: it calls a steps module's default\n * export inside each scenario's test.\n *\n * ```ts\n * // tests/acceptance/steps/checkout-steps.ts\n * const pages = definePages({ checkout: CheckoutPage })\n * const checkout = yaddaWorld<{ checkout: CheckoutPage }>()\n *\n * export default function (assert: Assert) {\n *   const steps = checkout.steps({ pages, env: () => ember() })\n *   steps.when('I open the $page page', async ({ world, open }, name: 'checkout') => {\n *     world.checkout = open(name)\n *     await world.checkout.goto()\n *   })\n *   return steps.library\n * }\n * ```\n *\n * The world's type is a call of its own because TypeScript cannot take one type\n * argument explicitly and infer another; `steps` infers the pages.\n */\nexport function yaddaWorld<W = Record<string, unknown>>(): YaddaWorld<W> {\n  return {\n    steps<P extends PageMap>(options: YaddaStepsOptions<P>) {\n      return createSteps<W, P>(options)\n    },\n  }\n}\n\nfunction createSteps<W, P extends PageMap>(options: YaddaStepsOptions<P>): YaddaSteps<W, P> {\n  const { pages, env } = options\n  const language = options.language ?? Yadda.localisation.English\n  const library = language.localise(\n    new Yadda.ContextParamLibrary(options.dictionary ?? pageDictionary(pages)),\n  )\n  const world = createWorld<W>()\n  const open = <N extends keyof P & string>(name: N): InstanceType<P[N]> => pages.open(name, env())\n\n  // Yadda passes the step's context first and, in promise mode, its completion\n  // callback last; a harnessed step sees neither, only the scenario and the\n  // captured values. Promise mode is explicit so Yadda never guesses from the\n  // wrapper's arity.\n  const wrap =\n    <A extends unknown[]>(step: YaddaStep<W, P, A>) =>\n    async (context: Record<string, unknown>, ...rest: unknown[]): Promise<void> => {\n      await step({ world, open, context }, ...(rest.slice(0, -1) as A))\n    }\n  const promise: Yadda.DefineOptions = { mode: 'promise' }\n\n  // Every step keyword the language has, as one alternation: `the world is\n  // empty` is the same step after `Given` as after `Then`.\n  const anyKeyword = `(?:${['given', 'when', 'then'].map(keyword => language.translate(keyword)).join('|')})`\n\n  return {\n    world,\n    library,\n    given(signature, step) {\n      library.given(signature, wrap(step), undefined, promise)\n      return this\n    },\n    when(signature, step) {\n      library.when(signature, wrap(step), undefined, promise)\n      return this\n    },\n    then(signature, step) {\n      library.then(signature, wrap(step), undefined, promise)\n      return this\n    },\n    step(signature, step) {\n      const signatures = Array.isArray(signature) ? signature : [signature]\n      library.define(\n        signatures.map(one => withKeyword(anyKeyword, one)),\n        wrap(step),\n        undefined,\n        promise,\n      )\n      return this\n    },\n  }\n}\n\n/** Prefixes a signature with a keyword pattern, the way a Yadda language does. */\nfunction withKeyword(keyword: string, signature: string | RegExp): string {\n  const source = signature instanceof RegExp ? signature.source : signature\n  return `^(?:\\\\s)*${keyword}\\\\s+${source.replace(/^\\^/, '')}`\n}\n"]}

package/package.json

@@ -1,6 +1,111 @@
 {
   "name": "@harnessed-ts/gherkin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.6.0",
+  "description": "Gherkin support for harnessed: a scenario-scoped world, a typed page registry and a {page} parameter type, with adapters for playwright-bdd, cucumber-js, Cypress cucumber and ember-cli-yadda.",
+  "keywords": [
+    "testing",
+    "harness",
+    "gherkin",
+    "cucumber",
+    "bdd",
+    "playwright-bdd"
+  ],
+  "license": "MIT",
+  "contributors": [
+    {
+      "name": "Joe Gaudet",
+      "url": "https://github.com/joegaudet"
+    },
+    {
+      "name": "Jay Seo",
+      "url": "https://github.com/jayseo5953"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/joegaudet/harnessed.git",
+    "directory": "packages/gherkin"
+  },
+  "homepage": "https://github.com/joegaudet/harnessed#readme",
+  "bugs": "https://github.com/joegaudet/harnessed/issues",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./playwright-bdd": {
+      "types": "./dist/playwright-bdd.d.ts",
+      "import": "./dist/playwright-bdd.js",
+      "require": "./dist/playwright-bdd.cjs"
+    },
+    "./cucumber": {
+      "types": "./dist/cucumber.d.ts",
+      "import": "./dist/cucumber.js",
+      "require": "./dist/cucumber.cjs"
+    },
+    "./cypress": {
+      "types": "./dist/cypress.d.ts",
+      "import": "./dist/cypress.js",
+      "require": "./dist/cypress.cjs"
+    },
+    "./yadda": {
+      "types": "./dist/yadda.d.ts",
+      "import": "./dist/yadda.js",
+      "require": "./dist/yadda.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "dependencies": {
+    "@harnessed-ts/core": "^0.6.0"
+  },
+  "peerDependencies": {
+    "@badeball/cypress-cucumber-preprocessor": ">=20",
+    "@cucumber/cucumber": ">=10",
+    "@playwright/test": ">=1.43",
+    "yadda": ">=3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@cucumber/cucumber": "~13.2.1",
+    "@cucumber/cucumber-expressions": "~20.0.0",
+    "@playwright/test": "^1.63.0",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.3",
+    "yadda": "^3.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    },
+    "@cucumber/cucumber": {
+      "optional": true
+    },
+    "@badeball/cypress-cucumber-preprocessor": {
+      "optional": true
+    },
+    "yadda": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "test": "vitest run"
+  }
 }