dev-loops 0.1.0

package/scripts/loop/pre-flight-gate.mjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { buildParseError, formatCliError, isDirectCliRun } from "../_core-helpers.mjs";
+import { requireOptionValue } from "../_cli-primitives.mjs";
+import { createPiAdapter } from "@dev-loops/core/harness";
+import {
+  isUnderWorktreePath,
+  parseMainWorktreePath,
+  isMainCheckout,
+  parseAllWorktreePaths,
+  isListedWorktree,
+  detectSubagentAvailability,
+} from "@dev-loops/core/loop/worktree-guard";
+const PI_PREFLIGHT_BYPASS_VAR = "PI_PREFLIGHT_BYPASS";
+const USAGE = `Usage:
+  pre-flight-gate.mjs [--expected-branch <name>] [--check-subagents]
+Gate local implementation mutations before planning or editing.
+Required environment:
+  (none)
+Optional:
+  --expected-branch <name>   Expected current branch (for branch identity check).
+  --check-subagents        Check subagent availability (advisory; fails-open).
+Success output (stdout, JSON):
+  { "ok": true, "checks": { "worktree": true, "branch": "matched",
+    "subagents": "available" } }
+Violation output (stderr, JSON, exit 1):
+  { "ok": false, "error": "<error_code>", "checks": { ... },
+    "guidance": "<actionable instruction for the agent>" }
+Bypass:
+  PI_PREFLIGHT_BYPASS=1   Skip all checks (for development/testing only).`.trim();
+const parseError = buildParseError(USAGE);
+export function parsePreFlightGateCliArgs(argv) {
+  const args = [...argv];
+  const options = {
+    help: false,
+    expectedBranch: undefined,
+    checkSubagents: false,
+  };
+  while (args.length > 0) {
+    const token = args.shift();
+    if (token === "--help" || token === "-h") {
+      options.help = true;
+      return options;
+    }
+    if (token === "--expected-branch") {
+      options.expectedBranch = requireOptionValue(args, "--expected-branch", parseError, { flagPattern: /^-/u });
+      continue;
+    }
+    if (token === "--check-subagents") {
+      options.checkSubagents = true;
+      continue;
+    }
+    throw parseError(`Unknown argument: ${token}`);
+  }
+  return options;
+}
+function checkWorktreeIsolation({ cwd, env, gitCommand = "git" }) {
+  let worktreeListOutput;
+  try {
+    worktreeListOutput = execFileSync(gitCommand, ["worktree", "list"], {
+      cwd,
+      env,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch {
+    return {
+      ok: false,
+      error: "worktree_list_failed",
+      guidance: "Could not run `git worktree list`. Verify the repository is a valid git working directory.",
+    };
+  }
+  const mainWorktreePath = parseMainWorktreePath(worktreeListOutput);
+  if (!isUnderWorktreePath(cwd)) {
+    if (mainWorktreePath !== null && isMainCheckout(cwd, mainWorktreePath)) {
+      return {
+        ok: false,
+        error: "main_checkout_detected",
+        guidance:
+          `Current directory appears to be the main git checkout (${mainWorktreePath}).\n` +
+          "Local implementation requires worktree isolation. Create a worktree:\n" +
+          "  git worktree add -b <branch> tmp/worktrees/<slug>/ origin/main\n" +
+          "Then re-run from the worktree directory.",
+        mainWorktreePath,
+      };
+    }
+    return {
+      ok: false,
+      error: "not_in_worktree",
+      guidance:
+        "Local implementation requires worktree isolation. Create a worktree:\n" +
+        "  git worktree add -b <branch> tmp/worktrees/<slug>/ origin/main\n" +
+        "Then re-run from the worktree directory.",
+      mainWorktreePath: mainWorktreePath ?? undefined,
+    };
+  }
+  const allPaths = parseAllWorktreePaths(worktreeListOutput);
+  if (!isListedWorktree(cwd, allPaths)) {
+    return {
+      ok: false,
+      error: "not_in_worktree",
+      guidance:
+        "Current directory is under tmp/worktrees/ but is not a real git worktree.\n" +
+        "Create a worktree with:\n" +
+        "  git worktree add -b <branch> tmp/worktrees/<slug>/ origin/main\n" +
+        "Then re-run from the worktree directory.",
+      mainWorktreePath: mainWorktreePath ?? undefined,
+    };
+  }
+  return { ok: true, mainWorktreePath: mainWorktreePath ?? undefined };
+}
+function checkBranchIdentity({ cwd, env, expectedBranch, gitCommand = "git" }) {
+  if (!expectedBranch) {
+    return { ok: true, status: "skipped" };
+  }
+  let currentBranch;
+  try {
+    currentBranch = execFileSync(gitCommand, ["branch", "--show-current"], {
+      cwd,
+      env,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+  } catch {
+    return {
+      ok: false,
+      status: "error",
+      error: "branch_check_failed",
+      guidance: "Could not determine current branch. Verify the repository is a valid git working directory.",
+    };
+  }
+  if (currentBranch !== expectedBranch) {
+    return {
+      ok: false,
+      status: "mismatch",
+      error: "branch_mismatch",
+      guidance: `Expected branch "${expectedBranch}" but current branch is "${currentBranch}". Switch to the working branch and re-run.`,
+    };
+  }
+  return { ok: true, status: "matched", branch: currentBranch };
+}
+function checkSubagentAvailability({ env, checkSubagents }) {
+  if (!checkSubagents) {
+    return { ok: true, status: "skipped" };
+  }
+  const available = detectSubagentAvailability({ env });
+  return { ok: true, status: available ? "available" : "unavailable" };
+}
+export async function runCli(
+  argv = process.argv.slice(2),
+  {
+    stdout = process.stdout,
+    stderr = process.stderr,
+    adapter = createPiAdapter(),
+    cwd,
+    env,
+    gitCommand = "git",
+  } = {},
+) {
+  const effectiveCwd = cwd ?? adapter.getCwd();
+  const effectiveEnv = env ?? adapter.getEnv();
+  const options = parsePreFlightGateCliArgs(argv);
+  if (options.help) {
+    stdout.write(`${USAGE}\n`);
+    return { ok: true, help: true };
+  }
+  if ((effectiveEnv[PI_PREFLIGHT_BYPASS_VAR] ?? "").trim() === "1") {
+    const payload = {
+      ok: true,
+      checks: { worktree: true, branch: "skipped", subagents: "skipped" },
+      summary: "pre-flight gate bypassed via PI_PREFLIGHT_BYPASS=1",
+    };
+    stdout.write(`${JSON.stringify(payload)}\n`);
+    return payload;
+  }
+  const checks = { worktree: false, branch: "skipped", subagents: "skipped" };
+  const errors = [];
+  const worktreeResult = checkWorktreeIsolation({ cwd: effectiveCwd, env: effectiveEnv, gitCommand });
+  checks.worktree = worktreeResult.ok;
+  if (!worktreeResult.ok) {
+    errors.push({
+      check: "worktree",
+      error: worktreeResult.error,
+      guidance: worktreeResult.guidance,
+    });
+  }
+  const branchResult = checkBranchIdentity({
+    cwd: effectiveCwd,
+    env: effectiveEnv,
+    expectedBranch: options.expectedBranch,
+    gitCommand,
+  });
+  checks.branch = branchResult.status;
+  if (!branchResult.ok) {
+    errors.push({
+      check: "branch",
+      error: branchResult.error,
+      guidance: branchResult.guidance,
+    });
+  }
+  const subagentResult = checkSubagentAvailability({
+    env: effectiveEnv,
+    checkSubagents: options.checkSubagents,
+  });
+  checks.subagents = subagentResult.status;
+  if (errors.length > 0) {
+    const payload = {
+      ok: false,
+      error: errors[0].error,
+      checks,
+      guidance: errors.map((e) => e.guidance).join("\n\n"),
+      errors,
+    };
+    stderr.write(`${JSON.stringify(payload)}\n`);
+    return payload;
+  }
+  const payload = {
+    ok: true,
+    checks,
+    summary: "all checks passed",
+  };
+  stdout.write(`${JSON.stringify(payload)}\n`);
+  return payload;
+}
+if (isDirectCliRun(import.meta.url)) {
+  runCli()
+    .then((result) => {
+      if (result?.ok === false) {
+        process.exitCode = 1;
+      }
+    })
+    .catch((error) => {
+      process.stderr.write(`${formatCliError(error)}\n`);
+      process.exitCode = 1;
+    });
+}

package/scripts/loop/pre-pr-ready-gate.mjs

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+import {
+  buildParseError,
+  formatCliError,
+  isDirectCliRun,
+  parseJsonText,
+  summarizeGateReviewComments,
+  summarizeGateReviewCommentMarkers,
+} from "../_core-helpers.mjs";
+import { parsePrNumber, requireOptionValue, runChild } from "../_cli-primitives.mjs";
+import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
+
+const USAGE = `Usage:
+  pre-pr-ready-gate.mjs --repo <owner/name> --pr <number>
+
+Gate guard for gh pr ready (draft → ready-for-review transition).
+Blocks unless a visible clean draft_gate checkpoint verdict comment exists
+for the PR's current head SHA.
+
+Exit codes:
+  0  Draft gate evidence exists — ready transition is allowed
+  1  Draft gate evidence missing or insufficient — transition blocked
+
+Output (stdout, JSON on success):
+  {
+    "ok": true,
+    "repo": "owner/repo",
+    "pr": 17,
+    "currentHeadSha": "abc1234",
+    "draftGateSatisfied": true,
+    "draftGate": { "visible": true, "headSha": "abc1234", "verdict": "clean", ... }
+  }
+
+Error output (stderr, JSON):
+  { "ok": false, "error": "<reason>" }`.trim();
+
+const parseError = buildParseError(USAGE);
+const PR_VIEW_QUERY = `query($owner:String!, $name:String!, $number:Int!) { repository(owner:$owner, name:$name) { pullRequest(number:$number) { id, isDraft, headRefOid, state } } }`;
+
+export function parsePrePrReadyGateCliArgs(argv) {
+  const args = [...argv];
+  const options = { help: false, repo: undefined, pr: undefined };
+  while (args.length > 0) {
+    const token = args.shift();
+    if (token === "--help" || token === "-h") { options.help = true; return options; }
+    if (token === "--repo") { options.repo = requireOptionValue(args, "--repo", parseError).trim(); continue; }
+    if (token === "--pr") { options.pr = parsePrNumber(requireOptionValue(args, "--pr", parseError), parseError); continue; }
+    throw parseError(`Unknown argument: ${token}`);
+  }
+  if (options.repo === undefined || options.pr === undefined) {
+    throw parseError("pre-pr-ready-gate requires both --repo <owner/name> and --pr <number>");
+  }
+  try { parseRepoSlug(options.repo); } catch (error) {
+    throw parseError(error instanceof Error ? error.message : String(error));
+  }
+  return options;
+}
+
+async function runGhJson(args, { env, ghCommand }) {
+  const result = await runChild(ghCommand, args, env);
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || `exit code ${result.code}`;
+    throw new Error(`gh command failed: ${detail}`);
+  }
+  return parseJsonText(result.stdout);
+}
+
+async function fetchPrState({ repo, pr }, { env, ghCommand }) {
+  const [owner, name] = repo.split("/");
+  const r = await runGhJson(
+    ["api", "graphql", "-f", `query=${PR_VIEW_QUERY}`, "-f", `owner=${owner}`, "-f", `name=${name}`, "-F", `number=${pr}`],
+    { env, ghCommand },
+  );
+  const d = r?.data?.repository?.pullRequest;
+  if (!d) throw new Error(`Could not fetch PR #${pr}`);
+  return {
+    id: d.id,
+    isDraft: d.isDraft === true,
+    headRefOid: typeof d.headRefOid === "string" ? d.headRefOid.trim() : null,
+    state: typeof d.state === "string" ? d.state.trim() : null,
+  };
+}
+
+async function fetchGateEvidence({ repo, pr, headSha }, { env, ghCommand }) {
+  const r = await runChild(
+    ghCommand,
+    ["api", "--paginate", "--slurp", `repos/${repo}/issues/${pr}/comments?per_page=100`],
+    env,
+  );
+  if (r.code !== 0) throw new Error(`Failed to fetch PR comments`);
+  const raw = parseJsonText(r.stdout);
+  const comments = Array.isArray(raw)
+    ? (raw.every((e) => Array.isArray(e)) ? raw.flat() : raw)
+    : [];
+  const cs = summarizeGateReviewComments(comments);
+  const ms = summarizeGateReviewCommentMarkers(comments, { headSha });
+
+  const dg = cs.draft_gate ? { ...cs.draft_gate, visible: true } : { visible: false };
+  const dm = ms.draft_gate
+    ? { ...ms.draft_gate, visible: true, contractComplete: ms.draft_gate.contractComplete === true }
+    : { visible: false, contractComplete: false };
+
+  // Marker match: current head SHA starts with the marker's recorded head SHA
+  const markerHeadMatch = dm.headSha && headSha && headSha.startsWith(dm.headSha);
+  const currentHeadClean = dm.visible && markerHeadMatch && dm.verdict === "clean" && dm.contractComplete;
+
+  // Legacy comment match (non-marker draft_gate comment)
+  const cleanEvidenceExists = dg.visible && dg.verdict === "clean" && typeof dg.headSha === "string";
+  const legacyHeadMatch = !currentHeadClean && dg.headSha && headSha && headSha.startsWith(dg.headSha) && dg.verdict === "clean";
+
+  return {
+    draftGate: dg,
+    draftGateMarker: dm,
+    currentHeadClean,
+    cleanEvidenceExists,
+    effectiveHeadClean: currentHeadClean || legacyHeadMatch,
+  };
+}
+
+export async function prePrReadyGate(options, { env = process.env, ghCommand = "gh" } = {}) {
+  const prState = await fetchPrState({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+  const headSha = prState.headRefOid;
+  if (!headSha) throw new Error(`Could not resolve PR head SHA`);
+
+  const gate = await fetchGateEvidence({ repo: options.repo, pr: options.pr, headSha }, { env, ghCommand });
+
+  // When the PR is no longer draft, a visible clean draft_gate comment that
+  // exists at all (one-time transition record) is sufficient — don't require
+  // head-SHA matching after draft has been left.
+  const gateSatisfied = prState.isDraft
+    ? gate.effectiveHeadClean
+    : gate.cleanEvidenceExists;
+
+  if (!gateSatisfied) {
+    const shortSha = headSha.slice(0, 7);
+    const reason = gate.cleanEvidenceExists
+      ? `PR #${options.pr} draft_gate evidence exists but does not match current head ${shortSha}. Re-run draft gate for the current head.`
+      : `No visible clean draft_gate checkpoint verdict comment found on PR #${options.pr} for head ${shortSha}. Run the draft gate review and post a clean verdict before marking ready for review.`;
+    return {
+      ok: false,
+      error: reason,
+      repo: options.repo,
+      pr: options.pr,
+      currentHeadSha: headSha,
+      draftGateSatisfied: false,
+      draftGate: gate.draftGate,
+      draftGateMarker: gate.draftGateMarker,
+    };
+  }
+
+  return {
+    ok: true,
+    repo: options.repo,
+    pr: options.pr,
+    currentHeadSha: headSha,
+    draftGateSatisfied: true,
+    draftGate: gate.draftGate,
+    draftGateMarker: gate.draftGateMarker,
+  };
+}
+
+export async function runCli(argv = process.argv.slice(2), runtime = {}) {
+  const options = parsePrePrReadyGateCliArgs(argv);
+  if (options.help) {
+    process.stdout.write(`${USAGE}\n`);
+    return { ok: true, help: true };
+  }
+  const result = await prePrReadyGate(options, runtime);
+  if (!result.ok) {
+    process.stderr.write(`${JSON.stringify(result)}\n`);
+    process.exitCode = 1;
+    return result;
+  }
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  return result;
+}
+
+if (isDirectCliRun(import.meta.url)) {
+  runCli().catch((error) => {
+                process.stderr.write(`${formatCliError(error, { usage: USAGE })}\n`);
+    process.exitCode = 1;
+  });
+}

package/scripts/loop/pre-push-main-guard.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline";
+import { buildParseError, formatCliError, isDirectCliRun } from "../_core-helpers.mjs";
+
+const PI_PREPUSH_BYPASS_VAR = "PI_PREPUSH_BYPASS";
+const BLOCKED_REFS = ["refs/heads/main"];
+
+const USAGE = `Usage:
+  pre-push-main-guard.mjs
+
+Reads pre-push hook input from stdin (Git pre-push hook protocol).
+Blocks direct pushes to protected refs (by default: refs/heads/main).
+
+Exit codes:
+  0  Push allowed (non-main ref, or bypassed)
+  1  Push blocked (target is a protected ref)
+
+Bypass:
+  PI_PREPUSH_BYPASS=1   Skip all checks (for emergencies only).
+                         Preferred: push a feature branch and open a PR.`.trim();
+
+const parseError = buildParseError(USAGE);
+
+/**
+ * Parse pre-push hook input lines.
+ *
+ * Git pre-push hook protocol: each line is four whitespace-delimited fields:
+ *   <local ref> <local sha> <remote ref> <remote sha>
+ * The fourth field (remote sha) is all-zeros for new branches.
+ *
+ * This parser accepts lines with at least three fields (treating the
+ * optional fourth field as null when absent). Malformed non-empty
+ * lines with fewer than three fields are ignored silently — the guard
+ * prefers to fail-open on unparseable input rather than silently
+ * blocking unknown refs.
+ */
+async function readPushRefs(input) {
+  const refs = [];
+  const rl = createInterface({ input, crlfDelay: Infinity });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(/\s+/);
+    if (parts.length >= 3) {
+      refs.push({ localRef: parts[0], localSha: parts[1], remoteRef: parts[2], remoteSha: parts[3] || null });
+    }
+  }
+  return refs;
+}
+
+/**
+ * Check whether any push target is a blocked ref.
+ */
+function findBlockedRef(refs) {
+  for (const ref of refs) {
+    if (BLOCKED_REFS.includes(ref.remoteRef)) {
+      return ref.remoteRef;
+    }
+  }
+  return null;
+}
+
+export function parsePrePushGuardCliArgs(argv) {
+  const args = [...argv];
+  while (args.length > 0) {
+    const token = args.shift();
+    if (token === "--help" || token === "-h") return { help: true };
+    throw parseError(`Unknown argument: ${token}`);
+  }
+  return { help: false };
+}
+
+export async function runCli(argv = process.argv.slice(2), { stdout = process.stdout, stderr = process.stderr, stdin = process.stdin, env = process.env } = {}) {
+  const options = parsePrePushGuardCliArgs(argv);
+  if (options.help) { stdout.write(`${USAGE}\n`); return { ok: true, help: true }; }
+
+  if (env[PI_PREPUSH_BYPASS_VAR] === "1") {
+    stdout.write(JSON.stringify({ ok: true, bypassed: true, reason: `${PI_PREPUSH_BYPASS_VAR}=1` }) + "\n");
+    return { ok: true, bypassed: true };
+  }
+
+  const refs = await readPushRefs(stdin);
+  const blockedRef = findBlockedRef(refs);
+
+  if (blockedRef) {
+    const payload = {
+      ok: false,
+      error: "direct_push_to_main_blocked",
+      blockedRef,
+      message: "Direct pushes to main branch are blocked. Push a feature branch and open a pull request instead.",
+    };
+    stderr.write(`${JSON.stringify(payload)}\n`);
+    return payload;
+  }
+
+  const payload = { ok: true, blocked: false, refsChecked: refs.length };
+  stdout.write(`${JSON.stringify(payload)}\n`);
+  return payload;
+}
+
+if (isDirectCliRun(import.meta.url)) {
+  runCli().then((result) => { if (result?.ok === false) { process.exitCode = 1; } }).catch((error) => { process.stderr.write(`${formatCliError(error)}\n`); process.exitCode = 1; });
+}

package/scripts/loop/pre-write-remote-freshness-guard.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { buildParseError, formatCliError, isDirectCliRun } from "../_core-helpers.mjs";
+import { requireOptionValue, runCommand } from "../_cli-primitives.mjs";
+
+const USAGE = `Usage: pre-write-remote-freshness-guard.mjs --branch <name>\nRefresh remote branch state before starting local file writes.`;
+const parseError = buildParseError(USAGE);
+
+export function parseRemoteFreshnessGuardCliArgs(argv) {
+  const args = [...argv], options = { help: false, branch: undefined };
+  while (args.length > 0) {
+    const token = args.shift();
+    if (token === "--help" || token === "-h") { options.help = true; return options; }
+    if (token === "--branch") { options.branch = requireOptionValue(args, "--branch", parseError, { flagPattern: /^-/u }); continue; }
+    throw parseError(`Unknown argument: ${token}`);
+  }
+  if (options.branch === undefined) throw parseError("--branch <name> is required");
+  return options;
+}
+
+export async function runCli(argv = process.argv.slice(2), { stdout = process.stdout, stderr = process.stderr, cwd = process.cwd(), env = process.env, gitCommand = "git" } = {}) {
+  const options = parseRemoteFreshnessGuardCliArgs(argv);
+  if (options.help) { stdout.write(`${USAGE}\n`); return { ok: true, help: true }; }
+  await runCommand(gitCommand, ["fetch", "origin", options.branch], { cwd, env });
+  const { stdout: logOutput } = await runCommand(gitCommand, ["log", `HEAD..origin/${options.branch}`, "--oneline"], { cwd, env });
+  const newCommits = logOutput.split(/\r?\n/u).map(l => l.trim()).filter(l => l.length > 0);
+  if (newCommits.length === 0) { const p = { ok: true, status: "up_to_date" }; stdout.write(`${JSON.stringify(p)}\n`); return p; }
+  const p = { ok: false, error: "remote_ahead", newCommits }; stderr.write(`${JSON.stringify(p)}\n`); return p;
+}
+
+if (isDirectCliRun(import.meta.url)) {
+  runCli().then(r => { if (r?.ok === false) process.exitCode = 1; }).catch(e => { process.stderr.write(`${formatCliError(e)}\n`); process.exitCode = 1; });
+}

package/scripts/loop/print-gates.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import process from "node:process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadDevLoopConfig } from "@dev-loops/core/config";
+import { resolveGateConfig } from "@dev-loops/core/config";
+import { resolveGateAngles, resolveReviewerRole } from "@dev-loops/core/config";
+async function run({ stdout = process.stdout, repoRoot = process.cwd() } = {}) {
+  const { config } = await loadDevLoopConfig({ repoRoot });
+  const gates = [
+    { name: "draft_gate", label: "draft gate", gate: "draft" },
+    { name: "pre_approval_gate", label: "pre-approval gate", gate: "preApproval" },
+  ];
+  for (const { label, gate } of gates) {
+    const gateConfig = resolveGateConfig(config, gate);
+    const angles = resolveGateAngles(config, gate);
+    const ciLabel = gate === "draft"
+      ? String(gateConfig.requireCi)
+      : "true (always enforced)";
+    stdout.write(`${label}:\n`);
+    stdout.write(`  requireCi: ${ciLabel}\n`);
+    if (!angles || angles.length === 0) {
+      stdout.write("  (no angles configured)\n\n");
+      continue;
+    }
+    const maxLen = Math.max(...angles.map(a => a.length));
+    for (const angle of angles) {
+      const { prompt } = resolveReviewerRole(config, angle);
+      const displayPrompt = prompt ?? "(no prompt — add to config personas)";
+      stdout.write(`  ${angle.padEnd(maxLen + 2)} ${displayPrompt}\n`);
+    }
+    stdout.write("\n");
+  }
+}
+const isDirectRun = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isDirectRun) {
+  run().catch(err => {
+    process.stderr.write(`${err.message}\n`);
+    process.exitCode = 1;
+  });
+}
+export { run };