@politty/zod 0.0.0

package/dist/augment.d.ts

@@ -0,0 +1,15 @@
+import { n as ArgMeta } from "./arg-registry-YaWTVu_x.js";
+//#region src/augment.d.ts
+declare module "zod" {
+  interface ZodTypeDef {
+    argMeta?: ArgMeta;
+  }
+  interface GlobalMeta {
+    description?: string;
+    positional?: boolean;
+    placeholder?: string;
+    alias?: string | string[] | readonly string[];
+    hiddenAlias?: string | string[] | readonly string[];
+    overrideBuiltinAlias?: boolean;
+  }
+}

package/dist/augment.js

@@ -0,0 +1 @@
+export {  };

package/dist/cli-main-Dn88vIyn.js

@@ -0,0 +1,84 @@
+import { n as generateCompileCacheShim, t as formatShimPath } from "./src-KzC0g5CS.js";
+import { a as internalField, i as internalArgs } from "./schema-extractor-DMSozq40.js";
+import { n as defineCommand } from "./command-k-4yAz4J.js";
+import { p as generateBundledCompletionWorker } from "./completion-gtWX3mwP.js";
+import { n as runMain } from "./runner-D72I7wvK.js";
+
+//#region ../core/src/cli-main.ts
+const generateWorkerCommand = defineCommand({
+	name: "generate-worker",
+	description: "Generate and verify a bundled shell completion worker",
+	args: internalArgs({
+		bin: internalField.string({
+			description: "CLI binary or built JS entry file to invoke",
+			placeholder: "PATH"
+		}),
+		program: internalField.string({
+			description: "Program name embedded in worker metadata",
+			placeholder: "NAME"
+		}),
+		shell: internalField.enum([
+			"bash",
+			"zsh",
+			"fish"
+		], {
+			description: "Shell worker to generate",
+			placeholder: "SHELL"
+		}),
+		out: internalField.optionalString({
+			description: "Output worker path (defaults to dist/completion/<shell>-worker.<ext>)",
+			placeholder: "PATH"
+		}),
+		verify: internalField.boolean({ description: "Verify __completion-worker-path resolves to the generated worker" })
+	}),
+	async run(args) {
+		await generateBundledCompletionWorker({
+			bin: args.bin,
+			programName: args.program,
+			shell: args.shell,
+			...args.out !== void 0 && { outputPath: args.out },
+			verify: args.verify
+		});
+	}
+});
+runMain(defineCommand({
+	name: "politty",
+	description: "politty development utilities",
+	subCommands: {
+		"generate-shim": defineCommand({
+			name: "generate-shim",
+			description: "Generate a compile-cache bin shim that loads the real CLI via dynamic import",
+			args: internalArgs({
+				entry: internalField.optionalStringArray({
+					description: "Module specifier the shim imports, relative to the shim file; repeatable, one per bin/--out (defaults to ./cli.js, ./cli.mjs, ./index.js, or ./index.mjs next to each shim)",
+					placeholder: "SPECIFIER"
+				}),
+				out: internalField.optionalStringArray({
+					description: "Output path for the generated shim; repeatable, one per --entry (defaults to the bin paths in package.json)",
+					placeholder: "PATH"
+				}),
+				program: internalField.optionalString({
+					description: "Program name for the cache directory, applied to all shims (defaults per shim to its bin name)",
+					placeholder: "NAME"
+				})
+			}),
+			run(args) {
+				const cwd = process.cwd();
+				const results = generateCompileCacheShim({
+					...args.entry !== void 0 && { entry: args.entry },
+					...args.out !== void 0 && { out: args.out },
+					...args.program !== void 0 && { program: args.program },
+					cwd
+				});
+				for (const result of results) console.log(`Generated compile-cache shim: ${formatShimPath(result.outputPath, cwd)} (program: ${result.program}, entry: ${result.entry})`);
+			}
+		}),
+		"generate-worker": generateWorkerCommand
+	}
+})).catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exit(1);
+});
+
+//#endregion
+export {  };

package/dist/cli-run-eibUcgys.js

@@ -0,0 +1,7 @@
+import "./register-Bk0K83W2.js";
+
+//#region src/cli-run.ts
+await import("./cli-main-Dn88vIyn.js");
+
+//#endregion
+export {  };

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/cli.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { n as enableCompileCache } from "./compile-cache-Ct41pWGL.js";
+
+//#region src/cli.ts
+/**
+* Bin shim: enable the on-disk V8 compile cache before the real CLI graph
+* is compiled, so warm starts skip recompilation (Node >= 22.8.0; no-op
+* otherwise). The actual CLI lives in `cli-run.ts` and is loaded via
+* dynamic import — ESM static imports are compiled during the link phase,
+* before any code runs, so they could never hit a cache enabled here.
+*/
+enableCompileCache("politty");
+await import("./cli-run-eibUcgys.js");
+
+//#endregion
+export {  };

package/dist/command-k-4yAz4J.js

@@ -0,0 +1,42 @@
+//#region ../core/src/core/command.ts
+function defineCommand(config) {
+	return {
+		name: config.name,
+		description: config.description,
+		aliases: config.aliases,
+		args: config.args,
+		subCommands: config.subCommands,
+		setup: config.setup,
+		run: config.run,
+		cleanup: config.cleanup,
+		notes: config.notes,
+		examples: config.examples
+	};
+}
+/**
+* Create a typed defineCommand factory with pre-bound global args type.
+* This is the recommended pattern for type-safe global options.
+*
+* @example
+* ```ts
+* // global-args.ts
+* type GlobalArgsType = { verbose: boolean; config?: string };
+* export const defineAppCommand = createDefineCommand<GlobalArgsType>();
+*
+* // commands/build.ts
+* export const buildCommand = defineAppCommand({
+*   name: "build",
+*   args: z.object({ output: arg(z.string().default("dist")) }),
+*   run: (args) => {
+*     args.verbose; // typed via GlobalArgsType
+*     args.output;  // typed via local args
+*   },
+* });
+* ```
+*/
+function createDefineCommand() {
+	return defineCommand;
+}
+
+//#endregion
+export { defineCommand as n, createDefineCommand as t };

package/dist/compile-cache-Ct41pWGL.js

@@ -0,0 +1,100 @@
+import * as nodeModule from "node:module";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+//#region ../core/src/compile-cache.ts
+/**
+* Node.js on-disk compile cache (V8 code cache) helpers.
+*
+* `node:module`'s `enableCompileCache` (Node.js >= 22.8.0) persists compiled
+* bytecode to disk so warm starts skip recompilation. Because ESM static
+* import graphs are compiled during the link phase — before any user code
+* runs — enabling the cache inside `runMain` only covers modules imported
+* *after* the call (e.g. `lazy()` subcommands). To cover the whole CLI,
+* enable it from a minimal bin shim that dynamically imports the real entry:
+*
+* ```ts
+* #!/usr/bin/env node
+* import { enableCompileCache } from "politty/compile-cache";
+*
+* enableCompileCache("my-cli");
+* await import("./cli.js");
+* ```
+*
+* This module must stay dependency-free (node builtins only) so the shim's
+* static graph — the part that can never be cached — stays tiny.
+*/
+/**
+* Reduce a program name to a single safe path segment. Path separators and
+* a leading scope marker are collapsed (`@scope/cli` → `scope-cli`) so the
+* name cannot escape the cache root; names that reduce to nothing (or to
+* `.`/`..`) yield `undefined`. Realistic command names pass through
+* unchanged.
+*/
+function sanitizeProgramName(programName) {
+	const safe = programName.replace(/^@/, "").replace(/[/\\]+/g, "-").trim();
+	if (!safe || /^[.-]+$/.test(safe)) return void 0;
+	return safe;
+}
+/**
+* Compute the cache directory for a program following the same XDG
+* convention as the shell-completion dispatcher scripts
+* (`src/completion/dispatcher.ts`), so direct CLI runs and completion
+* workers share one warm cache:
+* `${XDG_CACHE_HOME:-$HOME/.cache}/<sanitized programName>/node-compile-cache`.
+* The program name is first reduced to a single safe path segment by
+* {@link sanitizeProgramName} (e.g. `@scope/cli` → `scope-cli`). The
+* dispatcher scripts use the raw name, but a completion program name is a
+* single shell word resolved on PATH and can never contain separators, so
+* for every name that can actually reach both sides the two paths coincide.
+*
+* Returns `undefined` when no home directory can be resolved or the program
+* name does not reduce to a safe path segment; callers fall back to Node's
+* default location (`NODE_COMPILE_CACHE` or the OS tmpdir).
+*/
+function compileCacheDir(programName) {
+	const safeName = sanitizeProgramName(programName);
+	if (safeName === void 0) return void 0;
+	const xdg = process.env.XDG_CACHE_HOME;
+	if (xdg) return join(xdg, safeName, "node-compile-cache");
+	try {
+		const home = homedir();
+		if (!home) return void 0;
+		return join(home, ".cache", safeName, "node-compile-cache");
+	} catch {
+		return;
+	}
+}
+/**
+* Enable the Node.js on-disk compile cache for this process.
+*
+* - No-ops (returns `{ enabled: false }`) on runtimes without
+*   `module.enableCompileCache` (Node.js < 22.8.0) and never throws.
+* - When the `NODE_COMPILE_CACHE` environment variable is set it always
+*   wins, keeping runs spawned by completion scripts (which set the same
+*   variable) consistent with direct runs.
+* - Repeat calls are harmless: Node keeps the directory from the first
+*   successful call.
+*
+* @param options - Program name (string shorthand) or {@link CompileCacheOptions}.
+*/
+function enableCompileCache(options) {
+	const opts = typeof options === "string" ? { programName: options } : options ?? {};
+	try {
+		const enable = nodeModule.enableCompileCache;
+		if (typeof enable !== "function") return { enabled: false };
+		let dir;
+		if (!process.env.NODE_COMPILE_CACHE) dir = opts.cacheDir ?? (opts.programName !== void 0 ? compileCacheDir(opts.programName) : void 0);
+		const result = dir === void 0 ? enable() : enable(dir);
+		const status = nodeModule.constants?.compileCacheStatus;
+		return {
+			enabled: status !== void 0 ? result.status === status.ENABLED || result.status === status.ALREADY_ENABLED : result.status === 0 || result.status === 1,
+			...result.directory !== void 0 && { directory: result.directory }
+		};
+	} catch {
+		return { enabled: false };
+	}
+}
+
+//#endregion
+export { enableCompileCache as n, compileCacheDir as t };

package/dist/compile-cache.d.ts

@@ -0,0 +1,78 @@
+//#region ../core/src/compile-cache.d.ts
+/**
+ * Node.js on-disk compile cache (V8 code cache) helpers.
+ *
+ * `node:module`'s `enableCompileCache` (Node.js >= 22.8.0) persists compiled
+ * bytecode to disk so warm starts skip recompilation. Because ESM static
+ * import graphs are compiled during the link phase — before any user code
+ * runs — enabling the cache inside `runMain` only covers modules imported
+ * *after* the call (e.g. `lazy()` subcommands). To cover the whole CLI,
+ * enable it from a minimal bin shim that dynamically imports the real entry:
+ *
+ * ```ts
+ * #!/usr/bin/env node
+ * import { enableCompileCache } from "politty/compile-cache";
+ *
+ * enableCompileCache("my-cli");
+ * await import("./cli.js");
+ * ```
+ *
+ * This module must stay dependency-free (node builtins only) so the shim's
+ * static graph — the part that can never be cached — stays tiny.
+ */
+/**
+ * Options for {@link enableCompileCache}.
+ */
+interface CompileCacheOptions {
+  /**
+   * Program name used to derive the default cache directory
+   * (`${XDG_CACHE_HOME:-$HOME/.cache}/<sanitized programName>/node-compile-cache`
+   * — see {@link compileCacheDir} for how the name is sanitized).
+   * Ignored when `cacheDir` is set.
+   */
+  programName?: string;
+  /** Explicit cache directory (takes precedence over `programName`). */
+  cacheDir?: string;
+}
+/**
+ * Result of {@link enableCompileCache}.
+ */
+interface CompileCacheResult {
+  /** Whether the compile cache is active for this process. */
+  enabled: boolean;
+  /** Directory the cache is (or was already) persisted to, when known. */
+  directory?: string;
+}
+/**
+ * Compute the cache directory for a program following the same XDG
+ * convention as the shell-completion dispatcher scripts
+ * (`src/completion/dispatcher.ts`), so direct CLI runs and completion
+ * workers share one warm cache:
+ * `${XDG_CACHE_HOME:-$HOME/.cache}/<sanitized programName>/node-compile-cache`.
+ * The program name is first reduced to a single safe path segment by
+ * {@link sanitizeProgramName} (e.g. `@scope/cli` → `scope-cli`). The
+ * dispatcher scripts use the raw name, but a completion program name is a
+ * single shell word resolved on PATH and can never contain separators, so
+ * for every name that can actually reach both sides the two paths coincide.
+ *
+ * Returns `undefined` when no home directory can be resolved or the program
+ * name does not reduce to a safe path segment; callers fall back to Node's
+ * default location (`NODE_COMPILE_CACHE` or the OS tmpdir).
+ */
+declare function compileCacheDir(programName: string): string | undefined;
+/**
+ * Enable the Node.js on-disk compile cache for this process.
+ *
+ * - No-ops (returns `{ enabled: false }`) on runtimes without
+ *   `module.enableCompileCache` (Node.js < 22.8.0) and never throws.
+ * - When the `NODE_COMPILE_CACHE` environment variable is set it always
+ *   wins, keeping runs spawned by completion scripts (which set the same
+ *   variable) consistent with direct runs.
+ * - Repeat calls are harmless: Node keeps the directory from the first
+ *   successful call.
+ *
+ * @param options - Program name (string shorthand) or {@link CompileCacheOptions}.
+ */
+declare function enableCompileCache(options?: string | CompileCacheOptions): CompileCacheResult;
+//#endregion
+export { CompileCacheOptions, CompileCacheResult, compileCacheDir, enableCompileCache };

package/dist/compile-cache.js

@@ -0,0 +1,3 @@
+import { n as enableCompileCache, t as compileCacheDir } from "./compile-cache-Ct41pWGL.js";
+
+export { compileCacheDir, enableCompileCache };