dsh-pstack 0.1.0 → 0.2.0-beta.3

package/dist/{assets → pstack}/skills/poteto-mode/playbooks/worktree-cleanup.md

@@ -1,11 +1,11 @@
 ### Worktree and simulator cleanup
 
-1. Snapshot and audit. Record `df -h /`, then run `scripts/worktree-audit.sh [-b <pr-base-ref>] [repo-path]` (principle-build-the-lever). Without `-b` it checks `MERGED` against `origin/HEAD`, so pass `-b origin/<branch>` when PRs target another branch. It reads paths from `git worktree list`, never hand-typed, since a hand-typed `myrepo-worktrees/x` misses one that lives at `.worktrees/myrepo/x` (principle-encode-lessons-in-structure). It classifies each worktree by size, age, merge state, uncommitted work, PR state, and the newest chat that touched it, then suggests a bucket. The transcript scan is slow, so background it.
+1. Snapshot and audit. Record `df -h /`, then run `scripts/worktree-audit.sh [-b <pr-base-ref>] [repo-path]` (principle-build-the-lever). Without `-b` it checks `MERGED` against `origin/HEAD`, so pass `-b origin/<branch>` when PRs target another branch. It reads paths from `git worktree list`, never hand-typed, since a hand-typed `myrepo-worktrees/x` misses one that lives at `.cursor/worktrees/myrepo/x` (principle-encode-lessons-in-structure). It classifies each worktree by size, age, merge state, uncommitted work, PR state, and the newest chat that touched it, then suggests a bucket. The transcript scan is slow, so background it.
 2. The bucket is advice, not permission. The pinned and active chats are the real artifact (principle-prove-it-works). Get that set from the user or sidebar and cross-check every candidate. The lever has marked `safe` a worktree the user had pinned, so the pinned set wins.
 3. Verify usage before deleting. For every `verify-recent-chat` row, or anything you doubt, fan subagents out to read the transcripts and report whether the chat is pinned or ongoing and which worktrees it touches (principle-guard-the-context-window, transcripts are bulk). A pinned chat spawns arena and repro trees into sibling worktrees via background subagents, and those are in use even when their names never hit the sidebar. Pick each subagent's reasoning level and fast or standard speed for the job, per the Subagents section.
 4. Pause on irreversible loss. `wip:N` is N tracked uncommitted edits. Show the diff and get a decision first, since removing a clean worktree is recoverable from its branch but uncommitted work is gone. `scratch:N` is untracked throwaway, safe to drop, but name the files. Per Autonomy, clean and merged and not-in-use proceeds. `wip` and in-use pause.
 5. Prune the confirmed set. Per path, `git worktree remove --force <path>`. If the dir survives on ignored build artifacts, `rm -rf` it, then `git worktree prune`. Branch refs survive, so no commits are lost. Confirm with `df -h /` and re-list.
-6. Simulators and other reclaimers. Simulators are usually the next-biggest win. `xcrun simctl --set testing delete all` (XCTestDevices clones), `xcrun simctl delete unavailable`, and `xcrun simctl runtime list` then `runtime delete <id>` for old runtimes. More when needed: Xcode `DerivedData` and `iOS DeviceSupport`, package caches (pnpm, uv, brew, yarn). Clear only caches the user has not said to keep.
+6. Simulators and other reclaimers. Simulators are usually the next-biggest win. `xcrun simctl --set testing delete all` (XCTestDevices clones), `xcrun simctl delete unavailable`, and `xcrun simctl runtime list` then `runtime delete <id>` for old runtimes. More when needed: Xcode `DerivedData` and `iOS DeviceSupport`, `~/Library/Application Support/Cursor` (`state.vscdb.backup`, and `snapshots/roots/<root>` where a `<root>` named for a folder you opened as a workspace balloons), package caches (pnpm, uv, brew, yarn). Clear only caches the user has not said to keep.
 
 This is the one playbook that deletes user state with no code review to catch a slip, so the gates above are the review.
 

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

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import process from "node:process";
-
-const RULE =
-	"Tests alone are not sufficient verification. A PR is verified only when its unit, live, and perf boxes are all checked.";
+// 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 = [
 	"Depends on.",
@@ -14,49 +13,54 @@ const SUB_BLOCKS = [
 	"Verify, live.",
 	"Verify, perf.",
 	"Review gate.",
-	"Merge.",
+	"Merge."
 ];
-const PROGRAM_H3 = ["Arm the program", "Spawn owners", "PR mechanics", "Verdict and merge", "Boot recipe"];
-const PROGRAM_MARKERS = ["git show origin/main:", "schedule_create 1h", "status message"];
+const PROGRAM_H3 = [
+	"Arm the program",
+	"Spawn owners",
+	"PR mechanics",
+	"Verdict and merge",
+	"Boot recipe"
+];
+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",
 	"Check a box only when its evidence exists",
 	"playbooks/",
-	RULE,
+	RULE
+];
+const PERF_ITEMS = [
+	"Metric.",
+	"Probe.",
+	"Baseline.",
+	"Rule."
 ];
-const PERF_ITEMS = ["Metric.", "Probe.", "Baseline.", "Rule."];
 const BOX = /^\s*- \[[ x]\] (.*)$/;
-
 const file = process.argv[2];
 if (!file) {
 	console.error("Usage: node check-plan.mjs <plan.md>");
 	process.exit(2);
 }
-
 const raw = fs.readFileSync(file, "utf8").split(/\r?\n/);
 const problems = [];
 const fail = (line, message) => problems.push(`${file}:${line}: ${message}`);
-
 let start = 0;
-if (raw[0] === "---") {
-	start = raw.indexOf("---", 1) + 1;
-}
-
+if (raw[0] === "---") start = raw.indexOf("---", 1) + 1;
 const lines = [];
 let fence = null;
 const openingFence = (text) => {
 	const match = text.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
-	if (!match || (match[1][0] === "`" && match[2].includes("`"))) return null;
-	return { char: match[1][0], length: match[1].length };
+	if (!match || match[1][0] === "`" && match[2].includes("`")) return null;
+	return {
+		char: match[1][0],
+		length: match[1].length
+	};
 };
 const closingFence = (text, opening) => {
 	const match = text.match(/^ {0,3}(`+|~+)[ \t]*$/);
-	return Boolean(
-		match &&
-		match[1][0] === opening.char &&
-		match[1].length >= opening.length,
-	);
+	return Boolean(match && match[1][0] === opening.char && match[1].length >= opening.length);
 };
 for (let i = start; i < raw.length; i++) {
 	const text = raw[i];
@@ -69,42 +73,45 @@ for (let i = start; i < raw.length; i++) {
 		fence = openingFence(text);
 		code = Boolean(fence);
 	}
-	lines.push({ n, text, code });
+	lines.push({
+		n,
+		text,
+		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");
 }
-
-const h2 = (l) => (!l.code && l.text.startsWith("## ") ? l.text.slice(3).trim() : null);
+const h2 = (l) => !l.code && l.text.startsWith("## ") ? l.text.slice(3).trim() : null;
 const sections = [];
 for (const l of lines) {
 	const title = h2(l);
-	if (title !== null) sections.push({ title, n: l.n, body: [] });
+	if (title !== null) sections.push({
+		title,
+		n: l.n,
+		body: []
+	});
 	else if (sections.length) sections.at(-1).body.push(l);
 }
 const find = (title) => sections.find((s) => s.title === title);
 const bodyText = (s) => s.body.map((l) => l.text).join("\n");
-const boxes = (ls) => ls.filter((l) => !l.code && BOX.test(l.text)).map((l) => ({ n: l.n, text: l.text.match(BOX)[1] }));
-
+const boxes = (ls) => ls.filter((l) => !l.code && BOX.test(l.text)).map((l) => ({
+	n: l.n,
+	text: l.text.match(BOX)[1]
+}));
 const h1 = lines.findIndex((l) => !l.code && l.text.startsWith("# "));
 if (h1 === -1) fail(1, "no H1 title");
 const howToRead = find("How to read this");
-if (!howToRead) fail(1, 'no "## How to read this" section');
+if (!howToRead) fail(1, "no \"## How to read this\" section");
 if (h1 !== -1 && howToRead) {
 	const intro = lines.slice(h1 + 1).filter((l) => l.n < howToRead.n && l.text.trim() !== "");
 	if (intro.length >= 10) fail(lines[h1].n, `intro is ${intro.length} lines, under ten required`);
-	for (const marker of HOW_TO_READ_MARKERS) {
-		if (!bodyText(howToRead).includes(marker)) fail(howToRead.n, `How to read this lacks "${marker}"`);
-	}
+	for (const marker of HOW_TO_READ_MARKERS) if (!bodyText(howToRead).includes(marker)) fail(howToRead.n, `How to read this lacks "${marker}"`);
 }
-
 const program = find("Program checklist");
-if (!program) fail(1, 'no "## Program checklist" section');
+if (!program) fail(1, "no \"## Program checklist\" section");
 else {
 	const h3s = program.body.filter((l) => !l.code && l.text.startsWith("### ")).map((l) => l.text.slice(4).trim());
 	let cursor = 0;
@@ -113,65 +120,73 @@ else {
 		if (at === -1) fail(program.n, `Program checklist lacks "### ${name}" in order`);
 		else cursor = at + 1;
 	}
-	for (const marker of PROGRAM_MARKERS) {
-		if (!bodyText(program).includes(marker)) fail(program.n, `Program checklist lacks "${marker}"`);
-	}
+	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');
+if (!close) fail(1, "no \"## Close the program\" section");
 const programIndex = sections.indexOf(program);
 const closeIndex = sections.indexOf(close);
 const prSections = programIndex === -1 || closeIndex === -1 ? [] : sections.slice(programIndex + 1, closeIndex);
 if (prSections.length === 0) fail(1, "no PR sections between Program checklist and Close the program");
-
 const report = [];
 for (const pr of prSections) {
 	const heads = [];
 	for (const l of pr.body) {
 		if (l.code) continue;
 		const m = l.text.match(/^\*\*([^*]+)\*\*(.*)$/);
-		if (m && SUB_BLOCKS.includes(m[1])) heads.push({ name: m[1], n: l.n, rest: m[2].trim(), lines: [] });
+		if (m && SUB_BLOCKS.includes(m[1])) heads.push({
+			name: m[1],
+			n: l.n,
+			rest: m[2].trim(),
+			lines: []
+		});
 		else if (heads.length) heads.at(-1).lines.push(l);
 	}
 	const names = heads.map((h) => h.name);
-	if (names.join("|") !== SUB_BLOCKS.join("|")) {
-		fail(pr.n, `${pr.title}: sub-blocks are [${names.join(", ")}], expected [${SUB_BLOCKS.join(", ")}]`);
-	}
+	if (names.join("|") !== SUB_BLOCKS.join("|")) fail(pr.n, `${pr.title}: sub-blocks are [${names.join(", ")}], expected [${SUB_BLOCKS.join(", ")}]`);
 	const block = (name) => heads.find((h) => h.name === name);
 	const counts = {};
 	for (const h of heads) counts[h.name] = boxes(h.lines).length;
-
 	const depends = block("Depends on.");
 	if (depends && depends.rest === "") fail(depends.n, `${pr.title}: Depends on names nothing`);
-	for (const name of ["Files.", "Build.", "You see.", "Verify, unit.", "Merge."]) {
+	for (const name of [
+		"Files.",
+		"Build.",
+		"You see.",
+		"Verify, unit.",
+		"Merge."
+	]) {
 		const b = block(name);
 		if (b && boxes(b.lines).length === 0) fail(b.n, `${pr.title}: ${name} has no box`);
 	}
-	for (const name of ["Verify, unit.", "Verify, live.", "Verify, perf."]) {
+	for (const name of [
+		"Verify, unit.",
+		"Verify, live.",
+		"Verify, perf."
+	]) {
 		const b = block(name);
 		if (b && !b.rest.startsWith(RULE)) fail(b.n, `${pr.title}: ${name} does not open with the rule`);
 	}
-
 	const live = block("Verify, live.");
 	if (live) {
 		if (!LANES.test(live.rest)) fail(live.n, `${pr.title}: Verify, live lacks "Ten lanes on \`<swarm workers model>\` at the PR head" with the model filled in`);
-		const lanes = boxes(live.lines).map((b) => ({ ...b, m: b.text.match(/^Lane (\d+)\. /) }));
+		const lanes = boxes(live.lines).map((b) => ({
+			...b,
+			m: b.text.match(/^Lane (\d+)\. /)
+		}));
 		const numbers = lanes.filter((b) => b.m).map((b) => Number(b.m[1])).sort((a, b) => a - b);
 		if (numbers.join(",") !== "1,2,3,4,5,6,7,8,9,10") fail(live.n, `${pr.title}: lanes are [${numbers.join(",")}], expected 1 to 10`);
-		for (const lane of lanes) {
-			if (!lane.m) fail(lane.n, `${pr.title}: live box is not a lane`);
-			else if (!/Save `[^`]+`/.test(lane.text)) fail(lane.n, `${pr.title}: lane ${lane.m[1]} names no screenshot`);
-			else if (!lane.text.includes("Pass when")) fail(lane.n, `${pr.title}: lane ${lane.m[1]} has no pass predicate`);
-		}
+		for (const lane of lanes) if (!lane.m) fail(lane.n, `${pr.title}: live box is not a lane`);
+		else if (!/Save `[^`]+`/.test(lane.text)) fail(lane.n, `${pr.title}: lane ${lane.m[1]} names no screenshot`);
+		else if (!lane.text.includes("Pass when")) fail(lane.n, `${pr.title}: lane ${lane.m[1]} has no pass predicate`);
 	}
-
 	const perf = block("Verify, perf.");
 	if (perf) {
 		const items = boxes(perf.lines).map((b) => b.text.split(" ")[0]);
 		if (items.join("|") !== PERF_ITEMS.join("|")) fail(perf.n, `${pr.title}: perf boxes are [${items.join(", ")}], expected [${PERF_ITEMS.join(", ")}]`);
 	}
-
 	const gate = block("Review gate.");
 	if (gate) {
 		const gateBoxes = boxes(gate.lines);
@@ -180,26 +195,24 @@ for (const pr of prSections) {
 		} else {
 			const text = gate.lines.map((l) => l.text).join("\n");
 			if (gateBoxes.length === 0) fail(gate.n, `${pr.title}: Review gate has no box`);
-			for (const word of ["screenshot", "video", "operator"]) {
-				if (!text.includes(word)) fail(gate.n, `${pr.title}: Review gate lacks "${word}"`);
-			}
+			for (const word of [
+				"screenshot",
+				"video",
+				"operator"
+			]) if (!text.includes(word)) fail(gate.n, `${pr.title}: Review gate lacks "${word}"`);
 		}
 	}
-
 	const total = boxes(pr.body).length;
 	const cells = SUB_BLOCKS.filter((s) => s !== "Depends on.").map((s) => `${s.replace(/[ ,.]+/g, "-").replace(/-$/, "").toLowerCase()}=${counts[s] ?? 0}`);
 	report.push(`${pr.title}  boxes=${total}  ${cells.join(" ")}`);
 }
-
 if (closeIndex !== -1) {
 	const tail = sections.slice(closeIndex + 1);
-	for (const s of tail) {
-		if (!s.title.startsWith("Appendix")) fail(s.n, `"## ${s.title}" after Close the program is not an appendix`);
-	}
-	if (!tail.some((s) => s.title.includes("Prototype evidence"))) fail(close.n, 'no "## Appendix ... Prototype evidence" section');
+	for (const s of tail) if (!s.title.startsWith("Appendix")) fail(s.n, `"## ${s.title}" after Close the program is not an appendix`);
+	if (!tail.some((s) => s.title.includes("Prototype evidence"))) fail(close.n, "no \"## Appendix ... Prototype evidence\" section");
 }
-
 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);
+export {};

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

@@ -1,13 +1,13 @@
+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 { expect, test } from "bun:test";
-
-const checker = join(import.meta.dir, "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.";
-
+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
@@ -20,7 +20,7 @@ ${rule}
 ### PR mechanics
 ### Verdict and merge
 ### Boot recipe
-\`git show origin/main:\` schedule_create 1h status message
+\`git show origin/main:\` \`create_goal\` \`schedule_create\` status message
 
 ## PR 1
 **Depends on.** None.
@@ -49,8 +49,7 @@ Close.
 ## Appendix Prototype evidence
 Recorded.
 `;
-
-const runPlan = (example: string, expectedExit: number) => {
+const runPlan = (example, expectedExit) => {
 	const directory = mkdtempSync(join(tmpdir(), "check-plan-test-"));
 	const file = join(directory, "plan.md");
 	writeFileSync(file, validPlan + example);
@@ -59,38 +58,71 @@ const runPlan = (example: string, expectedExit: number) => {
 		expect(result.status).toBe(expectedExit);
 		return result;
 	} finally {
-		rmSync(directory, { recursive: true, force: true });
+		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);
+	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 ["  ", "\t"]) {
+	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');
+		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');
+	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/dist/pstack/skills/poteto-mode/scripts/expect.mjs

@@ -0,0 +1,254 @@
+import { inspect } from "node:util";
+// runtime/skills/poteto-mode/scripts/expect.ts
+/**
+* A small `expect` for `node:test`.
+*
+* The five upstream test files were written against `bun:test`. Their assertions
+* are ordinary value comparisons, so this module supplies exactly the matchers
+* they use rather than a general test framework. It is deliberately not a drop-in
+* replacement: a matcher that is not listed here fails to compile, which keeps the
+* port auditable against the calls that actually exist.
+*
+* Covered: `toBe`, `toEqual`, `toContain`, `toMatch`, `toThrow`, `toBeNull`,
+* `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:
+*
+* - `toEqual` is structural for arrays and plain objects, `Object.is` otherwise.
+*   A class instance only equals itself; `toBeInstanceOf` is the matcher for type
+*   identity. The ported tests compare plain data, which is why this is enough.
+* - A failure throws `AssertionError` with the two values rendered, not Bun's
+*   coloured diff.
+*/
+/** Raised by every failing assertion. */
+var AssertionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AssertionError";
+	}
+};
+function display(value) {
+	if (typeof value === "function") return `[Function ${value.name || "anonymous"}]`;
+	return inspect(value, {
+		depth: 3,
+		breakLength: 120,
+		maxArrayLength: 20
+	});
+}
+function messageOf(error) {
+	if (error instanceof Error) return `${error.name}: ${error.message}`;
+	return String(error);
+}
+/** Structural equality for the shapes the ported tests compare. */
+function deepEqual(left, right) {
+	if (Object.is(left, right)) return true;
+	if (left instanceof Date || right instanceof Date) return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+	if (Array.isArray(left) || Array.isArray(right)) {
+		if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+		return left.every((item, index) => deepEqual(item, right[index]));
+	}
+	if (left === null || right === null || typeof left !== "object" || typeof right !== "object") return false;
+	const leftProto = Object.getPrototypeOf(left);
+	if (leftProto !== Object.getPrototypeOf(right)) return false;
+	if (leftProto !== Object.prototype && leftProto !== null) return false;
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	return leftKeys.every((key) => deepEqual(left[key], right[key]));
+}
+function contains(haystack, needle) {
+	if (typeof haystack === "string") return haystack.includes(String(needle));
+	if (Array.isArray(haystack)) return haystack.some((item) => deepEqual(item, needle));
+	if (haystack instanceof Set) return [...haystack].some((item) => deepEqual(item, needle));
+	return false;
+}
+/**
+* Whether `expected` is a partial description of `actual`.
+*
+* `bun:test`'s `toMatchObject` is recursive: every key in `expected` must exist and
+* match, arrays match element by element with the same partial rule, and extra keys
+* in `actual` are allowed. That is what lets an assertion name only the fields it
+* cares about, which several ported cases rely on.
+*/
+function matchesObject(actual, expected) {
+	if (Array.isArray(expected)) {
+		if (!Array.isArray(actual) || actual.length !== expected.length) return false;
+		return expected.every((item, index) => matchesObject(actual[index], item));
+	}
+	if (expected instanceof Date) return deepEqual(actual, expected);
+	if (expected === null || typeof expected !== "object") return deepEqual(actual, expected);
+	if (actual === null || typeof actual !== "object") return false;
+	return Object.entries(expected).every(([key, value]) => matchesObject(actual[key], value));
+}
+function thrownBy(call) {
+	try {
+		call();
+		return { thrown: false };
+	} catch (error) {
+		return {
+			thrown: true,
+			error
+		};
+	}
+}
+function buildMatchers(actual, negate) {
+	/**
+	* Fail when `ok` is not what the matcher asked for.
+	*
+	* `negate` inverts the requirement, so `.not.toContain(x)` passes on a haystack
+	* that does not contain `x` and fails when it does.
+	*/
+	const check = (ok, matcher, expected) => {
+		if (ok === !negate) return;
+		const relation = negate ? `not to ${matcher}` : matcher;
+		throw new AssertionError(`expected ${display(actual)} ${relation} ${display(expected)}`);
+	};
+	const checkPlain = (ok, matcher) => {
+		if (ok === !negate) return;
+		throw new AssertionError(`expected ${display(actual)} ${negate ? `not to ${matcher}` : matcher}`);
+	};
+	const matchers = {
+		toBe(expected) {
+			check(Object.is(actual, expected), "toBe", expected);
+		},
+		toEqual(expected) {
+			check(deepEqual(actual, expected), "toEqual", expected);
+		},
+		toContain(expected) {
+			check(contains(actual, expected), "toContain", expected);
+		},
+		toMatch(expected) {
+			const text = String(actual);
+			check(typeof expected === "string" ? text.includes(expected) : expected.test(text), "toMatch", expected);
+		},
+		toThrow(expected) {
+			if (typeof actual !== "function") throw new AssertionError(`toThrow needs a function, received ${display(actual)}`);
+			const result = thrownBy(actual);
+			if (!result.thrown) {
+				checkPlain(false, "toThrow");
+				return;
+			}
+			if (expected === void 0) {
+				checkPlain(true, "toThrow");
+				return;
+			}
+			const message = messageOf(result.error);
+			const ok = typeof expected === "string" ? message.includes(expected) : expected instanceof RegExp ? expected.test(message) : result.error instanceof expected;
+			check(ok, "toThrow", expected);
+		},
+		toBeNull() {
+			checkPlain(actual === null, "toBeNull");
+		},
+		toBeUndefined() {
+			checkPlain(actual === void 0, "toBeUndefined");
+		},
+		toBeInstanceOf(expected) {
+			check(actual instanceof expected, "toBeInstanceOf", expected);
+		},
+		toHaveLength(expected) {
+			const length = actual?.length;
+			check(length === expected, "toHaveLength", expected);
+		},
+		toEndWith(expected) {
+			check(String(actual).endsWith(expected), "toEndWith", expected);
+		},
+		toMatchObject(expected) {
+			check(matchesObject(actual, expected), "toMatchObject", expected);
+		}
+	};
+	Object.defineProperties(matchers, {
+		not: {
+			get: () => buildMatchers(actual, !negate),
+			enumerable: true
+		},
+		rejects: {
+			get: () => buildAsyncMatchers(actual, "rejects", negate),
+			enumerable: true
+		},
+		resolves: {
+			get: () => buildAsyncMatchers(actual, "resolves", negate),
+			enumerable: true
+		}
+	});
+	return matchers;
+}
+/**
+* Compare against a settled promise.
+*
+* `rejects` reads the rejection reason and fails when the promise resolved;
+* `resolves` is the mirror. Each matcher awaits the settlement, which is what
+* makes `await expect(promise).rejects.toThrow(...)` wait before it compares.
+*/
+function buildAsyncMatchers(actual, mode, negate) {
+	if (typeof actual?.then !== "function") throw new AssertionError(`expected a promise, received ${display(actual)}`);
+	const wantRejection = mode === "rejects" !== negate;
+	const settle = async () => {
+		let resolved;
+		let rejected;
+		await Promise.resolve(actual).then((value) => {
+			resolved = { value };
+		}, (error) => {
+			rejected = { error };
+		});
+		if (wantRejection) {
+			if (resolved !== void 0) throw new AssertionError(`expected the promise to reject, it resolved to ${display(resolved.value)}`);
+			return rejected?.error;
+		}
+		if (rejected !== void 0) throw new AssertionError(`expected the promise to resolve, it rejected with ${messageOf(rejected.error)}`);
+		return resolved?.value;
+	};
+	/**
+	* Run one matcher against the settled value.
+	*
+	* `toThrow` and `toBeInstanceOf` both read the rejection reason, so a thrown
+	* reason is turned back into a thunk for `toThrow` rather than special-cased
+	* twice. `negate` is already folded into the settlement mode, so the inner
+	* matchers run un-negated.
+	*/
+	const wrap = async (name, expected) => {
+		const subject = await settle();
+		if (name === "toThrow") {
+			buildMatchers(() => {
+				throw subject;
+			}, false).toThrow(expected);
+			return;
+		}
+		if (name === "toBeNull") {
+			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}`);
+		matcher.call(matchers, expected);
+	};
+	const matchers = {
+		toBe: (expected) => wrap("toBe", expected),
+		toEqual: (expected) => wrap("toEqual", expected),
+		toContain: (expected) => wrap("toContain", expected),
+		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),
+		toMatchObject: (expected) => wrap("toMatchObject", expected)
+	};
+	Object.defineProperty(matchers, "not", {
+		get: () => buildAsyncMatchers(actual, mode, !negate),
+		enumerable: true
+	});
+	return matchers;
+}
+const expect = Object.assign((actual) => buildMatchers(actual, false), {
+	not: (actual) => buildMatchers(actual, true),
+	rejects: (actual) => buildAsyncMatchers(actual, "rejects", false),
+	resolves: (actual) => buildAsyncMatchers(actual, "resolves", false)
+});
+export { AssertionError, deepEqual, expect };