@step-forge/step-forge 0.0.20 → 0.0.22

package/dist/gherkinParser-NcttZgN4.js

@@ -0,0 +1,259 @@
+import _ from "lodash";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { glob, stat } from "node:fs/promises";
+import * as fs from "node:fs";
+import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
+import * as messages from "@cucumber/messages";
+//#region src/sourceLocation.ts
+/**
+* Directory holding the library's own compiled code. In development this is the
+* `src/` tree; in the published package it's `dist/` (this module is bundled
+* into the shipped chunks). Stack frames under it are internal plumbing —
+* builders, the engine, the runner — and are hidden from users so that a
+* failure points at *their* step, not ours.
+*/
+const LIB_ROOT = path.dirname(fileURLToPath(import.meta.url));
+/**
+* A frame belongs to user code if it's an absolute path that is neither inside
+* the library nor inside any `node_modules` (assertion libs, etc.). That leaves
+* exactly the frames a user cares about: their own step definitions.
+*/
+function isUserFile(file) {
+	return path.isAbsolute(file) && !file.startsWith(LIB_ROOT + path.sep) && !file.includes(`${path.sep}node_modules${path.sep}`);
+}
+/** Parse one `Error.stack` line into a frame, tolerating V8/Bun variations. */
+function parseFrame(frameLine) {
+	const m = /:(\d+):(\d+)\)?\s*$/.exec(frameLine);
+	if (!m) return void 0;
+	let file = frameLine.slice(0, m.index);
+	const paren = file.lastIndexOf("(");
+	if (paren !== -1) file = file.slice(paren + 1);
+	file = file.trim().replace(/^at\s+/, "");
+	if (file.startsWith("file://")) try {
+		file = fileURLToPath(file);
+	} catch {
+		return;
+	}
+	return {
+		file,
+		line: Number(m[1]),
+		column: Number(m[2])
+	};
+}
+/** Every user-code frame in a stack, nearest-first, internals removed. */
+function userFrames(stack) {
+	if (!stack) return [];
+	const frames = [];
+	for (const line of stack.split("\n")) {
+		const frame = parseFrame(line);
+		if (frame && isUserFile(frame.file)) frames.push(frame);
+	}
+	return frames;
+}
+/**
+* Capture the user source location of the current call site — the first
+* user-code frame above this function. Called from `.step()` registration so
+* each step remembers where it was defined (Cucumber-style), independent of
+* where an error is later thrown. Returns an absolute `file:line:column`, or
+* `undefined` if no user frame is visible.
+*/
+function captureDefinitionSite() {
+	const frame = userFrames((/* @__PURE__ */ new Error()).stack)[0];
+	return frame ? `${frame.file}:${frame.line}:${frame.column}` : void 0;
+}
+/** Render an absolute `file:line:column` relative to `cwd` for display. */
+function relativeLocation(location, cwd) {
+	const m = /^(.*):(\d+):(\d+)$/.exec(location);
+	if (!m) return location;
+	return `${path.relative(cwd, m[1])}:${m[2]}:${m[3]}`;
+}
+/** Render a frame relative to `cwd`. */
+function relativeFrame(frame, cwd) {
+	return `${path.relative(cwd, frame.file)}:${frame.line}:${frame.column}`;
+}
+//#endregion
+//#region src/world.ts
+function mergeCustomizer(objValue, srcValue) {
+	if (_.isArray(objValue)) return objValue.concat(srcValue);
+	else if (objValue && !_.isPlainObject(objValue) && objValue !== srcValue) throw new Error(`Merge would have destroyed previous value ${objValue} with ${srcValue}`);
+	return objValue;
+}
+var BasicWorld = class {
+	givenState = {};
+	whenState = {};
+	thenState = {};
+	get given() {
+		return {
+			...this.givenState,
+			merge: (newState) => {
+				this.givenState = _.merge({ ...this.givenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+	get when() {
+		return {
+			...this.whenState,
+			merge: (newState) => {
+				this.whenState = _.merge({ ...this.whenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+	get then() {
+		return {
+			...this.thenState,
+			merge: (newState) => {
+				this.thenState = _.merge({ ...this.thenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+};
+//#endregion
+//#region src/globFiles.ts
+/** Glob metacharacters. A pattern with none of these is a literal path. */
+const MAGIC = /[*?[\]{}!()]/;
+async function isFile(p) {
+	try {
+		return (await stat(p)).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve glob patterns to a de-duplicated list of absolute file paths, with one
+* important portability guarantee: a **literal absolute path** (no glob magic)
+* is returned directly if it exists, without being handed to `glob()`.
+*
+* This exists because `node:fs`'s `glob` diverges between runtimes — Node
+* matches an absolute-path pattern, Bun returns nothing for one. Rather than
+* depend on that behaviour, we only ever glob relative patterns (against `cwd`)
+* and short-circuit concrete absolute paths ourselves, so callers get identical
+* results under Node and Bun.
+*/
+async function globFiles(patterns, cwd = process.cwd()) {
+	const files = /* @__PURE__ */ new Set();
+	for (const pattern of patterns) {
+		if (path.isAbsolute(pattern) && !MAGIC.test(pattern)) {
+			if (await isFile(pattern)) files.add(pattern);
+			continue;
+		}
+		for await (const match of glob(pattern, { cwd })) files.add(path.resolve(cwd, match));
+	}
+	return [...files];
+}
+//#endregion
+//#region src/analyzer/gherkinParser.ts
+function parseFeatureFiles(filePaths) {
+	const scenarios = [];
+	for (const filePath of filePaths) {
+		const parsed = parseFeatureContent(fs.readFileSync(filePath, "utf-8"), filePath);
+		scenarios.push(...parsed);
+	}
+	return scenarios;
+}
+function parseFeatureContent(content, filePath) {
+	const feature = new Parser(new AstBuilder(messages.IdGenerator.uuid()), new GherkinClassicTokenMatcher()).parse(content).feature;
+	if (!feature) return [];
+	const featureBackground = [];
+	const scenarios = [];
+	const featureTags = tagNames(feature.tags);
+	for (const child of feature.children) {
+		if (child.background) featureBackground.push(...child.background.steps);
+		if (child.scenario) scenarios.push(...expandScenario(child.scenario, featureBackground, filePath, featureTags));
+		if (child.rule) {
+			const ruleBackground = [...featureBackground];
+			const ruleTags = [...featureTags, ...tagNames(child.rule.tags)];
+			for (const ruleChild of child.rule.children) {
+				if (ruleChild.background) ruleBackground.push(...ruleChild.background.steps);
+				if (ruleChild.scenario) scenarios.push(...expandScenario(ruleChild.scenario, ruleBackground, filePath, ruleTags));
+			}
+		}
+	}
+	return scenarios;
+}
+/** Extract tag names (each keeping its leading `@`), deduped in order. */
+function tagNames(tags) {
+	return [...new Set((tags ?? []).map((t) => t.name))];
+}
+function expandScenario(scenario, backgroundSteps, filePath, inheritedTags) {
+	const scenarioTags = [...inheritedTags, ...tagNames(scenario.tags)];
+	if (!(scenario.examples.length > 0 && scenario.examples.some((e) => e.tableBody.length > 0))) {
+		const bgParsed = convertSteps(backgroundSteps);
+		const scenarioParsed = convertSteps(scenario.steps);
+		const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioParsed]);
+		return [{
+			name: scenario.name,
+			file: filePath,
+			line: scenario.location.line,
+			steps: allSteps,
+			tags: scenarioTags
+		}];
+	}
+	const results = [];
+	for (const example of scenario.examples) {
+		if (!example.tableHeader || example.tableBody.length === 0) continue;
+		const headers = example.tableHeader.cells.map((c) => c.value);
+		const exampleTags = [...scenarioTags, ...tagNames(example.tags)];
+		for (const row of example.tableBody) {
+			const values = row.cells.map((c) => c.value);
+			const substitution = {};
+			headers.forEach((h, i) => {
+				substitution[h] = values[i];
+			});
+			const bgParsed = convertSteps(backgroundSteps);
+			const scenarioSteps = convertSteps(scenario.steps).map((step) => ({
+				...step,
+				text: substituteExampleValues(step.text, substitution)
+			}));
+			const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioSteps]);
+			results.push({
+				name: headers.map((h, i) => `${h}=${values[i]}`).join(", "),
+				file: filePath,
+				line: row.location.line,
+				steps: allSteps,
+				tags: exampleTags,
+				outline: { name: scenario.name }
+			});
+		}
+	}
+	return results;
+}
+function convertSteps(steps) {
+	return steps.map((step) => ({
+		keyword: normalizeKeyword(step.keyword),
+		text: step.text,
+		line: step.location.line,
+		column: (step.location.column ?? 1) + step.keyword.length
+	}));
+}
+function normalizeKeyword(keyword) {
+	const trimmed = keyword.trim();
+	if (trimmed === "Given") return "Given";
+	if (trimmed === "When") return "When";
+	if (trimmed === "Then") return "Then";
+	if (trimmed === "And") return "And";
+	if (trimmed === "But") return "But";
+	return "Given";
+}
+function resolveEffectiveKeywords(steps) {
+	let lastEffective = "Given";
+	return steps.map((step) => {
+		let effectiveKeyword;
+		if (step.keyword === "And" || step.keyword === "But") effectiveKeyword = lastEffective;
+		else effectiveKeyword = step.keyword;
+		lastEffective = effectiveKeyword;
+		return {
+			...step,
+			effectiveKeyword
+		};
+	});
+}
+function substituteExampleValues(text, substitution) {
+	let result = text;
+	for (const [key, value] of Object.entries(substitution)) result = result.replace(new RegExp(`<${key}>`, "g"), value);
+	return result;
+}
+//#endregion
+export { captureDefinitionSite as a, userFrames as c, BasicWorld as i, parseFeatureFiles as n, relativeFrame as o, globFiles as r, relativeLocation as s, parseFeatureContent as t };
+
+//# sourceMappingURL=gherkinParser-NcttZgN4.js.map

package/dist/gherkinParser-NcttZgN4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gherkinParser-NcttZgN4.js","names":[],"sources":["../../src/sourceLocation.ts","../../src/world.ts","../../src/globFiles.ts","../../src/analyzer/gherkinParser.ts"],"sourcesContent":["import * as path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\n/**\n * Directory holding the library's own compiled code. In development this is the\n * `src/` tree; in the published package it's `dist/` (this module is bundled\n * into the shipped chunks). Stack frames under it are internal plumbing —\n * builders, the engine, the runner — and are hidden from users so that a\n * failure points at *their* step, not ours.\n */\nconst LIB_ROOT = path.dirname(fileURLToPath(import.meta.url));\n\nexport interface SourceFrame {\n  file: string;\n  line: number;\n  column: number;\n}\n\n/**\n * A frame belongs to user code if it's an absolute path that is neither inside\n * the library nor inside any `node_modules` (assertion libs, etc.). That leaves\n * exactly the frames a user cares about: their own step definitions.\n */\nfunction isUserFile(file: string): boolean {\n  return (\n    path.isAbsolute(file) &&\n    !file.startsWith(LIB_ROOT + path.sep) &&\n    !file.includes(`${path.sep}node_modules${path.sep}`)\n  );\n}\n\n/** Parse one `Error.stack` line into a frame, tolerating V8/Bun variations. */\nfunction parseFrame(frameLine: string): SourceFrame | undefined {\n  const m = /:(\\d+):(\\d+)\\)?\\s*$/.exec(frameLine);\n  if (!m) return undefined;\n  let file = frameLine.slice(0, m.index);\n  const paren = file.lastIndexOf(\"(\");\n  if (paren !== -1) file = file.slice(paren + 1);\n  file = file.trim().replace(/^at\\s+/, \"\");\n  if (file.startsWith(\"file://\")) {\n    try {\n      file = fileURLToPath(file);\n    } catch {\n      return undefined;\n    }\n  }\n  return { file, line: Number(m[1]), column: Number(m[2]) };\n}\n\n/** Every user-code frame in a stack, nearest-first, internals removed. */\nexport function userFrames(stack: string | undefined): SourceFrame[] {\n  if (!stack) return [];\n  const frames: SourceFrame[] = [];\n  for (const line of stack.split(\"\\n\")) {\n    const frame = parseFrame(line);\n    if (frame && isUserFile(frame.file)) frames.push(frame);\n  }\n  return frames;\n}\n\n/**\n * Capture the user source location of the current call site — the first\n * user-code frame above this function. Called from `.step()` registration so\n * each step remembers where it was defined (Cucumber-style), independent of\n * where an error is later thrown. Returns an absolute `file:line:column`, or\n * `undefined` if no user frame is visible.\n */\nexport function captureDefinitionSite(): string | undefined {\n  const frame = userFrames(new Error().stack)[0];\n  return frame ? `${frame.file}:${frame.line}:${frame.column}` : undefined;\n}\n\n/** Render an absolute `file:line:column` relative to `cwd` for display. */\nexport function relativeLocation(location: string, cwd: string): string {\n  const m = /^(.*):(\\d+):(\\d+)$/.exec(location);\n  if (!m) return location;\n  return `${path.relative(cwd, m[1])}:${m[2]}:${m[3]}`;\n}\n\n/** Render a frame relative to `cwd`. */\nexport function relativeFrame(frame: SourceFrame, cwd: string): string {\n  return `${path.relative(cwd, frame.file)}:${frame.line}:${frame.column}`;\n}\n","import _ from \"lodash\";\n\nexport type WorldState<State> = {\n  readonly [K in keyof State]?: State[K];\n};\n\nexport type MergeableWorldState<T> = WorldState<T> & {\n  merge: (newState: Partial<T>) => void;\n};\n\nfunction mergeCustomizer(objValue: unknown, srcValue: unknown) {\n  if (_.isArray(objValue)) {\n    return objValue.concat(srcValue);\n  } else if (objValue && !_.isPlainObject(objValue) && objValue !== srcValue) {\n    throw new Error(\n      `Merge would have destroyed previous value ${objValue} with ${srcValue}`\n    );\n  }\n  return objValue;\n}\n\nexport const createMergeableState = <T>(\n  state: WorldState<T>\n): MergeableWorldState<T> => {\n  return {\n    ...state,\n    merge: (newState: Partial<T>) => {\n      state = _.merge({ ...state }, newState, mergeCustomizer);\n    },\n  };\n};\n\nexport type MergeableWorld<Given, When, Then> = {\n  given: MergeableWorldState<Given>;\n  when: MergeableWorldState<When>;\n  then: MergeableWorldState<Then>;\n};\n\nexport class BasicWorld<Given, When, Then> {\n  private givenState: WorldState<Given> = {};\n  private whenState: WorldState<When> = {};\n  private thenState: WorldState<Then> = {};\n\n  public get given(): MergeableWorldState<Given> {\n    return {\n      ...this.givenState,\n      merge: (newState: Partial<Given>) => {\n        this.givenState = _.merge(\n          { ...this.givenState },\n          newState,\n          mergeCustomizer\n        );\n      },\n    };\n  }\n\n  public get when(): MergeableWorldState<When> {\n    return {\n      ...this.whenState,\n      merge: (newState: Partial<When>) => {\n        this.whenState = _.merge(\n          { ...this.whenState },\n          newState,\n          mergeCustomizer\n        );\n      },\n    };\n  }\n\n  public get then(): MergeableWorldState<Then> {\n    return {\n      ...this.thenState,\n      merge: (newState: Partial<Then>) => {\n        this.thenState = _.merge(\n          { ...this.thenState },\n          newState,\n          mergeCustomizer\n        );\n      },\n    };\n  }\n}\n\nexport const createBasicWorld = <Given, When, Then>(): MergeableWorld<\n  Given,\n  When,\n  Then\n> => {\n  return new BasicWorld<Given, When, Then>();\n};\n","import { glob } from \"node:fs/promises\";\nimport { stat } from \"node:fs/promises\";\nimport * as path from \"node:path\";\n\n/** Glob metacharacters. A pattern with none of these is a literal path. */\nconst MAGIC = /[*?[\\]{}!()]/;\n\nasync function isFile(p: string): Promise<boolean> {\n  try {\n    return (await stat(p)).isFile();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Resolve glob patterns to a de-duplicated list of absolute file paths, with one\n * important portability guarantee: a **literal absolute path** (no glob magic)\n * is returned directly if it exists, without being handed to `glob()`.\n *\n * This exists because `node:fs`'s `glob` diverges between runtimes — Node\n * matches an absolute-path pattern, Bun returns nothing for one. Rather than\n * depend on that behaviour, we only ever glob relative patterns (against `cwd`)\n * and short-circuit concrete absolute paths ourselves, so callers get identical\n * results under Node and Bun.\n */\nexport async function globFiles(\n  patterns: string[],\n  cwd: string = process.cwd()\n): Promise<string[]> {\n  const files = new Set<string>();\n  for (const pattern of patterns) {\n    if (path.isAbsolute(pattern) && !MAGIC.test(pattern)) {\n      if (await isFile(pattern)) files.add(pattern);\n      continue;\n    }\n    for await (const match of glob(pattern, { cwd })) {\n      files.add(path.resolve(cwd, match));\n    }\n  }\n  return [...files];\n}\n","import * as fs from \"node:fs\";\nimport { GherkinClassicTokenMatcher, Parser, AstBuilder } from \"@cucumber/gherkin\";\nimport * as messages from \"@cucumber/messages\";\nimport { ParsedScenario, ParsedStep } from \"./types.js\";\n\ntype GherkinKeyword = \"Given\" | \"When\" | \"Then\" | \"And\" | \"But\";\n\nexport function parseFeatureFiles(filePaths: string[]): ParsedScenario[] {\n  const scenarios: ParsedScenario[] = [];\n\n  for (const filePath of filePaths) {\n    const content = fs.readFileSync(filePath, \"utf-8\");\n    const parsed = parseFeatureContent(content, filePath);\n    scenarios.push(...parsed);\n  }\n\n  return scenarios;\n}\n\nexport function parseFeatureContent(\n  content: string,\n  filePath: string\n): ParsedScenario[] {\n  const newId = messages.IdGenerator.uuid();\n  const builder = new AstBuilder(newId);\n  const matcher = new GherkinClassicTokenMatcher();\n  const parser = new Parser(builder, matcher);\n\n  const gherkinDocument: messages.GherkinDocument = parser.parse(content);\n  const feature = gherkinDocument.feature;\n  if (!feature) return [];\n\n  // Collect background steps at the feature level\n  const featureBackground: messages.Step[] = [];\n  const scenarios: ParsedScenario[] = [];\n  const featureTags = tagNames(feature.tags);\n\n  for (const child of feature.children) {\n    if (child.background) {\n      featureBackground.push(...child.background.steps);\n    }\n\n    if (child.scenario) {\n      scenarios.push(\n        ...expandScenario(\n          child.scenario,\n          featureBackground,\n          filePath,\n          featureTags\n        )\n      );\n    }\n\n    if (child.rule) {\n      // Rules can have their own backgrounds and tags, both inherited by the\n      // rule's scenarios.\n      const ruleBackground: messages.Step[] = [...featureBackground];\n      const ruleTags = [...featureTags, ...tagNames(child.rule.tags)];\n      for (const ruleChild of child.rule.children) {\n        if (ruleChild.background) {\n          ruleBackground.push(...ruleChild.background.steps);\n        }\n        if (ruleChild.scenario) {\n          scenarios.push(\n            ...expandScenario(\n              ruleChild.scenario,\n              ruleBackground,\n              filePath,\n              ruleTags\n            )\n          );\n        }\n      }\n    }\n  }\n\n  return scenarios;\n}\n\n/** Extract tag names (each keeping its leading `@`), deduped in order. */\nfunction tagNames(tags: readonly messages.Tag[] | undefined): string[] {\n  return [...new Set((tags ?? []).map(t => t.name))];\n}\n\nfunction expandScenario(\n  scenario: messages.Scenario,\n  backgroundSteps: messages.Step[],\n  filePath: string,\n  inheritedTags: string[]\n): ParsedScenario[] {\n  const scenarioTags = [...inheritedTags, ...tagNames(scenario.tags)];\n  const hasExamples =\n    scenario.examples.length > 0 &&\n    scenario.examples.some((e) => e.tableBody.length > 0);\n\n  if (!hasExamples) {\n    // Regular scenario\n    const bgParsed = convertSteps(backgroundSteps);\n    const scenarioParsed = convertSteps(scenario.steps);\n    const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioParsed]);\n\n    return [\n      {\n        name: scenario.name,\n        file: filePath,\n        line: scenario.location.line,\n        steps: allSteps,\n        tags: scenarioTags,\n      },\n    ];\n  }\n\n  // Scenario Outline — expand with each example row. Rows carry the outline's\n  // base name so the runner can group them, plus the Examples-block tags.\n  const results: ParsedScenario[] = [];\n  for (const example of scenario.examples) {\n    if (!example.tableHeader || example.tableBody.length === 0) continue;\n    const headers = example.tableHeader.cells.map((c) => c.value);\n    const exampleTags = [...scenarioTags, ...tagNames(example.tags)];\n\n    for (const row of example.tableBody) {\n      const values = row.cells.map((c) => c.value);\n      const substitution: Record<string, string> = {};\n      headers.forEach((h, i) => {\n        substitution[h] = values[i];\n      });\n\n      const bgParsed = convertSteps(backgroundSteps);\n      const scenarioSteps = convertSteps(scenario.steps).map((step) => ({\n        ...step,\n        text: substituteExampleValues(step.text, substitution),\n      }));\n      const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioSteps]);\n\n      results.push({\n        name: headers.map((h, i) => `${h}=${values[i]}`).join(\", \"),\n        file: filePath,\n        line: row.location.line,\n        steps: allSteps,\n        tags: exampleTags,\n        outline: { name: scenario.name },\n      });\n    }\n  }\n\n  return results;\n}\n\nfunction convertSteps(\n  steps: readonly messages.Step[]\n): Omit<ParsedStep, \"effectiveKeyword\">[] {\n  return steps.map((step) => ({\n    keyword: normalizeKeyword(step.keyword),\n    text: step.text,\n    line: step.location.line,\n    // step.location.column points to the keyword start; shift past the\n    // keyword (which includes a trailing space) so column points to the\n    // start of the step text. This makes `column + text.length` produce\n    // the correct end position for diagnostic ranges.\n    column: (step.location.column ?? 1) + step.keyword.length,\n  }));\n}\n\nfunction normalizeKeyword(keyword: string): GherkinKeyword {\n  const trimmed = keyword.trim();\n  // Gherkin keywords may include trailing space, e.g. \"Given \"\n  if (trimmed === \"Given\") return \"Given\";\n  if (trimmed === \"When\") return \"When\";\n  if (trimmed === \"Then\") return \"Then\";\n  if (trimmed === \"And\") return \"And\";\n  if (trimmed === \"But\") return \"But\";\n  // Fallback: treat as Given (shouldn't happen with valid Gherkin)\n  return \"Given\";\n}\n\nfunction resolveEffectiveKeywords(\n  steps: Omit<ParsedStep, \"effectiveKeyword\">[]\n): ParsedStep[] {\n  let lastEffective: \"Given\" | \"When\" | \"Then\" = \"Given\";\n\n  return steps.map((step) => {\n    let effectiveKeyword: \"Given\" | \"When\" | \"Then\";\n    if (step.keyword === \"And\" || step.keyword === \"But\") {\n      effectiveKeyword = lastEffective;\n    } else {\n      effectiveKeyword = step.keyword as \"Given\" | \"When\" | \"Then\";\n    }\n    lastEffective = effectiveKeyword;\n\n    return {\n      ...step,\n      effectiveKeyword,\n    };\n  });\n}\n\nfunction substituteExampleValues(\n  text: string,\n  substitution: Record<string, string>\n): string {\n  let result = text;\n  for (const [key, value] of Object.entries(substitution)) {\n    result = result.replace(new RegExp(`<${key}>`, \"g\"), value);\n  }\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAUA,MAAM,WAAW,KAAK,QAAQ,cAAc,OAAO,KAAK,GAAG,CAAC;;;;;;AAa5D,SAAS,WAAW,MAAuB;CACzC,OACE,KAAK,WAAW,IAAI,KACpB,CAAC,KAAK,WAAW,WAAW,KAAK,GAAG,KACpC,CAAC,KAAK,SAAS,GAAG,KAAK,IAAI,cAAc,KAAK,KAAK;AAEvD;;AAGA,SAAS,WAAW,WAA4C;CAC9D,MAAM,IAAI,sBAAsB,KAAK,SAAS;CAC9C,IAAI,CAAC,GAAG,OAAO,KAAA;CACf,IAAI,OAAO,UAAU,MAAM,GAAG,EAAE,KAAK;CACrC,MAAM,QAAQ,KAAK,YAAY,GAAG;CAClC,IAAI,UAAU,IAAI,OAAO,KAAK,MAAM,QAAQ,CAAC;CAC7C,OAAO,KAAK,KAAK,CAAC,CAAC,QAAQ,UAAU,EAAE;CACvC,IAAI,KAAK,WAAW,SAAS,GAC3B,IAAI;EACF,OAAO,cAAc,IAAI;CAC3B,QAAQ;EACN;CACF;CAEF,OAAO;EAAE;EAAM,MAAM,OAAO,EAAE,EAAE;EAAG,QAAQ,OAAO,EAAE,EAAE;CAAE;AAC1D;;AAGA,SAAgB,WAAW,OAA0C;CACnE,IAAI,CAAC,OAAO,OAAO,CAAC;CACpB,MAAM,SAAwB,CAAC;CAC/B,KAAK,MAAM,QAAQ,MAAM,MAAM,IAAI,GAAG;EACpC,MAAM,QAAQ,WAAW,IAAI;EAC7B,IAAI,SAAS,WAAW,MAAM,IAAI,GAAG,OAAO,KAAK,KAAK;CACxD;CACA,OAAO;AACT;;;;;;;;AASA,SAAgB,wBAA4C;CAC1D,MAAM,QAAQ,4BAAW,IAAI,MAAM,EAAA,CAAE,KAAK,CAAC,CAAC;CAC5C,OAAO,QAAQ,GAAG,MAAM,KAAK,GAAG,MAAM,KAAK,GAAG,MAAM,WAAW,KAAA;AACjE;;AAGA,SAAgB,iBAAiB,UAAkB,KAAqB;CACtE,MAAM,IAAI,qBAAqB,KAAK,QAAQ;CAC5C,IAAI,CAAC,GAAG,OAAO;CACf,OAAO,GAAG,KAAK,SAAS,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE;AAClD;;AAGA,SAAgB,cAAc,OAAoB,KAAqB;CACrE,OAAO,GAAG,KAAK,SAAS,KAAK,MAAM,IAAI,EAAE,GAAG,MAAM,KAAK,GAAG,MAAM;AAClE;;;ACxEA,SAAS,gBAAgB,UAAmB,UAAmB;CAC7D,IAAI,EAAE,QAAQ,QAAQ,GACpB,OAAO,SAAS,OAAO,QAAQ;MAC1B,IAAI,YAAY,CAAC,EAAE,cAAc,QAAQ,KAAK,aAAa,UAChE,MAAM,IAAI,MACR,6CAA6C,SAAS,QAAQ,UAChE;CAEF,OAAO;AACT;AAmBA,IAAa,aAAb,MAA2C;CACzC,aAAwC,CAAC;CACzC,YAAsC,CAAC;CACvC,YAAsC,CAAC;CAEvC,IAAW,QAAoC;EAC7C,OAAO;GACL,GAAG,KAAK;GACR,QAAQ,aAA6B;IACnC,KAAK,aAAa,EAAE,MAClB,EAAE,GAAG,KAAK,WAAW,GACrB,UACA,eACF;GACF;EACF;CACF;CAEA,IAAW,OAAkC;EAC3C,OAAO;GACL,GAAG,KAAK;GACR,QAAQ,aAA4B;IAClC,KAAK,YAAY,EAAE,MACjB,EAAE,GAAG,KAAK,UAAU,GACpB,UACA,eACF;GACF;EACF;CACF;CAEA,IAAW,OAAkC;EAC3C,OAAO;GACL,GAAG,KAAK;GACR,QAAQ,aAA4B;IAClC,KAAK,YAAY,EAAE,MACjB,EAAE,GAAG,KAAK,UAAU,GACpB,UACA,eACF;GACF;EACF;CACF;AACF;;;;AC5EA,MAAM,QAAQ;AAEd,eAAe,OAAO,GAA6B;CACjD,IAAI;EACF,QAAQ,MAAM,KAAK,CAAC,EAAA,CAAG,OAAO;CAChC,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;;AAaA,eAAsB,UACpB,UACA,MAAc,QAAQ,IAAI,GACP;CACnB,MAAM,wBAAQ,IAAI,IAAY;CAC9B,KAAK,MAAM,WAAW,UAAU;EAC9B,IAAI,KAAK,WAAW,OAAO,KAAK,CAAC,MAAM,KAAK,OAAO,GAAG;GACpD,IAAI,MAAM,OAAO,OAAO,GAAG,MAAM,IAAI,OAAO;GAC5C;EACF;EACA,WAAW,MAAM,SAAS,KAAK,SAAS,EAAE,IAAI,CAAC,GAC7C,MAAM,IAAI,KAAK,QAAQ,KAAK,KAAK,CAAC;CAEtC;CACA,OAAO,CAAC,GAAG,KAAK;AAClB;;;AClCA,SAAgB,kBAAkB,WAAuC;CACvE,MAAM,YAA8B,CAAC;CAErC,KAAK,MAAM,YAAY,WAAW;EAEhC,MAAM,SAAS,oBADC,GAAG,aAAa,UAAU,OACD,GAAG,QAAQ;EACpD,UAAU,KAAK,GAAG,MAAM;CAC1B;CAEA,OAAO;AACT;AAEA,SAAgB,oBACd,SACA,UACkB;CAOlB,MAAM,UAD4C,IAF/B,OAAO,IAFN,WADN,SAAS,YAAY,KACA,CAEH,GAAG,IADf,2BACqB,CAEc,CAAC,CAAC,MAAM,OACjC,CAAC,CAAC;CAChC,IAAI,CAAC,SAAS,OAAO,CAAC;CAGtB,MAAM,oBAAqC,CAAC;CAC5C,MAAM,YAA8B,CAAC;CACrC,MAAM,cAAc,SAAS,QAAQ,IAAI;CAEzC,KAAK,MAAM,SAAS,QAAQ,UAAU;EACpC,IAAI,MAAM,YACR,kBAAkB,KAAK,GAAG,MAAM,WAAW,KAAK;EAGlD,IAAI,MAAM,UACR,UAAU,KACR,GAAG,eACD,MAAM,UACN,mBACA,UACA,WACF,CACF;EAGF,IAAI,MAAM,MAAM;GAGd,MAAM,iBAAkC,CAAC,GAAG,iBAAiB;GAC7D,MAAM,WAAW,CAAC,GAAG,aAAa,GAAG,SAAS,MAAM,KAAK,IAAI,CAAC;GAC9D,KAAK,MAAM,aAAa,MAAM,KAAK,UAAU;IAC3C,IAAI,UAAU,YACZ,eAAe,KAAK,GAAG,UAAU,WAAW,KAAK;IAEnD,IAAI,UAAU,UACZ,UAAU,KACR,GAAG,eACD,UAAU,UACV,gBACA,UACA,QACF,CACF;GAEJ;EACF;CACF;CAEA,OAAO;AACT;;AAGA,SAAS,SAAS,MAAqD;CACrE,OAAO,CAAC,GAAG,IAAI,KAAK,QAAQ,CAAC,EAAA,CAAG,KAAI,MAAK,EAAE,IAAI,CAAC,CAAC;AACnD;AAEA,SAAS,eACP,UACA,iBACA,UACA,eACkB;CAClB,MAAM,eAAe,CAAC,GAAG,eAAe,GAAG,SAAS,SAAS,IAAI,CAAC;CAKlE,IAAI,EAHF,SAAS,SAAS,SAAS,KAC3B,SAAS,SAAS,MAAM,MAAM,EAAE,UAAU,SAAS,CAAC,IAEpC;EAEhB,MAAM,WAAW,aAAa,eAAe;EAC7C,MAAM,iBAAiB,aAAa,SAAS,KAAK;EAClD,MAAM,WAAW,yBAAyB,CAAC,GAAG,UAAU,GAAG,cAAc,CAAC;EAE1E,OAAO,CACL;GACE,MAAM,SAAS;GACf,MAAM;GACN,MAAM,SAAS,SAAS;GACxB,OAAO;GACP,MAAM;EACR,CACF;CACF;CAIA,MAAM,UAA4B,CAAC;CACnC,KAAK,MAAM,WAAW,SAAS,UAAU;EACvC,IAAI,CAAC,QAAQ,eAAe,QAAQ,UAAU,WAAW,GAAG;EAC5D,MAAM,UAAU,QAAQ,YAAY,MAAM,KAAK,MAAM,EAAE,KAAK;EAC5D,MAAM,cAAc,CAAC,GAAG,cAAc,GAAG,SAAS,QAAQ,IAAI,CAAC;EAE/D,KAAK,MAAM,OAAO,QAAQ,WAAW;GACnC,MAAM,SAAS,IAAI,MAAM,KAAK,MAAM,EAAE,KAAK;GAC3C,MAAM,eAAuC,CAAC;GAC9C,QAAQ,SAAS,GAAG,MAAM;IACxB,aAAa,KAAK,OAAO;GAC3B,CAAC;GAED,MAAM,WAAW,aAAa,eAAe;GAC7C,MAAM,gBAAgB,aAAa,SAAS,KAAK,CAAC,CAAC,KAAK,UAAU;IAChE,GAAG;IACH,MAAM,wBAAwB,KAAK,MAAM,YAAY;GACvD,EAAE;GACF,MAAM,WAAW,yBAAyB,CAAC,GAAG,UAAU,GAAG,aAAa,CAAC;GAEzE,QAAQ,KAAK;IACX,MAAM,QAAQ,KAAK,GAAG,MAAM,GAAG,EAAE,GAAG,OAAO,IAAI,CAAC,CAAC,KAAK,IAAI;IAC1D,MAAM;IACN,MAAM,IAAI,SAAS;IACnB,OAAO;IACP,MAAM;IACN,SAAS,EAAE,MAAM,SAAS,KAAK;GACjC,CAAC;EACH;CACF;CAEA,OAAO;AACT;AAEA,SAAS,aACP,OACwC;CACxC,OAAO,MAAM,KAAK,UAAU;EAC1B,SAAS,iBAAiB,KAAK,OAAO;EACtC,MAAM,KAAK;EACX,MAAM,KAAK,SAAS;EAKpB,SAAS,KAAK,SAAS,UAAU,KAAK,KAAK,QAAQ;CACrD,EAAE;AACJ;AAEA,SAAS,iBAAiB,SAAiC;CACzD,MAAM,UAAU,QAAQ,KAAK;CAE7B,IAAI,YAAY,SAAS,OAAO;CAChC,IAAI,YAAY,QAAQ,OAAO;CAC/B,IAAI,YAAY,QAAQ,OAAO;CAC/B,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,OAAO,OAAO;CAE9B,OAAO;AACT;AAEA,SAAS,yBACP,OACc;CACd,IAAI,gBAA2C;CAE/C,OAAO,MAAM,KAAK,SAAS;EACzB,IAAI;EACJ,IAAI,KAAK,YAAY,SAAS,KAAK,YAAY,OAC7C,mBAAmB;OAEnB,mBAAmB,KAAK;EAE1B,gBAAgB;EAEhB,OAAO;GACL,GAAG;GACH;EACF;CACF,CAAC;AACH;AAEA,SAAS,wBACP,MACA,cACQ;CACR,IAAI,SAAS;CACb,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,YAAY,GACpD,SAAS,OAAO,QAAQ,IAAI,OAAO,IAAI,IAAI,IAAI,GAAG,GAAG,KAAK;CAE5D,OAAO;AACT"}

package/dist/hooks-BDCMKeNq.js

@@ -0,0 +1,71 @@
+//#region src/runtime/registry.ts
+/**
+* A collection of registered steps. Deliberately a plain instance (not a hidden
+* module global) so tests and the Vitest plugin can create isolated registries.
+* `globalRegistry` is the default sink that `.step()` writes to.
+*/
+var StepRegistry = class {
+	steps = [];
+	add(step) {
+		this.steps.push(step);
+	}
+	all() {
+		return this.steps;
+	}
+	clear() {
+		this.steps = [];
+	}
+};
+const globalRegistry = new StepRegistry();
+//#endregion
+//#region src/runtime/hooks.ts
+/**
+* Collection of registered hooks. Like {@link StepRegistry}, a plain instance
+* (not a hidden global) so tests can isolate; `globalHookRegistry` is the
+* default sink the public `beforeScenario`/`afterAll`/etc helpers write to.
+*/
+var HookRegistry = class {
+	hooks = [];
+	add(hook) {
+		this.hooks.push(hook);
+	}
+	/**
+	* Hooks for a scope+timing. `before` hooks run in registration order;
+	* `after` hooks run in reverse (LIFO), so teardown unwinds setup.
+	*/
+	for(scope, timing) {
+		const matching = this.hooks.filter((h) => h.scope === scope && h.timing === timing);
+		return timing === "after" ? matching.reverse() : matching;
+	}
+	clear() {
+		this.hooks = [];
+	}
+};
+const globalHookRegistry = new HookRegistry();
+/**
+* Run every registered hook of a scope+timing **in registration order** (after
+* hooks reversed by {@link HookRegistry.for}, so teardown unwinds setup). Used
+* for feature hooks, where ordering matters. Throws if a hook throws, so the
+* runner reports it against the enclosing boundary.
+*/
+async function runHooks(scope, timing, registry = globalHookRegistry) {
+	for (const hook of registry.for(scope, timing)) await hook.fn();
+}
+/**
+* Run every registered hook of a scope+timing **concurrently**, resolving once
+* all of them settle. This is how global `beforeAll`/`afterAll` run: independent
+* setup/teardown steps fire in parallel with no ordering between them. A hook
+* with a sequential requirement should sequence that work inside a single hook.
+*
+* The runner calls this exactly once for `beforeAll` (before any scenario
+* starts) and once for `afterAll` (after every scenario is done), so global
+* setup/teardown brackets the whole run deterministically. Rejects if any hook
+* rejects (via `Promise.all`), surfacing the first failure to the caller.
+*/
+async function runHooksParallel(scope, timing, registry = globalHookRegistry) {
+	await Promise.all(registry.for(scope, timing).map((hook) => hook.fn()));
+}
+//#endregion
+export { StepRegistry as a, runHooksParallel as i, globalHookRegistry as n, globalRegistry as o, runHooks as r, HookRegistry as t };
+
+//# sourceMappingURL=hooks-BDCMKeNq.js.map

package/dist/{hooks-CywugMQQ.js.map → hooks-BDCMKeNq.js.map}

@@ -1 +1 @@
-{"version":3,"file":"hooks-CywugMQQ.js","names":[],"sources":["../../src/runtime/registry.ts","../../src/runtime/hooks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Parser } from \"../parsers\";\nimport { MergeableWorld } from \"../world\";\n\nexport type StepType = \"given\" | \"when\" | \"then\";\n\n/**\n * A step definition as it exists at *runtime*, independent of any test runner.\n *\n * `execute` is the fully-wired step body: given a world and the raw values\n * captured from a Gherkin step, it applies parsers, validates + narrows\n * dependencies, runs the user's step function, and merges the result back into\n * the world. The engine never needs to know how any of that works — it just\n * matches text to a step and calls `execute`.\n */\nexport interface RegisteredStep {\n  stepType: StepType;\n  /** The Cucumber-expression source, e.g. `a user named {string}`. */\n  expression: string;\n  /** Parsers, one per captured variable, applied after expression capture. */\n  parsers: Parser<any>[];\n  execute: (\n    world: MergeableWorld<any, any, any>,\n    capturedArgs: unknown[]\n  ) => Promise<void>;\n  /** Where the step was defined, for ambiguous-match diagnostics. */\n  source?: string;\n}\n\n/**\n * A collection of registered steps. Deliberately a plain instance (not a hidden\n * module global) so tests and the Vitest plugin can create isolated registries.\n * `globalRegistry` is the default sink that `.step()` writes to.\n */\nexport class StepRegistry {\n  private steps: RegisteredStep[] = [];\n\n  add(step: RegisteredStep): void {\n    this.steps.push(step);\n  }\n\n  all(): readonly RegisteredStep[] {\n    return this.steps;\n  }\n\n  clear(): void {\n    this.steps = [];\n  }\n}\n\nexport const globalRegistry = new StepRegistry();\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { MergeableWorld } from \"../world\";\n\n/**\n * Hooks are side-effect callbacks that run around scenarios, feature files, or\n * the whole run. Unlike steps they never seed state: state is owned end to end\n * by the typed dependency graph (given/when/then), and hooks exist for setup and\n * teardown (opening a DB, starting a server, resetting mocks). A scenario hook\n * may *read* the world, but its return value is ignored.\n */\nexport type HookScope = \"scenario\" | \"feature\" | \"global\";\nexport type HookTiming = \"before\" | \"after\";\n\n/** Lightweight scenario identity handed to per-scenario hooks. */\nexport interface ScenarioInfo {\n  name: string;\n  file: string;\n}\n\n/** A per-scenario hook: gets the scenario's world (read-only in spirit). */\nexport type ScenarioHookFn = (context: {\n  world: MergeableWorld<any, any, any>;\n  scenario: ScenarioInfo;\n}) => void | Promise<void>;\n\n/** A per-feature-file or global hook: no world exists at these boundaries. */\nexport type PlainHookFn = () => void | Promise<void>;\n\nexport interface RegisteredHook {\n  scope: HookScope;\n  timing: HookTiming;\n  fn: ScenarioHookFn | PlainHookFn;\n}\n\n/**\n * Collection of registered hooks. Like {@link StepRegistry}, a plain instance\n * (not a hidden global) so tests can isolate; `globalHookRegistry` is the\n * default sink the public `beforeScenario`/`afterAll`/etc helpers write to.\n */\nexport class HookRegistry {\n  private hooks: RegisteredHook[] = [];\n\n  add(hook: RegisteredHook): void {\n    this.hooks.push(hook);\n  }\n\n  /**\n   * Hooks for a scope+timing. `before` hooks run in registration order;\n   * `after` hooks run in reverse (LIFO), so teardown unwinds setup.\n   */\n  for(scope: HookScope, timing: HookTiming): RegisteredHook[] {\n    const matching = this.hooks.filter(\n      h => h.scope === scope && h.timing === timing\n    );\n    return timing === \"after\" ? matching.reverse() : matching;\n  }\n\n  clear(): void {\n    this.hooks = [];\n  }\n}\n\nexport const globalHookRegistry = new HookRegistry();\n\n/**\n * Run every registered feature/global hook of a scope+timing in order. Used by\n * the generated test modules (feature hooks). Throws if a hook throws, so the\n * runner reports it against the enclosing boundary.\n */\nexport async function runHooks(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  for (const hook of registry.for(scope, timing)) {\n    await (hook.fn as PlainHookFn)();\n  }\n}\n\n// Process-global (via Symbol.for so it survives module duplication) guard so\n// global hooks fire exactly once per worker, no matter how many feature modules\n// call in.\nconst GLOBAL_GUARD = Symbol.for(\"step-forge.globalHooksStarted\");\n\n/**\n * Run global before-hooks once per worker, ahead of that worker's first\n * scenario, and schedule global after-hooks for worker exit. Idempotent: every\n * feature module calls this in a `beforeAll`, but only the first call in a given\n * worker does anything.\n *\n * Semantics & caveats (the once-per-worker model):\n * - Runs in the *same* realm as steps, so global setup may touch in-process\n *   state that steps later read.\n * - \"Once per worker\", not strictly once per run — with multiple workers it runs\n *   in each. Size global setup to be worker-safe (e.g. a server per worker).\n * - Teardown is best-effort: after-hooks start on the worker's `beforeExit` and\n *   are not awaited by the runner, so keep them fast/synchronous.\n */\nexport async function ensureGlobalHooks(\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  const store = globalThis as Record<symbol, boolean>;\n  if (store[GLOBAL_GUARD]) return;\n  store[GLOBAL_GUARD] = true;\n\n  for (const hook of registry.for(\"global\", \"before\")) {\n    await (hook.fn as PlainHookFn)();\n  }\n\n  process.once(\"beforeExit\", () => {\n    void (async () => {\n      for (const hook of registry.for(\"global\", \"after\")) {\n        await (hook.fn as PlainHookFn)();\n      }\n    })();\n  });\n}\n"],"mappings":";;;;;;AAkCA,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;CAEA,MAAiC;EAC/B,OAAO,KAAK;CACd;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,iBAAiB,IAAI,aAAa;;;;;;;;ACX/C,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;;;;;CAMA,IAAI,OAAkB,QAAsC;EAC1D,MAAM,WAAW,KAAK,MAAM,QAC1B,MAAK,EAAE,UAAU,SAAS,EAAE,WAAW,MACzC;EACA,OAAO,WAAW,UAAU,SAAS,QAAQ,IAAI;CACnD;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,qBAAqB,IAAI,aAAa;;;;;;AAOnD,eAAsB,SACpB,OACA,QACA,WAAyB,oBACV;CACf,KAAK,MAAM,QAAQ,SAAS,IAAI,OAAO,MAAM,GAC3C,MAAO,KAAK,GAAmB;AAEnC;AAKA,MAAM,eAAe,OAAO,IAAI,+BAA+B;;;;;;;;;;;;;;;AAgB/D,eAAsB,kBACpB,WAAyB,oBACV;CACf,MAAM,QAAQ;CACd,IAAI,MAAM,eAAe;CACzB,MAAM,gBAAgB;CAEtB,KAAK,MAAM,QAAQ,SAAS,IAAI,UAAU,QAAQ,GAChD,MAAO,KAAK,GAAmB;CAGjC,QAAQ,KAAK,oBAAoB;EAC/B,CAAM,YAAY;GAChB,KAAK,MAAM,QAAQ,SAAS,IAAI,UAAU,OAAO,GAC/C,MAAO,KAAK,GAAmB;EAEnC,EAAA,CAAG;CACL,CAAC;AACH"}
+{"version":3,"file":"hooks-BDCMKeNq.js","names":[],"sources":["../../src/runtime/registry.ts","../../src/runtime/hooks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Parser } from \"../parsers\";\nimport { MergeableWorld } from \"../world\";\n\nexport type StepType = \"given\" | \"when\" | \"then\";\n\n/**\n * A step definition as it exists at *runtime*, independent of any test runner.\n *\n * `execute` is the fully-wired step body: given a world and the raw values\n * captured from a Gherkin step, it applies parsers, validates + narrows\n * dependencies, runs the user's step function, and merges the result back into\n * the world. The engine never needs to know how any of that works — it just\n * matches text to a step and calls `execute`.\n */\nexport interface RegisteredStep {\n  stepType: StepType;\n  /** The Cucumber-expression source, e.g. `a user named {string}`. */\n  expression: string;\n  /** Parsers, one per captured variable, applied after expression capture. */\n  parsers: Parser<any>[];\n  execute: (\n    world: MergeableWorld<any, any, any>,\n    capturedArgs: unknown[]\n  ) => Promise<void>;\n  /** Where the step was defined, for ambiguous-match diagnostics. */\n  source?: string;\n}\n\n/**\n * A collection of registered steps. Deliberately a plain instance (not a hidden\n * module global) so tests and the Vitest plugin can create isolated registries.\n * `globalRegistry` is the default sink that `.step()` writes to.\n */\nexport class StepRegistry {\n  private steps: RegisteredStep[] = [];\n\n  add(step: RegisteredStep): void {\n    this.steps.push(step);\n  }\n\n  all(): readonly RegisteredStep[] {\n    return this.steps;\n  }\n\n  clear(): void {\n    this.steps = [];\n  }\n}\n\nexport const globalRegistry = new StepRegistry();\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { MergeableWorld } from \"../world\";\n\n/**\n * Hooks are side-effect callbacks that run around scenarios, feature files, or\n * the whole run. Unlike steps they never seed state: state is owned end to end\n * by the typed dependency graph (given/when/then), and hooks exist for setup and\n * teardown (opening a DB, starting a server, resetting mocks). A scenario hook\n * may *read* the world, but its return value is ignored.\n */\nexport type HookScope = \"scenario\" | \"feature\" | \"global\";\nexport type HookTiming = \"before\" | \"after\";\n\n/** Lightweight scenario identity handed to per-scenario hooks. */\nexport interface ScenarioInfo {\n  name: string;\n  file: string;\n}\n\n/** A per-scenario hook: gets the scenario's world (read-only in spirit). */\nexport type ScenarioHookFn = (context: {\n  world: MergeableWorld<any, any, any>;\n  scenario: ScenarioInfo;\n}) => void | Promise<void>;\n\n/** A per-feature-file or global hook: no world exists at these boundaries. */\nexport type PlainHookFn = () => void | Promise<void>;\n\nexport interface RegisteredHook {\n  scope: HookScope;\n  timing: HookTiming;\n  fn: ScenarioHookFn | PlainHookFn;\n}\n\n/**\n * Collection of registered hooks. Like {@link StepRegistry}, a plain instance\n * (not a hidden global) so tests can isolate; `globalHookRegistry` is the\n * default sink the public `beforeScenario`/`afterAll`/etc helpers write to.\n */\nexport class HookRegistry {\n  private hooks: RegisteredHook[] = [];\n\n  add(hook: RegisteredHook): void {\n    this.hooks.push(hook);\n  }\n\n  /**\n   * Hooks for a scope+timing. `before` hooks run in registration order;\n   * `after` hooks run in reverse (LIFO), so teardown unwinds setup.\n   */\n  for(scope: HookScope, timing: HookTiming): RegisteredHook[] {\n    const matching = this.hooks.filter(\n      h => h.scope === scope && h.timing === timing\n    );\n    return timing === \"after\" ? matching.reverse() : matching;\n  }\n\n  clear(): void {\n    this.hooks = [];\n  }\n}\n\nexport const globalHookRegistry = new HookRegistry();\n\n/**\n * Run every registered hook of a scope+timing **in registration order** (after\n * hooks reversed by {@link HookRegistry.for}, so teardown unwinds setup). Used\n * for feature hooks, where ordering matters. Throws if a hook throws, so the\n * runner reports it against the enclosing boundary.\n */\nexport async function runHooks(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  for (const hook of registry.for(scope, timing)) {\n    await (hook.fn as PlainHookFn)();\n  }\n}\n\n/**\n * Run every registered hook of a scope+timing **concurrently**, resolving once\n * all of them settle. This is how global `beforeAll`/`afterAll` run: independent\n * setup/teardown steps fire in parallel with no ordering between them. A hook\n * with a sequential requirement should sequence that work inside a single hook.\n *\n * The runner calls this exactly once for `beforeAll` (before any scenario\n * starts) and once for `afterAll` (after every scenario is done), so global\n * setup/teardown brackets the whole run deterministically. Rejects if any hook\n * rejects (via `Promise.all`), surfacing the first failure to the caller.\n */\nexport async function runHooksParallel(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  await Promise.all(\n    registry.for(scope, timing).map(hook => (hook.fn as PlainHookFn)())\n  );\n}\n"],"mappings":";;;;;;AAkCA,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;CAEA,MAAiC;EAC/B,OAAO,KAAK;CACd;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,iBAAiB,IAAI,aAAa;;;;;;;;ACX/C,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;;;;;CAMA,IAAI,OAAkB,QAAsC;EAC1D,MAAM,WAAW,KAAK,MAAM,QAC1B,MAAK,EAAE,UAAU,SAAS,EAAE,WAAW,MACzC;EACA,OAAO,WAAW,UAAU,SAAS,QAAQ,IAAI;CACnD;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,qBAAqB,IAAI,aAAa;;;;;;;AAQnD,eAAsB,SACpB,OACA,QACA,WAAyB,oBACV;CACf,KAAK,MAAM,QAAQ,SAAS,IAAI,OAAO,MAAM,GAC3C,MAAO,KAAK,GAAmB;AAEnC;;;;;;;;;;;;AAaA,eAAsB,iBACpB,OACA,QACA,WAAyB,oBACV;CACf,MAAM,QAAQ,IACZ,SAAS,IAAI,OAAO,MAAM,CAAC,CAAC,KAAI,SAAS,KAAK,GAAmB,CAAC,CACpE;AACF"}

package/dist/{hooks-CGYzwDOv.cjs → hooks-Be0cjULN.cjs}

@@ -43,38 +43,27 @@ var HookRegistry = class {
 };
 const globalHookRegistry = new HookRegistry();
 /**
-* Run every registered feature/global hook of a scope+timing in order. Used by
-* the generated test modules (feature hooks). Throws if a hook throws, so the
+* Run every registered hook of a scope+timing **in registration order** (after
+* hooks reversed by {@link HookRegistry.for}, so teardown unwinds setup). Used
+* for feature hooks, where ordering matters. Throws if a hook throws, so the
 * runner reports it against the enclosing boundary.
 */
 async function runHooks(scope, timing, registry = globalHookRegistry) {
 	for (const hook of registry.for(scope, timing)) await hook.fn();
 }
-const GLOBAL_GUARD = Symbol.for("step-forge.globalHooksStarted");
 /**
-* Run global before-hooks once per worker, ahead of that worker's first
-* scenario, and schedule global after-hooks for worker exit. Idempotent: every
-* feature module calls this in a `beforeAll`, but only the first call in a given
-* worker does anything.
+* Run every registered hook of a scope+timing **concurrently**, resolving once
+* all of them settle. This is how global `beforeAll`/`afterAll` run: independent
+* setup/teardown steps fire in parallel with no ordering between them. A hook
+* with a sequential requirement should sequence that work inside a single hook.
 *
-* Semantics & caveats (the once-per-worker model):
-* - Runs in the *same* realm as steps, so global setup may touch in-process
-*   state that steps later read.
-* - "Once per worker", not strictly once per run — with multiple workers it runs
-*   in each. Size global setup to be worker-safe (e.g. a server per worker).
-* - Teardown is best-effort: after-hooks start on the worker's `beforeExit` and
-*   are not awaited by the runner, so keep them fast/synchronous.
+* The runner calls this exactly once for `beforeAll` (before any scenario
+* starts) and once for `afterAll` (after every scenario is done), so global
+* setup/teardown brackets the whole run deterministically. Rejects if any hook
+* rejects (via `Promise.all`), surfacing the first failure to the caller.
 */
-async function ensureGlobalHooks(registry = globalHookRegistry) {
-	const store = globalThis;
-	if (store[GLOBAL_GUARD]) return;
-	store[GLOBAL_GUARD] = true;
-	for (const hook of registry.for("global", "before")) await hook.fn();
-	process.once("beforeExit", () => {
-		(async () => {
-			for (const hook of registry.for("global", "after")) await hook.fn();
-		})();
-	});
+async function runHooksParallel(scope, timing, registry = globalHookRegistry) {
+	await Promise.all(registry.for(scope, timing).map((hook) => hook.fn()));
 }
 //#endregion
 Object.defineProperty(exports, "HookRegistry", {
@@ -89,12 +78,6 @@ Object.defineProperty(exports, "StepRegistry", {
 		return StepRegistry;
 	}
 });
-Object.defineProperty(exports, "ensureGlobalHooks", {
-	enumerable: true,
-	get: function() {
-		return ensureGlobalHooks;
-	}
-});
 Object.defineProperty(exports, "globalHookRegistry", {
 	enumerable: true,
 	get: function() {
@@ -113,5 +96,11 @@ Object.defineProperty(exports, "runHooks", {
 		return runHooks;
 	}
 });
+Object.defineProperty(exports, "runHooksParallel", {
+	enumerable: true,
+	get: function() {
+		return runHooksParallel;
+	}
+});
 
-//# sourceMappingURL=hooks-CGYzwDOv.cjs.map
+//# sourceMappingURL=hooks-Be0cjULN.cjs.map

package/dist/{hooks-CGYzwDOv.cjs.map → hooks-Be0cjULN.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"hooks-CGYzwDOv.cjs","names":[],"sources":["../../src/runtime/registry.ts","../../src/runtime/hooks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Parser } from \"../parsers\";\nimport { MergeableWorld } from \"../world\";\n\nexport type StepType = \"given\" | \"when\" | \"then\";\n\n/**\n * A step definition as it exists at *runtime*, independent of any test runner.\n *\n * `execute` is the fully-wired step body: given a world and the raw values\n * captured from a Gherkin step, it applies parsers, validates + narrows\n * dependencies, runs the user's step function, and merges the result back into\n * the world. The engine never needs to know how any of that works — it just\n * matches text to a step and calls `execute`.\n */\nexport interface RegisteredStep {\n  stepType: StepType;\n  /** The Cucumber-expression source, e.g. `a user named {string}`. */\n  expression: string;\n  /** Parsers, one per captured variable, applied after expression capture. */\n  parsers: Parser<any>[];\n  execute: (\n    world: MergeableWorld<any, any, any>,\n    capturedArgs: unknown[]\n  ) => Promise<void>;\n  /** Where the step was defined, for ambiguous-match diagnostics. */\n  source?: string;\n}\n\n/**\n * A collection of registered steps. Deliberately a plain instance (not a hidden\n * module global) so tests and the Vitest plugin can create isolated registries.\n * `globalRegistry` is the default sink that `.step()` writes to.\n */\nexport class StepRegistry {\n  private steps: RegisteredStep[] = [];\n\n  add(step: RegisteredStep): void {\n    this.steps.push(step);\n  }\n\n  all(): readonly RegisteredStep[] {\n    return this.steps;\n  }\n\n  clear(): void {\n    this.steps = [];\n  }\n}\n\nexport const globalRegistry = new StepRegistry();\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { MergeableWorld } from \"../world\";\n\n/**\n * Hooks are side-effect callbacks that run around scenarios, feature files, or\n * the whole run. Unlike steps they never seed state: state is owned end to end\n * by the typed dependency graph (given/when/then), and hooks exist for setup and\n * teardown (opening a DB, starting a server, resetting mocks). A scenario hook\n * may *read* the world, but its return value is ignored.\n */\nexport type HookScope = \"scenario\" | \"feature\" | \"global\";\nexport type HookTiming = \"before\" | \"after\";\n\n/** Lightweight scenario identity handed to per-scenario hooks. */\nexport interface ScenarioInfo {\n  name: string;\n  file: string;\n}\n\n/** A per-scenario hook: gets the scenario's world (read-only in spirit). */\nexport type ScenarioHookFn = (context: {\n  world: MergeableWorld<any, any, any>;\n  scenario: ScenarioInfo;\n}) => void | Promise<void>;\n\n/** A per-feature-file or global hook: no world exists at these boundaries. */\nexport type PlainHookFn = () => void | Promise<void>;\n\nexport interface RegisteredHook {\n  scope: HookScope;\n  timing: HookTiming;\n  fn: ScenarioHookFn | PlainHookFn;\n}\n\n/**\n * Collection of registered hooks. Like {@link StepRegistry}, a plain instance\n * (not a hidden global) so tests can isolate; `globalHookRegistry` is the\n * default sink the public `beforeScenario`/`afterAll`/etc helpers write to.\n */\nexport class HookRegistry {\n  private hooks: RegisteredHook[] = [];\n\n  add(hook: RegisteredHook): void {\n    this.hooks.push(hook);\n  }\n\n  /**\n   * Hooks for a scope+timing. `before` hooks run in registration order;\n   * `after` hooks run in reverse (LIFO), so teardown unwinds setup.\n   */\n  for(scope: HookScope, timing: HookTiming): RegisteredHook[] {\n    const matching = this.hooks.filter(\n      h => h.scope === scope && h.timing === timing\n    );\n    return timing === \"after\" ? matching.reverse() : matching;\n  }\n\n  clear(): void {\n    this.hooks = [];\n  }\n}\n\nexport const globalHookRegistry = new HookRegistry();\n\n/**\n * Run every registered feature/global hook of a scope+timing in order. Used by\n * the generated test modules (feature hooks). Throws if a hook throws, so the\n * runner reports it against the enclosing boundary.\n */\nexport async function runHooks(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  for (const hook of registry.for(scope, timing)) {\n    await (hook.fn as PlainHookFn)();\n  }\n}\n\n// Process-global (via Symbol.for so it survives module duplication) guard so\n// global hooks fire exactly once per worker, no matter how many feature modules\n// call in.\nconst GLOBAL_GUARD = Symbol.for(\"step-forge.globalHooksStarted\");\n\n/**\n * Run global before-hooks once per worker, ahead of that worker's first\n * scenario, and schedule global after-hooks for worker exit. Idempotent: every\n * feature module calls this in a `beforeAll`, but only the first call in a given\n * worker does anything.\n *\n * Semantics & caveats (the once-per-worker model):\n * - Runs in the *same* realm as steps, so global setup may touch in-process\n *   state that steps later read.\n * - \"Once per worker\", not strictly once per run — with multiple workers it runs\n *   in each. Size global setup to be worker-safe (e.g. a server per worker).\n * - Teardown is best-effort: after-hooks start on the worker's `beforeExit` and\n *   are not awaited by the runner, so keep them fast/synchronous.\n */\nexport async function ensureGlobalHooks(\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  const store = globalThis as Record<symbol, boolean>;\n  if (store[GLOBAL_GUARD]) return;\n  store[GLOBAL_GUARD] = true;\n\n  for (const hook of registry.for(\"global\", \"before\")) {\n    await (hook.fn as PlainHookFn)();\n  }\n\n  process.once(\"beforeExit\", () => {\n    void (async () => {\n      for (const hook of registry.for(\"global\", \"after\")) {\n        await (hook.fn as PlainHookFn)();\n      }\n    })();\n  });\n}\n"],"mappings":";;;;;;AAkCA,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;CAEA,MAAiC;EAC/B,OAAO,KAAK;CACd;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,iBAAiB,IAAI,aAAa;;;;;;;;ACX/C,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;;;;;CAMA,IAAI,OAAkB,QAAsC;EAC1D,MAAM,WAAW,KAAK,MAAM,QAC1B,MAAK,EAAE,UAAU,SAAS,EAAE,WAAW,MACzC;EACA,OAAO,WAAW,UAAU,SAAS,QAAQ,IAAI;CACnD;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,qBAAqB,IAAI,aAAa;;;;;;AAOnD,eAAsB,SACpB,OACA,QACA,WAAyB,oBACV;CACf,KAAK,MAAM,QAAQ,SAAS,IAAI,OAAO,MAAM,GAC3C,MAAO,KAAK,GAAmB;AAEnC;AAKA,MAAM,eAAe,OAAO,IAAI,+BAA+B;;;;;;;;;;;;;;;AAgB/D,eAAsB,kBACpB,WAAyB,oBACV;CACf,MAAM,QAAQ;CACd,IAAI,MAAM,eAAe;CACzB,MAAM,gBAAgB;CAEtB,KAAK,MAAM,QAAQ,SAAS,IAAI,UAAU,QAAQ,GAChD,MAAO,KAAK,GAAmB;CAGjC,QAAQ,KAAK,oBAAoB;EAC/B,CAAM,YAAY;GAChB,KAAK,MAAM,QAAQ,SAAS,IAAI,UAAU,OAAO,GAC/C,MAAO,KAAK,GAAmB;EAEnC,EAAA,CAAG;CACL,CAAC;AACH"}
+{"version":3,"file":"hooks-Be0cjULN.cjs","names":[],"sources":["../../src/runtime/registry.ts","../../src/runtime/hooks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Parser } from \"../parsers\";\nimport { MergeableWorld } from \"../world\";\n\nexport type StepType = \"given\" | \"when\" | \"then\";\n\n/**\n * A step definition as it exists at *runtime*, independent of any test runner.\n *\n * `execute` is the fully-wired step body: given a world and the raw values\n * captured from a Gherkin step, it applies parsers, validates + narrows\n * dependencies, runs the user's step function, and merges the result back into\n * the world. The engine never needs to know how any of that works — it just\n * matches text to a step and calls `execute`.\n */\nexport interface RegisteredStep {\n  stepType: StepType;\n  /** The Cucumber-expression source, e.g. `a user named {string}`. */\n  expression: string;\n  /** Parsers, one per captured variable, applied after expression capture. */\n  parsers: Parser<any>[];\n  execute: (\n    world: MergeableWorld<any, any, any>,\n    capturedArgs: unknown[]\n  ) => Promise<void>;\n  /** Where the step was defined, for ambiguous-match diagnostics. */\n  source?: string;\n}\n\n/**\n * A collection of registered steps. Deliberately a plain instance (not a hidden\n * module global) so tests and the Vitest plugin can create isolated registries.\n * `globalRegistry` is the default sink that `.step()` writes to.\n */\nexport class StepRegistry {\n  private steps: RegisteredStep[] = [];\n\n  add(step: RegisteredStep): void {\n    this.steps.push(step);\n  }\n\n  all(): readonly RegisteredStep[] {\n    return this.steps;\n  }\n\n  clear(): void {\n    this.steps = [];\n  }\n}\n\nexport const globalRegistry = new StepRegistry();\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { MergeableWorld } from \"../world\";\n\n/**\n * Hooks are side-effect callbacks that run around scenarios, feature files, or\n * the whole run. Unlike steps they never seed state: state is owned end to end\n * by the typed dependency graph (given/when/then), and hooks exist for setup and\n * teardown (opening a DB, starting a server, resetting mocks). A scenario hook\n * may *read* the world, but its return value is ignored.\n */\nexport type HookScope = \"scenario\" | \"feature\" | \"global\";\nexport type HookTiming = \"before\" | \"after\";\n\n/** Lightweight scenario identity handed to per-scenario hooks. */\nexport interface ScenarioInfo {\n  name: string;\n  file: string;\n}\n\n/** A per-scenario hook: gets the scenario's world (read-only in spirit). */\nexport type ScenarioHookFn = (context: {\n  world: MergeableWorld<any, any, any>;\n  scenario: ScenarioInfo;\n}) => void | Promise<void>;\n\n/** A per-feature-file or global hook: no world exists at these boundaries. */\nexport type PlainHookFn = () => void | Promise<void>;\n\nexport interface RegisteredHook {\n  scope: HookScope;\n  timing: HookTiming;\n  fn: ScenarioHookFn | PlainHookFn;\n}\n\n/**\n * Collection of registered hooks. Like {@link StepRegistry}, a plain instance\n * (not a hidden global) so tests can isolate; `globalHookRegistry` is the\n * default sink the public `beforeScenario`/`afterAll`/etc helpers write to.\n */\nexport class HookRegistry {\n  private hooks: RegisteredHook[] = [];\n\n  add(hook: RegisteredHook): void {\n    this.hooks.push(hook);\n  }\n\n  /**\n   * Hooks for a scope+timing. `before` hooks run in registration order;\n   * `after` hooks run in reverse (LIFO), so teardown unwinds setup.\n   */\n  for(scope: HookScope, timing: HookTiming): RegisteredHook[] {\n    const matching = this.hooks.filter(\n      h => h.scope === scope && h.timing === timing\n    );\n    return timing === \"after\" ? matching.reverse() : matching;\n  }\n\n  clear(): void {\n    this.hooks = [];\n  }\n}\n\nexport const globalHookRegistry = new HookRegistry();\n\n/**\n * Run every registered hook of a scope+timing **in registration order** (after\n * hooks reversed by {@link HookRegistry.for}, so teardown unwinds setup). Used\n * for feature hooks, where ordering matters. Throws if a hook throws, so the\n * runner reports it against the enclosing boundary.\n */\nexport async function runHooks(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  for (const hook of registry.for(scope, timing)) {\n    await (hook.fn as PlainHookFn)();\n  }\n}\n\n/**\n * Run every registered hook of a scope+timing **concurrently**, resolving once\n * all of them settle. This is how global `beforeAll`/`afterAll` run: independent\n * setup/teardown steps fire in parallel with no ordering between them. A hook\n * with a sequential requirement should sequence that work inside a single hook.\n *\n * The runner calls this exactly once for `beforeAll` (before any scenario\n * starts) and once for `afterAll` (after every scenario is done), so global\n * setup/teardown brackets the whole run deterministically. Rejects if any hook\n * rejects (via `Promise.all`), surfacing the first failure to the caller.\n */\nexport async function runHooksParallel(\n  scope: \"feature\" | \"global\",\n  timing: HookTiming,\n  registry: HookRegistry = globalHookRegistry\n): Promise<void> {\n  await Promise.all(\n    registry.for(scope, timing).map(hook => (hook.fn as PlainHookFn)())\n  );\n}\n"],"mappings":";;;;;;AAkCA,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;CAEA,MAAiC;EAC/B,OAAO,KAAK;CACd;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,iBAAiB,IAAI,aAAa;;;;;;;;ACX/C,IAAa,eAAb,MAA0B;CACxB,QAAkC,CAAC;CAEnC,IAAI,MAA4B;EAC9B,KAAK,MAAM,KAAK,IAAI;CACtB;;;;;CAMA,IAAI,OAAkB,QAAsC;EAC1D,MAAM,WAAW,KAAK,MAAM,QAC1B,MAAK,EAAE,UAAU,SAAS,EAAE,WAAW,MACzC;EACA,OAAO,WAAW,UAAU,SAAS,QAAQ,IAAI;CACnD;CAEA,QAAc;EACZ,KAAK,QAAQ,CAAC;CAChB;AACF;AAEA,MAAa,qBAAqB,IAAI,aAAa;;;;;;;AAQnD,eAAsB,SACpB,OACA,QACA,WAAyB,oBACV;CACf,KAAK,MAAM,QAAQ,SAAS,IAAI,OAAO,MAAM,GAC3C,MAAO,KAAK,GAAmB;AAEnC;;;;;;;;;;;;AAaA,eAAsB,iBACpB,OACA,QACA,WAAyB,oBACV;CACf,MAAM,QAAQ,IACZ,SAAS,IAAI,OAAO,MAAM,CAAC,CAAC,KAAI,SAAS,KAAK,GAAmB,CAAC,CACpE;AACF"}