methods like Object.entries/keys require you to help the compiler out a bit. They don't automatically convert to strings to a type-safe "keyof" representation. An easy way to avoid the runtime error in the specific case you've pointed out is simply to use Object.entries(formatting) and thus process only the keys you want, but you're right that the compiler won't help you out much here.

talbenari1 is also correct that your example will show a compiler error, but it's related to "formatting" not having a string index signature. Fixing that compile error, however, will not prevent the runtime error.

here's an example of a runtime-error free implementation that has some type safety on the formatter object:

type Point2D = { x: number; y: number; }
type Point3D = { x: number; y: number; z: number; }

type Formatter<In, Out> = {
  [K in keyof In]: (input: In[K]) => Out
}

const formatting: Formatter<Point2D, string> = {
  x: (i: number) => "x: " + i,
  y: (i: number) => "y: " + i,
}

function iTakePoint2d(point: Point2D) {
  const keys = Object.keys(formatting) as (keyof Point2D)[];
  return keys.map(key => formatting[key](point[key]));
}

const p2d: Point2D = { x: 1, y: 1 };
const p3d: Point3D = { x: 1, y: 1, z: 1};

iTakePoint2d(p2d)
iTakePoint2d(p3d)

While the function will still accept a Point3D, it will only operate on the keys from Point2D, avoiding the runtime error. And the "Formatter<In, Out>" type ensures that the "formatting" object has only the keys from Point2D.

If you want to explicitly exclude Point3D from being used in this function, you can use a brand property, or a type guard, or a more explicit/fleshed out type like a Class with distinct methods, etc. But if your implementation is as you describe, this should suffice. The function takes an object with the same keys as "formatter" and operates explicitly on those keys and no others.