@g_package/jest-cucumber-fusion 2.0.0 → 3.0.0

package/src/index.js

@@ -1,34 +1,114 @@
+// The public surface: the step verbs, the hooks, the registry they write into, and Fusion.
+//
+// Everything Fusion does beyond holding the registry is delegated: the option merge to
+// src/configuration.js, the outside world (the feature file, the parser, the caller stack) to
+// src/feature-source.js, and the Jest runner to src/test-registration.js. Both ports are
+// required by module path and are never exported, so they stay internal.
+import { inspect } from "util";
+import { mergeFusionOptions, setFusionConfiguration } from "./configuration.js";
+import * as featureSource from "./feature-source.js";
+import * as testRegistration from "./test-registration.js";
+import { shared, replaceShared } from "./shared-state.js";
+
+// Each bucket is keyed by step text or regex source, so it has no prototype: a step whose text
+// is `constructor` or `toString` would otherwise find the inherited property and be refused as
+// a duplicate on its first registration (fresh fuzz of PR #16, 2026-10-10, B2).
+const emptyBucket = () => Object.create(null);
 const emptyStepsDefinition = () => ({
-  given: {},
-  when: {},
-  then: {},
-  and: {},
-  but: {},
+  given: emptyBucket(),
+  when: emptyBucket(),
+  then: emptyBucket(),
+  and: emptyBucket(),
+  but: emptyBucket(),
   before: [],
   after: [],
 });
 
-// Module-level registry. Rebuilt from the empty shape above once a feature has been
-// loaded, so a second Fusion() in the same module starts from a clean slate rather
+// The registry the verbs and hooks write into. It lives in src/shared-state.js, not in a module
+// variable, so that a step file using one copy of the dual package (import) and a shared step
+// library using the other (require) register into the same one. Rebuilt from the empty shape
+// above once a feature has been loaded, so a second Fusion() starts from a clean slate rather
 // than inheriting the previous feature's step definitions and hooks.
-let stepsDefinition = emptyStepsDefinition();
+const stepsDefinition = () => shared("steps", emptyStepsDefinition);
+
+const isRegExp = (candidate) =>
+  Object.prototype.toString.call(candidate) === "[object RegExp]";
+
+const isStepMatcher = (candidate) =>
+  typeof candidate === "string" || isRegExp(candidate);
+
+const verbNamed = (definitionType) =>
+  definitionType.charAt(0).toUpperCase() + definitionType.slice(1);
+
+const whatTheMatcherWas = (candidate) =>
+  candidate === undefined || candidate === null
+    ? String(candidate)
+    : `${typeof candidate} ${inspect(candidate)}`;
+
+// Refused at the call, like every other misuse. Until 3.0.0 a matcher of any other type was
+// silently ignored, so the scenario failed later as an unbound step, far from the mistake.
+const refuseUnsupportedMatcher = (definitionType, candidate) =>
+  new Error(
+    `Unsupported step matcher: ${verbNamed(
+      definitionType,
+    )} was given ${whatTheMatcherWas(candidate)}.\n\n` +
+      `WHY:  Fusion binds a step definition to the feature's steps by its matcher, and only\n` +
+      `      a string or a regular expression can match a step's text. Any other matcher\n` +
+      `      binds nothing, and the step would then fail as unbound, far from this call.\n` +
+      `HOW:  pass the step's text, ${verbNamed(
+        definitionType,
+      )}("the shop is open", fn), or a regular\n` +
+      `      expression, ${verbNamed(
+        definitionType,
+      )}(/^(\\d+) items? in the basket$/, fn).`,
+  );
+
+// Refused at the call too. Accepted, a definition with no function failed only when its step
+// ran, as "step.bound.stepFn is not a function" (fresh fuzz of PR #16, 2026-10-10).
+const refuseMissingStepFunction = (
+  definitionType,
+  matcher,
+  fnForDefinition,
+) => {
+  const call = `${verbNamed(definitionType)}(${
+    typeof matcher === "string" ? JSON.stringify(matcher) : String(matcher)
+  })`;
+  return new Error(
+    `Missing step function: ${call} was given ${whatTheMatcherWas(
+      fnForDefinition,
+    )}.\n\n` +
+      `WHY:  the function is what runs when a step matches, so a definition without one\n` +
+      `      would fail only when its step ran, far from this call.\n` +
+      `HOW:  pass the step's code as the second argument, for example\n` +
+      `      ${call.slice(0, -1)}, () => { ... }).`,
+  );
+};
 
 const addDefinitionFunction = (
   definitionType,
   regexpSentence,
-  fnForDefinition
+  fnForDefinition,
 ) => {
-  if (stepsDefinition[definitionType]) {
-    if (regexpSentence.constructor === RegExp) {
+  if (!isStepMatcher(regexpSentence))
+    throw refuseUnsupportedMatcher(definitionType, regexpSentence);
+  if (typeof fnForDefinition !== "function")
+    throw refuseMissingStepFunction(
+      definitionType,
+      regexpSentence,
+      fnForDefinition,
+    );
+
+  if (stepsDefinition()[definitionType]) {
+    if (isRegExp(regexpSentence)) {
       throwIfDuplicateMatcher(definitionType, regexpSentence.source);
-      stepsDefinition[definitionType][regexpSentence.source] = {
+      stepsDefinition()[definitionType][regexpSentence.source] = {
         stepRegExp: regexpSentence,
         stepExpression: null,
         stepFn: fnForDefinition,
       };
-    } else if (typeof regexpSentence === "string") {
+    } else {
       throwIfDuplicateMatcher(definitionType, regexpSentence);
-      stepsDefinition[definitionType][regexpSentence] = {
+      stepsDefinition()[definitionType][regexpSentence] = {
         stepRegExp: null,
         stepExpression: regexpSentence,
         stepFn: fnForDefinition,
@@ -38,9 +118,9 @@ const addDefinitionFunction = (
 };
 
 const throwIfDuplicateMatcher = (definitionType, matcherKey) => {
-  if (stepsDefinition[definitionType][matcherKey])
+  if (stepsDefinition()[definitionType][matcherKey])
     throw new Error(
-      `Duplicate step definition: "${matcherKey}" is already registered for "${definitionType}"`
+      `Duplicate step definition: "${matcherKey}" is already registered for "${definitionType}"`,
     );
 };
 
@@ -48,7 +128,7 @@ const Given = (regexpSentenceOrChainedObject, fnForDefinition) => {
   return defineAndChain(
     "given",
     regexpSentenceOrChainedObject,
-    fnForDefinition
+    fnForDefinition,
   );
 };
 const When = (regexpSentenceOrChainedObject, fnForDefinition) => {
@@ -65,18 +145,21 @@ const But = (regexpSentenceOrChainedObject, fnForDefinition) => {
   return defineAndChain("but", regexpSentenceOrChainedObject, fnForDefinition);
 };
 
+// The chained form: a StepChain handed back by an earlier verb, re-registered under a second
+// keyword. A single argument carrying a stepSentence is one of those; a matcher is not, and
+// the RegExp clause keeps a regex out even though a regex carries no stepSentence either.
+const isChainedStepObject = (candidate, fnForStep) =>
+  !fnForStep &&
+  candidate instanceof Object &&
+  Object.prototype.toString.call(candidate) !== "[object RegExp]" &&
+  candidate.stepSentence;
+
 const defineAndChain = (stepType, stepObjectOrSentence, fnForStep) => {
-  if (
-    !fnForStep &&
-    stepObjectOrSentence instanceof Object &&
-    Object.prototype.toString.call(stepObjectOrSentence) !==
-      "[object RegExp]" &&
-    stepObjectOrSentence.stepSentence
-  ) {
+  if (isChainedStepObject(stepObjectOrSentence, fnForStep)) {
     addDefinitionFunction(
       stepType,
       stepObjectOrSentence.stepSentence,
-      stepObjectOrSentence.stepFnDefinition
+      stepObjectOrSentence.stepFnDefinition,
     );
 
     return stepObjectOrSentence;
@@ -88,411 +171,61 @@ const defineAndChain = (stepType, stepObjectOrSentence, fnForStep) => {
 };
 
 const Before = (fnDefinition) => {
-  stepsDefinition.before.push(fnDefinition);
+  stepsDefinition().before.push(fnDefinition);
 };
 const After = (fnDefinition) => {
-  stepsDefinition.after.push(fnDefinition);
-};
+  stepsDefinition().after.push(fnDefinition);
+};
+
+// Fusion() with no path, or a non-string one, reached Node's path module and failed with its
+// raw `The "paths[1]" argument must be of type string` (fresh fuzz of PR #16, 2026-10-10).
+const refuseFeaturePathNotAString = (featureFileToLoad) =>
+  new Error(
+    `Fusion needs the feature file's path as a string, but was given ${whatTheMatcherWas(
+      featureFileToLoad,
+    )}.\n\n` +
+      `HOW:  pass the feature file's path, relative to this steps file, for example\n` +
+      `      Fusion("rocket-launching.feature"). A file: URL needs url.fileURLToPath first.`,
+  );
 
-const Fusion = (featureFileToLoad, optionsToPassToJestCucumber) => {
+const Fusion = (featureFileToLoad, optionsForThisFeature) => {
   try {
-    const path = require("path");
-    const callerSites = require("callsites");
-    // Resolve the feature path from the FIRST stack frame outside this package, so
-    // an in-package re-export/wrapper frame does not retarget it; guard a shallow
-    // stack (no external frame) so we never call getFileName() on undefined.
-    const externalFrame = callerSites
-      .default()
-      .find((currentFrame) => currentFrame.getFileName() !== __filename);
-    const callerSiteCaller = externalFrame ? externalFrame.getFileName() : "";
-    const dirOfCaller = path.dirname(callerSiteCaller || "");
-    const absoluteFeatureFilePath = path.resolve(
-      dirOfCaller,
-      featureFileToLoad
-    );
+    if (typeof featureFileToLoad !== "string")
+      throw refuseFeaturePathNotAString(featureFileToLoad);
+    const absoluteFeatureFilePath =
+      featureSource.resolveFeaturePath(featureFileToLoad);
+    const effectiveOptions = mergeFusionOptions(optionsForThisFeature);
 
-    const jestCucumber = require("jest-cucumber");
-    const feature = jestCucumber.loadFeature(
+    const loadedFeature = featureSource.loadFeature(
       absoluteFeatureFilePath,
-      optionsToPassToJestCucumber
-    );
-
-    // When jest-cucumber's own step-count validation is disabled ({ errors: false }),
-    // the wrapper must fail loudly on an unmatched step itself; otherwise stay silent
-    // so jest-cucumber's native validation remains the (transparent) source of truth.
-    const failOnUnmatchedStep = !!(
-      optionsToPassToJestCucumber &&
-      optionsToPassToJestCucumber.errors === false
-    );
-
-    // This feature binds the definitions and hooks registered for IT — captured before the
-    // registry is reset below, so the binding does not depend on when jest-cucumber invokes
-    // the callback.
-    const registryForThisFeature = stepsDefinition;
-
-    jestCucumber.defineFeature(feature, (testFn) => {
-      // jest-cucumber wraps the whole feature in ONE describe, so a hook registered here
-      // already runs around every test in it. Register each hook once per feature, never
-      // per scenario: N registrations would run every hook N times per test.
-      registerHooks(registryForThisFeature, beforeEach, afterEach);
-
-      if (feature.scenarios.length > 0)
-        matchJestTestSuiteWithCucumberFeature(
-          registryForThisFeature,
-          feature.scenarios,
-          testFn,
-          false,
-          failOnUnmatchedStep
-        );
-
-      if (feature.scenarioOutlines.length > 0)
-        matchJestTestSuiteWithCucumberFeature(
-          registryForThisFeature,
-          feature.scenarioOutlines,
-          testFn,
-          true,
-          failOnUnmatchedStep
-        );
-    });
-  } finally {
-    // Unconditional: Fusion() always leaves a clean slate — normal return OR throw. Rebinding
-    // the module-level registry (never mutating it in place) keeps the object captured above
-    // intact for the callback, while the next Fusion() starts empty and must re-register.
-    stepsDefinition = emptyStepsDefinition();
-  }
-};
-
-const registerHooks = (featureRegistry, beforeEachFn, afterEachFn) => {
-  featureRegistry.before.forEach((beforeHook) => beforeEachFn(beforeHook));
-  featureRegistry.after.forEach((afterHook) => afterEachFn(afterHook));
-};
-
-const matchJestTestSuiteWithCucumberFeature = (
-  featureRegistry,
-  featureScenariosOrOutline,
-  testFn,
-  isOutline,
-  failOnUnmatchedStep
-) => {
-  featureScenariosOrOutline.forEach((currentScenarioOrOutline) => {
-    matchJestTestWithCucumberScenario(
-      featureRegistry,
-      currentScenarioOrOutline.title,
-      currentScenarioOrOutline.steps,
-      testFn,
-      isOutline,
-      failOnUnmatchedStep
-    );
-  });
-};
-
-const matchJestTestWithCucumberScenario = (
-  featureRegistry,
-  currentScenarioTitle,
-  currentScenarioSteps,
-  testFn,
-  isOutline,
-  failOnUnmatchedStep
-) => {
-  testFn(currentScenarioTitle, ({ given, when, then, and, but }) => {
-    currentScenarioSteps.forEach((currentStep) => {
-      matchJestDefinitionWithCucumberStep(
-        featureRegistry,
-        { given, when, then, and, but },
-        currentStep,
-        isOutline,
-        failOnUnmatchedStep
-      );
-    });
-  });
-};
-
-const matchJestDefinitionWithCucumberStep = (
-  featureRegistry,
-  verbFunction,
-  currentStep,
-  isOutline,
-  failOnUnmatchedStep
-) => {
-  const foundMatchingStep = findMatchingStep(
-    featureRegistry,
-    currentStep,
-    isOutline
-  );
-  if (!foundMatchingStep) {
-    if (failOnUnmatchedStep)
-      throw new Error(`No step definition matches: "${currentStep.stepText}"`);
-    return;
-  }
-
-  // this will be the "given", "when", "then"...functions
-  verbFunction[currentStep.keyword](
-    foundMatchingStep.stepExpression,
-    foundMatchingStep.stepFn
-  );
-};
-
-const findMatchingStep = (featureRegistry, currentStep, isOutline) => {
-  const scenarioType = currentStep.keyword;
-  const scenarioSentence = currentStep.stepText;
-  const matchingSteps = Object.keys(featureRegistry[scenarioType]).filter(
-    (currentStepDefinitionFunction) => {
-      return isFunctionForScenario(
-        scenarioSentence,
-        featureRegistry[scenarioType][currentStepDefinitionFunction],
-        isOutline
-      );
-    }
-  );
-  if (matchingSteps.length === 0) return null;
-
-  if (matchingSteps.length > 1) {
-    const competingMatchers = matchingSteps
-      .map((matcherSource) => `"${matcherSource}"`)
-      .join(", ");
-    throw new Error(
-      `Ambiguous step definition: "${scenarioSentence}" matches ${matchingSteps.length} step definitions: ${competingMatchers}`
+      effectiveOptions,
     );
-  }
-
-  return injectVariable(
-    featureRegistry,
-    scenarioType,
-    scenarioSentence,
-    matchingSteps[0],
-    currentStep.stepArgument
-  );
-};
-
-const isFunctionForScenario = (
-  scenarioSentence,
-  stepDefinitionFunction,
-  isOutline
-) => {
-  if (stepDefinitionFunction.stepRegExp) {
-    if (isOutline && /<[\w]*>/.test(scenarioSentence)) {
-      return isPotentialStepFunctionForScenario(
-        scenarioSentence,
-        stepDefinitionFunction.stepRegExp
-      );
-    } else return scenarioSentence.match(stepDefinitionFunction.stepRegExp);
-  }
-
-  return scenarioSentence === stepDefinitionFunction.stepExpression;
-};
 
-// An ESCAPED paren is literal text, never a group delimiter — the same knowledge holdsCapturingGroup
-// (below) already encodes. Masking each `\(` / `\)` with an ordinary two-character body sequence keeps
-// every index and length identical to the raw source, so the group locator can run over the mask and
-// its result still addresses the RAW string.
-const maskEscapedParens = (stepFunctionDef) =>
-  stepFunctionDef.replace(/\\[()]/g, "\\-");
+    // This feature binds the definitions and hooks registered for IT, captured before the
+    // registry is reset below, so the binding never depends on registration that came after.
+    const registryForThisFeature = stepsDefinition();
 
-// The scenario sentence carries a matcher's parens/anchors as LITERAL characters, so a position in the
-// sentence is only comparable against the step function once its escapes are collapsed the same way.
-const asScenarioText = (stepFunctionDef) =>
-  stepFunctionDef
-    .replace(/\\\(/g, "(")
-    .replace(/\\\)/g, ")")
-    .replace(/\\\^/g, "^")
-    .replace(/\\\$/g, "$");
-
-const isPotentialStepFunctionForScenario = (
-  scenarioDefinition,
-  regStepFunc
-) => {
-  //so this one is tricky, to ensure we only find the
-  // step definition corresponding to actual steps function in the case of outlined gherkin
-  // we have to "disable" the outlining (since it can replace regular expression
-  // and then ensure that all "non-outlined" part do respect the regular expression of
-  // of the step function
-  // FIRST, we clean the string version of the step definition that has outline variable
-  const cleanedStepFunc = regStepFunc.source
-    .replace(/^\^/, "")
-    // .replace( /\\\(/g, '(' )
-    // .replace( /\\\)/g, ')')
-    // .replace( /\\\^/g, '^')
-    // .replace( /\\\$/g, '$')
-    .replace(/\$$/, "");
-  // .replace( /\([.\\]+[sSdDwWbB*][*?+]?\)|\(\[.*\](?:[+?*]{1}|\{\d\})\)/g, '' )
-
-  let currentScenarioPart;
-  let currentStepFuncLeft = cleanedStepFunc;
-  let currentScenarioDefLeft = scenarioDefinition;
-
-  //we step through each of the scenario outline variables
-  // from there, we will try to detect any regexp present in the
-  // step definition, so that we can ensure to find the right match
-  while (
-    (currentScenarioPart = /<[\w]*>/gi.exec(currentScenarioDefLeft)) != null
-  ) {
-    let fixedPart = currentScenarioPart.input.substring(
-      0,
-      currentScenarioPart.index
-    );
-    let idxCutScenarioPart =
-      currentScenarioPart.index + currentScenarioPart[0].length;
-
-    // The character class spans the source of a capturing group. It must include the digits 0-9:
-    // spelled `0` alone it cannot span a group whose source holds a digit 1-9, which makes EVERY
-    // bounded quantifier — "(\d{4})" — invisible to this detector and therefore unbindable in an
-    // outline, while "(\d+)" (no digit in its source) binds. Braces are not the cause; the digits are.
-    //
-    // Locate the group over the MASKED source, so an escaped paren can never be mistaken for a group
-    // boundary: previously the locator ran twice — once on the raw source, once on a source whose
-    // `\(`/`\)` had been unescaped into BARE parens — and the two disagreed about where (and whether)
-    // a group was. For "(\w+\(\))" the raw pass matched "(\)" while the unescaped pass ("(\w+())")
-    // matched nothing at all, and a guard that tested the first while dereferencing the second threw
-    // on the null. One escape-aware pass gives one answer: the real group, in raw coordinates.
-    const groupInStepFunc = /\([a-zA-Z0-9!|,:?*+.^=${}><\\\-]+\)/g.exec(
-      maskEscapedParens(currentStepFuncLeft)
+    testRegistration.registerFeature(
+      loadedFeature,
+      registryForThisFeature,
+      effectiveOptions,
     );
-    // The scenario sentence spells the step function's prefix as literal text, so the two are only
-    // comparable in scenario-text coordinates — escapes collapsed, one character each.
-    const stepFuncPrefixAsScenarioText = groupInStepFunc
-      ? asScenarioText(currentStepFuncLeft.substring(0, groupInStepFunc.index))
-      : "";
-
-    if (
-      groupInStepFunc &&
-      stepFuncPrefixAsScenarioText.length == currentScenarioPart.index
-    ) {
-      //if we have a regex inside our step function definition
-      // and that regex is at the same position than our Outlined variable
-      // we just need to check that the sentence match,
-      // so we can "evaluate" the step function and remove the regex in it
-      currentStepFuncLeft =
-        stepFuncPrefixAsScenarioText +
-        currentStepFuncLeft.substring(
-          groupInStepFunc.index + groupInStepFunc[0].length
-        );
-    } else if (
-      groupInStepFunc &&
-      groupInStepFunc.index < currentScenarioPart.index
-    ) {
-      //if we have a regex inside our step function definition
-      // but that regex is not at the same position than our outlined variable
-      // we need to evaluate the regex against the scenario part
-      const strRegexToEvaluate = currentStepFuncLeft.substring(
-        0,
-        groupInStepFunc.index + groupInStepFunc[0].length
-      );
-      const regexToEvaluate = new RegExp(strRegexToEvaluate);
-      const regIntermediatePart = regexToEvaluate.exec(
-        currentScenarioPart.input
-      );
-      if (regIntermediatePart) {
-        fixedPart = strRegexToEvaluate;
-        idxCutScenarioPart = regIntermediatePart[0].length;
-      }
-    }
-
-    const partIndex = currentStepFuncLeft.indexOf(fixedPart);
-    if (partIndex !== -1) {
-      currentStepFuncLeft = currentStepFuncLeft.substring(
-        partIndex + fixedPart.length
-      );
-      currentScenarioDefLeft =
-        currentScenarioDefLeft.substring(idxCutScenarioPart);
-    } else {
-      return false;
-    }
-  }
-
-  return (
-    (currentScenarioDefLeft === "" && currentStepFuncLeft === "") ||
-    evaluateStepFuncEndVsScenarioEnd(
-      currentStepFuncLeft,
-      currentScenarioDefLeft
-    )
-  );
-};
-
-// A leftover fragment holds a CAPTURING group — so it has to be evaluated as a regex, not compared
-// as a literal. Escaped parens are stripped first (`\(n\)` is literal text, not a group) and `(?...)`
-// is skipped (non-capturing), so this recognises exactly the real groups.
-const holdsCapturingGroup = (stepFunctionDef) =>
-  /\((?!\?)[^()]*\)/.test(stepFunctionDef.replace(/\\[()]/g, ""));
-
-const evaluateStepFuncEndVsScenarioEnd = (
-  stepFunctionDef,
-  scenarioDefinition
-) => {
-  // The leftover is regex SOURCE, so a capturing group in it must be evaluated as a regex. The old
-  // test only recognised a group holding one of [sSdDwWbB*], which made the group's SPELLING the
-  // discriminator rather than its presence: " lamp is (on|off)" fell through to a literal endsWith
-  // (always false — the scenario text reads " lamp is on") and never bound, while the identically
-  // shaped " lamp is (on|down)" took the regex branch and bound. Widening is strict: every fragment
-  // that already took the regex branch still does.
-  if (
-    /\(.*(\?\:)?[.\\]*[sSdDwWbB*][*?+]?.*\)|\(\[.*\](?:[+?*]{1}|\{\d\})\)/g.test(
-      stepFunctionDef
-    ) ||
-    holdsCapturingGroup(stepFunctionDef)
-  ) {
-    return new RegExp(stepFunctionDef).test(scenarioDefinition);
-  }
-
-  return stepFunctionDef.endsWith(scenarioDefinition);
-};
-
-const injectVariable = (
-  featureRegistry,
-  scenarioType,
-  scenarioSentence,
-  stepFunctionDefinition,
-  stepArgs
-) => {
-  const stepObject = featureRegistry[scenarioType][stepFunctionDefinition];
-
-  if (!stepObject.stepRegExp)
-    return {
-      stepExpression: scenarioSentence,
-      // Forward through a rest-param wrapper so the reported arity is 0.
-      // jest-cucumber v4.4.0+ treats an arity mismatch (stepFn.length >
-      // matched args) as a request for a done() callback and then blocks
-      // on a Promise that never resolves. A rest param has length 0 while
-      // still passing along whatever args jest-cucumber provides.
-      stepFn: (...args) => stepObject.stepFn(...args),
-    };
-
-  const exprMatches = stepObject.stepRegExp.exec(scenarioSentence);
-
-  if (!exprMatches || /<.*>/.test(scenarioSentence))
-    return {
-      stepExpression: stepObject.stepRegExp,
-      // See note above: keep arity 0 to avoid jest-cucumber's done-callback
-      // heuristic hanging the step (matters for plain scenarios whose text
-      // contains "<...>" and for outline template steps).
-      stepFn: (...args) => stepObject.stepFn(...args),
-    };
-
-  const dynamicMatchThatAreVariables = [];
-
-  exprMatches.forEach((match, groupIndex) => {
-    if (groupIndex > 0) dynamicMatchThatAreVariables.push(match);
-  });
-
-  // Forward the step's Gherkin argument on PRESENCE, never on its type — the same test jest-cucumber
-  // itself applies before handing an argument to a step (feature-definition-creation.js:129-130). A
-  // type test drops half the shapes: Gherkin parses a data table to an array but a docstring to a
-  // string, and an empty docstring to "" — which a `.length` test would drop too. Absent, the argument
-  // is null, so this is the whole distinction that matters.
-  if (stepArgs != null) {
-    dynamicMatchThatAreVariables.push(stepArgs);
+  } finally {
+    // Unconditional: Fusion() always leaves a clean slate (normal return OR throw). Replacing
+    // the shared registry (never mutating it in place) keeps the object captured above intact
+    // for whoever still holds it, while the next Fusion() starts empty and must re-register.
+    replaceShared("steps", emptyStepsDefinition());
   }
-
-  return {
-    stepExpression: stepObject.stepRegExp,
-    stepFn: () => stepObject.stepFn(...dynamicMatchThatAreVariables),
-  };
 };
 
-module.exports.Before = Before;
-module.exports.After = After;
-module.exports.Given = Given;
-module.exports.When = When;
-module.exports.Then = Then;
-module.exports.And = And;
-module.exports.But = But;
-module.exports.Fusion = Fusion;
+export { Before };
+export { After };
+export { Given };
+export { When };
+export { Then };
+export { And };
+export { But };
+export { Fusion };
+// Re-exported, not re-implemented: the module that owns the merge owns the layer the setter
+// writes, so the entry point keeps no state of its own.
+export { setFusionConfiguration };