dsh-pstack 0.2.0-beta.1 → 0.2.0

package/{assets → dist/pstack}/skills/poteto-mode/scripts/check-plan.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import process from "node:process";
-//#region .runtime-sources/skills/poteto-mode/scripts/check-plan.mjs
+// runtime/skills/poteto-mode/scripts/check-plan.mjs
 const RULE = "Tests alone are not sufficient verification. A PR is verified only when its unit, live, and perf boxes are all checked.";
 const LANES = /Ten lanes on `[^`<>]+` at the PR head/;
 const SUB_BLOCKS = [
@@ -22,11 +22,8 @@ const PROGRAM_H3 = [
 	"Verdict and merge",
 	"Boot recipe"
 ];
-const PROGRAM_MARKERS = [
-	"create_goal",
-	"schedule_create",
-	"status message"
-];
+const PROGRAM_MARKERS = ["git show origin/main:", "status message"];
+const TICK_MARKERS = ["create_goal", "schedule_create"];
 const HOW_TO_READ_MARKERS = [
 	"One box is one unit of work",
 	"names the evidence",
@@ -82,7 +79,7 @@ for (let i = start; i < raw.length; i++) {
 		code
 	});
 	if (code) continue;
-	const prose = text.replace(/`[^`]*`/g, "`").replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\]\([^)]*\)/g, "]");
+	const prose = text.replace(/(?<!`)(`+)(?!`)(.*?)(?<!`)\1(?!`)/g, "`").replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\]\([^)]*\)/g, "]");
 	if (/[\u2013\u2014]/.test(prose)) fail(n, "long dash");
 	if (/[\u2018\u2019\u201c\u201d]/.test(prose)) fail(n, "curly quote");
 	if (/: \S/.test(prose)) fail(n, "mid-sentence colon");
@@ -124,6 +121,8 @@ else {
 		else cursor = at + 1;
 	}
 	for (const marker of PROGRAM_MARKERS) if (!bodyText(program).includes(marker)) fail(program.n, `Program checklist lacks "${marker}"`);
+	const programText = bodyText(program);
+	if (!programText.includes("/loop 1h") && !TICK_MARKERS.every((marker) => programText.includes(marker))) fail(program.n, `Program checklist lacks "/loop 1h" or both "create_goal" and "schedule_create"`);
 }
 const close = find("Close the program");
 if (!close) fail(1, "no \"## Close the program\" section");
@@ -216,5 +215,4 @@ for (const line of report) console.log(line);
 console.log(`${prSections.length} PR sections, ${problems.length} problems`);
 for (const p of problems) console.error(p);
 process.exit(problems.length ? 1 : 0);
-//#endregion
 export {};

package/dist/pstack/skills/poteto-mode/scripts/check-plan.test.mjs

@@ -0,0 +1,128 @@
+import { expect } from "./expect.mjs";
+import "./support.mjs";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { test } from "node:test";
+// runtime/skills/poteto-mode/scripts/check-plan.test.ts
+const checker = join(import.meta.dirname, "check-plan.mjs");
+const rule = "Tests alone are not sufficient verification. A PR is verified only when its unit, live, and perf boxes are all checked.";
+const validPlan = `# Demo
+
+## How to read this
+One box is one unit of work and names the evidence. Check a box only when its evidence exists. See playbooks/.
+${rule}
+
+## Program checklist
+### Arm the program
+### Spawn owners
+### PR mechanics
+### Verdict and merge
+### Boot recipe
+\`git show origin/main:\` \`create_goal\` \`schedule_create\` status message
+
+## PR 1
+**Depends on.** None.
+**Files.**
+- [ ] Do the thing.
+**Build.**
+- [ ] Do the thing.
+**You see.**
+- [ ] Do the thing.
+**Verify, unit.** ${rule}
+- [ ] Check the thing.
+**Verify, live.** ${rule} Ten lanes on \`example-model\` at the PR head
+${Array.from({ length: 10 }, (_, i) => `- [ ] Lane ${i + 1}. Save \`lane-${i + 1}.png\`. Pass when evidence exists.`).join("\n")}
+**Verify, perf.** ${rule}
+- [ ] Metric. Recorded.
+- [ ] Probe. Recorded.
+- [ ] Baseline. Recorded.
+- [ ] Rule. Recorded.
+**Review gate.** None.
+**Merge.**
+- [ ] Merge when approved.
+
+## Close the program
+Close.
+
+## Appendix Prototype evidence
+Recorded.
+`;
+const runPlan = (example, expectedExit) => {
+	const directory = mkdtempSync(join(tmpdir(), "check-plan-test-"));
+	const file = join(directory, "plan.md");
+	writeFileSync(file, validPlan + example);
+	try {
+		const result = spawnSync("node", [checker, file], { encoding: "utf8" });
+		expect(result.status).toBe(expectedExit);
+		return result;
+	} finally {
+		rmSync(directory, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+test("accepts ordinary, indented, and longer closing fences", () => {
+	for (const indent of [
+		"",
+		" ",
+		"  ",
+		"   "
+	]) runPlan(`${indent}\`\`\`markdown\n## Example only\n${indent}\`\`\`\n`, 0);
+	runPlan("```markdown\n## Example only\n````\n", 0);
+});
+test("accepts nested backticks and tilde info strings", () => {
+	runPlan("````markdown\n```markdown\n## Example only\n```\n````\n", 0);
+	runPlan("~~~markdown `info`\n## Example only\n ~~~\n", 0);
+});
+test("keeps mismatched, shorter, and suffixed closers inside the fence", () => {
+	runPlan("````markdown\n~~~\n## Example only\n````\n", 0);
+	runPlan("````markdown\n```\n## Example only\n````\n", 0);
+	runPlan("````markdown\n``` info\n## Example only\n````\n", 0);
+});
+test("rejects headings and prose outside a proper close", () => {
+	for (const suffix of ["  ", "	"]) {
+		const heading = runPlan(`\`\`\`markdown\n## Example only\n\`\`\`${suffix}\n## Example only\n`, 1);
+		expect(heading.stderr).toContain("\"## Example only\" after Close the program is not an appendix");
+	}
+	const prose = runPlan("```markdown\nThis prose has a mid-sentence colon: inside code\n```\nThis prose has a mid-sentence colon: bad.\n", 1);
+	expect(prose.stderr).toContain("mid-sentence colon");
+});
+test("rejects backtick info strings containing a backtick", () => {
+	const result = runPlan("```markdown `invalid`\n## Example only\n```\n", 1);
+	expect(result.stderr).toContain("\"## Example only\" after Close the program is not an appendix");
+});
+test("ignores prose punctuation inside matching multi-backtick code spans", () => {
+	for (const count of [
+		2,
+		3,
+		4
+	]) {
+		const delimiter = "`".repeat(count);
+		runPlan(`Use ${delimiter}echo \`x\`: “quoted” — example${delimiter}.\n`, 0);
+	}
+});
+test("checks prose following a multi-backtick span and unmatched delimiters", () => {
+	const outside = runPlan("Use ``echo `x`: y``. Bad: prose.\n", 1);
+	expect(outside.stderr).toContain("mid-sentence colon");
+	const unmatched = runPlan("Use ``unclosed: bad` here.\n", 1);
+	expect(unmatched.stderr).toContain("mid-sentence colon");
+});
+test("accepts the upstream /loop tick or the DSH goal plus schedule tick", () => {
+	const upstream = validPlan.replace("`git show origin/main:` `create_goal` `schedule_create` status message", "`git show origin/main:` /loop 1h status message");
+	const directory = mkdtempSync(join(tmpdir(), "check-plan-test-"));
+	const file = join(directory, "plan.md");
+	writeFileSync(file, upstream);
+	try {
+		const result = spawnSync("node", [checker, file], { encoding: "utf8" });
+		expect(result.status).toBe(0);
+	} finally {
+		rmSync(directory, {
+			recursive: true,
+			force: true
+		});
+	}
+});
+export {};

package/{assets/skills/poteto-mode/scripts/check-plan.test.mjs → dist/pstack/skills/poteto-mode/scripts/expect.mjs}

@@ -1,11 +1,5 @@
-#!/usr/bin/env node
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawnSync } from "node:child_process";
-import { test } from "node:test";
 import { inspect } from "node:util";
-//#region .runtime-sources/skills/poteto-mode/scripts/expect.ts
+// runtime/skills/poteto-mode/scripts/expect.ts
 /**
 * A small `expect` for `node:test`.
 *
@@ -16,8 +10,8 @@ import { inspect } from "node:util";
 * port auditable against the calls that actually exist.
 *
 * Covered: `toBe`, `toEqual`, `toContain`, `toMatch`, `toThrow`, `toBeNull`,
-* `toBeInstanceOf`, `toHaveLength`, `toEndWith`, `toMatchObject`, `.not` on each,
-* and `rejects` / `resolves` for promises.
+* `toBeUndefined`, `toBeInstanceOf`, `toHaveLength`, `toEndWith`, `toMatchObject`,
+* `.not` on each, and `rejects` / `resolves` for promises.
 *
 * Two differences from `bun:test`, stated so a failure is not misread:
 *
@@ -146,6 +140,9 @@ function buildMatchers(actual, negate) {
 		toBeNull() {
 			checkPlain(actual === null, "toBeNull");
 		},
+		toBeUndefined() {
+			checkPlain(actual === void 0, "toBeUndefined");
+		},
 		toBeInstanceOf(expected) {
 			check(actual instanceof expected, "toBeInstanceOf", expected);
 		},
@@ -221,6 +218,10 @@ function buildAsyncMatchers(actual, mode, negate) {
 			buildMatchers(subject, false).toBeNull();
 			return;
 		}
+		if (name === "toBeUndefined") {
+			buildMatchers(subject, false).toBeUndefined();
+			return;
+		}
 		const matchers = buildMatchers(subject, false);
 		const matcher = matchers[name];
 		if (typeof matcher !== "function") throw new AssertionError(`unknown matcher ${name}`);
@@ -233,6 +234,7 @@ function buildAsyncMatchers(actual, mode, negate) {
 		toMatch: (expected) => wrap("toMatch", expected),
 		toThrow: (expected) => wrap("toThrow", expected),
 		toBeNull: () => wrap("toBeNull"),
+		toBeUndefined: () => wrap("toBeUndefined"),
 		toBeInstanceOf: (expected) => wrap("toBeInstanceOf", expected),
 		toHaveLength: (expected) => wrap("toHaveLength", expected),
 		toEndWith: (expected) => wrap("toEndWith", expected),
@@ -249,95 +251,4 @@ const expect = Object.assign((actual) => buildMatchers(actual, false), {
 	rejects: (actual) => buildAsyncMatchers(actual, "rejects", false),
 	resolves: (actual) => buildAsyncMatchers(actual, "resolves", false)
 });
-//#endregion
-//#region .runtime-sources/skills/poteto-mode/scripts/check-plan.test.ts
-const checker = join(import.meta.dirname, "check-plan.mjs");
-const rule = "Tests alone are not sufficient verification. A PR is verified only when its unit, live, and perf boxes are all checked.";
-const validPlan = `# Demo
-
-## How to read this
-One box is one unit of work and names the evidence. Check a box only when its evidence exists. See playbooks/.
-${rule}
-
-## Program checklist
-### Arm the program
-### Spawn owners
-### PR mechanics
-### Verdict and merge
-### Boot recipe
-\`create_goal\` \`schedule_create\` status message
-
-## PR 1
-**Depends on.** None.
-**Files.**
-- [ ] Do the thing.
-**Build.**
-- [ ] Do the thing.
-**You see.**
-- [ ] Do the thing.
-**Verify, unit.** ${rule}
-- [ ] Check the thing.
-**Verify, live.** ${rule} Ten lanes on \`example-model\` at the PR head
-${Array.from({ length: 10 }, (_, i) => `- [ ] Lane ${i + 1}. Save \`lane-${i + 1}.png\`. Pass when evidence exists.`).join("\n")}
-**Verify, perf.** ${rule}
-- [ ] Metric. Recorded.
-- [ ] Probe. Recorded.
-- [ ] Baseline. Recorded.
-- [ ] Rule. Recorded.
-**Review gate.** None.
-**Merge.**
-- [ ] Merge when approved.
-
-## Close the program
-Close.
-
-## Appendix Prototype evidence
-Recorded.
-`;
-const runPlan = (example, expectedExit) => {
-	const directory = mkdtempSync(join(tmpdir(), "check-plan-test-"));
-	const file = join(directory, "plan.md");
-	writeFileSync(file, validPlan + example);
-	try {
-		const result = spawnSync("node", [checker, file], { encoding: "utf8" });
-		expect(result.status).toBe(expectedExit);
-		return result;
-	} finally {
-		rmSync(directory, {
-			recursive: true,
-			force: true
-		});
-	}
-};
-test("accepts ordinary, indented, and longer closing fences", () => {
-	for (const indent of [
-		"",
-		" ",
-		"  ",
-		"   "
-	]) runPlan(`${indent}\`\`\`markdown\n## Example only\n${indent}\`\`\`\n`, 0);
-	runPlan("```markdown\n## Example only\n````\n", 0);
-});
-test("accepts nested backticks and tilde info strings", () => {
-	runPlan("````markdown\n```markdown\n## Example only\n```\n````\n", 0);
-	runPlan("~~~markdown `info`\n## Example only\n ~~~\n", 0);
-});
-test("keeps mismatched, shorter, and suffixed closers inside the fence", () => {
-	runPlan("````markdown\n~~~\n## Example only\n````\n", 0);
-	runPlan("````markdown\n```\n## Example only\n````\n", 0);
-	runPlan("````markdown\n``` info\n## Example only\n````\n", 0);
-});
-test("rejects headings and prose outside a proper close", () => {
-	for (const suffix of ["  ", "	"]) {
-		const heading = runPlan(`\`\`\`markdown\n## Example only\n\`\`\`${suffix}\n## Example only\n`, 1);
-		expect(heading.stderr).toContain("\"## Example only\" after Close the program is not an appendix");
-	}
-	const prose = runPlan("```markdown\nThis prose has a mid-sentence colon: inside code\n```\nThis prose has a mid-sentence colon: bad.\n", 1);
-	expect(prose.stderr).toContain("mid-sentence colon");
-});
-test("rejects backtick info strings containing a backtick", () => {
-	const result = runPlan("```markdown `invalid`\n## Example only\n```\n", 1);
-	expect(result.stderr).toContain("\"## Example only\" after Close the program is not an appendix");
-});
-//#endregion
-export {};
+export { AssertionError, deepEqual, expect };

package/dist/pstack/skills/poteto-mode/scripts/support.mjs

@@ -0,0 +1,93 @@
+import { expect } from "./expect.mjs";
+import { spawn as spawn$1, spawnSync as spawnSync$1 } from "node:child_process";
+// runtime/skills/poteto-mode/scripts/support.ts
+/**
+* The one support module the ported upstream tests import.
+*
+* The five upstream test files were written for `bun:test` and use exactly two
+* Bun facilities: its `expect`, and `Bun.spawnSync` / `Bun.spawn` for running git
+* and short-lived processes. Rather than rewrite every call site, this module
+* supplies those two shapes and the test patch only replaces the import line. The
+* bodies below stay byte-for-byte the upstream text, so a future upstream change
+* is still readable against this tree.
+*
+* `Bun.spawnSync` returns `{ exitCode, stdout, stderr, success }` with Buffer
+* output and never throws on a nonzero exit; `node:child_process.spawnSync`
+* returns `{ status, stdout, stderr }`. The adapter is the mapping between them,
+* not a second implementation.
+*
+* `Bun.spawn` returns `{ pid, exited: Promise<number> }`. The adapter runs the
+* child to completion and resolves `exited` with the exit status, which is what
+* the one call site awaits.
+*/
+/**
+* Run a command to completion, Bun-shaped.
+*
+* A signal-terminated child reports `exitCode: 1` rather than `null`, so a test
+* that formats the code never prints `undefined` for a killed process.
+*/
+function spawnSync(argv, options = {}) {
+	const [command, ...args] = argv;
+	if (command === void 0) throw new TypeError("spawnSync needs a command");
+	const result = spawnSync$1(command, args, {
+		cwd: options.cwd,
+		env: options.env,
+		stdio: [
+			options.stdin === "inherit" ? "inherit" : "pipe",
+			options.stdout === "inherit" ? "inherit" : "pipe",
+			options.stderr === "inherit" ? "inherit" : "pipe"
+		],
+		encoding: "buffer"
+	});
+	const exitCode = result.status ?? 1;
+	return {
+		exitCode,
+		stdout: Buffer.isBuffer(result.stdout) ? result.stdout : Buffer.alloc(0),
+		stderr: Buffer.isBuffer(result.stderr) ? result.stderr : Buffer.alloc(0),
+		success: exitCode === 0
+	};
+}
+/**
+* A child that exits immediately, as a real process.
+*
+* The current interpreter running an empty program is a process like any other: its
+* `pid` is real and its exit status is 0.
+*/
+function immediateExit() {
+	return spawn$1(process.execPath, ["-e", ""], { stdio: "ignore" });
+}
+/** Whether `command` starts at all, checked without a shell. */
+function resolves(command) {
+	return spawnSync$1(command, ["--version"], { stdio: "ignore" }).error === void 0;
+}
+/**
+* Start a command and expose Bun's `{ pid, exited }` shape.
+*
+* The one upstream call is `spawn(["true"])`, used to obtain a pid that has already
+* exited so the test can plant a stale lock. It reads `pid` *before* awaiting
+* `exited`, so the pid must be real and already dead when this returns.
+*
+* That rules out "spawn it and fall back on failure": the failure is asynchronous, so
+* the caller would read `-1`. The probe is synchronous instead, which lets this
+* function choose the right child before returning. `true` is used when it exists and
+* the current interpreter otherwise — a `PATH` without the usual Unix utilities is
+* exactly the environment this release has to work in.
+*/
+function spawn(argv) {
+	const [command, ...args] = argv;
+	if (command === void 0) throw new TypeError("spawn needs a command");
+	const child = resolves(command) ? spawn$1(command, args, { stdio: "ignore" }) : immediateExit();
+	return {
+		pid: child.pid ?? -1,
+		exited: new Promise((resolve) => {
+			child.once("close", (code) => resolve(code ?? 1));
+			child.once("error", () => resolve(1));
+		})
+	};
+}
+/** The `Bun` global the upstream tests reference, limited to what they call. */
+const Bun = {
+	spawnSync,
+	spawn
+};
+export { Bun, expect, spawn, spawnSync };

package/dist/pstack/skills/poteto-mode/scripts/watch-pr/cli.mjs

@@ -0,0 +1,123 @@
+import { nonEmpty, parsePrNumber } from "./types.mjs";
+import { GhGitHubReader, WatcherQueryError, discoverStack, resolveContext } from "./github.mjs";
+import { runQueued, runSimple, statusQueryVerdict, verdictFactory } from "./policy.mjs";
+import { renderJson, renderPretty } from "./render.mjs";
+import { setTimeout } from "node:timers/promises";
+import { Command, CommanderError, InvalidArgumentError, Option } from "commander";
+// runtime/skills/poteto-mode/scripts/watch-pr/cli.ts
+function positiveNumber(value) {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed <= 0) throw new InvalidArgumentError("must be greater than zero");
+	return parsed;
+}
+function nonNegativeNumber(value) {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed < 0) throw new InvalidArgumentError("must be zero or greater");
+	return parsed;
+}
+function positiveInteger(value) {
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new InvalidArgumentError("must be a positive integer");
+	return parsed;
+}
+function prNumber(value) {
+	try {
+		return parsePrNumber(Number(value.replace(/^#/, "")));
+	} catch {
+		throw new InvalidArgumentError("must be a positive integer");
+	}
+}
+function stackPrList(value) {
+	const numbers = value.split(",").map((part) => prNumber(part.trim()));
+	if (new Set(numbers).size !== numbers.length) throw new InvalidArgumentError("contains a duplicate PR");
+	const parsed = nonEmpty(numbers);
+	if (parsed === null) throw new InvalidArgumentError("cannot be empty");
+	return parsed;
+}
+function parseArgs(argv, io) {
+	const program = new Command("watch-pr").description("Watch one pull request, a connected stack, or an immutable queued stack.\nJSON (NDJSON while polling) is the default; --pretty renders human text.").configureOutput({
+		writeOut: io.stdout,
+		writeErr: io.stderr
+	}).exitOverride().option("--owner <owner>", "GitHub repository owner").option("--repo <repo>", "GitHub repository name").option("--pr <number>", "pull request number", prNumber).addOption(new Option("--stack", "watch the connected open stack").default(false).conflicts("queuedStack")).option("--queued-stack", "watch the captured stack until all PRs merge", false).option("--stack-prs <n,...>", "frozen bottom-to-top queue (queued mode only)", stackPrList).option("--interval <seconds>", "poll interval", positiveNumber, 60).option("--sweep-interval <seconds>", "whole-stack sweep interval", positiveNumber, 300).option("--timeout <seconds>", "deadline; 0 disables it", nonNegativeNumber, 0).option("--max-query-errors <count>", "consecutive query-error budget", positiveInteger, 5).option("--status-only", "print one status table and exit 0", false).option("--allow-draft", "do not treat a draft as a merge gate", false).option("--pretty", "render human text instead of JSON", false);
+	program.parse(argv, { from: "user" });
+	const raw = program.opts();
+	if (raw.stackPrs !== void 0 && !raw.queuedStack) program.error("error: --stack-prs requires --queued-stack");
+	return {
+		owner: raw.owner ?? null,
+		repo: raw.repo ?? null,
+		pr: raw.pr ?? null,
+		mode: raw.queuedStack ? "queued-stack" : raw.stack ? "stack" : "single",
+		stackPrs: raw.stackPrs ?? [],
+		statusOnly: raw.statusOnly,
+		pretty: raw.pretty,
+		polling: {
+			interval: raw.interval,
+			sweepInterval: raw.sweepInterval,
+			timeout: raw.timeout,
+			maxQueryErrors: raw.maxQueryErrors,
+			allowDraft: raw.allowDraft
+		}
+	};
+}
+function realRuntime() {
+	return {
+		reader: new GhGitHubReader(),
+		clock: {
+			now: () => performance.now() / 1e3,
+			observedAt: () => (/* @__PURE__ */ new Date()).toISOString(),
+			sleep: async (seconds) => {
+				await setTimeout(seconds * 1e3);
+			}
+		},
+		stdout: (value) => process.stdout.write(value),
+		stderr: (value) => process.stderr.write(value)
+	};
+}
+async function main(argv, runtime = realRuntime()) {
+	let options;
+	try {
+		options = parseArgs(argv, runtime);
+	} catch (error) {
+		if (!(error instanceof CommanderError)) throw error;
+		return error.exitCode === 0 ? 0 : 64;
+	}
+	const render = options.pretty ? renderPretty : renderJson;
+	const emit = (verdict) => runtime.stdout(render(verdict));
+	let contexts;
+	try {
+		const seed = await resolveContext({
+			reader: runtime.reader,
+			owner: options.owner,
+			repo: options.repo,
+			pr: options.pr ?? options.stackPrs[0] ?? null
+		});
+		contexts = nonEmpty(options.stackPrs.map((number) => ({
+			...seed,
+			number
+		}))) ?? (options.mode === "single" ? [seed] : await discoverStack(runtime.reader, seed));
+	} catch (error) {
+		if (!(error instanceof WatcherQueryError)) throw error;
+		const verdict = statusQueryVerdict(verdictFactory(runtime.clock, options.mode), 1, error.failure);
+		runtime.stdout(render(verdict));
+		return verdict.exitCode;
+	}
+	const dependencies = {
+		reader: runtime.reader,
+		clock: runtime.clock,
+		emit
+	};
+	const verdict = options.mode === "queued-stack" && !options.statusOnly ? await runQueued({
+		dependencies,
+		contexts,
+		options: options.polling
+	}) : await runSimple({
+		dependencies,
+		contexts,
+		mode: options.mode,
+		statusOnly: options.statusOnly,
+		options: options.polling
+	});
+	runtime.stdout(render(verdict));
+	return verdict.exitCode;
+}
+export { main, parseArgs };