```ts
export function admitBytes(perKey: number, total: number, span: number, entries: (string | number)[][]): string[] {
  if (!Number.isInteger(perKey) || perKey <= 0) throw new Error("perKey must be a positive integer");
  if (!Number.isInteger(total) || total <= 0) throw new Error("total must be a positive integer");
  if (!Number.isInteger(span) || span <= 0) throw new Error("span must be a positive integer");

  const result: string[] = [];
  const keyCarry: { [key: string]: number } = {};
  let totalCarry = 0;
  const timeSortedEntries = entries.slice().sort((a, b) => (a[0] as number) - (b[0] as number));

  for (const entry of timeSortedEntries) {
    const [time, key, size] = entry;

    if (!Number.isInteger(time) || time < 0) throw new Error("Time must be a non-negative integer");
    if (typeof key !== "string" || key.length === 0) throw new Error("Key must be a non-empty string");
    if (!Number.isInteger(size) || size <= 0) throw new Error("Size must be a positive integer");

    // Remove entries that are out of span
    for (const [t, k] of timeSortedEntries) {
      if ((t as number) + span < (time as number)) {
        totalCarry -= keyCarry[k as string];
        delete keyCarry[k as string];
      } else {
        break;
      }
    }

    const newTotalCarry = totalCarry + size;

    if (
      newTotalCarry <= total &&
      (keyCarry[key as string] || 0) + size <= perKey
    ) {
      result.push("pass");
      keyCarry[key as string] = (keyCarry[key as string] || 0) + size;
      totalCarry += size;
    } else {
      result.push("drop");
    }
  }

  return result;
}
```