@teamscala/service-boot 0.23.524 → 0.23.525

package/src/content-gate/gate-entry-marker.test.ts

@@ -1,111 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Locks the OPT-IN gate-entry marker. A gate that does NOT declare
- * entryCookieName must behave exactly as before — a valid token authorizes on
- * any load and nothing is recorded for clearing (condition 1: every non-opting
- * service unchanged). An opting gate authorizes ONLY the request that carries
- * the marker (the identity submit's own redirect) and returns the marker name
- * so the page Response clears it — one view, then the gate is presented again.
- *
- * The clears are asserted from the CALL'S RETURN VALUE: the store lives only
- * inside the run() scope, and the first shipped version read it afterwards,
- * saw nothing, and left the marker in the browser (measured live 2026-09-14).
- *
- * Operator ruling 2026-09-14 (refresh must return to the identity gate),
- * mechanism measured live: the quiz_token cookie alone was the carrier that
- * skipped the gate on reload.
- */
-import { describe, expect, test } from "bun:test";
-import type { ContentGateConfig } from "./config-types.ts";
-import { runContentGate } from "./gate.ts";
-import { withGateEntryClears } from "./gate-entry-clears.ts";
-
-function makeConfig(entryCookieName?: string) {
-	const calls = { authorized: 0, unauthorized: 0 };
-	const cfg: ContentGateConfig = {
-		cookieName: "quiz_token",
-		entryCookieName,
-		getResourceId: () => "res-1",
-		verifyToken: (token) =>
-			token === "good" ? { email: "v@example.com", name: "V" } : null,
-		onAuthorized: () => {
-			calls.authorized++;
-		},
-		onUnauthorized: () => {
-			calls.unauthorized++;
-		},
-	};
-	return { cfg, calls };
-}
-
-describe("gate entry marker is opt-in and one-view", () => {
-	test("non-opting gate: a valid token authorizes on any load, nothing cleared — behaviour unchanged", async () => {
-		const { cfg, calls } = makeConfig();
-		const { clears } = await withGateEntryClears(async () => {
-			const out = await runContentGate({}, "quiz_token=good", Date.now(), cfg);
-			expect(out.authorized).toBe(true);
-			expect(calls.authorized).toBe(1);
-		});
-		expect(clears).toEqual([]);
-	});
-
-	test("opting gate: token WITHOUT the marker is unauthorized — a refresh shows the gate", async () => {
-		const { cfg, calls } = makeConfig("quiz_token_entered");
-		const { clears } = await withGateEntryClears(async () => {
-			const out = await runContentGate({}, "quiz_token=good", Date.now(), cfg);
-			expect(out.authorized).toBe(false);
-			expect(calls.unauthorized).toBe(1);
-			expect(calls.authorized).toBe(0);
-		});
-		expect(clears).toEqual([]);
-	});
-
-	test("opting gate: token + marker authorizes and RETURNS the marker for clearing — one view", async () => {
-		const { cfg, calls } = makeConfig("quiz_token_entered");
-		const { clears } = await withGateEntryClears(async () => {
-			const out = await runContentGate(
-				{},
-				"quiz_token=good; quiz_token_entered=1",
-				Date.now(),
-				cfg,
-			);
-			expect(out.authorized).toBe(true);
-			expect(calls.authorized).toBe(1);
-		});
-		expect(clears).toEqual(["quiz_token_entered"]);
-	});
-
-	test("opting gate: marker present but token invalid stays unauthorized and clears nothing", async () => {
-		const { cfg, calls } = makeConfig("quiz_token_entered");
-		const { clears } = await withGateEntryClears(async () => {
-			const out = await runContentGate(
-				{},
-				"quiz_token=bad; quiz_token_entered=1",
-				Date.now(),
-				cfg,
-			);
-			expect(out.authorized).toBe(false);
-			expect(calls.unauthorized).toBe(1);
-		});
-		expect(clears).toEqual([]);
-	});
-
-	test("two gates in one request each report their own marker, drained once", async () => {
-		const first = makeConfig("gate_a_entered");
-		const second = makeConfig("gate_b_entered");
-		const { clears } = await withGateEntryClears(async () => {
-			await runContentGate({}, "quiz_token=good; gate_a_entered=1", Date.now(), first.cfg);
-			await runContentGate({}, "quiz_token=good; gate_b_entered=1", Date.now(), second.cfg);
-		});
-		expect(clears).toEqual(["gate_a_entered", "gate_b_entered"]);
-	});
-
-	test("the quiz gate and its access endpoint both opt in on the same marker name", async () => {
-		const { quizAccessConfig, quizGateConfig } = await import("../quiz-gate.ts");
-		expect(quizGateConfig.entryCookieName).toBe("quiz_token_entered");
-		expect(quizAccessConfig.entryCookieName).toBe("quiz_token_entered");
-	});
-});

package/src/content-gate/token.segmentation.test.ts

@@ -1,76 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Segmentation carriage in the content-gate token. The quiz's composed gate
- * screen captures company/linkedin_url/website/team_size alongside the
- * identity; the token carries them to the next render so the submit can put
- * all seven fields on the ONE response row with no client storage. The
- * generated `token.test.ts` owns the identity/binding suite; these are the
- * segmentation-specific cases (including the backward-compatibility contract:
- * a token minted before `s` existed verifies identically).
- */
-
-process.env.AUTH_SECRET = "local-test-fixture-entropy-0001";
-
-import { describe, expect, test } from "bun:test";
-import { signAccessToken, verifyAccessTokenIdentity } from "./token.ts";
-
-const NOW = 1_000_000_000_000;
-const TTL = 60_000;
-
-function decodePayload(token: string): Record<string, unknown> {
-	return JSON.parse(Buffer.from(token.split(".")[0], "base64url").toString());
-}
-
-describe("content-gate token — segmentation carriage", () => {
-	test("round-trips the four captured fields", () => {
-		const t = signAccessToken("quiz_token", "quiz-1", "a@b.com", NOW, TTL, "Ann", "+614", {
-			company: "Acme",
-			linkedinUrl: "https://www.linkedin.com/in/ann",
-			website: "https://acme.test",
-			teamSize: "Me + team of 2–5",
-		});
-		const id = verifyAccessTokenIdentity(t, "quiz_token", "quiz-1", NOW + 1);
-		expect(id?.email).toBe("a@b.com");
-		expect(id?.name).toBe("Ann");
-		expect(id?.phone).toBe("+614");
-		expect(id?.segmentation).toEqual({
-			company: "Acme",
-			linkedinUrl: "https://www.linkedin.com/in/ann",
-			website: "https://acme.test",
-			teamSize: "Me + team of 2–5",
-		});
-	});
-
-	test("BACKWARD COMPATIBILITY: a pre-widening token (no s key) verifies with segmentation undefined — never an error", () => {
-		// Mint with the old shape by omitting segmentation entirely, then assert
-		// the exact contract a deploy-window survivor must satisfy.
-		const t = signAccessToken("quiz_token", "quiz-1", "a@b.com", NOW, TTL, "Ann", "+614");
-		expect(decodePayload(t as string).s).toBeUndefined();
-		const id = verifyAccessTokenIdentity(t, "quiz_token", "quiz-1", NOW + 1);
-		expect(id).toEqual({ email: "a@b.com", name: "Ann", phone: "+614", segmentation: undefined });
-	});
-
-	test("empty/whitespace segmentation values produce no s key at all", () => {
-		const t = signAccessToken("quiz_token", "quiz-1", "a@b.com", NOW, TTL, undefined, undefined, {
-			company: "   ",
-			linkedinUrl: "",
-			website: undefined,
-			teamSize: undefined,
-		});
-		expect(decodePayload(t as string).s).toBeUndefined();
-		const id = verifyAccessTokenIdentity(t, "quiz_token", "quiz-1", NOW + 1);
-		expect(id?.segmentation).toBeUndefined();
-	});
-
-	test("values are trimmed on sign", () => {
-		const t = signAccessToken("quiz_token", "quiz-1", "a@b.com", NOW, TTL, undefined, undefined, {
-			company: "  Acme  ",
-			teamSize: "Just me",
-		});
-		const id = verifyAccessTokenIdentity(t, "quiz_token", "quiz-1", NOW + 1);
-		expect(id?.segmentation).toEqual({ company: "Acme", teamSize: "Just me" });
-	});
-});

package/src/content-gate/token.test.ts

@@ -1,65 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// carries them verbatim, this file is the emission, and hand edits here are
-// overwritten on the next run. The rationale each assertion carries moved
-// with it into the band.
-
-process.env.AUTH_SECRET = "test-secret-at-least-16-chars-long";
-
-import { describe, expect, test } from "bun:test";
-import {
-	signAccessToken,
-	verifyAccessToken,
-	verifyAccessTokenIdentity,
-} from "./token.ts";
-
-const NOW = 1_000_000_000_000;
-const TTL = 60_000;
-
-describe("content-gate token — identity", () => {
-	test("signs + verifies email AND name (GPT capture)", () => {
-		const t = signAccessToken("gpt_token", "gpt-1", "A@B.com", NOW, TTL, "Ann");
-		expect(t).toBeTruthy();
-		const id = verifyAccessTokenIdentity(t, "gpt_token", "gpt-1", NOW + 1);
-		expect(id).toEqual({ email: "a@b.com", name: "Ann" });
-	});
-
-	test("name omitted → identity has email, name undefined", () => {
-		const t = signAccessToken("gpt_token", "gpt-1", "a@b.com", NOW, TTL);
-		const id = verifyAccessTokenIdentity(t, "gpt_token", "gpt-1", NOW + 1);
-		expect(id).toEqual({ email: "a@b.com", name: undefined });
-	});
-
-	test("email-only verifyAccessToken still works (proposals/agreements)", () => {
-		const t = signAccessToken("prop_token", "p-1", "a@b.com", NOW, TTL);
-		expect(verifyAccessToken(t, "prop_token", "p-1", NOW + 1)).toBe("a@b.com");
-	});
-});
-
-describe("content-gate token — binding (withholds content)", () => {
-	const t = signAccessToken("gpt_token", "gpt-1", "a@b.com", NOW, TTL, "Ann");
-
-	test("wrong gate (cookieName) → null", () => {
-		expect(verifyAccessTokenIdentity(t, "prop_token", "gpt-1", NOW + 1)).toBeNull();
-	});
-
-	test("wrong resource → null", () => {
-		expect(verifyAccessTokenIdentity(t, "gpt_token", "gpt-2", NOW + 1)).toBeNull();
-	});
-
-	test("expired → null", () => {
-		expect(verifyAccessTokenIdentity(t, "gpt_token", "gpt-1", NOW + TTL + 1)).toBeNull();
-	});
-
-	test("tampered signature → null", () => {
-		const bad = `${t?.split(".")[0]}.deadbeef`;
-		expect(verifyAccessTokenIdentity(bad, "gpt_token", "gpt-1", NOW + 1)).toBeNull();
-	});
-
-	test("missing token → null", () => {
-		expect(verifyAccessTokenIdentity(undefined, "gpt_token", "gpt-1", NOW)).toBeNull();
-	});
-});

package/src/content-gate/token.ts

@@ -1,197 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- */
-
-import type { GateSegmentation } from "./config-types.ts";
-import { resolveDbUrlOrNull } from "@teamscala/db/db-url";
-
-function secret(): string | null {
-	// The last resort is the tenant DB address, read through the named-need
-	// resolver (wrong-database guard, 2026-09-27) — never `process.env` here;
-	// the resolver is the only env-aware surface and it names the plane. It is
-	// used only as a stable per-deployment string (≥16 chars), never as a
-	// connection target.
-	for (const s of [
-		process.env.AUTH_SECRET,
-		process.env.ENCRYPTION_KEY,
-		resolveDbUrlOrNull("tenant"),
-	]) {
-		if (s && s.length >= 16) return s;
-	}
-	return null;
-}
-
-function hmac(payloadB64: string, key: string): string {
-	return new Bun.CryptoHasher("sha256", key).update(payloadB64).digest("base64url");
-}
-
-/** Constant-time string compare (equal-length); avoids node:crypto. */
-function safeEqual(a: string, b: string): boolean {
-	if (a.length !== b.length) return false;
-	let diff = 0;
-	for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
-	return diff === 0;
-}
-
-/** Mint a token proving `email` is authorized for `resourceId` under `cookieName`. */
-export function signAccessToken(
-	cookieName: string,
-	resourceId: string,
-	email: string,
-	nowMs: number,
-	ttlMs: number,
-	/**
-	 * Optional display name to carry in the token (the public GPT lead-capture
-	 * gate uses this so a returning visitor's name is known at SSR — first paint
-	 * renders the full identity, not just the email). Allow-list gates
-	 * (proposals/agreements) omit it.
-	 */
-	name?: string,
-	/**
-	 * Optional captured phone, same reasoning as `name`. It exists so a capture
-	 * gate needs NO browser storage to remember it: the operator's ruling is
-	 * that identity lives in the database and the request, never in
-	 * localStorage.
-	 */
-	phone?: string,
-	/**
-	 * Optional prospect segmentation captured alongside the identity on the
-	 * quiz's composed gate screen (company / LinkedIn / website / team size).
-	 * Same reasoning as name/phone: it rides the signed request, never client
-	 * storage. OPTIONAL and absent from older tokens — a token without it
-	 * verifies exactly as before.
-	 */
-	segmentation?: GateSegmentation,
-): string | null {
-	const key = secret();
-	if (!key) return null;
-	const payload: {
-		c: string;
-		r: string;
-		e: string;
-		x: number;
-		n?: string;
-		p?: string;
-		s?: GateSegmentation;
-	} = {
-		c: cookieName,
-		r: resourceId,
-		e: email.trim().toLowerCase(),
-		x: nowMs + ttlMs,
-	};
-	const trimmedName = name?.trim();
-	if (trimmedName) payload.n = trimmedName;
-	const trimmedPhone = phone?.trim();
-	if (trimmedPhone) payload.p = trimmedPhone;
-	const seg: GateSegmentation = {};
-	const segCompany = segmentation?.company?.trim();
-	if (segCompany) seg.company = segCompany;
-	const segLinkedin = segmentation?.linkedinUrl?.trim();
-	if (segLinkedin) seg.linkedinUrl = segLinkedin;
-	const segWebsite = segmentation?.website?.trim();
-	if (segWebsite) seg.website = segWebsite;
-	const segTeamSize = segmentation?.teamSize?.trim();
-	if (segTeamSize) seg.teamSize = segTeamSize;
-	if (Object.keys(seg).length > 0) payload.s = seg;
-	const payloadB64 = Buffer.from(JSON.stringify(payload)).toString("base64url");
-	return `${payloadB64}.${hmac(payloadB64, key)}`;
-}
-
-/**
- * Validate a token for `cookieName` + `resourceId`. Returns the verified email
- * on success, null otherwise (bad signature, wrong gate, wrong resource,
- * expired, no secret).
- */
-export function verifyAccessToken(
-	token: string | undefined | null,
-	cookieName: string,
-	resourceId: string,
-	nowMs: number,
-): string | null {
-	if (!token) return null;
-	const key = secret();
-	if (!key) return null;
-	const dot = token.indexOf(".");
-	if (dot <= 0) return null;
-	const payloadB64 = token.slice(0, dot);
-	const sig = token.slice(dot + 1);
-	if (!safeEqual(sig, hmac(payloadB64, key))) return null;
-	try {
-		const p = JSON.parse(Buffer.from(payloadB64, "base64url").toString()) as {
-			c?: string;
-			r?: string;
-			e?: string;
-			x?: number;
-		};
-		if (p.c !== cookieName) return null;
-		if (p.r !== resourceId) return null;
-		if (typeof p.x !== "number" || p.x < nowMs) return null;
-		return typeof p.e === "string" ? p.e : null;
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Like `verifyAccessToken` but returns the full verified identity
- * ({email, name, phone, segmentation}) so a gate that carries a display name in
- * the token (the public GPT lead-capture gate) can seed the visitor's name — not
- * just the email — at SSR, and the quiz gate can seed the captured prospect
- * segmentation the same way. Same signature/expiry/gate-binding checks; null on
- * any failure. A token minted BEFORE segmentation existed carries no `s` key and
- * verifies identically (segmentation comes back undefined) — never an error.
- */
-export function verifyAccessTokenIdentity(
-	token: string | undefined | null,
-	cookieName: string,
-	resourceId: string,
-	nowMs: number,
-): {
-	email: string;
-	name?: string;
-	phone?: string;
-	segmentation?: GateSegmentation;
-} | null {
-	if (!token) return null;
-	const key = secret();
-	if (!key) return null;
-	const dot = token.indexOf(".");
-	if (dot <= 0) return null;
-	const payloadB64 = token.slice(0, dot);
-	const sig = token.slice(dot + 1);
-	if (!safeEqual(sig, hmac(payloadB64, key))) return null;
-	try {
-		const p = JSON.parse(Buffer.from(payloadB64, "base64url").toString()) as {
-			c?: string;
-			r?: string;
-			e?: string;
-			x?: number;
-			n?: string;
-			p?: string;
-			s?: GateSegmentation;
-		};
-		if (p.c !== cookieName) return null;
-		if (p.r !== resourceId) return null;
-		if (typeof p.x !== "number" || p.x < nowMs) return null;
-		if (typeof p.e !== "string") return null;
-		const segmentation =
-			p.s && typeof p.s === "object"
-				? {
-						company: typeof p.s.company === "string" ? p.s.company : undefined,
-						linkedinUrl:
-							typeof p.s.linkedinUrl === "string" ? p.s.linkedinUrl : undefined,
-						website: typeof p.s.website === "string" ? p.s.website : undefined,
-						teamSize: typeof p.s.teamSize === "string" ? p.s.teamSize : undefined,
-					}
-				: undefined;
-		return {
-			email: p.e,
-			name: typeof p.n === "string" ? p.n : undefined,
-			phone: typeof p.p === "string" ? p.p : undefined,
-			segmentation,
-		};
-	} catch {
-		return null;
-	}
-}

package/src/is-react-element-type.test.ts

@@ -1,45 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// carries them verbatim, this file is the emission, and hand edits here are
-// overwritten on the next run. The rationale each assertion carries moved
-// with it into the band.
-
-import { expect, test } from "bun:test";
-import { forwardRef, lazy, memo } from "react";
-import { isReactElementType } from "./is-react-element-type.ts";
-
-function Plain() {
-	return null;
-}
-
-test("accepts a plain function component", () => {
-	expect(isReactElementType(Plain)).toBe(true);
-});
-
-test("accepts memo() — the PresenceAvatars shape that rendered blank", () => {
-	expect(isReactElementType(memo(Plain))).toBe(true);
-});
-
-test("accepts forwardRef()", () => {
-	expect(isReactElementType(forwardRef(() => null))).toBe(true);
-});
-
-test("accepts lazy()", () => {
-	expect(isReactElementType(lazy(async () => ({ default: Plain })))).toBe(true);
-});
-
-test("still rejects what genuinely cannot render", () => {
-	expect(isReactElementType(undefined)).toBe(false);
-	expect(isReactElementType(null)).toBe(false);
-	expect(isReactElementType({})).toBe(false);
-	expect(isReactElementType("PresenceAvatarsBlock")).toBe(false);
-	expect(isReactElementType(42)).toBe(false);
-});
-
-test("rejects a plain object wearing a non-symbol $$typeof", () => {
-	// A data blob with the key but not the symbol must not pass as renderable.
-	expect(isReactElementType({ $$typeof: "react.memo" })).toBe(false);
-});

package/src/is-react-element-type.ts

@@ -1,10 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- */
-
-export function isReactElementType(value: unknown): boolean {
-	if (typeof value === "function") return true;
-	if (typeof value !== "object" || value === null) return false;
-	return typeof (value as { $$typeof?: unknown }).$$typeof === "symbol";
-}

package/src/page-server-orpc/hub-mcp-client.ts

@@ -1,14 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- */
-
-let _hubMcpClient: unknown | null = null;
-
-export function setHubMcpClient(client: unknown): void {
-	_hubMcpClient = client;
-}
-
-export function getHubMcpClient(): unknown | undefined {
-	return _hubMcpClient ?? undefined;
-}

package/src/pg-boss-mount.test.ts

@@ -1,101 +0,0 @@
-/**
- * @system server-boot
- * @status handwritten
- * @edit edit directly
- *
- * The mount's poll-only contract: pg-boss v12 dispatches by polling, so the
- * mount dials the INJECTED transaction-pooler URL unchanged (no endpoint
- * derivation of its own — the session-port mapping died with the door,
- * 2026-09-14) and constructs with useListenNotify false spelled explicitly
- * rather than inherited from the supplier default, so a pg-boss bump cannot
- * silently re-introduce a LISTEN dependency. The mock captures the opts
- * PgBoss is constructed with — the claim is about what the mount DIALS and
- * how it dispatches, so the assertions are on the captured opts.
- */
-
-import { afterEach, describe, expect, it, mock } from "bun:test";
-
-interface CapturedOpts {
-	connectionString?: string;
-	max?: number;
-	useListenNotify?: boolean;
-}
-
-const POOLED_URL =
-	"postgresql://scala_container_gbg.gbg:s3cret@10.205.50.1:6543/scala_container_gbg?sslmode=require";
-
-function seedScheduledJob() {
-	return {
-		id: "test-job-1",
-		type: "scheduled_job",
-		slug: "scheduled_job:test-sync",
-		label: "Test Sync Job",
-		description: null,
-		config: {
-			handler_slug: "@teamscala/sync-worker:processSyncQueue",
-			cron: "*/5 * * * *",
-			queue_name: "sync-worker",
-		},
-		is_active: true,
-		sort_order: 0,
-		created_at: new Date(),
-		updated_at: new Date(),
-		noun: "scheduled_job",
-		kind: "scheduled_job",
-	};
-}
-
-describe("mountPgBoss poll-only contract", () => {
-	afterEach(() => {
-		mock.restore();
-	});
-
-	it("dials the injected transaction pooler unchanged and dispatches poll-only", async () => {
-		let captured: CapturedOpts | null = null;
-
-		mock.module("pg-boss", () => ({
-			PgBoss: mock((opts: CapturedOpts) => {
-				captured = opts;
-				return {
-					start: mock(() => Promise.resolve()),
-					stop: mock(() => Promise.resolve()),
-					on: mock(() => undefined),
-					createQueue: mock(() => Promise.resolve()),
-					work: mock(() => Promise.resolve("worker-id")),
-					schedule: mock(() => Promise.resolve()),
-					getSchedules: mock(() => Promise.resolve([])),
-					unschedule: mock(() => Promise.resolve()),
-				};
-			}),
-		}));
-		mock.module("@teamscala/db/registry/accessors", () => ({
-			getAllEntries: () => [seedScheduledJob()],
-		}));
-		mock.module("@teamscala/event-log/record-event", () => ({
-			recordEvent: () => undefined,
-		}));
-
-		const { mountPgBoss } = await import("./pg-boss-mount.ts");
-		await mountPgBoss({
-			databaseUrl: POOLED_URL,
-			serviceSlug: "scala-sync-worker",
-			packages: ["@teamscala/sync-worker"],
-		});
-
-		const capturedOpts = captured as unknown as CapturedOpts | undefined;
-		const connectionString = capturedOpts?.connectionString ?? "";
-		// The transaction pooler, exactly as injected — the mount adds no
-		// endpoint derivation.
-		expect(connectionString).toContain(":6543");
-		// NEVER the session port: the door is closing, not widening.
-		expect(connectionString).not.toContain(":5999");
-		// The tenant suffix the pooler routes by is kept.
-		expect(connectionString).toContain("scala_container_gbg.gbg:");
-		// The pg sslmode dialect rewrite still applies.
-		expect(connectionString).toContain("sslmode=no-verify");
-		// Poll-only, spelled: no LISTEN dependency, now and after a bump.
-		expect(capturedOpts?.useListenNotify).toBe(false);
-		// pg-boss stays a single sibling connection (pool sizing doctrine).
-		expect(capturedOpts?.max).toBe(1);
-	});
-});