@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-HXDTA5VU.js

@@ -1,208 +0,0 @@
-import {
-  git_gh_blocked_by_graphql
-} from "./chunk-CQZI7RIK.js";
-import {
-  BLOCKED_BY_COUNT_FIELD,
-  BLOCKED_BY_FIELD,
-  ISSUE_FIELDS,
-  PAGE,
-  git_gh_issue_graphql,
-  git_gh_issue_rest,
-  issue_fields_schema,
-  read_blocked_by
-} from "./chunk-ENKFCOVY.js";
-import {
-  git_gh_transport
-} from "./chunk-TVZXG4Y4.js";
-import {
-  git_gh_etag_read
-} from "./chunk-EWVR5AEX.js";
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  GH_SPAWN_CONCURRENCY
-} from "./chunk-XDF25GSU.js";
-import {
-  bounded_pool
-} from "./chunk-EBVS2LKX.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/gh/git-gh-issue-list-graphql.ts
-import { z } from "zod";
-var LISTING_QUERY = `query($owner: String!, $name: String!, $labels: [String!]) {
-	rateLimit { cost remaining }
-	repository(owner: $owner, name: $name) {
-		issues(${PAGE}, labels: $labels, states: OPEN, orderBy: { field: CREATED_AT, direction: DESC }) {
-			pageInfo { hasNextPage }
-			nodes { ${ISSUE_FIELDS} }
-		}
-	}
-}`;
-var rate_limit_schema = z.object({ cost: z.number(), remaining: z.number() });
-var page_info_schema = z.object({ hasNextPage: z.boolean() });
-var issues_schema = z.object({
-  pageInfo: page_info_schema,
-  nodes: z.array(issue_fields_schema)
-});
-var response_schema = z.looseObject({
-  data: z.looseObject({
-    rateLimit: rate_limit_schema,
-    repository: z.looseObject({ issues: issues_schema })
-  })
-});
-function labels_of(label) {
-  return label === void 0 ? void 0 : [label];
-}
-function to_page(data) {
-  const { issues } = data.repository;
-  return {
-    issues: issues.nodes.map((issue) => ({
-      rest: git_gh_issue_graphql.to_rest_issue(issue),
-      blocked_by: git_gh_issue_graphql.to_blocked_by(issue)
-    })),
-    has_next_page: issues.pageInfo.hasNextPage,
-    cost: data.rateLimit.cost,
-    remaining: data.rateLimit.remaining
-  };
-}
-async function read_open_page(label, repo) {
-  const repository = git_gh_issue_graphql.repository_variables_of(repo);
-  if (repository === void 0) return void 0;
-  const variables = { ...repository, labels: labels_of(label) };
-  const json = await git_gh_transport.query({ query: LISTING_QUERY, variables });
-  if (json === void 0) return void 0;
-  const data = json_value.parse_with(json, response_schema)?.data;
-  return data === void 0 ? void 0 : to_page(data);
-}
-var git_gh_issue_list_graphql = {
-  read_open_page
-};
-
-// scripts/gh/git-gh-issue-list.ts
-var PER_PAGE = 100;
-var FIRST_PAGE = 1;
-var DEFAULT_STATE = "open";
-var DEFAULT_SORT = "created";
-var LISTING_DIRECTION = "direction=desc";
-function listing_query(request) {
-  const state = request.state ?? DEFAULT_STATE;
-  const sort = request.sort ?? DEFAULT_SORT;
-  return `state=${state}&sort=${sort}&${LISTING_DIRECTION}`;
-}
-function listing_path(request, page) {
-  const label = request.label === void 0 ? "" : `&labels=${encodeURIComponent(request.label)}`;
-  const paging = `&per_page=${String(PER_PAGE)}&page=${String(page)}`;
-  return `${git_gh_api_path.issues_api_path(request.repo)}?${listing_query(request)}${label}${paging}`;
-}
-var DIGIT_PATTERN = /\d/u;
-function has_token_occurrence(body, term) {
-  let index = body.indexOf(term);
-  while (index !== -1) {
-    if (!DIGIT_PATTERN.test(body.charAt(index + term.length))) return true;
-    index = body.indexOf(term, index + 1);
-  }
-  return false;
-}
-function matches_body(rest, term) {
-  if (term === void 0) return true;
-  const { body } = rest;
-  return typeof body === "string" && has_token_occurrence(body, term);
-}
-function is_selected(rest, request) {
-  return !git_gh_issue_rest.is_pull_request(rest) && matches_body(rest, request.body_term);
-}
-async function fetch_page(request, page) {
-  const detail = await git_gh_etag_read.read_detail(listing_path(request, page));
-  const rows = git_gh_issue_rest.parse_rest_issues(detail.body);
-  return {
-    selected: rows.filter((row) => is_selected(row, request)),
-    is_full: rows.length >= PER_PAGE,
-    is_unchanged: detail.is_unchanged
-  };
-}
-var MAX_PAGES = 5;
-var MAX_SCANNED = MAX_PAGES * PER_PAGE;
-function wants_more(has_more, selected_count, limit) {
-  return has_more && selected_count < limit;
-}
-async function fetch_selected(request) {
-  const selected = [];
-  const unchanged = [];
-  let has_more = true;
-  while (unchanged.length < MAX_PAGES && wants_more(has_more, selected.length, request.limit)) {
-    const result = await fetch_page(request, FIRST_PAGE + unchanged.length);
-    selected.push(...result.selected);
-    has_more = result.is_full;
-    unchanged.push(result.is_unchanged);
-  }
-  return {
-    rows: selected.slice(0, request.limit),
-    is_capped: wants_more(has_more, selected.length, request.limit),
-    is_unchanged: unchanged.length > 0 && unchanged.every(Boolean)
-  };
-}
-async function read_relations(rows, repo) {
-  const answered = await git_gh_blocked_by_graphql.read_answered(rows);
-  return await bounded_pool.bounded_map(
-    rows,
-    GH_SPAWN_CONCURRENCY,
-    async (row) => answered.get(row) ?? await read_blocked_by(String(row.number), row, repo)
-  );
-}
-var GRAPHQL_FIELDS = /* @__PURE__ */ new Set([
-  "number",
-  "title",
-  "body",
-  "labels",
-  "createdAt",
-  "url",
-  "author_association",
-  "user",
-  BLOCKED_BY_FIELD,
-  BLOCKED_BY_COUNT_FIELD
-]);
-function is_open_newest_first(request) {
-  return (request.state ?? DEFAULT_STATE) === DEFAULT_STATE && (request.sort ?? DEFAULT_SORT) === DEFAULT_SORT;
-}
-function is_graphql_listing(request, fields) {
-  return is_open_newest_first(request) && fields.every((field) => GRAPHQL_FIELDS.has(field));
-}
-async function read_graphql(request, fields) {
-  if (!is_graphql_listing(request, fields)) return void 0;
-  const page = await git_gh_issue_list_graphql.read_open_page(request.label, request.repo);
-  if (page === void 0) return void 0;
-  const selected = page.issues.filter((issue) => is_selected(issue.rest, request));
-  if (wants_more(page.has_next_page, selected.length, request.limit)) return void 0;
-  const rows = selected.slice(0, request.limit).map((issue) => git_gh_issue_rest.to_gh_issue(issue.rest, fields, issue.blocked_by));
-  return { rows, is_capped: false, is_unchanged: false };
-}
-async function read_rest(request, fields) {
-  const { rows, is_capped, is_unchanged } = await fetch_selected(request);
-  const relations = fields.includes(BLOCKED_BY_FIELD) ? await read_relations(rows, request.repo) : void 0;
-  const mapped = rows.map(
-    (row, index) => git_gh_issue_rest.to_gh_issue(row, fields, relations?.[index])
-  );
-  return { rows: mapped, is_capped, is_unchanged };
-}
-async function issue_list(request) {
-  try {
-    const fields = git_gh_issue_rest.split_fields(request.json_fields);
-    const { rows, is_capped, is_unchanged } = await read_graphql(request, fields) ?? await read_rest(request, fields);
-    return { json: JSON.stringify(rows), is_capped, is_unchanged };
-  } catch {
-    return { json: void 0, is_capped: false };
-  }
-}
-var git_gh_issue_list = {
-  issue_list,
-  listing_path
-};
-
-export {
-  FIRST_PAGE,
-  MAX_SCANNED,
-  git_gh_issue_list
-};

package/dist/commands/chunk-I2KCGKJI.js

@@ -1,107 +0,0 @@
-import {
-  run_event_stream_emit
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-
-// scripts/run/event/run-event-setup.ts
-var STAGE = {
-  // `josh backlogrun` started the parent session, which is reading its procedure.
-  STARTING: "starting session",
-  // `run:carry --begin` claimed the run, and the parent is planning it.
-  PLANNING: "planning",
-  // The supervisor took the run over from the parent and is asking for the first offer.
-  HANDING_OFF: "handing off",
-  // The driver answered something only a session can act on — an untriaged child, an epic left to a
-  // person — and the supervisor is waking one. The next hand-off replaces it.
-  JUDGING: "waiting on judgment",
-  // The supervisor started that session, which is now acting on the driver's answer. It is detached, so
-  // its end is the supervisor's next hand-off, which replaces this.
-  SESSION: "judgment session running",
-  // The driver read a drain owing the retrospective and is waiting on the retrospective unit it
-  // started (joshuafolkken/kit#6745). The unit's end is the driver's next stage, which replaces this.
-  RETROSPECTIVE: "retrospective",
-  // The driver's launch of a lane returned without a child: no lane was free to open, or a step after
-  // the open failed. Written through `no_child`, naming its issue, so it ends that lane's stage alone
-  // while the pass's other launches run on (joshuafolkken/kit#5519).
-  NO_CHILD: "no child launched"
-};
-var OPENING = "opening lane";
-var INSTALLING = "installing dependencies";
-var DISPATCHING = "dispatching";
-var LANE_STAGE = { OPENING, INSTALLING, DISPATCHING };
-function opening_lane(issue) {
-  return `${OPENING} ${issue_cite.plain_for("program", issue)}`;
-}
-function installing(issue) {
-  return `${INSTALLING} ${issue_cite.plain_for("program", issue)}`;
-}
-function dispatching(issue) {
-  return `${DISPATCHING} ${issue_cite.plain_for("program", issue)}`;
-}
-function no_child(issue) {
-  return `${STAGE.NO_CHILD} ${issue_cite.plain_for("program", issue)}`;
-}
-async function emit(text) {
-  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.SETUP, text);
-}
-function append_stage(resolve_target, text, at) {
-  try {
-    const { SETUP } = run_event_stream.EVENT_KIND;
-    run_event_stream.append(resolve_target(), SETUP, text, at.toISOString());
-  } catch (error) {
-    error_text.trace_swallowed("run_event_setup.append_stage", error);
-  }
-}
-function emit_in(repository, text, at) {
-  append_stage(() => run_event_stream.target_of(repository), text, at);
-}
-function emit_to(target, text, at) {
-  append_stage(() => target, text, at);
-}
-function is_stage(event, prefix) {
-  return event.kind === run_event_stream.EVENT_KIND.SETUP && event.text.startsWith(prefix);
-}
-function first_lane_span(start, later) {
-  const next_start = later.findIndex((event) => is_stage(event, STAGE.STARTING));
-  const session = next_start === -1 ? later : later.slice(0, next_start);
-  const opening = session.find((event) => is_stage(event, OPENING));
-  return {
-    from_ms: Date.parse(start.at),
-    end_ms: opening === void 0 ? void 0 : Date.parse(opening.at)
-  };
-}
-function first_lane_spans(events) {
-  return events.flatMap(
-    (event, index) => is_stage(event, STAGE.STARTING) ? [first_lane_span(event, events.slice(index + 1))] : []
-  );
-}
-function first_lane_ms(events) {
-  const span = first_lane_spans(events).at(-1);
-  return span?.end_ms === void 0 ? void 0 : span.end_ms - span.from_ms;
-}
-var run_event_setup = {
-  LANE_STAGE,
-  STAGE,
-  dispatching,
-  emit,
-  emit_in,
-  emit_to,
-  first_lane_ms,
-  first_lane_spans,
-  installing,
-  is_stage,
-  no_child,
-  opening_lane
-};
-
-export {
-  run_event_setup
-};

package/dist/commands/chunk-I63RNFFR.js

@@ -1,213 +0,0 @@
-import {
-  durable_state,
-  run_carry
-} from "./chunk-MPGJ4ONJ.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-
-// scripts/lane/lane-ledger-write.ts
-import { closeSync, constants, openSync, writeSync } from "node:fs";
-
-// scripts/lane/lane-ledger-kind.ts
-var KIND = {
-  MERGE: "merge",
-  GATE: "gate",
-  LOAD: "load",
-  DISPATCH: "dispatch",
-  STAGE: "stage",
-  STOP: "stop",
-  CHAIN: "chain",
-  OVERLAP: "overlap",
-  HELD: "held",
-  RELEASED: "released",
-  ROUND_ONE: "round-one",
-  ROUND_TWO: "round-two",
-  OFFERABLE: "offerable",
-  OFFER: "offer",
-  CORE_WAIT: "core-wait",
-  UNIT_FILES: "unit-files",
-  TEST_RELATED: "test-related",
-  TEST_PINNED: "test-pinned",
-  SPLIT_NOTICE: "split-notice",
-  SPLIT_FILED: "split-filed",
-  UNPLANNED_NOTICE: "unplanned-notice",
-  LANE_STATE: "lane-state",
-  PUSH_MISS: "push-miss",
-  EARLY_PUSH: "early-push",
-  SHIP_LAP: "ship-lap",
-  SIZE: "size",
-  LIMIT: "limit"
-};
-var lane_ledger_kind = { KIND };
-
-// scripts/lane/lane-ledger-write.ts
-var LEDGER_PREFIX = durable_state.PREFIX.LANE_LEDGER;
-var LEDGER_SUFFIX = ".jsonl";
-var LINE_SEPARATOR = "\n";
-var CI_WAIT_STAGE = "ci-wait";
-var CODERABBIT_WAIT_STAGE = "coderabbit-wait";
-var CODERABBIT_RATE_LIMIT_STAGE = "coderabbit-rate-limit";
-var CODERABBIT_RETRIGGER_STAGE = "coderabbit-retriggered";
-var PRE_DETACH_STAGE = "pre-detach";
-var ROUND_ONE_REUSED = "reused";
-var LEDGER_FILE_MODE = 384;
-var { O_APPEND, O_CREAT, O_NOFOLLOW, O_WRONLY } = constants;
-var APPEND_FLAGS = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
-var { KIND: KIND2 } = lane_ledger_kind;
-function target_of(repository) {
-  return durable_state.path(LEDGER_PREFIX, repository, LEDGER_SUFFIX);
-}
-async function target() {
-  if (process.env["VITEST"] !== void 0) return void 0;
-  try {
-    const repository = await run_carry.repository_directory();
-    return repository === void 0 ? void 0 : target_of(repository);
-  } catch {
-    return void 0;
-  }
-}
-function append(path, entry) {
-  const descriptor = openSync(path, APPEND_FLAGS, LEDGER_FILE_MODE);
-  try {
-    if (!stamp_file.is_own_regular_file(path)) {
-      throw new Error("Ledger is not an owned regular file");
-    }
-    writeSync(descriptor, `${JSON.stringify(entry)}${LINE_SEPARATOR}`);
-  } finally {
-    closeSync(descriptor);
-  }
-}
-async function record(entry, path) {
-  try {
-    const destination = path ?? await target();
-    if (destination !== void 0) append(destination, entry);
-  } catch {
-  }
-}
-function now_iso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-async function record_gate(path, gate) {
-  await record({ kind: KIND2.GATE, at: now_iso(), ...gate }, path);
-}
-async function record_merge(issue, at = /* @__PURE__ */ new Date()) {
-  await record({ kind: KIND2.MERGE, at: at.toISOString(), issue });
-}
-async function record_dispatch(issue, path) {
-  await record({ kind: KIND2.DISPATCH, at: now_iso(), issue }, path);
-}
-async function record_stage(stage, path) {
-  await record({ kind: KIND2.STAGE, at: now_iso(), ...stage }, path);
-}
-async function record_stop(stop, path) {
-  await record({ kind: KIND2.STOP, at: now_iso(), ...stop }, path);
-}
-async function record_chain(chain, path) {
-  await record({ kind: KIND2.CHAIN, at: now_iso(), ...chain }, path);
-}
-async function record_overlap(overlap, path) {
-  await record({ kind: KIND2.OVERLAP, at: now_iso(), ...overlap }, path);
-}
-async function record_held(held, path) {
-  const waiting = held.waiting ?? [];
-  const named = waiting.length > 0 ? { waiting: [...waiting] } : {};
-  await record({ kind: KIND2.HELD, at: now_iso(), reason: held.reason, ...named }, path);
-}
-async function record_released(path) {
-  await record({ kind: KIND2.RELEASED, at: now_iso() }, path);
-}
-async function record_lane_state(change, path) {
-  await record({ kind: KIND2.LANE_STATE, at: now_iso(), ...change }, path);
-}
-async function record_offerable(is_offerable, path) {
-  await record({ kind: KIND2.OFFERABLE, at: now_iso(), is_offerable }, path);
-}
-async function record_offer(offer, path) {
-  await record({ kind: KIND2.OFFER, at: now_iso(), ...offer }, path);
-}
-async function record_round_one(round_one, path) {
-  await record({ kind: KIND2.ROUND_ONE, at: now_iso(), ...round_one }, path);
-}
-async function record_round_two(round_two, path) {
-  await record({ kind: KIND2.ROUND_TWO, at: now_iso(), ...round_two }, path);
-}
-async function record_core_wait(wait, path) {
-  await record({ kind: KIND2.CORE_WAIT, at: now_iso(), ...wait }, path);
-}
-async function record_unit_files(files, path) {
-  await record({ kind: KIND2.UNIT_FILES, at: now_iso(), files: [...files] }, path);
-}
-async function record_test_related(run, path) {
-  await record({ kind: KIND2.TEST_RELATED, at: now_iso(), ...run }, path);
-}
-async function record_test_pinned(run, path) {
-  await record({ kind: KIND2.TEST_PINNED, at: now_iso(), ...run }, path);
-}
-async function record_split_notice(notice, path) {
-  await record({ kind: KIND2.SPLIT_NOTICE, at: now_iso(), ...notice }, path);
-}
-async function record_split_filed(filed, path) {
-  const destination = path ?? await target();
-  if (destination === void 0) throw new Error("Could not resolve the split-child ledger");
-  append(destination, { kind: KIND2.SPLIT_FILED, at: now_iso(), ...filed });
-}
-async function record_push_miss(miss, path) {
-  await record({ kind: KIND2.PUSH_MISS, at: now_iso(), ...miss }, path);
-}
-async function record_early_push(push, path) {
-  await record({ kind: KIND2.EARLY_PUSH, at: now_iso(), ...push }, path);
-}
-async function record_ship_lap(lap, path) {
-  await record({ kind: KIND2.SHIP_LAP, at: now_iso(), ...lap }, path);
-}
-async function record_size(size, path) {
-  await record({ kind: KIND2.SIZE, at: now_iso(), ...size }, path);
-}
-async function record_unplanned_notice(notice, path) {
-  await record({ kind: KIND2.UNPLANNED_NOTICE, at: now_iso(), ...notice }, path);
-}
-var lane_ledger_write = {
-  CI_WAIT_STAGE,
-  CODERABBIT_RATE_LIMIT_STAGE,
-  CODERABBIT_RETRIGGER_STAGE,
-  CODERABBIT_WAIT_STAGE,
-  KIND: KIND2,
-  LINE_SEPARATOR,
-  PRE_DETACH_STAGE,
-  ROUND_ONE_REUSED,
-  append,
-  record,
-  record_chain,
-  record_core_wait,
-  record_dispatch,
-  record_gate,
-  record_held,
-  record_lane_state,
-  record_released,
-  record_merge,
-  record_overlap,
-  record_offer,
-  record_offerable,
-  record_push_miss,
-  record_early_push,
-  record_round_one,
-  record_round_two,
-  record_ship_lap,
-  record_size,
-  record_split_filed,
-  record_split_notice,
-  record_stage,
-  record_stop,
-  record_test_pinned,
-  record_test_related,
-  record_unit_files,
-  record_unplanned_notice,
-  target,
-  target_of
-};
-
-export {
-  lane_ledger_kind,
-  lane_ledger_write
-};

package/dist/commands/chunk-IAD4WLLI.js

@@ -1,98 +0,0 @@
-import {
-  REPOSITORY_SEGMENT_SOURCE
-} from "./chunk-VDGNXSP3.js";
-import {
-  git_gh_issue_rest
-} from "./chunk-ENKFCOVY.js";
-import {
-  author_fields_schema,
-  blocked_by_schema
-} from "./chunk-34DND4BA.js";
-import {
-  parse_json_object_or_undefined
-} from "./chunk-XDF25GSU.js";
-
-// scripts/epic/epic-issue.ts
-import { z } from "zod";
-var label_schema = z.object({ name: z.string() });
-var CLOSED = "CLOSED";
-var OPEN = "OPEN";
-var UNKNOWN_STATE = "UNKNOWN";
-var PULL_REQUEST_SEGMENT = "/pull/";
-var epic_issue_schema = z.object({
-  number: z.number(),
-  title: z.string().default(""),
-  body: z.union([z.string(), z.null().transform(() => "")]).default(""),
-  state: z.string().default(UNKNOWN_STATE),
-  // The issue endpoint answers for a pull request as readily as for an issue, and nothing in the
-  // other fields separates them — an open PR reports `state: OPEN`, a merged one `MERGED`. The URL
-  // is what says which it is: `/pull/<n>` against `/issues/<n>`.
-  url: z.string().default(""),
-  labels: z.array(label_schema).default([]),
-  blockedBy: blocked_by_schema,
-  // Who filed the issue, for `backlog:next`'s author-trust check (joshuafolkken/kit#4633).
-  ...author_fields_schema
-});
-function parse_epic_issue(raw) {
-  if (raw === void 0) return void 0;
-  try {
-    return parse_json_object_or_undefined(raw, epic_issue_schema);
-  } catch {
-    return void 0;
-  }
-}
-function blocker_references_of(issue, fallback_repo = "") {
-  return (issue.blockedBy?.nodes ?? []).map(
-    (blocker) => git_gh_issue_rest.reference_of_blocker(blocker, fallback_repo)
-  );
-}
-function label_names(issue) {
-  return issue.labels.map((label) => label.name);
-}
-function normalize_state(state) {
-  return state.toUpperCase() === CLOSED ? CLOSED : "OPEN";
-}
-function is_open(state) {
-  return state.toUpperCase() === OPEN;
-}
-function is_pull_request(issue) {
-  return issue.url.includes(PULL_REQUEST_SEGMENT);
-}
-function parse_epic_number(raw = "") {
-  if (raw.includes("/")) return void 0;
-  const parsed = Number(raw.replace("#", ""));
-  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : void 0;
-}
-var QUALIFIED_REFERENCE = new RegExp(
-  String.raw`^(${REPOSITORY_SEGMENT_SOURCE}\/${REPOSITORY_SEGMENT_SOURCE})#(\d+)$`,
-  "u"
-);
-var QUALIFIED_REPO_GROUP = 1;
-var QUALIFIED_NUMBER_GROUP = 2;
-function to_qualified_reference(match) {
-  const repo = match[QUALIFIED_REPO_GROUP];
-  if (repo === void 0) return void 0;
-  const number = Number(match[QUALIFIED_NUMBER_GROUP]);
-  return Number.isSafeInteger(number) && number > 0 ? { repo, number } : void 0;
-}
-function parse_epic_reference(raw = "") {
-  const match = QUALIFIED_REFERENCE.exec(raw.trim());
-  if (match !== null) return to_qualified_reference(match);
-  const number = parse_epic_number(raw);
-  return number === void 0 ? void 0 : { number };
-}
-var epic_issue = {
-  CLOSED,
-  blocker_references_of,
-  parse_epic_issue,
-  label_names,
-  normalize_state,
-  is_open,
-  is_pull_request,
-  parse_epic_number,
-  parse_epic_reference
-};
-
-export {
-  epic_issue
-};