```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 keyVolumeMap: Map<string, number> = new Map();
  let totalVolume = 0;

  for (const entry of entries) {
    if (entry.length !== 3) throw new Error("Each entry must have exactly three elements");
    
    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 older than the span
    for (const [k, v] of keyVolumeMap.entries()) {
      const lastEntryTime = v[v.length - 1][0];
      if (time > lastEntryTime + span) {
        keyVolumeMap.set(k, v.filter(([t]) => t > time - span));
      }
    }

    // Calculate current volumes
    let keyVolume = keyVolumeMap.get(key)?.reduce((sum, [, s]) => sum + s, 0) || 0;
    const newKeyVolume = keyVolume + size;

    if (newKeyVolume <= perKey && totalVolume + size <= total) {
      result.push("pass");
      totalVolume += size;
      keyVolumeMap.set(key, [...(keyVolumeMap.get(key) || []), [time, size]]);
    } else {
      result.push("drop");
    }
  }

  return result;
}
```