```ts
export function preloadPicks(entries: unknown, room: unknown): string[] {
  if (!Array.isArray(entries)) {
    throw new Error("Entries must be an array.");
  }
  if (typeof room !== "number" || !Number.isInteger(room) || room < 0) {
    throw new Error("Room must be a non-negative whole number.");
  }

  const candidates = entries.map((entry, index) => {
    if (
      typeof entry !== "object" ||
      entry === null ||
      Array.isArray(entry)
    ) {
      throw new Error(`Entry at index ${index} is not a valid mapping.`);
    }
    const { key, size, hits } = entry as Record<string, unknown>;
    if (typeof key !== "string" || key.length === 0) {
      throw new Error(`Key at index ${index} must be a non-empty string.`);
    }
    if (typeof size !== "number" || !Number.isInteger(size) || size <= 0) {
      throw new Error(`Size at index ${index} must be a positive whole number.`);
    }
    if (typeof hits !== "number" || !Number.isInteger(hits) || hits < 0) {
      throw new Error(`Hits at index ${index} must be a non-negative whole number.`);
    }

    return { key, size, hits };
  });

  const uniqueKeys = new Set(candidates.map((c) => c.key));
  if (uniqueKeys.size !== candidates.length) {
    throw new Error("Two candidates share the same key.");
  }

  candidates.sort((a, b) => {
    if (b.hits !== a.hits) {
      return b.hits - a.hits;
    }
    if (a.size !== b.size) {
      return a.size - b.size;
    }
    return a.key.localeCompare(b.key);
  });

  const selectedKeys: string[] = [];
  for (const candidate of candidates) {
    if (candidate.size <= room) {
      selectedKeys.push(candidate.key);
      room -= candidate.size;
    }
  }

  return selectedKeys;
}
```