@fairfox/polly 0.82.1 → 0.83.0

package/dist/tools/bdd/src/cli.js

@@ -0,0 +1,701 @@
+#!/usr/bin/env bun
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// tools/bdd/src/parse.ts
+import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
+import { IdGenerator } from "@cucumber/messages";
+function newParser() {
+  return new Parser(new AstBuilder(IdGenerator.uuid()), new GherkinClassicTokenMatcher);
+}
+function normalizeKeyword(raw, prev) {
+  const k = raw.trim().toLowerCase();
+  if (k === "given")
+    return "given";
+  if (k === "when")
+    return "when";
+  if (k === "then")
+    return "then";
+  return prev ?? "given";
+}
+function normalizeSteps(rawSteps) {
+  const out = [];
+  let prev = null;
+  for (const s of rawSteps) {
+    const keyword = normalizeKeyword(s.keyword, prev);
+    prev = keyword;
+    out.push({
+      keyword,
+      rawKeyword: s.keyword.trim(),
+      text: s.text.trim(),
+      line: s.location?.line ?? 0
+    });
+  }
+  return out;
+}
+function tagNames(tags) {
+  return (tags ?? []).map((t) => t.name.replace(/^@/, ""));
+}
+function fillOutline(text, headers, cells) {
+  let filled = text;
+  headers.forEach((h, i) => {
+    filled = filled.split(`<${h}>`).join(cells[i] ?? "");
+  });
+  return filled;
+}
+function buildScenarios(sc) {
+  const baseSteps = sc.steps ?? [];
+  const tags = tagNames(sc.tags);
+  const examples = sc.examples ?? [];
+  if (examples.length === 0) {
+    return [
+      { name: sc.name, tags, steps: normalizeSteps(baseSteps), line: sc.location?.line ?? 0 }
+    ];
+  }
+  const out = [];
+  for (const ex of examples) {
+    const headers = (ex.tableHeader?.cells ?? []).map((c) => c.value);
+    for (const row of ex.tableBody ?? []) {
+      const cells = (row.cells ?? []).map((c) => c.value);
+      const rowSteps = baseSteps.map((s) => ({
+        keyword: s.keyword,
+        text: fillOutline(s.text, headers, cells),
+        location: s.location
+      }));
+      const label = headers.map((h, i) => `${h}=${cells[i] ?? ""}`).join(", ");
+      out.push({
+        name: `${sc.name} [${label}]`,
+        tags: [...tags, ...tagNames(ex.tags)],
+        steps: normalizeSteps(rowSteps),
+        line: row.location?.line ?? sc.location?.line ?? 0,
+        fromOutline: true
+      });
+    }
+  }
+  return out;
+}
+function parseFeatureText(text, file) {
+  const doc = newParser().parse(text);
+  const feature = doc.feature;
+  if (!feature) {
+    return { name: "", description: "", tags: [], background: [], scenarios: [], file };
+  }
+  let background = [];
+  const scenarios = [];
+  for (const child of feature.children ?? []) {
+    if (child.background) {
+      background = normalizeSteps(child.background.steps ?? []);
+    } else if (child.scenario) {
+      scenarios.push(...buildScenarios(child.scenario));
+    }
+  }
+  return {
+    name: feature.name,
+    description: (feature.description ?? "").trim(),
+    tags: tagNames(feature.tags),
+    background,
+    scenarios,
+    file
+  };
+}
+async function parseFeatureFile(path) {
+  const text = await Bun.file(path).text();
+  return parseFeatureText(text, path);
+}
+var init_parse = () => {};
+
+// tools/bdd/src/steps.ts
+function state() {
+  globalThis.__pollyBddRegistry__ ??= { bindings: [], worldDef: null };
+  return globalThis.__pollyBddRegistry__;
+}
+function compilePattern(pattern) {
+  const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const withGroups = escaped.replace(/\\\{string\\\}/g, `(?:"([^"]*)"|'([^']*)')`).replace(/\\\{int\\\}/g, "([-+]?\\d+)").replace(/\\\{float\\\}/g, "([-+]?\\d*\\.?\\d+)").replace(/\\\{word\\\}/g, "([^\\s]+)");
+  return new RegExp(`^${withGroups}$`);
+}
+function defineStep(binding) {
+  state().bindings.push({ binding, regex: compilePattern(binding.pattern) });
+}
+function defineWorld(def) {
+  state().worldDef = def;
+}
+function getWorldDef() {
+  return state().worldDef;
+}
+function resetRegistry() {
+  const s = state();
+  s.bindings.length = 0;
+  s.worldDef = null;
+}
+function matchStep(text, keyword) {
+  let textOnlyFallback = null;
+  for (const { binding, regex } of state().bindings) {
+    const m = regex.exec(text);
+    if (!m)
+      continue;
+    const args = m.slice(1).filter((g) => g !== undefined);
+    if (!keyword || binding[keyword])
+      return { binding, args };
+    textOnlyFallback ??= { binding, args };
+  }
+  return textOnlyFallback;
+}
+function registeredBindings() {
+  return state().bindings.map((c) => c.binding);
+}
+
+// tools/bdd/src/cli.ts
+import { resolve as resolve4 } from "node:path";
+
+// tools/bdd/src/args.ts
+var VALUE_FLAGS = new Set(["--features", "--steps", "--tags"]);
+function parseBddArgs(argv) {
+  const positionals = [];
+  const flags = new Map;
+  const bools = new Set;
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i] ?? "";
+    if (VALUE_FLAGS.has(a)) {
+      flags.set(a, argv[i + 1] ?? "");
+      i += 2;
+    } else {
+      if (a.startsWith("-"))
+        bools.add(a);
+      else
+        positionals.push(a);
+      i += 1;
+    }
+  }
+  return {
+    verb: positionals[0] ?? "run",
+    rest: positionals.slice(1),
+    features: flags.get("--features"),
+    steps: flags.get("--steps"),
+    tags: flags.get("--tags"),
+    json: bools.has("--json"),
+    help: bools.has("--help") || bools.has("-h")
+  };
+}
+
+// tools/bdd/src/check-verify.ts
+import { resolve } from "node:path";
+
+// tools/bdd/src/extract.ts
+init_parse();
+async function loadStepModules(stepFiles) {
+  resetRegistry();
+  for (const file of stepFiles) {
+    await import(`${file}?t=${Bun.nanoseconds()}`);
+  }
+}
+function toTraceStep(text, keyword) {
+  const match = matchStep(text, keyword);
+  if (!match)
+    return { text, keyword, unbound: true };
+  return {
+    text,
+    keyword,
+    message: match.binding.message,
+    stateExpr: match.binding.stateExpr
+  };
+}
+async function extractTraces(featureFiles, stepFiles) {
+  await loadStepModules(stepFiles);
+  const traces = [];
+  for (const file of featureFiles) {
+    const feature = await parseFeatureFile(file);
+    for (const scenario of feature.scenarios) {
+      const allSteps = [...feature.background, ...scenario.steps];
+      const trace = {
+        feature: feature.name,
+        scenario: scenario.name,
+        tags: [...feature.tags, ...scenario.tags],
+        given: [],
+        when: [],
+        then: [],
+        file
+      };
+      for (const step of allSteps) {
+        trace[step.keyword].push(toTraceStep(step.text, step.keyword));
+      }
+      traces.push(trace);
+    }
+  }
+  return traces;
+}
+
+// tools/bdd/src/check-verify.ts
+async function loadVerifyConfig(configPath) {
+  const mod = await import(`file://${resolve(configPath)}?t=${Bun.nanoseconds()}`);
+  const config = mod.verificationConfig ?? mod.default;
+  if (!config)
+    throw new Error(`no verificationConfig/default export in ${configPath}`);
+  return config;
+}
+function messageSet(config) {
+  const set = new Set;
+  for (const t of config.messages?.include ?? [])
+    set.add(t);
+  for (const t of Object.keys(config.messages?.perMessageBounds ?? {}))
+    set.add(t);
+  for (const sub of Object.values(config.subsystems ?? {})) {
+    for (const h of sub.handlers ?? [])
+      set.add(h);
+  }
+  return set;
+}
+function stateKeys(config) {
+  const keys = new Set(Object.keys(config.state ?? {}));
+  for (const sub of Object.values(config.subsystems ?? {})) {
+    for (const f of sub.state ?? [])
+      keys.add(f);
+  }
+  return [...keys];
+}
+function fieldsIn(expr) {
+  const noStrings = expr.replace(/"[^"]*"|'[^']*'/g, "");
+  const ids = noStrings.match(/[a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*)*/g) ?? [];
+  const ignore = new Set(["true", "false", "null", "undefined", "length", "value"]);
+  return ids.filter((id) => !ignore.has(id) && Number.isNaN(Number(id)));
+}
+function fieldKnown(field, keys) {
+  return keys.some((k) => k === field || field.startsWith(`${k}.`) || k.startsWith(`${field}.`));
+}
+var NEGATIVE_TAGS = new Set(["negative", "formal"]);
+function checkTrace(trace, messages, keys, findings) {
+  const id = `${trace.feature} › ${trace.scenario}`;
+  for (const step of [...trace.given, ...trace.when, ...trace.then]) {
+    if (step.unbound) {
+      findings.push({ kind: "warn", scenario: id, message: `step has no binding: "${step.text}"` });
+    }
+  }
+  for (const step of trace.when) {
+    if (step.message && !messages.has(step.message)) {
+      findings.push({
+        kind: "error",
+        scenario: id,
+        message: `When sends "${step.message}", which the verification config does not model`
+      });
+    }
+  }
+  for (const step of [...trace.given, ...trace.then]) {
+    if (!step.stateExpr)
+      continue;
+    for (const field of fieldsIn(step.stateExpr)) {
+      if (!fieldKnown(field, keys)) {
+        findings.push({
+          kind: "error",
+          scenario: id,
+          message: `${step.keyword} asserts on "${field}", absent from the config's state map`
+        });
+      }
+    }
+  }
+}
+function featureNeedsNegative(traces) {
+  return traces.some((t) => t.then.some((s) => /\bnot\b|exclud|reject|empty|invalid|limit|forbidden/i.test(s.text)));
+}
+function checkNegativeComplement(traces, findings) {
+  const byFeature = new Map;
+  for (const t of traces) {
+    const arr = byFeature.get(t.feature) ?? [];
+    arr.push(t);
+    byFeature.set(t.feature, arr);
+  }
+  for (const [feature, group] of byFeature) {
+    const hasNegative = group.some((t) => t.tags.some((tag) => NEGATIVE_TAGS.has(tag)));
+    if (!hasNegative && featureNeedsNegative(group)) {
+      findings.push({
+        kind: "warn",
+        scenario: feature,
+        message: "feature filters/selects/validates but has no negative complement (a @negative or @formal scenario) — an over-permissive build would still pass"
+      });
+    }
+  }
+}
+async function checkAgainstVerify(opts) {
+  const config = await loadVerifyConfig(opts.configPath);
+  const messages = messageSet(config);
+  const keys = stateKeys(config);
+  const traces = await extractTraces(opts.featureFiles, opts.stepFiles);
+  const findings = [];
+  for (const trace of traces)
+    checkTrace(trace, messages, keys, findings);
+  checkNegativeComplement(traces, findings);
+  return {
+    ok: findings.every((f) => f.kind !== "error"),
+    checked: traces.length,
+    findings
+  };
+}
+
+// tools/bdd/src/config.ts
+import { resolve as resolve2 } from "node:path";
+import { Glob } from "bun";
+async function expand(cwd, pattern) {
+  const out = [];
+  for await (const f of new Glob(pattern).scan({ cwd, absolute: true, onlyFiles: true })) {
+    out.push(f);
+  }
+  return out.sort();
+}
+async function resolveBddConfig(cwd, args) {
+  const pathArg = args.verb === "run" ? args.rest[0] : undefined;
+  let featurePattern = args.features ?? "features/**/*.feature";
+  if (pathArg) {
+    featurePattern = pathArg.endsWith(".feature") ? pathArg : `${pathArg.replace(/\/$/, "")}/**/*.feature`;
+  }
+  const stepPatterns = args.steps ? [args.steps] : ["features/**/*.steps.ts", "features/steps.ts"];
+  const featureFiles = pathArg?.endsWith(".feature") ? [resolve2(cwd, pathArg)] : await expand(cwd, featurePattern);
+  const stepSets = await Promise.all(stepPatterns.map((p) => expand(cwd, p)));
+  const stepFiles = [...new Set(stepSets.flat())];
+  return { cwd, featureFiles, stepFiles };
+}
+
+// tools/bdd/src/report.ts
+var MARK = {
+  pass: "✓",
+  fail: "✗",
+  undefined: "?",
+  "deferred-formal": "→"
+};
+function relFile(file, cwd) {
+  return file.startsWith(cwd) ? file.slice(cwd.length + 1) : file;
+}
+function scenarioDetail(s) {
+  if (s.outcome === "deferred-formal") {
+    return [
+      "      deferred to polly verify — precondition is formal-only (requires() is a runtime no-op)"
+    ];
+  }
+  if (s.outcome !== "fail" && s.outcome !== "undefined")
+    return [];
+  const lines = [];
+  for (const step of s.steps) {
+    if (step.outcome !== "fail" && step.outcome !== "undefined")
+      continue;
+    lines.push(`      ${step.outcome === "fail" ? "✗" : "?"} ${step.rawKeyword} ${step.text}`);
+    if (step.message)
+      lines.push(`        ↳ ${step.message}`);
+  }
+  return lines;
+}
+function formatRun(result, cwd) {
+  const lines = [];
+  let currentFeature = "";
+  for (const s of result.scenarios) {
+    if (s.feature !== currentFeature) {
+      currentFeature = s.feature;
+      lines.push(`
+Feature: ${s.feature}  (${relFile(s.file, cwd)})`);
+    }
+    lines.push(`  ${MARK[s.outcome]} ${s.scenario}`);
+    lines.push(...scenarioDetail(s));
+  }
+  lines.push("");
+  lines.push(`${result.ok ? "✓" : "✗"} ${result.passed} passed, ${result.failed} failed, ` + `${result.undefinedSteps} undefined, ${result.deferred} deferred (formal)`);
+  return lines.join(`
+`);
+}
+function toJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+
+// tools/bdd/src/run.ts
+init_parse();
+var FORMAL_TAG = "formal";
+async function loadStepModules2(stepFiles) {
+  resetRegistry();
+  for (const file of stepFiles) {
+    await import(`${file}?t=${Bun.nanoseconds()}`);
+  }
+}
+function tagMatches(tags, filter) {
+  if (!filter)
+    return true;
+  if (filter.startsWith("~"))
+    return !tags.includes(filter.slice(1));
+  return tags.includes(filter);
+}
+async function runStep(world, step) {
+  const base = { text: step.text, rawKeyword: step.rawKeyword };
+  const match = matchStep(step.text, step.keyword);
+  if (!match) {
+    return { ...base, outcome: "undefined", message: `no binding matches "${step.text}"` };
+  }
+  const fn = match.binding[step.keyword];
+  if (!fn) {
+    return {
+      ...base,
+      outcome: "undefined",
+      message: `binding for "${step.text}" has no '${step.keyword}' callback`
+    };
+  }
+  try {
+    const ret = await fn(world, ...match.args);
+    if (ret !== undefined)
+      world.lastResponse = ret;
+    return { ...base, outcome: "pass" };
+  } catch (err) {
+    world.lastError = err;
+    return { ...base, outcome: "fail", message: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function runScenario(world, feature, scenario, reset) {
+  const result = {
+    feature: feature.name,
+    scenario: scenario.name,
+    tags: scenario.tags,
+    outcome: "pass",
+    steps: [],
+    file: feature.file
+  };
+  await reset(world);
+  world.vars = {};
+  world.lastResponse = undefined;
+  world.lastError = undefined;
+  const steps = [...feature.background, ...scenario.steps];
+  let aborted = false;
+  for (const step of steps) {
+    if (aborted) {
+      result.steps.push({ text: step.text, rawKeyword: step.rawKeyword, outcome: "skipped" });
+      continue;
+    }
+    const sr = await runStep(world, step);
+    result.steps.push(sr);
+    if (sr.outcome === "fail") {
+      result.outcome = "fail";
+      aborted = true;
+    } else if (sr.outcome === "undefined") {
+      result.outcome = result.outcome === "fail" ? "fail" : "undefined";
+      aborted = true;
+    }
+  }
+  return result;
+}
+async function runFeatures(options) {
+  await loadStepModules2(options.stepFiles);
+  const worldDef = getWorldDef();
+  if (!worldDef) {
+    throw new Error("no world defined. A step module must call defineWorld({ create, reset }) — see tools/bdd/README.md.");
+  }
+  const world = await worldDef.create();
+  const features = await Promise.all(options.featureFiles.map((f) => parseFeatureFile(f)));
+  const scenarios = [];
+  for (const feature of features) {
+    for (const scenario of feature.scenarios) {
+      const tags = [...feature.tags, ...scenario.tags];
+      if (!tagMatches(tags, options.tagFilter))
+        continue;
+      if (tags.includes(FORMAL_TAG)) {
+        scenarios.push({
+          feature: feature.name,
+          scenario: scenario.name,
+          tags,
+          outcome: "deferred-formal",
+          steps: [],
+          file: feature.file
+        });
+        continue;
+      }
+      scenarios.push(await runScenario(world, feature, { ...scenario, tags }, worldDef.reset));
+    }
+  }
+  const passed = scenarios.filter((s) => s.outcome === "pass").length;
+  const failed = scenarios.filter((s) => s.outcome === "fail").length;
+  const undef = scenarios.filter((s) => s.outcome === "undefined").length;
+  const deferred = scenarios.filter((s) => s.outcome === "deferred-formal").length;
+  return {
+    scenarios,
+    passed,
+    failed,
+    undefinedSteps: undef,
+    deferred,
+    ok: failed === 0 && undef === 0
+  };
+}
+
+// tools/bdd/src/scaffold.ts
+import { existsSync } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+async function loadVocabulary(configPath) {
+  if (!existsSync(configPath))
+    return { messages: [], fields: [] };
+  const mod = await import(`file://${resolve3(configPath)}?t=${Bun.nanoseconds()}`);
+  const config = mod.verificationConfig ?? mod.default ?? {};
+  const messages = new Set;
+  for (const t of config.messages?.include ?? [])
+    messages.add(t);
+  for (const t of Object.keys(config.messages?.perMessageBounds ?? {}))
+    messages.add(t);
+  for (const sub of Object.values(config.subsystems ?? {})) {
+    for (const h of sub.handlers ?? [])
+      messages.add(h);
+  }
+  return { messages: [...messages].sort(), fields: Object.keys(config.state ?? {}).sort() };
+}
+function slug(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+async function scaffoldFeature(cwd, name, configPath) {
+  const { messages, fields } = await loadVocabulary(configPath);
+  const featurePath = resolve3(cwd, "features", `${slug(name)}.feature`);
+  if (existsSync(featurePath)) {
+    return { created: false, featurePath, messages, fields };
+  }
+  const body = `Feature: ${name}
+  # Three-amigos: state the user story, then converge on declarative scenarios.
+  # As a <role> I want <capability> so that <benefit>.
+  #
+  # Bind each step in features/steps.ts. The dual-use binding carries formal
+  # metadata so 'polly bdd check' can cross-check it against the verify config:
+  #   When-steps declare \`message\` (a modeled message type)
+  #   Given/Then-steps declare \`stateExpr\` (a tracked state field)
+  #
+  # Message types this project models:
+${messages.map((m) => `  #   - ${m}`).join(`
+`) || "  #   (none found — is specs/verification.config.ts present?)"}
+  # State fields this project tracks:
+${fields.map((f) => `  #   - ${f}`).join(`
+`) || "  #   (none found)"}
+
+  Scenario: <name the behaviour by its outcome>
+    Given <context that is already true>
+    When <a single action>
+    Then <an observable outcome>
+
+  @negative
+  Scenario: <the negative complement — what is excluded / rejected / empty>
+    Given <context>
+    When <a single action>
+    Then <the system observably says no>
+`;
+  await Bun.write(featurePath, body);
+  return { created: true, featurePath, messages, fields };
+}
+
+// tools/bdd/src/cli.ts
+var HELP = `polly bdd — executable Gherkin against polly's handlers + state
+
+Three-amigos sessions produce acceptance examples from the user's perspective;
+this runs them across the real factory boundary and cross-checks them against
+the verification config — so the example layer, the formal layer, and the
+mutation layer all describe the same handlers and state.
+
+Usage:
+  polly bdd [run] [path]      Run .feature files (default: features/**/*.feature)
+  polly bdd check             Cross-check scenarios against specs/verification.config.ts
+  polly bdd new <name>        Scaffold a feature stub seeded from the verify vocabulary
+  polly bdd help              Show this help
+
+Flags:
+  --features <glob>   feature files (default: features/**/*.feature)
+  --steps <glob>      step modules to load (default: features/**/*.steps.ts + features/steps.ts)
+  --tags <tag>        only run scenarios with this tag (~tag negates)
+  --json              machine-readable output
+  -h, --help
+
+Scenarios tagged @formal cover precondition-only behaviour (requires() is a
+runtime no-op) — the runner defers them; 'polly verify' checks them, since the
+requires() guard is extracted into the TLA+ model.`;
+async function main() {
+  const args = parseBddArgs(process.argv.slice(2));
+  if (args.help || args.verb === "help") {
+    console.log(HELP);
+    return 0;
+  }
+  const cwd = process.cwd();
+  switch (args.verb) {
+    case "run": {
+      const cfg = await resolveBddConfig(cwd, args);
+      if (cfg.featureFiles.length === 0) {
+        console.log("No .feature files found (looked for features/**/*.feature).");
+        return 1;
+      }
+      if (cfg.stepFiles.length === 0) {
+        console.log("No step modules found (looked for features/**/*.steps.ts and features/steps.ts).");
+        return 1;
+      }
+      const result = await runFeatures({
+        featureFiles: cfg.featureFiles,
+        stepFiles: cfg.stepFiles,
+        tagFilter: args.tags
+      });
+      console.log(args.json ? toJson(result) : formatRun(result, cwd));
+      return result.ok ? 0 : 1;
+    }
+    case "check": {
+      const cfg = await resolveBddConfig(cwd, args);
+      const configPath = resolve4(cwd, "specs", "verification.config.ts");
+      const result = await checkAgainstVerify({
+        featureFiles: cfg.featureFiles,
+        stepFiles: cfg.stepFiles,
+        configPath
+      });
+      if (args.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return result.ok ? 0 : 1;
+      }
+      console.log(`
+Cross-checked ${result.checked} scenario(s) against the verification config:`);
+      if (result.findings.length === 0) {
+        console.log("  ✓ every When models a real message; every Given/Then names a tracked field");
+      }
+      for (const f of result.findings) {
+        console.log(`  ${f.kind === "error" ? "✗" : "⚠"} ${f.scenario}
+      ${f.message}`);
+      }
+      console.log(result.ok ? `
+✓ BDD ↔ verify cross-check holds.` : `
+✗ Cross-check failed.`);
+      return result.ok ? 0 : 1;
+    }
+    case "new": {
+      const name = args.rest.join(" ").trim();
+      if (!name) {
+        console.log("usage: polly bdd new <feature name>");
+        return 1;
+      }
+      const configPath = resolve4(cwd, "specs", "verification.config.ts");
+      const res = await scaffoldFeature(cwd, name, configPath);
+      if (!res.created) {
+        console.log(`${res.featurePath} already exists.`);
+        return 1;
+      }
+      console.log(`✓ wrote ${res.featurePath}`);
+      console.log(`  seeded from ${res.messages.length} message type(s), ${res.fields.length} state field(s)`);
+      console.log(`
+Next: bind the steps in features/steps.ts, then 'polly bdd run'.`);
+      return 0;
+    }
+    default:
+      console.log(`Unknown subcommand: ${args.verb}
+`);
+      console.log(HELP);
+      return 1;
+  }
+}
+main().then((code) => process.exit(code)).catch((err) => {
+  console.log(`
+❌ ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+});
+
+//# debugId=2DDEB2D363C2D86864756E2164756E21