void 0.26.1 → 0.28.0

package/dist/{github-cmd-D_FsOFxq.mjs → github-cmd-BdkU4Nhe.mjs}

@@ -1,9 +1,9 @@
-import { r as readProjectConfig } from "./project-DQstYTxO.mjs";
-import { c as getToken, n as createCodeChallenge, r as createCodeVerifier, t as awaitBrowserCallback, u as openBrowser } from "./auth-B5_tZLxT.mjs";
+import { r as readProjectConfig } from "./project-rqDnVsJN.mjs";
+import { c as getToken, n as createCodeChallenge, r as createCodeVerifier, t as awaitBrowserCallback, u as openBrowser } from "./auth-B6iOCjKI.mjs";
 import { A as confirm, K as select, L as log, O as cancel, X as text, tt as isCancel } from "./dist-D3m88sjf.mjs";
-import { d as printSuccess, l as import_picocolors } from "./output-C50ag2r3.mjs";
-import { c as parsePlatformErrorBody, l as platformErrorMessage, n as PlatformApiError, r as PlatformClient } from "./client-C2Prx_Bi.mjs";
-import { i as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-CP8rZs_p.mjs";
+import { f as import_picocolors, l as formatUrl, m as printSuccess } from "./output-FNHKw5Ac.mjs";
+import { c as platformErrorMessage, n as PlatformApiError, r as PlatformClient, s as parsePlatformErrorBody } from "./client-DM9Kcf4e.mjs";
+import { a as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-C_Cu7E8a.mjs";
 import { t as collectGitDeployMetadata } from "./git-metadata-D-gurjzG.mjs";
 import { randomBytes } from "node:crypto";
 //#region src/cli/github-cmd.ts
@@ -36,11 +36,8 @@ function describeConnectError(status, errorCode) {
 	return null;
 }
 /**
-* Like {@link describeConnectError}, but for `void github update`. The update
-* flow starts from an EXISTING connection, so a 404 "connection not found"
-* (the project has no GitHub connection, or it was disconnected between the
-* read and the write) is the common case and gets a "connect first" message.
-* Everything else defers to the shared connect mapping.
+* Like {@link describeConnectError}, but maps a 404 "connection not found" to a
+* "connect first" message.
 */
 function describeUpdateError(status, errorCode) {
 	const code = errorCode ?? "";
@@ -82,10 +79,8 @@ function formatInstallations(installations) {
 	}).join("\n\n");
 }
 /**
-* Render a GitHub connection as an aligned key/value block for `void github
-* status`. The workflow file is the OIDC deploy pin — it is only read for
-* github_actions builds (container builds never use it), so it is annotated as
-* unused when the executor is container to avoid implying it is active.
+* Render a GitHub connection for `void github status`. Container builds never
+* read the workflow file, so it is marked unused for them.
 */
 function formatConnection(connection) {
 	const row = (label, value) => `  ${label.padEnd(16)}${value}`;
@@ -116,15 +111,9 @@ async function runGithubCommand(root, args) {
 	}
 }
 /**
-* `void github install` — print the GitHub App install URL and open it.
-*
-* If the account has no linked GitHub identity, the server returns a 403 with
-* the stable code `github_identity_required`. Rather than telling the
-* user to `void account login` (which risks forking into a second account), we run
-* the link flow inline and retry the install URL exactly once.
-*
-* `linkIdentity` is injectable so tests can supply a fake linker instead of
-* starting a real localhost callback server / browser.
+* `void github install`. Without a linked GitHub identity the server returns a
+* 403 `github_identity_required`; link inline and retry once rather than send the
+* user to `void account login`, which risks creating a second account.
 */
 async function runInstall(client, linkIdentity = runGithubLink) {
 	let url;
@@ -145,18 +134,13 @@ async function runInstall(client, linkIdentity = runGithubLink) {
 			}
 		} else throw err;
 	}
-	log.message(`Open this URL to install the Void GitHub App:\n${import_picocolors.default.blue(url)}`);
-	const { execFile } = await import("node:child_process");
-	openBrowser(url, execFile);
+	log.message(`Open this URL to install the Void GitHub App:\n${import_picocolors.default.blue(formatUrl(url))}`);
+	openBrowser(url);
 	log.message("After installing, run `void github connect` to link a repository to your project.");
 }
 /**
-* Link the current Void account (the logged-in CLI token holder) to a GitHub
-* identity. Drives the platform's 3-endpoint link flow with a localhost +
-* PKCE handshake, mirroring `void account login`.
-*
-* The success path is non-exiting so a caller (`github install` after a 403
-* for a GitHub-less account) can continue; only error paths exit/throw.
+* Link the logged-in Void account to a GitHub identity. Returns on success so
+* `github install` can continue after linking.
 */
 async function runGithubLink(client) {
 	const verifier = createCodeVerifier();
@@ -173,7 +157,7 @@ async function runGithubLink(client) {
 				return url;
 			},
 			describeError: (p) => p.get("error") ? "GitHub authorization failed." : null,
-			onUrl: (url) => log.message(`Open this URL to link your GitHub account:\n${import_picocolors.default.blue(url)}`),
+			onUrl: (url) => log.message(`Open this URL to link your GitHub account:\n${import_picocolors.default.blue(formatUrl(url))}`),
 			finalize: async (params) => {
 				const linkCode = params.get("link_code");
 				if (!linkCode) throw new Error("github: link callback did not return a link code.");
@@ -195,12 +179,8 @@ async function runGithubLink(client) {
 	else printSuccess("GitHub account linked.");
 }
 /**
-* Browser round-trip (localhost + PKCE) that joins the caller to their
-* organization's shared GitHub App installations. Returns the number of
-* installations joined. Throws PlatformApiError — including the 503
-* `github_oauth_not_configured` — so callers own the user-facing handling
-* (`runGithubJoin` prints and exits; the connect auto-join fallback falls
-* through to its install-first error).
+* Join the caller to their organization's shared GitHub App installations and
+* return how many were joined. Errors are left to the caller.
 */
 async function performGithubJoin(client) {
 	const verifier = createCodeVerifier();
@@ -215,7 +195,7 @@ async function performGithubJoin(client) {
 			return url;
 		},
 		describeError: (p) => p.get("error") ? "GitHub authorization failed." : null,
-		onUrl: (url) => log.message(`Open this URL to join your organization's shared GitHub App installations:\n${import_picocolors.default.blue(url)}`),
+		onUrl: (url) => log.message(`Open this URL to join your organization's shared GitHub App installations:\n${import_picocolors.default.blue(formatUrl(url))}`),
 		finalize: async (params) => {
 			const joinCode = params.get("join_code");
 			if (!joinCode) throw new Error("github: join callback did not return a join code.");
@@ -250,20 +230,8 @@ async function runInstallations(client) {
 	log.message(formatInstallations(installations));
 }
 /**
-* Per-repo connect authorization round-trip for a non-owner org member.
-*
-* When the connect route returns 403 `connect_authorization_required`,
-* the member has no proof they can access the specific repo under the shared
-* installation. This drives the same localhost + PKCE handshake as
-* {@link runGithubLink}/{@link runGithubJoin}, but against the platform's
-* connect-authorize route: the callback mints and returns the grant IN
-* the redirect URL (`?connect_grant=…`), so there is no separate `/complete`
-* POST — `finalize` just reads the grant out of the callback query. A
-* `?error=repo_not_accessible` callback is mapped to a friendly per-repo message
-* by `describeError`, which rejects out of the handshake (no grant, no retry).
-*
-* Returns the grant plus the PKCE verifier the caller must echo to the connect
-* route so the platform can bind the grant to this exchange.
+* Per-repo authorization for an org member who cannot yet prove repo access.
+* The grant arrives in the callback URL; the caller sends it with the verifier.
 */
 async function runGithubConnectAuthorize(client, installationId, repoFullName) {
 	const verifier = createCodeVerifier();
@@ -282,7 +250,7 @@ async function runGithubConnectAuthorize(client, installationId, repoFullName) {
 			if (e === "repo_not_accessible") return `You don't have access to ${repoFullName} under this installation on GitHub.`;
 			return e ? "GitHub authorization failed." : null;
 		},
-		onUrl: (url) => log.message(`Open this URL to authorize access to ${repoFullName}:\n${import_picocolors.default.blue(url)}`),
+		onUrl: (url) => log.message(`Open this URL to authorize access to ${repoFullName}:\n${import_picocolors.default.blue(formatUrl(url))}`),
 		finalize: async (params) => {
 			const grant = params.get("connect_grant");
 			if (!grant) throw new Error("github: connect authorization did not return a grant.");
@@ -639,18 +607,12 @@ async function runGithubUpdate(root, client, args) {
 				log.error(`update: ${message}`);
 				process.exit(1);
 			}
-			throw err;
 		}
 		throw err;
 	}
 	printSuccess(`Updated ${updated.repo_full_name} → branch ${updated.branch}, executor ${updated.build_executor}, workflow ${updated.workflow_path}.`);
 }
-/**
-* `void github status [project]` — print the current GitHub connection (repo,
-* branch, build executor, deploy workflow). Read-only; never mutates. Project
-* resolution mirrors connect/update; a 404 means the project was never
-* connected and points the user at `connect`.
-*/
+/** `void github status [project]`: print the project's GitHub connection. */
 async function runStatus(root, client, args) {
 	const isTTY = process.stdin.isTTY === true;
 	const projectId = await resolveGithubProjectId(root, client, args.projectName, "status", isTTY);
@@ -670,12 +632,8 @@ async function runStatus(root, client, args) {
 	log.message(formatConnection(connection));
 }
 /**
-* `void github disconnect [project]` — remove a project's GitHub connection so
-* pushes no longer auto-deploy. The server (DELETE /projects/:id/github)
-* terminalizes any in-flight builds (revoking their deploy tokens) before
-* dropping the connection row. Destructive, so a TTY run confirms first; --yes
-* skips the prompt and is REQUIRED in a non-interactive shell. A project with no
-* connection is already in the goal state — report it and exit 0.
+* `void github disconnect [project]`. The server cancels in-flight builds before
+* it removes the connection, so a TTY run confirms first.
 */
 async function runGithubDisconnect(root, client, args) {
 	const isTTY = process.stdin.isTTY === true;
@@ -685,9 +643,7 @@ async function runGithubDisconnect(root, client, args) {
 		connection = await client.getGithubConnection(projectId);
 	} catch (err) {
 		if (err instanceof PlatformApiError) {
-			const body = parsePlatformErrorBody(err.body);
-			const code = body?.error ?? body?.message ?? "";
-			if (err.status === 404 && code.includes("connection not found")) {
+			if (err.status === 404 && err.code?.includes("connection not found")) {
 				log.info("This project is not connected to a GitHub repository. Nothing to disconnect.");
 				return;
 			}

package/dist/{handler-BHAn2fZJ.mjs → handler-BZ1t7-Rv.mjs}

@@ -1,3 +1,4 @@
+import { t as base64ToBytes } from "./base64-DVrOndmI.mjs";
 import { t as convertReturnValue } from "./response-Tn7rU0MV.mjs";
 import { t as runValidation } from "./validator-BTOu0fB0.mjs";
 //#region src/runtime/handler.ts
@@ -58,8 +59,7 @@ function parseBasicAuthHeader(authorization) {
 	if (!authorization?.toLowerCase().startsWith("basic ")) return null;
 	try {
 		const encoded = authorization.slice(6).trim();
-		const binary = atob(encoded);
-		const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+		const bytes = base64ToBytes(encoded);
 		const decoded = basicAuthDecoder.decode(bytes);
 		const separator = decoded.indexOf(":");
 		if (separator === -1) return null;

package/dist/{handler-CNAwjRcW.d.mts → handler-_PqY82xe.d.mts}

@@ -1,4 +1,4 @@
-import { l as VoidPlatformSandbox } from "./sandbox-C5LFoJMf.mjs";
+import { l as VoidPlatformSandbox } from "./sandbox-q3waMc2T.mjs";
 import { t as StandardSchemaV1 } from "./standard-schema-Fo_vCAZh.mjs";
 import { n as HeadDescriptor } from "./head-C8K_iGe6.mjs";
 import { r as AuthUser, t as AuthSession } from "./auth-DkcFflXV.mjs";

package/dist/{headers-DlfR78Nu.mjs → headers-Di1FsD3e.mjs}

@@ -1,5 +1,5 @@
-import { a as join } from "./dist-BVqXeR_h.mjs";
-import { a as convertFallbacksConfig, c as convertRewritesConfig, f as isProtocolRelative, l as countSplats, n as VALID_REDIRECT_STATUSES, o as convertHeadersConfig, p as parseHostPrefixedSource, s as convertRedirectsConfig } from "./config-DiowPT80.mjs";
+import { a as join } from "./dist-ipQi0Q8y.mjs";
+import { a as convertRewritesConfig, i as convertRedirectsConfig, l as isProtocolRelative, n as convertFallbacksConfig, o as countSplats, r as convertHeadersConfig, t as VALID_REDIRECT_STATUSES, u as parseHostPrefixedSource } from "./config-Bx_1SpnO.mjs";
 import { i as voidWarn } from "./log-vqY3pqwI.mjs";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/cli/headers.ts
@@ -49,23 +49,14 @@ function parseHeadersFile(dir) {
 	return rules;
 }
 /**
-* Parse a `_redirects` file.
+* Parse a `_redirects` file: `source destination [status]` per line (status
+* defaults to 302, `#` starts a comment). Keeps 3xx redirects and 200 rewrites.
 *
-* Format: `source destination [status]` per line (status defaults to 302).
-* Lines starting with # are comments. Includes 3xx redirects and 200 rewrites.
-*
-* Force suffix (`!`) semantics:
-*   - On status 200: toggles `force: true` (Netlify-compat). The plain form
-*     fires only when the static asset would 404; the force form fires
-*     unconditionally, overriding any matching static asset.
-*   - On 3xx (301/302/307/308): silently stripped. A redirect always changes
-*     the URL, so `!` is redundant. We count these in `redundantForceOn3xx`
-*     so the deploy command can surface a single aggregated lint warning
-*     rather than one per line — Netlify users pasting their `_redirects`
-*     file shouldn't be punished for harmless cruft.
+* A `!` suffix on 200 sets `force`, so the rewrite applies even when a static
+* asset matches. On a 3xx it is a no-op, stripped and counted in
+* `redundantForceOn3xx`.
 *
 * Returns `undefined` when the file doesn't exist or yields no valid rules.
-* Otherwise returns `{rules, redundantForceOn3xx}`.
 */
 function parseRedirectsFile(dir) {
 	const filePath = join(dir, "_redirects");
@@ -144,11 +135,8 @@ function parseRedirectsFile(dir) {
 	};
 }
 /**
-* Split parsed `_redirects` rules into "always-apply" and "asset-miss only"
-* buckets. Rules with `status: 200` and `force === false` are fallbacks — they
-* should only fire when the static asset resolver would 404. All other rules
-* (3xx redirects and forced `200!` rewrites) stay in the "always" bucket and
-* are merged with `routing.rewrites` / `routing.redirects` from void.json.
+* Split `_redirects` rules into rules that always apply and fallbacks: unforced
+* 200 rewrites, which apply only when no static asset matches.
 */
 function splitRedirectRulesByForce(rules) {
 	const always = [];
@@ -165,33 +153,8 @@ function splitRedirectRulesByForce(rules) {
 	};
 }
 /**
-* Merge file-based rules (`_redirects`, `_headers`) in `dir` with routing
-* rules from `void.json`. Shared between the deploy pipeline and the dev
-* plugin so both surfaces produce identical rule tables.
-*
-* Ordering for routing rules (redirects/rewrites/fallbacks): `void.json`
-* rules first, then `_redirects` file rules. Because the router evaluates
-* routing rules with first-match-wins semantics, `void.json` entries
-* override `_redirects` entries for the same source — matching the
-* documented precedence (`docs/guide/edge/rewrites.md`). This holds even
-* though `_redirects` is conceptually "closer to the build output".
-*
-* Header rules use the inverse order — `_redirects`/`_headers` last —
-* because header rules are last-match-wins (`_headers` is Netlify-style
-* last-wins). The asymmetry is intentional and matches dispatch.
-*
-* Phase split:
-*   - `_redirects` `200!` (force) + 3xx entries → `redirectRules` (always-fire)
-*   - `_redirects` plain `200`           entries → `fallbackRules` (asset-miss)
-*   - `routing.redirects` + `routing.rewrites`    → `redirectRules`
-*   - `routing.fallbacks`                         → `fallbackRules`
-*
-* Returns `fallbackRules === undefined` when empty, meaning "no post-asset
-* phase".
-*
-* Duplicate linting is NOT called here (callers decide which warning surface
-* to use — CLI vs. Vite logger). `redundantForceOn3xx` is returned raw for
-* the same reason.
+* Merge `_redirects` and `_headers` in `dir` with `routing` from void.config.ts.
+* Deploy and dev share it so both build the same rule tables; callers lint them.
 */
 function mergeRoutingRules(opts) {
 	const { dir, routing } = opts;
@@ -218,20 +181,18 @@ function mergeRoutingRules(opts) {
 	};
 }
 /**
-* Warn when a rule's `destination` contains a literal `*`. The platform's
-* `substituteParams` only replaces `:name` tokens (e.g. `:splat`, `:id`) —
-* bare `*` in destinations is a literal character, not a capture reference,
-* and will silently pass through to the rewritten/redirected URL.
-*
-* Users who write `/old/*` → `/new/*` almost always intended `:splat` to
-* reflect the captured portion of the source wildcard. Surface the mistake
-* with a single aggregated warning at the same surface as
-* `lintDuplicateSources` — per-phase, near the merge site — rather than
-* failing the deploy: a `*` in a destination is well-formed output, just
-* probably not what was meant.
-*
-* Only reported once per rule — the count of `*` in the destination is
-* irrelevant, a single occurrence is already suspicious.
+* Lint each phase on its own: only duplicates within a phase shadow each other,
+* so a redirect and a fallback with the same source are fine.
+*/
+function lintRoutingPhases(rules) {
+	lintDuplicateSources(rules.redirectRules, "redirects/rewrites (pre-asset)");
+	lintDuplicateSources(rules.fallbackRules, "fallbacks (post-asset)");
+	lintDestinationSplats(rules.redirectRules, "redirects/rewrites (pre-asset)");
+	lintDestinationSplats(rules.fallbackRules, "fallbacks (post-asset)");
+}
+/**
+* Warn about a literal `*` in a destination. Destinations substitute only
+* `:name` params such as `:splat`, so a `*` passes through unchanged.
 */
 function lintDestinationSplats(rules, phaseName) {
 	if (!rules || rules.length === 0) return;
@@ -241,24 +202,8 @@ function lintDestinationSplats(rules, phaseName) {
 	voidWarn(`destinations in ${phaseName} contain a literal "*" — splat tokens are not substituted in destinations; use ":splat" (or other named params) or rewrite the destination:\n${lines.join("\n")}`);
 }
 /**
-* Warn when the same `source` pattern appears more than once within a single
-* merged phase (pre-asset `redirectRules` or post-asset `fallbackRules`).
-*
-* Sources are scoped to the phase: a pattern appearing once in redirects and
-* once in fallbacks is *not* a collision, because those lists run in separate
-* phases and don't shadow each other. Within a single phase the dispatcher
-* uses first-match-wins semantics, so a duplicate silently hides the later
-* entry. This lint never fails the deploy; it surfaces the collision so the
-* user can decide whether to fix it.
-*
-* Only exact string duplicates are reported. Subset-shadow cases (e.g. `/*`
-* overshadowing `/docs`) are out of scope — pattern-aware analysis would be
-* both harder and noisier.
-*
-* Emits a single aggregated warning summarizing every duplicated source, each
-* annotated with the `origin` of every occurrence (e.g. `_redirects:12` vs
-* `void.json#routing.rewrites`). Aggregation avoids a wall of per-pair
-* warnings on configs with many collisions.
+* Warn when one phase repeats an exact `source`: first match wins, so the later
+* rule never applies. Phases run separately, so callers lint each one.
 */
 function lintDuplicateSources(rules, phaseName) {
 	if (!rules || rules.length < 2) return;
@@ -278,4 +223,4 @@ function lintDuplicateSources(rules, phaseName) {
 	voidWarn(`duplicate rule sources detected in ${phaseName} (first match wins — the earlier entry takes effect):\n${lines.join("\n")}`);
 }
 //#endregion
-export { parseRedirectsFile as i, lintDuplicateSources as n, mergeRoutingRules as r, lintDestinationSplats as t };
+export { mergeRoutingRules as n, parseRedirectsFile as r, lintRoutingPhases as t };

package/dist/{help-CVFBTmBx.mjs → help-Bug7pyK_.mjs}

@@ -1,9 +1,7 @@
-import { a as join } from "./dist-BVqXeR_h.mjs";
 import { H as outro } from "./dist-D3m88sjf.mjs";
-import { c as helpLine, l as import_picocolors, p as sectionTitle, t as categoryTitle, u as note } from "./output-C50ag2r3.mjs";
-import { n as getPackageDir } from "./agents-B_pX_HmQ.mjs";
-import { n as operatorGroups, t as operatorCommands } from "./operator-args-BNsW5gfp.mjs";
-import { readFileSync } from "node:fs";
+import { d as helpLine, f as import_picocolors, g as sectionTitle, l as formatUrl, p as note, t as categoryTitle } from "./output-FNHKw5Ac.mjs";
+import { n as getOwnVersion } from "./agents-CuNtT0D_.mjs";
+import { n as operatorGroups, t as operatorCommands } from "./operator-args-UnE8Y2eK.mjs";
 //#region src/cli/ascii.ts
 const asciiArts = [
 	`
@@ -80,9 +78,9 @@ function operatorHelpTree() {
 						command: `--${flag} <value>`,
 						description
 					})),
-					...(entry.booleans ?? []).map((flag) => ({
+					...Object.entries(entry.booleans ?? {}).map(([flag, description]) => ({
 						command: `--${flag}`,
-						description: flag === "follow" ? "Poll new logs until interrupted or the build ends" : flag === "ended" ? "Attest that the original provider execution has ended" : flag === "public-apps" ? "Manage public app rules without identity policies" : flag === "protect-new-projects" ? "Protect newly created projects by default" : flag === "check" && group === "zero-trust" ? "Also check the saved settings against Cloudflare Access (several API calls)" : flag === "token-stdin" && group === "zero-trust" ? "Read the Access management API token from stdin" : flag === "token-stdin" && group === "email" ? entry.action === "domain-remove" ? "Read a replacement Cloudflare token for blocked project cleanup from stdin" : "Read a scoped Cloudflare API token from stdin" : flag === "all" ? "Rotate every project" : "Read a full API session from stdin for explicit operator session exchange"
+						description
 					}))
 				]
 			}]))
@@ -1417,13 +1415,23 @@ const HELP_TREE = {
 			push: basicSubcommand("Push schema to local D1 without migration files.", "void db push"),
 			generate: basicSubcommand("Generate SQL migrations from schema changes.", "void db generate"),
 			status: basicSubcommand("Show migration status for local and remote DBs.", "void db status"),
-			reset: basicSubcommand("Reset local DB and re-run migrations.", "void db reset"),
+			reset: {
+				summary: "Reset local DB and re-run migrations.",
+				usage: ["void db reset [options]"],
+				options: [{
+					command: "--yes",
+					description: "Skip the prompt for a non-local PostgreSQL/MySQL database"
+				}]
+			},
 			seed: {
 				summary: "Reset local DB, run migrations, and seed data.",
 				usage: ["void db seed [options]"],
 				options: [{
 					command: "--file <path>",
 					description: "Seed from a specific file"
+				}, {
+					command: "--yes",
+					description: "Skip the prompt for a non-local PostgreSQL/MySQL database"
 				}]
 			},
 			execute: {
@@ -1756,10 +1764,10 @@ function printGlobalHelp() {
 		helpLine("void <command> --help", "Show command-specific help")
 	].join("\n"), sectionTitle("Commands"));
 	note([helpLine("VOID_TOKEN", "Auth token (or use `void account login`)"), helpLine("VOID_PROJECT", "Deploy target project name override")].join("\n"), sectionTitle("Environment"));
-	outro("https://void.cloud");
+	outro(formatUrl("https://void.cloud"));
 }
 function printVoidHeader() {
-	const version = JSON.parse(readFileSync(join(getPackageDir(), "package.json"), "utf-8")).version;
+	const version = getOwnVersion();
 	const art = asciiArts[Math.floor(Math.random() * asciiArts.length)];
 	console.log(import_picocolors.default.blue(`${art}  v${version}\n`));
 }

package/dist/help-s9q7LTcu.mjs

@@ -0,0 +1,2 @@
+import { r as printHelpPage } from "./help-Bug7pyK_.mjs";
+export { printHelpPage };