@ryanatkn/gro 0.160.0 → 0.161.1

package/dist/task_logging.js

@@ -1,7 +1,7 @@
 import { styleText as st } from 'node:util';
 import { plural } from '@ryanatkn/belt/string.js';
 import { print_value } from '@ryanatkn/belt/print.js';
-import { ZodFirstPartyTypeKind } from 'zod';
+import { z } from 'zod';
 import { print_path } from "./paths.js";
 export const log_tasks = (log, loaded_tasks, log_intro = true) => {
     const { modules, found_tasks } = loaded_tasks;
@@ -36,7 +36,7 @@ export const log_task_help = (log, meta) => {
     const logged = [];
     logged.push(st('cyan', name), 'help', st('cyan', `\n\ngro ${name}`) + `: ${task.summary ?? '(no summary available)'}\n`);
     if (task.Args) {
-        const properties = to_arg_properties(task.Args._def, meta);
+        const properties = to_arg_properties(task.Args, meta, log);
         // TODO hacky padding for some quick and dirty tables
         const longest_task_name = Math.max(ARGS_PROPERTY_NAME.length, to_max_length(properties, (p) => p.name));
         const longest_type = to_max_length(properties, (p) => p.schema.type);
@@ -51,12 +51,15 @@ export const log_task_help = (log, meta) => {
     }
     log.info(...logged, '\n');
 };
-const to_arg_properties = (def, meta) => {
-    const type_name = to_type_name(def);
-    if (type_name !== ZodFirstPartyTypeKind.ZodObject) {
-        throw Error(`Expected Args for task "${meta.name}" to be a ZodObject schema but got ${type_name}`);
+// TODO this blocks many usecases like unions, and it's only implemented for CLI arg types, need better support for arbitrary schemas
+const to_arg_properties = (schema, meta, log) => {
+    const { def } = schema;
+    // TODO overly restrictive, support optional objects and/or unions?
+    if (!('shape' in def)) {
+        log.error(`Expected Args for task "${meta.name}" to be an object schema but got ${def.type}`);
+        return [];
     }
-    const shape = def.shape();
+    const shape = def.shape;
     const properties = [];
     for (const name in shape) {
         if ('no-' + name in shape)
@@ -64,7 +67,7 @@ const to_arg_properties = (def, meta) => {
         const s = shape[name];
         const schema = {
             type: to_args_schema_type(s),
-            description: to_args_schema_description(s),
+            description: to_args_schema_description(s) || '',
             default: to_args_schema_default(s),
         };
         properties.push({ name, schema });
@@ -72,63 +75,127 @@ const to_arg_properties = (def, meta) => {
     return properties;
 };
 const to_max_length = (items, toString) => items.reduce((max, m) => Math.max(toString(m).length, max), 0);
-// The following Zod helpers only need to support single-depth schemas for CLI args,
-// but there's generic recursion to handle things like `ZodOptional` and `ZodDefault`.
-const to_type_name = (def) => def.typeName;
-const to_args_schema_type = ({ _def }) => {
-    const t = to_type_name(_def);
-    switch (t) {
-        case ZodFirstPartyTypeKind.ZodBoolean:
-            return 'boolean';
-        case ZodFirstPartyTypeKind.ZodString:
+const to_args_schema_type = (schema) => {
+    const { def } = schema._zod;
+    switch (def.type) {
+        case 'string':
             return 'string';
-        case ZodFirstPartyTypeKind.ZodNumber:
+        case 'number':
             return 'number';
-        case ZodFirstPartyTypeKind.ZodArray:
-            return 'Array<string>'; // TODO support arrays of arbitrary types, or more hardcoded ones as needed
-        case ZodFirstPartyTypeKind.ZodEnum:
-            return _def.values.map((v) => `'${v}'`).join(' | ');
-        case ZodFirstPartyTypeKind.ZodUnion:
-            return 'string | Array<string>'; // TODO support unions of arbitrary types, or more hardcoded ones as needed
+        case 'int':
+            return 'int';
+        case 'boolean':
+            return 'boolean';
+        case 'bigint':
+            return 'bigint';
+        case 'symbol':
+            return 'symbol';
+        case 'null':
+            return 'null';
+        case 'undefined':
+            return 'undefined';
+        case 'void':
+            return 'void';
+        case 'never':
+            return 'never';
+        case 'any':
+            return 'any';
+        case 'unknown':
+            return 'unknown';
+        case 'date':
+            return 'date';
+        case 'object':
+            return 'object';
+        case 'record':
+            return 'record';
+        case 'file':
+            return 'file';
+        case 'array':
+            // TODO other types, only handling a subset of CLI arg cases
+            return 'Array<string>';
+        case 'tuple':
+            return 'tuple';
+        case 'union':
+            // TODO fix, this is a hacky way to handle unions for CLI args
+            return 'string | Array<string>';
+        case 'intersection':
+            return 'intersection';
+        case 'map':
+            return 'map';
+        case 'set':
+            return 'set';
+        case 'enum':
+            return schema.options
+                .map((v) => `'${v}'`)
+                .join(' | ');
+        case 'literal':
+            return def.values.map((v) => print_value(v)).join(' | ');
+        case 'nullable': {
+            const subschema = to_subschema(def);
+            return subschema ? to_args_schema_type(subschema) + ' | null' : 'nullable';
+        }
+        case 'optional': {
+            const subschema = to_subschema(def);
+            return subschema ? to_args_schema_type(subschema) + ' | undefined' : 'optional';
+        }
+        case 'success':
+            return 'success';
+        case 'catch':
+            return 'catch';
+        case 'nan':
+            return 'NaN';
+        case 'readonly':
+            return 'readonly';
+        case 'template_literal':
+            return 'template_literal';
+        case 'promise':
+            return 'promise';
+        case 'lazy':
+            return 'lazy';
+        case 'custom':
+            return 'custom';
+        // Unwrap these:
+        // case 'nonoptional':
+        // case 'transform':
+        // case 'default':
+        // case 'prefault':
+        // case 'pipe':
         default: {
-            const subschema = to_subschema(_def);
-            if (subschema) {
-                return to_args_schema_type(subschema);
-            }
-            else {
-                throw Error('Unknown zod type ' + t);
-            }
+            const subschema = to_subschema(def);
+            return subschema ? to_args_schema_type(subschema) : def.type;
         }
     }
 };
-const to_args_schema_description = ({ _def }) => {
-    if (_def.description) {
-        return _def.description;
+const to_args_schema_description = (schema) => {
+    const meta = schema.meta();
+    if (meta?.description) {
+        return meta.description;
     }
-    const subschema = to_subschema(_def);
+    const subschema = to_subschema(schema.def);
     if (subschema) {
         return to_args_schema_description(subschema);
     }
-    return '';
+    return null;
 };
-const to_args_schema_default = ({ _def }) => {
-    if (_def.defaultValue) {
-        return _def.defaultValue();
+const to_args_schema_default = (schema) => {
+    const { def } = schema._zod;
+    if ('defaultValue' in def) {
+        return def.defaultValue;
     }
-    const subschema = to_subschema(_def);
+    const subschema = to_subschema(def);
     if (subschema) {
         return to_args_schema_default(subschema);
     }
 };
-const to_subschema = (_def) => {
-    if ('type' in _def) {
-        return _def.type;
+const to_subschema = (def) => {
+    if ('innerType' in def) {
+        return def.innerType;
     }
-    else if ('innerType' in _def) {
-        return _def.innerType;
+    else if ('in' in def) {
+        return def.in;
     }
-    else if ('schema' in _def) {
-        return _def.schema;
+    else if ('schema' in def) {
+        return def.schema;
     }
     return undefined;
 };

package/dist/test.task.d.ts

@@ -1,21 +1,11 @@
 import { z } from 'zod';
 import { type Task } from './task.ts';
 export declare const Args: z.ZodObject<{
-    _: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    _: z.ZodDefault<z.ZodArray<z.ZodString>>;
     bail: z.ZodDefault<z.ZodBoolean>;
     cwd: z.ZodOptional<z.ZodString>;
-    ignore: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
-}, "strict", z.ZodTypeAny, {
-    _: string[];
-    bail: boolean;
-    cwd?: string | undefined;
-    ignore?: string | string[] | undefined;
-}, {
-    _?: string[] | undefined;
-    cwd?: string | undefined;
-    ignore?: string | string[] | undefined;
-    bail?: boolean | undefined;
-}>;
+    ignore: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strict>;
 export type Args = z.infer<typeof Args>;
 export declare const task: Task<Args>;
 //# sourceMappingURL=test.task.d.ts.map

package/dist/test.task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/test.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAIhD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;EAWP,CAAC;AACX,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA4B3B,CAAC"}
+{"version":3,"file":"test.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/test.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAIhD,eAAO,MAAM,IAAI;;;;;kBAWf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA4B3B,CAAC"}

package/dist/test.task.js

@@ -3,18 +3,18 @@ import { z } from 'zod';
 import { Task_Error } from "./task.js";
 import { paths } from "./paths.js";
 import { find_cli } from "./cli.js";
-export const Args = z
-    .object({
-    _: z.array(z.string(), { description: 'file patterns to test' }).default([`\\.test\\.ts$`]), // TODO maybe use uvu's default instead of being restrictive?
+export const Args = z.strictObject({
+    _: z.array(z.string()).meta({ description: 'file patterns to test' }).default([`\\.test\\.ts$`]), // TODO maybe use uvu's default instead of being restrictive?
     bail: z
-        .boolean({ description: 'the bail option to uvu run, exit immediately on failure' })
+        .boolean()
+        .meta({ description: 'the bail option to uvu run, exit immediately on failure' })
         .default(false),
-    cwd: z.string({ description: 'the cwd option to uvu parse' }).optional(),
+    cwd: z.string().meta({ description: 'the cwd option to uvu parse' }).optional(),
     ignore: z
-        .union([z.string(), z.array(z.string())], { description: 'the ignore option to uvu parse' })
+        .union([z.string(), z.array(z.string())])
+        .meta({ description: 'the ignore option to uvu parse' })
         .optional(),
-})
-    .strict();
+});
 export const task = {
     summary: 'run tests with uvu',
     Args,

package/dist/typecheck.task.d.ts

@@ -5,17 +5,7 @@ export declare const Args: z.ZodObject<{
     typescript_cli: z.ZodDefault<z.ZodString>;
     path_replacement: z.ZodDefault<z.ZodString>;
     cwd: z.ZodDefault<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    cwd: string;
-    svelte_check_cli: string;
-    typescript_cli: string;
-    path_replacement: string;
-}, {
-    cwd?: string | undefined;
-    svelte_check_cli?: string | undefined;
-    typescript_cli?: string | undefined;
-    path_replacement?: string | undefined;
-}>;
+}, z.core.$strict>;
 export type Args = z.infer<typeof Args>;
 export declare const task: Task<Args>;
 //# sourceMappingURL=typecheck.task.d.ts.map

package/dist/typecheck.task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typecheck.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/typecheck.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAOhD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;EAaP,CAAC;AACX,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAiD3B,CAAC"}
+{"version":3,"file":"typecheck.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/typecheck.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAOhD,eAAO,MAAM,IAAI;;;;;kBAcf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAiD3B,CAAC"}

package/dist/typecheck.task.js

@@ -6,22 +6,23 @@ import { find_cli, spawn_cli, spawn_cli_process } from "./cli.js";
 import { SVELTE_CHECK_CLI, sveltekit_sync_if_available } from "./sveltekit_helpers.js";
 import { configure_colored_output_with_path_replacement } from "./child_process_logging.js";
 import { paths } from "./paths.js";
-export const Args = z
-    .object({
+export const Args = z.strictObject({
     svelte_check_cli: z
-        .string({ description: 'the svelte-check CLI to use' })
+        .string()
+        .meta({ description: 'the svelte-check CLI to use' })
         .default(SVELTE_CHECK_CLI),
     typescript_cli: z
-        .string({ description: 'the TypeScript CLI to use as a fallback to svelte-check' })
+        .string()
+        .meta({ description: 'the TypeScript CLI to use as a fallback to svelte-check' })
         .default('tsc'),
     path_replacement: z
-        .string({ description: 'replacement string for current working directory in output' })
+        .string()
+        .meta({ description: 'replacement string for current working directory in output' })
         .default('.'),
-    cwd: z.string({ description: 'current working directory' }).default(paths.root),
-})
-    .strict();
+    cwd: z.string().meta({ description: 'current working directory' }).default(paths.root),
+});
 export const task = {
-    summary: 'run tsc on the project without emitting any files',
+    summary: 'run svelte-check or tsc on the project without emitting any files',
     Args,
     run: async ({ args, log }) => {
         const { svelte_check_cli, typescript_cli, path_replacement, cwd } = args;

package/dist/upgrade.task.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 import { type Task } from './task.ts';
 export declare const Args: z.ZodObject<{
-    _: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    only: z.ZodEffects<z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>, string[], string | string[] | undefined>;
+    _: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    only: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[], string | string[]>>;
     origin: z.ZodDefault<z.ZodString>;
     force: z.ZodDefault<z.ZodBoolean>;
     pull: z.ZodDefault<z.ZodBoolean>;
@@ -12,31 +12,7 @@ export declare const Args: z.ZodObject<{
     delete_lockfile: z.ZodDefault<z.ZodBoolean>;
     lockfile_path: z.ZodDefault<z.ZodString>;
     dry: z.ZodDefault<z.ZodBoolean>;
-}, "strict", z.ZodTypeAny, {
-    _: string[];
-    origin: string;
-    pull: boolean;
-    dry: boolean;
-    force: boolean;
-    'no-pull': boolean;
-    only: string[];
-    delete_node_modules: boolean;
-    node_modules_path: string;
-    delete_lockfile: boolean;
-    lockfile_path: string;
-}, {
-    _?: string[] | undefined;
-    origin?: string | undefined;
-    pull?: boolean | undefined;
-    dry?: boolean | undefined;
-    force?: boolean | undefined;
-    'no-pull'?: boolean | undefined;
-    only?: string | string[] | undefined;
-    delete_node_modules?: boolean | undefined;
-    node_modules_path?: string | undefined;
-    delete_lockfile?: boolean | undefined;
-    lockfile_path?: string | undefined;
-}>;
+}, z.core.$strict>;
 export type Args = z.infer<typeof Args>;
 export declare const task: Task<Args>;
 //# sourceMappingURL=upgrade.task.d.ts.map

package/dist/upgrade.task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upgrade.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/upgrade.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAOhD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BP,CAAC;AACX,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA2E3B,CAAC"}
+{"version":3,"file":"upgrade.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/upgrade.task.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAOhD,eAAO,MAAM,IAAI;;;;;;;;;;;;kBAiCf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA2E3B,CAAC"}

package/dist/upgrade.task.js

@@ -7,34 +7,40 @@ import { Git_Origin, git_pull } from "./git.js";
 import { spawn_cli } from "./cli.js";
 import { serialize_args, to_forwarded_args } from "./args.js";
 import { NODE_MODULES_DIRNAME } from "./constants.js";
-export const Args = z
-    .object({
-    _: z.array(z.string(), { description: 'names of deps to exclude from the upgrade' }).default([]),
+export const Args = z.strictObject({
+    _: z
+        .array(z.string())
+        .meta({ description: 'names of deps to exclude from the upgrade' })
+        .default([]),
     only: z
-        .union([z.string(), z.array(z.string())], {
+        .union([z.string(), z.array(z.string())])
+        .meta({
         description: 'names of deps to include in the upgrade',
     })
         .default([])
         .transform((v) => (Array.isArray(v) ? v : [v])),
     origin: Git_Origin.describe('git origin to deploy to').default('origin'),
-    force: z.boolean({ description: 'if true, print out the planned upgrades' }).default(false),
-    pull: z.boolean({ description: 'dual of no-pull' }).default(true),
-    'no-pull': z.boolean({ description: 'opt out of git pull' }).default(false),
+    force: z.boolean().meta({ description: 'if true, print out the planned upgrades' }).default(false),
+    pull: z.boolean().meta({ description: 'dual of no-pull' }).default(true),
+    'no-pull': z.boolean().meta({ description: 'opt out of git pull' }).default(false),
     delete_node_modules: z
-        .boolean({ description: 'if true, deletes node_modules before upgrading' })
+        .boolean()
+        .meta({ description: 'if true, deletes node_modules before upgrading' })
         .default(false),
     node_modules_path: z // TODO maybe configured globally instead
-        .string({ description: 'path to modules directory to delete' })
+        .string()
+        .meta({ description: 'path to modules directory to delete' })
         .default(NODE_MODULES_DIRNAME),
     delete_lockfile: z
-        .boolean({ description: 'if true, deletes the lockfile before upgrading' })
+        .boolean()
+        .meta({ description: 'if true, deletes the lockfile before upgrading' })
         .default(false),
     lockfile_path: z
-        .string({ description: 'path to the lockfile to delete' })
+        .string()
+        .meta({ description: 'path to the lockfile to delete' })
         .default('package-lock.json'),
-    dry: z.boolean({ description: 'if true, print out the planned upgrades' }).default(false),
-})
-    .strict();
+    dry: z.boolean().meta({ description: 'if true, print out the planned upgrades' }).default(false),
+});
 export const task = {
     summary: 'upgrade deps',
     Args,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.160.0",
+  "version": "0.161.1",
   "description": "task runner and toolkit extending SvelteKit",
   "motto": "generate, run, optimize",
   "glyph": "🌰",
@@ -49,46 +49,46 @@
     "typescript"
   ],
   "dependencies": {
-    "@ryanatkn/belt": "^0.31.0",
+    "@ryanatkn/belt": "^0.33.0",
     "chokidar": "^4.0.3",
-    "dotenv": "^17.0.1",
+    "dotenv": "^17.2.1",
     "esm-env": "^1.2.2",
     "mri": "^1.2.0",
-    "oxc-parser": "^0.75.1",
+    "oxc-parser": "^0.79.1",
     "prettier": "^3.6.2",
     "prettier-plugin-svelte": "^3.4.0",
     "ts-blank-space": "^0.6.1",
     "tslib": "^2.8.1",
-    "zod": "^3.25.74"
+    "zod": "^4.0.14"
   },
   "peerDependencies": {
     "esbuild": "^0.25",
     "svelte": "^5",
     "typescript": "^5"
   },
+  "optionalDependencies": {
+    "@ryanatkn/moss": ">=0.31.0"
+  },
   "devDependencies": {
     "@changesets/changelog-git": "^0.2.1",
     "@changesets/types": "^6.1.0",
     "@ryanatkn/eslint-config": "^0.8.0",
-    "@ryanatkn/fuz": "^0.144.3",
-    "@ryanatkn/moss": "^0.31.0",
+    "@ryanatkn/fuz": "^0.145.0",
+    "@ryanatkn/moss": "^0.32.0",
     "@sveltejs/adapter-static": "^3.0.8",
-    "@sveltejs/kit": "^2.22.2",
-    "@sveltejs/package": "^2.3.12",
-    "@sveltejs/vite-plugin-svelte": "^5.1.0",
-    "@types/node": "^24.0.10",
+    "@sveltejs/kit": "^2.27.0",
+    "@sveltejs/package": "^2.4.0",
+    "@sveltejs/vite-plugin-svelte": "^6.1.0",
+    "@types/node": "^24.1.0",
     "esbuild": "^0.25.5",
-    "eslint": "^9.30.1",
-    "eslint-plugin-svelte": "^3.10.1",
-    "svelte": "^5.35.2",
-    "svelte-check": "^4.2.2",
+    "eslint": "^9.32.0",
+    "eslint-plugin-svelte": "^3.11.0",
+    "svelte": "^5.37.2",
+    "svelte-check": "^4.3.0",
     "typescript": "^5.8.3",
-    "typescript-eslint": "^8.35.1",
+    "typescript-eslint": "^8.38.0",
     "uvu": "^0.5.6"
   },
-  "optionalDependencies": {
-    "@ryanatkn/moss": ">=0.27.0"
-  },
   "prettier": {
     "plugins": [
       "prettier-plugin-svelte"
@@ -313,10 +313,6 @@
       "types": "./dist/package_json.d.ts",
       "default": "./dist/package_json.js"
     },
-    "./package_meta.js": {
-      "types": "./dist/package_meta.d.ts",
-      "default": "./dist/package_meta.js"
-    },
     "./package.gen.js": {
       "types": "./dist/package.gen.d.ts",
       "default": "./dist/package.gen.js"

package/src/lib/args.ts

@@ -38,12 +38,12 @@ export interface Arg_Schema {
  * A simpler implementation could replace `mri`, but it handles some finicky details well.
  */
 export const parse_args = <
-	TOutput extends Record<string, Arg_Value> = Args,
-	TInput extends Record<string, Arg_Value> = Args,
+	T_Output extends Record<string, Arg_Value> = Args,
+	T_Input extends Record<string, Arg_Value> = Args,
 >(
-	unparsed_args: TInput,
-	schema: z.ZodType<TOutput, z.ZodTypeDef, TInput>,
-): z.SafeParseReturnType<TInput, TOutput> => {
+	unparsed_args: T_Input,
+	schema: z.ZodType<T_Output, T_Input>,
+): z.ZodSafeParseResult<T_Output> => {
 	const parsed = schema.safeParse(unparsed_args);
 	if (parsed.success) {
 		// mutate `data` with the correct source of truth for `no-` prefixed args

package/src/lib/build.task.ts

@@ -4,16 +4,15 @@ import type {Task} from './task.ts';
 import {Plugins} from './plugin.ts';
 import {clean_fs} from './clean_fs.ts';
 
-export const Args = z
-	.object({
-		sync: z.boolean({description: 'dual of no-sync'}).default(true),
-		'no-sync': z.boolean({description: 'opt out of gro sync'}).default(false),
-		install: z.boolean({description: 'dual of no-install'}).default(true),
-		'no-install': z // convenience, same as `gro build -- gro sync --no-install` but the latter takes precedence
-			.boolean({description: 'opt out of installing packages before building'})
-			.default(false),
-	})
-	.strict();
+export const Args = z.strictObject({
+	sync: z.boolean().meta({description: 'dual of no-sync'}).default(true),
+	'no-sync': z.boolean().meta({description: 'opt out of gro sync'}).default(false),
+	install: z.boolean().meta({description: 'dual of no-install'}).default(true),
+	'no-install': z // convenience, same as `gro build -- gro sync --no-install` but the latter takes precedence
+		.boolean()
+		.meta({description: 'opt out of installing packages before building'})
+		.default(false),
+});
 export type Args = z.infer<typeof Args>;
 
 export const task: Task<Args> = {

package/src/lib/changeset.task.ts

@@ -20,32 +20,33 @@ import {
 } from './changeset_helpers.ts';
 import {load_package_json} from './package_json.ts';
 
-export const Args = z
-	.object({
-		/**
-		 * The optional rest args get joined with a space to form the `message`.
-		 */
-		_: z
-			.array(z.string(), {description: 'the message for the changeset and commit'})
-			.max(1)
-			.default([]),
-		minor: z.boolean({description: 'bump the minor version'}).default(false),
-		major: z.boolean({description: 'bump the major version'}).default(false),
-		dir: z.string({description: 'changeset dir'}).default(CHANGESET_DIR),
-		access: Changeset_Access.describe(
-			"changeset 'access' config value, the default depends on package.json#private",
-		).optional(),
-		changelog: z
-			.string({description: 'changelog dep package name, used as changeset\'s "changelog" config'})
-			.default('@changesets/changelog-git'),
-		dep: z.boolean({description: 'dual of no-dep'}).default(true),
-		'no-dep': z
-			.boolean({description: 'opt out of installing the changelog package'})
-			.default(false),
-		origin: Git_Origin.describe('git origin to deploy to').default('origin'),
-		changeset_cli: z.string({description: 'the changeset CLI to use'}).default(CHANGESET_CLI),
-	})
-	.strict();
+export const Args = z.strictObject({
+	/**
+	 * The optional rest args get joined with a space to form the `message`.
+	 */
+	_: z
+		.array(z.string())
+		.meta({description: 'the message for the changeset and commit'})
+		.max(1)
+		.default([]),
+	minor: z.boolean().meta({description: 'bump the minor version'}).default(false),
+	major: z.boolean().meta({description: 'bump the major version'}).default(false),
+	dir: z.string().meta({description: 'changeset dir'}).default(CHANGESET_DIR),
+	access: Changeset_Access.describe(
+		"changeset 'access' config value, the default depends on package.json#private",
+	).optional(),
+	changelog: z
+		.string()
+		.meta({description: 'changelog dep package name, used as changeset\'s "changelog" config'})
+		.default('@changesets/changelog-git'),
+	dep: z.boolean().meta({description: 'dual of no-dep'}).default(true),
+	'no-dep': z
+		.boolean()
+		.meta({description: 'opt out of installing the changelog package'})
+		.default(false),
+	origin: Git_Origin.describe('git origin to deploy to').default('origin'),
+	changeset_cli: z.string().meta({description: 'the changeset CLI to use'}).default(CHANGESET_CLI),
+});
 export type Args = z.infer<typeof Args>;
 
 /**

package/src/lib/changeset_helpers.ts

@@ -4,6 +4,7 @@ export const CHANGESET_RESTRICTED_ACCESS = 'restricted';
 export const CHANGESET_PUBLIC_ACCESS = 'public';
 
 export const Changeset_Access = z.enum([CHANGESET_RESTRICTED_ACCESS, CHANGESET_PUBLIC_ACCESS]);
+export type Changeset_Access = z.infer<typeof Changeset_Access>;
 
 export const CHANGESET_CLI = 'changeset';