@politty/zod 0.1.2 → 0.2.1

package/dist/subcommand-router-D8GTMXYL.js

@@ -0,0 +1 @@
+const e=`__politty_lazy__`;function t(t){return typeof t==`object`&&!!t&&e in t&&t[e]===!0}function n(t,n){return{[e]:!0,meta:t,load:n}}function r(e){return t(e)?e.meta:typeof e==`function`?null:e}async function i(e){return t(e)?await e.load():typeof e==`function`?await e():e}async function a(e,t){if(!e.subCommands)return;let n=Object.hasOwn(e.subCommands,t)?e.subCommands[t]:void 0;if(n)return{command:await i(n),aliasFor:void 0};let r=o(e,t);if(r)return{command:await i(e.subCommands[r]),aliasFor:r}}function o(e,t){if(e.subCommands){for(let[n,i]of Object.entries(e.subCommands))if(r(i)?.aliases?.includes(t))return n}}function s(e){let t=new Set;if(!e.subCommands)return t;for(let[n,i]of Object.entries(e.subCommands)){t.add(n);let e=r(i);if(e?.aliases)for(let n of e.aliases)t.add(n)}return t}function c(e){return e.subCommands?Object.keys(e.subCommands):[]}export{a,r as c,o as i,c as n,t as o,i as r,n as s,s as t};

package/dist/{index-B4NylQOW.d.ts → with-completion-command-CmVdHFHX.d.ts}

@@ -1,4 +1,4 @@
-import { C as Command, Q as UnknownKeysMode, b as ArgsSchema, f as ResolvedExpandCandidate, g as DynamicCompletionResolver, n as ArgMeta, v as AnyCommand } from "./arg-registry-Be4GJADw.js";
+import { Q as UnknownKeysMode, b as ArgsSchema, f as ResolvedExpandCandidate, g as DynamicCompletionResolver, n as ArgMeta, v as AnyCommand } from "./arg-registry-BzQ-y-e0.js";
 //#region ../core/src/adapter/internal-args.d.ts
 /** Runtime brand distinguishing internal descriptors from library schemas. */
 declare const INTERNAL_ARGS_BRAND = "__polittyInternalArgs";
@@ -338,78 +338,7 @@ declare function defaultBundledWorkerOutputPath(shell: ShellType): string;
 declare function validateBundledWorkerFile(path: string, programName: string, shell: ShellType): void;
 declare function generateBundledCompletionWorker(options: GenerateBundledCompletionWorkerOptions): Promise<GenerateBundledCompletionWorkerResult>;
 //#endregion
-//#region ../core/src/completion/index.d.ts
-/**
- * Generate completion script for the specified shell
- */
-declare function generateCompletion(command: AnyCommand, options: CompletionOptions): CompletionResult;
-/**
- * Get the list of supported shells
- */
-declare function getSupportedShells(): ShellType[];
-/**
- * Detect the current shell from environment
- */
-declare function detectShell(): ShellType | null;
-/**
- * Schema for the completion command arguments
- */
-declare const completionArgsSchema: InternalArgsSchema<{
-  shell: "bash" | "fish" | "zsh" | undefined;
-  instructions: boolean;
-  loader: boolean;
-  install: boolean;
-  static: boolean;
-  dispatcher: boolean;
-  worker: boolean;
-}>;
-type CompletionArgs = InferInternalArgs<typeof completionArgsSchema>;
-declare const refreshArgsSchema: InternalArgsSchema<{
-  shell: "bash" | "fish" | "zsh";
-  target: string | undefined;
-  static: boolean;
-  worker: boolean;
-}>;
-type RefreshArgs = InferInternalArgs<typeof refreshArgsSchema>;
-declare const workerPathArgsSchema: InternalArgsSchema<{
-  shell: "bash" | "fish" | "zsh";
-}>;
-type WorkerPathArgs = InferInternalArgs<typeof workerPathArgsSchema>;
-/**
- * Create a completion subcommand for your CLI
- *
- * This creates a ready-to-use subcommand that generates completion scripts.
- *
- * @example
- * ```typescript
- * const mainCommand = defineCommand({
- *   name: "mycli",
- *   subCommands: {
- *     completion: createCompletionCommand(mainCommand)
- *   }
- * });
- * ```
- */
-declare function createCompletionCommand(rootCommand: AnyCommand, programName?: string, globalArgsSchema?: ArgsSchema, extra?: {
-  cacheDir?: string;
-  programVersion?: string;
-  bundledWorker?: BundledWorkerOptions;
-}): Command<typeof completionArgsSchema, CompletionArgs, any>;
-/**
- * Hidden subcommand that the runMain background hook spawns. It does
- * the same stat-compare + atomic rewrite as the rc loader, but in a
- * detached child process so it's invisible to the user.
- */
-declare function createRefreshCompletionCommand(rootCommand: AnyCommand, programName: string, extra?: {
-  cacheDir?: string;
-  programVersion?: string;
-  globalArgsSchema?: ArgsSchema;
-  bundledWorker?: BundledWorkerOptions;
-}): Command<typeof refreshArgsSchema, RefreshArgs, any>;
-declare function createCompletionWorkerPathCommand(programName: string, extra?: {
-  binPath?: string;
-  bundledWorker?: BundledWorkerOptions;
-}): Command<typeof workerPathArgsSchema, WorkerPathArgs, any>;
+//#region ../core/src/completion/with-completion-command.d.ts
 /**
  * Options for withCompletionCommand
  */
@@ -452,4 +381,4 @@ interface WithCompletionOptions {
  */
 declare function withCompletionCommand<T extends AnyCommand>(command: T, options?: string | WithCompletionOptions): T;
 //#endregion
-export { CompletionResult as C, InternalArgsSchema as D, InferInternalArgs as E, CompletionOptions as S, ValueCompletion as T, CompletablePositional as _, detectShell as a, CompletionGenerator as b, withCompletionCommand as c, bundledWorkerShellExtension as d, defaultBundledWorkerOutputPath as f, CompletableOption as g, BundledWorkerOptions as h, createRefreshCompletionCommand as i, GenerateBundledCompletionWorkerOptions as l, validateBundledWorkerFile as m, createCompletionCommand as n, generateCompletion as o, generateBundledCompletionWorker as p, createCompletionWorkerPathCommand as r, getSupportedShells as s, WithCompletionOptions as t, GenerateBundledCompletionWorkerResult as u, CompletableSubcommand as v, ShellType as w, CompletionMode as x, CompletionData as y };
+export { CompletionResult as _, bundledWorkerShellExtension as a, InferInternalArgs as b, validateBundledWorkerFile as c, CompletablePositional as d, CompletableSubcommand as f, CompletionOptions as g, CompletionMode as h, GenerateBundledCompletionWorkerResult as i, BundledWorkerOptions as l, CompletionGenerator as m, withCompletionCommand as n, defaultBundledWorkerOutputPath as o, CompletionData as p, GenerateBundledCompletionWorkerOptions as r, generateBundledCompletionWorker as s, WithCompletionOptions as t, CompletableOption as u, ShellType as v, InternalArgsSchema as x, ValueCompletion as y };

package/dist/with-completion-command-DDohm8U6.js

@@ -0,0 +1,3 @@
+import{a as e,i as t}from"./schema-extractor-DU0Vuhbd.js";import{n}from"./command-Mbdt0bmN.js";import{s as r}from"./subcommand-router-D8GTMXYL.js";import{t as i}from"./schema-BiUP_KyV.js";import{existsSync as a,readFileSync as o}from"node:fs";import{join as s}from"node:path";import{spawn as c}from"node:child_process";function l(){let e=(process.env.SHELL||``).split(`/`).pop()?.toLowerCase()||``;return e.includes(`bash`)?`bash`:e.includes(`zsh`)?`zsh`:e.includes(`fish`)?`fish`:null}function u(e){return`${process.env.XDG_CACHE_HOME??`${process.env.HOME??``}/.cache`}/${e}`}function d(e,t,n){if(t===`fish`){let t=process.env.XDG_CONFIG_HOME??`${process.env.HOME??``}/.config`;return s(t,`fish`,`completions`,`${e}.fish`)}let r=n??u(e);return s(r,`completion.${t}`)}function f(e){try{if(!a(e))return null;let t=o(e,`utf8`).split(`
+`,6).join(`
+`).match(/^# politty-bin-sig: (\S+)/m);return t?t[1]:null}catch{return null}}function p(e,t){return f(d(e.programName,t,e.cacheDir))!==null}function m(e,t){try{c(process.execPath,[e,`__refresh-completion`,t],{detached:!0,stdio:`ignore`}).unref()}catch{}}const h=t({shell:e.optionalEnum([`bash`,`zsh`,`fish`],{positional:!0,description:`Shell type (bash, zsh, or fish)`,placeholder:`SHELL`}),instructions:e.boolean({alias:`i`,description:`Show installation instructions`}),loader:e.boolean({description:`Print just the rc loader snippet (bash/zsh). Add it to ~/.bashrc or ~/.zshrc; it auto-regenerates the cache when the binary changes.`}),install:e.boolean({description:`Write the completion script to its on-disk cache (bash/zsh) or autoload location (fish) instead of printing it.`}),static:e.boolean({description:`Generate the legacy static completion script with command metadata baked in.`}),dispatcher:e.boolean({description:`Generate the runtime dispatcher completion script. This is the default.`}),worker:e.boolean({description:`Generate an internal static worker artifact for dispatcher mode.`})}),g=t({shell:e.enum([`bash`,`zsh`,`fish`],{positional:!0,description:`Shell to refresh`,placeholder:`SHELL`}),target:e.optionalString({positional:!0,description:`Existing politty-generated completion file to refresh`,placeholder:`TARGET`}),static:e.boolean({description:`Refresh using the legacy static completion script mode.`}),worker:e.boolean({description:`Refresh an internal static worker completion script.`})}),_=t({shell:e.enum([`bash`,`zsh`,`fish`],{positional:!0,description:`Shell worker to locate`,placeholder:`SHELL`})});function v(e,t){let{programName:a,globalArgsSchema:o,cacheDir:s,programVersion:c,bundledWorker:l}=typeof t==`string`?{programName:t}:t??{},u=a??e.name,d={...s!==void 0&&{cacheDir:s},...c!==void 0&&{programVersion:c},...o!==void 0&&{globalArgsSchema:o},...l!==void 0&&{bundledWorker:l}},f={...e};return f.subCommands={...e.subCommands,completion:r(n({name:`completion`,description:`Generate shell completion script`,args:h,run(){}}),()=>import(`./completion-DUMcvXkT.js`).then(e=>e.createCompletionCommand(f,a,o,d))),__complete:r(n({name:`__complete`,args:i,run(){}}),()=>import(`./dynamic-CMtee4tD.js`).then(e=>e.createDynamicCompleteCommand(f,a,o))),"__refresh-completion":r(n({name:`__refresh-completion`,description:`(internal) Refresh the on-disk completion cache if stale.`,args:g,run(){}}),()=>import(`./completion-DUMcvXkT.js`).then(e=>e.createRefreshCompletionCommand(f,u,d))),"__completion-worker-path":r(n({name:`__completion-worker-path`,description:`(internal) Print the bundled completion worker path when available.`,args:_,run(){}}),()=>import(`./completion-DUMcvXkT.js`).then(e=>e.createCompletionWorkerPathCommand(u,d)))},f.runMainHook=e=>{y(e,{programName:u,...s!==void 0&&{cacheDir:s}})},f}function y(e,t){if(process.env.POLITTY_NO_COMPLETION_REFRESH)return;let n=e.find(e=>!e.startsWith(`-`));if(n===`__complete`||n===`__refresh-completion`||n===`__completion-worker-path`||n===`completion`)return;let r=l();if(!r)return;let i=process.argv[1];i&&p(t,r)&&m(i,r)}export{d as a,_ as i,h as n,f as o,g as r,l as s,v as t};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@politty/zod",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "A lightweight CLI framework inspired by citty with zod v4 registry integration for type-safe metadata management",
   "keywords": [
     "argument-parser",
@@ -74,12 +74,12 @@
     "yaml": "^2.9.0"
   },
   "devDependencies": {
+    "@politty/core": "0.1.0",
     "@types/node": "25.9.5",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "tsdown": "0.22.14",
     "typescript": "7.0.2",
-    "zod": "4.4.3",
-    "@politty/core": "0.1.0"
+    "zod": "4.4.3"
   },
   "peerDependencies": {
     "@clack/prompts": "^0.10.0 || ^0.11.0 || ^1.0.0",

package/dist/cli-main-CAa5KwCo.js

@@ -1,314 +0,0 @@
-import { a as internalField, i as internalArgs } from "./schema-extractor-CVNDs07l.js";
-import { n as defineCommand } from "./command-k-4yAz4J.js";
-import { n as runMain } from "./runner-Bz3arOqh.js";
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-//#region ../core/src/compile-cache-shim.ts
-/**
-* Generator for compile-cache bin shims.
-*
-* Emits the minimal entry file described in docs/recipes.md ("Faster
-* Startup"): a shim that enables the Node.js on-disk compile cache and then
-* loads the real CLI with a dynamic import. Meant to be wired into a
-* `postbuild` or `prepack` script via `politty generate-shim` so the shim
-* never has to live in source.
-*
-* Each politty package binds its own generator with
-* {@link createCompileCacheShimGenerator}, so the shim imports the cache
-* helper from the package that generated it.
-*/
-/**
-* Marker identifying files this generator wrote (overwrite guard). Must be
-* shim-specific: other politty artifacts (e.g. completion scripts) also say
-* "Generated by politty", and those must never be treated as overwritable.
-*/
-const SHIM_MARKER = "Generated by politty: compile-cache bin shim";
-/** Entry candidates tried, in order, when `entry` is omitted. */
-const DEFAULT_ENTRY_CANDIDATES = [
-	"./cli.js",
-	"./cli.mjs",
-	"./index.js",
-	"./index.mjs"
-];
-/**
-* Read the nearest `package.json`, walking up from `startDir` to the
-* filesystem root. A malformed file is a real error and propagates.
-*/
-function readNearestPackageJson(startDir) {
-	let dir = resolve(startDir);
-	for (;;) {
-		const candidate = join(dir, "package.json");
-		if (existsSync(candidate)) return {
-			pkg: JSON.parse(readFileSync(candidate, "utf8")),
-			dir
-		};
-		const parent = dirname(dir);
-		if (parent === dir) return void 0;
-		dir = parent;
-	}
-}
-/**
-* `bin` entries as `[name, path]` pairs: the object form's entries in
-* declaration order, or the string form as a single pair named after the
-* package (npm's own convention for `"bin": "path"`).
-*/
-function binEntries(pkg) {
-	if (!pkg) return [];
-	if (typeof pkg.bin === "string" && pkg.bin) {
-		const name = defaultProgramName(pkg);
-		return name ? [[name, pkg.bin]] : [];
-	}
-	if (typeof pkg.bin === "object" && pkg.bin !== null) return Object.entries(pkg.bin).filter((pair) => typeof pair[1] === "string" && pair[1] !== "");
-	return [];
-}
-/**
-* Derive the fallback program name from a package.json: the first `bin`
-* command name when present (that is the name users type in their shell),
-* else the package name without its scope.
-*/
-function defaultProgramName(pkg) {
-	if (!pkg) return void 0;
-	if (typeof pkg.bin === "object" && pkg.bin !== null) {
-		const [first] = Object.keys(pkg.bin);
-		if (first) return first;
-	}
-	if (typeof pkg.name === "string" && pkg.name) {
-		const name = pkg.name;
-		return name.startsWith("@") ? name.split("/")[1] ?? name : name;
-	}
-}
-/**
-* Pick the default entry: the first {@link DEFAULT_ENTRY_CANDIDATES} that
-* exists next to the shim (never the shim itself).
-*/
-function defaultEntry(outputPath) {
-	const dir = dirname(outputPath);
-	const self = basename(outputPath);
-	for (const candidate of DEFAULT_ENTRY_CANDIDATES) {
-		if (basename(candidate) === self) continue;
-		if (existsSync(join(dir, candidate))) return candidate;
-	}
-}
-function shimContent(program, entry, compileCacheSpecifier) {
-	return [
-		"#!/usr/bin/env node",
-		"",
-		`// ${SHIM_MARKER}.`,
-		"// Enables the Node.js on-disk compile cache (V8 code cache) before the",
-		"// CLI module graph is compiled, so warm starts skip recompilation",
-		"// (Node >= 22.8.0; silent no-op otherwise).",
-		"try {",
-		`  const { enableCompileCache } = await import(${JSON.stringify(compileCacheSpecifier)});`,
-		`  enableCompileCache(${JSON.stringify(program)});`,
-		"} catch {",
-		`  // ${compileCacheSpecifier} is not resolvable from here (e.g. a fully`,
-		"  // bundled CLI) — start without the compile cache rather than failing",
-		"  // the CLI.",
-		"}",
-		`await import(${JSON.stringify(entry)});`,
-		""
-	].join("\n");
-}
-function toArray(value) {
-	if (value === void 0) return [];
-	return Array.isArray(value) ? value : [value];
-}
-/**
-* Build the shim generator for one politty package.
-*
-* `ownerPackage` is the npm name of the package the generator is exported
-* from (`@politty/zod`, `@politty/valibot`, `politty`), and the shim imports
-* `enableCompileCache` from its `compile-cache` subpath. Taking the name from
-* the owner rather than guessing it is what makes the specifier reliable:
-* reaching this generator at all — through that package's bin or through an
-* import of it — means the package is installed in the host, so the specifier
-* resolves from the shim that lands there. The alternative, reading the host's
-* `package.json`, could only guess which of the three politty packages was
-* meant.
-*
-* The returned function generates executable shims. With no explicit paths,
-* one is generated per `bin` entry of the nearest `package.json`, each
-* importing a conventional built module next to it — so a bare
-* `politty generate-shim` in a `postbuild` script is usually enough. Explicit
-* `entry` values are paired in order with the `bin` entries (or with explicit
-* `out` values of the same count).
-*
-* The generated files are ESM (they use top-level `await import`), so `.js`
-* output requires `"type": "module"` in the package; use a `.mjs` extension
-* otherwise. Refuses to overwrite an existing file it did not generate, so
-* a `bin` path still pointing at the real CLI entry fails loudly instead of
-* clobbering the build output.
-*/
-function createCompileCacheShimGenerator(ownerPackage) {
-	return (options = {}) => generateShims(`${ownerPackage}/compile-cache`, options);
-}
-function generateShims(defaultCompileCacheSpecifier, options) {
-	const cwd = options.cwd ?? process.cwd();
-	const found = readNearestPackageJson(cwd);
-	const pkg = found?.pkg;
-	const entries = toArray(options.entry);
-	const outs = toArray(options.out);
-	const bins = binEntries(pkg);
-	let outputPaths;
-	if (outs.length > 0) {
-		if (entries.length > 0 && entries.length !== outs.length) throw new Error(`--entry count (${entries.length}) does not match --out count (${outs.length}); pass one --out per --entry or omit --out entirely.`);
-		outputPaths = outs.map((out) => isAbsolute(out) ? out : resolve(cwd, out));
-	} else {
-		if (bins.length === 0 || found === void 0) throw new Error("Cannot derive the output path: no bin entry in package.json. Pass --out explicitly.");
-		if (entries.length > 0 && entries.length !== bins.length) throw new Error(`--entry count (${entries.length}) does not match the package's bin entries (${bins.length}); pass one --entry per bin (in declaration order) or matching --out paths.`);
-		outputPaths = bins.map(([, path]) => resolve(found.dir, path));
-	}
-	if (new Set(outputPaths).size !== outputPaths.length) throw new Error("Duplicate output paths; each shim needs a distinct output file. Check the --out values (or the bin paths in package.json when --out is omitted).");
-	const binNameByPath = /* @__PURE__ */ new Map();
-	if (found) for (const [name, path] of bins) binNameByPath.set(resolve(found.dir, path), name);
-	const warnings = [];
-	const compileCacheSpecifier = options.compileCacheSpecifier ?? defaultCompileCacheSpecifier;
-	if (/[\r\n\u2028\u2029]/.test(compileCacheSpecifier)) throw new Error(`Invalid compile-cache specifier ${JSON.stringify(compileCacheSpecifier)}: a module specifier cannot contain a line terminator.`);
-	const plans = outputPaths.map((outputPath, index) => {
-		const matchedBinName = binNameByPath.get(outputPath);
-		const program = options.program ?? matchedBinName ?? defaultProgramName(pkg);
-		if (!program) throw new Error("Cannot derive a program name: no bin or name in package.json. Pass --program explicitly.");
-		if (options.program === void 0 && matchedBinName === void 0 && outs.length > 0) warnings.push(`Warning: ${formatShimPath(outputPath, cwd)} does not match any bin path in package.json, so its cache directory uses the program name ${JSON.stringify(program)}. Pass --program to override.`);
-		if (outputPath.endsWith(".cjs")) throw new Error("The generated shim is an ES module and cannot be written to a .cjs file. Use a .mjs (or .js in a \"type\": \"module\" package) output path.");
-		if (extname(outputPath) === "") throw new Error("The generated shim is an ES module and cannot be written to an extensionless file (it would not load on every supported Node.js version). Use a .mjs (or .js in a \"type\": \"module\" package) output path.");
-		if (outputPath.endsWith(".js") && pkg?.type !== "module") throw new Error(pkg === void 0 ? "The generated shim is an ES module, and no package.json was found to confirm .js files are treated as ESM. Write it to a .mjs file instead (e.g. --out dist/bin.mjs)." : "The generated shim is an ES module, but the package is not \"type\": \"module\". Write it to a .mjs file instead (e.g. --out dist/bin.mjs).");
-		const entry = entries[index] ?? defaultEntry(outputPath);
-		if (entry === void 0) throw new Error(`Cannot derive an entry: none of ${DEFAULT_ENTRY_CANDIDATES.join(", ")} exist next to ${outputPath}. Pass --entry explicitly.`);
-		if (!entry.startsWith("./") && !entry.startsWith("../") && !entry.startsWith("file:")) throw new Error(`Invalid entry ${entry}: pass a specifier relative to the shim file ("./..." or "../...") or a file: URL.`);
-		let entryPath;
-		if (entry.startsWith("file:")) try {
-			entryPath = fileURLToPath(entry);
-		} catch {
-			entryPath = void 0;
-		}
-		else entryPath = resolve(dirname(outputPath), entry);
-		if (entryPath === outputPath) throw new Error(`The shim at ${outputPath} would import itself (entry ${entry}). Point bin at a separate shim path (e.g. dist/bin.js) or pass a different --entry.`);
-		if (existsSync(outputPath) && !readFileSync(outputPath, "utf8").includes(SHIM_MARKER)) throw new Error(`Refusing to overwrite ${outputPath}: it exists and was not generated by politty. If bin currently points at your real CLI entry, point it at a separate shim path (e.g. dist/bin.js) or pass --out explicitly.`);
-		return {
-			outputPath,
-			program,
-			entry,
-			compileCacheSpecifier
-		};
-	});
-	for (const warning of warnings) console.warn(warning);
-	for (const { outputPath, program, entry } of plans) {
-		mkdirSync(dirname(outputPath), { recursive: true });
-		writeFileSync(outputPath, shimContent(program, entry, compileCacheSpecifier));
-		chmodSync(outputPath, 493);
-	}
-	return plans;
-}
-/**
-* Format a generated path for CLI output: relative to `cwd` when inside it.
-*/
-function formatShimPath(outputPath, cwd) {
-	const rel = relative(cwd, outputPath);
-	return rel && !rel.startsWith("..") ? rel : outputPath;
-}
-
-//#endregion
-//#region ../core/src/cli-main.ts
-const generateWorkerArgsSchema = 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" })
-});
-const generateWorkerCommand = defineCommand({
-	name: "generate-worker",
-	description: "Generate and verify a bundled shell completion worker",
-	args: generateWorkerArgsSchema,
-	async run(args) {
-		const { generateBundledCompletionWorker } = await import("./src-DhQVU2hG.js");
-		await generateBundledCompletionWorker({
-			bin: args.bin,
-			programName: args.program,
-			shell: args.shell,
-			...args.out !== void 0 && { outputPath: args.out },
-			verify: args.verify
-		});
-	}
-});
-const generateShimArgsSchema = 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"
-	}),
-	compileCacheSpecifier: internalField.optionalString({
-		description: "Module specifier the shim imports enableCompileCache from (defaults to the compile-cache subpath of the politty package running this command)",
-		placeholder: "SPECIFIER"
-	})
-});
-/**
-* Run politty's own development CLI (`generate-shim`, `generate-worker`).
-*
-* `ownerPackage` is the npm name of the politty package providing the `politty`
-* bin that invoked this — `@politty/zod`, `@politty/valibot`, or `politty`. It
-* is threaded through to {@link createCompileCacheShimGenerator} so a generated
-* shim imports the cache helper from the package the user actually installed,
-* which is the one guaranteed to resolve from their own package.
-*
-* Never returns: it exits the process, like `runMain`.
-*/
-function runPolittyCli(ownerPackage) {
-	const generateCompileCacheShim = createCompileCacheShimGenerator(ownerPackage);
-	const generateShimCommand = defineCommand({
-		name: "generate-shim",
-		description: "Generate a compile-cache bin shim that loads the real CLI via dynamic import",
-		args: generateShimArgsSchema,
-		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 },
-				...args.compileCacheSpecifier !== void 0 && { compileCacheSpecifier: args.compileCacheSpecifier },
-				cwd
-			});
-			for (const result of results) console.log(`Generated compile-cache shim: ${formatShimPath(result.outputPath, cwd)} (program: ${result.program}, entry: ${result.entry}, compile-cache: ${result.compileCacheSpecifier})`);
-		}
-	});
-	const cli = defineCommand({
-		name: "politty",
-		description: "politty development utilities",
-		subCommands: {
-			"generate-shim": generateShimCommand,
-			"generate-worker": generateWorkerCommand
-		}
-	});
-	return runMain(cli).catch((error) => {
-		console.error(error instanceof Error ? error.message : String(error));
-		process.exit(1);
-	});
-}
-
-//#endregion
-export { createCompileCacheShimGenerator as n, runPolittyCli as t };

package/dist/cli-main-DIRMduj1.js

@@ -1,3 +0,0 @@
-import { t as runPolittyCli } from "./cli-main-CAa5KwCo.js";
-
-export { runPolittyCli };

package/dist/cli-run-B--tZW_I.js

@@ -1,8 +0,0 @@
-import "./register-DdcsbNwM.js";
-
-//#region src/cli-run.ts
-const { runPolittyCli } = await import("./cli-main-DIRMduj1.js");
-await runPolittyCli("@politty/zod");
-
-//#endregion
-export {  };

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

@@ -1,42 +0,0 @@
-//#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-BC65o7MH.js

@@ -1,103 +0,0 @@
-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 from the `compile-cache` subpath of the politty package your CLI
-* // depends on — `politty generate-shim` writes that specifier for you,
-* // naming whichever package's bin generated the shim.
-* import { enableCompileCache } from "<your-politty-package>/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 };